Wet­ter­sta­ti­on mit UNO R4 WiFi und LCD

#include "DHT.h"
#include "WiFiS3.h"
#include "NTP.h"
#include "LCDIC2.h"

LCDIC2 lcd(0x27, 20, 4);

// Pin des Sensors
int SENSOR_DHT = 7;

// DHT11
// # define SensorTyp DHT11

// DHT22
#define SensorTyp DHT22

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

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

WiFiUDP wifiUdp;
NTP ntp(wifiUdp);

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

// 60 Sekunden Intervall, kann angepasst werden
int Intervall = 60000;

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

  delay(1000);

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

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

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

  // IP des Arduinos anzeigen
  Serial.print("IP Adresse Arduino DHCP: ");
  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();

  // Zeit holen
  ntp.update();

  dht.begin();

  // beim Start Daten ausgeben
  // Serieller Monitor
  String Temperatur = String(dht.readTemperature());
  Temperatur.replace(".", ",");
  Serial.print("Temperatur:");
  Serial.println(Temperatur + " °C");

  // Luftfeuchtigkeit
  String Luftfeuchtigkeit = String(dht.readHumidity());
  Luftfeuchtigkeit.replace(".", ",");
  Serial.print("Luftfeuchtigkeit: ");
  Serial.println(Luftfeuchtigkeit + " %");

  lcd.setCursor(0, 0);

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

  Serial.print(", ");

  // Zeit mit formatedTime() anzeigen:
  // %d = Tag, %m = Monat, %Y = Jahr, %T = Zeit in Stunden, Minuten, Sekunden
  Serial.println(ntp.formattedTime("%d.%m.%Y Uhrzeit: %T"));

  lcd.setCursor(0, 1);

  String Zeit = ntp.formattedTime("%d.%m.%Y %T");

  // String Zeit nch Minuten kürzen
  lcd.print(Zeit.substring(0, Zeit.indexOf(":") + 3));
  lcd.setCursor(0, 2);
  lcd.print(Temperatur + " \337C");
  lcd.setCursor(0, 3);
  lcd.print(Luftfeuchtigkeit + " %");

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

void loop() 
{

  // Startzeit setzen
  Startzeit = millis();

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

    // Startzeit zurücksetzen
    GesicherteStartZeit = Startzeit;

    // Zeit holen
    ntp.update();
    Serial.println("Temperatur und Luftfeuchtigkeit messen");
    Serial.println("Letzte Messung: ");

    // formatedTime() zeigt Wochentage in englischer Sprache
    // -> müssen einzeln abgefragt werden

    lcd.setCursor(0, 0);
    switch (ntp.weekDay()) 
    {
      case 0:
        Serial.print("Sonntag");
        lcd.print("Sonntag");
        break;
      case 1:
        Serial.print("Montag");
        lcd.print("Montag");
        break;
      case 2:
        Serial.print("Dienstag");
        lcd.print("Dienstag");
        break;
      case 3:
        Serial.print("Mittwoch");
        lcd.print("Mittwoch");
        break;
      case 4:
        Serial.print("Donnerstag");
        lcd.print("Donnerstag");
        break;
      case 5:
        Serial.print("Freitag");
        lcd.print("Freitag");
        break;
      case 6:
        Serial.print("Samstag");
        lcd.print("Samstag");
        break;
    }

    Serial.print(", ");
    Serial.println(ntp.formattedTime("%d.%m.%Y Uhrzeit: %T"));

    // Temperatur
    String Temperatur = String(dht.readTemperature());
    Temperatur.replace(".", ",");
    Serial.print("Temperatur:");
    Serial.println(Temperatur + " °C");

    // Luftfeuchtigkeit
    String Luftfeuchtigkeit = String(dht.readHumidity());
    Luftfeuchtigkeit.replace(".", ",");
    Serial.print("Luftfeuchtigkeit: ");
    Serial.println(Luftfeuchtigkeit + " %");

    // Ausgabe LCD
    lcd.setCursor(0, 1);
    String Zeit = ntp.formattedTime("%d.%m.%Y %T");

    // String Zeit nach Minuten kürzen
    lcd.print(Zeit.substring(0, Zeit.indexOf(":") + 3));
    lcd.setCursor(0, 2);
    lcd.print(Temperatur + " \337C");
    lcd.setCursor(0, 3);
    lcd.print(Luftfeuchtigkeit + " %");
  }
}

Letzte Aktualisierung: Wei­ter lesen ...

Datum/Zeit und Mess­da­ten DHT-Sen­sor mit R4 WiFi auf einem LCD anzeigen

# include "DHT.h"
# include "WiFiS3.h"
# include "NTP.h"
# include "LCDIC2.h"

LCDIC2 lcd(0x27, 20, 4);

// Pin des Sensors
int SENSOR_DHT = 7;

// DHT11
// # define SensorTyp DHT11

// DHT22
#define SensorTyp DHT22

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

// SSID und Passwort des Routers
char Router[] = "FRITZ!Box 7590 LB";
char Passwort[] = "anea1246";
int Status = WL_IDLE_STATUS;

WiFiUDP wifiUdp;
NTP ntp(wifiUdp);

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

// 60 Sekunden Intervall, kann angepasst werden
int Intervall = 60000;

void setup() 
{
  lcd.begin();
  lcd.setBacklight(true);
  Serial.begin(9600);
  while (!Serial) { ; }

  delay(1000);

  // Verbindung aufbauen
  if (WiFi.status() == WL_NO_MODULE) 
  {
    Serial.println(F("Verbindungsaufbau gescheitert!"));
  }

  Serial.print("Verbindung aufbauen mit ");
  Serial.println(Router);
  while (Status != WL_CONNECTED) 
  {
    Status = WiFi.begin(Router, Passwort);

    // Zeit für den Verbindungsaufbau
    // wenn die Verbindung nicht zustandekommt -> Zeit vergrößern
    delay(500);
  }

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

  // IP des Arduinos anzeigen
  Serial.print("IP Adresse Arduino DHCP: ");
  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();

  // Zeit holen
  ntp.update();

  // Zeit mit formatedTime() anzeigen:
  // %d = Tag, %m = Monat, %Y = Jahr, %T = Zeit in Stunden, Minuten, Sekunden
  Serial.println(ntp.formattedTime("%d.%m.%Y Uhrzeit: %T"));
  dht.begin();

  // beim Start Daten ausgeben
  // Serieller Monitor
  String Temperatur = String(dht.readTemperature());
  Temperatur.replace(".", ",");
  Serial.print("Temperatur:");
  Serial.println(Temperatur + " °C");

  // Luftfeuchtigkeit
  String Luftfeuchtigkeit = String(dht.readHumidity());
  Luftfeuchtigkeit.replace(".", ",");
  Serial.print("Luftfeuchtigkeit: ");
  Serial.println(Luftfeuchtigkeit + " %");

  lcd.setCursor(0, 0);

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

  lcd.setCursor(0, 1);
  lcd.print(ntp.formattedTime("%d.%m.%Y %T"));
  lcd.setCursor(0, 2);
  lcd.print(Temperatur + " \337C");
  lcd.setCursor(0, 3);
  lcd.print(Luftfeuchtigkeit + " %");

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

void loop() 
{

  // Startzeit setzen
  Startzeit = millis();

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

    // Startzeit zurücksetzen
    GesicherteStartZeit = Startzeit;

    // Zeit holen
    ntp.update();
    Serial.println("Temperatur und Luftfeuchtigkeit messen");
    Serial.println("Letzte Messung: ");

    // formatedTime() zeigt Wochentage in englischer Sprache
    // -> müssen einzeln abgefragt werden

    lcd.setCursor(0, 0);
    switch (ntp.weekDay()) 
    {
      case 0:
        Serial.print("Sonntag");
        lcd.print("Sonntag");
        break;
      case 1:
        Serial.print("Montag");
        lcd.print("Montag");
        break;
      case 2:
        Serial.print("Dienstag");
        lcd.print("Dienstag");
        break;
      case 3:
        Serial.print("Mittwoch");
        lcd.print("Mittwoch");
        break;
      case 4:
        Serial.print("Donnerstag");
        lcd.print("Donnerstag");
        break;
      case 5:
        Serial.print("Freitag");
        lcd.print("Freitag");
        break;
      case 6:
        Serial.print("Samstag");
        lcd.print("Samstag");
        break;
    }

    Serial.print(", ");
    Serial.println(ntp.formattedTime("%d.%m.%Y Uhrzeit: %T"));

    // Temperatur
    String Temperatur = String(dht.readTemperature());
    Temperatur.replace(".", ",");
    Serial.print("Temperatur:");
    Serial.println(Temperatur + " °C");

    // Luftfeuchtigkeit
    String Luftfeuchtigkeit = String(dht.readHumidity());
    Luftfeuchtigkeit.replace(".", ",");
    Serial.print("Luftfeuchtigkeit: ");
    Serial.println(Luftfeuchtigkeit + " %");

    // Ausgabe LCD
    lcd.setCursor(0, 1);
    lcd.print(ntp.formattedTime("%d.%m.%Y %T"));
    lcd.setCursor(0, 2);
    lcd.print(Temperatur + " \337C");
    lcd.setCursor(0, 3);
    lcd.print(Luftfeuchtigkeit + " %");
  }
}

Letzte Aktualisierung: Wei­ter lesen ...

Licht schal­ten mit Bewe­gungs­mel­der und Lichtinsitätssensor/oder Fotozelle

// Definition der Variablen
int LICHTSENSOR = A0;
int LED = 8;
int BEWEGUNGSMELDER = 7;

// TEMT6000
int SchwelleDunkelheit = 30;

// Fotozelle
// int SchwelleDunkelheit = 400;

void setup() 
{
 Serial.begin(9600);
 pinMode(LED, OUTPUT);
 pinMode(BEWEGUNGSMELDER, INPUT); 
}

void loop() 
{
  // Kommentarzeichen in den Zeilen 23 - 25 entfernen
  // um den Wert für SchwelleDunkelheit anzupassen
  // Serial.print("Gemessener Wert an A0: "); 
  // Serial.println(analogRead(LICHTSENSOR));
  // delay(500);

  if (digitalRead(BEWEGUNGSMELDER) && analogRead(LICHTSENSOR) < SchwelleDunkelheit) 
  {
    digitalWrite(LED, HIGH);
  }
  
  else digitalWrite(LED, LOW);
}

Letzte Aktualisierung: Wei­ter lesen ...

Licht­sen­sor TEM6000 mit Bewegungsmelder

int TEMT6000 = A0;
int LED = 8;
int BEWEGUNGSMELDER = 7;
int SchwelleDunkelheit = 50;

void setup() 
{
 Serial.begin(9600);
 pinMode(LED, OUTPUT);
 pinMode(BEWEGUNGSMELDER, INPUT); 
}

void loop() 
{
  if (digitalRead(BEWEGUNGSMELDER) && analogRead(TEMT6000) < SchwelleDunkelheit) digitalWrite(LED, HIGH);
  else digitalWrite(LED, LOW);
}

Letzte Aktualisierung: Wei­ter lesen ...

Wet­ter­sta­ti­on DHT11/DHT22 und UNO R4 WiFi

#include "DHT.h"
#include "WiFiS3.h"
#include "NTP.h"

// Pin des Sensors
int SENSOR_DHT = 7;

// DHT11
# define SensorTyp DHT11

// DHT22
// # define SensorTyp DHT22

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

// SSID und Passwort des Routers
char Router[] = "Router_SSID";
char Passwort[] = "xxxxxxxx";
int Status = WL_IDLE_STATUS;
WiFiServer WiFiServer(80);
WiFiClient WiFiClient;
WiFiUDP wifiUdp;
NTP ntp(wifiUdp);

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

  // Verbindung aufbauen
  WiFi.begin(Router, Passwort);
  if (WiFi.status() == WL_NO_MODULE) 
  {
    Serial.println(F("Verbindungsaufbau gescheitert!"));
  }
  Serial.print("Verbindung aufbauen mit ");
  Serial.println(Router);

  // Webserver starten
  WiFiServer.begin();

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

  // IP des Arduinos anzeigen
  Serial.print("IP Adresse Arduino DHCP: ");
  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();

  // Zeit holen
  ntp.update();

  // Zeit mit formatedTime() anzeigen:
  // %d = Tag, %m = Monat, %Y = Jahr, %T = Zeit in Stunden, Minuten, Sekunden
  Serial.println(ntp.formattedTime("%d.%m.%Y Uhrzeit: %T"));
  dht.begin();
}

void loop()
{
  WiFiClient = WiFiServer.available();
  if (WiFiClient) 
  {
    // Seite aufbauen wenn SeiteAufbauen true ist
    boolean SeiteAufbauen = true;
    while (WiFiClient.connected())
    {
      if (WiFiClient.available())
      {
        char Zeichen = WiFiClient.read();
        if (Zeichen == '\n' && SeiteAufbauen)
        {
          // HTTP-Anforderung senden
          WiFiClient.println("HTTP/1.1 200 OK");
          WiFiClient.println("Content-Type: text/html");
          // Leerzeile zwingend erforderlich
          WiFiClient.println();

          /*
            HTML-Seite aufbauen
            die folgenden Anweisungen müssen mit print oder println gesendet werden
            println "verschönert" den Quelltext
            " muss mit \" maskiert werden
          */
          WiFiClient.println("<!doctype html>");
          WiFiClient.println("<html>");
          WiFiClient.println("<body>");

          // alle 60 Sekunden aktualisieren mit meta-Tag
          WiFiClient.println("<meta http-equiv=\"refresh\" content=\"60\">");
          WiFiClient.println("<h1> Temperatur und Luftfeuchtigkeit messen</h1>");
          WiFiClient.println("<hr />");
          WiFiClient.print("<h2>Letzte Messung: ");

          // formatedTime() zeigt Wochentage in englischer Sprache
          // -> müssen einzeln abgefragt werden
          switch (ntp.weekDay())
          {
            case 0:
              WiFiClient.print("Sonntag");
              break;
            case 1:
              WiFiClient.print("Montag");
              break;
            case 2:
              WiFiClient.print("Dienstag");
              break;
            case 3:
              WiFiClient.print("Mittwoch");
              break;
            case 4:
              WiFiClient.print("Donnerstag");
              break;
            case 5:
              WiFiClient.print("Freitag");
              break;
            case 6:
              WiFiClient.print("Samstag");
              break;
          }
          WiFiClient.print(", ");
          WiFiClient.print(ntp.formattedTime("%d.%m.%Y Uhrzeit: %T"));
          WiFiClient.println("</h2>");
          WiFiClient.println("<hr />");

          // Temperatur
          String Temperatur = String(dht.readTemperature());
          Temperatur.replace(".", ",");
          WiFiClient.print("<b>Temperatur:</b><blockquote>");
          WiFiClient.println(Temperatur + " °C</blockquote>");

          WiFiClient.println("<br>");

          // Luftfeuchtigkeit
          String Luftfeuchtigkeit = String(dht.readHumidity());
          Luftfeuchtigkeit.replace(".", ",");
          WiFiClient.print("<b>Luftfeuchtigkeit:</b><blockquote>");
          WiFiClient.println(Luftfeuchtigkeit + " %</blockquote>");
          WiFiClient.println("<br>");
         
          WiFiClient.println("<hr>");
          WiFiClient.println("<form>");

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

          // IPs anzeigen
          WiFiClient.print(F("<b>Eigene IP: "));
          WiFiClient.print(WiFiClient.remoteIP());
          WiFiClient.print(F("</b>"));
          WiFiClient.print(F("<br><b>IP Klient: "));
          WiFiClient.print(WiFi.localIP());
          WiFiClient.print(F("</b>"));
          WiFiClient.println("</b>");
          WiFiClient.println("</body>");
          WiFiClient.print("</html>");
          
          // HTTP-Antwort endet mit neuer Zeile
          WiFiClient.println();
          
          // Seite vollständig geladen -> loop verlassen
          break;
        }
        if (Zeichen == '\n') SeiteAufbauen = true;
        else if (Zeichen != '\r') SeiteAufbauen = false;
      }
    }
    delay(1);
    WiFiClient.stop();
  }
}

Letzte Aktualisierung: Wei­ter lesen ...

Wet­ter­sta­ti­on BME280 mit UNO R4 Wifi

#include "Wire.h"
#include "SPI.h"
#include "Adafruit_Sensor.h"
#include "Adafruit_BME280.h"
#include "WiFiS3.h"
#include "NTP.h"

// Luftdruck auf Meereshöhe
#define LuftdruckMeeresHoehe (1013.25)
Adafruit_BME280 bme;

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

int Status = WL_IDLE_STATUS;
WiFiServer WiFiServer(80);

WiFiClient WiFiClient;
WiFiUDP wifiUdp;
NTP ntp(wifiUdp);

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

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

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

  // Webserver starten
  WiFiServer.begin();

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

  // IP des Arduinos anzeigen
  Serial.print("IP Adresse Arduino DHCP: ");
  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();

  // Zeit holen
  ntp.update();

  // Zeit mit formatedTime() anzeigen:
  // %d = Tag, %m = Monat, %Y = Jahr, %T = Zeit in Stunden, Minuten, Sekunden
  Serial.println(ntp.formattedTime("%d.%m.%Y Uhrzeit: %T"));

  // I2C über SCL/SDA oder A5/A4
  // if (!bme.begin()

  // I2C über QWIIC-Verbindung
  // Adresse und Wire1-Bus
  if (!bme.begin(0x77, &Wire1)) 
  {
    Serial.println("Kein BME280-Modul gefunden");
    while (true);
  } 
  else Serial.println("BME280-Modul gefunden");

  Serial.println();
}

void loop() 
{
  WiFiClient = WiFiServer.available();

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

    while (WiFiClient.connected()) 
    {
      if (WiFiClient.available()) 
      {
        char Zeichen = WiFiClient.read();
        if (Zeichen == '\n' && SeiteAufbauen) 
        {
          // HTTP-Anforderung senden
          WiFiClient.println("HTTP/1.1 200 OK");
          WiFiClient.println("Content-Type: text/html");

          // Leerzeile zwingend erforderlich
          WiFiClient.println();

          /*
              HTML-Seite aufbauen
              die folgenden Anweisungen müssen mit print oder println gesendet werden
              println "verschönert" den Quelltext
              " muss mit \" maskiert werden
            */
          WiFiClient.println("<!doctype html>");
          WiFiClient.println("<html>");
          WiFiClient.println("<body>");

          // alle 60 Sekunden aktualisieren mit meta-Tag
          WiFiClient.println("<meta http-equiv=\"refresh\" content=\"60\">");
          WiFiClient.println("<h1> Temperatur und Luftfeuchtigkeit messen</h1>");
          WiFiClient.println("<hr />");
          WiFiClient.print("<h2>Letzte Messung: ");

          // Zeit aktualisieren
          ntp.update();

          // formatedTime() zeigt Wochentage in englischer Sprache
          // -> müssen einzeln abgefragt werden
          switch (ntp.weekDay()) 
          {
            case 0:
              WiFiClient.print("Sonntag");
              break;
            case 1:
              WiFiClient.print("Montag");
              break;
            case 2:
              WiFiClient.print("Dienstag");
              break;
            case 3:
              WiFiClient.print("Mittwoch");
              break;
            case 4:
              WiFiClient.print("Donnerstag");
              break;
            case 5:
              WiFiClient.print("Freitag");
              break;
            case 6:
              WiFiClient.print("Samstag");
              break;
          }
          WiFiClient.print(", ");
          WiFiClient.print(ntp.formattedTime("%d.%m.%Y Uhrzeit: %T"));

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

          // Temperatur
          String Temperatur = String(bme.readTemperature());
          Temperatur.replace(".", ",");
          WiFiClient.print("<b>Temperatur:</b><blockquote>");
          WiFiClient.println(Temperatur + " &deg;C</blockquote>");
          WiFiClient.println("<br>");

          // Luftfeuchtigkeit
          String Luftfeuchtigkeit = String(bme.readHumidity());
          Luftfeuchtigkeit.replace(".", ",");
          WiFiClient.print("<b>Luftfeuchtigkeit:</b><blockquote>");
          WiFiClient.println(Luftfeuchtigkeit + " %</blockquote>");
          WiFiClient.println("<br>");

          // Luftdruck
          String Luftdruck = String(bme.readPressure() / 100);
          Luftdruck.replace(".", ",");
          WiFiClient.print("<b>Luftdruck:</b><blockquote>");
          WiFiClient.println(Luftdruck + " hPa</blockquote>");
          WiFiClient.println("<br>");

          // Höhe
          String Hoehe = String(bme.readAltitude(LuftdruckMeeresHoehe));
          Hoehe.replace(".", ",");
          WiFiClient.println("<b>Ungef&auml;hre H&ouml;he:</b><blockquote>");

          WiFiClient.println(Hoehe + " m</blockquote>");
          WiFiClient.println("<hr>");

          WiFiClient.println("<form>");

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

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

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

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

        if (Zeichen == '\n') SeiteAufbauen = true;
        else if (Zeichen != '\r') SeiteAufbauen = false;
      }
    }
    delay(1);

    WiFiClient.stop();
  }
}

Letzte Aktualisierung: Wei­ter lesen ...

Far­ben­spie­le RGB-LED

RGB-LED auto­ma­tisch dimmen

Ardui­no

// Farbe rot an Pin 11
int LEDrot = 11;

// Farbe grün an Pin 10
int LEDgruen = 10;

// Farbe blau an Pin 9
int LEDblau = 9;

void setup() 
{   
  pinMode(LEDrot, OUTPUT);
  pinMode(LEDgruen, OUTPUT); 
  pinMode(LEDblau, OUTPUT); 
} 

void loop() 
{ 
  analogWrite(LEDrot, 255); 
  delay(1000); 
  analogWrite(LEDrot, 0); 
  analogWrite(LEDgruen, 255);
  delay(1000); 
  analogWrite(LEDgruen, 0);  
  analogWrite(LEDblau, 255); 
  delay(1000); 
  analogWrite(LEDblau, 0); 
}

Wemos D1 Mini

int LEDrot = D1; 
int LEDgruen = D2;
int LEDblau = D3;  

void setup() 
{ 
  pinMode (LEDblau, OUTPUT);
  pinMode(LEDgruen, OUTPUT); 
  pinMode(LEDrot, OUTPUT); 
}

void loop()
{
  // rot heller
  for (int i = 0; i < 250; i += 10)  
  { 
    analogWrite(LEDrot, i);  
    delay(200);   
  }
  
  // rot dunkler
  for (int i = 250; i > 0; i -= 10)  
  { 
    analogWrite(LEDrot, i);  
    delay(200);   
  }

  // grün heller
  for (int i = 0; i < 250; i += 10)  
  { 
    analogWrite(LEDgruen, i);  
    delay(200);   
  }
  
  // grün dunkler
  for (int i = 250; i > 0; i -= 10)  
  { 
    analogWrite(LEDgruen, i);  
    delay(200);   
  }

   // blau heller
  for (int i = 0; i < 250; i += 10)  
  { 
    analogWrite(LEDblau, i);  
    delay(200);   
  }
  
  // blau dunkler
  for (int i = 250; i > 0; i -= 10)  
  { 
    analogWrite(LEDblau, i);  
    delay(200);   
  }
}

ESP32-Wroom

int LEDrot = 19; 
int LEDgruen = 18;
int LEDblau = 5;  

void setup() 
{ 
  pinMode (LEDblau, OUTPUT);
  pinMode(LEDgruen, OUTPUT); 
  pinMode(LEDrot, OUTPUT); 
}

void loop()
{
  // rot heller
  for (int i = 0; i < 250; i += 10)  
  { 
    analogWrite(LEDrot, i);  
    delay(200);   
  }
  
  // rot dunkler
  for (int i = 250; i > 0; i -= 10)  
  { 
    analogWrite(LEDrot, i);  
    delay(200);   
  }

  // grün heller
  for (int i = 0; i < 250; i += 10)  
  { 
    analogWrite(LEDgruen, i);  
    delay(200);   
  }
  
  // grün dunkler
  for (int i = 250; i > 0; i -= 10)  
  { 
    analogWrite(LEDgruen, i);  
    delay(200);   
  }

   // blau heller
  for (int i = 0; i < 250; i += 10)  
  { 
    analogWrite(LEDblau, i);  
    delay(200);   
  }
  
  // blau dunkler
  for (int i = 250; i > 0; i -= 10)  
  { 
    analogWrite(LEDblau, i);  
    delay(200);   
  }
}

Mit Tas­ter dimmen

int LEDblau = 9; 
int LEDgruen = 10; 
int LEDrot = 11; 

int TASTER_ROT = 5;   // Taste 1 
int TASTER_GRUEN = 4; // Taste 2 
int TASTER_BLAU = 7;  // Taste 3 

// die Farben 
int rot = 0; 
int gruen = 0; 
int blau = 0;

void setup() 
{ 
  pinMode (LEDblau, OUTPUT);
  pinMode(LEDgruen, OUTPUT); 
  pinMode(LEDrot, OUTPUT); 

  // INPUT_PULLUP -> Eingangspegel auf HIGH setzen 
  pinMode(TASTER_ROT, INPUT_PULLUP); 
  pinMode(TASTER_GRUEN, INPUT_PULLUP); 
  pinMode(TASTER_BLAU, INPUT_PULLUP); 
}

void loop()
{
  if (digitalRead(TASTER_ROT) == LOW)   
  {  
    rot ++;  

    // Wert darf 255 nicht übersteigen -> auf 0 setzen  
    if (rot > 255) rot = 0;   
  } 

  if (digitalRead(TASTER_GRUEN) == LOW)   
  { 
    gruen ++;

    // Wert darf 255 nicht übersteigen-> auf 0 setzen
    if (gruen > 255) gruen = 0;   
  }  

  if (digitalRead(TASTER_BLAU) == LOW)  
  { 
    blau ++;

    // Wert darf 255 nicht übersteigen -> auf 0 setzen
    if (blau > 255) blau = 0; 
  }

  analogWrite(LEDrot, rot);
  analogWrite(LEDgruen, gruen);
  analogWrite(LEDblau, blau);
  delay(20);
}

Letzte Aktualisierung: Wei­ter lesen ...

Blin­ken­de LED Potentiometer

int ROT = 6;
int REGLER = A0;

// speichert den analogen Wert des Drehpotentiometers
int ReglerWert;

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

  // Seriellen Monitor starten 
  Serial.begin(9600);
}

void loop()
{
  // aktuellen Zustand des Potentiometers lesen
  // und in der Variable ReglerWert speichern
  ReglerWert = analogRead(REGLER);
  digitalWrite(ROT, HIGH);

  // entsprechend dem gelesenen Wert warten
  // (0 – 1023 Millisekunden)
  delay(ReglerWert);
  Serial.print("Zeit in Millisekunden: ");

  // Serial.println() erzeugt einen Zeilenumbruch
  Serial.println(ReglerWert);
  digitalWrite(ROT, LOW);
  delay(ReglerWert);
}

Letzte Aktualisierung: Wei­ter lesen ...

Lot­to­zah­len mit UNO R4 WiFi

# include "WiFiS3.h"
# include "NTP.h"

// Minimum/Maximum der Zufallszahlen
const byte Minimum = 1;
const byte Maximum = 49;

// Anzahl der zu ziehenden Zahlen
const byte Anzahl = 6;

// Array für die gezogenen Zahlen
int LottoZahl[Anzahl];

// Array für die angekreuzten Zahlen
int SpielZahl[Anzahl];

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

int Status = WL_IDLE_STATUS;
WiFiServer WiFiServer(80);
WiFiClient WiFiClient;

WiFiUDP wifiUdp;
NTP ntp(wifiUdp);

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

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

  // Verbindung aufbauen
  if (WiFi.status() == WL_NO_MODULE) 
  {
    Serial.println(F("Verbindungsaufbau gescheitert!"));
  }

  Serial.print("Verbindung aufbauen mit ");
  Serial.println(Router);
  while (Status != WL_CONNECTED) 
  {
    Status = WiFi.begin(Router, Passwort);

    // Zeit für den Verbindungsaufbau
    // wenn die Verbindung nicht zustandekommt -> Zeit vergrößern
    delay(500);
  }

  // Webserver starten
  WiFiServer.begin();

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

  // IP des Arduinos anzeigen
  Serial.print("IP Adresse Arduino DHCP: ");
  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();

  // Zeit holen
  ntp.update();

  // Zeit mit formatedTime() anzeigen: 
  // %d = Tag, %m = Monat, %Y = Jahr, %T = Zeit in Stunden, Minuten, Sekunden
  Serial.println(ntp.formattedTime("%d.%m.%Y Uhrzeit: %T"));

  // Zufallsgenerator mit dem Signal an A0 starten
  randomSeed(analogRead(A0));
}

void loop() 
{
  // Variable "leeren"/auf 0 setzen
  String AnzahlTreffer = "";
  String GespielteZahlen = "";
  String GezogeneZahlen = "";
  byte Treffer = 0;
  
  // auf WiFiClienten warten ...
  WiFiClient = WiFiServer.available();
  if (WiFiClient) 
  {
    // Seite aufbauen wenn SeiteAufbauen true ist
    boolean SeiteAufbauen = true;

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

        // wenn als Zeichen neue Zeile (\n) übergeben wird
        // SeiteAufbauen true ist -> Seite anzeigen
        if (Zeichen == '\n' && SeiteAufbauen) 
        {
          ntp.update();

          /*
              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 " -> \"
          */
          WiFiClient.println("HTTP/1.1 200 OK");
          WiFiClient.println("Content-type:text/html");

          // Leerzeile zwingend erforderlich
          WiFiClient.println();
          WiFiClient.println("<!doctype html>");
          WiFiClient.println("<html>");
          WiFiClient.println("<body>");
          WiFiClient.println("<h2>Lottozahlen mit WiFi ziehen (6 aus " + String(Maximum) + ")");
          WiFiClient.print("</h2>");
          WiFiClient.println("<hr />");
          WiFiClient.println("<b>");

          // formatedTime() zeigt Wochentage in englischer Sprache
          // -> müssen einzeln abgefragt werden
          switch (ntp.weekDay()) 
          {
            case 0:
              WiFiClient.print("Sonntag");
              break;
            case 1:
              WiFiClient.print("Montag");
              break;
            case 2:
              WiFiClient.print("Dienstag");
              break;
            case 3:
              WiFiClient.print("Mittwoch");
              break;
            case 4:
              WiFiClient.print("Donnerstag");
              break;
            case 5:
              WiFiClient.print("Freitag");
              break;
            case 6:
              WiFiClient.print("Samstag");
              break;
          }
          WiFiClient.print(", ");
          WiFiClient.print(ntp.formattedTime("%d.%m.%Y Uhrzeit: %T</b>"));

          WiFiClient.println("<hr />");

          WiFiClient.println("<table><tr>");

          // Button neue Ziehung
          WiFiClient.print("<td><input style='font-size:14pt;");
          WiFiClient.print("font-weight:bold;");
          WiFiClient.print(" background-color:#7eff78;");
          WiFiClient.print(" width:200px; cursor:pointer;");
          WiFiClient.print(" border-radius:5px;border: 2px solid black;'");
          WiFiClient.print(" type='button'");
          WiFiClient.println(" onClick=\"location.href='WiFi.localIP()'\"");
          WiFiClient.println(" value='neue Ziehung'>");
          WiFiClient.println("</td></tr></table>");
          WiFiClient.println("<hr />");

          // Ziehung der "angekreuzten" Zahlen
          Ziehung();
          ZahlenSortieren(LottoZahl, 6);

          // String GespielteZahlen aus den Elementen des Arrays LottoZahl
          // zusammensetzen
          for (int i = 0; i < Anzahl; i++) 
          {
            GespielteZahlen = GespielteZahlen + LottoZahl[i] + " ";
            SpielZahl[i] = LottoZahl[i];
          }

          // Ziehung der Lottozahlen
          Ziehung();

          // Zahlen sortieren
          ZahlenSortieren(LottoZahl, 6);

          // Vergleichen der Elemente der Arrays SpielZahl und LottoZahl
          for (int i = 0; i < Anzahl; i++)
          {
            for (int ii = 0; ii < Anzahl; ii++) 
            {
              // Übereinstimmung gefunden -> Treffer um 1 erhöhen
              // AnzahlTreffer: String für übereinstimmende Zahlen erzeugen
              if (SpielZahl[i] == LottoZahl[ii]) 
              {
                AnzahlTreffer = AnzahlTreffer + SpielZahl[i] + " ";
                Treffer++;
              }
            }
          }

          // String GezogeneZahlen aus den Elementen des Arrays LottoZahl
          // zusammensetzen
          for (int i = 0; i < Anzahl; i++) 
          {
            GezogeneZahlen = GezogeneZahlen + LottoZahl[i] + " ";
          }
          WiFiClient.println("<h3 style='background-color:lightyellow'>");
          WiFiClient.println("Gespielte Zahlen: ");
          WiFiClient.println(GespielteZahlen);
          WiFiClient.println("</h3>");

          WiFiClient.println("<h3 style='background-color:lightcyan'>");

          WiFiClient.println("Gezogene Zahlen: ");
          WiFiClient.println(GezogeneZahlen);
          WiFiClient.println("</h3>");

          if (Treffer == 0) WiFiClient.println("<br><b>keine Treffer!</b>");

          // getroffene Zahlen anzeigen
          else 
          {
            WiFiClient.print("<br><b>" + String(Treffer));
            WiFiClient.print(" Treffer: </b>");
            WiFiClient.print(AnzahlTreffer);
          }

          WiFiClient.println("<hr>");

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

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

          // Seite vollständig geladen -> loop verlassen

          break;
        }
        // neue Zeile -> SeiteAufbauen auf true setzen
        if (Zeichen == '\n') SeiteAufbauen = true;

        // die aktuelle Zeile enthält ein Zeichen
        else if (Zeichen != '\r') SeiteAufbauen = false;
      }
    }
    delay(1);

    WiFiClient.stop();
  }
}

int Ziehung() 
{
  for (int i = 0; i < Anzahl; i++) 
  {
    /*
      die Lottozahl gilt solange als bereits gezogen
      bis in der for-Schleife nachgewiesen wird, dass sie neu ist
      und BereitsGezogen den Wert false hat
    */
    bool BereitsGezogen = true;
    while (BereitsGezogen) 
    {
      // Zahl ziehen
      LottoZahl[i] = random(Minimum, Maximum);
      BereitsGezogen = false;
      /*
        Zufallszahl mit den bereits gezogenen Zahlen vergleichen
        i wird in der ersten for-Schleife hochgezählt
        alle bisherigen Zahlen (ii) werden mit den bisher gezogenen
        (außer der gerade gezogenen) verglichen (ii < i)
        ist sie identisch, erhält BereitsGezogen den Wert true
        es wird erneut eine Zufallszahl bestimmt
        wenn die Zahl neu ist, (BereitsGezogen hat noch den Wert false)
        wird die while-Schleife verlassen und die nächste Zahl gezogen
      */
      for (int ii = 0; ii < i; ii++) 
      {
        if (LottoZahl[i] == LottoZahl[ii]) BereitsGezogen = true;
      }
    }
  }
  /*
    das Array mit den Zahlen wird an das Hauptprogramm zurückgegeben
    beim ersten Aufruf sind es die gespielten Zahlen
    beim zweiten Aufruf die gezogenen Lottozahlen
  */
  return LottoZahl[Anzahl];
}

void ZahlenSortieren(int Zahlen[], int Groesse) 
{
  // unsortierten Bereich des Arrays durchlaufen
  for (int i = 0; i < (Groesse - 1); i++) 
  {
    // bei jedem Durchlauf wird das jeweils letzte Element weggelassen
    for (int ii = 0; ii < (Groesse - (i + 1)); ii++) 
    {
      /*
        wenn die aktuelle Zahl größer als die nachfolgende Zahl ist
        -> aktuelle Zahl temporär speichern
        -> Zahlen vertauschen
        -> temporäre Zahl der nachfolgenden Zahl zuweisen
      */
      if (Zahlen[ii] > Zahlen[ii + 1]) 
      {
        int zwischengespeicherteZahl = Zahlen[ii];
        Zahlen[ii] = Zahlen[ii + 1];
        Zahlen[ii + 1] = zwischengespeicherteZahl;
      }
    }
  }
}

Letzte Aktualisierung: Wei­ter lesen ...

Wür­feln LED-Matrix Ardui­no R4 WiFi

Arrays als Byte-Array

# include "Arduino_LED_Matrix.h"

int TASTER = 7;

/*
  Minimum und Maximum der Zufallszahlen
  ermittelde Zahl wird immer nach unten gerundet
  -> maximaler Wert muss 7 sein
*/
int Minimum = 1;
int Maximum = 7;

// Name der Matrix
ArduinoLEDMatrix Matrix;

// Start-Button 
byte StartButton[8][12] = 
{
  { 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0 },
  { 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0 },
  { 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0 },
  { 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 0 },
  { 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 0 },
  { 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0 },
  { 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0 },
  { 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0 }
};

byte eins[8][12] = 
{
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  { 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0 },
  { 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0 },
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
};

byte zwei[8][12] = 
{
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1 },
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1 },
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  { 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  { 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
};

byte drei[8][12] = 
{
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1 },
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1 },
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  { 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0 },
  { 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0 },
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  { 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  { 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
};

byte vier[8][12] = 
{
  { 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1 },
  { 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1 },
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  { 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1 },
  { 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1 }
};

byte fuenf[8][12] = 
{
  { 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1 },
  { 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1 },
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  { 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0 },
  { 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0 },
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  { 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1 },
  { 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1 }
};

byte sechs[8][12] = {
  { 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1 },
  { 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1 },
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  { 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1 },
  { 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1 }
};

void setup() 
{
  Matrix.begin();

  // Zufallsgenerator starten
  randomSeed(A0);

  pinMode(TASTER, INPUT_PULLUP);

  // Start-Button anzeigen
  Matrix.renderBitmap(StartButton, 8, 12);
}

void loop() 
{
  // Zustand des Tasters lesen
  int TasterLesen = digitalRead(TASTER);

  if (TasterLesen == LOW) 
  {
    delay(200);

    // Würfeleffekt
    for (int i = 0; i < 5; i++) 
    {
      Wuerfeln();
      delay(200);
    }
  }
}

void Wuerfeln() 
{
  // Zufallszahl ermitteln
  int Zahl = random(Minimum, Maximum);

  // Abfrage der gewürfelten Zahl
  switch (Zahl) 
  {
    case 1:
      Matrix.renderBitmap(eins, 8, 12);
      break;

    case 2:
      Matrix.renderBitmap(zwei, 8, 12);
      break;

    case 3:
      Matrix.renderBitmap(drei, 8, 12);
      break;

    case 4:
      Matrix.renderBitmap(vier, 8, 12);
      break;

    case 5:
      Matrix.renderBitmap(vier, 8, 12);
      break;

    case 6:
      Matrix.renderBitmap(sechs, 8, 12);
      break;
  }
}

Arrays mit Matrix-Edi­tor erstellt

# include "Arduino_LED_Matrix.h"

int TASTER = 7;

/*
  Minimum und Maximum der Zufallszahlen
  ermittelde Zahl wird immer nach unten gerundet
  -> maximaler Wert muss 7 sein
*/
int Minimum = 1;
int Maximum = 7;

// Name der Matrix
ArduinoLEDMatrix Matrix;

// Array Start-Button
const unsigned long StartButton[] =
{
  0x6009010,
  0x82642641,
  0x8090060,
};

const unsigned long eins[] =
{
  0x0,
  0x600600,
  0x0
};

const unsigned long zwei[] =
{
  0x300300,
  0x0,
  0xc00c00
};

const unsigned long drei[] =
{
  0x300300,
  0x600600,
  0xc00c00,
};

const unsigned long vier[] =
{
  0xc03c0300,
  0x0,
  0xc03c03
};

const unsigned long fuenf[] =
{
  0xc03c0300,
  0x600600,
  0xc03c03
};

const unsigned long sechs[] =
{
  0xc63c6300,
  0x0,
  0xc63c63
};

void setup()
{
  Matrix.begin();

  // Zufallsgenerator starten
  randomSeed(A0);

  pinMode(TASTER, INPUT_PULLUP);
  Matrix.loadFrame(StartButton);
}

void loop()
{
  int TasterLesen = digitalRead(TASTER);
  if (TasterLesen == LOW)
  {
    delay(200);

    // Würfeleffekt
    for (int i = 0; i < 5; i++)
    {
      Wuerfeln();
      delay(200);
    }
  }
}

void Wuerfeln()
{
  int Zahl = random(Minimum, Maximum);
  switch (Zahl)
  {
    case 1:
      Matrix.loadFrame(eins);
      break;
    case 2:
      Matrix.loadFrame(zwei);
      break;
    case 3:
      Matrix.loadFrame(drei);
      break;
    case 4:
      Matrix.loadFrame(vier);
      break;
    case 5:
      Matrix.loadFrame(fuenf);
      break;
    case 6:
      Matrix.loadFrame(sechs);
      break;
  }
}

Letzte Aktualisierung: Wei­ter lesen ...