Source-Code Group2

#include "DHT.h"

// ---------- Festlegung der Variablen und Pins

// Festlegung des Temperatursensors:
#define DHTPIN 2                // Pin zum DHT Sensor
#define DHTTYPE DHT11           // Typ des Sensors (DHT 11)

// Festlegung der LEDs:
#define RED 6                   // Rote LED auf Pin 6
#define GREEN 5                 // Grüne LED auf Pin 5
#define BLUE 3                  // Blaue LED auf Pin 3

// Festlegung des Bewegungssensors:
int inputPin = 4;               // Festlegung des Inputs der Daten
int bewegung = LOW;             // Keine Bewegung als Standartwert
int pinStatus = 0;              // Variable um den Pin-Status auszulesen

// Festlegung des Lichtsensors:
int LDR = A2;                   // Analoger Pin als LDR Eingang
int sensorWert = 0;             // Variable für den Sensorwert mit 0 als Startwert

// Feste Variablen:
int redValue;                   // Variable, die den Rotwert  (0-255) speichert
int greenValue;                 // Variable, die den Grünwert (0-255) speichert
int blueValue;                  // Variable, die den Blauwert (0-255) speichert
int redOldValue;                // Variable, die den vorherigen Rotwert  (0-255) speichert
int greenOldValue;              // Variable, die den vorherigen Grünwert (0-255) speichert
int blueOldValue;               // Variable, die den vorherigen Blauwert (0-255) speichert
int farbwert = 0;               // Variable, die den Farbwert festlegt, um eine Unterscheidung der Farben zu ermöglichen
int oldFarbwert;                // Variable, die den alten Farbwert speichert, um eine Änderung feststellen zu können
int zaehler = 0;                // Variable, die genutzt wird, um die Anzahl der Durchgänge mit Beleuchtung zu zählen (zählt hoch)
int temperaturSchleife = 0;     // Variable, die genutzt wird, um die Temperatur nur in bestimmten Zeitintervallen abzufragen
float h;                        // Variable, die die Luftfeuchtigkeit speichert
float t;                        // Variable, die die Temperatur speichert
float f;                        // Variable, die die Temperatur auf Celsius setzt

// Anpassbare Variablen:
int zaehlerwert = 10;           // Legt fest, wie lange das Licht nach Auslösung anbleiben soll. Angabe in Durchgängen (z.B. bei 1000 wartezeit und 10 zaehlerwert = 10 Sekunden)
int wartezeit = 1000;           // Legt fest nach wieviel Millisekunden die Sensoren reagieren sollen(z.B. 1000ms = 1 Sekunde)
int tempSchleifenZeit = 2;      // Legt fest, wann der Temperatursensor messen soll. Angabe in Durchgängen z.B.: 2 = nach 2 Durchgängen wird gemessen (Richtwert = ungefähr 2 Sekunden)

DHT dht(DHTPIN, DHTTYPE);       // Erstellt die Temperatur




// ---------- Erstmaliges Starten des Programms:
void setup() {
  Serial.begin(9600);           // Öffnet die serielle Konsole
  Serial.println("Start!");     // Gibt in der seriellen Konsole an, dass das Programm startet
  pinMode(inputPin, INPUT);     // Input des Bewegungssensors starten
  dht.begin();                  // Temperatursensor starten
}




// ---------- Hauptprogramm:
void loop() {
  // Temperaturmessung:
  if (temperaturSchleife == 0 || temperaturSchleife == tempSchleifenZeit) {   // Temperatursensor misst beim ersten Durchlauf der Schleife sowie beim Erreichen des Maximalwerts
    h = dht.readHumidity();             // Auslesen der Feuchtigkeit in Celsius
    t = dht.readTemperature();          // Auslesen der Temperatur
    f = dht.readTemperature(false);     // Bei True ist es Fahrenheit
    // Überprüfung, ob Fehler beim Auslesen sind:
    if (isnan(h) || isnan(t) || isnan(f)) {
      Serial.println(F("Fehler beim Auslesen!"));
      return;
    }
    // Ausgabe der Werte:
    Serial.print(F("Humidity: "));
    Serial.print(h);
    Serial.print(F("%  Temperature: "));
    Serial.print(t);
    Serial.println(F("°C "));
    temperaturSchleife = 1;         // Setzt die Schleife auf 1, sobald gemessen wurde
  }

  // Bewegungsmessung:
  pinStatus = digitalRead(inputPin);      // Liest den Inputwert aus
  if (pinStatus == HIGH) {                // Überprüft, ob der Input High ist (Datenfluss)
    if (bewegung == LOW) {                // Wenn die bewegung-Variable low ist, soll sie auf HIGH gesetzt werden
      Serial.println("Motion detected");
      zaehler = 1;                        // Da Bewegung vorhanden war, wird die Zählschleife zur Aktivierung des Lichts gestartet
      bewegung = HIGH;                    // Bewegung wird auf High gesetzt
    }
  }
  else {
    if (bewegung == HIGH){
      Serial.println("Motion stopped");
      bewegung = LOW;
    }
  }

  delay(wartezeit);                       // Wartezeit zwischen den Messungen
  Serial.print(F("Zaehler: "));           // Ausgabe des Zählers zur Nachverfolgung
  Serial.println( zaehler );              // Ausgabe des Zählers zur Nachverfolgung

  // Lichtmessung:
  sensorWert = analogRead(LDR);           // Wert auslesen
  Serial.print(F("Brightness: "));
  Serial.println(sensorWert);             // Ausgabe am Serial-Monitor

  // Ausschalten der LEDs:
  // Wenn der zaehler 5 ist, wird die LED ausgeschaltet:
  if ( zaehler == zaehlerwert) {          // Wenn der zaehler den zaehlerwert erreicht hat, wird das Licht ausgeschaltet
    zaehler = 0;                          // zaehler wird auf 0 gesetzt, um eine neue Auslösung zu ermöglichen
    Serial.println( "LIGHTS OFF" );
    analogWrite(RED, 0);
    analogWrite(GREEN, 0);
    analogWrite(BLUE, 0);
    farbwert = 0;                         // Farbwert wird gesetzt, um eine Farbänderung nach Ausschalten feststellen zu können
  }

  // Auswertung ob LEDs eingeschaltet werden müssen:
  if (sensorWert > 300) {                           // Wenn es dunkler als 300 ist, dann passiert das folgende (Im Test war ein Wert von 500 Dunkel):
    Serial.print("Dunkel --> Wert: ");              // Ausgabe der Dunkelheit
    Serial.println(sensorWert);
    if (zaehler < zaehlerwert && zaehler != 0) {    // Wenn Bewegung erfolgt ist und damit die Zaehlschleife aktiv wurde, setze die Farben anhand der Temperatur:
      if ( t >= 25 ) {
        Serial.println( "Temperature-Color: PINK" );
        farbwert = 1;                               // Ermöglicht die einfache Unterscheidung, um Wechsel der Farben zu ermöglichen
        redValue = 255;
        greenValue = 0;
        blueValue = 255;
      }
      else if ( t >= 24 && t < 25) {
        Serial.println( "Temperature-Color: RED" );
        farbwert = 2;
        redValue = 255;
        greenValue = 0;
        blueValue = 0;
      }
      else if ( t >= 23 && t < 24) {
        Serial.println( "Temperature-Color: ORANGE" );
        farbwert = 3;
        redValue = 255;
        greenValue = 140;
        blueValue = 26;
      }
      else if ( t >= 22 && t < 23) {
        Serial.println( "Temperature-Color: YELLOW" );
        farbwert = 4;
        redValue = 255;
        greenValue = 255;
        blueValue = 0;
      }
      else if ( t >= 21 && t < 22) {
        Serial.println( "Temperature-Color: GREEN" );
        farbwert = 5;
        redValue = 0;
        greenValue = 255;
        blueValue = 0;
      }
      else if ( t >= 20 && t < 21) {
        Serial.println( "Temperature-Color: TURQUOISE" );
        farbwert = 6;
        redValue = 100;
        greenValue = 255;
        blueValue = 255;
      }
      else if ( t < 20) {
      Serial.println( "Temperature-Color: BLUE" );
      farbwert = 7;
      redValue = 0;
      greenValue = 0;
      blueValue = 255;
      }
      // Temperatur-Unterschiede - ÜBerprüfung ob Farbe geändert werden muss:
      if ( farbwert != oldFarbwert) {               // Wenn sich die neue Farbe nicht gleich dem alten Farbwert ist, dann mache das folgende:
        for(int i = 0; i < 255; i += 1) {           // For-Schleife um Werte langsam zu ändern
          // Rote Farbe:
          if (redValue > redOldValue) {             // Wenn der neue Farbwert größer ist als der alte (z.B. 255 statt 100)
            redOldValue += 1;
          }
          else if (redValue < redOldValue) {        // Wenn der neue Farbwert kleiner ist als der alte (z.B. 100 statt 255)
            redOldValue -= 1;
          }
          // Grüne Farbe:
          if (greenValue > greenOldValue) {         // Wenn der neue Farbwert größer ist als der alte (z.B. 255 statt 100)
            greenOldValue += 1;
          }
          else if (greenValue < greenOldValue) {    // Wenn der neue Farbwert kleiner ist als der alte (z.B. 100 statt 255)
            greenOldValue -= 1;
          }
          // Blaue Farbe:
          if (blueValue > blueOldValue) {           // Wenn der neue Farbwert größer ist als der alte (z.B. 255 statt 100)
            blueOldValue += 1;
          }
          else if (blueValue < blueOldValue) {      // Wenn der neue Farbwert kleiner ist als der alte (z.B. 100 statt 255)
            blueOldValue -= 1;
          }
          // Ändern der Farbe im Abstand von 10 ms:
          analogWrite(RED, redOldValue);
          analogWrite(GREEN, greenOldValue);
          analogWrite(BLUE, blueOldValue);
          delay(10);
       }
      }
      zaehler++;    // zaehler zählt hoch, um ein Anbleiben der Lichter zu ermöglichen
  }
  // Merken der alten Farbwerte, für zukünftigen Vergleich:
  redOldValue = redValue;
  greenOldValue = greenValue;
  blueOldValue = blueValue;
  oldFarbwert = farbwert;
  }
  // Falls es zu hell ist, mache das folgende:
  else{
  Serial.println("Bright");
  if( zaehler <= zaehlerwert && zaehler != 0 )  // Zähler wird trotzdem hochgezählt, obwohl es hell wurde, damit das Licht anbleibt
    {
      zaehler++;
    }
  }
  temperaturSchleife++;           // Temperaturschleife zählt hoch, um den Abstand der Messungen festlegen zu können
  Serial.println("-------------------");
}