Spiele, MINT Ideen und Projekte auf dem Open Smart Rich Shield V1

Details: Kategorie: Arduino neue Ideen; Erstellt: 05. März 2026; Zugriffe: 279

Diese 40 Projektideen verwandeln dein Rich Shield v1.0 in ein vielseitiges Werkzeuglabor, mit dem du von praktischen Alltagshelfern bis hin zu komplexen Logikspielen alles selbst entwickeln kannst. Durch die Kombination von Sensoren, Aktoren und dem Display lernst du spielerisch, mit Hardware und Software interagieren, um reale Probleme digital zu lösen. Besonders die integrierten MINT-Projekte schärfen dabei dein Verständnis für physikalische Messungen und mathematische Algorithmen direkt am Mikrocontroller.

Stück für die Stück werde ich die 40 Projekte hier fertig machen und hochladen ;-).

🏠 Alltag & Lifestyle (10 Ideen)

Eieruhr mit Alarm: Poti stellt die Minuten ein, Display zählt runter, Buzzer meldet "Fertig".
Licht-Wecker: Der LDR erkennt den Sonnenaufgang und spielt eine Melodie über den Buzzer.
Digitaler Würfel: Nach Knopfdruck läuft eine Animation auf dem Display und stoppt bei einer Zufallszahl (1-6).
Reaktionszeit-Tester: Eine LED leuchtet zufällig auf, und du musst so schnell wie möglich den Button drücken – die Zeit erscheint im Display.
Post-Eingangs-Warner: Das Shield im Briefkasten misst per LDR, ob der Schlitz geöffnet wurde.
Pflanzen-Monitor: Misst Temperatur/Feuchtigkeit und die rote LED blinkt, wenn es zu warm/trocken ist.
Zollstock-Ersatz (Schrittzähler-Prinzip): Ein Button-Druck zählt Distanzen oder Klicks beim Abmessen von Objekten.
Nachtlicht mit Automatik: LEDs schalten sich bei Dunkelheit ein und per Poti lässt sich die Helligkeit regeln.
Tresor-Simulation: Gibt den richtigen Code ein, dann öffent sich der Tersor.
Kühlschrank-Wächter: Alarm schlägt an, wenn die Tür zu lange offen steht (LDR registriert Licht).

🎮 Spiele & Unterhaltung (10 Ideen)

"Heißer Draht" (Digital): Nutze einen externen Draht am Voltage Sensor Pin; bei Kontakt summt der Buzzer und ein Fehlerzähler im Display steigt.
Simon Says: Das Shield gibt eine Blinkfolge vor, die du über die Buttons nachspielen musst.
Metronom für Musiker: Poti regelt die BPM, der Buzzer gibt den Takt vor, die LEDs blinken im Rhythmus.
Glücksrad: 2 Blöcke der 7 Segmentanzeige rotieren im Kreis, werden langsamer und bleiben bei einem zufälligen "Strich" stehen.
Ping-Pong Scoreboard: Zwei Buttons zählen die Punkte für zwei Spieler im Display hoch.
Lügendetektor (Gimmick): Misst über den Voltage Sensor (Hautwiderstand) "Stress" und lässt die rote LED flackern.
Space Invader: Bewege dein Raumschiff an den bösen Strichen vorbei die auf dich zu rasen.
Morse-Trainer: Gib per Button Morsezeichen ein, das Display übersetzt sie (oder gibt Buchstaben vor).
Countdown-Bombe (Spiel): Display zählt eine Zeit runter, und die musst den richtigen Button und den Poti richtig einstellen, um zu entschärfen.
Slot-Machine: Drei Zahlen rotieren im Display; bei drei gleichen Zahlen gibt es ein LED-Feuerwerk.

🛠️ Werkzeuge & Gadgets (10 Ideen)

Luxmeter: Anzeige der aktuellen Lichtstärke in Lux (kalibriert über den LDR).
Digitales Thermometer: Präzise Anzeige der Raumtemperatur mit Min/Max-Speicherung (über Buttons abrufbar).
Volt-Meter: Nutze den Voltage-Sensor-Anschluss, um Spannungen von Batterien (bis 28Volt) zu messen und anzuzeigen.
Infrarot-Fernbedienungs-Tester: Der IR-Empfänger prüft, ob eine Fernbedienung noch sendet (LED-Feedback).
Park-Hilfe Simulation: Ein (externer) Ultraschallsensor wird angeschlossen, das Shield zeigt die Distanz und piept schneller, je näher man kommt.
Stoppuhr: Start/Stopp per Button K1.
Passwort-Manager (Einfach): Poti wählt Zeichen, Button bestätigt; generiert einen 4-stelligen Pin-Code.
Hygrometer: Anzeige der Luftfeuchtigkeit (DHT11) mit Schimmel-Warnung (LED).
TV-Mute-Button: Sendet über eine IR-Diode (falls vorhanden) den Mute-Befehl an den Fernseher.
Binär-Uhr-Trainer: Das Display zeigt eine Zahl, du musst sie mit den LEDs binär nachstellen.

🧪 MINT-Projektideen (Bildung & Wissenschaft)

Untersuchung der Verdunstungskälte: Wickle ein feuchtes Tuch um den NTC/DHT11 und beobachte den Temperaturabfall im Display.
Taupunkt-Rechner: Berechne aus Temperatur und Luftfeuchtigkeit den Taupunkt und zeige an, wann Wasser kondensiert.
Lichtgeschwindigkeits-Modell: Demonstriere das Abstandsgesetz des Lichts mit dem LDR und einer Taschenlampe in verschiedenen Abständen.
Wärmekapazitäts-Tester: Vergleiche, wie schnell sich der NTC-Sensor bei verschiedenen Materialien (Hand, kaltes Wasser, Föhn) erwärmt/abkühlt.
Statistik-Generator: Würfle 100-mal automatisch (Zufallszahlen) und zeige am Ende die Häufigkeitsverteilung der Zahlen im Display.
Photosynthese-Monitor: Platziere das Shield bei einer Pflanze und logge die Lichtstunden pro Tag (LDR-Schwellenwert-Analyse).
Kalorimeter-Simulation: Berechne die Energie (theoretisch), die nötig ist, um die gemessene Umgebungsluft zu erwärmen.
Frequenz-Experiment: Erzeuge mit dem Buzzer Töne und bestimme die Resonanzfrequenz von Alltagsgegenständen (akustische Physik).
Batterie-Entladekurve: Miss über Zeitintervalle die Spannung einer Batterie am Voltage-Sensor und zeige den Abfall an.
Binär-Dezimal-Konverter: Gib über die Buttons einen 4-Bit-Binärcode ein und das Display zeigt den Dezimalwert sofort an.

1, die Eieruhr

Die Entwicklung der Eieruhr auf Basis des Rich Shield v1.0 ohne externe Zeit-Bibliotheken ist ein hervorragendes Beispiel für hardwarenahe Programmierung, bei der man die volle Kontrolle über die CPU-Zyklen behält. Durch die Nutzung der internen millis()-Funktion hast du ein nicht-blockierendes System geschaffen, das es dem Arduino erlaubt, gleichzeitig die verbleibende Zeit zu berechnen, das TM1637-Display zu aktualisieren und jederzeit auf Benutzereingaben über die Taster zu reagieren.

Der Arduino Code

#include<arduino.h>
#include<TM1637Display.h>
const int CLK = 10;
const int DIO = 11;
TM1637Display display(CLK,DIO);

const int K1 = 8;
const int K2 = 9;
const int blau = 6;
const int rot = 7;
const int summer = 3;
int analogA0 = A0;
int vergangenEieruhr = 0;
int ablauf = 0; 
unsigned long eieruhr = 0;
unsigned long zeitstempel = 0;

bool letzterK1 =1;
bool statusK1 =0;

void setup() {
  display.setBrightness(5);
  pinMode(K1,INPUT_PULLUP);
  pinMode(blau, OUTPUT);
  pinMode(rot,OUTPUT);
  pinMode(summer,OUTPUT);
  display.showNumberDec(0,true);
  Serial.begin(9600);
}

void loop() {
  statusK1 = digitalRead(K1);
  if (statusK1 == 0 && letzterK1 == 1){
    delay(50);
    ablauf++;
  }
  letzterK1 = statusK1;

  
  if (ablauf == 0){
      display.showNumberDec(0,true);
      ablauf++;
      }
    
  if (ablauf ==2 ){
    analogA0 = map(analogRead(A0),10,1010,1,30);
    display.showNumberDec(analogA0);
    }

  if (ablauf == 3){
    digitalWrite(blau,1);
    vergangenEieruhr = analogA0 * 60;
    zeitstempel = millis();
    ablauf++;
  }

  if (ablauf == 4) {
  unsigned long jetzt = millis();
  unsigned long vergangenMs = jetzt - zeitstempel;
  long restSekunden = (long)vergangenEieruhr - (vergangenMs / 1000);


  unsigned long anzeigeMinuten = (restSekunden + 59) / 60; 
  display.showNumberDec(anzeigeMinuten);  
  if (restSekunden <= 0) {
    ablauf = 5;
    digitalWrite(summer, 1);
    digitalWrite(blau, 0);
    digitalWrite(rot, 1); 
  }
}

  if(ablauf == 5){
    //warte auf Eingabe
  }

 if(ablauf == 6){
      digitalWrite(summer,0);
      digitalWrite(rot,0);
      delay(300);
      display.showNumberDec(0,true);
      ablauf = 0;
 }
}

3. digitaler Würfel

Das Prinzip hinter diesem Würfel ist so simpel wie genial: Eingabe, Action, Ergebnis. Sobald du den Strom einschaltest, begrüßt dich das Display mit einem motivierenden „LOS“. Das Programm wartet dann geduldig im Hintergrund, bis du den Taster drückst. Sobald dein Finger den Knopf berührt, startet die Animation: Ein einzelner Strich jagt in rasantem Tempo im Kreis über das Display. Das sieht nicht nur cool aus, sondern überbrückt auch die Zeit, während der Arduino im Hintergrund eine echte Zufallszahl zwischen 1 und 6 berechnet. Das Beste daran: Durch die Dauer der Animation wird der Taster automatisch „entprellt“ – Mehrfachklicks durch zittrige Finger haben also keine Chance. Am Ende stoppt das Kreisen und dein Ergebnis erscheint groß und deutlich auf der Anzeige. Ein erneuter Druck löscht die alte Zahl und das Spiel beginnt von vorn!

Der Arduino Code für den Arduino Würfel

#include<arduino.h>
#include<TM1637Display.h>
const int CLK = 10;
const int DIO = 11;
TM1637Display display(CLK,DIO);
const int K1 = 8;
int zufall = 0; 

uint8_t wortLos[] = {
    SEG_F | SEG_E | SEG_D ,              
    SEG_A | SEG_B | SEG_C | SEG_D | SEG_E | SEG_F,   
    SEG_A | SEG_F | SEG_G | SEG_C | SEG_D,   
    0X00                          
  };
uint8_t kreis[] = { SEG_A, SEG_B, SEG_C, SEG_D, SEG_E, SEG_F };

void setup() {
  display.setBrightness(5);
  randomSeed(analogRead(4));
  display.setSegments(wortLos);
  pinMode(K1,INPUT_PULLUP);
}

void loop() {
      
    if(digitalRead(K1) == 0){
      Serial.println("druck");
      for (int a=0; a<6;a++){
        for (int i=0; i<6; i++){
            uint8_t muster[] = { 0x00, kreis[i], 0x00, 0x00 };
            display.setSegments(muster);
            delay(30); 
      }
      }
      zufall = random(1,7);
      display.showNumberDec(zufall);
  }
}

9, Digitaler Arduino Safe mit 4 Stellen:

Das Spiel beginnt damit, dass dir das System für zwei Sekunden die geheime Kombination verrät, bevor das Display erlischt und die blaue LED deine Einsatzbereitschaft abfragt. Da die Steuerung komplett über den Taster K1 läuft, erhöhst du mit jedem kurzen Tippen die Ziffer an der aktuellen Stelle, während ein langer Druck die Zahl fest einloggt. Sobald der Mikrocontroller die Zeitdauer von 600 Millisekunden erkennt, springt er sofort zur nächsten Stelle, quittiert dies mit einem Piepton und zeigt zur Orientierung eine Null als neuen Startwert an.

Sind alle vier Ziffern eingegeben, startet eine zweisekündige Matrix-Animation aus wirren Zufallszahlen, die den internen Rechenvorgang visualisiert. War deine Eingabe korrekt, wechselt die LED auf Rot, ein hoher Bestätigungston erklingt und das Display signalisiert mit dem Wort „LOS“ den Erfolg. War die Kombination hingegen falsch, bleibt die blaue LED aktiv, während ein tiefes, 1,5 Sekunden langes Brummen den Fehlversuch untermalt, bevor das System das Display leert und für den nächsten Einbruchsversuch bereitsteht.

Der Arduino Code für den digital Save.

#include <TM1637Display.h>

// Pins
#define CLK 10 
#define  DIO 11
const int BUZZER = 3;
const int LED_BLAU = 6;
const int LED_ROT = 4;
const int K1 = 8;

TM1637Display display(CLK, DIO);

// Variablen
int geheimCode[4];
int eingegebenerCode[4];
int aktuellerDigitIndex = 0;
int aktuellerWert = 0;
int schritt = 1; 

const uint8_t SEG_LOS[] = {
  0x38, 0x3F, 0x6D, 0x00 // L O S _
};

void setup() {
  pinMode(BUZZER, OUTPUT);
  pinMode(LED_BLAU, OUTPUT);
  pinMode(LED_ROT, OUTPUT);
  pinMode(K1, INPUT_PULLUP);
  
  display.setBrightness(0x0f);
  randomSeed(analogRead(A4));

  // 1. Code generieren
  for (int i = 0; i < 4; i++) geheimCode[i] = random(0, 10);
  
  // 2. Code anzeigen
  for (int i = 0; i < 4; i++) display.showNumberDecEx(geheimCode[i], 0, true, 1, i);
  delay(2000);
  
  // 3. Startzustand
  display.clear();
  digitalWrite(LED_BLAU, HIGH);
  digitalWrite(LED_ROT, LOW);
  display.showNumberDecEx(0, 0, true, 1, 0); // Erste 0 anzeigen
  
  schritt = 1; 
}

void loop() {
  
  // --- SCHRITT 1: EINGABE ---
  if (schritt == 1) {
    if (digitalRead(K1) == LOW) {
      unsigned long startZeitPress = millis();
      bool bereitsBestaetigt = false;

      // Während gedrückt gehalten wird...
      while (digitalRead(K1) == LOW) {
        // Checken: Ist es JETZT gerade ein langer Druck geworden?
        if (!bereitsBestaetigt && (millis() - startZeitPress > 600)) {
          
          // SOFORT-REAKTION (bevor losgelassen wird):
          eingegebenerCode[aktuellerDigitIndex] = aktuellerWert;
          tone(BUZZER, 3000, 50); // Bestätigungs-Piep
          
          aktuellerDigitIndex++;
          aktuellerWert = 0; 
          
          if (aktuellerDigitIndex <= 3) {
            display.showNumberDecEx(0, 0, true, 1, aktuellerDigitIndex);
          }
          
          bereitsBestaetigt = true; // Merken, dass für diesen Druck alles erledigt ist
        }
        
        // Optisches Feedback während des Haltens
        if (millis() - startZeitPress > 600) display.setBrightness(0x01);
      }
      
      // NACH DEM LOSLASSEN:
      display.setBrightness(0x0f);
      
      // Wenn es nur ein kurzer Druck war (nicht bestätigt wurde):
      if (!bereitsBestaetigt) {
        aktuellerWert++;
        if (aktuellerWert > 9) aktuellerWert = 0;
        display.showNumberDecEx(aktuellerWert, 0, true, 1, aktuellerDigitIndex);
      }
      
      // Prüfen, ob wir nach der Bestätigung fertig sind
      if (aktuellerDigitIndex > 3) schritt = 2;

      delay(100); // Kleiner Entprell-Schutz
    }
  }

  // --- SCHRITT 2: MATRIX ANIMATION ---
  if (schritt == 2) {
    display.clear();
    unsigned long animStart = millis();
    while (millis() - animStart < 2000) {
      display.showNumberDec(random(0, 9999), false);
      delay(70);
    }
    display.clear();
    schritt = 3;
  }

  // --- SCHRITT 3: AUSWERTUNG ---
  if (schritt == 3) {
    bool korrekt = true;
    for (int i = 0; i < 4; i++) {
      if (eingegebenerCode[i] != geheimCode[i]) korrekt = false;
    }

    if (korrekt) {
      digitalWrite(LED_BLAU, LOW);
      digitalWrite(LED_ROT, HIGH);
      tone(BUZZER, 2000, 200); 
      display.setSegments(SEG_LOS);
      delay(2000);
      display.clear();
      digitalWrite(LED_ROT, LOW);
      digitalWrite(LED_BLAU, HIGH);
      
      // Reset für neue Runde
      aktuellerDigitIndex = 0;
      aktuellerWert = 0;
      display.showNumberDecEx(0, 0, true, 1, 0);
      schritt = 1;
    } else {
      schritt = 4;
    }
  }

  // --- SCHRITT 4: FEHLER ---
  if (schritt == 4) {
    tone(BUZZER, 150, 1500); 
    delay(1500);
    display.clear();
    
    // Reset für neuen Versuch
    aktuellerDigitIndex = 0;
    aktuellerWert = 0;
    display.showNumberDecEx(0, 0, true, 1, 0);
    schritt = 1;
  }
}

14. Digitales Glücksrad

Das Prinzip hinter diesem Glücksrad ist so interaktiv wie spannend: Eingabe, Action, Timing. Sobald du das Rich Shield einschaltest, signalisiert dir eine leuchtende grüne LED, dass das System bereit für den nächsten Einsatz ist. Das Programm verweilt geduldig im Standby, bis du den Taster K1 drückst.

Sobald der Startschuss fällt, erwacht die Anzeige zum Leben: Die rote LED springt an und ein einzelnes Segment jagt in rasantem Tempo über die hinteren beiden Blöcke des Displays. Durch die gezielte Ansteuerung der äußeren Segmente entsteht die optische Täuschung eines großen, kreisenden Ovals. In dieser Phase hast du als Spieler die volle Kontrolle oder zumindest das Gefühl davon: Erst wenn du K1 ein zweites Mal drückst, leitest du den Bremsvorgang ein. Die rote LED erlischt und das Rad beginnt physikalisch korrekt auszurollen, indem es mit jedem Schritt spürbar langsamer wird. Bleibt das Segment schließlich stehen, leuchtet die grüne LED wieder auf und verkündet das Ergebnis.

Das Besondere an diesem Projekt ist die technische Umsetzung der Logik:

Die enum-Variante: Diese Methode nutzt sprechende Namen wie SPINNING oder SLOWING. Das macht den Code besonders für Profis lesbar, da man sofort sieht, in welcher Phase („Zustand“) sich das Rad gerade befindet.
Die 1, 2, 3, 4-Variante: Dieser Ansatz ist ideal für den Einstieg. Hier steuert eine einfache Zahl die Logik von der Bereitschaft (1) über das Drehen (2) und Bremsen (3) bis hin zum Reset (4).

Beide Wege führen zum selben Ziel: Einem flüssigen Spielablauf, bei dem das Timing des Spielers darüber entscheidet, auf welchem Segment das Rad am Ende zum Stehen kommt!

Der Arduino Code für das Glücksrad

#include <TM1637Display.h>

// Pins für Rich Shield
const int CLK = 10;
const int DIO = 11;
const int BTN_K1 = 8;
const int LED_RED = 4;
const int LED_GREEN = 5;

TM1637Display display(CLK, DIO);

// Definition der Segmente für ein großes Oval über Block 2 und 3
// Segmente: A=0x01, B=0x02, C=0x04, D=0x08, E=0x10, F=0x20
const uint8_t wheelSteps[] = {
  0x01, // Block 2, Segment A (Oben links)
  0x01, // Block 3, Segment A (Oben rechts)
  0x02, // Block 3, Segment B (Rechts oben)
  0x04, // Block 3, Segment C (Rechts unten)
  0x08, // Block 3, Segment D (Unten rechts)
  0x08, // Block 2, Segment D (Unten links)
  0x10, // Block 2, Segment E (Links unten)
  0x20  // Block 2, Segment F (Links oben)
};

// Die zugehörigen Positionen auf dem Display (0, 1, 2, 3)
// Wir nehmen die hinteren beiden: 2 und 3
const int wheelPositions[] = {2, 3, 3, 3, 3, 2, 2, 2};

enum State { IDLE, SPINNING, SLOWING };
State currentState = IDLE;

int currentStep = 0;
float spinDelay = 60; // Startgeschwindigkeit
bool lastBtnState = HIGH;

void setup() {
  pinMode(BTN_K1, INPUT_PULLUP);
  pinMode(LED_RED, OUTPUT);
  pinMode(LED_GREEN, OUTPUT);
  display.setBrightness(0x0f);
  display.clear();
  digitalWrite(LED_GREEN, HIGH); // Startzustand: Grün leuchtet
}

void loop() {
  bool btnState = digitalRead(BTN_K1);

  // K1 Taster Logik
  if (btnState == LOW && lastBtnState == HIGH) {
    delay(50); // Entprellen
    if (currentState == IDLE) {
      currentState = SPINNING;
      spinDelay = 40; // Schneller Start
    } else if (currentState == SPINNING) {
      currentState = SLOWING;
    }
  }
  lastBtnState = btnState;

  switch (currentState) {
    case IDLE:
      digitalWrite(LED_GREEN, HIGH);
      digitalWrite(LED_RED, LOW);
      break;

    case SPINNING:
      digitalWrite(LED_GREEN, LOW);
      digitalWrite(LED_RED, HIGH);
      animate();
      delay((int)spinDelay);
      break;

    case SLOWING:
      digitalWrite(LED_RED, LOW);
      animate();
      delay((int)spinDelay);
      spinDelay *= 1.1; // Exponentiell langsamer für "echtes" Gefühl
      
      if (spinDelay > 500) { // Stopp-Punkt
        currentState = IDLE;
      }
      break;
  }
}

void animate() {
  display.clear();
  uint8_t seg[] = { wheelSteps[currentStep] };
  display.setSegments(seg, 1, wheelPositions[currentStep]);
  
  currentStep++;
  if (currentStep >= 8) currentStep = 0;
}

Der Arduino Code für das Glücksrad mit "enum"

#include <TM1637Display.h>

// Pins für Rich Shield V1.0
const int CLK = 10;
const int DIO = 11;
const int BTN_K1 = 8;
const int LED_RED = 4;
const int LED_GREEN = 5;

TM1637Display display(CLK, DIO);

// Definition des "großen Ovals" über Digit 2 und 3
const uint8_t wheelSteps[] = {
  0x01, // Digit 2, Seg A (Oben links)
  0x01, // Digit 3, Seg A (Oben rechts)
  0x02, // Digit 3, Seg B (Rechts oben)
  0x04, // Digit 3, Seg C (Rechts unten)
  0x08, // Digit 3, Seg D (Unten rechts)
  0x08, // Digit 2, Seg D (Unten links)
  0x10, // Digit 2, Seg E (Links unten)
  0x20  // Digit 2, Seg F (Links oben)
};

const int wheelPositions[] = {2, 3, 3, 3, 3, 2, 2, 2};

// Zustands-Variable: 1=Bereit, 2=Drehen, 3=Bremsen, 4=Stopp/Reset
int state = 1; 

int currentStep = 0;
float spinDelay = 50;
bool lastBtnState = HIGH;

void setup() {
  pinMode(BTN_K1, INPUT_PULLUP);
  pinMode(LED_RED, OUTPUT);
  pinMode(LED_GREEN, OUTPUT);
  display.setBrightness(0x0f);
  display.clear();
}

void loop() {
  bool btnState = digitalRead(BTN_K1);

  // Taster-Abfrage mit Entprellung
  if (btnState == LOW && lastBtnState == HIGH) {
    delay(50); 
    if (state == 1) {
      state = 2; // Starten
      spinDelay = 50;
    } else if (state == 2) {
      state = 3; // Bremsen einleiten
    }
    lastBtnState = LOW;
  }
  if (btnState == HIGH) lastBtnState = HIGH;

  // Ablaufsteuerung über die Zustände 1 bis 4
  if (state == 1) { 
    // ZUSTAND 1: Warten (IDLE)
    digitalWrite(LED_GREEN, HIGH);
    digitalWrite(LED_RED, LOW);
  } 
  else if (state == 2) { 
    // ZUSTAND 2: Drehen (SPINNING)
    digitalWrite(LED_GREEN, LOW);
    digitalWrite(LED_RED, HIGH);
    animateWheel();
    delay((int)spinDelay);
  } 
  else if (state == 3) { 
    // ZUSTAND 3: Langsamer werden (SLOWING)
    digitalWrite(LED_RED, LOW); 
    digitalWrite(LED_GREEN, LOW);
    animateWheel();
    delay((int)spinDelay);
    
    spinDelay *= 1.15; // Verzögerung erhöhen (Brems-Effekt)
    
    if (spinDelay > 600) { 
      state = 4; // Zum Stopp-Zustand wechseln
    }
  } 
  else if (state == 4) { 
    // ZUSTAND 4: Stehenbleiben (RESET)
    digitalWrite(LED_GREEN, HIGH);
    // Kurz warten, damit das Ergebnis sichtbar bleibt, dann zurück zu 1
    delay(1000); 
    state = 1;
  }
}

void animateWheel() {
  display.clear();
  uint8_t seg[] = { wheelSteps[currentStep] };
  display.setSegments(seg, 1, wheelPositions[currentStep]);
  
  currentStep++;
  if (currentStep >= 8) currentStep = 0;
}

17 Space Invaders "Light": Das 7-Segment-Endlos-Spiel für das Open-Smart Rich Shield 1

Willkommen zu einer kompakten Version eines minimalistischen Endlos-Runners, direkt auf deinem Arduino! In diesem Projekt verwandelst du das 4-stellige 7-Segment-Display des Open-Smart Rich Shields in eine rasante Ausweichstrecke. Die Ursprungsidee Die Grundidee und der ursprüngliche Code für dieses Spiel stammen von meiner Webseite . Dort habe ich das "Dino Run" Spiel ursprünglich für das größere QYF-TM1638-Board (HCW-132) mit seinen 8 Ziffern programmiert und es hier nur für das kleine Display geändert.

Was erwartet dich in dieser Version?

Kompaktes Spielfeld: Da das Rich Shield über 4 Ziffern verfügt, ist die Reaktionszeit deutlich knackiger. Du musst die herannahenden Hindernisse schneller erkennen!
Intuitive Steuerung: Gesteuert wird über die integrierten Taster des Shields. Mit K1 (Pin 8) springst du hoch, mit K2 (Pin 9) bewegst du dich nach unten.
Minimalistisches Gameplay: Du bist ein leuchtendes Segment und weichst den nahenden Strichen (Hindernissen auf drei Höhen) aus. Je weiter du kommst, desto schneller wird das Spiel.
Highscore-Anzeige: Nach einem Crash wechselt das Display zwischen der Anzeige "FAIL" und deinen hart verdienten Punkten.

Der Arduino Code für das Space Invaders Spiel

#include <TM1637Display.h>

// --- PINS FÜR DAS DISPLAY ---
#define CLK 10
#define DIO 11

// --- PINS FÜR DIE TASTER ---
const int K1 = 8; // Taster Hoch
const int K2 = 9; // Taster Runter

TM1637Display display(CLK, DIO);

// --- GESCHWINDIGKEIT ---
int startSpeed = 700;    // Start-Geschwindigkeit (max. Zeit zwischen Schritten)
int minSpeed = 300;      // Maximale Spielgeschwindigkeit (min. Zeit)
int speedDecrease = 2;   // Um wie viele ms wird es pro Schritt schneller?

const uint8_t PLAYER_TOP = 0x01; 
const uint8_t PLAYER_MID = 0x40; 
const uint8_t PLAYER_BOT = 0x08; 

// Hindernisse (nur Striche)
const uint8_t OBS_TOP_LINE  = 0x01; 
const uint8_t OBS_MID_LINE  = 0x40; 
const uint8_t OBS_BOT_LINE  = 0x08; 

uint8_t obstacles[] = { OBS_TOP_LINE, OBS_MID_LINE, OBS_BOT_LINE };

// --- TEXTE FÜR DAS 4-DIGIT DISPLAY ---
// Hex-Codes für "PLAY"
const uint8_t textPlay[] = { 0x73, 0x38, 0x77, 0x6E };
// Hex-Codes für "FAIL"
const uint8_t textFail[] = { 0x71, 0x77, 0x06, 0x38 };

// --- SPIEL-VARIABLEN ---
uint8_t board[4] = {0, 0, 0, 0}; 
uint8_t playerPos = PLAYER_BOT;              
int score = 0;
int gameSpeed = startSpeed;      
unsigned long lastMoveTime = 0;  
int gapCounter = 3;              

bool isWaiting = true;   
bool isGameOver = false; 

// Taster-Status merken (Flankenerkennung)
bool lastUpState = true;   
bool lastDownState = true; 

void setup() {
  pinMode(K1, INPUT_PULLUP);
  pinMode(K2, INPUT_PULLUP);
  
  display.setBrightness(0x0f); // Maximale Helligkeit
  display.clear();
  
  randomSeed(analogRead(0));

  // Zeige "PLAY" zum Start
  display.setSegments(textPlay);
}

void loop() {
  // Aktuellen Status der Taster lesen (LOW = gedrückt beim Rich Shield)
  bool upState = digitalRead(K1);
  bool downState = digitalRead(K2);

  // Flankenerkennung
  bool upPressed = (upState == LOW && lastUpState == HIGH);
  bool downPressed = (downState == LOW && lastDownState == HIGH);

  lastUpState = upState;
  lastDownState = downState;

  bool anyBtnPressed = (upPressed || downPressed);

  // 1. DER STARTBILDSCHIRM
  if (isWaiting) {
    if (anyBtnPressed) { 
      isWaiting = false; 
      resetGame();       
    }
    delay(20); 
    return;    
  }

  // 2. DER GAME OVER BILDSCHIRM
  if (isGameOver) {
    // Zeige abwechselnd "FAIL" und den Score
    if (millis() % 2000 < 1000) {
      display.setSegments(textFail);
    } else {
      display.showNumberDec(score);
    }
    
    // Neustart durch beliebigen Tastendruck
    if (anyBtnPressed) { 
      resetGame();
    }
    delay(20);
    return; 
  }

  // 3. DAS SPIEL
  bool playerMoved = false;
  
  if (upPressed) {
    if (playerPos == PLAYER_BOT) { playerPos = PLAYER_MID; playerMoved = true; }
    else if (playerPos == PLAYER_MID) { playerPos = PLAYER_TOP; playerMoved = true; }
  }

  if (downPressed) {
    if (playerPos == PLAYER_TOP) { playerPos = PLAYER_MID; playerMoved = true; }
    else if (playerPos == PLAYER_MID) { playerPos = PLAYER_BOT; playerMoved = true; }
  }
  
  // Sofortige Kollisionsprüfung, wenn der Spieler sich bewegt
  if (playerMoved) {
    if ((board[0] & playerPos) != 0) { 
      gameOver();
      return;
    }
    drawBoard();
  }

  // Spiellogik (Bewegung der Hindernisse)
  if (millis() - lastMoveTime > gameSpeed) {
    lastMoveTime = millis();

    // Kollisionsprüfung bei herannahendem Hindernis auf Feld 0
    if ((board[1] & playerPos) != 0) {
      gameOver();
      return;
    }

    // Hindernisse nach links rücken (von Feld 3 zu 0)
    for (int i = 0; i < 3; i++) {
      board[i] = board[i+1];
    }

    // Neues Hindernis oder Lücke generieren
    if (gapCounter > 0) {
      board[3] = 0x00; // Leeres Feld
      gapCounter--;
    } else {
      board[3] = obstacles[random(0, 3)]; // 0, 1 oder 2 für die 3 Strich-Arten
      gapCounter = random(1, 3);            
    }

    score++; 
    
    // Das Spiel wird schneller
    if (gameSpeed > minSpeed) {
      gameSpeed -= speedDecrease; 
      if (gameSpeed < minSpeed) {
        gameSpeed = minSpeed;     
      }
    }

    drawBoard();
  }
}

// --- ZEICHNEN ---
void drawBoard() {
  uint8_t displayData[4]; 
  
  for (int i = 0; i < 4; i++) {
    displayData[i] = board[i];
  }
  
  // Spieler auf das erste Segment setzen (mit dem Hindernis kombinieren)
  displayData[0] = board[0] | playerPos;
  display.setSegments(displayData);
}

// --- CRASH ---
void gameOver() {
  isGameOver = true;
  display.setSegments(textFail);
  delay(1000); 
}

// --- NEUSTART ---
void resetGame() {
  for (int i = 0; i < 4; i++) board[i] = 0x00;
  playerPos = PLAYER_BOT;
  score = 0;
  
  gameSpeed = startSpeed; 
  gapCounter = 3;
  
  isGameOver = false;
  isWaiting = false;
  display.clear();
  drawBoard(); 
  lastMoveTime = millis(); 
}

19 Arduino Countdown-Bombe, entschärfe die Bombe

Das Prinzip hinter diesem nervenaufreibenden Logikrätsel ist absolute Präzision unter Zeitdruck: Start, Fokus, Entschärfung. Sobald du das System einschaltest, signalisiert dir das Display mit dem Status „6 120“, dass die Uhr tickt: 6 Aufgaben, 120 Sekunden. Ein Druck auf den Taster K1 aktiviert den Zünder – die rote LED leuchtet bedrohlich und der Countdown beginnt unerbittlich zu laufen.

Zuerst ist Fingerspitzengefühl gefragt: Du musst das Potentiometer drehen, um den richtigen Widerstandswert zu finden. Die RGB-LED dient dir dabei als Detektor: Suchst du noch, leuchtet sie Rot. Triffst du das schmale Fenster des richtigen Wertes, springt sie auf Blau um. Doch Vorsicht: Du musst den Wert für eine volle Sekunde exakt halten – zitterst du oder drehst zu weit, wird die LED wieder Rot und der interne Timer für diese Aufgabe setzt sich zurück. Erst nach drei erfolgreichen Poti-Einstellungen (bestätigt durch ein grünes Aufleuchten und einen hohen Piepser) wechselt das Spiel in die nächste Phase.

Jetzt zählt dein Gedächtnis! In drei aufeinanderfolgenden Runden musst du eine geheime Kombination aus den Tastern K1 und K2 eingeben. Die Länge des Codes kannst du dabei selbst festlegen – bis zu 9 Eingaben sind möglich. Jeder richtige Tastendruck wird mit einem kurzen blauen Blitz und einem hellen Bestätigungston belohnt. Vertippst du dich jedoch nur ein einziges Mal, ertönt ein tiefer Fehlerton und die aktuelle Sequenz muss komplett von vorn begonnen werden. Währenddessen schrumpft die Anzeige auf der ersten Stelle des Displays bei jedem Erfolg von 6 bis auf 1 herunter. Schaffst du es rechtzeitig, belohnt dich das Display mit einem erleichternden „GOOD“ und einer Siegesmelodie. Läuft die Zeit jedoch ab, bevor der letzte Code geknackt ist, quittiert der Summer das Versagen mit einer „Loser-Melodie“ und das Spiel setzt sich für den nächsten Versuch zurück.

Der Arduino Code für das Bomben entschärfen Spiel

#include <TM1637Display.h>

// --- ZENTRALE EINSTELLUNGEN 
const int INITIAL_ZEIT = 120;       // Zeit in Sekunden (max 999)
const int TASTER_KOMBI_LAENGE = 5;  // Wie viele Tasten pro Runde (nur bis 9 möglich)

// --- PIN DEFINITIONEN ---
const int PIN_K1 = 8;
const int PIN_K2 = 9;
const int PIN_POTI = A0;
const int PIN_BUZZER = 3;
const int PIN_LED_R = 4;
const int PIN_LED_G = 6;
const int PIN_LED_B = 7;
const int PIN_CLK = 10;
const int PIN_DIO = 11;

// --- DISPLAY SETUP ---
TM1637Display display(PIN_CLK, PIN_DIO);
const uint8_t SEG_GOOD[] = {
  SEG_A | SEG_C | SEG_D | SEG_E | SEG_F,           // G
  SEG_A | SEG_B | SEG_C | SEG_D | SEG_E | SEG_F,   // O
  SEG_A | SEG_B | SEG_C | SEG_D | SEG_E | SEG_F,   // O
  SEG_B | SEG_C | SEG_D | SEG_E | SEG_G            // d
};

// --- SPIEL VARIABLEN ---
int gameState = 0; 
unsigned long startTime;
unsigned long zeitLimitMillis = (unsigned long)INITIAL_ZEIT * 1000;
int tasksLeft = 6; 

// Poti Variablen
int potiTarget = 0;
unsigned long potiHoldStartTime = 0;
bool potiIsInRange = false;

// Taster Variablen
int btnSequence[9]; // Array für bis zu 9 Eingaben
int currentBtnIndex = 0;
bool lastK1 = HIGH;
bool lastK2 = HIGH;

void setup() {
  Serial.begin(9600);
  pinMode(PIN_K1, INPUT_PULLUP);
  pinMode(PIN_K2, INPUT_PULLUP);
  pinMode(PIN_BUZZER, OUTPUT);
  pinMode(PIN_LED_R, OUTPUT);
  pinMode(PIN_LED_G, OUTPUT);
  pinMode(PIN_LED_B, OUTPUT);
  
  randomSeed(analogRead(A1)); 
  display.setBrightness(0x0f);
  resetGame();
}

void loop() {
  // --- ZUSTAND 0: Warten auf Start ---
  if (gameState == 0) {
    displayNumber(6, INITIAL_ZEIT); 
    if (digitalRead(PIN_K1) == LOW) {
      delay(200); 
      startGame();
    }
    return; 
  }

  // --- SPIEL LÄUFT: Timer prüfen ---
  unsigned long elapsedTime = millis() - startTime;
  int timeLeft = (int)((zeitLimitMillis - elapsedTime) / 1000);
  
  if (elapsedTime >= zeitLimitMillis) {
    loseGame();
    return;
  }
  displayNumber(tasksLeft, timeLeft);

  // --- AUFGABEN 1 bis 3: Potentiometer ---
  if (gameState >= 1 && gameState <= 3) {
    int potiValue = analogRead(PIN_POTI);
    
    if (abs(potiValue - potiTarget) <= 10) {
      setLED(LOW, LOW, HIGH); // Blau: Bereich gefunden
      
      if (!potiIsInRange) {
        potiIsInRange = true;
        potiHoldStartTime = millis(); 
      } else {
        if (millis() - potiHoldStartTime >= 1000) { 
          potiIsInRange = false; 
          successBeep(1); // Grün + Beep
          tasksLeft--;
          gameState++;
          if (gameState <= 3) generatePotiTarget(); 
          else generateBtnSequence(); 
        }
      }
    } else {
      potiIsInRange = false; 
      setLED(HIGH, LOW, LOW); // Rot
    }
  }

  // --- AUFGABEN 4 bis 6: Taster-Sequenz ---
  if (gameState >= 4 && gameState <= 6) {
    setLED(HIGH, LOW, LOW); 
    
    bool currentK1 = digitalRead(PIN_K1);
    bool currentK2 = digitalRead(PIN_K2);
    int pressedBtn = 0; 

    if (currentK1 == LOW && lastK1 == HIGH) { pressedBtn = 1; delay(50); }
    else if (currentK2 == LOW && lastK2 == HIGH) { pressedBtn = 2; delay(50); }

    lastK1 = currentK1;
    lastK2 = currentK2;

    if (pressedBtn > 0) {
      if (pressedBtn == btnSequence[currentBtnIndex]) {
        // Richtiger Taster in der Reihe
        setLED(LOW, LOW, HIGH);
        tone(PIN_BUZZER, 1500, 100);
        delay(150); 
        currentBtnIndex++;
        
        // Prüfen gegen die zentrale Variable
        if (currentBtnIndex == TASTER_KOMBI_LAENGE) {
          successBeep(2); 
          tasksLeft--;
          gameState++;
          if (gameState <= 6) generateBtnSequence(); 
          else winGame(); 
        }
      } else {
        // Falscher Taster
        Serial.println("FALSCH! Sequenz-Reset.");
        currentBtnIndex = 0; 
        tone(PIN_BUZZER, 100, 500); 
      }
    }
  }
}

// HILFSFUNKTIONEN

void startGame() {
  Serial.println("\n--- BOMBE AKTIVIERT ---");
  tasksLeft = 6;
  gameState = 1;
  potiIsInRange = false;
  generatePotiTarget();
  startTime = millis();
}

void generatePotiTarget() {
  potiTarget = random(100, 924); 
  Serial.print("Ziel Poti-Wert (Runde ");
  Serial.print(gameState);
  Serial.print("): ");
  Serial.println(potiTarget);
}

void generateBtnSequence() {
  currentBtnIndex = 0;
  Serial.print("Ziel Taster-Sequenz (Runde ");
  Serial.print(gameState - 3); 
  Serial.print("): ");
  
  for (int i = 0; i < TASTER_KOMBI_LAENGE; i++) {
    btnSequence[i] = random(1, 3); 
    Serial.print(btnSequence[i] == 1 ? "K1 " : "K2 ");
  }
  Serial.println();
}

void successBeep(int type) {
  if (type == 1) setLED(LOW, HIGH, LOW); 
  else setLED(LOW, LOW, HIGH);           
  
  tone(PIN_BUZZER, 1000); 
  delay(500);             
  noTone(PIN_BUZZER);
  startTime += 500; 
}

void winGame() {
  setLED(LOW, HIGH, LOW); 
  display.setSegments(SEG_GOOD);
  Serial.println("\nBOMBE ENTSCHÄRFT!");
  tone(PIN_BUZZER, 800, 200); delay(200);
  tone(PIN_BUZZER, 1200, 400); delay(3000);
  resetGame();
}

void loseGame() {
  setLED(HIGH, LOW, LOW); 
  Serial.println("\nBOOM!");
  tone(PIN_BUZZER, 200, 1000); delay(2000);
  resetGame();
}

void resetGame() {
  gameState = 0;
  tasksLeft = 6;
  setLED(LOW, LOW, LOW); 
  Serial.println("\nSystem bereit. Druecke K1 zum Starten.");
}

void setLED(bool r, bool g, bool b) {
  digitalWrite(PIN_LED_R, r);
  digitalWrite(PIN_LED_G, g);
  digitalWrite(PIN_LED_B, b);
}

void displayNumber(int taskNum, int seconds) {
  uint8_t data[4];
  data[0] = display.encodeDigit(taskNum);
  data[1] = display.encodeDigit((seconds / 100) % 10); 
  data[2] = display.encodeDigit((seconds / 10) % 10);  
  data[3] = display.encodeDigit(seconds % 10);         
  display.setSegments(data);
}

20, die Slot Maschine:

Das Spiel funktioniert so, dass es im Ruhezustand auf deine Eingabe wartet, während das Display die letzte Zahl oder eine Null anzeigt. Sobald du den Taster K1 drückst, setzt das Programm alle LEDs zurück und startet den Zufallsgenerator. Auf dem Display beginnt nun eine schnelle Animation, bei der hunderte Zahlen vorbeiziehen, bis das System nach einem kurzen Moment künstlich abbremst und bei einer finalen vierstelligen Zahl stehen bleibt. Jetzt analysiert der Mikrocontroller im Hintergrund das Ergebnis, indem er die Zahl in ihre vier Einzelstellen zerlegt und jede Ziffer mit jeder anderen vergleicht. Je nachdem, wie viele Übereinstimmungen dabei gefunden werden, leuchtet eine der farbigen LEDs auf dem Shield auf, um dir deinen Gewinnrang anzuzeigen, wobei der Jackpot bei vier identischen Zahlen zusätzlich den Summer aktiviert, bevor das Spiel nach einer kurzen Pause wieder für den nächsten Druck auf den Taster bereit ist.

Der Arduino Code

#include<arduino.h>
#include<TM1637Display.h>
const int CLK = 10;
const int DIO = 11;
TM1637Display display(CLK,DIO);
const int K1 = 8;
const int K2 = 9;
unsigned long zufall = 4;
int ablauf = 0;
int z1;
int z2;
int z3;
int z4;


void setup() {
  display.setBrightness(5);
  pinMode (K1,INPUT_PULLUP);
  pinMode (K2,INPUT_PULLUP);
  pinMode (3,OUTPUT);
  pinMode (4,OUTPUT);
  pinMode (5,OUTPUT);
  pinMode (6,OUTPUT);
  pinMode (7,OUTPUT);
  Serial.begin(9600);
  randomSeed(analogRead(0));
  display.showNumberDec(0,true);
}

void loop() {
  // Spiel Starten
  if (ablauf == 0 && digitalRead(K1) == 0){
    Serial.print("push");
    for (int i = 3; i< 8; i++){
      digitalWrite (i,0);
    }
    ablauf = 1;
    delay(50);
    
  }
 // Spiel
 // Setzen der Zufallszahl und diese anzeigen
 if (ablauf == 1) { 
    int zeit = 0;
    for (int i = 0; i < 100; i++){
      zufall = random(0,10000); // Zufällige Zahl von 0-9999 
      if ( i >= 70) {
        zeit = zeit + 5;
      delay (zeit);
     }else{
      delay(10);
     }
     display.showNumberDec(zufall, true);
   }
   // auswerten der einzelnen Zahlen
  z1 = zufall % 10;
  z2 = (zufall / 10) % 10;
  z3 = (zufall / 100) % 10;
  z4 = (zufall / 1000) % 10;
  // Pruefung des gewinnes 
  int ergebnis = 0;
  if (z1 == z2) {ergebnis++;}
  if (z1 == z3) {ergebnis++;}
  if (z1 == z4) {ergebnis++;}
  if (z2 == z3) {ergebnis++;}
  if (z2 == z4) {ergebnis++;}
  if (z3 == z4) {ergebnis++;}

  // leds setzen
  if (ergebnis == 0) { digitalWrite(4,1);}
  if (ergebnis == 1) { digitalWrite(5,1);}
  if (ergebnis == 2) { digitalWrite(6,1);}
  if (ergebnis == 3) { digitalWrite(7,1);}
  if (ergebnis == 6) { digitalWrite(3,1);} // Summer
  delay(1000);
   ablauf = 0;
 }
}

23, Präzises Voltmeter (Spannungsmesser) mit LED-Wächter:

In diesem Projekt verwandelst du dein Rich Shield in ein zuverlässiges Messgerät, mit dem du Spannungen bis zu 28 Volt (je nach Kalibrierung) überwachen kannst. Das Programm nutzt dabei einen cleveren Mittelwert-Algorithmus: Anstatt nur einmal kurz zu messen, sammelt der Arduino in jedem Durchgang 10 (oder mehr) einzelne Rohwerte ein und berechnet daraus einen stabilen Durchschnitt. Das verhindert, dass die letzte Ziffer auf dem Display nervös flackert, und sorgt für ein ruhiges Messergebnis.

Die Besonderheit liegt in der Software-Kalibrierung: Da jeder Arduino eine leicht unterschiedliche Betriebsspannung hat, lässt sich das Voltmeter im Code exakt auf dein Board anpassen, um maximale Präzision zu erreichen. Zusätzlich ist eine intelligente Logik integriert, die zwei der farbigen LEDs als Statuswächter nutzt. Liegt die gemessene Spannung über einem von dir definierten Schwellenwert (zum Beispiel 20 Volt), schaltet das Shield sofort auf die rote Warn-LED um sinkt sie darunter, leuchtet zur Bestätigung die gelbe LED. So hast du deine Stromversorgung nicht nur digital als Zahl, sondern auch visuell immer sicher im Blick.

Der Arduino Code

#include <Arduino.h>
#include <TM1637Display.h>
const int CLK = 10;
const int DIO = 11;
TM1637Display display(CLK, DIO);

const int analog = A3;
const int rot = 7;
const int gelb = 4;


void setup() {
  display.setBrightness(5);
  pinMode (rot,OUTPUT);
  pinMode (gelb,OUTPUT);
  }

void loop() {
  
  /*
  int rohSpannung = analogRead(analog);
    unsigned long spannung = (rohSpannung * 2800L) / 1023L;
    display.showNumberDecEx((spannung), (0x80 >> 1), true); 
    delay (100);
*/

unsigned long spannung = 0;
  for (int i = 0; i < 10; i++){
      spannung += analogRead(analog);
          delay(10);
  }

  spannung = (spannung * 2781L) /10230L; //1023*10 oder 1023*20 oder 1023* 30 wenn < 10 20 30 28/5 wegen 18 und 5 volt 
  display.showNumberDecEx((spannung), (0x80 >> 1), true); 
  delay(100);

if (spannung >2000){
  digitalWrite (rot,0);
  digitalWrite (gelb,1);
} else { 
  digitalWrite (rot,1);
  digitalWrite (gelb,0);
}


}

26, Arduino Stoppuhr

Es gibt 5 Stoppuhren:

Der Arduino Code für die Stoppuhr mit einfacher Weiterschaltung über Variablenzahlen
Der Arduino Code für die Stoppuhr mit enum
Der Arduino Code für die Stoppuhr mit enum und Zeit bis 49 Min über die LEDs
Die Rundenzeit-Stoppuhr mit 4 Speichern
Die Rundenzeit-Stoppuhr mit Speicherfunktion über Binäranzeige

Das System fungiert als präzise Stoppuhr, die im Bereitschaftszustand auf das Startsignal wartet und eine genullte Zeit auf dem 4-stelligen Display anzeigt. Sobald der Taster K1 zum ersten Mal betätigt wird, wechselt der interne Zustandsautomat in den Modus "Läuft", startet den Millisekunden-Zähler und aktualisiert fortlaufend das Display, wobei die Zeit im Format Minuten, Sekunden und Zehntelsekunden ausgegeben wird.

Da das Display baubedingt nur vier Stellen besitzt, nutzt das Projekt eine intelligente Farbcodes-Logik über externe LEDs, um den Zehnerbereich der Minuten darzustellen: Ab der zehnten Minute leuchtet die gelbe LED (10–19 Min.), ab der zwanzigsten die blaue (20–29 Min.), ab der dreißigsten die grüne (30–39 Min.) und ab der vierzigsten Minute schließlich die rote LED.

Ein zweiter Druck auf den Taster pausiert die Zeitmessung im Zustand "Gestoppt", sodass der aktuelle Wert dauerhaft abgelesen werden kann. Erreicht die Uhr während des Betriebs die kritische Marke von 49 Minuten, löst die Software einen Sicherheits-Stopp aus, friert die Anzeige ein und verhindert ein weiteres Hochzählen. Erst durch eine dritte Betätigung des Tasters setzt das Programm alle Variablen sowie die farbigen LEDs zurück, löscht das Display und kehrt in den Ausgangszustand zurück, bereit für die nächste Messung.

1 Der Arduino Code für die Stoppuhr mit einfacher Weiterschaltung über Variablenzahlen

#include <KK_ButtonHandler.h>
#include <StopWatch.h>
#include <TM1637Display.h>

#define CLK 10
#define DIO 11
TM1637Display display(CLK, DIO);

StopWatch MySW;
StopWatch SWarray[1];

KK_ButtonHandler myK1(8);

void setup() {
  Serial.begin(9600);
  display.setBrightness(5, true);
  myK1.begin();
  SWarray[0].setResolution(StopWatch::MILLIS);
  display.showNumberDec(0, true);
}

void loop() {
  myK1.update();

  if (myK1.getClickCount() ==1 ){
  SWarray[0].start();
  Serial.println("start");
  myK1.setClickCount( myK1.getClickCount() + 1 );
  }

  if (myK1.getClickCount()==2){
    unsigned long millisabsolut = SWarray[0].elapsed(); 
 
      
        int zehntel  = (millisabsolut / 100) % 10;
        int sekunden = (millisabsolut / 1000) % 60;
        int minuten  = (millisabsolut / 60000) % 10; 

        uint8_t data[] = { 0xff, 0xff, 0xff, 0xff };

      data[0] = display.encodeDigit(minuten) | 0x80;        
      data[1] = display.encodeDigit(sekunden / 10);         
      data[2] = display.encodeDigit(sekunden % 10) | 0x80;   
      data[3] = display.encodeDigit(zehntel);                

    display.setSegments(data);
}

if (myK1.getClickCount()==3){
  SWarray[0].stop();
  myK1.setClickCount( myK1.getClickCount() + 1 );
}

if(myK1.getClickCount()==5){
  SWarray[0].reset();
  myK1.setClickCount( myK1.getClickCount() + 1 );
  unsigned long millisabsolut = SWarray[0].elapsed(); 
 
      uint8_t data[] = { 0xff, 0xff, 0xff, 0xff };
        int zehntel  = (millisabsolut / 100) % 10;
        int sekunden = (millisabsolut / 1000) % 60;
        int minuten  = (millisabsolut / 60000) % 10; 

      data[0] = display.encodeDigit(minuten) | 0x80;        
      data[1] = display.encodeDigit(sekunden / 10);         
      data[2] = display.encodeDigit(sekunden % 10) | 0x80;   
      data[3] = display.encodeDigit(zehntel);                

    display.setSegments(data);
}

if(myK1.getClickCount()==7){
  myK1.setClickCount( myK1.getClickCount() -6 );
}
}

2 Der Arduino Code für die Stoppuhr mit enum

#include <KK_ButtonHandler.h>
#include <StopWatch.h>
#include <TM1637Display.h>

#define CLK 10
#define DIO 11
TM1637Display display(CLK, DIO);

StopWatch MySW;
StopWatch SWarray[1];

KK_ButtonHandler myK1(8);

// 1. Enum definieren: Die drei klaren Zustände der Stoppuhr
enum StoppuhrZustand {
  BEREIT,   // Stoppuhr steht auf 0 und wartet auf den Start
  LAEUFT,   // Stoppuhr zählt die Zeit hoch
  GESTOPPT  // Stoppuhr ist pausiert, die Endzeit wird angezeigt
};

// Startzustand festlegen
StoppuhrZustand aktuellerZustand = BEREIT;

// Variable, um zu erkennen, ob ein NEUER Klick passiert ist
int letzterKlickWert = 0;


void setup() {
  Serial.begin(9600);
  display.setBrightness(5, true);
  myK1.begin();
  
  SWarray[0].setResolution(StopWatch::MILLIS);
  
  // Startanzeige: 00:00
  aktualisiereDisplay(0); 
}

void loop() {
  myK1.update();

  // 2. Klick-Erkennung: Prüfen, ob der Zähler hochgegangen ist
  int aktuellerKlickWert = myK1.getClickCount();
  bool knopfWurdeGedrueckt = (aktuellerKlickWert != letzterKlickWert);

  // 3. Zustandswechsel (State Machine)
  if (knopfWurdeGedrueckt) {
    letzterKlickWert = aktuellerKlickWert; // Klick merken, damit er nicht doppelt auslöst

    switch (aktuellerZustand) {
      
      case BEREIT:
        // Wechsel von BEREIT zu LAEUFT
        SWarray[0].start();
        Serial.println("start");
        aktuellerZustand = LAEUFT;
        break;

      case LAEUFT:
        // Wechsel von LAEUFT zu GESTOPPT
        SWarray[0].stop();
        Serial.println("stop");
        aktuellerZustand = GESTOPPT;
        break;

      case GESTOPPT:
        // Wechsel von GESTOPPT zurück zu BEREIT
        SWarray[0].reset();
        Serial.println("reset");
        aktualisiereDisplay(0); // Display sofort wieder auf Null setzen
        aktuellerZustand = BEREIT;
        break;
    }
  }

  // 4. Kontinuierliche Aktionen im Loop
  // Wenn die Stoppuhr läuft, muss das Display ständig aktualisiert werden
  if (aktuellerZustand == LAEUFT) {
    aktualisiereDisplay(SWarray[0].elapsed());
  }
}

// 5. Hilfsfunktion: Display-Logik auslagern, um doppelten Code zu vermeiden
void aktualisiereDisplay(unsigned long millisabsolut) {
  int zehntel  = (millisabsolut / 100) % 10;
  int sekunden = (millisabsolut / 1000) % 60;
  int minuten  = (millisabsolut / 60000) % 10; 

  uint8_t data[] = { 0xff, 0xff, 0xff, 0xff };

  data[0] = display.encodeDigit(minuten) | 0x80;        
  data[1] = display.encodeDigit(sekunden / 10);         
  data[2] = display.encodeDigit(sekunden % 10) | 0x80;   
  data[3] = display.encodeDigit(zehntel);                

  display.setSegments(data);
}

3 Der Arduino Code für die Stoppuhr mit enum und Zeit bis 49 Min über die LEDs

#include <KK_ButtonHandler.h>
#include <StopWatch.h>
#include <TM1637Display.h>

#define CLK 10
#define DIO 11
TM1637Display display(CLK, DIO);

StopWatch MySW;
StopWatch SWarray[1];

KK_ButtonHandler myK1(8);

const int LED_GELB  = 4; // 10-19 Minuten
const int LED_BLAU  = 5; // 20-29 Minuten
const int LED_GRUEN = 6; // 30-39 Minuten
const int LED_ROT   = 7; // ab 40 Minuten

enum StoppuhrZustand {
  BEREIT,
  LAEUFT,
  GESTOPPT
};

StoppuhrZustand aktuellerZustand = BEREIT;
int letzterKlickWert = 0;

void setup() {
  Serial.begin(9600);
  display.setBrightness(5, true);
  myK1.begin();
  
  pinMode(LED_GELB, OUTPUT);
  pinMode(LED_BLAU, OUTPUT);
  pinMode(LED_GRUEN, OUTPUT);
  pinMode(LED_ROT, OUTPUT);
  alleLedsAus(); 
  
  SWarray[0].setResolution(StopWatch::MILLIS);
  
  aktualisiereDisplay(0); 
}

void loop() {
  myK1.update();

  int aktuellerKlickWert = myK1.getClickCount();
  bool knopfWurdeGedrueckt = (aktuellerKlickWert != letzterKlickWert);

  // --- 1. Manuelle Steuerung über den Knopf ---
  if (knopfWurdeGedrueckt) {
    letzterKlickWert = aktuellerKlickWert; 

    switch (aktuellerZustand) {
      case BEREIT:
        SWarray[0].start();
        Serial.println("start");
        aktuellerZustand = LAEUFT;
        break;

      case LAEUFT:
        SWarray[0].stop();
        Serial.println("stop (manuell)");
        aktuellerZustand = GESTOPPT;
        break;

      case GESTOPPT:
        SWarray[0].reset();
        Serial.println("reset");
        aktualisiereDisplay(0); 
        aktuellerZustand = BEREIT;
        break;
    }
  }

  // --- 2. Automatische Steuerung & Display-Update ---
  if (aktuellerZustand == LAEUFT) {
    unsigned long aktuelleZeit = SWarray[0].elapsed();
    int gesamtMinuten = (aktuelleZeit / 60000);

    //Prüfen, ob 49 Minuten erreicht wurden
    if (gesamtMinuten >= 49) {
      SWarray[0].stop();                       // Stoppuhr anhalten
      Serial.println("Auto-Stop bei 49 Min");  // Info an den Serial Monitor
      aktuellerZustand = GESTOPPT;             // Zustand wechseln
      
      // Das Display exakt auf 49:00:0 einfrieren (verhindert Anzeige von 49:00:1)
      aktualisiereDisplay(49UL * 60000UL);     
    } else {
      // Normale Zeitaktualisierung, solange unter 49 Minuten
      aktualisiereDisplay(aktuelleZeit);
    }
  }
}

void alleLedsAus() {
  digitalWrite(LED_GELB, LOW);
  digitalWrite(LED_BLAU, LOW);
  digitalWrite(LED_GRUEN, LOW);
  digitalWrite(LED_ROT, LOW);
}

void aktualisiereDisplay(unsigned long millisabsolut) {
  int zehntel = (millisabsolut / 100) % 10;
  int sekunden = (millisabsolut / 1000) % 60;
  
  int gesamtMinuten = (millisabsolut / 60000); 
  int minutenEiner = gesamtMinuten % 10; 

  uint8_t data[] = { 0xff, 0xff, 0xff, 0xff };

  data[0] = display.encodeDigit(minutenEiner) | 0x80;        
  data[1] = display.encodeDigit(sekunden / 10);         
  data[2] = display.encodeDigit(sekunden % 10) | 0x80;   
  data[3] = display.encodeDigit(zehntel);                

  display.setSegments(data);

  alleLedsAus(); 

  if (gesamtMinuten >= 10 && gesamtMinuten < 20) {
    digitalWrite(LED_GELB, HIGH);
  } 
  else if (gesamtMinuten >= 20 && gesamtMinuten < 30) {
    digitalWrite(LED_BLAU, HIGH);
  } 
  else if (gesamtMinuten >= 30 && gesamtMinuten < 40) {
    digitalWrite(LED_GRUEN, HIGH);
  } 
  else if (gesamtMinuten >= 40) {
    digitalWrite(LED_ROT, HIGH); 
  }
}

Die Rundenzeit-Stoppuhr mit Speicherfunktion

Das System ermöglicht es, während einer laufenden Messung durch Drücken von K2 bis zu vier Rundenzeiten in einem rotierenden Speicher (Ringpuffer) zu sichern, wobei die fünfte Messung automatisch die älteste überschreibt. Um die Lesbarkeit auf dem Display zu garantieren, stoppt die Uhr softwareseitig exakt bei 9:49,9 Minuten und friert diesen Maximalwert ein, falls kein manueller Abbruch erfolgt. Im gestoppten Zustand erlaubt die Logik das sequentielle Durchschalten der gespeicherten Zeiten, wobei jede Runde durch eine eigene farbige LED (Gelb, Blau, Grün, Rot) visualisiert wird, bis ein Druck auf K1 das gesamte System und alle Speicherregister für einen Neustart zurücksetzt.

Der Arduino Code für die Stoppuhr

#include <KK_ButtonHandler.h>
#include <StopWatch.h>
#include <TM1637Display.h>

#define CLK 10
#define DIO 11
TM1637Display display(CLK, DIO);

StopWatch MySW;
StopWatch SWarray[1];

// Buttons
KK_ButtonHandler myK1(8); // Start / Stopp / Reset
KK_ButtonHandler myK2(9); // Rundenzeit (Lap) / Zeiten durchschalten

// LEDs
const int LED_GELB  = 4; // Rundenzeit 1
const int LED_BLAU  = 5; // Rundenzeit 2
const int LED_GRUEN = 6; // Rundenzeit 3
const int LED_ROT   = 7; // Rundenzeit 4

// Maximalzeit: 9 Min, 49 Sek, 9 Zehntel in Millisekunden berechnet
// (9 * 60000) + (49 * 1000) + 900 = 589900
const unsigned long MAX_ZEIT = 589900UL;

// Zustandsautomat
enum StoppuhrZustand {
  BEREIT,
  LAEUFT,
  GESTOPPT
};

StoppuhrZustand aktuellerZustand = BEREIT;

// Klick-Speicher zur Flankenerkennung
int letzterKlickK1 = 0;
int letzterKlickK2 = 0;

// Rundenzeit-Variablen
unsigned long rundenZeiten[4] = {0, 0, 0, 0};
int rundenIndex = 0;   // An welche Stelle gespeichert wird (0 bis 3)
int anzahlRunden = 0;  // Wie viele Runden tatsächlich gespeichert wurden (max 4)

unsigned long gestoppteEndZeit = 0; // Speichert die Zeit beim Drücken auf Stopp
int anzeigeModus = 0; // 0 = Endzeit, 1 = Runde 1, 2 = Runde 2 etc.


void setup() {
  Serial.begin(9600);
  display.setBrightness(5, true);
  myK1.begin();
  myK2.begin();
  
  pinMode(LED_GELB, OUTPUT);
  pinMode(LED_BLAU, OUTPUT);
  pinMode(LED_GRUEN, OUTPUT);
  pinMode(LED_ROT, OUTPUT);
  alleLedsAus(); 
  
  SWarray[0].setResolution(StopWatch::MILLIS);
  zeigeZeit(0); 
}

void loop() {
  myK1.update();
  myK2.update();

  int aktKlickK1 = myK1.getClickCount();
  int aktKlickK2 = myK2.getClickCount();
  
  // Prüfen, ob Buttons frisch gedrückt wurden
  bool k1Gedrueckt = (aktKlickK1 != letzterKlickK1);
  bool k2Gedrueckt = (aktKlickK2 != letzterKlickK2);

  if (k1Gedrueckt) letzterKlickK1 = aktKlickK1;
  if (k2Gedrueckt) letzterKlickK2 = aktKlickK2;

  switch (aktuellerZustand) {
    
    case BEREIT:
      if (k1Gedrueckt) {
        // Starten und Runden-Speicher leeren
        rundenIndex = 0;
        anzahlRunden = 0;
        anzeigeModus = 0;
        alleLedsAus();
        SWarray[0].start();
        aktuellerZustand = LAEUFT;
      }
      break;

    case LAEUFT:
      // 1. Automatischen Stopp bei 9:49:9 prüfen
      if (SWarray[0].elapsed() >= MAX_ZEIT) {
        SWarray[0].stop();
        gestoppteEndZeit = MAX_ZEIT;
        aktuellerZustand = GESTOPPT;
        zeigeZeit(gestoppteEndZeit);
      } 
      // 2. Manueller Stopp durch K1
      else if (k1Gedrueckt) {
        SWarray[0].stop();
        gestoppteEndZeit = SWarray[0].elapsed();
        aktuellerZustand = GESTOPPT;
        zeigeZeit(gestoppteEndZeit);
      } 
      // 3. Rundenzeit speichern durch K2
      else if (k2Gedrueckt) {
        rundenZeiten[rundenIndex] = SWarray[0].elapsed();
        rundenIndex = (rundenIndex + 1) % 4; // Erhöht sich, springt nach 3 wieder auf 0 (Ringpuffer)
        if (anzahlRunden < 4) {
          anzahlRunden++;
        }
      } 
      // 4. Normales Display-Update
      else {
        zeigeZeit(SWarray[0].elapsed());
      }
      break;

    case GESTOPPT:
      // Reset auf 0 durch K1
      if (k1Gedrueckt) {
        SWarray[0].reset();
        aktuellerZustand = BEREIT;
        alleLedsAus();
        zeigeZeit(0);
      } 
      // Rundenzeiten abrufen durch K2
      else if (k2Gedrueckt && anzahlRunden > 0) {
        anzeigeModus++;
        
        // Wenn alle gespeicherten Runden durchgeschaltet wurden, zurück zur Endzeit
        if (anzeigeModus > anzahlRunden) {
          anzeigeModus = 0; 
        }

        alleLedsAus();

        if (anzeigeModus == 0) {
          // Anzeige 0: Letzte gestoppte Zeit (Endzeit) ohne LEDs
          zeigeZeit(gestoppteEndZeit);
        } else {
          // Anzeige 1 bis 4: Rundenzeit anzeigen und entsprechende LED einschalten
          zeigeZeit(rundenZeiten[anzeigeModus - 1]);
          
          if (anzeigeModus == 1) digitalWrite(LED_GELB, HIGH);
          if (anzeigeModus == 2) digitalWrite(LED_BLAU, HIGH);
          if (anzeigeModus == 3) digitalWrite(LED_GRUEN, HIGH);
          if (anzeigeModus == 4) digitalWrite(LED_ROT, HIGH);
        }
      }
      break;
  }
}

// --- Hilfsfunktionen ---

void alleLedsAus() {
  digitalWrite(LED_GELB, LOW);
  digitalWrite(LED_BLAU, LOW);
  digitalWrite(LED_GRUEN, LOW);
  digitalWrite(LED_ROT, LOW);
}

void zeigeZeit(unsigned long millisabsolut) {
  int zehntel  = (millisabsolut / 100) % 10;
  int sekunden = (millisabsolut / 1000) % 60;
  int minuten  = (millisabsolut / 60000) % 10; 

  uint8_t data[] = { 0xff, 0xff, 0xff, 0xff };

  data[0] = display.encodeDigit(minuten) | 0x80;        
  data[1] = display.encodeDigit(sekunden / 10);         
  data[2] = display.encodeDigit(sekunden % 10) | 0x80;   
  data[3] = display.encodeDigit(zehntel);                

  display.setSegments(data);
}

Die binäre Runden-Stoppuhr

Durch die Implementierung einer binären LED-Logik erweitert das System seine Kapazität massiv und kann nun bis zu 15 individuelle Rundenzeiten in einem dynamischen Ringpuffer verwalten, bevor die älteste Messung überschrieben wird. Da das Display auf eine maximale Laufzeit von 9:49,9 Minuten begrenzt ist, übernehmen die vier farbigen LEDs im gestoppten Zustand die Funktion eines digitalen Wegweisers: Sie zeigen die Nummer der aktuell aufgerufenen Runde als Binärcode an, wobei jede LED eine feste Wertigkeit (1, 2, 4 oder 8) repräsentiert. Erst wenn der Nutzer alle gespeicherten Runden durchgeschaltet hat oder die Stoppuhr über K1 zurücksetzt, erlöschen die LEDs und das System kehrt in den Bereitschaftsmodus zurück.

Der Arduino Code für die binäre Stoppuhr

#include <KK_ButtonHandler.h>
#include <StopWatch.h>
#include <TM1637Display.h>

#define CLK 10
#define DIO 11
TM1637Display display(CLK, DIO);

StopWatch MySW;
StopWatch SWarray[1];

KK_ButtonHandler myK1(8); // Start / Stopp / Reset
KK_ButtonHandler myK2(9); // Rundenzeit (Lap) / Zeiten durchschalten

// LEDs (sortiert nach binärer Wertigkeit)
const int LED_GELB  = 4; // Wert 8
const int LED_BLAU  = 5; // Wert 4
const int LED_GRUEN = 6; // Wert 2
const int LED_ROT   = 7; // Wert 1

const unsigned long MAX_ZEIT = 589900UL; // 9:49,9 in Millisekunden

enum StoppuhrZustand {
  BEREIT,
  LAEUFT,
  GESTOPPT
};

StoppuhrZustand aktuellerZustand = BEREIT;

int letzterKlickK1 = 0;
int letzterKlickK2 = 0;

// --- NEU: Speicher für 15 Runden ---
const int MAX_RUNDEN = 15;
unsigned long rundenZeiten[MAX_RUNDEN];
int rundenIndex = 0;   
int anzahlRunden = 0;  

unsigned long gestoppteEndZeit = 0; 
int anzeigeModus = 0; 

void setup() {
  Serial.begin(9600);
  display.setBrightness(5, true);
  myK1.begin();
  myK2.begin();
  
  pinMode(LED_GELB, OUTPUT);
  pinMode(LED_BLAU, OUTPUT);
  pinMode(LED_GRUEN, OUTPUT);
  pinMode(LED_ROT, OUTPUT);
  alleLedsAus(); 
  
  // Array beim Start sicherheitshalber mit 0 füllen
  for(int i=0; i<MAX_RUNDEN; i++) rundenZeiten[i] = 0;
  
  SWarray[0].setResolution(StopWatch::MILLIS);
  zeigeZeit(0); 
}

void loop() {
  myK1.update();
  myK2.update();

  int aktKlickK1 = myK1.getClickCount();
  int aktKlickK2 = myK2.getClickCount();
  
  bool k1Gedrueckt = (aktKlickK1 != letzterKlickK1);
  bool k2Gedrueckt = (aktKlickK2 != letzterKlickK2);

  if (k1Gedrueckt) letzterKlickK1 = aktKlickK1;
  if (k2Gedrueckt) letzterKlickK2 = aktKlickK2;

  switch (aktuellerZustand) {
    
    case BEREIT:
      if (k1Gedrueckt) {
        rundenIndex = 0;
        anzahlRunden = 0;
        anzeigeModus = 0;
        alleLedsAus();
        SWarray[0].start();
        aktuellerZustand = LAEUFT;
      }
      break;

    case LAEUFT:
      if (SWarray[0].elapsed() >= MAX_ZEIT) {
        SWarray[0].stop();
        gestoppteEndZeit = MAX_ZEIT;
        aktuellerZustand = GESTOPPT;
        zeigeZeit(gestoppteEndZeit);
      } 
      else if (k1Gedrueckt) {
        SWarray[0].stop();
        gestoppteEndZeit = SWarray[0].elapsed();
        aktuellerZustand = GESTOPPT;
        zeigeZeit(gestoppteEndZeit);
      } 
      else if (k2Gedrueckt) {
        rundenZeiten[rundenIndex] = SWarray[0].elapsed();
        // Ringpuffer für 15 Runden
        rundenIndex = (rundenIndex + 1) % MAX_RUNDEN; 
        if (anzahlRunden < MAX_RUNDEN) {
          anzahlRunden++;
        }
      } 
      else {
        zeigeZeit(SWarray[0].elapsed());
      }
      break;

    case GESTOPPT:
      if (k1Gedrueckt) {
        SWarray[0].reset();
        aktuellerZustand = BEREIT;
        alleLedsAus();
        zeigeZeit(0);
      } 
      else if (k2Gedrueckt && anzahlRunden > 0) {
        anzeigeModus++;
        
        if (anzeigeModus > anzahlRunden) {
          anzeigeModus = 0; 
        }

        if (anzeigeModus == 0) {
          alleLedsAus();
          zeigeZeit(gestoppteEndZeit);
        } else {
          zeigeZeit(rundenZeiten[anzeigeModus - 1]);
          // --- NEU: Aufruf der binären LED-Anzeige ---
          zeigeBinaereLeds(anzeigeModus);
        }
      }
      break;
  }
}

// --- Hilfsfunktionen ---

void alleLedsAus() {
  digitalWrite(LED_GELB, LOW);
  digitalWrite(LED_BLAU, LOW);
  digitalWrite(LED_GRUEN, LOW);
  digitalWrite(LED_ROT, LOW);
}

// --- NEU: Funktion zur binären Ansteuerung der LEDs ---
void zeigeBinaereLeds(int nummer) {
  // Das & Symbol (Bitweises UND) prüft, ob das jeweilige Bit in der Zahl gesetzt ist.
  digitalWrite(LED_ROT,   (nummer & 0b0001) ? HIGH : LOW); // Prüft auf 1
  digitalWrite(LED_GRUEN, (nummer & 0b0010) ? HIGH : LOW); // Prüft auf 2
  digitalWrite(LED_BLAU,  (nummer & 0b0100) ? HIGH : LOW); // Prüft auf 4
  digitalWrite(LED_GELB,  (nummer & 0b1000) ? HIGH : LOW); // Prüft auf 8
}

void zeigeZeit(unsigned long millisabsolut) {
  int zehntel  = (millisabsolut / 100) % 10;
  int sekunden = (millisabsolut / 1000) % 60;
  int minuten  = (millisabsolut / 60000) % 10; 

  uint8_t data[] = { 0xff, 0xff, 0xff, 0xff };

  data[0] = display.encodeDigit(minuten) | 0x80;        
  data[1] = display.encodeDigit(sekunden / 10);         
  data[2] = display.encodeDigit(sekunden % 10) | 0x80;   
  data[3] = display.encodeDigit(zehntel);                

  display.setSegments(data);
}

Arduino Ideen

Spiele, MINT Ideen und Projekte auf dem Open Smart Rich Shield V1

🏠 Alltag & Lifestyle (10 Ideen)

🎮 Spiele & Unterhaltung (10 Ideen)

🛠️ Werkzeuge & Gadgets (10 Ideen)

🧪 MINT-Projektideen (Bildung & Wissenschaft)

1, die Eieruhr

Der Arduino Code

3. digitaler Würfel

Der Arduino Code für den Arduino Würfel

9, Digitaler Arduino Safe mit 4 Stellen:

Der Arduino Code für den digital Save.

14. Digitales Glücksrad

Der Arduino Code für das Glücksrad

Der Arduino Code für das Glücksrad mit "enum"

17 Space Invaders "Light": Das 7-Segment-Endlos-Spiel für das Open-Smart Rich Shield 1

Der Arduino Code für das Space Invaders Spiel

19 Arduino Countdown-Bombe, entschärfe die Bombe

Der Arduino Code für das Bomben entschärfen Spiel

20, die Slot Maschine:

Der Arduino Code

23, Präzises Voltmeter (Spannungsmesser) mit LED-Wächter:

Der Arduino Code

26, Arduino Stoppuhr

1 Der Arduino Code für die Stoppuhr mit einfacher Weiterschaltung über Variablenzahlen

2 Der Arduino Code für die Stoppuhr mit enum

3 Der Arduino Code für die Stoppuhr mit enum und Zeit bis 49 Min über die LEDs

Die Rundenzeit-Stoppuhr mit Speicherfunktion

Der Arduino Code für die Stoppuhr

Die binäre Runden-Stoppuhr

Der Arduino Code für die binäre Stoppuhr

Kontakt

Ronnie

Beliebte Beiträge

Neueste Beiträge