Lösungen

#include "SoftPWM.h"

// Array mit 5 Elementen und den zugehörigen Ports
byte LED[5] = {3, 4, 5, 6, 7};

// Anzahl der LEDs feststellen
byte LEDMax = sizeof(LED);

void setup()
{
  // SoftPWM starten
  SoftPWMBegin();
  for (int i = 0; i < LEDMax; i++)
  {
    // Status aus für jede LED setzen
    SoftPWMSet(LED[i], 0);

    /*
      Dimmzeiten setzen:
      Parameter LED, Auf-Dimmen (in Millisekunden), Ab-Dimmen (in Millisekunden)
      Dimmzeiten müssen mit der Wartezeit übereinstimmen
    */
    SoftPWMSetFadeTime(LED[i], 400, 400);
  }
}

void loop()
{
  for (int i = 0; i < LEDMax; i++)
  {
    // aktuelle LED einschalten und dimmen
    SoftPWMSet(LED[i], 255);

    // Wartezeit muss mit den Dimmzeiten übereinstimmen
    delay(400);

    // aktuelle LED ausschalten
    SoftPWMSet(LED[i], 0);

    // Wartezeit vor der nächsten LED
    delay(100);
  }
}

Letzte Aktualisierung:

#include "EEPROM.h"

byte Zufallszahl;
byte MaxWuerfeln = 5;
int Minumum = 1;
int Maximum = 7;
int TASTER = 12;
int TasterLesen;

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

  // auf serielle Verbindung warten
  while (!Serial) {;}
  pinMode(TASTER, INPUT_PULLUP);
  randomSeed(analogRead(A0));

  /*
    Überblick Statistik
    Speicherstelle EEPROM
    0 -> Anzahl der Spiele
    1 -> Anzahl Dreierpasch
    2 -> Anzahl Vierpasch
    3 -> Anzahl Kniffel
  */
  Serial.print("Anzahl bisheriger Spiele: ");
  Serial.println(EEPROM[0]);
  Serial.print("Anzahl Dreierpasch: ");
  Serial.println(EEPROM[1]);
  Serial.print("Anzahl Viererpasch: ");
  Serial.println(EEPROM[2]);
  Serial.print("Anzahl Kniffel: ");
  Serial.println(EEPROM[3]);
  
  /*
    Statistik in %
    für die Division muss der ausgelesene Wert nach float umgewandelt werden
    nur rechnen, wenn AnzahlSpiele > 0 (durch 0 kann nicht geteilt werden)
  */
  if (EEPROM[0] > 0)
  {
    Serial.println("-----------------------------");
    Serial.print("Anzahl bisheriger Spiele: ");
    Serial.println(EEPROM[0]);
    
    // Anzahl der bisherigen Dreier- Vierpasch und Kniffel anzeigen
    Serial.print("Anzahl Dreierpasch: ");
    Serial.print(EEPROM[1]);
    Serial.print("  ");
    
    String PaschDrei = String(float(EEPROM[1]) / float(EEPROM[0]) * 100);
    PaschDrei.replace(".", ",");
    Serial.println(PaschDrei + " %");
    Serial.print("Anzahl Viererpasch: ");
    Serial.print(EEPROM[2]);
    Serial.print("  ");
    
    String PaschVier = String(float(EEPROM[2]) / float(EEPROM[0]) * 100);
    PaschVier.replace(".", ",");
    Serial.println(PaschVier + " %");
    Serial.print("Anzahl Kniffel: ");
    Serial.print(EEPROM[3]);
    Serial.print("  ");
    
    String KniffelAnzahl = String(float(EEPROM[3]) / float(EEPROM[0]) * 100);
    KniffelAnzahl.replace(".", ",");
    Serial.println(KniffelAnzahl + " %");
  }

  /*
    Abfrage ob die bisherigen Daten aus dem EEPROM gelöscht werden sollen
    Umlaute ersetzen:
    ö -> \u00f6
    ü -> \u00fc
  */
  Serial.println("---------------------------------------");
  Serial.println("Bisherige Statistik l\u00f6schen (j/n)?");
  Serial.println("---------------------------------------");
}

void loop()
{
  // auf serielle Eingabe warten
  while (Serial.available() > 0)
  {
    // solange lesen, bis return \n eingegeben wurde
    String Eingabe = Serial.readStringUntil('\n');
    
    // das letzte Zeichen ist return = \n ⇒ soll entfernt werden (-1)
    Eingabe = Eingabe.substring(0, Eingabe.length() - 1);
    
    // die ersten 5 Speicherstellen mit 0 überschreiben
    if (Eingabe == "j")
    {
      for (int i = 0; i < 5; ++i)
      {
        EEPROM.write(i, 0);
      }
      Serial.println("Statistik gel\u00f6scht!");
    }
    else Serial.println("Statistik bleibt erhalten!");
    Serial.println("Bitte zum W\u00fcrfeln Taster dr\u00fccken!");
  }
  
  // alle Werte zurücksetzen
  byte Summe = 0;
  int AnzahlEins = 0;
  int AnzahlZwei = 0;
  int AnzahlDrei = 0;
  int AnzahlVier = 0;
  int AnzahlFuenf = 0;
  int AnzahlSechs = 0;
  
  // Werte aus EEPROM lesen
  byte AnzahlSpiele = EEPROM[0];
  byte DreierPasch = EEPROM[1];
  byte ViererPasch = EEPROM[2];
  byte Kniffel = EEPROM[3];
  
  if (AnzahlSpiele < EEPROM.length())
  {
    TasterLesen = digitalRead(TASTER);
    delay(200);
    if (TasterLesen == LOW)
    {
      AnzahlSpiele ++;
      Serial.println("W\u00fcrfele ...");
      for (int i = 0; i  < MaxWuerfeln; i++)
      {
        Zufallszahl = random(Minumum, Maximum);
        // Anzahl der einsen, zweien ... zählen
        // wird für die Auswertung benötigt
        switch (Zufallszahl)
        {
          case 1:
            AnzahlEins ++;
            break;
          case 2:
            AnzahlZwei++;
            break;
          case 3:
            AnzahlDrei++;
            break;
          case 4:
            AnzahlVier ++;
            break;
          case 5:
            AnzahlFuenf ++;
            break;
          case 6:
            AnzahlSechs ++;
            break;
        }
        Serial.println(Zufallszahl);
        
        // Summe berechnen
        Summe += Zufallszahl;
      }
      
      // Summe anzeigen
      Serial.println("-----------------------------");
      Serial.print("Summe:  ");
      Serial.println(Summe);
      
      /*
        Auswertung Dreierpasch
        Anzahl wird um 1 erhöht und in die Speicherstelle 1 geschrieben
      */
      if (AnzahlEins == 3)
      {
        Serial.println("Dreierpasch 1");
        DreierPasch ++;
        EEPROM.update(1, DreierPasch);
      }
      if (AnzahlZwei == 3)
      {
        Serial.println("Dreierpasch 2");
        DreierPasch ++;
        EEPROM.update(1, DreierPasch);
      }
      if (AnzahlDrei == 3)
      {
        Serial.println("Dreierpasch 3");
        DreierPasch ++;
        EEPROM.update(1, DreierPasch);
      }
      if (AnzahlVier == 3)
      {
        Serial.println("Dreierpasch 4");
        DreierPasch ++;
        EEPROM.update(1, DreierPasch);
      }
      if (AnzahlFuenf == 3)     {
        Serial.println("Dreierpasch 5");
        DreierPasch ++;
        EEPROM.update(1, DreierPasch);
      }
      if (AnzahlSechs == 3)
      {
        Serial.println("Dreierpasch 6");
        DreierPasch ++;
        EEPROM.update(1, DreierPasch);
      }
      
      /*
        Auswertung Viererpasch
        Anzahl wird um 1 erhöht und in die Speicherstelle 2 geschrieben
      */
      if (AnzahlEins == 4)
      {
        Serial.println("Viererpasch 1");
        ViererPasch ++;
        EEPROM.update(2, ViererPasch);
      }
      if (AnzahlZwei == 4)
      {
        Serial.println("Viererpasch 2");
        ViererPasch ++;
        EEPROM.update(2, ViererPasch);
      }
      if (AnzahlDrei == 4)
      {
        Serial.println("Viererpasch 3");
        ViererPasch ++;
        EEPROM.update(2, ViererPasch);
      }
      if (AnzahlVier == 4)
      {
        Serial.println("Viererpasch 4");
        ViererPasch ++;
        EEPROM.update(2, ViererPasch);
      }
      if (AnzahlFuenf == 4)
      {
        Serial.println("Viererpasch 5");
        ViererPasch ++;
        EEPROM.update(2, ViererPasch);
      }
      if (AnzahlSechs == 4)
      {
        Serial.println("Viererpasch 6");
        ViererPasch ++;
        EEPROM.update(2, ViererPasch);
      }
      
      /*
        Auswertung Kniffel
        wenn AnzahlEins == 5 oder (||) AnzahlZwei = 5 ...
        keine Auswertung mit welcher Zahl der Kniffel gewürfelt wurde
        Anzahl wird um 1 erhöht und in die Speicherstelle 2 geschrieben
      */
      if (AnzahlEins == 5 || AnzahlZwei == 5 || AnzahlDrei == 5 || AnzahlVier == 5 || AnzahlFuenf == 5 || AnzahlSechs == 5)
      {
        Serial.println("Kniffel");
        Kniffel ++;
        EEPROM.update(3, Kniffel);
      }
      
      // Anzahl der Spiele in Speicherstelle 0 schreiben und anzeigen
      EEPROM.update(0, AnzahlSpiele);
      Serial.println("-----------------------------");
      Serial.print("Anzahl bisheriger Spiele: ");
      Serial.println(EEPROM[0]);
      
      // Anzahl der bisherigen Dreier- Vierpasch und Kniffel anzeigen
      Serial.print("Anzahl Dreierpasch: ");
      Serial.print(EEPROM[1]);
      Serial.print("  ");
      
      String PaschDrei = String(float(EEPROM[1]) / float(EEPROM[0]) * 100);
      PaschDrei.replace(".", ",");
      Serial.println(PaschDrei + " %");
      Serial.print("Anzahl Viererpasch: ");
      Serial.print(EEPROM[2]);
      Serial.print("  ");
      
      String PaschVier = String(float(EEPROM[2]) / float(EEPROM[0]) * 100);
      PaschVier.replace(".", ",");
      Serial.println(PaschVier + " %");
      Serial.print("Anzahl Kniffel: ");
      Serial.print(EEPROM[3]);
      Serial.print("  ");
      
      String KniffelAnzahl = String(float(EEPROM[3]) / float(EEPROM[0]) * 100);
      KniffelAnzahl.replace(".", ",");
      Serial.println(KniffelAnzahl + " %");
      Serial.println("-----------------------------");
    }
  }
  else Serial.println("Kein Speicherplatz mehr vorhanden!");
}

Letzte Aktualisierung:

int BitsSchieben = 8;
int AusgabePin = 9;
int EingangPin = 10;

// Array LEDs leuchten von außen nach innen und zurück
byte AussenNachInnen[] =
{
  B10000001, B01000010, B00100100, B00011000,
  B00100100, B01000010, B10000001
};

void setup()
{
  pinMode(BitsSchieben, OUTPUT);
  pinMode(AusgabePin, OUTPUT);
  pinMode(EingangPin, OUTPUT);
}

void loop()
{
  /*
    Lauflicht vorwärts
    LSBFIRST Bits von rechts ins Register schieben
    dann jeweils 1 Bit nach rechts schieben
    Startpunkt hängt davon ab, an welchen Pins die
    1. Led und die weiteren LEDs gesteckt sind
  */
  byte LED = B10000000;

  // die letzte LED bleibt an
  for (int i = 0; i <= 6; i++)
  {
    // Ausgaberegister ausschalten
    digitalWrite(AusgabePin, 0);

    // Bits von rechts in das Register schieben
    shiftOut(EingangPin, BitsSchieben, LSBFIRST, LED);

    // Ausgaberegister einschalten
    digitalWrite(AusgabePin, 1);
    delay(200);

    // 1 Bit nach rechts schieben
    LED = LED >> 1;
  }

  /*
    durch die Verschiebung ist der aktuelle Stand:
    LED = B00000001
    Lauflicht rückwärts -> 1 Bit nach links schieben
  */
  for (int i = 0; i <= 7; i++)
  {
    // Ausgaberegister ausschalten
    digitalWrite(AusgabePin, 0);

    // Bits von rechts in das Register schieben
    shiftOut(EingangPin, BitsSchieben, LSBFIRST, LED);

    // Ausgaberegister einschalten
    digitalWrite(AusgabePin, 1);
    delay(200);

    // 1 Bit nach links schieben
    LED = LED << 1;
  }

  // Lauflicht 2 LEDs vorwärts
  LED = B11000000;

  for (int i = 0; i <= 2; i++)
  {
    // Ausgaberegister ausschalten
    digitalWrite(AusgabePin, 0);

    // LSBFIRST -> Bits von rechts in das Register schieben
    shiftOut(EingangPin, BitsSchieben, LSBFIRST, LED);

    // Ausgaberegister einschalten
    digitalWrite(AusgabePin, 1);
    delay(200);

    // 2 Bits nach rechts schieben
    LED = LED >> 2;
  }

  // Lauflicht 2 LEDs rückwärts
  for (int i = 0; i <= 3; i++)
  {
    // Ausgaberegister ausschalten
    digitalWrite(AusgabePin, 0);

    // Bits von links in das Register schieben
    shiftOut(EingangPin, BitsSchieben, LSBFIRST, LED);

    // Ausgaberegister einschalten
    digitalWrite(AusgabePin, 1);
    delay(200);

    // 2 Bits nach links schieben
    LED = LED << 2;
  }

  // Lauflicht -> LEDs gehen nach und nach aus
  // LSBFIRST -> Bits von rechts in das Register schieben
  LED = B11111111;

  for (int i = 0; i <= 7; i++)
  {
    // Ausgaberegister ausschalten
    digitalWrite(AusgabePin, 0);

    // Bits in das Schiebregister schieben
    shiftOut(EingangPin, BitsSchieben, LSBFIRST, LED);

    // Ausgaberegister einschalten
    digitalWrite(AusgabePin, 1);
    delay(200);

    // 1 Bit nach rechts schieben
    LED = LED >> 1;
  }

  // LSBFIRST -> Bits von rechts in das Register schieben
  LED = B11111111;
  for (int i = 0; i <= 7; i++)
  {
    // Ausgaberegister ausschalten
    digitalWrite(AusgabePin, 0);

    // Bits in das Schiebregister schieben
    shiftOut(EingangPin, BitsSchieben, LSBFIRST, LED);

    // Ausgaberegister einschalten
    digitalWrite(AusgabePin, 1);
    delay(200);

    // 1 Bit nach links schieben
    LED = LED << 1;
  }

  // LEDS leuchten von außen nach innen und zurück
  // Array AussenNachInnen
  for (int i = 0; i <= 6; i++)
  {
    digitalWrite(AusgabePin, 0);
    shiftOut(EingangPin, BitsSchieben, MSBFIRST, AussenNachInnen[i]);
    digitalWrite(AusgabePin, 1);
    delay(200);
  }

  // alle LEDs blinken
  for (int i = 0; i <= 6; i++)
  {
    digitalWrite(AusgabePin, 0);
    shiftOut(EingangPin, BitsSchieben, MSBFIRST, LED);
    digitalWrite(AusgabePin, 1);
    delay(200);

    // alle Werte umkehren
    LED = ~ LED;
  }

  // MSBFIRST -> Bits von links in das Register schieben
  // jede zweite LED im Wechsel
  LED = B10101010;

  for (int i = 0; i <= 6; i++)
  {
    digitalWrite(AusgabePin, 0);
    shiftOut(EingangPin, BitsSchieben, MSBFIRST, LED);
    digitalWrite(AusgabePin, 1);
    delay(200);

    // alle Werte umkehren
    LED = ! LED;
  }

  // jeweils 2 LEDs im Wechsel
  LED = B11001100;

  for (int i = 0; i <= 6; i++)
  {
    digitalWrite(AusgabePin, 0);
    shiftOut(EingangPin, BitsSchieben, MSBFIRST, LED);
    digitalWrite(AusgabePin, 1);
    delay(200);

    // alle Werte umkehren
    LED = ~ LED;
  }

  // äußere LEDs/innere LEDs im Wechsel
  LED = B11000011;

  for (int i = 0; i <= 6; i++)
  {
    digitalWrite(AusgabePin, 0);
    shiftOut(EingangPin, BitsSchieben, MSBFIRST, LED);
    digitalWrite(AusgabePin, 1);
    delay(200);

    // alle Werte umkehren
    LED = ~ LED;
  }
}

Letzte Aktualisierung:

int LED[5] = {3, 4, 5, 6, 7};
int Leuchtdauer = 200;

void setup() 
{
  for (int i = 0; i <= 4; i++) 
  {
    pinMode(LED[i], OUTPUT);
  }
}

void loop() 
{
  for (int i = 0; i <= 4; i++) 
  {
    // aktuelle LED i einschalten
    digitalWrite(LED[i], HIGH);

    delay(Leuchtdauer);
    digitalWrite(LED[i], LOW);
  }
}

Letzte Aktualisierung:

int LED[5] = {3, 4, 5, 6, 7};
int AnzahlBlinken; 
int LEDNummer;

void setup()
{
  for (int i = 0; i <= 4; i++)
  {
    pinMode(LED[i], OUTPUT);
  }

   // Zufallsgenerator starten
   randomSeed(analogRead(A0));
}

void loop()  
{ 
  for (int i = 0; i <= 4; i++)    
  {  
    // Anzahl des Blinkens der LEDs zufällig bestimmen       
    AnzahlBlinken = random(1, 5);   

    // Leuchtdauer zufällig bestimmen
    int Leuchtdauer = random(50, 500);  

    /* 
      aktuelle LED i einschalten     
      -> Funktion LEDBlinken aufrufen   
    */    
    LEDBlinken(LED[i], AnzahlBlinken, Leuchtdauer);   
  } 
}

void LEDBlinken(int LEDNummer, int Anzahl, int Leuchtdauer) 
{ 
  for (int i = 0; i <= Anzahl; i++)   
  {  
    digitalWrite(LEDNummer, HIGH);   
    delay(Leuchtdauer);   
    digitalWrite(LEDNummer, LOW);   
    delay(Leuchtdauer); 
  }
}

Letzte Aktualisierung:

#include "RTClib.h"
#include "LiquidCrystal_I2C.h"
#include "Bounce2.h"

// Name des RTC-Moduls 
RTC_DS3231 rtc; 

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

int Lautsprecher = 3;
int TasterLinks = 7;
int TasterMitte = 8;
int TasterRechts = 9 ;

// Beginn der Weckzeit
int StundeWeckzeit = 6;
int MinuteWeckzeit = 0;

// Dauer des Signal in Sekunden
int DauerWecksignal = 3;
bool TonSekunde = false;
bool WeckerEinAus = true;

// Zeit messen für Ticken der Uhr
long Startzeit;
long ZeitJetzt;

Bounce WeckzeitStunde = Bounce();
Bounce WeckzeitMinute = Bounce();
Bounce StatusWecker = Bounce();

void setup()
{
  pinMode(TasterLinks, INPUT_PULLUP);
  pinMode(TasterMitte, INPUT_PULLUP);
  pinMode(TasterRechts, INPUT_PULLUP);

  // Instanzen des Objekts Bounce für jede Taste zuordnen
  // Zeitintervall einstellen
  WeckzeitStunde.attach(TasterLinks);
  WeckzeitStunde.interval(20);
  WeckzeitMinute.attach(TasterMitte);
  WeckzeitMinute.interval(20);
  StatusWecker.attach(TasterRechts);
  StatusWecker.interval(20);
  
  Serial.begin(9600);
 
  // auf serielle Verbindung warten
  while (!Serial) {;}

  rtc.begin();
  /*
    wenn Datum und Zeit nicht korrekt -> Datum/Zeit setzen
    Jahr, Monat, Tag, Stunde, Minute, Sekunde
    keine führende 0 setzen
    rtc.adjust(DateTime(2025, 4, 14, 16, 42, 30));
  */
  // rtc.adjust(DateTime(2025, 4, 14, 16, 42, 30));

  // Zeitpunkt des Kompilierens als aktuelle Zeit setzen
  rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));

  // LCD starten
  lcd.init();

  // Hintergrundbeleuchtung einschalten
  lcd.backlight();

  Serial.println("Bitte die Weckzeit eingeben:");
  Serial.println("Taster links -> Stunde +/Taster Mitte -> Minute + Taster rechts -> Weckzeit ein/aus");
  Startzeit = millis();
}

void loop()
{
  String Stunde, Minute, Weckzeit;

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

  // Stunde einstellen
  if (WeckzeitStunde.update())
  {
    if (WeckzeitStunde.read() == LOW)
    {
      if (StundeWeckzeit >= 24) StundeWeckzeit = 1;
      else StundeWeckzeit ++;
    }
  }

  // Minute einstellen
  if (WeckzeitMinute.update())
  {
    if (WeckzeitMinute.read() == LOW)
    {
      if (MinuteWeckzeit >= 59) MinuteWeckzeit = 0;
      else MinuteWeckzeit ++;
    }
  }

  // Wecker ein/aus
  if (StatusWecker.update())
  {
    if (StatusWecker.read() == LOW)
    {
      WeckerEinAus = !WeckerEinAus;
    }
  }

  // Wochentag, Datum und Zeit anzeigen
  lcd.setCursor(0, 0);

  /*
    Wochentag anzeigen
    0 = Sonntag
    1 = Montag
    ...
    6 = Samstag
  */
  switch (aktuell.dayOfTheWeek())
  {
    case 0:
      lcd.print("Sonntag");
      break;
    case 1:
      lcd.print("Montag");
      break;
    case 2:
      lcd.print("Dienstag");
      break;
    case 3:
      lcd.print("Mittwoch");
      break;
    case 4:
      lcd.print("Donnerstag");
      break;
    case 5:
      lcd.print("Freitag");
      break;
    case 6:
      lcd.print("Samstag");
      break;
  }

  lcd.setCursor(0, 1);
  lcd.print(aktuell.day());
  lcd.print(".");

  // Monatsnamen anzeigen
  lcd.print(" ");

  switch (aktuell.month())
  {
    case 1:
      lcd.print("Januar");
      break;
    case 2:
      lcd.print("Februar");
      break;
    case 3:
      lcd.print("M\341rz");
      break;
    case 4:
      lcd.print("April");
      break;
    case 5:
      lcd.print("Mai");
      break;
    case 6:
      lcd.print("Juni");
      break;
    case 7:
      lcd.print("Juli");
      break;
    case 8:
      lcd.print("August");
      break;
    case 9:
      lcd.print("September");
      break;
    case 10:
      lcd.print("Oktober");
      break;
    case 11:
      lcd.print("November");
      break;
    case 12:
      lcd.print("Dezember");
      break;
  }
  lcd.print(" ");

  lcd.print(aktuell.year());
  lcd.setCursor(0, 2);

  // wenn Stunden < 10 -> führende 0 setzen
  if (aktuell.hour() < 10) lcd.print("0");
  lcd.print(aktuell.hour());
  lcd.print(':');

  // wenn Minuten < 10 -> führende 0 setzen
  if (aktuell.minute() < 10) lcd.print("0");
  lcd.print(aktuell.minute());
  lcd.print(':');

  // wenn Sekunden < 10 -> führende 0 setzen
  if (aktuell.second() < 10) lcd.print("0");
  lcd.print(aktuell.second());

  if (WeckerEinAus) lcd.print(" Wecker ein");
  else lcd.print(" Wecker aus");

  /*
    Weckzeit formatieren -> führende 0 ergänzen
    4 mögliche Fälle
    Stunde < 10 Minute < 10
    Stunde < 10 Minute > 9
    Stunde > 10 Minute < 10
    Stunde > 10 Minute > 9
  */
  if (StundeWeckzeit < 10 && MinuteWeckzeit < 10) 
  {
    Weckzeit = "0" + String(StundeWeckzeit) + ":0" + String(MinuteWeckzeit);
  }

  if (StundeWeckzeit < 10 && MinuteWeckzeit > 9) 
  {
    Weckzeit = "0" + String(StundeWeckzeit) + ":" + String(MinuteWeckzeit);
  }

  if (StundeWeckzeit > 9 && MinuteWeckzeit < 10) 
  {
    Weckzeit = String(StundeWeckzeit) + ":0" + String(MinuteWeckzeit);
  }

  if (StundeWeckzeit > 9 && MinuteWeckzeit > 9) 
  {
    Weckzeit = String(StundeWeckzeit) + ":" + String(MinuteWeckzeit);
  }
  
  lcd.setCursor(0, 3);
  lcd.print("Weckzeit: " + Weckzeit);

  // führende 0 setzen
  if (aktuell.hour() < 10) Stunde = "0" + String(aktuell.hour());
  else Stunde = String(aktuell.hour());

  // führende 0 setzen
  if (aktuell.minute() < 10) Minute = "0" +  String(aktuell.minute());
  else Minute = String(aktuell.minute());

  // String zusammensetzen
  String aktuelleZeit = Stunde + ":" + Minute;
  if (aktuelleZeit == Weckzeit && aktuell.second() <  DauerWecksignal)
  {
    tone(Lautsprecher, 1000, 500);
  }

  /*
    Ticken der Uhr
    aktuelle Zeit (ZeitJetzt) messen
    millis() -> Zeit, die seit dem Start des Programms
    vergangen ist
    wenn die Differenz zwischen der gerade gemessenen Zeit
    und der im setup gemessenen Startzeit >= 1000 (1 Sekunde) ist
    -> kurzen Ton wiedergeben
    Startzeit muss anschließend auf die aktuelle Zeit gesetzt werden
  */
  ZeitJetzt = millis();
  if (ZeitJetzt - Startzeit >= 1000)
  {
    if (TonSekunde) tone(Lautsprecher, 1000, 2);
    Startzeit = ZeitJetzt;
  }
}

Letzte Aktualisierung:

#include "U8g2lib.h"
#include "Bounce2.h"

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

// Bildschirmgröße
int BildschirmBreite = oled.getDisplayWidth();
int BildschirmHoehe = oled.getDisplayHeight();
int TASTER = 7;

// Stoppuhr als Objekt der Bibliothek Bounce
Bounce StoppUhr = Bounce();

// Bild Stoppuhr
#define StoppuhrBreite 50
#define StoppuhrHoehe 56

static unsigned char Stoppuhr[] =
{
  0x00, 0x00, 0xf0, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x7f, 0x00,
  0x00, 0x00, 0x00, 0x00, 0xf0, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0,
  0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x0f, 0x00, 0x00, 0x00, 0x00,
  0x00, 0xc0, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0xff, 0x00, 0x00,
  0x00, 0x00, 0x00, 0xff, 0xff, 0x07, 0x00, 0x00, 0x00, 0xe0, 0x0f, 0x80,
  0x1f, 0x00, 0x00, 0x00, 0xf0, 0x01, 0x00, 0x7e, 0x00, 0x00, 0x00, 0x78,
  0x00, 0x00, 0xf8, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0xe0, 0x01, 0x00,
  0x00, 0x0f, 0x00, 0x00, 0x80, 0x03, 0x00, 0x00, 0x07, 0x00, 0x00, 0x04,
  0x07, 0x00, 0xc0, 0x03, 0x00, 0x00, 0x00, 0x0e, 0x00, 0xc0, 0x01, 0x01,
  0x00, 0x00, 0x1c, 0x00, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x70,
  0x00, 0x00, 0x02, 0x00, 0x38, 0x00, 0x30, 0x00, 0x00, 0x02, 0x00, 0x70,
  0x00, 0x38, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x00, 0x98, 0x00, 0x00, 0x02,
  0x00, 0xe2, 0x00, 0x1c, 0x00, 0x00, 0x03, 0x00, 0xc0, 0x00, 0x1c, 0x00,
  0x00, 0x02, 0x00, 0xc0, 0x00, 0x0c, 0x00, 0x00, 0x03, 0x00, 0xc0, 0x01,
  0x0e, 0x00, 0x00, 0x03, 0x00, 0x80, 0x01, 0x0e, 0x00, 0x00, 0x07, 0x00,
  0x80, 0x01, 0x06, 0x00, 0x00, 0x07, 0x00, 0x80, 0x03, 0x06, 0x00, 0x00,
  0x07, 0x00, 0x80, 0x01, 0x06, 0x00, 0xc0, 0x07, 0x00, 0x00, 0x03, 0x06,
  0x00, 0x80, 0x07, 0x00, 0x80, 0x01, 0x96, 0x00, 0x80, 0x0f, 0x00, 0x80,
  0x03, 0x06, 0x00, 0x00, 0x1f, 0x00, 0x80, 0x01, 0x06, 0x00, 0x00, 0x3e,
  0x00, 0x00, 0x03, 0x06, 0x00, 0x00, 0xf8, 0x00, 0x80, 0x03, 0x06, 0x00,
  0x00, 0xf0, 0x01, 0x80, 0x01, 0x0e, 0x00, 0x00, 0x80, 0x01, 0x80, 0x01,
  0x0e, 0x00, 0x00, 0x00, 0x07, 0xc0, 0x01, 0x0c, 0x00, 0x00, 0x00, 0x0e,
  0x80, 0x01, 0x0c, 0x00, 0x00, 0x00, 0x18, 0xc1, 0x00, 0x1c, 0x04, 0x00,
  0x00, 0x20, 0xe0, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x00, 0x38,
  0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x70,
  0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x38, 0x00, 0xe0, 0x00, 0x00, 0x00,
  0x00, 0x3c, 0x00, 0xc0, 0x01, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x80, 0x01,
  0x00, 0x00, 0x00, 0x0f, 0x00, 0x80, 0x87, 0x00, 0x02, 0x08, 0x07, 0x00,
  0x00, 0x1f, 0x00, 0x00, 0xc0, 0x03, 0x00, 0x00, 0x3c, 0x00, 0x00, 0xf0,
  0x01, 0x00, 0x00, 0x78, 0x00, 0x00, 0xf8, 0x00, 0x00, 0x00, 0xf0, 0x01,
  0x00, 0x3e, 0x00, 0x00, 0x00, 0xc0, 0x7f, 0xe0, 0x0f, 0x00, 0x00, 0x00,
  0x00, 0xff, 0xff, 0x03, 0x00, 0x00, 0x00, 0x00, 0xd0, 0x7f, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};

// Bild Zielflagge
#define ZielBreite 50
#define ZielHoehe 53
static unsigned char Zielflagge[] =
{
  0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0xfe, 0xff, 0x01, 0x00, 0xfe,
  0xff, 0x03, 0xfe, 0x7f, 0x00, 0x00, 0xfc, 0xff, 0x03, 0xfe, 0xff, 0x00,
  0x00, 0xfc, 0xff, 0x03, 0xfe, 0xff, 0x00, 0x00, 0xfc, 0xff, 0x03, 0xfe,
  0xff, 0x00, 0x00, 0xfc, 0xff, 0x03, 0xfe, 0xff, 0x00, 0x00, 0xfc, 0xff,
  0x03, 0xfe, 0xff, 0x00, 0x00, 0xfc, 0xff, 0x03, 0xfe, 0xff, 0x00, 0x00,
  0xfc, 0xff, 0x03, 0xfe, 0xff, 0x00, 0x00, 0xfc, 0xff, 0x03, 0xfe, 0xff,
  0x00, 0x00, 0xfc, 0xff, 0x03, 0xfe, 0xff, 0x00, 0x00, 0xfc, 0xff, 0x03,
  0xfe, 0xff, 0x00, 0x00, 0xfc, 0xff, 0x03, 0xfe, 0xff, 0x00, 0x00, 0xfc,
  0xff, 0x03, 0xfe, 0xff, 0x00, 0x00, 0xfc, 0xff, 0x03, 0xfe, 0xff, 0x00,
  0x00, 0xfc, 0xff, 0x03, 0x8a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x02,
  0x00, 0xfe, 0xff, 0x01, 0x00, 0x02, 0x02, 0x00, 0xfe, 0xff, 0x01, 0x00,
  0x02, 0x02, 0x00, 0xfe, 0xff, 0x01, 0x00, 0x02, 0x02, 0x00, 0xfe, 0xff,
  0x01, 0x00, 0x02, 0x02, 0x00, 0xfe, 0xff, 0x01, 0x00, 0x02, 0x02, 0x00,
  0xfe, 0xff, 0x01, 0x00, 0x02, 0x02, 0x00, 0xfe, 0xff, 0x01, 0x00, 0x02,
  0x02, 0x00, 0xfe, 0xff, 0x01, 0x00, 0x02, 0x02, 0x00, 0xfe, 0xff, 0x01,
  0x00, 0x02, 0x02, 0x00, 0xfe, 0xff, 0x01, 0x00, 0x02, 0x02, 0x00, 0xfe,
  0xff, 0x01, 0x00, 0x02, 0x02, 0x00, 0xfe, 0xff, 0x01, 0x00, 0x02, 0x02,
  0x00, 0xfe, 0xff, 0x01, 0x00, 0x02, 0x02, 0x00, 0xfe, 0xff, 0x01, 0x00,
  0x02, 0x02, 0x00, 0xfe, 0xff, 0x01, 0x00, 0x02, 0x02, 0x00, 0xfe, 0xff,
  0x01, 0x00, 0x02, 0x02, 0x00, 0xfe, 0xff, 0x01, 0x00, 0x02, 0x02, 0x00,
  0xaa, 0xaa, 0x00, 0x00, 0x02, 0x06, 0x44, 0x00, 0x00, 0x54, 0xd5, 0x03,
  0xfe, 0xff, 0x00, 0x00, 0xfc, 0xff, 0x03, 0xfe, 0xff, 0x00, 0x00, 0xfc,
  0xff, 0x03, 0xfe, 0xff, 0x00, 0x00, 0xfc, 0xff, 0x03, 0xfe, 0xff, 0x00,
  0x00, 0xfc, 0xff, 0x03, 0xfe, 0xff, 0x00, 0x00, 0xfc, 0xff, 0x03, 0xfe,
  0xff, 0x00, 0x00, 0xfc, 0xff, 0x03, 0xfe, 0xff, 0x00, 0x00, 0xfc, 0xff,
  0x03, 0xfe, 0xff, 0x00, 0x00, 0xfc, 0xff, 0x03, 0xfe, 0xff, 0x00, 0x00,
  0xfc, 0xff, 0x03, 0xfe, 0xff, 0x00, 0x00, 0xfc, 0xff, 0x03, 0xfe, 0xff,
  0x00, 0x00, 0xfc, 0xff, 0x03, 0xfe, 0xff, 0x00, 0x00, 0xfc, 0xff, 0x03,
  0xfe, 0xff, 0x00, 0x00, 0xfc, 0xff, 0x03, 0xfe, 0xff, 0x00, 0x00, 0xfc,
  0xff, 0x03, 0xfe, 0xff, 0x00, 0x00, 0xfc, 0xff, 0x03, 0xfe, 0xff, 0x01,
  0x00, 0xfc, 0xff, 0x03, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03
};

void setup()
{
  StoppUhr.attach(TASTER);

  // Display starten
  oled.begin();

  // Kontrast maximal 255
  oled.setContrast(200);
  pinMode(TASTER, INPUT_PULLUP);

  // Stoppuhr anzeigen
  oled.firstPage();
  do
  {
    oled.drawXBM(40, 1, StoppuhrBreite, StoppuhrHoehe, Stoppuhr);
  }
  while (oled.nextPage());
}

void loop()
{
  // Farbe weiß
  oled.setDrawColor(1);

  // Beginn des Countdowns
  int Nummer = 9;
  int TasterLesen = digitalRead(TASTER);

  // Taster gedrückt
  if (StoppUhr.update())
  {
    if (StoppUhr.read() == LOW)
    {
      oled.setFont(u8g2_font_logisoso62_tn);
      while (Nummer > 0)
      {
        oled.firstPage();
        do
        {
          oled.setFontDirection(0);
          oled.setCursor(50, BildschirmHoehe);
          oled.print(Nummer);
        }
        while (oled.nextPage());
        delay(1000);
        Nummer --;
      }

      // Ziel anzeigen
      oled.firstPage();
      do
      {
        oled.drawXBM(40, 5, ZielBreite, ZielHoehe, Zielflagge);
      }
      while (oled.nextPage());
    }
  }
}

Letzte Aktualisierung:

#include "U8g2lib.h"
#include "Bounce2.h"

int Minimum = 1;
int Maximum = 7;
int TASTER = 7;

/*
  OLED initialisieren
  Controller: SH1106 oder SSD1306
  es wird der page buffer mode verwendet
  Typbezeichnung mit Bildschirmgröße in Pixeln
  1 = page buffer mode, F = full screen buffer mode 
  Hardware I2C 
  Name des OLEDs
  Rotation R0 (keine)
*/

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

// Bounce initialisieren
Bounce Wuerfel = Bounce();

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

  // Taster Bounce zuordnen
  Wuerfel.attach(TASTER);
  Wuerfel.interval(20); 

  oled.begin();

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

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

  // Position 90 Grad
  oled.clearDisplay();
  oled.setFont(u8g2_font_t0_22_te);

  // oled.setDisplayRotation(U8G2_R1);
  oled.setFlipMode(1);

  // Hinweis anzeigen
  oled.firstPage();
  do
  {
    oled.drawStr(2, 20, "Start");
    oled.drawStr(2, 50, "->");
    oled.drawStr(2, 80, "Taste");
  }
  while (oled.nextPage());

  oled.setDisplayRotation(U8G2_R0);
  oled.setFlipMode(1);
}

void Wuerfeln()
{
  int Zahl =  random(Minimum, Maximum);
  oled.firstPage();

  // Würfelaugen zeichnen
  // 1
  if (Zahl == 1)
  {
    do
    {
      oled.drawRFrame(0, 0, 128, 64, 5);
      oled.drawDisc(60, 32, 8);
    }
    while (oled.nextPage());
  }

  // 2
  if (Zahl == 2)
  {
    do
    {
      oled.drawRFrame(0, 0, 128, 64, 5);
      oled.drawDisc(14, 14, 8);
      oled.drawDisc(112, 50, 8);
    }
    while (oled.nextPage());
  }

  // 3
  if (Zahl == 3)
  {
    do
    {
      oled.drawRFrame(0, 0, 128, 64, 5);
      oled.drawDisc(14, 14, 8);
      oled.drawDisc(60, 32, 8);
      oled.drawDisc(112, 50, 8);
    }
    while (oled.nextPage());
  }

  // 4
  if (Zahl == 4)
  {
    do
    {
      oled.drawRFrame(0, 0, 128, 64, 5);
      oled.drawDisc(14, 14, 8);
      oled.drawDisc(14, 50, 8);
      oled.drawDisc(112, 14, 8);
      oled.drawDisc(112, 50, 8);
    }
    while (oled.nextPage());
  }

  // 5
  if (Zahl == 5)
  {
    do
    {
      oled.drawRFrame(0, 0, 128, 64, 5);
      oled.drawDisc(14, 14, 8);
      oled.drawDisc(60, 32, 8);
      oled.drawDisc(112, 14, 8);
      oled.drawDisc(14, 50, 8);
      oled.drawDisc(112, 50, 8);
    }
    while (oled.nextPage());
  }

  // 6
  if (Zahl == 6)
  {
    do
    {
      oled.drawRFrame(0, 0, 128, 64, 5);
      oled.drawDisc(14, 14, 8);
      oled.drawDisc(60, 14, 8);
      oled.drawDisc(112, 14, 8);
      oled.drawDisc(14, 50, 8);
      oled.drawDisc(60, 50, 8);
      oled.drawDisc(112, 50, 8);
    }
    while (oled.nextPage());
  }
}

void loop()
{
  if (Wuerfel.update())
  {
    if (Wuerfel.read() == LOW)
    {
      // Würfeleffekt: Zufallszahlen in schneller Folge anzeigen
      // bedingt durch den Page buffer mode nicht sehr schnell
      for (int i = 0; i < 5; i++)
      {
        int Zahl =  random(Minimum, Maximum);

        Wuerfeln();
        delay(50);
      }
    }
  }
}

Letzte Aktualisierung:

boolean TASTER;

// Würfelaugen 1 bis 6
int Minimum = 1;
int Maximum = 7;

void setup()
{
  // Pins 7 bis 3 als OUTPUT definieren
  DDRD = B11111000;

  // Pins 8 bis 9 als OUTPUT definieren
  DDRB = B00000011;

  // Pin 13 auf HIGH schalten
  PORTB = B00100000;

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

  // Test ob alle LEDs leuchten
  PORTD = B11111000;
  PORTB = B00000011;
}

void loop()
{
  boolean TASTER;
  int Minimum = 1;
  int Maximum = 7;

  /*
    Port B lesen
    Bit 13 wird ausgeblendet (PINB & B00100000),
    damit der Wert gelesen werden kann
  */
  TASTER = PINB & B00100000;

  // Taster gedrückt, Pin 13 hat den Wert 0 (false)
  if (!TASTER)
  {
    delay(200);
    int Zahl = random(Minimum, Maximum);

    switch (Zahl)
    {
      case 1:
        AlleAus();
        PORTD = B01000000;
        break;

      case 2:
        AlleAus();
        PORTD = B10100000;
        break;

      case 3:
        AlleAus();
        PORTD = B11100000;
        break;

      case 4:
        AlleAus();
        PORTD = B10101000;
        PORTB = B00000010;
        break;

      case 5:
        AlleAus();
        PORTD = B11101000;
        PORTB = B00000010;
        break;

      case 6:
        AlleAus();
        PORTD = B10111000;
        PORTB = B00000011;
        break;

      default:
        break;
    }
  }
}

void AlleAus()
{
  PORTD = 0;
  PORTB = 0;
}

Letzte Aktualisierung: