Lösungen

LED mit Bewe­gungs­mel­der und Lichtinsitätssensor/oder Foto­zel­le schalten

// 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:

LED mit Licht­sen­sor TEM6000 und Bewe­gungs­mel­der schalten

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:

Far­ben­spie­le RGB-LED

Inhalts­ver­zeich­nis

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

/*
  Anschlüsse am Tastenfeld von links nach rechts
  GND D4 D5 D6 D7
*/
int TASTER_EINS = 5;  // Taste 1 
int TASTER_ZWEI = 4;  // Taste 2 
int TASTER_DREI = 7;  // Taste 3 
int TASTER_VIER = 6;  // Taste 4 

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

  // INPUT_PULLUP -> Eingangspegel auf HIGH setzen 
  pinMode(TASTER_EINS, INPUT_PULLUP); 
  pinMode(TASTER_ZWEI, INPUT_PULLUP); 
  pinMode(TASTER_DREI, INPUT_PULLUP); 
  pinMode(TASTER_VIER, INPUT_PULLUP); 
} 

void loop() 
{ 
  if (digitalRead(TASTER_EINS) == LOW) 
  {   
    delay(100); 
    Serial.println("Taste 1 an Pin " + String(TASTER_EINS));        
  } 

  if (digitalRead(TASTER_ZWEI) == LOW)   
  {  
    delay(100);   
    Serial.println("Taste 2 an Pin " + String(TASTER_ZWEI));     
  } 
 
  if (digitalRead(TASTER_DREI) == LOW)  
  {  
    delay(100); 
    Serial.println("Taste 3 an Pin " + String(TASTER_DREI));    
  } 

  if (digitalRead(TASTER_VIER) == LOW)   
  {  
    delay(100);  
    Serial.println("Taste 4 an Pin " + String(TASTER_VIER));    
  } 
}

Letzte Aktualisierung:

Blin­ken­de LED Potentiometer

int ROT = 7;
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);
}

letz­te Aktualisierung: 

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:

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

Inhalts­ver­zeich­nis

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: