ESP32 Tem­pe­ra­tur, Luft­feuch­tig­keit und Luft­druck TFT anzeigen

Inhalts­ver­zeich­nis

TFT gro­ße Schrift


# include "WiFi.h"
# include "time.h"
# include "Adafruit_GFX.h"
# include "Adafruit_ST7735.h"
# include "Adafruit_BMP280.h"

// Schrftart einbinden
# include "Fonts/FreeSans9pt7b.h"

# include "DHT.h"

int SENSOR_DHT = 15;

// Sensortyp festlegen
// DHT11
// # define SensorTyp DHT11

// DHT22
# define SensorTyp DHT22 

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

// Adafruit TFT, WaveShare TFT 1,8 Zoll
# define TFT_CS        5
# define TFT_RST       4
# define TFT_DC        2

Adafruit_BMP280 bmp;
Adafruit_ST7735 tft = Adafruit_ST7735(TFT_CS, TFT_DC, TFT_RST);

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

// 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);

// 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;
WiFiServer Server(80);
WiFiClient Client;

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

  Serial.begin(9600);

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

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

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

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

    // IP anzeigen
    Serial.print("Statische 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 über DHCP: ");
    Serial.println(WiFi.localIP());
  }

  // BMP280 starten
  bmp.begin();

  // DHT starten
  dht.begin();

  // schwarzer Hintergrund
  tft.initR(INITR_BLACKTAB);

  // Rotation anpassen
  tft.setRotation(1);
}

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

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

  /*
    TFT-Parameter:
    Schriftart (muss im Kopf eingebunden werden)
    Cursor Spalte, Zeile setzen
    Textfarbe
    Bildschirm mit schwarz füllen
  */
  tft.setFont(&FreeSans9pt7b);
  tft.setCursor(1, 13);
  tft.setTextColor(ST7735_GREEN);
  tft.fillScreen(ST7735_BLACK);

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

  // es kann bis zu 60 Sekunden dauern
  // bis die Zeit ermittelt wird

  // Name des Wochentages 0-6
  switch (Zeit.tm_wday)
  {
    case 0:
      Serial.print("Sonntag");      
      tft.print("Sonntag"); 
      break;
    case 1:
      Serial.print("Montag");
      tft.print("Montag"); 
      break;   
   case 2:
      Serial.print("Dienstag");
      tft.print("Dienstag"); 
      break;
   case 3:
      Serial.print("Mittwoch");
      break;
      tft.print("Mittwoch");
   case 4:
      Serial.print("Donnerstag");
      tft.print("Donnerstag");
      break;
   case 5:
      Serial.print("Freitag");
      tft.print("Freitag");
      break;
   case 6:
      Serial.print("Samstag");
      tft.print("Samstag");
      break;
  }

  Serial.print(", ");
  tft.setCursor(1, 33);

  // Datum
  if (Zeit.tm_mday < 10)  
  {
    Serial.print("0");
    tft.print("0");
  }
  Serial.print(Zeit.tm_mday);
  tft.print(Zeit.tm_mday);

  Serial.print(".");
  tft.print(".");

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

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

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

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

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

  // Sekunden (nur Serieller Monitor)
  if (Zeit.tm_sec < 10) Serial.print("0");
  Serial.print(Zeit.tm_sec);

  Serial.println();
  Serial.println("Tage seit dem 1.1. " + String(Zeit.tm_yday));

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

  // Temperatur BMP280
  String Temperatur = String(bmp.readTemperature());

  // alternativ: Temperatur DHT
  // String Temperatur = String(dht.readTemperature());

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

  /*
    BMP280 Luftdruck messen
    readPressure() liest in Pascal, Ausgabe in hPa (Hekto-Pascal)
    Ergebnis durch 100 teilen
  */
  String Luftdruck = String(bmp.readPressure() / 100);
  Luftdruck.replace(".", ",");

  // Luftfeuchtigkeit DHT lesen 
  String Luftfeuchtigkeit = String(dht.readHumidity());

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

  // Ausgabe Serieller Monitor
  Serial.println("Temperatur: " + Temperatur + "°C");
  Serial.println("Luftfeuchtigkeit: " + Luftfeuchtigkeit + "%");
  Serial.println("Luftdruck: " + Luftdruck + " hPa");

  // Ausgabe TFT
  tft.drawFastHLine(1, 57, tft.width(), ST7735_WHITE);
  tft.setCursor(1, 73);
  tft.print(Temperatur + " Grad C");
  tft.setCursor(1, 93);
  tft.print(Luftfeuchtigkeit + "%");
  tft.setCursor(1, 113);
  tft.print(Luftdruck + " hPa");

  // Wartezeit bis zur nächsten Messung
  delay(5000);
}

TFT klei­ne Schrift

# include "WiFi.h"
# include "time.h"
# include "Adafruit_GFX.h"
# include "Adafruit_ST7735.h"
# include "Adafruit_BMP280.h"

# include "DHT.h"

int SENSOR_DHT = 15;

// Sensortyp festlegen
// DHT22
# define SensorTyp DHT22 

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

// Adafruit TFT, WaveShare TFT 1,8 Zoll
# define TFT_CS        5
# define TFT_RST       4
# define TFT_DC        2

Adafruit_BMP280 bmp;
Adafruit_ST7735 tft = Adafruit_ST7735(TFT_CS, TFT_DC, TFT_RST);

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

// 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);

// 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;
WiFiServer Server(80);
WiFiClient Client;

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

  Serial.begin(9600);

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

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

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

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

    // IP anzeigen
    Serial.print("Statische 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 über DHCP: ");
    Serial.println(WiFi.localIP());
  }

  // BMP280 starten
  bmp.begin();

  // DHT starten
  dht.begin();

  // schwarzer Hintergrund
  tft.initR(INITR_BLACKTAB);

  // Rotation anpassen
  tft.setRotation(1);

  // schwarzer Hintergrund
  tft.fillScreen(ST7735_BLACK);
  tft.setTextSize(1);
}

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

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

  /*
    TFT-Parameter:
    Schriftart (muss im Kopf eingebunden werden)
    Cursor Spalte, Zeile setzen
    Textfarbe
    Bildschirm mit schwarz füllen
  */
  tft.setCursor(1, 5);
  tft.setTextColor(ST7735_GREEN);
  tft.fillScreen(ST7735_BLACK);
  tft.setTextSize(1);

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

  // es kann bis zu 60 Sekunden dauern
  // bis die Zeit ermittelt wird

  // Name des Wochentages 0-6
  switch (Zeit.tm_wday)
  {
    case 0:
      Serial.print("Sonntag");      
      tft.print("Sonntag"); 
      break;
    case 1:
      Serial.print("Montag");
      tft.print("Montag"); 
      break;   
   case 2:
      Serial.print("Dienstag");
      tft.print("Dienstag"); 
      break;
   case 3:
      Serial.print("Mittwoch");
      break;
      tft.print("Mittwoch");
   case 4:
      Serial.print("Donnerstag");
      tft.print("Donnerstag");
      break;
   case 5:
      Serial.print("Freitag");
      tft.print("Freitag");
      break;
   case 6:
      Serial.print("Samstag");
      tft.print("Samstag");
      break;
  }

  Serial.print(", ");
  tft.setCursor(1, 20);
  if (Zeit.tm_mday < 10)  
  {
    Serial.print("0");
    tft.print("0");
  }
  Serial.print(Zeit.tm_mday);
  tft.print(Zeit.tm_mday);

  Serial.print(".");
  tft.print(".");

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

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

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

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

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

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

  Serial.println();
  Serial.println("Tage seit dem 1.1. " + String(Zeit.tm_yday));

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

   // Temperatur BMP280
  String Temperatur = String(bmp.readTemperature());

  // alternativ: Temperatur DHT
  // String Temperatur = String(dht.readTemperature());

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

  /*
    BMP280 Luftdruck messen
    readPressure() liest in Pascal, Ausgabe in hPa (Hekto-Pascal)
    Ergebnis durch 100 teilen
  */
  String Luftdruck = String(bmp.readPressure() / 100);
  Luftdruck.replace(".", ",");

  // Luftfeuchtigkeit DHT lesen 
  String Luftfeuchtigkeit = String(dht.readHumidity());

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

  // Ausgabe Serieller Monitor
  Serial.println("Temperatur: " + Temperatur + "°C");
  Serial.println("Luftfeuchtigkeit: " + Luftfeuchtigkeit + "%");
  Serial.println("Luftdruck: " + Luftdruck + " hPa");

  // Ausgabe TFT
  tft.drawFastHLine(1, 35, tft.width(), ST7735_WHITE);
  tft.setCursor(1, 50);
  tft.print("Temperatur: " + Temperatur + char(247) + "C");
  tft.setCursor(1, 65);
  tft.print("Luftfeuchtigkeit: " + Luftfeuchtigkeit + "%");
  tft.setCursor(1, 80);
  tft.print(Luftdruck + " hPa");

  // Wartezeit bis zur nächsten Messung
  delay(5000);
}
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

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

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 ...

Ampel mit WiFi schalten

Inhalts­ver­zeich­nis

UNO R4 WiFi

#include "WiFiS3.h"

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

// Pins der LEDs
int ROT = 5;
int GELB = 6;
int GRUEN = 7;

// Schalter für den Zustand der LEDs (false->aus, true-> an
bool RotAn = false;
bool GelbAn = false;
bool GruenAn = false;

// statischeIP = false -> IP-Adresse über DHCP vergeben
// statischeIP = true -> statische IP festlegen
bool statischeIP = false;

// statische IP anpassen
IPAddress ip(192, 168, 1, 200);

WiFiServer WiFiServer(80);

WiFiClient WebClient = WiFiServer.available();

void setup() 
{
  pinMode(ROT, OUTPUT);
  pinMode(GELB, OUTPUT);
  pinMode(GRUEN, OUTPUT);

  Serial.begin(9600);

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

  // statische IP vergeben
  if (statischeIP) WiFi.config(ip);

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

  Serial.print("Verbindung aufbauen mit ");
  Serial.println(Router);

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

  WiFiServer.begin();

  // IP des Servers/des verbunden Computers anzeigen
  Serial.print("Server: ");
  Serial.println(WiFi.SSID());

  // IP des Arduinos anzeigen
  if (statischeIP) Serial.print("Statische IP Adresse Arduino: ");
  else Serial.print("IP Adresse Arduino DHCP: ");
  Serial.println(WiFi.localIP());
}

void loop() 
{
  // auf WebClienten warten ...
  WebClient = WiFiServer.available();
  if (WebClient) 
  {
    String SchaltungLesen;
    // solange der WebClient verbunden ist ...
    while (WebClient.connected()) 
    {
      if (WebClient.available()) 
      {
        // Anforderung vom WebClienten lesen ...
        char Zeichen = WebClient.read();

        // return (\n) gesendet
        if (Zeichen == '\n') 
        {
          // wenn der String SchaltungLesen leer ist
          if (SchaltungLesen == "") 
          {
            /*
              HTML-Seite aufbauen
              die folgenden Anweisungen müssen
              mit print oder println gesendet werden
              println "verschönert" den Quelltext
              (erzeugt einen Zeilenumbruch im Quelltext)
              " müssen mit \ maskiert werden " -> \"
            */
            // HTML-Seite aufbauen
            WebClient.println("HTTP/1.1 200 OK");
            WebClient.println("Content-type:text/html");

            // Leerzeile zwingend erforderlich
            WebClient.println();

            // Gerüst der HTML-Seite:
            WebClient.println("<!doctype html>");
            WebClient.println("<html>");

            WebClient.println("<body>");

            // h2 -> Überschrift, hr horizontale Linie
            WebClient.println("<h2>Ampel mit WiFi-Modul schalten</h2>");
            WebClient.println("<hr>");

            // table = Tabelle, tr = Tabelle Zeile, td = Tabelle Zelle
            WebClient.println("<table><tr>");

            // rote LED ist eingeschaltet -> roter Hintergrund
            /*
              style = Stil des Buttons bestimmen:
              background-color = Hintergrundfarbe, width/height = Breite/Höhe
              cursor: pointer = Cursor als Hand darstellen, 
              border-radius: 50% = runder Button, 
              border = Rand des Buttons als 2 Pixel breite durchgezogene Linie (solid)
              onclick: beim Klick auf den Button wird die URL RotAus übergeben,
              sie wird später ausgewertet
            */
            if (RotAn) 
            {
              WebClient.print("<td><input style='background-color:#FF6565;");
              WebClient.print(" width:150px;height:150px; cursor:pointer;");
              WebClient.print(" font-size:14pt;");
              WebClient.print(" border-radius:50%;border: 2px solid black;'");
              WebClient.print(" type='button'");
              WebClient.println(" value='rot'");
              WebClient.println(" onClick=\"location.href='RotAus'\">");
              WebClient.println("</td><tr>");
            }

            // rote LED ist ausgeschaltet -> weißer Hintergrund
            else 
            {
              WebClient.print("<td><input style='background-color:white;");
              WebClient.print(" width:150px;height:150px; cursor:pointer;");
              WebClient.print(" font-size:14pt;");
              WebClient.print(" border-radius:50%;border: 2px solid black;'");
              WebClient.print(" type='button'");
              WebClient.println(" value='rot'");
              WebClient.println(" onClick=\"location.href='RotEin'\">");
              WebClient.println("</td><tr>");
            }

            // gelbe LED ist eingeschaltet -> gelber Hintergrund
            if (GelbAn) 
            {
              WebClient.print("<td><input style='background-color:#FFFB65;");
              WebClient.print(" width:150px;height:150px; cursor:pointer;");
              WebClient.print(" font-size:14pt;");
              WebClient.print(" border-radius:50%;border: 2px solid black;'");
              WebClient.print(" type='button'");
              WebClient.println(" value='gelb'");
              WebClient.println(" onClick=\"location.href='GelbAus'\">");
              WebClient.println("</td><tr>");
            }

            // gelbe LED ist ausgeschaltet -> weißer Hintergrund
            else 
            {
              WebClient.print("<td><input style='background-color:white;");
              WebClient.print(" width:150px;height:150px; cursor:pointer;");
              WebClient.print(" font-size:14pt;");
              WebClient.print(" border-radius:50%;border: 2px solid black;'");
              WebClient.print(" type='button'");
              WebClient.println(" value='gelb'");
              WebClient.println(" onClick=\"location.href='GelbEin'\">");
              WebClient.println("</td><tr>");
            }

            // grüne LED ist eingeschaltet -> grüner Hintergrund
            if (GruenAn) 
            {
              WebClient.print("<td><input style='background-color:green;");
              WebClient.print(" width:150px;height:150px; cursor:pointer;");
              WebClient.print(" font-size:14pt;");
              WebClient.print(" border-radius:50%;border: 2px solid black;'");
              WebClient.print(" type='button'");
              WebClient.println(" value='gr&uuml;n'");
              WebClient.println(" onClick=\"location.href='GruenAus'\">");
              WebClient.println("</td><tr>");
            }

            // grüne LED ist ausgeschaltet -> weißer Hintergrund
            else 
            {
              WebClient.print("<td><input style='background-color:white;");
              WebClient.print(" width:150px;height:150px; cursor:pointer;");
              WebClient.print(" font-size:14pt;");
              WebClient.print(" border-radius:50%;border: 2px solid black;'");
              WebClient.print(" type='button'");
              WebClient.println(" value='gr&uuml;n'");
              WebClient.println(" onClick=\"location.href='GruenEin'\">");
              WebClient.println("</td><tr>");
            }

            WebClient.println("</table>");
            WebClient.println("<hr />");

            // IPs anzeigen
            WebClient.print("<b>Eigene IP: ");
            WebClient.print(WebClient.remoteIP());
            WebClient.print("</b>");
            WebClient.print("<br><b>IP Arduino: ");
            WebClient.print(WiFi.localIP());
            WebClient.print("</b>");
            WebClient.println("</body>");
            WebClient.println("</html>");

            // HTTP-Antwort endet mit neuer Zeile
            WebClient.println();

            // Seite vollständig geladen -> loop verlassen
            break;
          }

          // wenn SchaltungLesen nicht leer ist -> Inhalt löschen
          else SchaltungLesen = "";
        }

        // bei einem anderen Zeichen als return (\r)
        // -> Zeichen dem String SchaltungLesen hinzufügen
        else if (Zeichen != '\r') SchaltungLesen += Zeichen;

        // indexOf überprüft, ob die Zeichenfolge
        // im String SchaltungLesen enthalten ist
        // der Zusatnd der jeweiligen LED (ein/aus) wird mit ! "umgedreht":
        // false->true, true->false
        if (SchaltungLesen.indexOf("RotEin") > 0) RotAn = !RotAn;
        if (SchaltungLesen.indexOf("RotAus") > 0) RotAn = !RotAn;
        if (SchaltungLesen.indexOf("GelbEin") > 0) GelbAn = !GelbAn;
        if (SchaltungLesen.indexOf("GelbAus") > 0) GelbAn = !GelbAn;
        if (SchaltungLesen.indexOf("GruenEin") > 0) GruenAn = !GruenAn;
        if (SchaltungLesen.indexOf("GruenAus") > 0) GruenAn = !GruenAn;
      }
    }
    WebClient.stop();
  }

  // LEDs schalten
  if (RotAn) digitalWrite(ROT, HIGH);
  if (!RotAn) digitalWrite(ROT, LOW);
  if (GelbAn) digitalWrite(GELB, HIGH);
  if (!GelbAn) digitalWrite(GELB, LOW);
  if (GruenAn) digitalWrite(GRUEN, HIGH);
  if (!GruenAn) digitalWrite(GRUEN, LOW);  
}

ESP32 Wroom

#include "WiFi.h"

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

// Pins der LEDs
int ROT = 19;
int GELB = 18;
int GRUEN = 5;

// Schalter für den Zustand der LEDs (false->aus, true-> an
bool RotAn = false;
bool GelbAn = false;
bool GruenAn = false;

// statischeIP = false -> IP-Adresse über DHCP vergeben
// statischeIP = true -> statische IP festlegen
bool statischeIP = false;

// statische IP, Gateway und Subnetz anpassen
IPAddress ip(192, 168, 1, 200);
IPAddress Gateway(192, 168, 1, 1);
IPAddress Subnetz(255, 255, 255, 0);

WiFiServer WiFiServer(80);
WiFiClient WebClient = WiFiServer.available();

void setup() 
{
  pinMode(ROT, OUTPUT);
  pinMode(GELB, OUTPUT);
  pinMode(GRUEN, OUTPUT);
  
  Serial.begin(9600);

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

	// statische IP vergeben
  if (statischeIP) WiFi.config(ip, Gateway, Subnetz);
  
  // WiFi starten
  WiFi.begin(Router, Passwort);

  Serial.print("Verbindung aufbauen mit ");
  Serial.println(Router);
  
  // Verbindung herstellen
  while (WiFi.status() != WL_CONNECTED) 
  {
    delay(200);
    Serial.print(".");
  }

  WiFiServer.begin();

  // IP des Servers/des verbunden Computers anzeigen
  Serial.println();
  Serial.print("Server: ");
  Serial.println(WiFi.SSID());

  // IP anzeigen
  if (statischeIP) Serial.print("Statische IP Adresse: ");
  else Serial.print("IP Adresse DHCP: ");
  Serial.println(WiFi.localIP());
}

void loop() 
{
  // auf WebClienten warten ...
  WebClient = WiFiServer.available();
  if (WebClient) 
  {
    String SchaltungLesen;
    // solange der WebClient verbunden ist ...
    while (WebClient.connected()) 
    {
      if (WebClient.available()) 
      {
        // Anforderung vom WebClienten lesen ...
        char Zeichen = WebClient.read();

        // return (\n) gesendet
        if (Zeichen == '\n') 
        {
          // wenn der String SchaltungLesen leer ist
          if (SchaltungLesen == "") 
          {
            /*
              HTML-Seite aufbauen
              die folgenden Anweisungen müssen
              mit print oder println gesendet werden
              println "verschönert" den Quelltext
              (erzeugt einen Zeilenumbruch im Quelltext)
              " müssen mit \ maskiert werden " -> \"
            */
            // HTML-Seite aufbauen
            WebClient.println("HTTP/1.1 200 OK");
            WebClient.println("Content-type:text/html");

            // Leerzeile zwingend erforderlich
            WebClient.println();

            // Gerüst der HTML-Seite:
            WebClient.println("<!doctype html>");
            WebClient.println("<html>");

            WebClient.println("<body>");

            // h2 -> Überschrift, hr horizontale Linie
            WebClient.println("<h2>Ampel mit WiFi-Modul schalten</h2>");
            WebClient.println("<hr>");

            // table = Tabelle, tr = Tabelle Zeile, td = Tabelle Zelle
            WebClient.println("<table><tr>");

            // rote LED ist eingeschaltet -> roter Hintergrund
            /*
              style = Stil des Buttons bestimmen:
              background-color = Hintergrundfarbe, width/height = Breite/Höhe
              cursor: pointer = Cursor als Hand darstellen, 
              border-radius: 50% = runder Button, 
              border = Rand des Buttons als 2 Pixel breite durchgezogene Linie (solid)
              onclick: beim Klick auf den Button wird die URL RotAus übergeben,
              sie wird später ausgewertet
            */
            if (RotAn) 
            {
              WebClient.print("<td><input style='background-color:#FF6565;");
              WebClient.print(" width:150px;height:150px; cursor:pointer;");
              WebClient.print(" font-size:14pt;");
              WebClient.print(" border-radius:50%;border: 2px solid black;'");
              WebClient.print(" type='button'");
              WebClient.println(" value='rot'");
              WebClient.println(" onClick=\"location.href='RotAus'\">");
              WebClient.println("</td><tr>");
            }

            // rote LED ist ausgeschaltet -> weißer Hintergrund
            else 
            {
              WebClient.print("<td><input style='background-color:white;");
              WebClient.print(" width:150px;height:150px; cursor:pointer;");
              WebClient.print(" font-size:14pt;");
              WebClient.print(" border-radius:50%;border: 2px solid black;'");
              WebClient.print(" type='button'");
              WebClient.println(" value='rot'");
              WebClient.println(" onClick=\"location.href='RotEin'\">");
              WebClient.println("</td><tr>");
            }

            // gelbe LED ist eingeschaltet -> gelber Hintergrund
            if (GelbAn) 
            {
              WebClient.print("<td><input style='background-color:#FFFB65;");
              WebClient.print(" width:150px;height:150px; cursor:pointer;");
              WebClient.print(" font-size:14pt;");
              WebClient.print(" border-radius:50%;border: 2px solid black;'");
              WebClient.print(" type='button'");
              WebClient.println(" value='gelb'");
              WebClient.println(" onClick=\"location.href='GelbAus'\">");
              WebClient.println("</td><tr>");
            }

            // gelbe LED ist ausgeschaltet -> weißer Hintergrund
            else 
            {
              WebClient.print("<td><input style='background-color:white;");
              WebClient.print(" width:150px;height:150px; cursor:pointer;");
              WebClient.print(" font-size:14pt;");
              WebClient.print(" border-radius:50%;border: 2px solid black;'");
              WebClient.print(" type='button'");
              WebClient.println(" value='gelb'");
              WebClient.println(" onClick=\"location.href='GelbEin'\">");
              WebClient.println("</td><tr>");
            }

            // grüne LED ist eingeschaltet -> grüner Hintergrund
            if (GruenAn) 
            {
              WebClient.print("<td><input style='background-color:green;");
              WebClient.print(" width:150px;height:150px; cursor:pointer;");
              WebClient.print(" font-size:14pt;");
              WebClient.print(" border-radius:50%;border: 2px solid black;'");
              WebClient.print(" type='button'");
              WebClient.println(" value='gr&uuml;n'");
              WebClient.println(" onClick=\"location.href='GruenAus'\">");
              WebClient.println("</td><tr>");
            }

            // grüne LED ist ausgeschaltet -> weißer Hintergrund
            else 
            {
              WebClient.print("<td><input style='background-color:white;");
              WebClient.print(" width:150px;height:150px; cursor:pointer;");
              WebClient.print(" font-size:14pt;");
              WebClient.print(" border-radius:50%;border: 2px solid black;'");
              WebClient.print(" type='button'");
              WebClient.println(" value='gr&uuml;n'");
              WebClient.println(" onClick=\"location.href='GruenEin'\">");
              WebClient.println("</td><tr>");
            }

            WebClient.println("</table>");
            WebClient.println("<hr />");

            // IPs anzeigen
            WebClient.print("<b>Eigene IP: ");
            WebClient.print(WebClient.remoteIP());
            WebClient.print("</b>");
            WebClient.print("<br><b>IP Arduino: ");
            WebClient.print(WiFi.localIP());
            WebClient.print("</b>");
            WebClient.println("</body>");
            WebClient.println("</html>");

            // HTTP-Antwort endet mit neuer Zeile
            WebClient.println();

            // Seite vollständig geladen -> loop verlassen
            break;
          }

          // wenn SchaltungLesen nicht leer ist -> Inhalt löschen
          else SchaltungLesen = "";
        }

        // bei einem anderen Zeichen als return (\r)
        // -> Zeichen dem String SchaltungLesen hinzufügen
        else if (Zeichen != '\r') SchaltungLesen += Zeichen;

        // indexOf überprüft, ob die Zeichenfolge
        // im String SchaltungLesen enthalten ist
        // der Zusatnd der jeweiligen LED (ein/aus) wird mit ! "umgedreht":
        // false->true, true->false
        if (SchaltungLesen.indexOf("RotEin") > 0) RotAn = !RotAn;
        if (SchaltungLesen.indexOf("RotAus") > 0) RotAn = !RotAn;
        if (SchaltungLesen.indexOf("GelbEin") > 0) GelbAn = !GelbAn;
        if (SchaltungLesen.indexOf("GelbAus") > 0) GelbAn = !GelbAn;
        if (SchaltungLesen.indexOf("GruenEin") > 0) GruenAn = !GruenAn;
        if (SchaltungLesen.indexOf("GruenAus") > 0) GruenAn = !GruenAn;
      }
    }
    WebClient.stop();
  }

  // LEDs schalten
  if (RotAn) digitalWrite(ROT, HIGH);
  if (!RotAn) digitalWrite(ROT, LOW);
  if (GelbAn) digitalWrite(GELB, HIGH);
  if (!GelbAn) digitalWrite(GELB, LOW);
  if (GruenAn) digitalWrite(GRUEN, HIGH);
  if (!GruenAn) digitalWrite(GRUEN, LOW);  
}

Wemos D1 Mini

#include "ESP8266WiFi.h"

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

// Pins der LEDs
int ROT = D5;
int GELB = D6;
int GRUEN = D7;

// Schalter für den Zustand der LEDs (false->aus, true-> an
bool RotAn = false;
bool GelbAn = false;
bool GruenAn = false;

// statischeIP = false -> IP-Adresse über DHCP vergeben
// statischeIP = true -> statische IP festlegen
bool statischeIP = false;

// statische IP, Gateway und Subnetz anpassen
IPAddress ip(192, 168, 1, 200);
IPAddress Gateway(192, 168, 1, 1);
IPAddress Subnetz(255, 255, 255, 0);

WiFiServer WiFiServer(80);
WiFiClient WebClient = WiFiServer.available();

void setup() 
{
  pinMode(ROT, OUTPUT);
  pinMode(GELB, OUTPUT);
  pinMode(GRUEN, OUTPUT);
  
  Serial.begin(9600);

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

	// statische IP vergeben
  if (statischeIP) WiFi.config(ip, Gateway, Subnetz);
  
  // WiFi starten
  WiFi.begin(Router, Passwort);

  Serial.print("Verbindung aufbauen mit ");
  Serial.println(Router);
  
  // Verbindung herstellen
  while (WiFi.status() != WL_CONNECTED) 
  {
    delay(200);
    Serial.print(".");
  }

  WiFiServer.begin();

  // IP des Servers/des verbunden Computers anzeigen
  Serial.println();
  Serial.print("Server: ");
  Serial.println(WiFi.SSID());

  // IP anzeigen
  if (statischeIP) Serial.print("Statische IP Adresse: ");
  else Serial.print("IP Adresse DHCP: ");
  Serial.println(WiFi.localIP());
}

void loop() 
{
  // auf WebClienten warten ...
  WebClient = WiFiServer.available();
  if (WebClient) 
  {
    String SchaltungLesen;
    // solange der WebClient verbunden ist ...
    while (WebClient.connected()) 
    {
      if (WebClient.available()) 
      {
        // Anforderung vom WebClienten lesen ...
        char Zeichen = WebClient.read();

        // return (\n) gesendet
        if (Zeichen == '\n') 
        {
          // wenn der String SchaltungLesen leer ist
          if (SchaltungLesen == "") 
          {
            /*
              HTML-Seite aufbauen
              die folgenden Anweisungen müssen
              mit print oder println gesendet werden
              println "verschönert" den Quelltext
              (erzeugt einen Zeilenumbruch im Quelltext)
              " müssen mit \ maskiert werden " -> \"
            */
            // HTML-Seite aufbauen
            WebClient.println("HTTP/1.1 200 OK");
            WebClient.println("Content-type:text/html");

            // Leerzeile zwingend erforderlich
            WebClient.println();

            // Gerüst der HTML-Seite:
            WebClient.println("<!doctype html>");
            WebClient.println("<html>");

            WebClient.println("<body>");

            // h2 -> Überschrift, hr horizontale Linie
            WebClient.println("<h2>Ampel mit WiFi-Modul schalten</h2>");
            WebClient.println("<hr>");

            // table = Tabelle, tr = Tabelle Zeile, td = Tabelle Zelle
            WebClient.println("<table><tr>");

            // rote LED ist eingeschaltet -> roter Hintergrund
            /*
              style = Stil des Buttons bestimmen:
              background-color = Hintergrundfarbe, width/height = Breite/Höhe
              cursor: pointer = Cursor als Hand darstellen, 
              border-radius: 50% = runder Button, 
              border = Rand des Buttons als 2 Pixel breite durchgezogene Linie (solid)
              onclick: beim Klick auf den Button wird die URL RotAus übergeben,
              sie wird später ausgewertet
            */
            if (RotAn) 
            {
              WebClient.print("<td><input style='background-color:#FF6565;");
              WebClient.print(" width:150px;height:150px; cursor:pointer;");
              WebClient.print(" font-size:14pt;");
              WebClient.print(" border-radius:50%;border: 2px solid black;'");
              WebClient.print(" type='button'");
              WebClient.println(" value='rot'");
              WebClient.println(" onClick=\"location.href='RotAus'\">");
              WebClient.println("</td><tr>");
            }

            // rote LED ist ausgeschaltet -> weißer Hintergrund
            else 
            {
              WebClient.print("<td><input style='background-color:white;");
              WebClient.print(" width:150px;height:150px; cursor:pointer;");
              WebClient.print(" font-size:14pt;");
              WebClient.print(" border-radius:50%;border: 2px solid black;'");
              WebClient.print(" type='button'");
              WebClient.println(" value='rot'");
              WebClient.println(" onClick=\"location.href='RotEin'\">");
              WebClient.println("</td><tr>");
            }

            // gelbe LED ist eingeschaltet -> gelber Hintergrund
            if (GelbAn) 
            {
              WebClient.print("<td><input style='background-color:#FFFB65;");
              WebClient.print(" width:150px;height:150px; cursor:pointer;");
              WebClient.print(" font-size:14pt;");
              WebClient.print(" border-radius:50%;border: 2px solid black;'");
              WebClient.print(" type='button'");
              WebClient.println(" value='gelb'");
              WebClient.println(" onClick=\"location.href='GelbAus'\">");
              WebClient.println("</td><tr>");
            }

            // gelbe LED ist ausgeschaltet -> weißer Hintergrund
            else 
            {
              WebClient.print("<td><input style='background-color:white;");
              WebClient.print(" width:150px;height:150px; cursor:pointer;");
              WebClient.print(" font-size:14pt;");
              WebClient.print(" border-radius:50%;border: 2px solid black;'");
              WebClient.print(" type='button'");
              WebClient.println(" value='gelb'");
              WebClient.println(" onClick=\"location.href='GelbEin'\">");
              WebClient.println("</td><tr>");
            }

            // grüne LED ist eingeschaltet -> grüner Hintergrund
            if (GruenAn) 
            {
              WebClient.print("<td><input style='background-color:green;");
              WebClient.print(" width:150px;height:150px; cursor:pointer;");
              WebClient.print(" font-size:14pt;");
              WebClient.print(" border-radius:50%;border: 2px solid black;'");
              WebClient.print(" type='button'");
              WebClient.println(" value='gr&uuml;n'");
              WebClient.println(" onClick=\"location.href='GruenAus'\">");
              WebClient.println("</td><tr>");
            }

            // grüne LED ist ausgeschaltet -> weißer Hintergrund
            else 
            {
              WebClient.print("<td><input style='background-color:white;");
              WebClient.print(" width:150px;height:150px; cursor:pointer;");
              WebClient.print(" font-size:14pt;");
              WebClient.print(" border-radius:50%;border: 2px solid black;'");
              WebClient.print(" type='button'");
              WebClient.println(" value='gr&uuml;n'");
              WebClient.println(" onClick=\"location.href='GruenEin'\">");
              WebClient.println("</td><tr>");
            }

            WebClient.println("</table>");
            WebClient.println("<hr />");

            // IPs anzeigen
            WebClient.print("<b>Eigene IP: ");
            WebClient.print(WebClient.remoteIP());
            WebClient.print("</b>");
            WebClient.print("<br><b>IP Arduino: ");
            WebClient.print(WiFi.localIP());
            WebClient.print("</b>");
            WebClient.println("</body>");
            WebClient.println("</html>");

            // HTTP-Antwort endet mit neuer Zeile
            WebClient.println();

            // Seite vollständig geladen -> loop verlassen
            break;
          }

          // wenn SchaltungLesen nicht leer ist -> Inhalt löschen
          else SchaltungLesen = "";
        }

        // bei einem anderen Zeichen als return (\r)
        // -> Zeichen dem String SchaltungLesen hinzufügen
        else if (Zeichen != '\r') SchaltungLesen += Zeichen;

        // indexOf überprüft, ob die Zeichenfolge
        // im String SchaltungLesen enthalten ist
        // der Zusatnd der jeweiligen LED (ein/aus) wird mit ! "umgedreht":
        // false->true, true->false
        if (SchaltungLesen.indexOf("RotEin") > 0) RotAn = !RotAn;
        if (SchaltungLesen.indexOf("RotAus") > 0) RotAn = !RotAn;
        if (SchaltungLesen.indexOf("GelbEin") > 0) GelbAn = !GelbAn;
        if (SchaltungLesen.indexOf("GelbAus") > 0) GelbAn = !GelbAn;
        if (SchaltungLesen.indexOf("GruenEin") > 0) GruenAn = !GruenAn;
        if (SchaltungLesen.indexOf("GruenAus") > 0) GruenAn = !GruenAn;
      }
    }
    WebClient.stop();
  }

  // LEDs schalten
  if (RotAn) digitalWrite(ROT, HIGH);
  if (!RotAn) digitalWrite(ROT, LOW);
  if (GelbAn) digitalWrite(GELB, HIGH);
  if (!GelbAn) digitalWrite(GELB, LOW);
  if (GruenAn) digitalWrite(GRUEN, HIGH);
  if (!GruenAn) digitalWrite(GRUEN, LOW);  
}

Letzte Aktualisierung: Wei­ter lesen ...

Glücks­rad 360°-Motor

# include "Servo.h"

// Name des Motors
Servo Motor;

// Minimum und Maximum der "Laufzeit" des Motors
int Minimum = 300;
int Maximum = 1500;

// Pin des tasters
int Taster = 7;

// Variable für die Drehrichtung
int Drehrichtung;

void setup() 
{
  // Motor an Pin 9
  Motor.attach(9);

  // Motor anhalten
  Motor.write(90);

  // Zufallsgenerator starten
  randomSeed(analogRead(0));

  // pinMode des Tasters
  // INPUT_PULLUP = Modus Eingabe und Eingangspegel auf HIGH setzen
  pinMode(Taster, INPUT_PULLUP);
}

void loop() 
{
  // Wert des Tasters lesen
  int TasterLesen = digitalRead(Taster);

  // Taster wurde gedrückt
  if (TasterLesen == LOW) 
  {
    // Drehrichtung zufällig bestimmen
    Drehrichtung = random(0, 2);

    // Motor im Uhrzeigersinn drehen
    if (Drehrichtung == 0) Motor.write(80);

    // Motor gegen den Uhrzeigersinn drehen
    else Motor.write(100);

    // zufällige Anzahl von Millisekunden drehen
    delay(random(Minimum, Maximum));

    // Motor anhalten
    Motor.write(90);
  }
}

Letzte Aktualisierung: Wei­ter lesen ...

Spiel­au­to­mat RGB-Matrix

ESP32-Wroom

#include "Adafruit_NeoMatrix.h"

// Pins ESP32-Wroom, für UNO anpassen
#define RGBMatrixPin 15
#define TASTER 2
#define LAUTSPRECHER 26

// RGBMatrix -> Name der RGB-Matrix
/*
  die wichtigsten Parameter:
  Parameter 1 = Breite der Matrix (8)
  Parameter 2 = Höhe der Matrix (8)
  Parameter 3 = Name des Daten-Pins (RGBMatrixPin)
*/
Adafruit_NeoMatrix RGBMatrix = Adafruit_NeoMatrix
(
  8, 8, RGBMatrixPin,
  NEO_MATRIX_TOP + NEO_MATRIX_RIGHT + NEO_MATRIX_COLUMNS + NEO_MATRIX_PROGRESSIVE,
  NEO_GRB + NEO_KHZ800
);

// Farben definieren
#define Rot RGBMatrix.Color(255, 0, 0)
#define Gruen RGBMatrix.Color(0, 255, 0)
#define Blau RGBMatrix.Color(0, 0, 255)
#define Magenta RGBMatrix.Color(139, 0, 139)
#define Pink RGBMatrix.Color(255, 20, 147)
#define Weiss RGBMatrix.Color(255, 255, 255)
#define Gelb RGBMatrix.Color(255, 255, 0)
#define Schwarz RGBMatrix.Color(0, 0, 0)
#define Rosa RGBMatrix.Color(236, 170, 170)
#define Orange RGBMatrix.Color(255, 165, 0)

// zufällige Farbe
#define Zufallsfarbe RGBMatrix.Color(random(1, 255), random(1, 255), random(1, 255))

// Variablen: Farbe -> Farbe der Zahl, Zahl -> zufällig ermittelte Zahl
int Farbe;
int Zahl;

// Array für die Zufallszahlen
int ZahlWert[2];

// Startwert für die Anzahl der Durchläufe
int Durchlauf = 0;

// Variable für den Zusand des Tasters
bool TasterGedrueckt = true;

void setup() 
{
  pinMode(TASTER, INPUT_PULLUP);

  // Helligkeit der RGBMatrix
  RGBMatrix.setBrightness(30);

  // RGBMatrix starten
  RGBMatrix.begin();

  // Zufallsgenerator starten
  randomSeed(analogRead(0));

  // Pfeil anzeigen
  RGBMatrix.drawFastHLine(0, 3, 8, Gelb);
  RGBMatrix.drawFastHLine(0, 4, 8, Gelb);
  RGBMatrix.drawPixel(6, 2, Gelb);
  RGBMatrix.drawPixel(6, 5, Gelb);
  RGBMatrix.show();
}

void loop() 
{
  // solange der Taster gedrückt wird laufen zufällige Zahlen
  if (!digitalRead(TASTER)) 
  {
    TasterGedrueckt = false;
    RGBMatrix.clear();

    // ASCII-Werte der Zahlen: 49 = 1 ... 57 = 9
    Zahl = random(49, 57);

    // Farben der Zahlen definieren
    switch (Zahl) 
    {
      case 49:
        Farbe = Rot;
        break;
      case 50:
        Farbe = Gruen;
        break;
      case 51:
        Farbe = Blau;
        break;
      case 52:
        Farbe = Magenta;
        break;
      case 53:
        Farbe = Pink;
        break;
      case 54:
        Farbe = Weiss;
        break;
      case 55:
        Farbe = Gelb;
        break;
      case 56:
        Farbe = Rosa;
        break;
      case 57:
        Farbe = Orange;
        break;
    }

    // Zahl anzeigen
    RGBMatrix.drawChar(2, 1, char(Zahl), Farbe, Schwarz, 1);
    RGBMatrix.show();
    tone(LAUTSPRECHER, 1000, 30);
    delay(100);
  }

  // wenn der Taster nicht gedrückt wurde
  // und (&&) TasterGedrueckt false ist
  if (digitalRead(TASTER) && !TasterGedrueckt)
  {
    TasterGedrueckt = true;

    // aktuelle Zahl im Array speichern
    ZahlWert[Durchlauf] = Zahl;

    // wenn zwei Zahlen im Array gleich sind
    if (ZahlWert[0] == ZahlWert[1]) 
    {
      RGBMatrix.clear();

      // Pfeil anzeigen
      RGBMatrix.drawFastHLine(0, 3, 8, Gelb);
      RGBMatrix.drawFastHLine(0, 4, 8, Gelb);
      RGBMatrix.drawPixel(6, 2, Gelb);
      RGBMatrix.drawPixel(6, 5, Gelb);
      RGBMatrix.show();

      delay(1000);
      RGBMatrix.clear();

      // identische Zahlen anzeigen
      // erste Zahl anzeigen
      RGBMatrix.drawChar(2, 1, char(ZahlWert[0]), Farbe, Schwarz, 1);
      RGBMatrix.show();
      delay(2000);
      RGBMatrix.clear();

      // Pfeil anzeigen
      RGBMatrix.drawFastHLine(0, 3, 8, Gelb);
      RGBMatrix.drawFastHLine(0, 4, 8, Gelb);
      RGBMatrix.drawPixel(6, 2, Gelb);
      RGBMatrix.drawPixel(6, 5, Gelb);
      RGBMatrix.show();
      delay(2000);
      RGBMatrix.clear();
      
      // zweite Zahl anzeigen
      RGBMatrix.drawChar(2, 1, char(ZahlWert[1]), Farbe, Schwarz, 1);
      RGBMatrix.show();
      delay(2000);      

      // Smley
      RGBMatrix.clear();
      RGBMatrix.drawCircle(4, 4, 3, Gelb);
      RGBMatrix.drawPixel(3, 3, Gelb);
      RGBMatrix.drawPixel(5, 3, Gelb);
      RGBMatrix.show();

      // Melodie abspielen
      tone(LAUTSPRECHER, 100, 100);
      tone(LAUTSPRECHER, 200, 100);
      tone(LAUTSPRECHER, 300, 100);
      tone(LAUTSPRECHER, 400, 100);
      tone(LAUTSPRECHER, 300, 100);
      tone(LAUTSPRECHER, 200, 100);
      tone(LAUTSPRECHER, 100, 100);
    }

    // Durchlauf erhöhen
    Durchlauf ++;

    // wenn Durchlauf > 1 -> Wert zurücksetzen
    if (Durchlauf > 1) Durchlauf = 0;
  }
}

Wemos D1 Mini

#include "Adafruit_NeoMatrix.h"

// Pins ESP32-Wroom, für UNO anpassen
#define RGBMatrixPin D1
#define TASTER D3
#define LAUTSPRECHER D2

// RGBMatrix -> Name de D2D2-Matrix
/*
  die wichtigsten Parameter:
  Parameter 1 = Breite der Matrix (8)
  Parameter 2 = Höhe der Matrix (8)
  Parameter 3 = Name des Daten-Pins (RGBMatrixPin)
*/
Adafruit_NeoMatrix RGBMatrix = Adafruit_NeoMatrix
(
  8, 8, RGBMatrixPin,
  NEO_MATRIX_TOP + NEO_MATRIX_RIGHT + NEO_MATRIX_COLUMNS + NEO_MATRIX_PROGRESSIVE,
  NEO_GRB + NEO_KHZ800
);

// Farben definieren
#define Rot RGBMatrix.Color(255, 0, 0)
#define Gruen RGBMatrix.Color(0, 255, 0)
#define Blau RGBMatrix.Color(0, 0, 255)
#define Magenta RGBMatrix.Color(139, 0, 139)
#define Pink RGBMatrix.Color(255, 20, 147)
#define Weiss RGBMatrix.Color(255, 255, 255)
#define Gelb RGBMatrix.Color(255, 255, 0)
#define Schwarz RGBMatrix.Color(0, 0, 0)
#define Rosa RGBMatrix.Color(236, 170, 170)
#define Orange RGBMatrix.Color(255, 165, 0)

// zufällige Farbe
#define Zufallsfarbe RGBMatrix.Color(random(1, 255), random(1, 255), random(1, 255))

// Variablen: Farbe -> Farbe der Zahl, Zahl -> zufällig ermittelte Zahl
int Farbe;
int Zahl;

// Array für die Zufallszahlen
int ZahlWert[2];

// Startwert für die Anzahl der Durchläufe
int Durchlauf = 0;

// Variable für den Zusand des Tasters
bool TasterGedrueckt = true;

void setup() 
{
  pinMode(TASTER, INPUT_PULLUP);

  // Helligkeit der RGBMatrix
  RGBMatrix.setBrightness(30);

  // RGBMatrix starten
  RGBMatrix.begin();

  // Zufallsgenerator starten
  randomSeed(analogRead(0));

  // Pfeil anzeigen
  RGBMatrix.drawFastHLine(0, 3, 8, Gelb);
  RGBMatrix.drawFastHLine(0, 4, 8, Gelb);
  RGBMatrix.drawPixel(6, 2, Gelb);
  RGBMatrix.drawPixel(6, 5, Gelb);
  RGBMatrix.show();
}

void loop() 
{
  // solange der Taster gedrückt wird laufen zufällige Zahlen
  if (!digitalRead(TASTER)) 
  {
    TasterGedrueckt = false;
    RGBMatrix.clear();

    // ASCII-Werte der Zahlen: 49 = 1 ... 57 = 9
    Zahl = random(49, 57);

    // Farben der Zahlen definieren
    switch (Zahl) 
    {
      case 49:
        Farbe = Rot;
        break;
      case 50:
        Farbe = Gruen;
        break;
      case 51:
        Farbe = Blau;
        break;
      case 52:
        Farbe = Magenta;
        break;
      case 53:
        Farbe = Pink;
        break;
      case 54:
        Farbe = Weiss;
        break;
      case 55:
        Farbe = Gelb;
        break;
      case 56:
        Farbe = Rosa;
        break;
      case 57:
        Farbe = Orange;
        break;
    }

    // Zahl anzeigen
    RGBMatrix.drawChar(2, 1, char(Zahl), Farbe, Schwarz, 1);
    RGBMatrix.show();
    tone(LAUTSPRECHER, 1000, 30);
    delay(100);
  }

  // wenn der Taster nicht gedrückt wurde
  // und (&&) TasterGedrueckt false ist
  if (digitalRead(TASTER) && !TasterGedrueckt)
  {
    TasterGedrueckt = true;

    // aktuelle Zahl im Array speichern
    ZahlWert[Durchlauf] = Zahl;

    // wenn zwei Zahlen im Array gleich sind
    if (ZahlWert[0] == ZahlWert[1]) 
    {
      RGBMatrix.clear();

      // Pfeil anzeigen
      RGBMatrix.drawFastHLine(0, 3, 8, Gelb);
      RGBMatrix.drawFastHLine(0, 4, 8, Gelb);
      RGBMatrix.drawPixel(6, 2, Gelb);
      RGBMatrix.drawPixel(6, 5, Gelb);
      RGBMatrix.show();

      delay(1000);
      RGBMatrix.clear();

      // identische Zahlen anzeigen
      // erste Zahl anzeigen
      RGBMatrix.drawChar(2, 1, char(ZahlWert[0]), Farbe, Schwarz, 1);
      RGBMatrix.show();
      delay(2000);
      RGBMatrix.clear();

      // Pfeil anzeigen
      RGBMatrix.drawFastHLine(0, 3, 8, Gelb);
      RGBMatrix.drawFastHLine(0, 4, 8, Gelb);
      RGBMatrix.drawPixel(6, 2, Gelb);
      RGBMatrix.drawPixel(6, 5, Gelb);
      RGBMatrix.show();
      delay(2000);
      RGBMatrix.clear();
      
      // zweite Zahl anzeigen
      RGBMatrix.drawChar(2, 1, char(ZahlWert[1]), Farbe, Schwarz, 1);
      RGBMatrix.show();
      delay(2000);      

      // Smley
      RGBMatrix.clear();
      RGBMatrix.drawCircle(4, 4, 3, Gelb);
      RGBMatrix.drawPixel(3, 3, Gelb);
      RGBMatrix.drawPixel(5, 3, Gelb);
      RGBMatrix.show();

      // Melodie abspielen
      tone(LAUTSPRECHER, 100, 100);
      tone(LAUTSPRECHER, 200, 100);
      tone(LAUTSPRECHER, 300, 100);
      tone(LAUTSPRECHER, 400, 100);
      tone(LAUTSPRECHER, 300, 100);
      tone(LAUTSPRECHER, 200, 100);
      tone(LAUTSPRECHER, 100, 100);
    }

    // Durchlauf erhöhen
    Durchlauf ++;

    // wenn Durchlauf > 1 -> Wert zurücksetzen
    if (Durchlauf > 1) Durchlauf = 0;
  }
}

Ardui­no UNO

#include "Adafruit_NeoMatrix.h"

// Pins ESP32-Wroom, für UNO anpassen
#define RGBMatrixPin 7
#define TASTER 8
#define LAUTSPRECHER 9

// RGBMatrix -> Name der RGB-Matrix
/*
  die wichtigsten Parameter:
  Parameter 1 = Breite der Matrix (8)
  Parameter 2 = Höhe der Matrix (8)
  Parameter 3 = Name des Daten-Pins (RGBMatrixPin)
*/
Adafruit_NeoMatrix RGBMatrix = Adafruit_NeoMatrix
(
  8, 8, RGBMatrixPin,
  NEO_MATRIX_TOP + NEO_MATRIX_RIGHT + NEO_MATRIX_COLUMNS + NEO_MATRIX_PROGRESSIVE,
  NEO_GRB + NEO_KHZ800
);

// Farben definieren
#define Rot RGBMatrix.Color(255, 0, 0)
#define Gruen RGBMatrix.Color(0, 255, 0)
#define Blau RGBMatrix.Color(0, 0, 255)
#define Magenta RGBMatrix.Color(139, 0, 139)
#define Pink RGBMatrix.Color(255, 20, 147)
#define Weiss RGBMatrix.Color(255, 255, 255)
#define Gelb RGBMatrix.Color(255, 255, 0)
#define Schwarz RGBMatrix.Color(0, 0, 0)
#define Rosa RGBMatrix.Color(236, 170, 170)
#define Orange RGBMatrix.Color(255, 165, 0)

// zufällige Farbe
#define Zufallsfarbe RGBMatrix.Color(random(1, 255), random(1, 255), random(1, 255))

// Variablen: Farbe -> Farbe der Zahl, Zahl -> zufällig ermittelte Zahl
int Farbe;
int Zahl;

// Array für die Zufallszahlen
int ZahlWert[2];

// Startwert für die Anzahl der Durchläufe
int Durchlauf = 0;

// Variable für den Zusand des Tasters
bool TasterGedrueckt = true;

void setup() 
{
  pinMode(TASTER, INPUT_PULLUP);

  // Helligkeit der RGBMatrix
  RGBMatrix.setBrightness(30);

  // RGBMatrix starten
  RGBMatrix.begin();

  // Zufallsgenerator starten
  randomSeed(analogRead(0));

  // Pfeil anzeigen
  RGBMatrix.drawFastHLine(0, 3, 8, Gelb);
  RGBMatrix.drawFastHLine(0, 4, 8, Gelb);
  RGBMatrix.drawPixel(6, 2, Gelb);
  RGBMatrix.drawPixel(6, 5, Gelb);
  RGBMatrix.show();
}

void loop() 
{
  // solange der Taster gedrückt wird laufen zufällige Zahlen
  if (!digitalRead(TASTER)) 
  {
    TasterGedrueckt = false;
    RGBMatrix.clear();

    // ASCII-Werte der Zahlen: 49 = 1 ... 57 = 9
    Zahl = random(49, 57);

    // Farben der Zahlen definieren
    switch (Zahl) 
    {
      case 49:
        Farbe = Rot;
        break;
      case 50:
        Farbe = Gruen;
        break;
      case 51:
        Farbe = Blau;
        break;
      case 52:
        Farbe = Magenta;
        break;
      case 53:
        Farbe = Pink;
        break;
      case 54:
        Farbe = Weiss;
        break;
      case 55:
        Farbe = Gelb;
        break;
      case 56:
        Farbe = Rosa;
        break;
      case 57:
        Farbe = Orange;
        break;
    }

    // Zahl anzeigen
    RGBMatrix.drawChar(2, 1, char(Zahl), Farbe, Schwarz, 1);
    RGBMatrix.show();
    tone(LAUTSPRECHER, 1000, 30);
    delay(100);
  }

  // wenn der Taster nicht gedrückt wurde
  // und (&&) TasterGedrueckt false ist
  if (digitalRead(TASTER) && !TasterGedrueckt)
  {
    TasterGedrueckt = true;

    // aktuelle Zahl im Array speichern
    ZahlWert[Durchlauf] = Zahl;

    // wenn zwei Zahlen im Array gleich sind
    if (ZahlWert[0] == ZahlWert[1]) 
    {
      RGBMatrix.clear();

      // Pfeil anzeigen
      RGBMatrix.drawFastHLine(0, 3, 8, Gelb);
      RGBMatrix.drawFastHLine(0, 4, 8, Gelb);
      RGBMatrix.drawPixel(6, 2, Gelb);
      RGBMatrix.drawPixel(6, 5, Gelb);
      RGBMatrix.show();

      delay(1000);
      RGBMatrix.clear();

      // identische Zahlen anzeigen
      // erste Zahl anzeigen
      RGBMatrix.drawChar(2, 1, char(ZahlWert[0]), Farbe, Schwarz, 1);
      RGBMatrix.show();
      delay(2000);
      RGBMatrix.clear();

      // Pfeil anzeigen
      RGBMatrix.drawFastHLine(0, 3, 8, Gelb);
      RGBMatrix.drawFastHLine(0, 4, 8, Gelb);
      RGBMatrix.drawPixel(6, 2, Gelb);
      RGBMatrix.drawPixel(6, 5, Gelb);
      RGBMatrix.show();
      delay(2000);
      RGBMatrix.clear();
      
      // zweite Zahl anzeigen
      RGBMatrix.drawChar(2, 1, char(ZahlWert[1]), Farbe, Schwarz, 1);
      RGBMatrix.show();
      delay(2000);      

      // Smley
      RGBMatrix.clear();
      RGBMatrix.drawCircle(4, 4, 3, Gelb);
      RGBMatrix.drawPixel(3, 3, Gelb);
      RGBMatrix.drawPixel(5, 3, Gelb);
      RGBMatrix.show();

      // Melodie abspielen
      tone(LAUTSPRECHER, 100, 100);
      tone(LAUTSPRECHER, 200, 100);
      tone(LAUTSPRECHER, 300, 100);
      tone(LAUTSPRECHER, 400, 100);
      tone(LAUTSPRECHER, 300, 100);
      tone(LAUTSPRECHER, 200, 100);
      tone(LAUTSPRECHER, 100, 100);
    }

    // Durchlauf erhöhen
    Durchlauf ++;

    // wenn Durchlauf > 1 -> Wert zurücksetzen
    if (Durchlauf > 1) Durchlauf = 0;
  }
}

Letzte Aktualisierung: Wei­ter lesen ...

Wet­ter­sta­ti­on ESP32-Wroom

#include "WiFi.h"
#include "time.h"
#include "Adafruit_AHTX0.h"
#include "DHT.h"
#include "Adafruit_BMP280.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;

// Aktualisierungs-Intervall
unsigned long Intervall = 60000;

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

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

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

// Sensor AHT20 einen Namen zuweisen
Adafruit_AHTX0 aht;

// Sensor BMP280 einen Namen zuweisen
Adafruit_BMP280 bmp;

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

  // Sensor AHT20 starten
  aht.begin();

  // Sensor DHT starten
  dht.begin();

  // Sensor BMP280 starten
  bmp.begin();

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

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

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

  // Server starten
  Server.begin();

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

  // IP anzeigen
  Serial.println(WiFi.localIP());
}

void loop() 
{
  // Sensoren AHT20 definieren
  sensors_event_t Luftfeuchtigkeit, Temperatur;

  // Daten AHT lesen
  aht.getEvent(&Luftfeuchtigkeit, &Temperatur);
  String AnzeigeTemperaturAHT = String(Temperatur.temperature);
  AnzeigeTemperaturAHT.replace(".", ",");
  String AnzeigeLuftfeuchtigkeitAHT = String(Luftfeuchtigkeit.relative_humidity);
  AnzeigeLuftfeuchtigkeitAHT.replace(".", ",");

  // Daten DHT lesen
  String AnzeigeTemperaturDHT = String(dht.readTemperature());
  AnzeigeTemperaturDHT.replace(".", ",");
  String AnzeigeLuftfeuchtigkeitDHT = String(dht.readHumidity());
  AnzeigeLuftfeuchtigkeitDHT.replace(".", ",");

  // Daten BMP280 lesen 
  String AnzeigeTemperaturBMP = String(bmp.readTemperature());
  AnzeigeTemperaturBMP.replace(".", ",");
  String Luftdruck = String(bmp.readPressure() / 100);
  Luftdruck.replace(".", ",");

  // Name des verfügbaren Servers
  Client = Server.available();

  if (Client) 
  {
    // Seite aufbauen wenn SeiteAufbauen true ist
    boolean SeiteAufbauen = true;

    // solange der Client verbunden ist ...
    while (Client.connected()) 
    {
      if (Client.available()) 
      {
        // Anforderung vom Clienten lesen ...
        char Zeichen = Client.read();

        // return (\n) gesendet
        if (Zeichen == '\n') 
        {
          // wenn SeiteAufbauen den Wert true hat
          if (SeiteAufbauen) 
          {
            /*
              HTML-Seite aufbauen
              die folgenden Anweisungen müssen
              mit print oder println gesendet werden
              println "verschönert" den Quelltext
              (erzeugt einen Zeilenumbruch im Quelltext)
            */

            // HTML-Seite aufbauen
            Client.println("HTTP/1.1 200 OK");
            Client.println("Content-type:text/html");

            // Leerzeile zwingend erforderlich
            Client.println();

            Client.println("<!doctype html>");
            Client.println("<html>");
            Client.println("<body>");

            // alle 60 Sekunden aktualisieren mit meta-Tag
            Client.println("<meta http-equiv=\"refresh\" content=\"60\">");

            // <h2> Überschrift H2
            Client.println("<h2>Temperatur, Luftfeuchtigkeit und Luftdruck anzeigen</h2>");

            // <hr> horizontale Linie
            Client.println("<hr>");

            // aktuelle Zeit holen
            time(&aktuelleZeit);

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

            Client.print("<b>Datum: </b>");

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

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

            // Anzahl Jahre seit 1900
            Client.print(Zeit.tm_year + 1900);
            Client.print(" ");
            Client.print("<b>Zeit: </b>");

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

            Client.print(Zeit.tm_hour);
            Client.print(":");

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

            Client.print(Zeit.tm_min);
            Client.print(":");

            // Sekunden
            if (Zeit.tm_sec < 10) Client.print("0");
            Client.println(Zeit.tm_sec);
            Client.print(" Uhr");
            Client.println("<hr>");

            // Daten anzeigen
            // AHT
            Client.println("<b>Temperatur AHT20: </b>");
            Client.println("<blockquote>" + AnzeigeTemperaturAHT + " °C</blockquote>");
            Client.println("<b>Luftfeuchtigkeit AHT20: </b>");
            Client.println("<blockquote>" + AnzeigeLuftfeuchtigkeitAHT + " %</blockquote>");

            // DHT
            Client.println("<b>Temperatur DHT: </b>");
            Client.println("<blockquote>" + AnzeigeTemperaturDHT + " °C</blockquote>"); 
            Client.println("<b>Luftfeuchtigkeit DHT: </b>");
            Client.println("<blockquote>" + AnzeigeLuftfeuchtigkeitDHT + " %</blockquote>");
            
            // BMP280
            Client.println("<b>Temperatur BMP280: </b>");
            Client.println("<blockquote>" + AnzeigeTemperaturBMP + " °C</blockquote>"); 
            Client.println("<b>Luftdruck BMP280 </b><blockquote>" + Luftdruck + " hPa</blockquote>");

            Client.println("<hr>");
            
            // Button formatieren
            Client.print("<input style=\"font-size:16pt; font-weight:bold;");
            Client.print("background-color:#F5FAC9;box-shadow: 2px 2px grey;");
            Client.print("display:inline-block; border-radius:10px; cursor:pointer;\"type=\"button\"");
            Client.println("onClick=\"location.href='WiFi.localIP()'\" value=\"aktualisieren\">");
            Client.println("<hr>");
            
            // IPs anzeigen
            Client.print("Eigene IP (Server): ");
            Client.println(Client.remoteIP());

            // <br> break = neue Zeile
            Client.println("<br>IP Adresse Klient DHCP ");
            Client.println(WiFi.localIP());

            // Seite schließen
            Client.println("</body>");
            Client.println("</html>");

            // HTTP-Antwort endet mit neuer Zeile
            Client.println();

            // Seite vollständig geladen -> loop verlassen
            break;
          }

          // wenn new line (\n) gesendet wurde -> Seite aufbauen
          if (Zeichen == '\n') SeiteAufbauen = true;

          else if (Zeichen != '\r') SeiteAufbauen = false;
          delay(1);
          Client.stop();
        }
      }
    }
  }
}

Letzte Aktualisierung: Wei­ter lesen ...

Ver­gleich AHT20 DHT BMP280

/*
  ESP32-Wroom
  DHT-Pin 15
  I2C-Pins 
*/
# include "Adafruit_AHTX0.h"
# include "DHT.h"
# include "Adafruit_BMP280.h"

Adafruit_BMP280 bmp;

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

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

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

// Sensor einen Namen zuweisen
Adafruit_AHTX0 aht;

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

  // Sensor starten
  aht.begin();

  // Sensor DHT starten
  dht.begin();

  // BMP280 starten
  bmp.begin();
}

void loop() 
{
  // Sensoren definieren 
  sensors_event_t Luftfeuchtigkeit, Temperatur;

  // Messwerte AHT holen
  aht.getEvent(&Luftfeuchtigkeit, &Temperatur);
 
  // Messwerte BMP280
  // readTemperature() Temperatur messen und Messergebnis formatieren
  String AnzeigeTemperaturBMP = String(bmp.readTemperature());

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

  /*
    readPressure() Luftdruck messen und Messergebnis formatieren
    readPressure() liest in Pascal, Ausgabe in hPa (Hekto-Pascal)
    Ergebnis durch 100 teilen
  */
  String Luftdruck = String(bmp.readPressure() / 100);
  Luftdruck.replace(".", ",");

  // . durch , ersetzen AHT
  String AnzeigeTemperaturAHT = String(Temperatur.temperature);
  AnzeigeTemperaturAHT.replace(".", ",");
  String AnzeigeLuftfeuchtigkeitAHT = String(Luftfeuchtigkeit.relative_humidity);
  AnzeigeLuftfeuchtigkeitAHT.replace(".", ",");

  // . durch , ersetzen DHT
  String AnzeigeTemperaturDHT = String(dht.readTemperature());
  AnzeigeTemperaturDHT.replace(".", ",");
  String AnzeigeLuftfeuchtigkeitDHT = String(dht.readHumidity());
  AnzeigeLuftfeuchtigkeitDHT.replace(".", ",");

  // Ausgabe im Seriellen Monitor
  Serial.print("Temperatur AHT: "); 
  Serial.print(AnzeigeTemperaturAHT); 
  Serial.println(" °C");
  Serial.print("Luftfeuchtigkeit AHT: "); 
  Serial.print(AnzeigeLuftfeuchtigkeitAHT); 
  Serial.println("%");

  Serial.println("-----------------------------");
  Serial.print("Temperatur DHT: "); 
  Serial.print(AnzeigeTemperaturDHT); 
  Serial.println(" °C");
  Serial.print("Luftfeuchtigkeit DHT: "); 
  Serial.print(AnzeigeLuftfeuchtigkeitDHT); 
  Serial.println("%");
  Serial.println("-----------------------------");

  Serial.print("Temperatur BMP280: "); 
  Serial.print(AnzeigeTemperaturBMP); 
  Serial.println(" °C");

  Serial.println("Luftdruck: " + Luftdruck + " hPa");
  Serial.println("-----------------------------");

  delay(5000);
}

Letzte Aktualisierung: Wei­ter lesen ...