Lösungen

#include "LedControl.h"
#include "Bounce2.h"

// Joystick-Button zuordnen
Bounce ZeitStoppen = Bounce();

// Joystick analoge Pins
int XAchse = A0;
int YAchse = A1;

// Joystick Knopf
int JoystickButton = 7;

// Variablen für die Auswertung der Bewegung des Joysticks
int PositionX;
int PositionY;

// Startposition der LED
int Reihe = 4;
int Spalte = 4;

// Anzahl zufälliger LEDs
int AnzahlLED = 5;

// Variablen der Zeit
float StartZeit;
float VerstricheneZeit;
float Sekunden;

// Variable für den Neustart
bool Start = false;

/*
   VCC -> 5V
   GND
   Pin 12 -> DATA IN-pin
   Pin 11 -> CLK-pin
   Pin 10 -> CS-pin
*/
LedControl LEDMatrix = LedControl(12, 11, 10, 1);

void setup()
{
  Serial.begin(9600);
  ZeitStoppen.attach(JoystickButton);

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

  // Matrix "aufwecken"
  LEDMatrix.shutdown(0, false);

  //  mittlere Helligkeit setzen
  LEDMatrix.setIntensity(0, 2);
  PfeilUnten();
  pinMode(JoystickButton, INPUT_PULLUP);

  // Start-LED setzen
  LEDMatrix.setLed(0, Reihe, Spalte, true);

  // Zeit starten
  StartZeit = millis();
}

void ParcoursBauen()
{
  LEDMatrix.clearDisplay(0);
  int Minimum = 0;
  int Maximum = 7;

  for (int i = 0; i < AnzahlLED; i++)
  {
    int Spalte =  random(Minimum, Maximum);
    int Zeile =  random(Minimum, Maximum);
    LEDMatrix.setLed(0, Spalte, Zeile, true);
  }
}

void PfeilUnten()
{
  byte Zeichen[8] = 
  {
     B00010000, // 1. Reihe
     B00110000, // 2. Reihe
     B01111111, // 3. Reihe
     B11111111, // 4. Reihe
     B01111111, // 5. Reihe
     B00110000, // 6. Reihe
     B00010000, // 7. Reihe
     B00000000  // 8. Reihe
  };
  // Matrix anzeigen
  for (int i = 0; i < 8; i++)   
  { 
    LEDMatrix.setRow(0, i, Zeichen[i]);   
  }
}

void loop()
{
  // Start
  if (Start)
  {
    ParcoursBauen();
    Start = false;
    StartZeit = millis();
    int Reihe = 4;
    int Spalte = 4;
    LEDMatrix.setLed(0, Reihe, Spalte, true);
  }

  // Joystick-Button lesen
  if (ZeitStoppen.update())
  {
    if (ZeitStoppen.read() == LOW)
    {
      Start = true;

      // Zeit berechnen
      float Sekunden;
      VerstricheneZeit = millis() - StartZeit;
      Sekunden = VerstricheneZeit / 1000;
      String GesamtSekunden = String(Sekunden);

      // . durch , ersetzen
      GesamtSekunden.replace(".", ",");

      // Ausgabe im Seriellen Monitor
      Serial.println("Sekunden insgesamt: " + GesamtSekunden + " Sekunden");

      // Minuten berechnen
      int Minute  = int(Sekunden) / 60;

      // nur Ausgabe der Minuten wenn Minute > 0
      if (Minute > 0)
      {
        // Ausgabe verschönern, wenn Minute > 1 -> Ausgabe "Minuten"
        // "Minute"
        if (Minute > 1)
        {
          Serial.print(String(Minute) + " Minuten ");
        }
        else
        {
          Serial.print(String(Minute) + " Minute ");
        }
      }

      // von Sekunden Anzahl der Minuten abziehen
      Sekunden = Sekunden - Minute * 60;

      // Sekunden in String umwandeln damit . durch , ersetzt werden kann
      String AnzahlSekunden = String(Sekunden);
      // . durch , ersetzen
      AnzahlSekunden.replace(".", ",");
      Serial.println(AnzahlSekunden + " Sekunden");
    }

  }

  // Bewegung der X-Achse lesen
  PositionX = analogRead(XAchse);

  // Bewegung X-Achse nach oben
  if (PositionX > 600)
  {
    // zu schnelles "Springen" verhindern
    delay(200);
    LEDMatrix.setLed(0, Reihe, Spalte, false);
    if (Spalte > 0) Spalte--;
    LEDMatrix.setLed(0, Reihe, Spalte, true);
  }

  // Bewegung X-Achse nach unten
  if (PositionX < 300)
  {
    delay(200);
    LEDMatrix.setLed(0, Reihe, Spalte, false);
    if (Spalte < 7) Spalte++;
    LEDMatrix.setLed(0, Reihe, Spalte, true);
  }

  // Bewegung der Y-Achse lesen
  PositionY = analogRead(YAchse);

  // Bewegung Y-Achse nach rechts
  if (PositionY > 600)
  {
    delay(200);
    LEDMatrix.setLed(0, Reihe, Spalte, false);
    if (Reihe > 0) Reihe--;
    LEDMatrix.setLed(0, Reihe, Spalte, true);
  }

  // Bewegung Y-Achse nach links
  if (PositionY < 300)
  {
    delay(200);
    LEDMatrix.setLed(0, Reihe, Spalte, false);
    if (Reihe < 7) Reihe++;
    LEDMatrix.setLed(0, Reihe, Spalte, true);
  }
}

Letzte Aktualisierung:

#include "LedControl.h"

int TASTER = 7;
int LAUTSPRECHER = 5;
int TasterLesen;

/*
   VCC -> 5V
   GND
   Pin 12 -> DATA IN-pin
   Pin 11 -> CLK-pin
   Pin 10 -> CS-pin
*/
LedControl LEDMatrix = LedControl(12, 11, 10, 1);

void setup() 
{
  // Matrix "aufwecken"
  LEDMatrix.shutdown(0, false);
  
  //  mittlere Helligkeit setzen
  LEDMatrix.setIntensity(0, 8);
  
  pinMode(TASTER, INPUT_PULLUP);
  pinMode(LAUTSPRECHER, OUTPUT);
}

void loop() 
{
  PfeilUnten();
  TasterLesen = digitalRead(TASTER);
  
  if (TasterLesen == LOW)
  {
    ZahlNeun();
    tone(LAUTSPRECHER, 1000, 100);
    delay(1000);
    
    ZahlAcht();
    tone(LAUTSPRECHER, 1000, 100);
    delay(1000);
    
    ZahlSieben();
    tone(LAUTSPRECHER, 1000, 100);
    delay(1000);
    
    ZahlSechs();
    tone(LAUTSPRECHER, 1000, 100);
    delay(1000);
    
    ZahlFuenf();
    tone(LAUTSPRECHER, 1000, 100);
    delay(1000);
    
    ZahlVier();
    tone(LAUTSPRECHER, 1000, 100);
    delay(1000);
    
    ZahlDrei();
    tone(LAUTSPRECHER, 1000, 100);
    delay(1000);
    
    ZahlZwei();
    tone(LAUTSPRECHER, 1000, 100);
    delay(1000);  
    
    ZahlEins();
    tone(LAUTSPRECHER, 1000, 100);
    delay(1000);    
    
    ZahlNull();
    delay(1000);

    Kreuz();
    tone(LAUTSPRECHER, 500, 1000);
    delay(2000);
  }
}

void PfeilUnten()
{
  byte Zeichen[8] =
  {
    B00010000,
    B00110000,
    B01111111,
    B11111111,
    B01111111,
    B00110000,
    B00010000,
    B00000000
  };

  for (int zaehler = 0; zaehler < 8; zaehler ++)
  {
    LEDMatrix.setRow(0, zaehler, Zeichen[zaehler]);
  }
}

void ZahlEins()
{
  byte Zeichen[8] =
  {
    B00000000,
    B00000000,
    B00000100,
    B10000010,
    B11111111,
    B10000000,
    B00000000,
    B00000000
  };

  for (int zaehler = 0; zaehler < 8; zaehler ++)
  {
    LEDMatrix.setRow(0, zaehler, Zeichen[zaehler]);
  }
}

void ZahlZwei()
{
  byte Zeichen[8] =
  {
    B00000000,
    B10000010,
    B11000001,
    B10100001,
    B10010001,
    B10001110,
    B00000000,
    B00000000
  };

  for (int zaehler = 0; zaehler < 8; zaehler ++)
  {
    LEDMatrix.setRow(0, zaehler, Zeichen[zaehler]);
  }
}

void ZahlDrei()
{
  byte Zeichen[8] =
  {
    B00000000,
    B01000010,
    B10000001,
    B10001001,
    B10001001,
    B01110110,
    B00000000,
    B00000000
  };

  for (int zaehler = 0; zaehler < 8; zaehler ++)
  {
    LEDMatrix.setRow(0, zaehler, Zeichen[zaehler]);
  }
}

void ZahlVier()
{
  byte Zeichen[8] =
  {
    B00000000,
    B00110000,
    B00101000,
    B00100100,
    B11110010,
    B00100001,
    B00000000,
    B00000000
  };

  for (int zaehler = 0; zaehler < 8; zaehler ++)
  {
    LEDMatrix.setRow(0, zaehler, Zeichen[zaehler]);
  }
}

void ZahlFuenf()
{
  byte Zeichen[8] =
  {
    B00000000,
    B01001111,
    B10001001,
    B10001001,
    B10001001,
    B01110001,
    B00000000,
    B00000000
  };

  for (int zaehler = 0; zaehler < 8; zaehler ++)
  {
    LEDMatrix.setRow(0, zaehler, Zeichen[zaehler]);
  }
}

void ZahlSechs()
{
  byte Zeichen[8] =
  {
    B00000000,
    B01111110,
    B10001001,
    B10001001,
    B10001001,
    B01110010,
    B00000000,
    B00000000
  };

  for (int zaehler = 0; zaehler < 8; zaehler ++)
  {
    LEDMatrix.setRow(0, zaehler, Zeichen[zaehler]);
  }
}

void ZahlSieben()
{
  byte Zeichen[8] =
  {
    B00000000,
    B11100001,
    B00010001,
    B00001001,
    B00000101,
    B00000011,
    B00000000,
    B00000000
  };

  for (int zaehler = 0; zaehler < 8; zaehler ++)
  {
    LEDMatrix.setRow(0, zaehler, Zeichen[zaehler]);
  }
}

void ZahlAcht()
{
  byte Zeichen[8] =
  {
    B00000000,
    B01110110,
    B10001001,
    B10001001,
    B10001001,
    B01110110,
    B00000000,
    B00000000
  };

  for (int zaehler = 0; zaehler < 8; zaehler ++)
  {
    LEDMatrix.setRow(0, zaehler, Zeichen[zaehler]);
  }
}

void ZahlNeun()
{
  byte Zeichen[8] =
  {
    B00000000,
    B01001110,
    B10010001,
    B10010001,
    B10010001,
    B01111110,
    B00000000,
    B00000000
  };

  for (int zaehler = 0; zaehler < 8; zaehler ++)
  {
    LEDMatrix.setRow(0, zaehler, Zeichen[zaehler]);
  }
}

void ZahlNull()
{
  byte Zeichen[8] =
  {
    B00000000,
    B01111110,
    B10000001,
    B10000001,
    B10000001,
    B01111110,
    B00000000,
    B00000000
  };

  for (int zaehler = 0; zaehler < 8; zaehler ++)
  {
    LEDMatrix.setRow(0, zaehler, Zeichen[zaehler]);
  }
}

void Kreuz()
{
  const PROGMEM byte Zeichen[8] =
  {
    B10000001,
    B01000010,
    B00100100,
    B00011000,
    B00011000,
    B00100100,
    B01000010,
    B10000001
  };

  for (int zaehler = 0; zaehler < 8; zaehler ++)
  {
    LEDMatrix.setRow(0, zaehler, Zeichen[zaehler]);
  }
}

Letzte Aktualisierung:

byte Zahlen[6] =
{
  B01100000, // 1
  B11001101, // 2
  B11101001, // 3
  B01100011, // 4
  B10101011, // 5
  B10101111, // 6
};

int TASTER = 13;
int LAUTSPRECHER = 10;

void setup()
{
  // Pins auf OUTPUT setzen
  for (int i = 2; i <= 9; i++)
  {
    pinMode(i, OUTPUT);
  }

  pinMode(TASTER, INPUT_PULLUP);

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

void loop()
{
  /* 
   der Bereich der Zahlen 1 bis 6
   als oberer Wert muss 7 angegeben werden,
   weil immer nach unten gerundet wird
  */
  int Minimum = 1;
  int Maximum = 7;
  
  int TasterLesen = digitalRead(TASTER);
  if (!TasterLesen)
  {
    // Würfeleffekt
    // in schneller Folge werden 10 Zufallszahlen angezeigt
    for (int i = 0; i < 10; i++)
    {
      /*
        das Array der Zahlen beginnt mit 0 und endet bei 5
        die Würfelzahlen beginnen mit 1
        -> 1 von der gewürfelten Zahl abziehen,
        um das richtige Array anzuzeigen 
      */
      ZahlZeigen(Zahlen[ZufallsZahl(Minimum, Maximum) - 1]);
      delay(100);
    }

    // gewürfelte Zahl anzeigen
    byte Zahl = ZufallsZahl(Minimum, Maximum);
    ZahlZeigen(Zahlen[Zahl - 1]);
    tone(LAUTSPRECHER, 1000, 10);
  }
}

void ZahlZeigen(byte ArrayZahl)
{
  // Bits des Arrays ArrayZahl prüfen
  // von Pin 2 bis Pin 9 durchlaufen
  for (int i = 2; i <= 9; i++)
  {
    /*
      vergleicht das Byte ArrayZahl mit dem Byte B10000000
      befindet sich an beiden Positionen eine 1
      das Ergebnis der Prüfung ist also nicht 0
      -> Segment einschalten
      ist eine der Positionen eine 0
      das Ergebnis der Prüfung ist 0
      -> Segment ausschalten
      1 Bit nach links schieben -> nächstes Bit prüfen
      nach 8 Durchläufen sind alle Segmente (Pins) richtig geschaltet
    */
    if ((ArrayZahl & B10000000) != 0) digitalWrite(i, HIGH);
    else  digitalWrite(i, LOW);

    ArrayZahl = ArrayZahl << 1;
  }
}

int ZufallsZahl(int Minimum, int Maximum)
{
  int Zahl =  random(Minimum, Maximum);
  return Zahl;
}

#include "IRremote.hpp"
int EmpfaengerPin = 11;

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

  // auf serielle Verbindung warten
  while (!Serial);
  delay(1000);

  // Empfänger starten
  IrReceiver.begin(EmpfaengerPin);
}

void ReiheAnzeigen(int Zahl) 
{
  Serial.print("Einmaleins der ");
  Serial.println(Zahl);
  for (int i = 1; i <= 10; i++) 
  {
    Serial.print(i);
    Serial.print(" * ");
    Serial.print(Zahl);
    Serial.print(" = ");
    Serial.print(i * Zahl);
    Serial.println();
  }
  Serial.println("-----------------------");
}

void loop() 
{
  // Daten lesen
  if (IrReceiver.decode()) 
  {
    // kurzes delay, damit nur eine Taste gelesen wird
    delay(200);

    // nächsten Wert lesen
    IrReceiver.resume();

    /*
      es sollen nur die korrekt erkannten Tasten ausgewertet werden
      die Dezimalwerte der korrekten Tasten liegen zwischen > 0 und < 95
    */
    if (IrReceiver.decodedIRData.command > 0 && IrReceiver.decodedIRData.command < 95) 
    {
      // wenn die Werte der Tasten nicht bekannt sind: // vor den nächsten Zeilen entfernen
      // Serial.print("Dezimalwert: ");
      // Serial.print(IrReceiver.decodedIRData.command);
      // Serial.println();
      
      // je nach Wert Zahl an die Funktion ReiheAnzeigen() übergeben
      switch (IrReceiver.decodedIRData.command) 
      {
        // Taste 1
        case 22:
          ReiheAnzeigen(1);
          break;

        // Taste 2
        case 25:
          ReiheAnzeigen(2);
          break;

        // Taste 3
        case 13:
          ReiheAnzeigen(3);
          break;

        // Taste 4
        case 12:
          ReiheAnzeigen(4);
          break;

        // Taste 5
        case 24:
          ReiheAnzeigen(5);
          break;

        // Taste 6
        case 94:
          ReiheAnzeigen(6);
          break;

        // Taste 7
        case 8:
          ReiheAnzeigen(7);
          break;

        // Taste 8
        case 28:
          ReiheAnzeigen(8);
          break;

        // Taste 9
        case 90:
          ReiheAnzeigen(9);
          break;

        default:
          break;
      }
    }
  }
}

Letzte Aktualisierung:

// Frequenzen: c' d' e' f' g' a' h' c'' 
int Tonleiter[] = 
{261, 293, 329, 349, 391, 440, 493, 523, 493, 440, 391, 349,  329, 293, 261}; 

// Länge der Töne "Tonleiter" in Millisekunden 
int TonlaengeTonleiter[] = 
{200, 200, 200, 200, 200, 200, 200, 200, 200, 200,  200, 200, 200, 200, 200, 200}; 

// Frequenzen "Alle meine Entchen“ 
int AlleMeineEntchen[] = 
{261, 293, 329, 349, 391, 391, 440, 440, 440, 440, 391, 440, 440, 440, 440, 391, 349, 349, 349, 349, 329, 329, 391, 391, 391, 391,  261}; 

// Länge der Töne "Alle meine Entchen“ in Millisekunden 
int TonlaengeAlleMeineEntchen[] = 
{250, 250, 250, 250, 500, 500, 250, 250, 250,  250, 500, 250, 250, 250, 250, 500, 250, 250, 250, 250, 500, 500, 250, 250, 250,  250, 500, 500}; 

// Frequenzen "Bruder Jakob“ 
int BruderJakob[] = 
{349, 391, 440, 349, 349, 391, 440, 349, 440, 466, 523,  440, 466, 523 }; 

// Länge der Töne "Bruder Jakob“ in Millisekunden 
int TonlaengeBruderJakob[] = 
{500, 500, 500, 500, 500, 500, 500, 500, 500, 500,  1000, 500, 500, 1000}; 

// Frequenzen "Backe backe Kuchen“
int BackeKuchen[] = 
{440, 440, 493, 493, 440, 369, 293, 440, 440, 493, 493, 440,  
369};

// Länge der Töne "Backe backe Kuchen“ in Millisekunden 
int TonlaengeBackeKuchen[] = 
{250, 250, 250, 250, 500, 250, 250, 250, 250, 250,  250, 500, 250};

int LAUTSPRECHER = 4; 
int Taster;
int Analogwert;

void setup()
{
  // wenn der Wert der gedrückten Taste angezeigt werden soll
  // Serial.begin(9600);
}

int Tasterabfrage()
{
  int Analogwert = analogRead(A0);
  
  // kurzes delay() -> doppelten Tastendruck so weit wie möglich verhindern
  delay(200);

  /* 
     A0 gibt je nach Taster einen Wert aus
     über den Seriellen Monitor wird dieser Wert angezeigt
     und kann dann eventuell angepasst werden
  */
  // Serial.println(Analogwert);

  switch (Analogwert)
  {
    case 0 ... 20:
      Taster = 1;
      break;
    case 30 ... 60:
      Taster = 2;
      break;
    case  70 ... 120:
      Taster = 3;
      break;
    case 150 ... 200:
      Taster = 4;
      break;
    case 300 ... 400:
      Taster = 5;
      break;
    default:
      return 0;
  }

  // gedrückten Taster zurückgeben
  return Taster;
}

void loop()
{
  Taster = Tasterabfrage();

  // Taste links
  if (Taster == 1)
  {
    // Alle meine Entchen
    for (int i = 0; i < sizeof(AlleMeineEntchen) / sizeof(AlleMeineEntchen[0]); i++)
    {
      tone(LAUTSPRECHER, AlleMeineEntchen[i]);
      delay(TonlaengeAlleMeineEntchen[i]);
      delay(10);
      noTone(LAUTSPRECHER);
    }
  }

  // Taste oben Mitte
  // backe backe Kuchen spielen
  if (Taster == 2)
  {
    // Backe backe Kuchen
    for (int i = 0; i < sizeof(BackeKuchen) / sizeof(BackeKuchen[0]); i++)
    { 
      tone(LAUTSPRECHER, BackeKuchen[i]);
      delay(TonlaengeBackeKuchen[i]);
      delay(20);
      noTone(LAUTSPRECHER);
    }
  }
  
  // Taste unten Mitte
  // Tonleiter spielen
  if (Taster == 3)    

  {
    for (int i = 0; i < sizeof(Tonleiter) / sizeof(Tonleiter[0]); i++)
    {
      tone(LAUTSPRECHER, Tonleiter[i]);
      delay(TonlaengeTonleiter[i]);
      delay(10);
      noTone(LAUTSPRECHER);
    }
  }

  // Taste rechts
  // Bruder Jakob spielen
  if (Taster == 4)
  {
    // Bruder Jakob
    for (int i = 0; i < sizeof(BruderJakob) / sizeof(BruderJakob[0]); i++)
    {
      tone(LAUTSPRECHER, BruderJakob[i]);
      delay(TonlaengeBruderJakob[i]);
      delay(10);
      noTone(LAUTSPRECHER);
    }
  }
}

int Leuchtdauer = 200;

void setup() 
{
  DDRD = B11111000;
}

void loop()
{
  // Lauflicht hin Start mit LED Pin 7
  PORTD = B10000000;
  delay(Leuchtdauer);
  for (int i = 0; i < 4; i++)
  {
    /*
      1 Bit nach rechts schieben
      B01000000 -> Pin 6
      B00100000 -> Pin 5
      B00010000 -> Pin 4
      B00001000 -> Pin 3
    */
    PORTD = PORTD >> 1;
    delay(Leuchtdauer);
  }

  // Lauflicht zurück Start mit LED Pin 3
  PORTD = B00001000;
  delay(Leuchtdauer);
  for (int i = 0; i < 4; i++)
  {
    /*
      1 Bit nach links schieben
      B00010000 -> Pin 4
      B00100000 -> Pin 5
      B01000000 -> Pin 6
      B10000000 -> Pin 7
    */
    PORTD = PORTD << 1;
    delay(Leuchtdauer);
  }
  delay(Leuchtdauer);
  
  // alle LED
  PORTD = B11111000;
  delay(1000);

  // alle aus
  PORTD = B00000000;
  delay(1000);

  // 7 5 3 leuchten
  PORTD = B10101000;
  delay(1000);

  // umkehren die inneren LEDs leuchten
  PORTD = ~PORTD;
  delay(1000);

  // die beiden äußeren
  PORTD = B10001000;
  delay(1000);

  // die inneren
  PORTD = ~PORTD;;
  delay(1000);
  
  // nur die mittlere
  PORTD = B00100000;
  delay(1000);

  // alle aus
  PORTD = B00000000;
  delay(1000);

}

Letzte Aktualisierung:

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

/*
  Array für den Zustand der LEDs
  false = ausgeschaltet
*/
bool Status[5] = {false, false, false, false, false};

int Taster;
int Analogwert;

int Tasterabfrage()
{
  Analogwert = analogRead(A0);
  delay(200);
  Serial.println(Analogwert);
  /*
    A0 gibt je nach gedrückten Taster einen Wert aus
    über den Seriellen Monitor wird dieser Wert angezeigt
    und kann dann eventuell angepasst werden
    die Zeile Serial.println ... kann dann gelöscht werden
    Taster 1 ⇒ links
    Taster 2 ⇒ oben Mitte
    Taster 3 ⇒ unten Mitte
    Taster 4 ⇒ rechts
    Taster 5 ⇒ außen
  */
  switch (Analogwert)
  {
    case 0 ... 20:
      Taster = 1;
      break;

    case 30 ... 60:
      Taster = 2;
      break;

    case  70 ... 120:
      Taster = 3;
      break;

    case 150 ... 200:
      Taster = 4;
      break;

    case 300 ... 400:
      Taster = 5;
      break;

    default:
      return 0;
  }

  // gedrückten Taster zurückgeben
  return Taster;
}

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

  Serial.begin(9600);
}

void loop()
{
  Taster = Tasterabfrage();

  // Taster links
  if (Taster == 1)
  {
    /*
      gelbe LED Pin 7, LED[4] Status[4]
      Status umdrehen, aus true wird false
      aus false wird true
    */
    Status[4] = !Status[4];
    digitalWrite(LED[4], Status[4]);
  }

  // Taster oben Mitte
  if (Taster == 2)
  {
    // blaue LED Pin 6, LED[3] Status[3]
    Status[3] = !Status[3];
    digitalWrite(LED[3], Status[3]);
  }

  // Taster unten Mitte
  if (Taster == 3)
  {
    // rote LED Pin 5, LED[2] Status[2]
    Status[2] = !Status[2];
    digitalWrite(LED[2], Status[2]);
  }

  // Taster rechts
  if (Taster == 4)
  {
    // weiße LED Pin 4, LED[1] Status[1]
    Status[1] = !Status[1];
    digitalWrite(LED[1], Status[1]);
  }

  // Taster rechts außen
  if (Taster == 3)
  {
    // grüne LED Pin 3, LED[0] Status[0]
    Status[0] = !Status[0];
    digitalWrite(LED[0], Status[0]);
  }
}

Letzte Aktualisierung:

// Definition der Tasten mit den dazugehörigen Pins
int TASTE[4] = {4, 5, 6, 7};

// Definition der LEDs mit den dzugehörigen Pins
int LED[3] = {8, 9, 10};

// Status der LEDs, beim Start alle aus
bool Status[3] = {false, false, false};

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

  // Tasten als INPUT definieren
  for (int i = 0; i <= 3; i++)
  {
    pinMode(TASTE[i], INPUT);
  }
}

void loop() 
{
  /* 
    prüfen, welche Taste gedrückt wurde
    Status der jeweiligen LED wird umgedreht
    HIGH ⇒ LOW LOW ⇒ HIGH
    die Tasten reagieren empfindlich auf Berührung
    -> kurzes delay einfügen
  */
  for (int i = 0; i < sizeof(TASTE) - 1; i++)
  {
    if (digitalRead(TASTE[i]) == HIGH)      
    {
      delay(200);
      Status[i] = !Status[i];
      digitalWrite(LED[i], Status[i]);
    }
  }

  // Taste 4 schaltet alle LEDs aus
  if (digitalRead(7) == HIGH)
  {
    for (int i = 0; i <= 2; i++)
    {
      digitalWrite(LED[i], LOW);
    }
  }
}

Letzte Aktualisierung: