BabyFoodControl

// COPYRIGHT BY ORHAN AKGÜN
// HS-ESSLINGEN IOT PROJECT BABYFOODCONTROL
// DATE: 10. JANUAR 2025 

#include "Particle.h"
#include "sht3x-i2c.h"

// Initialisierung des SHT3x-Sensors (Standard I2C-Adresse: 0x44)
Sht3xi2c shtSensor(Wire, 0x44);

// Pin-Zuweisungen für LEDs und Taster
int led1 = D4; // Grüne LED
int led2 = D5; // Orange LED
int led3 = D6; // Rote LED
int button = D2; // Taster

// Variablen für Tasterzustände und Ablaufzeit
bool buttonState;                // Aktueller Zustand des Tasters
bool lastButtonState = HIGH;     // Letzter Zustand des Tasters
unsigned long startTime = 0;     // Startzeit für den Ablauf
unsigned long ablaufzeit = 1;    // Dynamische Ablaufzeit Startwert 1ms
unsigned long lastTempUpdate = 0; // Letzte Aktualisierung der Temperatur
bool programRunning = false;     // Status, ob das Programm läuft
unsigned long buttonCounter = 0; // Zähler, wenn der Button gedrückt gehalten wird
double constantAblaufzeit = 0;   // Ablaufzeit für konstante Temperatur (in ms)

// Temperaturbereich
double maxTemp = 25.0;   // Maximale Temperatur
double minTemp = 4.0;    // Minimale Temperatur
double realTemp = 15.0;  // Aktuelle Temperatur

// LED-Zustand als String
String ledStatus = "AUS"; // Standard: LEDs sind aus

// Blink-Variablen
unsigned long blinkInterval = 500; // Blinkintervall in Millisekunden
unsigned long lastBlinkTime = 0;   // Letzter Zeitpunkt für den Blinkstatus
bool blinkState = false;           // Aktueller Blinkstatus

void setup() {
    // Pin-Modi setzen
    pinMode(led1, OUTPUT); // LED1 (grün)
    pinMode(led2, OUTPUT); // LED2 (orange)
    pinMode(led3, OUTPUT); // LED3 (rot)
    pinMode(button, INPUT); // Taster

    // Initialisierung des SHT3x-Sensors
    shtSensor.begin();

    // Registrierung der Cloud-Variablen
    Particle.variable("realTemp", realTemp);  // Aktuelle Temperatur als Cloud-Variable
    Particle.variable("ablaufzeit", ablaufzeit); // Ablaufzeit als Cloud-Variable
    Particle.variable("ledStatus", ledStatus); // LED-Status als Cloud-Variable
    Particle.variable("constantAblaufzeit", constantAblaufzeit);
}

// Funktion zur Berechnung der Ablaufzeit basierend auf der Temperatur
double calculateAblaufzeit(double temp) {
    double hours = exp(-0.18 * temp); // H(T) in Stunden RICHTIGE FORMEL: double hours = 125.24 * exp(-0.1376 * temp)
    return hours * 60 * 60 * 1000;              // Umrechnung in Millisekunden
}

void loop() {
    // Temperatur regelmäßig abrufen und Ablaufzeit aktualisieren (alle 1000ms)
    if (millis() - lastTempUpdate >= 1000) {
        lastTempUpdate = millis();
        realTemp = getTemperature(); // Temperatur vom Sensor abrufen
        constantAblaufzeit = calculateAblaufzeit(realTemp); // Aktualisiere Ablaufzeit
    }

    // Tasterstatus auslesen
    buttonState = digitalRead(button);

    // Button gedrückt halten
    if (buttonState == LOW) { // Button wird gehalten
        if (buttonCounter == 0) { // Startzeit beim Drücken initialisieren
            buttonCounter = millis();
        }
        unsigned long elapsedTime = millis() - buttonCounter; // Berechne die Haltezeit

        // Dynamische Ablaufzeit anpassen
        if (ablaufzeit > 0) {
        double dynamicAblaufzeit = constantAblaufzeit - elapsedTime; 
        if (dynamicAblaufzeit <= 0) {
            dynamicAblaufzeit = 0; // Ablaufzeit kann nicht negativ werden
        }
        ablaufzeit = dynamicAblaufzeit; // Setze die dynamische Ablaufzeit
        }
    } else {
        buttonCounter = 0; // Zähler zurücksetzen, wenn der Button losgelassen wird
    }

    // Wenn der Taster gedrückt wird und das Programm nicht läuft
    if (buttonState == LOW && lastButtonState == HIGH && !programRunning) {
            startTime = millis();  // Startzeit setzen
            programRunning = true;  // Programm läuft
    }

    // Wenn der Taster losgelassen wird, alle LEDs ausschalten
    if (buttonState == HIGH && lastButtonState == LOW) {
        digitalWrite(led1, LOW);  // LED1 aus
        digitalWrite(led2, LOW);  // LED2 aus
        digitalWrite(led3, LOW);  // LED3 aus
        programRunning = false;   // Programm stoppen
        ledStatus = "AUS";        // LED-Status auf "AUS" setzen
        ablaufzeit = 1;           // Ablaufzeit auf 1ms setzen
    }

    // LED-Steuerung, wenn das Programm läuft
    if (programRunning) {
        unsigned long currentMillis = millis();
        unsigned long elapsedTime = currentMillis - startTime;
        unsigned long remainingTime = constantAblaufzeit - elapsedTime;

        // Blinkstatus aktualisieren
        if (currentMillis - lastBlinkTime >= blinkInterval) {
            lastBlinkTime = currentMillis;
            blinkState = !blinkState;
        }

        // LED-Logik mit Blinksteuerung
        if (remainingTime > constantAblaufzeit / 4) {
            controlLED(led1, blinkState);
            digitalWrite(led2, LOW);
            digitalWrite(led3, LOW);
            ledStatus = "GRÜN";
        } else if (remainingTime > 0) {
            digitalWrite(led1, LOW);
            controlLED(led2, blinkState);
            digitalWrite(led3, LOW);
            ledStatus = "ORANGE";
        } else {
            digitalWrite(led1, LOW);
            digitalWrite(led2, LOW);
            controlLED(led3, blinkState);
            ledStatus = "ROT";
            
        }
    }

    // Den letzten Tasterstatus für die nächste Iteration speichern
    lastButtonState = buttonState;
}

// Funktion zur Steuerung der LEDs basierend auf Temperatur und Blinkstatus
void controlLED(int ledPin, bool shouldBlink) {
    if (realTemp < minTemp || realTemp > maxTemp) {
        // Blinken, wenn die Temperatur außerhalb des Bereichs ist
        digitalWrite(ledPin, shouldBlink ? HIGH : LOW);
    } else {
        // Konstant leuchten, wenn die Temperatur im Bereich ist
        digitalWrite(ledPin, HIGH);
    }
}

// Funktion zum Abrufen der Temperatur vom SHT3x-Sensor
double getTemperature() {
    double temp, humid;
    int status = shtSensor.single_shot(&temp, &humid, SHT31_ACCURACY_HIGH);

    if (status == 0) {
        realTemp = round(temp * 10.0) / 10.0;  // Temperatur auf eine Dezimalstelle runden
        return realTemp;
    } else {
        return realTemp;  // Rückgabe des letzten bekannten Werts, falls ein Fehler auftritt
    }
}