Lösungen

#include "vs1053_SdFat.h"
#include "Bounce2.h"

SdFat sd;
vs1053 MP3player;

// die Taster
int TASTER1 = 6;
int TASTER2 = 7;

// "Prallverhinderer" für die Tasten starten
Bounce Taste_Spieler1 = Bounce();
Bounce Taste_Spieler2 = Bounce();

// Summe der Augen der beiden Spieler
int SummeSpieler1;
int SummeSpieler2;

// Anzahl der Runden, Start mit 1
int Runde = 1;

int Zahl;
int TasterStatus;

// Reihenfolge der Spieler festlegen, Spieler1 startet
bool StartSpieler1 = true;
bool StartSpieler2 = false;

void setup()
{
  pinMode(TASTER1, INPUT_PULLUP);
  pinMode(TASTER2, INPUT_PULLUP);

  // Instanzen des Objekts Bounce für jede Taste zuordnen
  // Zeitintervall einstellen
  Taste_Spieler1.attach(TASTER1);
  Taste_Spieler1.interval(20);
  Taste_Spieler2.attach(TASTER2);
  Taste_Spieler2.interval(20);

  // SD Karte lesen
  sd.begin(SD_SEL, SPI_FULL_SPEED);

  // in das Wurzelverzeichnis wechseln
  sd.chdir("/");

  // Player starten
  MP3player.begin();

  // Lautstärke setzen
  MP3player.setVolume(5, 5);

  // Zufallsgenerator starten
  randomSeed(analogRead(A0));
  Serial.begin(9600);
}

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

  // 5 Durchgänge
  while (Runde < 6)
  {
    // Spieler 1
    if (StartSpieler1)
    {
      // 1. Spieler
      if (Taste_Spieler1.update())
      {
        if (Taste_Spieler1.read() == LOW)
        {
          // kurzes "Beep" spielen
          MP3player.SendSingleMIDInote();
          MP3player.SendSingleMIDInote();
          Serial.println("Runde " + String(Runde));

          int Zahl =  random(Minimum, Maximum);
          Serial.println("Spieler 1: gewuerfelte Zahl " + String(Zahl));
          delay(2000);

          /*
            track001 -> 1
            track002 -> 2
            ...
            track201 -> Spieler 1
          */
          MP3player.playTrack(211);
          delay(2000);
          MP3player.playTrack(Zahl);

          SummeSpieler1 = SummeSpieler1 + Zahl;
          Serial.println("Spieler 1: Summe: " + String(SummeSpieler1));
          Serial.println("-----------------------------");

          delay(2000);
          /*
            Summe ausgeben
            ab track101 sind die Zahlen für die Summe der gewürfelten Zahlen
            track101 -> 1
            track102 -> 2
            track103 -> 3
            ...
            -220 + SummeSpieler1
          */
          MP3player.playTrack(100 + SummeSpieler1);

          /*
            ausreichend Zeit lassen
            Datei muss geladen und abgespielt werden
          */
          delay(2000);

          // Wechsel -> Spieler2 ist an der Reihe
          StartSpieler1 = !StartSpieler1;
          StartSpieler2 = !StartSpieler2;
        }
      }
    }

    // 1. Spieler
    if (Taste_Spieler2.update())
    {
      if (Taste_Spieler2.read() == LOW)
      {
        // kurzes "Beep" spielen
        MP3player.SendSingleMIDInote();
        MP3player.SendSingleMIDInote();
        int Zahl =  random(Minimum, Maximum);
        Serial.println("Spieler 2: gewuerfelte Zahl " + String(Zahl));
        delay(2000);
        MP3player.playTrack(212);
        delay(2000);
        MP3player.playTrack(Zahl);
        SummeSpieler2 = SummeSpieler2 + Zahl;
        Serial.println("Spieler 2: Summe: " + String(SummeSpieler2));
        Serial.println("-----------------------------");

        delay(2000);
        // Summe ausgeben
        MP3player.playTrack(100 + SummeSpieler2);

        /*
          ausreichend Zeit lassen
          Datei muss geladen und abgespielt werden
        */
        delay(2000);

        // nur bei Spieler2 Runde hochzählen, Spieler1 hat angefangen
        Runde ++;

        // Wechsel -> Spieler2 ist an der Reihe
        StartSpieler1 = !StartSpieler1;
        StartSpieler2 = !StartSpieler2;
      }
    }
  }

  // unentschieden
  if (SummeSpieler1 == SummeSpieler2)
  {
    Serial.println("unentschieden");
    Serial.println("-----------------------------");
    MP3player.playTrack(200);
    delay(2000);

    // alle Werte zurücksetzen
    Runde = 1;
    SummeSpieler1 = 0;
    SummeSpieler2 = 0;
  }

  // Sieger Spieler1
  if (SummeSpieler1 > SummeSpieler2)
  {
    Serial.println("Sieger Spieler 1");
    Serial.println("-----------------------------");
    MP3player.playTrack(201);
    delay(2000);
    // alle Werte zurücksetzen
    Runde = 1;
    SummeSpieler1 = 0;
    SummeSpieler2 = 0;
  }

  // Sieger Spieler2
  if (SummeSpieler1 < SummeSpieler2)
  {
    Serial.println("Sieger Spieler 2");
    Serial.println("-----------------------------");
    MP3player.playTrack(202);
    delay(2000);

    // alle Werte zurücksetzen
    Runde = 1;
    SummeSpieler1 = 0;
    SummeSpieler2 = 0;
  }
}

Letzte Aktualisierung:

#include "IRremote.hpp"

// Pin für den Auslöser des Interrupts
int InterruptPin = 2;

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

// Anzahl der LEDs feststellen
int LEDMax = sizeof(LED) / sizeof(LED[0]);

// Variable im Flash-Speicher ablegen
volatile bool Status = true;
int Leuchtdauer = 100;

void setup()
{
  // Zufallsgenerator starten
  randomSeed(analogRead(A0));
  
  // Empfänger starten
  IrReceiver.begin(InterruptPin);
  
  for (int i = 0; i < LEDMax; i++)
  {
    pinMode(LED[i], OUTPUT);
  }

  // Funktion Schalten() dem Interrupt-Pin zuordnen
  attachInterrupt(digitalPinToInterrupt(InterruptPin), Schalten, FALLING);
}

void loop()
{
  // Daten lesen
  if (IrReceiver.decodedIRData.address == 0)
  {
    if (IrReceiver.decode()) 
    {
      delay(200);

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

      Status = true;
      /*
        solange der Status true ist, wird die jeweilige while-Schleife
        ausgeführt, ein weiterer Druck auf eine Taste der Fernbedienung löst
        den Interrupt aus
        -> Status wird zu false, die while-Schleife wird nicht erneut   
        ausgeführt
      */
      switch (IrReceiver.decodedIRData.command) 
      {
        // Taste 1: Lauflicht vor
        case 22:
          while (Status) LauflichtHin();
          break;

        // Taste 2:  LEDs leuchten vor und zurück
        case 25:
          while (Status) LauflichtHinUndHer();
          break;

        // Taste 3: LEDs blinken nacheinander
        case 13:
          while (Status) LauflichtMitBlinken();
          break;
      }
    }
  }
}

void Schalten()
{
  Status = false;
}

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

void LauflichtHin()
{
  for (int i = 0; i < LEDMax; i++)
  {
    digitalWrite(LED[i], HIGH);
    delay(Leuchtdauer);
    digitalWrite(LED[i], LOW);
  }
}

void LauflichtHinUndHer()
{
  for (int i = 0; i < LEDMax; i++)
  {
    digitalWrite(LED[i], HIGH);
    delay(Leuchtdauer);
    digitalWrite(LED[i], LOW);
  }
  
  // und wieder zurück
  for (int i = LEDMax - 1; i >= 0; i--)
  {
    digitalWrite(LED[i], HIGH);
    delay(Leuchtdauer);
    digitalWrite(LED[i], LOW);
  }
}

void LauflichtMitBlinken()
{
  for (int i = 0; i < LEDMax; i++)
  {
    int Anzahl = random(1, 5);
    /* aktuelle LED i einschalten
      ⇒ Funktion LEDBlinken aufrufen
    */
    LEDBlinken(LED[i], Anzahl);
  }
}

Letzte Aktualisierung:

#include "Adafruit_NeoPixel.h"

#define RING 7

// Anzahl der LEDs -> muss angepasst werden
#define AnzahlLED 16

// Variable für den gedrückten Taster
volatile bool Links = false;
volatile bool Rechts = false;

// Minimum/Maximum für die Farbwerte festlegen
#define Minimum 0
#define Maximum 255

// Leuchtdauer der LEDs
#define Wartezeit 50

// LED-Ring -> Name des LED-Rings
Adafruit_NeoPixel LEDRing = Adafruit_NeoPixel(AnzahlLED, RING, NEO_GRB + NEO_KHZ800);

// Taster definieren
#define TASTERLINKS 2
#define TASTERRECHTS 3

void setup()
{
  // Zufallsgenerator starten
  randomSeed(analogRead(A0));

  // NeoPixel Bibliothek initialisieren
  LEDRing.begin();

  // setBrightness(0..255)
  LEDRing.setBrightness(200);

  LEDRing.clear();
  LEDRing.show();
  
  pinMode(TASTERLINKS, INPUT_PULLUP);
  pinMode(TASTERRECHTS, INPUT_PULLUP);

  // Funktion für das Auslösen des Interrupts definieren
  // Taster links
  attachInterrupt(digitalPinToInterrupt(TASTERLINKS), LEDSchaltenLinks, CHANGE);

  // Taster rechts
  attachInterrupt(digitalPinToInterrupt(TASTERRECHTS), LEDSchaltenRechts, CHANGE);
}

void loop()
{
  // linke Taste gedrückt
  if (Links)
  {
    // zufällige Farbwerte
    int ROT = ZufallsFarbe();
    int GRUEN = ZufallsFarbe();
    int BLAU = ZufallsFarbe();

    /*
     feste Farbwerte:
     ROT:
     int ROT = 255; 
     int GRUEN = 0;
     int BLAU = 0;
     ----------------
     GRUEN     
     int ROT = 0;
     int GRUEN = 255;
     int BLAU = 0;
     -----------------
     BLAU     
     int ROT = 0;
     int GRUEN = 0;
     int BLAU = 255;
     -----------------
     GELB     
     int ROT = 255;
     int GRUEN = 255;
     int BLAU = 0;
    */

    // links drehen
    for (int LEDNummer = LEDRing.numPixels(); LEDNummer >= 0 ; LEDNummer--)
    {
      LEDRing.setPixelColor(LEDNummer, LEDRing.Color(ROT, GRUEN, BLAU));
      LEDRing.show();

      // Unterbrechung wenn der rechte Taster gedrückt wurde
      if (Rechts) break;

      delay(Wartezeit);
    }

    for (int LEDNummer = LEDRing.numPixels(); LEDNummer >= 0 ; LEDNummer--)
    {
      LEDRing.setPixelColor(LEDNummer, 0);
      LEDRing.show();

      // Unterbrechung wenn der rechte Taster gedrückt wurde
      if (Rechts) break;
      delay(Wartezeit);
    }

    /*
      wenn der Streifen nach einem Durchlauf stoppen soll:
     // Links = false;
    */
    Links = true;
    LEDRing.clear();
    LEDRing.show();
  }

  // rechte Taste gedrückt -> rechts drehen
  if (Rechts)
  {
    int ROT = ZufallsFarbe();
    int BLAU = ZufallsFarbe();
    int GRUEN = ZufallsFarbe();

    for (int LEDNummer = 0; LEDNummer <= LEDRing.numPixels() ; LEDNummer++)
    {
      LEDRing.setPixelColor(LEDNummer, LEDRing.Color(ROT, BLAU, GRUEN));
      LEDRing.show();
      // Unterbrechung wenn der rechte Taster gedrückt wurde
      if (Links) break;
      delay(Wartezeit);
    }

    // LEDs ausschalten
    for (int LEDNummer = 0; LEDNummer <= LEDRing.numPixels() ; LEDNummer++)
    {
      LEDRing.setPixelColor(LEDNummer, 0);
      LEDRing.show();

      // Unterbrechung wenn der linke Taster gedrückt wurde
      if (Links) break;
      delay(Wartezeit);
    }

    /*
      wenn der Ring nach einem Durchlauf stoppen soll:
      // Rechts = false;
    */
    Rechts = true;
    LEDRing.clear();
    LEDRing.show();
  }
}

void LEDSchaltenRechts()
{
  Rechts = true;
  Links = false;
}

void LEDSchaltenLinks()
{
  Links = true;
  Rechts = false;
}

int ZufallsFarbe() 
{ 
  int Farbe =  random(0, 255);  
  return Farbe; 
}

Letzte Aktualisierung:

#define BEWEGUNG_EIN 2
#define BEWEGUNG_AUS 3
#define ROT 5

void setup()
{ 
  pinMode(ROT, OUTPUT); 
  pinMode(BEWEGUNG_EIN, INPUT);   
  pinMode(BEWEGUNG_AUS, INPUT);

  /* 
    wenn eine Bewegung registriert wird 
    Signal ist HIGH -> RISING -> LEDEin 
    wenn die Wartezeit abgelaufen ist 
    Signal ist LOW -> FALLING -> LEDAus 
  */ 
  attachInterrupt(digitalPinToInterrupt(BEWEGUNG_EIN), LEDEin, RISING); 
  attachInterrupt(digitalPinToInterrupt(BEWEGUNG_AUS), LEDAus, FALLING);
}

void loop()
{
  // bleibt leer, das Programm reagiert nur auf die Interrupts
}

void LEDEin() 
{
  digitalWrite(ROT, HIGH);
}

void LEDAus() 
{
  digitalWrite(ROT, LOW);
}

Letzte Aktualisierung:

#define ROT 5

// nur Port 2 und 3 können mit 
// attachInterrupt angesprochen werden 
#define TASTER 2

/* 
  je nach Zustand der Variable TasterStatus ist die LED ein- 
  oder ausgeschaltet 
  beim Start des Programms ist sie ausgeschaltet
*/ 
volatile bool TasterStatus = LOW; 

void setup()  
{ 
  pinMode(ROT, OUTPUT); 
  
  // Eingangspegel auf HIGH setzen 
  pinMode(TASTER, INPUT_PULLUP); 
  attachInterrupt(digitalPinToInterrupt(TASTER), LEDSchalten, FALLING); 
} 

void loop()  
{ 
  // nichts zu tun 
  // das Programm reagiert nur auf den Interrupt 
}

void LEDSchalten()  
{ 
  TasterStatus = !TasterStatus; 
  digitalWrite(ROT, TasterStatus); 
}

Letzte Aktualisierung:

#define ROT 5 

// nur Port 2 und 3 können mit 
// attachInterrupt angesprochen werden 
#define TASTER 2 

/* 
  je nach Zustand der Variable TasterStatus ist die LED ein- 
  oder ausgeschaltet 
  beim Start des Programms ist sie ausgeschaltet
*/ 
volatile bool TasterStatus = LOW; 

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

  // Eingangspegel auf HIGH setzen 
  pinMode(TASTER, INPUT_PULLUP); 
  
  /*
    wenn der Taster gedrückt wird 
    ⇒ Funktion LEDSchalten aufrufen 
    CHANGE ⇒ es ist eine Veränderung eingetreten,
    der Taster wurde gedrückt
  */
  attachInterrupt(digitalPinToInterrupt(TASTER), LEDSchalten, CHANGE); 
} 

void loop()  
{ 
  // nichts zu tun 
  // das Programm reagiert nur auf den Interrupt 
} 

void LEDSchalten()  
{ 
  // TasterStatus wird gelesen 
  TasterStatus = digitalRead(TASTER); 

  /*  
    TasterStatus muss "umgedreht" werden 
    weil TasterStatus bei gedrücktem Taster den Wert LOW hat 
    die LED aber leuchten soll 
  */ 
  digitalWrite(ROT, !TasterStatus); 
}

#include <SoftwareSerial.h>

// Zuordnung von RX und TX: TX ⇒ 3, RX ⇒ 4
SoftwareSerial BTSerial(3, 4);

// über Bluetooth vom Smartphone gesendeter Wert
// dieser Wert wird im Programm ausgewertet
char btDaten;

// LEDs
int GRUEN = 7;
int GELB = 6;
int ROT = 5;

void setup()
{
  BTSerial.begin(9600);
  pinMode(ROT, OUTPUT);
  pinMode(GELB, OUTPUT);
  pinMode(GRUEN, OUTPUT);
}

void loop()
{
  if (BTSerial.available())
  {
    // vom Smartphone gesendeten Wert lesen
    btDaten = BTSerial.read();

    // rot ein
    if (btDaten == '1')
    {
      digitalWrite(ROT, HIGH);

      // gelesenen Wert in der App anzeigen
      BTSerial.println("rot an!");
    }

    // rot aus
    if (btDaten == '2')
    {
      digitalWrite(ROT, LOW);
      BTSerial.println("rot aus!");
    }

    // gelb an
    if (btDaten == '3')
    {
      digitalWrite(GELB, HIGH);
      BTSerial.println("gelb an!");
    }

    // gelb aus
    if (btDaten == '4')
    {
      digitalWrite(GELB, LOW);
      BTSerial.println("gelb aus!");
    }

    // grün an
    if (btDaten == '5')
    {
      digitalWrite(GRUEN, HIGH);
      BTSerial.println("gr\u00fcn an!");
    }

    // grün aus
    if (btDaten == '6')
    {
      digitalWrite(GRUEN, LOW);
      BTSerial.println("gr\u00fcn aus!");
    }
  }
}

Letzte Aktualisierung:

Für die Dar­stel­lung im Brow­ser ist in den Zei­le 127 und 136 eine Ände­rung nötig:

#include "SimpleDHT.h"
#include "LiquidCrystal_I2C.h"

int SENSOR_DHT22 = 9;

// Sensor einen Namen zuweisen (dht22)
SimpleDHT22 dht22(SENSOR_DHT22);

// LCD einen Namen zuweisen
LiquidCrystal_I2C lcd(0x27, 20, 4);

// Pin des Lüfters
int LUEFTER = 8;

void setup()
{
  // LCD einschalten
  lcd.init();
  lcd.backlight();

  pinMode(LUEFTER, OUTPUT);
  Serial.begin(9600);
}

void loop()
{
  float Temperatur;
  
  // Daten lesen 
  // nur Temperatur
  dht22.read2(&Temperatur, NULL, NULL);
  
  // in Strings umwandeln, . durch , ersetzen
  String AnzeigeTemperatur = String(Temperatur);
  AnzeigeTemperatur.replace(".", ",");

  // Anzeige Serieller Monitor
  Serial.println("DHT22: " + AnzeigeTemperatur);
  Serial.println("------------------------------");
  
  // Anzeige LCD
  lcd.setCursor(0, 0);
  lcd.print("Temperatur: ");
  lcd.setCursor(0, 1);
  lcd.print(AnzeigeTemperatur + " \337C -> DHT22");

  // Lüfter einschalten
  if (Temperatur > 25)
  {
    digitalWrite(LUEFTER, HIGH);
    lcd.setCursor(0, 3);
    lcd.print("L\365fter eingeschaltet");
  }

  // Lüfter ausschalten
  else
  {
    digitalWrite(LUEFTER, LOW);
    lcd.setCursor(0, 3);

    lcd.print("L\365fter ausgeschaltet");
  }

  delay(2000);
}

Letzte Aktualisierung: