Case Replay`after Start a Case

Projects General Guidance
1

As soon as I place the glass on the load cell, select the menu item and then start it, the case also starts. After that, the problem is that I cannot start a case again.


//------------------------------------------------------------------------------------------------------------------------------------
//Wichtig zu beachten ist das die Pumpen so verdrahtet wurden das LOW = Ein ist und HIGH = Aus ist------------------------------------
//------------------------------------------------------------------------------------------------------------------------------------
//Biblotheken die im Porgamm benutzt werden------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------------------------------------
#include "HX711.h"
//Benutzter Daten um Verbindung zur Blynk.Cloud herzustellen
#define BLYNK_PRINT Serial
#define BLYNK_TEMPLATE_ID ""
#define BLYNK_TEMPLATE_NAME ""
#define BLYNK_AUTH_TOKEN ""
#include <SPI.h>
#include <WiFiS3.h>
#include <BlynkSimpleWifi.h>
// Hier wird die Internet-Adresse eingetragen die der Arduino und Blynk benutzten
char ssid[] = "";
char pass[] = "";
//------------------------------------------------------------------------------------------------------------------------------------
// Pin-Konfiguration für alle Pumpen--------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------------------------------------
int pumpe1 = 9; //Rot (Orangensaft, Kokosmilch, Kokoswasser, Apfelsaft, Maracujasaft)
int pumpe2 = 8; //Blau (Cola, Bitter Lemon, Sprite, Fanta, Sprudel, Mineralwasser, Tonic)
int pumpe3 = 7; //Dunlelgrün (Limettensaft, Ananassaft, Cranberrysaft, Wassermelonensaft, Mangosaft, Traubensaft)
int pumpe4 = 6; //Rosa (Pfirsichlikör, Triple Sec, Kirschsaft, Grenadine)
int pumpe5 = 5; //Braun (Wodka, Malibu, Weißer Rum, Ficken)
int pumpe6 = 4; //Grün (Gin, Schokomilch, Rum)
int pumpe7 = 3; //Pink (Jack Daniels, Zitronensaft)
int pumpe8 = 2; // Lila (Tequila)

int LED1 = V1; // Virtueller Pin für LED 1 in der Blynk-App
int LED2 = V2; // Virtueller Pin für LED 2 in der Blynk-App
int LED3 = V3; // Virtueller Pin für LED 3 in der Blynk-App
int LED4 = V4; // Virtueller Pin für LED 4 in der Blynk-App
int LED5 = V5; // Virtueller Pin für LED 5 in der Blynk-App
int LED6 = V6; // Virtueller Pin für LED 6 in der Blynk-App
int LED7 = V7; // Virtueller Pin für LED 7 in der Blynk-App
int LED8 = V8; // Virtueller Pin für LED 8 in der Blynk-App
int LED_GlasBereit = V12; // Virtueller Pin für LED Glas Bereit in der Blynk-App
//------------------------------------------------------------------------------------------------------------------------------------
// Pin-Konfiguration für die Wägezelle------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------------------------------------
const int LOADCELL_DOUT_PIN = 13;
const int LOADCELL_SCK_PIN = 12;


float calibration_factor = 490; // Ermittelter Kalibrierungsfaktor hier einfügen

bool glass_placed = false;

const float threshold = 50; // Erhöhter Schwellenwert für die Glaserkennung
const float removal_threshold = -100.0; // Schwellenwert für die Entfernungserkennung
const float liquid_threshold = 1.0; // Schwellenwert für das Hinzufügen von Flüssigkeit
//------------------------------------------------------------------------------------------------------------------------------------
// Variablen zur Überwachung des Pumpen Status----------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------------------------------------
bool pumpenGestartet = false;
bool pumpe1Gestartet = false;
bool pumpe2Gestartet = false;
bool pumpe3Gestartet = false;
bool pumpe4Gestartet = false;
bool pumpe5Gestartet = false;
bool pumpe6Gestartet = false;
bool pumpe7Gestartet = false;
bool pumpe8Gestartet = false;
//------------------------------------------------------------------------------------------------------------------------------------
// Variablen zur Auswahl der Cocktails------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------------------------------------
bool ManuelleSteuerung = false;
bool ReinigungAusgewaehlt = false;
bool CubaLibreAusgewaehlt = false;
bool WodkaLemonAusgewaehlt = false;
bool WodkaSpriteAusgewaehlt = false;
bool MalibuOrangeAusgewaehlt = false;
bool RumPunchAusgewaehlt = false;
bool JackyColaAusgewaehlt = false;
bool GinTonicAusgewaehlt = false;
bool SexontheBeachAusgewaehlt = false;
bool PinaColadaAusgewaehlt = false;
bool TequilaSunriseAusgewaehlt = false;
bool WodkaCranberryAusgewaehlt = false;
bool MojitoAusgewaehlt = false;
bool LongIslandIcedTeaAusgewaehlt = false;
bool ScrewdriverAusgewaehlt = false;
bool JakababyYannickandSoerenAusgewaehlt = false;
bool LoversSunsetAusgewaehlt = false;
bool CocktailNojitoAusgewaehlt = false;
bool TropicalParadiseAusgewaehlt = false;
bool CocoLocoAusgewaehlt = false;
bool ColaSplashAusgewaehlt = false;
bool SparklingCitrusAusgewaehlt = false;
bool RefreshingWatermelonAusgewaehlt = false;
bool CoconutWaterRefresherAusgewaehlt = false;
bool CitrusMintCoolerAusgewaehlt = false;
bool VirginPinaColadaAusgewaehlt = false;
bool OrangeDreamMocktailAusgewaehlt = false;
bool cocktailZubereitet = false;
bool resetCompleted = false;

BlynkTimer timer;
HX711 scale;
//------------------------------------------------------------------------------------------------------------------------------------
// Blynk-Callback-Funktion zur Steuerung der Pumpen-----------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------------------------------------
// V10 = Startschalter für Cocktails, diese Funktion wird aufgerufen, wenn ein BLYNK_WRITE_Ergebnis für Pin 10 ausgelöst wird
BLYNK_WRITE(V10) {
  int state = param.asInt();                    // Die aktuelle Zustandsänderung des BLYNK-Pins V10 wird in die Variable "state" gespeichert
  if (state == HIGH) {                          // Überprüfung, ob der Zustand des Pins HIGH ist
    pumpenGestartet = false;                    // Wenn der Zustand HIGH ist, wird die Variable "pumpenGestartet" auf false gesetzt
  } else {
    pumpenGestartet = true;                     // Wenn der Zustand nicht HIGH ist (d.h. LOW oder ein anderer Wert), wird die Variable "pumpenGestartet" auf true gesetzt
  }
}
// V13 = Startschalter für Pumpe 1
BLYNK_WRITE(V13) {
  int state = param.asInt();
  if (state == HIGH && !pumpe1Gestartet) {      // Überprüfung, ob der Zustand des Pins HIGH ist und die Pumpe nicht bereits gestartet wurde   
    pumpe1Gestartet = true;
    digitalWrite(pumpe1, LOW);                  // Pumpe 1 Startet                   
  } else if (state == LOW && pumpe1Gestartet) { // Überprüfung, ob der Zustand des Pins LOW ist und die Pumpe bereits gestartet wurde
    pumpe1Gestartet = false;
    digitalWrite(pumpe1, HIGH);                 // Pumpe 1 Stoppt                   
  }
}
// V14 = Startschalter für Pumpe 2
BLYNK_WRITE(V14) {
  int state = param.asInt();
  if (state == HIGH && !pumpe2Gestartet) {      // Überprüfung, ob der Zustand des Pins HIGH ist und die Pumpe nicht bereits gestartet wurde 
    pumpe2Gestartet = true;
    digitalWrite(pumpe2, LOW);                  // Pumpe 2 Startet
  } else if (state == LOW && pumpe2Gestartet) { // Überprüfung, ob der Zustand des Pins LOW ist und die Pumpe bereits gestartet wurde
    pumpe2Gestartet = false;
    digitalWrite(pumpe2, HIGH);                 // Pumpe 2 Stoppt
  }
}
// V15 = Startschalter für Pumpe 3
BLYNK_WRITE(V15) {
  int state = param.asInt();
  if (state == HIGH && !pumpe3Gestartet) {      // Überprüfung, ob der Zustand des Pins HIGH ist und die Pumpe nicht bereits gestartet wurde 
    pumpe3Gestartet = true;
    digitalWrite(pumpe3, LOW);                  // Pumpe 3 Startet
  } else if (state == LOW && pumpe3Gestartet) { // Überprüfung, ob der Zustand des Pins LOW ist und die Pumpe bereits gestartet wurde
    pumpe3Gestartet = false;
    digitalWrite(pumpe3, HIGH);                 // Pumpe 3 Stoppt
  }
}
// V16 = Startschalter für Pumpe 4
BLYNK_WRITE(V16) {
  int state = param.asInt();
  if (state == HIGH && !pumpe4Gestartet) {      // Überprüfung, ob der Zustand des Pins HIGH ist und die Pumpe nicht bereits gestartet wurde 
    pumpe4Gestartet = true;
    digitalWrite(pumpe4, LOW);                  // Pumpe 4 Startet
  } else if (state == LOW && pumpe4Gestartet) { // Überprüfung, ob der Zustand des Pins LOW ist und die Pumpe bereits gestartet wurde
    pumpe4Gestartet = false;
    digitalWrite(pumpe4, HIGH);                 // Pumpe 4 Stoppt
  }
}
// V17 = Startschalter für Pumpe 6
BLYNK_WRITE(V17) {
  int state = param.asInt();
  if (state == HIGH && !pumpe5Gestartet) {      // Überprüfung, ob der Zustand des Pins HIGH ist und die Pumpe nicht bereits gestartet wurde 
    pumpe5Gestartet = true;
    digitalWrite(pumpe5, LOW);                  // Pumpe 5 Startet
  } else if (state == LOW && pumpe5Gestartet) { // Überprüfung, ob der Zustand des Pins LOW ist und die Pumpe bereits gestartet wurde
    pumpe5Gestartet = false;
    digitalWrite(pumpe5, HIGH);                 // Pumpe 5 Stoppt
  }
}
// V18 = Startschalter für Pumpe 6
BLYNK_WRITE(V18) {
  int state = param.asInt();
  if (state == HIGH && !pumpe6Gestartet) {      // Überprüfung, ob der Zustand des Pins HIGH ist und die Pumpe nicht bereits gestartet wurde 
    pumpe6Gestartet = true;
    digitalWrite(pumpe6, LOW);                  // Pumpe 6 Startet
  } else if (state == LOW && pumpe6Gestartet) { // Überprüfung, ob der Zustand des Pins LOW ist und die Pumpe bereits gestartet wurde
    pumpe6Gestartet = false;
    digitalWrite(pumpe6, HIGH);                 // Pumpe 6 Stoppt
  }
}
// V19 = Startschalter für Pumpe 7
BLYNK_WRITE(V19) {
  int state = param.asInt();
  if (state == HIGH && !pumpe7Gestartet) {      // Überprüfung, ob der Zustand des Pins HIGH ist und die Pumpe nicht bereits gestartet wurde 
    pumpe7Gestartet = true;
    digitalWrite(pumpe7, LOW);                  // Pumpe 7 Startet
  } else if (state == LOW && pumpe7Gestartet) { // Überprüfung, ob der Zustand des Pins LOW ist und die Pumpe bereits gestartet wurde
    pumpe7Gestartet = false;
    digitalWrite(pumpe7, HIGH);                 // Pumpe 7 Stoppt
  }
}
// V20 = Startschalter für Pumpe 8
BLYNK_WRITE(V20) {
  int state = param.asInt();
  if (state == HIGH && !pumpe8Gestartet) {      // Überprüfung, ob der Zustand des Pins HIGH ist und die Pumpe nicht bereits gestartet wurde 
    pumpe8Gestartet = true;
    digitalWrite(pumpe8, LOW);                  // Pumpe 8 Startet
  } else if (state == LOW && pumpe8Gestartet) { // Überprüfung, ob der Zustand des Pins LOW ist und die Pumpe bereits gestartet wurde
    pumpe8Gestartet = false;
    digitalWrite(pumpe8, HIGH);                 // Pumpe 8 Stoppt
  }
}

void resetCaseVariables() {
  // Setze alle Fallvariablen zurück
  ManuelleSteuerung = false;
  ReinigungAusgewaehlt = false;
  CubaLibreAusgewaehlt = false;
  WodkaLemonAusgewaehlt = false;
   WodkaSpriteAusgewaehlt = false;
 MalibuOrangeAusgewaehlt = false;
 RumPunchAusgewaehlt = false;
 JackyColaAusgewaehlt = false;
 GinTonicAusgewaehlt = false;
 SexontheBeachAusgewaehlt = false;
 PinaColadaAusgewaehlt = false;
 TequilaSunriseAusgewaehlt = false;
 WodkaCranberryAusgewaehlt = false;
 MojitoAusgewaehlt = false;
 LongIslandIcedTeaAusgewaehlt = false;
 ScrewdriverAusgewaehlt = false;
 JakababyYannickandSoerenAusgewaehlt = false;
 LoversSunsetAusgewaehlt = false;
 CocktailNojitoAusgewaehlt = false;
 TropicalParadiseAusgewaehlt = false;
 CocoLocoAusgewaehlt = false;
 ColaSplashAusgewaehlt = false;
 SparklingCitrusAusgewaehlt = false;
 RefreshingWatermelonAusgewaehlt = false;
 CoconutWaterRefresherAusgewaehlt = false;
 CitrusMintCoolerAusgewaehlt = false;
 VirginPinaColadaAusgewaehlt = false;
 OrangeDreamMocktailAusgewaehlt = false;

  // Aktiviere das Menü wieder
  Blynk.virtualWrite(V11, 0); // Setze das Menü auf den ersten Eintrag zurück

  // Setze die Variable für das Zurücksetzen abgeschlossen
  resetCompleted = true;
}

// V11 = Menü, wenn ein Menüpunkt ausgewählt wird die Variable auf True gesetzt
BLYNK_WRITE(V11) {
  int selectedMenuItem = param.asInt();
  if (selectedMenuItem == 0) {
    ManuelleSteuerung = true;
  } else if (selectedMenuItem == 1) { 
    ReinigungAusgewaehlt = true; 
  } else if (selectedMenuItem == 2) { 
    CubaLibreAusgewaehlt = true; 
  } else if (selectedMenuItem == 3) { 
    WodkaLemonAusgewaehlt = true; 
  } else if (selectedMenuItem == 4) {
    WodkaSpriteAusgewaehlt = true;
  } else if (selectedMenuItem == 5) {
    MalibuOrangeAusgewaehlt = true;
  } else if (selectedMenuItem == 6) {
    RumPunchAusgewaehlt = true;
  } else if (selectedMenuItem == 7) {
    JackyColaAusgewaehlt = true;
  } else if (selectedMenuItem == 8) {
    GinTonicAusgewaehlt = true;
  } else if (selectedMenuItem == 9) {
    SexontheBeachAusgewaehlt = true;
  } else if (selectedMenuItem == 10) {
    PinaColadaAusgewaehlt = true;
  } else if (selectedMenuItem == 11) {
    TequilaSunriseAusgewaehlt = true;
  } else if (selectedMenuItem == 12) {
    WodkaCranberryAusgewaehlt = true;
  } else if (selectedMenuItem == 13) {
    MojitoAusgewaehlt = true;
  } else if (selectedMenuItem == 14) {
    LongIslandIcedTeaAusgewaehlt = true;
  } else if (selectedMenuItem == 15) {
    ScrewdriverAusgewaehlt = true;
  } else if (selectedMenuItem == 16) {
    JakababyYannickandSoerenAusgewaehlt = true;
  } else if (selectedMenuItem == 17) {
    LoversSunsetAusgewaehlt = true;
  } else if (selectedMenuItem == 18) {
    CocktailNojitoAusgewaehlt = true;
  } else if (selectedMenuItem == 19) {
    TropicalParadiseAusgewaehlt = true;
  } else if (selectedMenuItem == 20) {
    CocoLocoAusgewaehlt = true;
  } else if (selectedMenuItem == 21) {
    ColaSplashAusgewaehlt = true;
  } else if (selectedMenuItem == 22) {
    SparklingCitrusAusgewaehlt = true;
  } else if (selectedMenuItem == 23) {
    RefreshingWatermelonAusgewaehlt = true;
  } else if (selectedMenuItem == 24) {
    CoconutWaterRefresherAusgewaehlt = true;
  } else if (selectedMenuItem == 25) {
    CitrusMintCoolerAusgewaehlt = true;
  } else if (selectedMenuItem == 26) {
    VirginPinaColadaAusgewaehlt = true;
  } else if (selectedMenuItem == 27) {
    OrangeDreamMocktailAusgewaehlt = true;
  } else {
  resetCaseVariables();
  }
}

void onCaseCompleted() {
  resetCaseVariables();
}

//------------------------------------------------------------------------------------------------------------------------------------
// void setup()-----------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------------------------------------

void setup() {
  Serial.begin(57600);
  scale.begin(LOADCELL_DOUT_PIN, LOADCELL_SCK_PIN);
  scale.set_scale(calibration_factor); // Setze den Kalibrierungsfaktor

  Serial.println("Wägezelle tarieren...");
  scale.tare(); // Tara ohne Glas

  Serial.println("Stelle das Glas auf die Wägezelle.");

  // Konfiguration der Pins für due Pumpen als Ausgänge
  pinMode(pumpe1, OUTPUT);
  pinMode(pumpe2, OUTPUT);
  pinMode(pumpe3, OUTPUT);
  pinMode(pumpe4, OUTPUT);
  pinMode(pumpe5, OUTPUT);
  pinMode(pumpe6, OUTPUT);
  pinMode(pumpe7, OUTPUT);
  pinMode(pumpe8, OUTPUT);

  // Alle Pumpen werden zu Beginn auf HIGH gesetzt, damit sie deaktiviert sind
  digitalWrite(pumpe1, HIGH);                   // Pumpe 1 Stoppt
  digitalWrite(pumpe2, HIGH);                   // Pumpe 2 Stoppt
  digitalWrite(pumpe3, HIGH);                   // Pumpe 3 Stoppt
  digitalWrite(pumpe4, HIGH);                   // Pumpe 4 Stoppt
  digitalWrite(pumpe5, HIGH);                   // Pumpe 5 Stoppt
  digitalWrite(pumpe6, HIGH);                   // Pumpe 6 Stoppt
  digitalWrite(pumpe7, HIGH);                   // Pumpe 7 Stoppt
  digitalWrite(pumpe8, HIGH);                   // Pumpe 8 Stoppt

  // Verbindung zum Blynk-Server mit den angegebenen Authentifizierungsdaten und WLAN-Zugangsdaten herstellen
  Blynk.begin(BLYNK_AUTH_TOKEN, ssid, pass);    
}


void loop()  {
  // Überwache den Status des Zurücksetzens
  if (resetCompleted) {
    // Das Zurücksetzen wurde abgeschlossen
     // Drucke eine Nachricht im Serial Monitor
    Serial.println("Zurücksetzen abgeschlossen!");
    resetCompleted = false; // Setze die Variable zurück, um erneut zu überwachen
  }



  Blynk.run(); // Blynk-Event-Handler
  timer.run(); // Blynk-Timer



  if (!pumpenGestartet) {
    stopAllPumps();
    return;
  }

 if (cocktailZubereitet) {
    stopAllPumps(); // Sicherstellen, dass alle Pumpen gestoppt sind
    return; // Beenden, wenn der Cocktail bereits zubereitet wurde
  }


  float weight = scale.get_units(10); // Durchschnitt aus 10 Messungen
  
  if (!glass_placed) {
    if (weight > threshold) { // Annahme: Glasgewicht ist größer als der Schwellenwert
      Serial.println("Glas erkannt. Nullsetze die Waage.");
      tareScale(); // Funktion zum Nullen der Waage aufrufen
      glass_placed = true;
      Serial.println("Glas nullgesetzt. Jetzt kann der Inhalt hinzugefügt werden.");
    }
  } else {
    if (weight < removal_threshold) { // Annahme: Glas wurde entfernt, wenn das Gewicht unter -100 g fällt
      Serial.println("Glas entfernt. Nullsetze die Waage.");
      tareScale(); // Funktion zum Nullen der Waage aufrufen
      glass_placed = false;
      Serial.println("Waage nullgesetzt. Stelle das Glas auf die Wägezelle."); // Aufforderung, ein neues Glas zu stellen
    } else {
      // Gewicht des hinzugefügten Inhalts messen
      Serial.print("Gewicht des Inhalts: ");
      Serial.print(weight);
      Serial.println(" g");

      // Ausgabe zur Überprüfung des Gewichtsanstiegs
      static float previous_weight = 0;
      if (weight > previous_weight + liquid_threshold) {
        Serial.println("Das Gewicht steigt.");
      } else if (weight < previous_weight - liquid_threshold) {
        Serial.println("Das Gewicht sinkt.");
      } else {
        Serial.println("Das Gewicht bleibt gleich.");
      }
      previous_weight = weight;
    }
  }

  delay(1000); // Messintervall von 1 Sekunde

// Hier werden die einzelenen cases aufgerufen um die Funktion auszuführen

// Case 0: Manuelle Steuerung





// Case 2: Cuba Libre
    if (CubaLibreAusgewaehlt) {
    case2_CubaLibre();
    }

}
void tareScale() {
  scale.tare(); // Nullt die Waage
}

void stopAllPumps() {
  digitalWrite(pumpe1, HIGH);
  digitalWrite(pumpe2, HIGH);
  digitalWrite(pumpe3, HIGH);
  digitalWrite(pumpe4, HIGH);
  digitalWrite(pumpe5, HIGH);
  digitalWrite(pumpe6, HIGH);
  digitalWrite(pumpe7, HIGH);
  digitalWrite(pumpe8, HIGH);
}




//------------------------------------------------------------------------------------------------------------------------------------
// Case 2: Cuba Libre
//------------------------------------------------------------------------------------------------------------------------------------
void case2_CubaLibre() {

  if (!CubaLibreAusgewaehlt || !pumpenGestartet) {
    // Wenn "Cuba Libre" nicht ausgewählt ist oder die Pumpen nicht gestartet sind, stoppe alle Pumpen
    digitalWrite(pumpe6, HIGH); // Stoppe Pumpe 6 (Rum)
    digitalWrite(pumpe2, HIGH); // Stoppe Pumpe 2 (Cola)
    digitalWrite(pumpe3, HIGH); // Stoppe Pumpe 3 (Limettensaft)
    return;
  }

  // Benutzte Pumpen für Cuba Libre
  // Pumpe 6: Rum
  // Pumpe 2: Cola
  // Pumpe 3: Limettensaft
  // 1ml = 1g (Nicht Alkoholisch), 1ml = 0,789 (0,8) (Alkoholisch)

  long TARGET_WEIGHT_PUMPE6 = 5; // Ursprüngliches Zielgewicht für Pumpe 6 in Millilitern
  long TARGET_WEIGHT_PUMPE2 = 5; // Ursprüngliches Zielgewicht für Pumpe 2 in Millilitern
  long TARGET_WEIGHT_PUMPE3 = 5; // Ursprüngliches Zielgewicht für Pumpe 3 in Millilitern

  tareScale();

  // Messung des aktuellen Gewichts
  float weight = scale.get_units(10); // Durchschnitt aus 10 Messungen
  Serial.print("Aktuelles Gewicht: ");
  Serial.print(weight);
  Serial.println(" g");

  // Wenn das Glas platziert und genullt wurde
  if (glass_placed) {
    // Starte die erste Pumpe (Rum), bis das Zielgewicht erreicht ist
    while (weight < TARGET_WEIGHT_PUMPE6 && pumpenGestartet && CubaLibreAusgewaehlt) {
      Serial.println("Starte Pumpe 6 (Rum)");
      digitalWrite(pumpe6, LOW); // Pumpe 6 starten (Rum)
      delay(100); // Kurze Verzögerung, um die Schleife zu verlangsamen
      weight = scale.get_units(10); // Gewicht erneut messen
      Serial.print("Gewicht: ");
      Serial.print(weight);
      Serial.println(" g");
    }
    Serial.println("Stoppe Pumpe 6 (Rum)");
    digitalWrite(pumpe6, HIGH); // Pumpe 6 stoppen

    // Wenn das Zielgewicht für Rum erreicht wurde, starte die nächste Pumpe (Cola)
    while (weight < TARGET_WEIGHT_PUMPE6 + TARGET_WEIGHT_PUMPE2 && pumpenGestartet && CubaLibreAusgewaehlt ) {
      Serial.println("Starte Pumpe 2 (Cola)");
      digitalWrite(pumpe2, LOW); // Pumpe 2 starten (Cola)
      delay(100); // Kurze Verzögerung, um die Schleife zu verlangsamen
      weight = scale.get_units(10); // Gewicht erneut messen
      Serial.print("Gewicht: ");
      Serial.print(weight);
      Serial.println(" g");
    }
    Serial.println("Stoppe Pumpe 2 (Cola)");
    digitalWrite(pumpe2, HIGH); // Pumpe 2 stoppen

    // Wenn das Zielgewicht für Cola erreicht wurde, starte die letzte Pumpe (Limettensaft)
    while (weight < TARGET_WEIGHT_PUMPE6 + TARGET_WEIGHT_PUMPE2 + TARGET_WEIGHT_PUMPE3 && pumpenGestartet && CubaLibreAusgewaehlt) {
      Serial.println("Starte Pumpe 3 (Limettensaft)");
      digitalWrite(pumpe3, LOW); // Pumpe 3 starten (Limettensaft)
      delay(100); // Kurze Verzögerung, um die Schleife zu verlangsamen
      weight = scale.get_units(10); // Gewicht erneut messen
      Serial.print("Gewicht: ");
      Serial.print(weight);
      Serial.println(" g");
    }
    Serial.println("Stoppe Pumpe 3 (Limettensaft)");
    digitalWrite(pumpe3, HIGH); // Pumpe 3 stoppen



    Serial.println("Cuba Libre fertig zubereitet. Stoppe alle Pumpen.");
  } else {
        Serial.println("Glas draufstellen bitte");
        digitalWrite(pumpe6, HIGH);               // Pumpe 6 Stoppt
        digitalWrite(pumpe2, HIGH);               // Pumpe 2 Stoppt
        digitalWrite(pumpe3, HIGH);               // Pumpe 3 Stoppt
        delay(1000);                              // Warte 1 Sekunde
    }

  // Markiere das Ende der Cocktailzubereitung
  cocktailZubereitet = true;
  CubaLibreAusgewaehlt = false; // Deaktiviere die Cuba Libre Auswahl

  // Rufe die Funktion auf, um alle Fallvariablen zurückzusetzen
  onCaseCompleted();

}

//------------------------------------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------------------------------------
// Case 3: Wodka Lemon
//------------------------------------------------------------------------------------------------------------------------------------
void case3_WodkaLemon() {

  if (!WodkaLemonAusgewaehlt || !pumpenGestartet) {
    // Wenn "Cuba Libre" nicht ausgewählt ist oder die Pumpen nicht gestartet sind, stoppe alle Pumpen
    digitalWrite(pumpe5, HIGH); // Stoppe Pumpe 5 (Wodka)
    digitalWrite(pumpe2, HIGH); // Stoppe Pumpe 2 (Bitter Lemon)

    return;
  }

  // Benutzte Pumpen für Cuba Libre
  // Pumpe 5: Wodka
  // Pumpe 2: Bitter Lemon
  // 1ml = 1g (Nicht Alkoholisch), 1ml = 0,789 (0,8) (Alkoholisch)

  long TARGET_WEIGHT_PUMPE5 = 20; // Ursprüngliches Zielgewicht für Pumpe 6 in Millilitern
  long TARGET_WEIGHT_PUMPE2 = 20; // Ursprüngliches Zielgewicht für Pumpe 2 in Millilitern
  

  tareScale();

  // Messung des aktuellen Gewichts
  float weight = scale.get_units(10); // Durchschnitt aus 10 Messungen
  Serial.print("Aktuelles Gewicht: ");
  Serial.print(weight);
  Serial.println(" g");

  // Wenn das Glas platziert und genullt wurde
  if (glass_placed) {
    // Starte die erste Pumpe (Rum), bis das Zielgewicht erreicht ist
    while (weight < TARGET_WEIGHT_PUMPE5 && pumpenGestartet && WodkaLemonAusgewaehlt) {
      Serial.println("Starte Pumpe 5 (Wodka)");
      digitalWrite(pumpe5, LOW); // Pumpe 6 starten (Rum)
      delay(100); // Kurze Verzögerung, um die Schleife zu verlangsamen
      weight = scale.get_units(10); // Gewicht erneut messen
      Serial.print("Gewicht: ");
      Serial.print(weight);
      Serial.println(" g");
    }
    Serial.println("Stoppe Pumpe 6 (Rum)");
    digitalWrite(pumpe5, HIGH); // Pumpe 6 stoppen

    // Wenn das Zielgewicht für Rum erreicht wurde, starte die nächste Pumpe (Cola)
    while (weight < TARGET_WEIGHT_PUMPE5 + TARGET_WEIGHT_PUMPE2 && pumpenGestartet && WodkaLemonAusgewaehlt ) {
      Serial.println("Starte Pumpe 2 (Cola)");
      digitalWrite(pumpe2, LOW); // Pumpe 2 starten (Cola)
      delay(100); // Kurze Verzögerung, um die Schleife zu verlangsamen
      weight = scale.get_units(10); // Gewicht erneut messen
      Serial.print("Gewicht: ");
      Serial.print(weight);
      Serial.println(" g");
    }
    Serial.println("Stoppe Pumpe 2 (Cola)");
    digitalWrite(pumpe2, HIGH); // Pumpe 2 stoppen


    // Markiere das Ende der Cocktailzubereitung
    cocktailZubereitet = true;
    CubaLibreAusgewaehlt = false; // Deaktiviere die Cuba Libre Auswahl

    Serial.println("Wodka Lemon fertig zubereitet. Stoppe alle Pumpen.");
  } else {
        Serial.println("Glas draufstellen bitte");
        digitalWrite(pumpe5, HIGH);               // Pumpe 6 Stoppt
        digitalWrite(pumpe2, HIGH);               // Pumpe 2 Stoppt
        delay(1000);                              // Warte 1 Sekunde
    }
}

//------------------------------------------------------------------------------------------------------------------------------------
````````
2

Imma fix myself a Wodka Lemon and look into this.

In the meantime, you have a serial monitor: an ideal place to see, from printing in your program, where in the sketch you are, and what the values of the variables that got you there might be.

In other words, put your finger on the code and trace the flow. Either by yourself, or let the sketch tell you as it goes where it is, and why.

Primitive, effective, easy and free diagnostics produced by the sketch itself.

a7

3

Hard coding the individual drinks and using number suffixes on things like the pumps are screaming out for the use of structs and arrays.

It should be possible to make the code much shorter by using such things to make the system data driven.

4

I am agree with @alto777 - the one who would try to figure out the code probably can do nothing without a good portion of whisky :slight_smile:

Your code is a good example of how not to write programs with a large number of actions.

Judging by the code, you wrote a part for one pump, and then copied all the variables and functions, blocks and conditions eight times. The result is what we see in the code - it is an absolute nightmare for debugging and simply finding errors.

Rewrite the code, place identical variables in an arrays and use functions with parameters so as not to write your own procedure for each variable.

2 Likes
5

This topic was automatically closed 180 days after the last reply. New replies are no longer allowed.