Lösungen

NTP - Datum und Zeit OLED anzeigen

// ESP
# include <ESP8266WiFi.h>
# include <NTP.h>
# include <WiFiUdp.h>
# include <NTP.h>

// Arduino WiFi
// # include <WiFiNINA.h>
// # include <NTP.h>

# include <U8g2lib.h>

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

// Parameter 1,3 Zoll SH1106
// U8G2_SH1106_128X64_NONAME_1_HW_I2C oled(U8G2_R0, U8X8_PIN_NONE);

// SSID des Routers und Passwort
char Router[] = "FRITZ!Box 7590 LB";
char Passwort[] = "xxxxxxxx";

WiFiUDP wifiUdp;
NTP ntp(wifiUdp);

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

// 30 Sekunden Intervall, kann angepasst werden
int Intervall = 30000;

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

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

  while (WiFi.status() != WL_CONNECTED)
  {
    delay(500);
  }
  // SSID des Routers anzeigen
  Serial.print("Verbunden mit ");
  Serial.println(WiFi.SSID());

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

  /*
    Zeitzone
    CEST: Central European Summertime
    Beginn europäische Sommerzeit letzter Sonntag im März 2 Uhr GMT + 2 Stunden
  */
  ntp.ruleDST("CEST", Last, Sun, Mar, 2, 120);

  // CET: Central European Time
  // Beginn Normalzeit letzter Sonntag im Oktober 3 Uhr GMT + 1 Stunde
  ntp.ruleSTD("CET", Last, Sun, Oct, 3, 60);

  // ntp starten
  ntp.begin();

  // OLED starten
  oled.begin();

  // Schriftart
  oled.setFont(u8g2_font_courB24_tf);

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

  // horizontale Schrift
  oled.setFontDirection(0);

  // Datum und Zeit beim Start anzeigen
  ntp.update();
  oled.clearDisplay();
  oled.firstPage();
  do
  {
    oled.setCursor(2, 15);
    oled.setFont(u8g2_font_t0_22_te);

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

    // Monat: führende 0 ergänzen
    if (ntp.month() < 10) oled.print("0");
    oled.print(ntp.month());
    oled.print(".");

    // Jahr
    oled.print(ntp.year());

    // horizontale Linie
    oled.drawHLine(1, 22, oled.getDisplayWidth());
    oled.setCursor(2, 63);

    // Uhrzeit
    // Stunden: führende 0 ergänzen
    oled.setFont(u8g2_font_logisoso32_tf);
    if (ntp.hours() < 10) oled.print("0");
    oled.print(String(ntp.hours()) + ":");

    // Minuten: führende 0 ergänzen
    if (ntp.minutes() < 10) oled.print("0");
    oled.print(String(ntp.minutes()));
  }
  while (oled.nextPage());
}

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

  // wenn das festgelegte Intervall erreicht ist
  if (Startzeit - GesicherteStartZeit > Intervall)
  {
    ntp.update();
    oled.clearDisplay();

    // Startzeit zurücksetzen
    GesicherteStartZeit = Startzeit;
    oled.setCursor(3, 20);
    oled.firstPage();
    do
    {
      oled.setCursor(2, 15);
      oled.setFont(u8g2_font_t0_22_te);

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

      // Monat: führende 0 ergänzen
      if (ntp.month() < 10) oled.print("0");
      oled.print(ntp.month());
      oled.print(".");
      oled.print(ntp.year());

      // horizontale Linie
      oled.drawHLine(1, 22, oled.getDisplayWidth());
      oled.setCursor(2, 63);

      // Uhrzeit
      // Stunden: führende 0 ergänzen
      oled.setFont(u8g2_font_logisoso32_tf);
      if (ntp.hours() < 10) oled.print("0");
      oled.print(String(ntp.hours()) + ":");

      // Minuten: führende 0 ergänzen
      if (ntp.minutes() < 10) oled.print("0");
      oled.print(String(ntp.minutes()));
    }
    while (oled.nextPage());
  }
}

Letzte Aktualisierung: Wei­ter lesen ...

NTP mit Ardui­no WiFi/Wemos D1 Seri­el­ler Monitor

// Arduino WiFi
// # include <WiFiNINA.h>
// # include <NTP.h>

// ESP8286
# include <ESP8266WiFi.h>
# include <WiFiUdp.h>
# include <NTP.h>

char Router[] = "FRITZ!Box 7590 LB";
char Passwort[] = "xxxxxxx ";

WiFiUDP wifiUdp;
NTP ntp(wifiUdp);

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

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

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

  /*
    Zeitzone
    CEST: Central European Summertime
    Beginn europäische Sommerzeit letzter Sonntag im März 2 Uhr GMT + 2 Stunden
  */
  ntp.ruleDST("CEST", Last, Sun, Mar, 2, 120);

  // CET: Central European Time
  // Beginn Normalzeit letzter Sonntag im Oktober 3 Uhr GMT + 1 Stunde
  ntp.ruleSTD("CET", Last, Sun, Oct, 3, 60);  // last sunday in october 3:00, timezone +60min (+1 GMT)
  ntp.begin();
}

void loop() 
{
  Startzeit = millis();
  if (Startzeit - GesicherteStartZeit > Intervall) 
  {
    // Startzeit zurücksetzen
    GesicherteStartZeit = Startzeit;
    Serial.print("Verbunden mit ");
    Serial.println(WiFi.SSID());

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

    // Zeit aktualisieren
    ntp.update();

    // Wochentag: int von 0 - 6
    switch (ntp.weekDay()) 
    {
      case 0:
        Serial.println("Sonntag");
        break;
      case 1:
        Serial.println("Montag");
        break;
      case 2:
        Serial.println("Dienstag");
        break;
      case 3:
        Serial.println("Mittwoch");
        break;
      case 4:
        Serial.println("Donnerstag");
        break;
      case 5:
        Serial.print("Freitag ");
        break;
      case 6:
        Serial.print("Samstag ");
        break;
    }

    Serial.print(ntp.day());
    Serial.print(". ");

    // Monatsnamen: int von 1 - 12
    switch (ntp.month()) 
    {
      case 1:
        Serial.print("Januar ");
        break;
      case 2:
        Serial.print("Februar ");
        break;
      case 3:
        Serial.print("März ");
        break;
      case 4:
        Serial.print("April ");
        break;
      case 5:
        Serial.print("Mai ");
        break;
      case 6:
        Serial.print("Juni ");
        break;
      case 7:
        Serial.print("Juli ");
        break;
      case 8:
        Serial.print("August ");
        break;
      case 9:
        Serial.print("September ");
        break;
      case 10:
        Serial.print("Oktober ");
        break;
      case 11:
        Serial.print("November ");
        break;
      case 12:
        Serial.print("Dezember ");
        break;
    }
    Serial.println(ntp.year());

    // Uhrzeit
    // führende 0 ergänzen
    if (ntp.hours() < 10) Serial.print("0");
    Serial.print(String(ntp.hours()) + ":");

    if (ntp.minutes() < 10) Serial.print("0");
    Serial.print(String(ntp.minutes()) + ":");

    if (ntp.seconds() < 10) Serial.print("0");
    Serial.println(String(ntp.seconds()) + " Uhr");
    Serial.println("-------------------");
  }
}

Letzte Aktualisierung: Wei­ter lesen ...

Wet­ter­sta­ti­on mit Wemos D1

Inhalts­ver­zeich­nis

Wet­ter­sta­ti­on mit RTC-Modul 3231

# include <ESP8266WebServer.h>
# include <Arduino.h>
# include <MHZ19.h>
# include <SoftwareSerial.h>
# include <RTClib.h>
# include <DHT.h>
# include <Adafruit_BMP280.h>

// Router: Name des Routers
// Passwort: WLAN-Passwort
char Router[] = "FRITZ!Box 7590 LB";
char Passwort[] = "xxxxxxxx";

// festeIP = false -> IP-Adresse über DHCP vergeben
// festeIP = true -> IP Gateway und Subnetz festlegen
bool festeIP = false;
// IP, Gateway und Subnetz festlegen
IPAddress ip(192, 168, 1, 200);
IPAddress gateway(192, 168, 1, 1);
IPAddress subnet(255, 255, 255, 0);
WiFiServer server(80);
WiFiClient client;

// Pin des DHT22
int SENSOR_DHT = D5;

// Sensortyp festlegen
// DHT22
# define SensorTyp DHT22

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

// Name des RTC-Moduls (rtc)
RTC_DS3231 rtc;

// RX/TX Pins zuordnen
// TX MH-Z19C auf D6, RX-Pin MH_Z19C auf D7 (überkreuz)
#define RX D6
#define TX D7

// Name des Moduls MH-Z19
MHZ19 MHZCO2;

// Name des bmp-Sensors
Adafruit_BMP280 bmp;

// SoftwareSerial -> Name zuordnen
SoftwareSerial MHZSerial(RX, TX);
unsigned long VerstricheneZeit = 0;

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

  // WiFi starten
  WiFi.begin(Router, Passwort);
  if (festeIP) WiFi.config(ip, gateway, subnet);

  // verbinden
  while (WiFi.status() != WL_CONNECTED)
  {
    delay(500);
    Serial.print(".");
  }
  server.begin();

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

  // IP des Arduinos anzeigen
  if (festeIP) Serial.print("Statische IP Adresse: ");
  else Serial.print("IP Adresse DHCP: ");
  Serial.println(WiFi.localIP());
  MHZSerial.begin(9600);
  MHZCO2.begin(MHZSerial);

  // automatische Kalibrierung ausschalten
  MHZCO2.autoCalibration(false);

  // RTC-Modul starten
  rtc.begin();

  // Datum/Zeit einmalig setzen, beim nächsten Starten auskommentieren
  // rtc.adjust(DateTime(2023, 4, 23, 8, 50, 30));

  // Sensor DHT starten
  dht.begin();

  // bmp starten
  bmp.begin();
}

void loop()
{
  VerstricheneZeit = millis();
  client = server.available();
  if (client)
  {
    String SchaltungLesen = "";
    while (client.connected())
    {
      if (client.available())
      {
        char Zeichen = client.read();
        if (Zeichen == '\n')
        {
          if (SchaltungLesen.length() == 0) {
            // HTTP-Anforderung senden
            client.println("HTTP/1.1 200 OK");
            client.println("Content-Type: text/html");
            // Leerzeile zwingend erforderlich
            client.println();

            /*
              HTML-Seite aufbauen
              die folgenden Anweisungen müssen mit print oder println gesendet werden
              println "verschönert" den Quelltext
              " muss mit \" maskiert werden
            */
            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\">");
            client.println("<h1> Temperatur, Luftfeuchtigkeit und CO&#8322;-Gehalt in der Luft messen</h1>");
            client.println("<hr />");
            client.print("<h2>Letzte Messung: ");
            DateTime aktuell = rtc.now();
            char Datum[] = "DD.MM.YYYY ";
            char Zeit[] = "hh:mm:ss Uhr";

            switch (aktuell.dayOfTheWeek())
            {
              case 0:
                client.print(F("Sonntag"));
                break;
              case 1:
                client.print(F("Montag"));
                break;
              case 2:
                client.print(F("Dienstag"));
                break;
              case 3:
                client.print(F("Mittwoch"));
                break;
              case 4:
                client.print(F("Donnerstag"));
                break;
              case 5:
                client.print(F("Freitag"));
                break;
              case 6:
                client.print(F("Samstag"));
                break;
            }
            client.print(", ");
            client.print(aktuell.toString(Datum));
            client.println(aktuell.toString(Zeit));
            client.println("</h2>");
            client.println("<hr />");

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

            // CO2-Wert ermitteln
            int CO2 = MHZCO2.getCO2();

            /* 
              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(".", ",");

            // Daten anzeigen
            client.print("<b>Temperatur:</b><blockquote>");
            client.println(AnzeigeTemperaturDHT + " &deg;C</blockquote>");
            client.println("<br>");
            client.print("<b>Luftfeuchtigkeit:</b><blockquote>");
            client.println(AnzeigeLuftfeuchtigkeit + " %</blockquote>");

            client.print("<b>Luftdruck:</b><blockquote>");
            client.println(Luftdruck + " hPa</blockquote>");
            client.println("<br>");

            client.print("<b>CO&#8322-Gehalt:</b><blockquote>");
            client.println(String(CO2) + " ppm</blockquote>");
            client.println("<form>");
            client.println(F("<hr />"));

            // Button formatieren
            client.print("<input style=\"font-size:16pt; font-weight:bold;");
            client.print("background-color:#55A96B;");
            client.print("display:block; cursor:pointer;\"type=\"button\"");
            client.println(" onClick=\"location.href='WiFi.localIP()'\" value=\"aktualisieren\">");
            client.println("</form>");
            client.println("<hr />");

            // IPs anzeigen
            client.print(F("<b>Eigene IP: "));
            client.print(client.remoteIP());
            client.print(F("</b>"));
            client.print(F("<br><b>IP Klient: "));
            client.print(WiFi.localIP());
            client.print(F("</b>"));
            client.println("</b>");
            client.println("</body>");
            client.print("</html>");
            // HTTP-Antwort endet mit neuer Zeile
            client.println();
            // Seite vollständig geladen -> loop verlassen
            break;
          }
          else
          {
            SchaltungLesen = "";
          }
        }
        // bei einem anderen Zeichen als return (\r)
        // -> Zeichen dem String SchaltungLesen hinzufügen
        else if (Zeichen != '\r')
        {
          SchaltungLesen += Zeichen;
        }
      }
    }
    client.stop();
  }
}

Wet­terst­ti­on mit Inter­net­zeit (NTP)

#include <ESP8266WebServer.h>
#include <MHZ19.h>
#include <SoftwareSerial.h>
#include <DHT.h>
#include <Adafruit_BMP280.h>
#include <WiFiUdp.h>
#include <NTP.h>

// Router: Name des Routers
// Passwort: WLAN-Passwort
char Router[] = "FRITZ!Box 7590 LB";
char Passwort[] = "xxxxxxxx";

WiFiUDP wifiUdp;
NTP ntp(wifiUdp);

// festeIP = false -> IP-Adresse über DHCP vergeben
// festeIP = true -> IP Gateway und Subnetz festlegen
bool festeIP = false;

// IP, Gateway und Subnetz festlegen
IPAddress ip(192, 168, 1, 200);
IPAddress gateway(192, 168, 1, 1);
IPAddress subnet(255, 255, 255, 0);
WiFiServer server(80);
WiFiClient client;

// Pin des DHT22
int SENSOR_DHT = D5;

// Sensortyp festlegen
// DHT22
#define SensorTyp DHT22

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

// RX/TX Pins zuordnen
// TX MH-Z19C auf D6, RX-Pin MH_Z19C auf D7 (überkreuz)
#define RX D6
#define TX D7

// Name des Moduls MH-Z19
MHZ19 MHZCO2;

// Name des bmp-Sensors
Adafruit_BMP280 bmp;

// SoftwareSerial -> Name zuordnen
SoftwareSerial MHZSerial(RX, TX);

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

  // WiFi starten
  WiFi.begin(Router, Passwort);
  if (festeIP) WiFi.config(ip, gateway, subnet);

  // verbinden
  while (WiFi.status() != WL_CONNECTED) 
  {
    delay(500);
    Serial.print(".");
  }
  server.begin();

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

  // IP des Arduinos anzeigen
  if (festeIP) Serial.print("Statische IP Adresse: ");
  else Serial.print("IP Adresse DHCP: ");
  Serial.println(WiFi.localIP());
  MHZSerial.begin(9600);
  MHZCO2.begin(MHZSerial);

  // automatische Kalibrierung ausschalten
  MHZCO2.autoCalibration(false);

  // Sensor DHT starten
  dht.begin();

  // bmp starten
  bmp.begin();

  // CEST: Beginn europäische Sommerzeit; letzter Sonntag im März 2 Uhr GMT + 2 Stunden
  ntp.ruleDST("CEST", Last, Sun, Mar, 2, 120);

  // CET: Beginn Normalzeit letzter Sonntag im Oktober 3 Uhr GMT + 1 Stunde
  ntp.ruleSTD("CET", Last, Sun, Oct, 3, 60);    // last sunday in october 3:00, timezone +60min (+1 GMT)

  // ntp starten
  ntp.begin();
}

void loop() 
{
  client = server.available();
  if (client) 
  {
    String SchaltungLesen = "";
    while (client.connected()) 
    {
      if (client.available()) 
      {
        char Zeichen = client.read();
        if (Zeichen == '\n') 
        {
          if (SchaltungLesen.length() == 0) 
          {
            // HTTP-Anforderung senden
            client.println("HTTP/1.1 200 OK");
            client.println("Content-Type: text/html");
            // Leerzeile zwingend erforderlich
            client.println();

            /*
              HTML-Seite aufbauen
              die folgenden Anweisungen müssen mit print oder println gesendet werden
              println "verschönert" den Quelltext
              " muss mit \" maskiert werden
            */
            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\">");
            client.println("<h1> Temperatur, Luftfeuchtigkeit und CO&#8322;-Gehalt in der Luft messen</h1>");
            client.println("<hr />");
            client.print("<h2>Letzte Messung: ");

            // Zeit-Server kontaktieren
            ntp.update();
            
            // Wochentag anzeigen
            switch (ntp.weekDay()) 
            {
              case 0:
                client.println("Sonntag ");
                break;
              case 1:
                client.println("Montag ");
                break;
              case 2:
                client.println("Dienstag ");
                break;
              case 3:
                client.println("Mittwoch ");
                break;
              case 4:
                client.println("Donnerstag ");
                break;
              case 5:
                client.print("Freitag ");
                break;
              case 6:
                client.print("Samstag ");
                break;
            }
            client.print(ntp.day());
            client.print(". ");

            // Moant anzeigen
            switch (ntp.month()) 
            {
              case 1:
                client.print("Januar ");
                break;
              case 2:
                client.print("Februar ");
                break;
              case 3:
                client.print("März ");
                break;
              case 4:
                client.print("April ");
                break;
              case 5:
                client.print("Mai ");
                break;
              case 6:
                client.print("Juni ");
                break;
              case 7:
                client.print("Juli ");
                break;
              case 8:
                client.print("August ");
                break;
              case 9:
                client.print("September ");
                break;
              case 10:
                client.print("Oktober ");
                break;
              case 11:
                client.print("November ");
                break;
              case 12:
                client.print("Dezember ");
                break;
            }
            client.print(ntp.year());
            client.print(" ");

            // führende 0 ergänzen
            if (ntp.hours() < 10) client.print("0");
            client.print(String(ntp.hours()) + ":");

            if (ntp.minutes() < 10) client.print("0");
            client.println(String(ntp.minutes()) + " Uhr");

            client.println("</h2>");
            client.println("<hr />");

            // Daten lesen DHT und . durch , ersetzetn
            String AnzeigeTemperaturDHT = PunktErsetzen(String(dht.readTemperature()));

            String AnzeigeLuftfeuchtigkeit = PunktErsetzen(String(dht.readHumidity()));

            // Daten lesen BMP und . durch , ersetzetn
            String AnzeigeTemperaturBMP = String(bmp.readTemperature());

            /* 
              readPressure() Luftdruck messen und Messergebnis formatieren
              readPressure() liest in Pascal, ausgabe in hPa (Hekto-Pascal)
              Ergebnis durch 100 teilen
            */

            // Luftdruck BMP280 lesen und . durch , ersetzetn
            String Luftdruck = PunktErsetzen(String(bmp.readPressure() / 100));

            // Temperatur DHT und BMP280 anzeigen
            client.print("<b>Temperatur:</b><blockquote>");
            client.print("<b>DHT:</b> " + AnzeigeTemperaturDHT + " &deg;C");
            client.print("    <b>BMP:</b> " + AnzeigeTemperaturBMP + " &deg;C</blockquote>");

            // DHT Luftfeuchtigkeit
            client.print("<b>Luftfeuchtigkeit:</b><blockquote>");
            client.println(AnzeigeLuftfeuchtigkeit + " %</blockquote>");

            client.print("<b>Luftdruck:</b><blockquote>");
            client.print(Luftdruck + " hPa</blockquote>");

            // CO2 messen und anzeigen
            int CO2 = MHZCO2.getCO2();

            // kurzes delay -> Messwert stabilisieren
            delay(500);
            client.print("<b>CO&#8322-Gehalt:</b><blockquote>");
            client.println(String(CO2) + " ppm</blockquote>");
            client.println("<form>");
            client.println(F("<hr />"));

            // Button formatieren
            client.print("<input style=\"font-size:16pt; font-weight:bold;");
            client.print("background-color:#55A96B;");
            client.print("display:block; cursor:pointer;\"type=\"button\"");
            client.println(" onClick=\"location.href='WiFi.localIP()'\" value=\"aktualisieren\">");
            client.println("</form>");
            client.println("<hr />");

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

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

            // Seite vollständig geladen -> loop verlassen
            break;
          } 
          else SchaltungLesen = "";
        }
        // bei einem anderen Zeichen als return (\r)
        // -> Zeichen dem String SchaltungLesen hinzufügen
        else if (Zeichen != '\r') SchaltungLesen += Zeichen;
      }
    }
    client.stop();
  }
}

String PunktErsetzen(String ErsatzString)
{
  ErsatzString.replace(".", ",");
  return ErsatzString;
}

Letzte Aktualisierung: Wei­ter lesen ...

Juke­box

Inhalt

Juke­box im Seri­el­len Monitor

# include <PlayRtttl.hpp>

#define Lautsprecher 7

// Interpret und Titel als String
String TitelSong;

char TeDeum[] =
"Charpentier/Te_Deum:d=4,o=6,b=63:8c5,8f5,16f5,16g5,8a5,8f5,c,8a5,8a5,8a_5,16c,16a_5,16a5,16a_5,8c,16g5,16f5,16g5,16a5,8g5,8c5,8f5,16f5,16g5,8a5,8f5,c,8a5,8a5,16a_5,16c,16a5,16a_5,g5,16f5,2f5";

char FuerElise[] =
"Beethoven/Für_Elise:d=8,o=5,b=125:32p,e6,d#6,e6,d#6,e6,b,d6,c6,4a.,32p,c,e,a,4b.,32p,e,g#,b,4c.6,32p,e,e6,d#6,e6,d#6,e6,b,d6,c6,4a.,32p,c,e,a,4b.,32p,d,c6,b,2a";

char FuenfteSymphonie[] =
"Beethoven/5._Symphonie:d=4,o=5,b=180:8f,8f,8f,1c#,8p,8d#,8d#,8d#,1c,8p,8f,8f,8f,8c#,8f#,8f#,8f#,8f,8c#6,8c#6,8c#6,2a#,8p,8f,8f,8f,8c,8f#,8f#,8f#,8f,8d#6,8d#6,8d#6,1c6";

char OdeandieFreude[] =
"Beethoven/Ode_an_die_Freude#:d=4,o=6,b=100:a5,a5,a_5,c,c,a_5,a5,g5,f5,f5,g5,a5,a.5,8g5,2g5,";

char Bolero[] =
"Ravel/Bolero:d=4,o=5,b=80:c6,8c6,16b,16c6,16d6,16c6,16b,16a,8c6,16c6,16a,c6,8c6,16b,16c6,16a,16g,16e,16f,2g,16g,16f,16e,16d,16e,16f,16g,16a,g,g,";

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

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

  // Menü im Seriellen Monitor
  Serial.println("1: Te Deum");
  Serial.println("2: Für Elise");
  Serial.println("3: Ode an die Freude");
  Serial.println("4: Bolero");
  Serial.println("5: Titel anzeigen");
  Serial.println("--------------------");
}

void loop() 
{
  // auf serielle Eingabe warten
  while (Serial.available() > 0) 
  {
    // Eingabe im Seriellen Monitor lesen
    char Zeichen = Serial.read();

    if (Zeichen == '1') 
    {
      // char-Array des Titels in String umwandeln
      TitelSong = String(TeDeum);

      // Funktion aufrufen, Interpret/Titel extrahieren
      ZeigeTitel(TitelSong);

      // Titel spielen
      playRtttlBlocking(Lautsprecher, TeDeum);
    }

    if (Zeichen == '2') 
    {
      // char-Array des Titels in String umwandeln
      TitelSong = String(FuerElise);

      // Funktion aufrufen, Interpret/Titel extrahieren
      ZeigeTitel(TitelSong);

      // Titel spielen
      playRtttlBlocking(Lautsprecher, FuerElise);
    }
   
    if (Zeichen == '3') 
    {
      // char-Array des Titels in String umwandeln
      TitelSong = String(OdeandieFreude);

      // Funktion aufrufen, Interpret/Titel extrahieren
      ZeigeTitel(TitelSong);

      // Titel spielen
      playRtttlBlocking(Lautsprecher, OdeandieFreude);
    }

    if (Zeichen == '4') 
    {
      // char-Array des Titels in String umwandeln
      TitelSong = String(Bolero);

      // Funktion aufrufen, Interpret/Titel extrahieren
      ZeigeTitel(TitelSong);

      // Titel spielen
      playRtttlBlocking(Lautsprecher, Bolero);
    }

 if (Zeichen == '5') 
    {
      // char-Array des Titels in String umwandeln
      TitelSong = String(FuenfteSymphonie);

      // Funktion aufrufen, Interpret/Titel extrahieren
      ZeigeTitel(TitelSong);

      // Titel spielen
      playRtttlBlocking(Lautsprecher, FuenfteSymphonie);
    }

    if (Zeichen == '6') 
    {
      Serial.println("1: Te Deum");
      Serial.println("2: Für Elise");
      Serial.println("3: Ode an die Freude");
      Serial.println("4: Bolero");
      Serial.println("5: 5. Symphonie");
      Serial.println("6: Titel anzeigen");
      Serial.println("--------------------");     
    }
  }
}

void ZeigeTitel(String TitelSong) 
{
  // Teil des Strings bis zum ersten Doppelpunkt kürzen
  TitelSong = TitelSong.substring(0, TitelSong.indexOf(":"));

  // _ durch leerzeichen ersetzen
  TitelSong.replace("_", " ");

  // erster Teil des Strings bis zum / -> Name des Interpreten
  String Interpret = TitelSong.substring(0, TitelSong.indexOf("/"));

  // zweiter Teil des Strings vom / + 1 bis zum Ende des Strings -> Name des Titels
  String Titel = TitelSong.substring(TitelSong.indexOf("/") + 1, TitelSong.length());

  Serial.println("Spiele:");

  // Interpret anzeigen
  Serial.print(Interpret + " ");

  // Titel anzeigen
  Serial.println(Titel);
  Serial.println("---------------------------");
}

Juke­box mit Tas­ten­pad und LCD

# include <PlayRtttl.hpp>
# include <LiquidCrystal_I2C.h>

// Name des LCDs (lcd) festlegen
LiquidCrystal_I2C lcd(0x27, 20, 4);

# define Lautsprecher  7

// Variable für die gedrückte Taste des Tastenpads
int GedrueckteTaste;

String TitelSong;

char TeDeum[] =
"Charpentier/Te_Deum:d=4,o=5,b=63:8c,8f,16f,16g,8a,8f,c6,8a,8a,8a#,16c6,16a#,16a,16a#,8c6,16g,16f,16g,16a,8g,8c,8f,16f,16g,8a,8f,c6,8a,8a,16a#,16c6,16a,16a#,g,16f,2f";

char FuerElise[] =
"Beethoven/Für_Elise:d=8,o=5,b=125:32p,e6,d#6,e6,d#6,e6,b,d6,c6,4a.,32p,c,e,a,4b.,32p,e,g#,b,4c.6,32p,e,e6,d#6,e6,d#6,e6,b,d6,c6,4a.,32p,c,e,a,4b.,32p,d,c6,b,2a";

char OdeandieFreude[] =
"Beethoven/Ode_an_die_Freude:d=4,o=6,b=100:a5,a5,a_5,c,c,a_5,a5,g5,f5,f5,g5,a5,a.5,8g5,2g5,";

char Bolero[] =
"Ravel/Bolero:d=4,o=5,b=80:c6,8c6,16b,16c6,16d6,16c6,16b,16a,8c6,16c6,16a,c6,8c6,16b,16c6,16a,16g,16e,16f,2g,16g,16f,16e,16d,16e,16f,16g,16a,g,g,";

void setup()
{
  // LCD starten
  lcd.init();

  // Hintergrundbeleuchtung einschalten
  lcd.backlight();
}

void loop()
{
  // Tastenpad abfragen
  int Analogwert = analogRead(A0);
 
  // linke Taste;
  switch (Analogwert)
  {
    case 0 ... 20:
      // char-Array des Titels in String umwandeln
      TitelSong = String(TeDeum);

      // Funktion aufrufen, Interpret/Titel extrahieren
      ZeigeTitel(TitelSong);

      // Titel spielen
      playRtttlBlocking(Lautsprecher, TeDeum);
      break;

    // obere Taste
    case 30 ... 60:
      TitelSong = String(FuerElise);
      ZeigeTitel(TitelSong);
      playRtttlBlocking(Lautsprecher, FuerElise);
      break;

    // rechte Taste
    case 70 ... 120:
      TitelSong = String(OdeandieFreude);
      ZeigeTitel(TitelSong);
      playRtttlBlocking(Lautsprecher, OdeandieFreude);
      break;

    // untere Taste
    case 150 ... 200:
      TitelSong = String(Bolero);
      ZeigeTitel(TitelSong);
      playRtttlBlocking(Lautsprecher, Bolero);
      break;

    // rechte äußere Taste
    case 300 ... 400:
      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print("1: Te Deum");
      lcd.setCursor(0, 1);
      lcd.print("2: F\365r Elise");
      lcd.setCursor(0, 2);
      lcd.print("3: Ode an die Freude");
      lcd.setCursor(0, 3);
      lcd.print("4: Bolero");
      break;
  }
}

void ZeigeTitel(String TitelSong) 
{
  // Teil des Strings bis zum ersten Doppelpunkt kürzen
  TitelSong = TitelSong.substring(0, TitelSong.indexOf(":"));

  // _ durch leerzeichen ersetzen
  TitelSong.replace("_", " ");

  // erster Teil des Strings bis zum / -> Name des Interpreten
  String Interpret = TitelSong.substring(0, TitelSong.indexOf("/"));

  // zweiter Teil des Strings vom / + 1 bis zum Ende des Strings -> Name des Titels
  String Titel = TitelSong.substring(TitelSong.indexOf("/") + 1, TitelSong.length());

   // Titel auf dem LCD anzeigen
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Spiele:");
  lcd.setCursor(0, 1);
  lcd.print(Interpret);
  lcd.setCursor(0, 2);
  lcd.print(Titel);
}

Letzte Aktualisierung: Wei­ter lesen ...

Wet­ter­sta­ti­on CO2-Sen­sor MH-Z19C

# include <Arduino.h>
# include <MHZ19.h>
# include <SoftwareSerial.h>
# include <RTClib.h>
# include <DHT.h>
# include <LiquidCrystal_I2C.h>

// Name des LCDs (lcd) festlegen
LiquidCrystal_I2C lcd(0x27, 20, 4);

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

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

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

// Name des RTC-Moduls (rtc)
RTC_DS3231 rtc;

// RX/TX Pins zuordnen
# define RX 2
# define TX 3  

// Name des Moduls MH-Z19
MHZ19 MHZCO2;

// SoftwareSerial -> Name zuordnen
SoftwareSerial MHZSerial(RX, TX);

unsigned long VerstricheneZeit = 0;

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

  // LCD starten
  lcd.init();

  // Hintergrundbeleuchtung einschalten
  lcd.backlight();

  // Serielle Kommunikation MH-Z19C starten
  MHZSerial.begin(9600);
  MHZCO2.begin(MHZSerial);

  // automatische Kalibrierung ausschalten (false), einschalten mit true
  MHZCO2.autoCalibration(false);

  // RTC-Modul starten
  rtc.begin();

  // Datum/Zeit einmalig setzen, beim nächsten Starten auskommentieren
  // rtc.adjust(DateTime(2023, 4, 23, 8, 50, 30));

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

void loop() 
{
  // 5 Sekunden warten
  if (millis() - VerstricheneZeit >= 5000) 
  {
     // rtc.now() -> aktuelle Zeit holen
    DateTime aktuell = rtc.now();

    /*
      Datumsformat festlegen
      DD -> Tag mit führender 0
      MM -> Monat mit führender 0
      YYYY -> vollständige Angabe des Jahres
    */
    char Datum[] = "DD.MM.YYYY ";

    // Datum in Zeichenkette (String) umwandeln und anzeigen
    Serial.print(aktuell.toString(Datum));

    // Format der Zeitangabe festlegen
    char Zeit[] = "hh:mm:ss Uhr";

    // Zeitangabe in Zeichenkette (String) umwandeln und anzeigen
    Serial.println(aktuell.toString(Zeit));
    
    // Daten lesen
    // CO2-Wert MH-Z19C
    int CO2 = MHZCO2.getCO2();

    // Temperatur MH-Z19
    int TemperaturMHZ = MHZCO2.getTemperature();

    // Temperatur RTC ermitteln
    String TemperaturRTC = String(rtc.getTemperature());
    String AnzeigeTemperaturRTC = String(TemperaturRTC);
    AnzeigeTemperaturRTC.replace(".", ",");

    // Temperatur DHT
    float TemperaturDHT = dht.readTemperature();
    String AnzeigeTemperaturDHT = String(TemperaturDHT);
    AnzeigeTemperaturDHT.replace(".", ",");

    // Luftfeuchtigkeit DHT
    String AnzeigeLuftfeuchtigkeit = String(dht.readHumidity());
    AnzeigeLuftfeuchtigkeit.replace(".", ",");
    Serial.print("Messwert CO²: ");
    Serial.println(String(CO2) + " ppm");

    Serial.print("Temperatur MH-Z19: ");
    Serial.println(String(TemperaturMHZ) + "°C");

    Serial.print("Temperatur RTC: ");
    Serial.println(AnzeigeTemperaturRTC + "°C");

    Serial.print("Temperatur DHT: ");
    Serial.println(AnzeigeTemperaturDHT + "°C");
    Serial.println("----------------------");

    lcd.setCursor(0, 0);
    lcd.print(aktuell.toString(Zeit));
    lcd.setCursor(0, 1);
    lcd.print("CO2 " + String(CO2) + " ppm");
    lcd.setCursor(0, 2);
    lcd.print("Temperatur " + AnzeigeTemperaturDHT + "\337C");
    lcd.setCursor(0, 3);
    lcd.print("Feuchtigkeit " + AnzeigeLuftfeuchtigkeit + "%");
    
    VerstricheneZeit = millis();
  }
}

Letzte Aktualisierung: Wei­ter lesen ...

DHT22 Wet­ter­sta­ti­on LAN Daten speichern

# include <Ethernet.h>
# include <RTClib.h>
# include <DHT.h>
# include <SD.h>

// Bezeichnung der Textdatei
File Messung;

// Datenpin für das SD-Kartenmodul
int DatenPin = 4;

// Name des RTC-Moduls
RTC_DS3231 rtc;

// Sensorpin
int SENSOR_DHT = 8;

// Sensortyp festlegen
// DHT22
# define SensorTyp DHT22

// DHT11
// # define SensorTyp DHT11

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

// MAC-Adresse und IP definieren
byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};

// festeIP = false -> IP-Adresse über DHCP vergeben
bool festeIP = false;

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

// Name des Servers vergeben
EthernetServer server(80);

// Intervall in Millisekunden
// 600000 = 10 Minuten
// 3600000 = 60 Minuten
const long Intervall = 1200000;
const unsigned int Minuten = Intervall / 60000;

// Start der Zeitmessung
unsigned long StartZeit = 0;

void setup()
{
  // RTC-Modul starten
  rtc.begin();
  /*
    wenn Datum und Zeit nicht korrekt -> Datum/Zeit setzen
    Jahr, Monat, Tag, Stunde, Minute, Sekunde
    keine führende 0 setzen
    Beispiel:
    rtc.adjust(DateTime(2023, 3, 10, 7, 2, 30));
  */

  Serial.begin(9600);
  delay(500);

  // Ethernet starten feste IP
  if (festeIP) Ethernet.begin(mac, ip);

  // Ethernet starten DHCP
  else Ethernet.begin(mac);

  // Server starten
  server.begin();

  // zur Kontrolle IP-Adresse im Seriellen Monitor anzeigen
  // localIP -> Adresse, die im Browser eingegeben wird
  Serial.print(F("IP des Ethernet-Shields: "));
  Serial.println(Ethernet.localIP());

  // SD-Karte starten
  SD.begin(DatenPin);

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

void loop() 
{
  String Auswertung = "";

  // Variablen für Temperatur und Luftfeuchtigkeit
  float Temperatur;
  float Luftfeuchtigkeit;

  // auf Clienten warten ...
  EthernetClient Client = server.available();

  // abgelaufene Zeit mit millis() ermitteln
  unsigned long VerstricheneZeit = millis();

  // Zeit messen und Daten speichern, wenn das Zeitintervall erreicht ist
  if (VerstricheneZeit - StartZeit >= Intervall) 
  {
    // StartZeit zurücksetzen
    StartZeit = VerstricheneZeit;

    // Temperatur, Luftfeuchtigkeit messen
    Temperatur = dht.readTemperature();
    Luftfeuchtigkeit = dht.readHumidity();

    // aktuelle Zeit ermitteln
    DateTime aktuell = rtc.now();

    // in Datei speichern
    Messung = SD.open("Messung.txt", FILE_WRITE);
    if (Messung) 
    {
      // Datum schreiben
      char Datum[] = "DD.MM.YYYY";
      Messung.print(aktuell.toString(Datum));

      // Zeit schreiben
      char Zeit[] = " Uhrzeit: hh:mm:ss";
      Messung.println(aktuell.toString(Zeit));

      // Messdaten schreiben
      Messung.print(F(" | "));
      Messung.println(Temperatur);
      Messung.print(F(" &deg;C | "));
      Messung.println(Luftfeuchtigkeit);
      Messung.print(F("%"));
      Messung.println(F("<br>"));

      // Datei schließen
      Messung.close();
    }
  }

  // neue Anfrage
  if (Client) 
  {
    // solange der Client verbunden ist ...
    while (Client.connected()) 
    {
      if (Client.available()) 
      {
        char Zeichen = Client.read();

        /*
          einegegebene Zeichen zum String zusammensetzen
          der String enthält eines der Zeichen (l, s, e)
          Beispiel lesen:
          GET /l HTTP/1.1
        */
        Auswertung += Zeichen;

        // \n =return: Seite vom Clienten vollständig geladen
        if (Zeichen == '\n') 
        {
          // HTTP-Anforderung senden
          Client.println(F("HTTP/1.1 200 OK"));
          Client.println(F("Content-Type: text/html"));

          // Leerzeile zwingend erforderlich
          Client.println();

          /*
            HTML-Seite aufbauen
            die folgenden Anweisungen müssen
            mit print oder println gesendet werden
            println "verschönert" den Quelltext
            (jede Anweisung in einer eigenen Zeile)
          */
          Client.println(F("<!doctype html>"));
          Client.println(F("<html>"));
          Client.println(F("<body>"));

          // String Auswertung lesen
          // indexOf -> Vorhandensein eines Zeichens prüfen
          // Daten speichern
          if (Auswertung.indexOf("s") > 0) 
          {
            Temperatur = dht.readTemperature();
            Luftfeuchtigkeit = dht.readHumidity();
            DateTime aktuell = rtc.now();

            Messung = SD.open("Messung.txt", FILE_WRITE);

            // wenn die Datei vorhanden ist
            if (Messung) 
            {
              char Datum[] = "DD.MM.YYYY";
              Messung.print(aktuell.toString(Datum));

              // Zeit schreiben
              char Zeit[] = " Uhrzeit: hh:mm:ss";
              Messung.println(aktuell.toString(Zeit));
              Messung.print(F(" | "));
              
              // Temperatur und Luftfeuchtigkeit schreiben
              Messung.println(Temperatur);
              Messung.print(F(" &deg;C | "));
              Messung.println(Luftfeuchtigkeit);
              Messung.print(F("%"));
              Messung.println(F("<br>"));

              // Datei schließen
              Messung.close();
            }
          }

          // Datei lesen
          if (Auswertung.indexOf("l") > 0) 
          {
            Messung = SD.open("Messung.txt");
            if (Messung) 
            {
              // solange sich Zeilen in der Datei befinden ...
              while (Messung.available()) 
              {
                // ... werden sie gelesen und auf der Webseite ausgegeben
                Client.write(Messung.read());
              }

              // Datei schließen
              Messung.close();
            }
          }

          // Zeitintervall der Messungen anzeigen
          Client.println(F("<hr />"));
          Client.println(F("Intervall: "));
          Client.println(Minuten);
          Client.println(F("Minuten<br> "));
          Client.println(F("<hr />"));

          // Button anzeigen
          Client.print(F("<input type='button' "));
          Client.println(F(" onClick=\"location.href='l'\""));
          Client.println(F(" value='lesen'>"));
          Client.print(F("<input type='button' "));
          Client.println(F(" onClick=\"location.href='s'\""));
          Client.println(F(" value='schreiben'>"));

          Client.println(F("<hr />"));

          // IPs anzeigen
          Client.print(F("Eigene IP: "));
          Client.print(Client.remoteIP());
          Client.print(F("<br>IP des Ethernet-Shields: "));
          Client.print(Ethernet.localIP());
          Client.println(F("</body>"));
          Client.println(F("</html>"));

          // Zeit, um die Antwort zu übertragen
          delay(1);

          // Verbindung beenden
          Client.stop();
        }
      }
    }
  }
}

Letzte Aktualisierung: Wei­ter lesen ...

Tem­pe­ra­tur mes­sen AHT20 OLED

# include <U8g2lib.h>
# include <Adafruit_AHTX0.h>

// Namen des Sensors (aht) festlegen
Adafruit_AHTX0 aht;

// 1,3 Zoll SH1106
// U8G2_SH1106_128X64_NONAME_1_HW_I2C oled(U8G2_R0, U8X8_PIN_NONE);
// 0,96 Zoll SSD1306
U8G2_SSD1306_128X64_NONAME_1_HW_I2C oled(U8G2_R0, U8X8_PIN_NONE);


// Bild Thermometer: Breite und Höhe definieren
# define ThermometerBreite 21
# define ThermometerHoehe 64

// Array Bild Thermometer
static unsigned char Thermometer[] = 
{
  0xf0, 0x7f, 0x00, 0xf0, 0x7f, 0x00, 0x30, 0x60, 0x00, 0x30, 0x60, 0x00,
  0x30, 0x60, 0x00, 0x30, 0x60, 0x00, 0x30, 0x60, 0x00, 0x30, 0x60, 0x00,
  0x30, 0x60, 0x00, 0x30, 0x60, 0x00, 0x30, 0x60, 0x00, 0x30, 0x60, 0x00,
  0x30, 0x60, 0x00, 0xff, 0xff, 0x0f, 0x30, 0x60, 0x00, 0x30, 0x60, 0x00,
  0x30, 0x60, 0x00, 0x30, 0x60, 0x00, 0x30, 0x60, 0x00, 0x30, 0x60, 0x00,
  0x30, 0x60, 0x00, 0x30, 0x60, 0x00, 0x30, 0x60, 0x00, 0xff, 0xff, 0x0f,
  0x30, 0x60, 0x00, 0x30, 0x60, 0x00, 0x30, 0x60, 0x00, 0x30, 0x60, 0x00,
  0x30, 0x60, 0x00, 0x30, 0x60, 0x00, 0x30, 0x60, 0x00, 0x30, 0x60, 0x00,
  0x30, 0x60, 0x00, 0xff, 0xff, 0x0f, 0x30, 0x60, 0x00, 0x30, 0x60, 0x00,
  0x30, 0x60, 0x00, 0x30, 0x60, 0x00, 0x30, 0x60, 0x00, 0x30, 0x60, 0x00,
  0x30, 0x60, 0x00, 0x30, 0x60, 0x00, 0x30, 0x60, 0x00, 0xf0, 0x7f, 0x00,
  0xf0, 0x7f, 0x00, 0xf0, 0xff, 0x01, 0xf8, 0xe0, 0x03, 0xfc, 0xff, 0x07,
  0xfe, 0xff, 0x0f, 0x0e, 0x00, 0x0e, 0x07, 0x00, 0x1c, 0xff, 0xff, 0x1f,
  0xff, 0xff, 0x1f, 0x03, 0x00, 0x18, 0x03, 0x00, 0x18, 0xff, 0xff, 0x1f,
  0xff, 0xff, 0x1f, 0x07, 0x00, 0x1c, 0x0e, 0x00, 0x0e, 0xfe, 0xff, 0x0f,
  0xfc, 0xff, 0x07, 0xf8, 0xe0, 0x03, 0xf0, 0xff, 0x01, 0xc0, 0x7f, 0x00
};

void setup() 
{
  // Display starten
  oled.begin();

  // AHT starten
  aht.begin();

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

  // Farbe weiß setzen
  oled.setDrawColor(1);

  // Schriftart festlegen
  oled.setFont(u8g2_font_helvB14_tf);
}

void loop() 
{
  // Variablen für Temperatur und Luftfeuchtigkeit definieren
  sensors_event_t Feuchtigkeit, Temperatur;

  // Werte Temperatur und Luftfeuchtigkeit erfassen
  aht.getEvent(&Feuchtigkeit, &Temperatur);  
  
  oled.firstPage();
  do 
  {
    // Thermometer anzeigen
    oled.drawXBM(10, 1, ThermometerBreite, ThermometerHoehe, Thermometer);
  
    // . durch , ersetzen    
    String AnzeigeTemperatur = PunktErsetzen(String(Temperatur.temperature));
    String AnzeigeLuftfeuchtigkeit = PunktErsetzen(String(Feuchtigkeit.relative_humidity));

    // Werte auf dem OLED anzeigen
    oled.setCursor(40, 20);
    oled.print(AnzeigeTemperatur +  " " +char(176) + "C");

    oled.setCursor(40, 50);
    oled.print(AnzeigeLuftfeuchtigkeit + " %");
  } 
  while (oled.nextPage());

  delay(2000);
}

// Funktion . durch , ersetzen
String PunktErsetzen(String ErsatzString) 
{
  ErsatzString.replace(".", ",");
  return ErsatzString;
}

Letzte Aktualisierung: Wei­ter lesen ...

Far­be und Hel­lig­keit LED-Strei­fen Potentiometer

# include <Adafruit_NeoPixel.h>

// Pin des LED-Streifens
# define STREIFEN 8

// Anzahl der LEDs -> muss angepasst werden
# define AnzahlLED 15

// Poti an A0
# define PotiFarbe A1
# define PotiHelligkeit A0
/*
  Initialisierung des LED-Streifens
  Parameter:
  LED-Streifen -> Name des LED-Streifens
  AnzahlLED -> Anzahl der LEDs
  STREIFEN -> verwendeter Pin
  NEO_GRB + NEO_KHZ800 -> Typ des verwendeten LED-Streifens
*/
Adafruit_NeoPixel LEDStreifen = Adafruit_NeoPixel(AnzahlLED, STREIFEN, NEO_GRB + NEO_KHZ800);

// Farben in RGB-Schreibweise definieren
# define ROT LEDStreifen.Color(255, 0, 0)
# define ROSA LEDStreifen.Color(255, 50, 100)

# define BLAU LEDStreifen.Color(0, 0, 255)
# define HELLBLAU LEDStreifen.Color(100, 100, 255)

# define GRUEN LEDStreifen.Color(0, 255, 0)
# define HELLGRUEN LEDStreifen.Color(0, 100, 153)

# define GELB LEDStreifen.Color(255, 255, 0)
# define ORANGE LEDStreifen.Color(200, 50, 0)

# define PINK LEDStreifen.Color(255, 20, 147)
# define MAGENTA LEDStreifen.Color(139, 0, 139)


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

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

void loop() 
{
  // LEDs löschen
  LEDStreifen.clear();

  /*
    PotiHelligkeit abfragen
    map -> Bereich von 0 bis 1023 
    (dem mit analogRead gelesenen Wert des Potentiometers)
    auf 0 bis 255 übertragen
    (Helligkeit des LED-Streifens)
  */
  int Helligkeit = map(analogRead(PotiHelligkeit), 0, 1023, 0, 255);

  // Helligkeit setzen
  LEDStreifen.setBrightness(Helligkeit);

  /*
   PotiFarbe abfragen
   Bereich 0 bis 1023
   Bereiche festlegen -> nach jeweils 128 Werten neue Farbe
  */
  switch (analogRead(PotiFarbe)) 
  {
    case 0 ... 128:
      LEDStreifen.fill(ROSA, 0, AnzahlLED);
      LEDStreifen.show();
      break;

    case 129 ... 256:
      LEDStreifen.fill(ROT, 0, AnzahlLED);
      LEDStreifen.show();
      break;

    case 257 ... 384:
      LEDStreifen.fill(HELLBLAU, 0, AnzahlLED);
      LEDStreifen.show();
      break;

    case 385 ... 512:
      LEDStreifen.fill(BLAU, 0, AnzahlLED);
      LEDStreifen.show();
      break;

    case 513 ... 640:
      LEDStreifen.fill(HELLGRUEN, 0, AnzahlLED);
      LEDStreifen.show();
      break;

    case 641 ... 768:
      LEDStreifen.fill(GRUEN, 0, AnzahlLED);
      LEDStreifen.show();
      break;
      
    case 769 ... 896:
      LEDStreifen.fill(GELB, 0, AnzahlLED);
      LEDStreifen.show();
      break;

    case 897 ... 1023:
      LEDStreifen.fill(ORANGE, 0, AnzahlLED);
      LEDStreifen.show();
      break;

    default:
      LEDStreifen.clear();
  }
}

Letzte Aktualisierung: Wei­ter lesen ...

LEDs mit einem Tas­ter steu­ern - Lösung mit Button2

# include <Button2.h>

int TASTER_PIN = 13;

# define LEDMax 5

// Array für die LEDs
int LED[LEDMax] = { 3, 4, 5, 6, 7 };

// Name des Tasters
Button2 Taster;

// LEDs sind beim Start ausgeschaltet
bool Status = LOW;

void setup() 
{
  // LEDs als OUTPUT setzen
  for (int i = 0; i < LEDMax; i++) 
  {
    pinMode(LED[i], OUTPUT);
  }

  Taster.begin(TASTER_PIN);
  Taster.setLongClickTime(1000);
  Taster.setDoubleClickTime(400);

  Taster.setClickHandler(click);
  Taster.setLongClickDetectedHandler(longClickDetected);
  Taster.setLongClickHandler(longClickDetected);
  Taster.setDoubleClickHandler(doubleClick);
}

void loop() 
{
  Taster.loop();
}

void click(Button2& btn) {
  /*
    Status == true (1) -> einschalten
    Status == false (0) -> ausschalten
    Status umkehren
  */
  Status = !Status;
  for (int i = 0; i <= LEDMax; i++) {
    // aktuelle LED i ein- oder ausschalten
    digitalWrite(LED[i], Status);
  }
}

void doubleClick(Button2& btn) 
{
  for (int i = 0; i <= LEDMax; i++) 
  {
    // aktuelle LED i einschalten
    digitalWrite(LED[i], HIGH);
    delay(200);

    // aktuelle LED i ausschalten
    digitalWrite(LED[i], LOW);
  }

  // ...und zurück
  for (int i = LEDMax; i >= 0; i--) 
  {
    // aktuelle LED i einschalten
    digitalWrite(LED[i], HIGH);
    delay(200);

    // aktuelle LED i ausschalten
    digitalWrite(LED[i], LOW);
  }
}

void longClickDetected(Button2& btn) 
{
  // alle LEDs blinken 5-mal
  // d -> Anzahl der Durchläufe
  for (int d = 0; d <= 5; d++) 
  {
    // einschalten
    for (int i = 0; i <= LEDMax; i++) 
    {
      digitalWrite(LED[i], HIGH);
    }
    delay(200);
    
    // ausschalten
    for (int i = 0; i < 5; i++) 
    {
      digitalWrite(LED[i], LOW);
    }
    
    delay(200);
  }
}

Letzte Aktualisierung: Wei­ter lesen ...

Lauf­licht mit Inter­rupt und Taster

// Bibliothek Bounce einbinden
# include <Bounce2.h>

// Bounce starten
// Namen des Objekts Bounce (TasterGedrueckt) festlegen
Bounce TasterGedrueckt = Bounce();

// Pin für den Auslöser des Interrupts
int TASTER = 2;

// Array mit 5 Elementen und den zugehörigen Pins
// wenn LEDs hinzugefügt werden -> Größe des Arrays in [...] anpassen
int LED[5] = { 3, 4, 5, 6, 7 };

// Anzahl der LEDs feststellen
int LEDMax = sizeof(LED) / sizeof(LED[0]);

// Leuchtdauer der LEDs
int Leuchtdauer = 100;

// Variable im Flash-Speicher ablegen
volatile bool LEDStatus = true;

void setup() 
{
  // pinMode Taster INPUT_PULLUP -> Vorwiderstand einschalten
  pinMode(TASTER, INPUT_PULLUP);

  // pinMode LEDs
  for (int i = 0; i < LEDMax; i++) {
    pinMode(LED[i], OUTPUT);
  }
  // Funktion Schalten() dem Interrupt-Pin zuordnen
  attachInterrupt(digitalPinToInterrupt(TASTER), Schalten, FALLING);
  TasterGedrueckt.attach(TASTER, INPUT_PULLUP);
}

void loop() 
{
  // Taster abfragen
  /*
    solange der Status true ist, wird die while-Schleife
    ausgeführt, ein weiterer Druck auf eine Taste der Fernbedienung löst
    den Interrupt aus
    -> Status wird zu false, die while-Schleife wird nicht erneut ausgeführt
    allerdings wird der aktuelle Durchlauf erst beendet
  */
  if (TasterGedrueckt.update()) 
  {
    // Taster wurde gedrückt, das Signal ist gefallen
    if (TasterGedrueckt.fell()) 
    {
      LEDStatus = true;

      /*
        solange der Status true ist, wird die while-Schleife
        ausgeführt, ein weiterer Druck auf eine Taste der Fernbedienung löst
        den Interrupt aus
        -> Status wird zu false, die while-Schleife wird nicht erneut ausgeführt
        allerdings wird der aktuelle Durchlauf erst beendet
      */
      while (LEDStatus) LauflichtHinUndHer();
    }
  }
}

// der Interrupt durch den Taster setzt den LEDStatus auf false
void Schalten() 
{
  LEDStatus = false;
}

void LauflichtHin() 
{
  for (int i = 0; i < LEDMax; i++) 
  {
    digitalWrite(LED[i], HIGH);
    delay(Leuchtdauer);
    digitalWrite(LED[i], LOW);
  }
}

void LauflichtHinUndHer() 
{
  for (int i = 0; i < LEDMax; i++) 
  {
    digitalWrite(LED[i], HIGH);
    delay(Leuchtdauer);
    digitalWrite(LED[i], LOW);
  }

  // und wieder zurück
  for (int i = LEDMax - 1; i >= 0; i--) 
  {
    digitalWrite(LED[i], HIGH);
    delay(Leuchtdauer);
    digitalWrite(LED[i], LOW);
  }
}

Letzte Aktualisierung: Wei­ter lesen ...