Code Optimization

sxren2001 · April 29, 2024, 12:45pm

-----German-----
Hallo, ich habe eine Frage,
Ich habe Projekt wobei ich die Blynk-App benutzte , anfangs hatte ich im Arduino Programm 1 oder 2 cases und 200 Zeilen. Dort ging die Ausführen direkt. Nun habe ich ca. 28 Cases und über 2000 Zeilen code nun dauert die ausführen so paar sekunden, ich denke mal das liegt an der größe. Kann man da irgendetwas machen damit die ausführungszeit wieder schneller ist ?. Ich benutzte ein Arduino UNO R4 WIFI

-----English------
Hello, I have a question.
I have a project where I use the Blynk app. Initially, I had 1 or 2 cases in the Arduino program and 200 lines of code. The execution was immediate. Now I have about 28 cases and over 2000 lines of code, and the execution takes a few seconds. I think this is due to the size. Is there anything I can do to make the execution time faster? I'm using an Arduino UNO R4 WIFI.

PaulRB · April 29, 2024, 12:47pm

Yes.

If you need more detail, give more detail.

sxren2001 · April 29, 2024, 2:59pm

You've got a cocktail machine where you select the desired drink from a menu and then start it with a button. For each drink, there's a case, and now you have 28 cases for 28 drinks, each of which needs to control a different pump. However, there's currently a delay of about 3-4 seconds before the pumps start.

paulpaulson · April 29, 2024, 3:13pm

Hello

Search for while()´s and hidden while()´s inside the delay() function.

sxren2001 · April 29, 2024, 3:30pm

Hier ist mal eine Beispiel Case

//------------------------------------------------------------------------------------------------------------------------------------
// Case 27: Orange Dream Cocktail
//------------------------------------------------------------------------------------------------------------------------------------
void case27_OrangeDreamMocktail() {
  // Benutzte Pumpen für den Orange Dream Mocktail
  // Pumpe 1: Orangensaft
  // Pumpe 7: Zitronensaft
  // Pumpe 2: Sprudel
  // Ausgangsgewicht 355-365, 1ml = 1g (Nicht Alkoholisch), 1ml = 0,789 (Alkoholisch)
  long TARGET_WEIGHT_PUMPE1 = 842 + 125; // 125ml Orangensaft = 125g
  long TARGET_WEIGHT_PUMPE7 = 842 + 50;  // 50ml Zitronensaft = 50g
  long TARGET_WEIGHT_PUMPE2 = 842 + 125; // 125ml Sprudel = 125g

  if (scale.is_ready()) {
    long reading = (scale.read() * 0.01) - 842;
    Serial.print("HX711 reading: ");
    Serial.println(reading);

    // Wenn das Gewicht innerhalb der Toleranz liegt
    if (reading >= LOWER_TOLERANCE && reading <= UPPER_TOLERANCE && pumpenGestartet && OrangeDreamMocktailAusgewaehlt) {
      Serial.println("Correct weight range reached");

      // Pumpe 1: Orangensaft
      while (reading < TARGET_WEIGHT_PUMPE1 && pumpenGestartet && OrangeDreamMocktailAusgewaehlt) {
        digitalWrite(pumpe1, LOW);
        delay(1000);
        reading = (scale.read() * 0.01) - 842;
      }
      digitalWrite(pumpe1, HIGH);
      Serial.println("Target weight for pump 1 reached. Pump 1 stopped.");

      delay(2000);

      // Pumpe 7: Zitronensaft
      while (reading < TARGET_WEIGHT_PUMPE7 && pumpenGestartet && OrangeDreamMocktailAusgewaehlt) {
        digitalWrite(pumpe7, LOW);
        delay(1000);
        reading = (scale.read() * 0.01) - 842;
      }
      digitalWrite(pumpe7, HIGH);
      Serial.println("Target weight for pump 7 reached. Pump 7 stopped.");

      delay(2000);

      // Pumpe 2: Sprudel
      while (reading < TARGET_WEIGHT_PUMPE2 && pumpenGestartet && OrangeDreamMocktailAusgewaehlt) {
        digitalWrite(pumpe2, LOW);
        delay(1000);
        reading = (scale.read() * 0.01) - 842;
      }
      digitalWrite(pumpe2, HIGH);
      Serial.println("Target weight for pump 2 reached. Pump 2 stopped.");
    } else {
      Serial.println("Weight outside correct range. Pump stopped.");
      digitalWrite(pumpe1, HIGH);
      digitalWrite(pumpe7, HIGH);
      digitalWrite(pumpe2, HIGH);

      delay(1000);
    }
  } else {
    Serial.println("HX711 not found.");
    digitalWrite(pumpe1, HIGH);
    digitalWrite(pumpe7, HIGH);
    digitalWrite(pumpe2, HIGH);

    delay(1000);
  }
}
//------------------------------------------------------------------------------------------------------------------------------------
````

PaulRB · April 29, 2024, 4:38pm

I don't think the problem is in the part of the code you shared.

Remove half of the cases. Does the unwanted delay still occur? If so, remove half of the remaining cases and repeat until the unwanted delay disappears or there are only a few cases left. Post the shortest code where the unwanted delay happens.

Don't forget to take a backup copy of your full code before you begin removing cases! You can go back to that backup version once we have identified the cause of the unwanted delay.

Rintin · April 29, 2024, 5:09pm

sxren2001:

  long TARGET_WEIGHT_PUMPE1 = 842 + 125; // 125ml Orangensaft = 125g
  long TARGET_WEIGHT_PUMPE7 = 842 + 50;  // 50ml Zitronensaft = 50g
  long TARGET_WEIGHT_PUMPE2 = 842 + 125; // 125ml Sprudel = 125g

I think this needs a bit more explanation...

When pumpenGestartet or OrangeDreamMocktailAusgewaehlt are false the else path is taken which contains a delay...
How are these variables set?

How is case27_OrangeDreamMocktail() called?

sxren2001 · April 29, 2024, 6:15pm

This is the program where I say the time until the start is okay, I left out the libraries at the top because there are still private things there, the HX711 and Blynk.

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)

// Pin-Konfiguration für die Wägezelle
int LOADCELL_DOUT_PIN = 13;
int LOADCELL_SCK_PIN = 12;

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;

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;

BlynkTimer timer;
HX711 scale;

BLYNK_WRITE(V10) {
  int state = param.asInt();
  if (state == HIGH) {
    pumpenGestartet = false;
  } else {
    pumpenGestartet = true;
  }
}
BLYNK_WRITE(V13) {
  int state = param.asInt();
  if (state == HIGH && !pumpe1Gestartet) { // Starte die Pumpe nur, wenn sie nicht bereits läuft
    pumpe1Gestartet = true;
    digitalWrite(pumpe1, LOW);
  } else if (state == LOW && pumpe1Gestartet) { // Stoppe die Pumpe nur, wenn sie bereits läuft
    pumpe1Gestartet = false;
    digitalWrite(pumpe1, HIGH);
  }
}
BLYNK_WRITE(V14) {
  int state = param.asInt();
  if (state == HIGH && !pumpe2Gestartet) {
    pumpe2Gestartet = true;
    digitalWrite(pumpe2, LOW);
  } else if (state == LOW && pumpe2Gestartet) {
    pumpe2Gestartet = false;
    digitalWrite(pumpe2, HIGH);
  }
}
BLYNK_WRITE(V15) {
  int state = param.asInt();
  if (state == HIGH && !pumpe3Gestartet) {
    pumpe3Gestartet = true;
    digitalWrite(pumpe3, LOW);
  } else if (state == LOW && pumpe3Gestartet) {
    pumpe3Gestartet = false;
    digitalWrite(pumpe3, HIGH);
  }
}
BLYNK_WRITE(V16) {
  int state = param.asInt();
  if (state == HIGH && !pumpe4Gestartet) {
    pumpe4Gestartet = true;
    digitalWrite(pumpe4, LOW);
  } else if (state == LOW && pumpe4Gestartet) {
    pumpe4Gestartet = false;
    digitalWrite(pumpe4, HIGH);
  }
}
BLYNK_WRITE(V17) {
  int state = param.asInt();
  if (state == HIGH && !pumpe5Gestartet) {
    pumpe5Gestartet = true;
    digitalWrite(pumpe5, LOW);
  } else if (state == LOW && pumpe5Gestartet) {
    pumpe5Gestartet = false;
    digitalWrite(pumpe5, HIGH);
  }
}
BLYNK_WRITE(V18) {
  int state = param.asInt();
  if (state == HIGH && !pumpe6Gestartet) {
    pumpe6Gestartet = true;
    digitalWrite(pumpe6, LOW);
  } else if (state == LOW && pumpe6Gestartet) {
    pumpe6Gestartet = false;
    digitalWrite(pumpe6, HIGH);
  }
}
BLYNK_WRITE(V19) {
  int state = param.asInt();
  if (state == HIGH && !pumpe7Gestartet) {
    pumpe7Gestartet = true;
    digitalWrite(pumpe7, LOW);
  } else if (state == LOW && pumpe7Gestartet) {
    pumpe7Gestartet = false;
    digitalWrite(pumpe7, HIGH);
  }
}
BLYNK_WRITE(V20) {
  int state = param.asInt();
  if (state == HIGH && !pumpe8Gestartet) {
    pumpe8Gestartet = true;
    digitalWrite(pumpe8, LOW);
  } else if (state == LOW && pumpe8Gestartet) {
    pumpe8Gestartet = false;
    digitalWrite(pumpe8, HIGH);
  }
}


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 {
    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;
  }
}

void setup() {
  Serial.begin(57600);
  scale.begin(LOADCELL_DOUT_PIN, LOADCELL_SCK_PIN);
  pinMode(pumpe1, OUTPUT);
  pinMode(pumpe2, OUTPUT);
  pinMode(pumpe3, OUTPUT);
  pinMode(pumpe4, OUTPUT);
  pinMode(pumpe5, OUTPUT);
  pinMode(pumpe6, OUTPUT);
  pinMode(pumpe7, OUTPUT);
  pinMode(pumpe8, OUTPUT);
  digitalWrite(pumpe1, HIGH);
  digitalWrite(pumpe2, HIGH);
  digitalWrite(pumpe3, HIGH);
  digitalWrite(pumpe4, HIGH);
  digitalWrite(pumpe5, HIGH);
  digitalWrite(pumpe6, HIGH);
  digitalWrite(pumpe7, HIGH);
  digitalWrite(pumpe8, HIGH);

  Blynk.begin(BLYNK_AUTH_TOKEN, ssid, pass);
}

void loop() {
  Blynk.run();

// Case 0: Manuelle Steuerung
  case0_ManuelleSteuerung();

// Case 1: Reinigung
  case1_Reinigungsprogramm();
 
// Case 2: Cuba Libre
  case2_CubaLibre();

// Case 3: Wodka Lemon
  case3_WodkaLemon();

// Case 4: Wodka Sprite
  case4_WodkaSprite();

// Case 5: Malibu Orange
  case5_MalibuOrange();

// Case 6: Rum Punch
  case6_RumPunch();

// Case 7: Jacky Cola
  case7_JackyCola();



 
}


// Untere und obere Grenze für die Toleranz
long LOWER_TOLERANCE = 1195 - 842; // Unterer Toleranzwert unter Berücksichtigung der Kalibrierung //355
long UPPER_TOLERANCE = 1205 - 842; // Oberer Toleranzwert unter Berücksichtigung der Kalibrierung // 365
//------------------------------------------------------------------------------------------------------------------------------------
// Case 0: Manuelle Steuerung
//------------------------------------------------------------------------------------------------------------------------------------
void case0_ManuelleSteuerung() {

  if (pumpe1Gestartet && ManuelleSteuerung ){
    Serial.println("Pumpe 1 läuft");
    digitalWrite(pumpe1,LOW);
  }

   if (pumpe2Gestartet && ManuelleSteuerung ){
    Serial.println("Pumpe 2 läuft");
    digitalWrite(pumpe2,LOW);
  }

   if (pumpe3Gestartet && ManuelleSteuerung ){
    Serial.println("Pumpe 3 läuft");
    digitalWrite(pumpe3,LOW);
  }

   if (pumpe4Gestartet && ManuelleSteuerung ){
    Serial.println("Pumpe 4 läuft");
    digitalWrite(pumpe4,LOW);
  }

   if (pumpe5Gestartet && ManuelleSteuerung ){
    Serial.println("Pumpe 5 läuft");
    digitalWrite(pumpe5,LOW);
  }

   if (pumpe6Gestartet && ManuelleSteuerung ){
    Serial.println("Pumpe 6 läuft");
    digitalWrite(pumpe6,LOW);
  }

   if (pumpe7Gestartet && ManuelleSteuerung ){
    Serial.println("Pumpe 7 läuft");
    digitalWrite(pumpe7,LOW);
  }

   if (pumpe8Gestartet && ManuelleSteuerung ){
    Serial.println("Pumpe 8 läuft");
    digitalWrite(pumpe8,LOW);
  }
}

//------------------------------------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------------------------------------
// Case 1: Reinigungsprogramm
//------------------------------------------------------------------------------------------------------------------------------------
void case1_Reinigungsprogramm() {
  //Benutzte Pumpen für Reinigungsprogramm
  //Pumpe 1-8: Wasser
  // Setze das Zielgewicht für das Reinigungsprogramm
  long TARGET_WEIGHT_ALL_PUMPS = 645; 
  
  // Überprüfe, ob die Waage betriebsbereit ist
  if (scale.is_ready()) {
    long reading = (scale.read() * 0.01) - 842;
    Serial.print("HX711 reading: ");
    Serial.println(reading);

   if (reading >= LOWER_TOLERANCE && reading <= UPPER_TOLERANCE && pumpenGestartet && ReinigungAusgewaehlt) {
      Serial.println("Correct weight range reached");
    
    // Schleife, die die Pumpen steuert, bis das Zielgewicht erreicht ist
    while (reading < TARGET_WEIGHT_ALL_PUMPS && pumpenGestartet && ReinigungAusgewaehlt) {
      // Aktiviere alle Pumpen gleichzeitig
      digitalWrite(pumpe1, LOW);
      digitalWrite(pumpe2, LOW);
      digitalWrite(pumpe3, LOW);
      digitalWrite(pumpe4, LOW);
      digitalWrite(pumpe5, LOW);
      digitalWrite(pumpe6, LOW);
      digitalWrite(pumpe7, LOW);
      digitalWrite(pumpe8, LOW);
      
      // Füge hier eine kurze Verzögerung ein, bevor das Gewicht erneut überprüft wird
      delay(1000);
      reading = (scale.read() * 0.01) - 842; // Beispiel: 1 Sekunde
    }
    
    // Deaktiviere alle Pumpen, wenn das Zielgewicht erreicht ist
    digitalWrite(pumpe1, HIGH);
    digitalWrite(pumpe2, HIGH);
    digitalWrite(pumpe3, HIGH);
    digitalWrite(pumpe4, HIGH);
    digitalWrite(pumpe5, HIGH);
    digitalWrite(pumpe6, HIGH);
    digitalWrite(pumpe7, HIGH);
    digitalWrite(pumpe8, HIGH);
  }
 else {
      Serial.println("Weight outside correct range. Pump stopped.");
    digitalWrite(pumpe1, HIGH);
    digitalWrite(pumpe2, HIGH);
    digitalWrite(pumpe3, HIGH);
    digitalWrite(pumpe4, HIGH);
    digitalWrite(pumpe5, HIGH);
    digitalWrite(pumpe6, HIGH);
    digitalWrite(pumpe7, HIGH);
    digitalWrite(pumpe8, HIGH);
      delay(1000);
    }
   } else {
    Serial.println("HX711 not found.");
    digitalWrite(pumpe1, HIGH);
    digitalWrite(pumpe2, HIGH);
    digitalWrite(pumpe3, HIGH);
    digitalWrite(pumpe4, HIGH);
    digitalWrite(pumpe5, HIGH);
    digitalWrite(pumpe6, HIGH);
    digitalWrite(pumpe7, HIGH);
    digitalWrite(pumpe8, HIGH);
    delay(1000);
  }
}
//------------------------------------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------------------------------------
// Case 2: Cuba Libre
//------------------------------------------------------------------------------------------------------------------------------------
void case2_CubaLibre() {
  //Benutzte Pumpen für Cuba Libre
  //Pumpe 6: Rum
  //Pumpe 2: Cola
  //Pumpe 3: Limettensaft
  //Ausgangsgewicht 355-365, 1ml = 1g (Nicht Alkolisch), 1ml = 0,789 (0,8) (Alkolisch)
  long TARGET_WEIGHT_PUMPE6 = 395; // 50ml Rum= 40g
  long TARGET_WEIGHT_PUMPE2 = 620; // 225ml Cola = 225g
  long TARGET_WEIGHT_PUMPE3 = 635; // 15ml Limettensaft = 15g

  if (scale.is_ready()) {
    long reading = (scale.read() * 0.01) - 842;
    Serial.print("HX711 reading: ");
    Serial.println(reading);

    // Wenn das Gewicht innerhalb der Toleranz liegt
    if (reading >= LOWER_TOLERANCE && reading <= UPPER_TOLERANCE && pumpenGestartet && CubaLibreAusgewaehlt) {
      Serial.println("Correct weight range reached");

      // Pumpe 6
      while (reading < TARGET_WEIGHT_PUMPE6 && pumpenGestartet && CubaLibreAusgewaehlt) {
        digitalWrite(pumpe6, LOW);
        delay(1000);
        reading = (scale.read() * 0.01) - 842;
      }
      digitalWrite(pumpe6, HIGH);
      Serial.println("Target weight for pump 6 reached. Pump 6 stopped.");

      delay(2000);

      // Pumpe 2
      while (reading < TARGET_WEIGHT_PUMPE2 && pumpenGestartet && CubaLibreAusgewaehlt) {
        digitalWrite(pumpe2, LOW);
        delay(1000);
        reading = (scale.read() * 0.01) - 842;
      }
      digitalWrite(pumpe2, HIGH);
      Serial.println("Target weight for pump 2 reached. Pump 2 stopped.");

      delay(2000);

      // Pumpe 3
      while (reading < TARGET_WEIGHT_PUMPE3 && pumpenGestartet && CubaLibreAusgewaehlt) {
        digitalWrite(pumpe3, LOW);
        delay(1000);
        reading = (scale.read() * 0.01) - 842;
      }
      digitalWrite(pumpe3, HIGH);
      Serial.println("Target weight for pump 3 reached. Pump 3 stopped.");

    } else {
      Serial.println("Weight outside correct range. Pump stopped.");
      digitalWrite(pumpe6, HIGH);
      digitalWrite(pumpe2, HIGH);
      digitalWrite(pumpe3, HIGH);
      delay(1000);
    }
  } else {
    Serial.println("HX711 not found.");
    digitalWrite(pumpe6, HIGH);
    digitalWrite(pumpe2, HIGH);
    digitalWrite(pumpe3, HIGH);
    delay(1000);
  }
}
//------------------------------------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------------------------------------
// Case 3: Wodka Lemon
//------------------------------------------------------------------------------------------------------------------------------------
void case3_WodkaLemon() {
  //Benutzte Pumpen für Wodka Lemon
  //Pumpe 5: Wodka
  //Pumpe 2: Bitter Lemon
  //Ausgangsgewicht 355-365, 1ml = 1g (Nicht Alkolisch), 1ml = 0,789 (0,8) (Alkolisch)
  long TARGET_WEIGHT_PUMPE5 = 395; // 50ml Wodka = 40g
  long TARGET_WEIGHT_PUMPE2 = 645; // 250ml Bitter Lemon = 250g
 

  if (scale.is_ready()) {
    long reading = (scale.read() * 0.01) - 842;
    Serial.print("HX711 reading: ");
    Serial.println(reading);

    // Wenn das Gewicht innerhalb der Toleranz liegt
    if (reading >= LOWER_TOLERANCE && reading <= UPPER_TOLERANCE && pumpenGestartet && WodkaLemonAusgewaehlt) {
      Serial.println("Correct weight range reached");

      // Pumpe 5
      while (reading < TARGET_WEIGHT_PUMPE5 && pumpenGestartet && WodkaLemonAusgewaehlt) {
        digitalWrite(pumpe5, LOW);
        delay(1000);
        reading = (scale.read() * 0.01) - 842;
      }
      digitalWrite(pumpe5, HIGH);
      Serial.println("Target weight for pump 5 reached. Pump 5 stopped.");

      delay(2000);

      // Pumpe 2
      while (reading < TARGET_WEIGHT_PUMPE2 && pumpenGestartet && WodkaLemonAusgewaehlt) {
        digitalWrite(pumpe2, LOW);
        delay(1000);
        reading = (scale.read() * 0.01) - 842;
      }
      digitalWrite(pumpe2, HIGH);
      Serial.println("Target weight for pump 2 reached. Pump 2 stopped.");

    } else {
      Serial.println("Weight outside correct range. Pump stopped.");
      digitalWrite(pumpe5, HIGH);
      digitalWrite(pumpe2, HIGH);
     
      delay(1000);
    }
  } else {
    Serial.println("HX711 not found.");
    digitalWrite(pumpe5, HIGH);
    digitalWrite(pumpe2, HIGH);
    
    delay(1000);
  }
}
//------------------------------------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------------------------------------
// Case 4: Wodka Sprite
//------------------------------------------------------------------------------------------------------------------------------------
void case4_WodkaSprite() {
  //Benutzte Pumpen für Wodka Sprite
  //Pumpe 5: Wodka
  //Pumpe 2: Sprite
  //Ausgangsgewicht 355-365, 1ml = 1g (Nicht Alkolisch), 1ml = 0,789 (0,8) (Alkolisch)
  long TARGET_WEIGHT_PUMPE5 = 395; // 50ml Wodka = 40g
  long TARGET_WEIGHT_PUMPE2 = 645; // 250ml Sprite = 250g
 

  if (scale.is_ready()) {
    long reading = (scale.read() * 0.01) - 842;
    Serial.print("HX711 reading: ");
    Serial.println(reading);

    // Wenn das Gewicht innerhalb der Toleranz liegt
    if (reading >= LOWER_TOLERANCE && reading <= UPPER_TOLERANCE && pumpenGestartet && WodkaSpriteAusgewaehlt) {
      Serial.println("Correct weight range reached");

      // Pumpe 5
      while (reading < TARGET_WEIGHT_PUMPE5 && pumpenGestartet && WodkaSpriteAusgewaehlt) {
        digitalWrite(pumpe5, LOW);
        delay(1000);
        reading = (scale.read() * 0.01) - 842;
      }
      digitalWrite(pumpe5, HIGH);
      Serial.println("Target weight for pump 5 reached. Pump 5 stopped.");

      delay(2000);

      // Pumpe 2
      while (reading < TARGET_WEIGHT_PUMPE2 && pumpenGestartet && WodkaSpriteAusgewaehlt) {
        digitalWrite(pumpe2, LOW);
        delay(1000);
        reading = (scale.read() * 0.01) - 842;
      }
      digitalWrite(pumpe2, HIGH);
      Serial.println("Target weight for pump 2 reached. Pump 2 stopped.");

    } else {
      Serial.println("Weight outside correct range. Pump stopped.");
      digitalWrite(pumpe5, HIGH);
      digitalWrite(pumpe2, HIGH);
     
      delay(1000);
    }
  } else {
    Serial.println("HX711 not found.");
    digitalWrite(pumpe5, HIGH);
    digitalWrite(pumpe2, HIGH);
    
    delay(1000);
  }
}
//------------------------------------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------------------------------------
// Case 5: Malibu Orange
//------------------------------------------------------------------------------------------------------------------------------------
void case5_MalibuOrange() {
  //Benutzte Pumpen für Malibu Orange
  //Pumpe 5: Malibu
  //Pumpe 1: Orangensaft
  //Ausgangsgewicht 355-365, 1ml = 1g (Nicht Alkolisch), 1ml = 0,789 (0,8) (Alkolisch)
  long TARGET_WEIGHT_PUMPE5 = 395; // 50ml Malibu = 40g
  long TARGET_WEIGHT_PUMPE1 = 645; // 250ml Orangensaft = 250g
 

  if (scale.is_ready()) {
    long reading = (scale.read() * 0.01) - 842;
    Serial.print("HX711 reading: ");
    Serial.println(reading);

    // Wenn das Gewicht innerhalb der Toleranz liegt
    if (reading >= LOWER_TOLERANCE && reading <= UPPER_TOLERANCE && pumpenGestartet && MalibuOrangeAusgewaehlt) {
      Serial.println("Correct weight range reached");

      // Pumpe 5
      while (reading < TARGET_WEIGHT_PUMPE5 && pumpenGestartet && MalibuOrangeAusgewaehlt) {
        digitalWrite(pumpe5, LOW);
        delay(1000);
        reading = (scale.read() * 0.01) - 842;
      }
      digitalWrite(pumpe5, HIGH);
      Serial.println("Target weight for pump 5 reached. Pump 5 stopped.");

      delay(2000);

      // Pumpe 2
      while (reading < TARGET_WEIGHT_PUMPE1 && pumpenGestartet && MalibuOrangeAusgewaehlt) {
        digitalWrite(pumpe1, LOW);
        delay(1000);
        reading = (scale.read() * 0.01) - 842;
      }
      digitalWrite(pumpe1, HIGH);
      Serial.println("Target weight for pump 2 reached. Pump 2 stopped.");

    } else {
      Serial.println("Weight outside correct range. Pump stopped.");
      digitalWrite(pumpe5, HIGH);
      digitalWrite(pumpe1, HIGH);
     
      delay(1000);
    }
  } else {
    Serial.println("HX711 not found.");
    digitalWrite(pumpe5, HIGH);
    digitalWrite(pumpe1, HIGH);
    
    delay(1000);
  }
}
//------------------------------------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------------------------------------
// Case 6: Rum Punch
//------------------------------------------------------------------------------------------------------------------------------------
void case6_RumPunch() {
  //Benutzte Pumpen Rum Punch
  //Pumpe 6: Rum
  //Pumpe 3: Ananassaft
  //Pumpe 1: Orangensaft
  //Pumpe 7: Zitronensaft
  //Ausgangsgewicht 355-365, 1ml = 1g (Nicht Alkolisch), 1ml = 0,789 (0,8) (Alkolisch)
  long TARGET_WEIGHT_PUMPE6 = 399; // 55ml Rum = 44g
  long TARGET_WEIGHT_PUMPE3 = 509; // 110ml Ananassaft = 110g
  long TARGET_WEIGHT_PUMPE1 = 619; // 110ml Orangensaft = 110g
  long TARGET_WEIGHT_PUMPE7 = 644; // 25ml Zitronensaft = 25g
 

  if (scale.is_ready()) {
    long reading = (scale.read() * 0.01) - 842;
    Serial.print("HX711 reading: ");
    Serial.println(reading);

    // Wenn das Gewicht innerhalb der Toleranz liegt
    if (reading >= LOWER_TOLERANCE && reading <= UPPER_TOLERANCE && pumpenGestartet && RumPunchAusgewaehlt) {
      Serial.println("Correct weight range reached");

      // Pumpe 6
      while (reading < TARGET_WEIGHT_PUMPE6 && pumpenGestartet && RumPunchAusgewaehlt) {
        digitalWrite(pumpe6, LOW);
        delay(1000);
        reading = (scale.read() * 0.01) - 842;
      }
      digitalWrite(pumpe6, HIGH);
      Serial.println("Target weight for pump 6 reached. Pump 6 stopped.");

      delay(2000);

      // Pumpe 3
      while (reading < TARGET_WEIGHT_PUMPE3 && pumpenGestartet && RumPunchAusgewaehlt) {
        digitalWrite(pumpe3, LOW);
        delay(1000);
        reading = (scale.read() * 0.01) - 842;
      }
      digitalWrite(pumpe3, HIGH);
      Serial.println("Target weight for pump 3 reached. Pump 3 stopped.");

      delay(2000);

      // Pumpe 1
      while (reading < TARGET_WEIGHT_PUMPE1 && pumpenGestartet && RumPunchAusgewaehlt) {
        digitalWrite(pumpe1, LOW);
        delay(1000);
        reading = (scale.read() * 0.01) - 842;
      }
      digitalWrite(pumpe1, HIGH);
      Serial.println("Target weight for pump 1 reached. Pump 1 stopped.");

      // Pumpe 7
      while (reading < TARGET_WEIGHT_PUMPE7 && pumpenGestartet && RumPunchAusgewaehlt) {
        digitalWrite(pumpe7, LOW);
        delay(1000);
        reading = (scale.read() * 0.01) - 842;
      }
      digitalWrite(pumpe7, HIGH);
      Serial.println("Target weight for pump 7 reached. Pump 7 stopped.");

    } else {
      Serial.println("Weight outside correct range. Pump stopped.");
      digitalWrite(pumpe6, HIGH);
      digitalWrite(pumpe3, HIGH);
      digitalWrite(pumpe1, HIGH);
      digitalWrite(pumpe7, HIGH);
     
      delay(1000);
    }
  } else {
    Serial.println("HX711 not found.");
      digitalWrite(pumpe6, HIGH);
      digitalWrite(pumpe3, HIGH);
      digitalWrite(pumpe1, HIGH);
      digitalWrite(pumpe7, HIGH);
    
    delay(1000);
  }
}
//------------------------------------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------------------------------------
// Case 7: JackyCola
//------------------------------------------------------------------------------------------------------------------------------------
void case7_JackyCola() {
  //Benutzte Pumpen für JackyCola
  //Pumpe 7: Jack Daniels
  //Pumpe 2: Cola
  //Ausgangsgewicht 355-365, 1ml = 1g (Nicht Alkolisch), 1ml = 0,789 (0,8) (Alkolisch)
  long TARGET_WEIGHT_PUMPE7 = 395; // 50ml Jack Daniels = 40g
  long TARGET_WEIGHT_PUMPE2 = 645; // 250ml Cola = 250g
 

  if (scale.is_ready()) {
    long reading = (scale.read() * 0.01) - 842;
    Serial.print("HX711 reading: ");
    Serial.println(reading);

    // Wenn das Gewicht innerhalb der Toleranz liegt
    if (reading >= LOWER_TOLERANCE && reading <= UPPER_TOLERANCE && pumpenGestartet && JackyColaAusgewaehlt) {
      Serial.println("Correct weight range reached");

      // Pumpe 7
      while (reading < TARGET_WEIGHT_PUMPE7 && pumpenGestartet && JackyColaAusgewaehlt) {
        digitalWrite(pumpe7, LOW);
        delay(1000);
        reading = (scale.read() * 0.01) - 842;
      }
      digitalWrite(pumpe7, HIGH);
      Serial.println("Target weight for pump 7 reached. Pump 7 stopped.");

      delay(2000);

      // Pumpe 2
      while (reading < TARGET_WEIGHT_PUMPE2 && pumpenGestartet && JackyColaAusgewaehlt) {
        digitalWrite(pumpe2, LOW);
        delay(1000);
        reading = (scale.read() * 0.01) - 842;
      }
      digitalWrite(pumpe2, HIGH);
      Serial.println("Target weight for pump 2 reached. Pump 2 stopped.");

    } else {
      Serial.println("Weight outside correct range. Pump stopped.");
      digitalWrite(pumpe7, HIGH);
      digitalWrite(pumpe2, HIGH);
     
      delay(1000);
    }
  } else {
    Serial.println("HX711 not found.");
    digitalWrite(pumpe7, HIGH);
    digitalWrite(pumpe2, HIGH);
    
    delay(1000);
  }
}

PaulRB · April 29, 2024, 6:17pm

You wrote these libraries? We need to see those also, they are part of your code.

Unless you mean there are WiFi passwords and Blynk application keys? Just redact those!

sxren2001 · April 29, 2024, 6:28pm

#include "HX711.h"

/* Comment this out to disable prints and save space */
#define BLYNK_PRINT Serial

/* Fill in information from Blynk Device Info here */
#define BLYNK_TEMPLATE_ID "--"
#define BLYNK_TEMPLATE_NAME "--"
#define BLYNK_AUTH_TOKEN "--"

#include <SPI.h>
#include <WiFiS3.h>
#include <BlynkSimpleWifi.h>

// Your WiFi credentials.
// Set password to "" for open networks.
char ssid[] = "--";
char pass[] = "--";
``

Rintin · April 29, 2024, 6:34pm

I see... when pumpenGestartet = false ever case adds one second to the loop.

PaulRB · April 29, 2024, 6:35pm

  if (scale.is_ready()) {
    long reading = (scale.read() * 0.01) - 842;
    Serial.print("HX711 reading: ");
    Serial.println(reading);

    // Wenn das Gewicht innerhalb der Toleranz liegt
    if (reading >= LOWER_TOLERANCE && reading <= UPPER_TOLERANCE && pumpenGestartet && CubaLibreAusgewaehlt) {
      Serial.println("Correct weight range reached");

Each of your recipe functions contains this code. Each function is called in turn from loop(), and executes this code before checking what selection has been chosen. I suspect it is this code, executed many times, is creating the unwanted delay.

Try changing it like this:

  if (CubaLibreAusgewaehlt && scale.is_ready()) {
    long reading = (scale.read() * 0.01) - 842;
    Serial.print("HX711 reading: ");
    Serial.println(reading);

    // Wenn das Gewicht innerhalb der Toleranz liegt
    if (reading >= LOWER_TOLERANCE && reading <= UPPER_TOLERANCE && pumpenGestartet) {
      Serial.println("Correct weight range reached");

sxren2001 · April 29, 2024, 6:49pm

I've changed it for all of them. But unfortunately, nothing changes. Is it important whether the void loop and setup comes before the whole case or afterwards?

Rintin · April 29, 2024, 6:50pm

For some reason I don't like tons of bool variables where only one can be true...

Maybe you can try something like this:

enum class Recipe{
  Idle,
  ManuelleSteuerung,
  Reinigungsprogramm,
  CubaLibre,
  WodkaLemon,
  WodkaSprite,
  MalibuOrange,
  RumPunch,
  JackyCola,
  ...
};


Recipe currentRecipe = Recipe::Idle;


BLYNK_WRITE(V11) {
  int selectedMenuItem = param.asInt();
  if (selectedMenuItem == 0) {
    currentRecipe = Recipe::ManuelleSteuerung;
  } else if (selectedMenuItem == 1) { 
    currentRecipe = Recipe::ReinigungAusgewaehlt; 
  } else if (selectedMenuItem == 2) { 
    currentRecipe = Recipe::CubaLibreAusgewaehlt; 
  } else if (selectedMenuItem == 3) { 
    ...
  }
}

void loop() {
  Blynk.run();

  switch(currentRecipe){
    case Recipe::ManuelleSteuerung:
      case0_ManuelleSteuerung();
      break;
    case Recipe::Reinigungsprogramm:
      case1_Reinigungsprogramm();
      break;
    case Recipe::CubaLibre:
      case2_CubaLibre();
      break;
    case Recipe::WodkaLemon:
      case3_WodkaLemon();
      break;
    case Recipe::WodkaSprite:
      case4_WodkaSprite();
      break;
    case Recipe::MalibuOrange:
      case5_MalibuOrange();
      break;
    case Recipe::RumPunch:
      case6_RumPunch();
      break;
    case Recipe::JackyCola:
      case7_JackyCola();
      break;
    ...
  }
}

Somewhere currentRecipe need to be set to Idle again.

Rintin · April 29, 2024, 6:56pm

When the scale is not ready, it takes the else path... with a delay()...

sxren2001 · April 29, 2024, 7:02pm

I'll give it a try, I've never done it this way before, I'll see if I can make it work

sxren2001 · April 29, 2024, 7:06pm

Is this right ?

#include "HX711.h"

/* Comment this out to disable prints and save space */
#define BLYNK_PRINT Serial

/* Fill in information from Blynk Device Info here */
#define BLYNK_TEMPLATE_ID "TMPL4CBq9QSu0"
#define BLYNK_TEMPLATE_NAME "Cocktailmaschine"
#define BLYNK_AUTH_TOKEN "j1F04hoTL7VXZPj9ftB62QG2eAo_sosP"

#include <SPI.h>
#include <WiFiS3.h>
#include <BlynkSimpleWifi.h>

// Your WiFi credentials.
// Set password to "" for open networks.
char ssid[] = "jctsh";
char pass[] = "79191924504718974086";

enum class Recipe {
  Idle,
  ManuelleSteuerung,
  Reinigungsprogramm,
  CubaLibre,
  WodkaLemon,
  WodkaSprite,
  MalibuOrange,
  RumPunch,
  JackyCola,
  // Add more recipes here as needed
};

Recipe currentRecipe = Recipe::Idle;

int pumpPins[] = {9, 8, 7, 6, 5, 4, 3, 2}; // Pin numbers for pumps

bool pumpStatus[] = {false, false, false, false, false, false, false, false}; // Status for each pump

bool pumpenGestartet = false;

BlynkTimer timer;
HX711 scale;

BLYNK_WRITE(V10) {
  int state = param.asInt();
  pumpenGestartet = !state;
}

void setPumpStatus(int pumpIndex, bool status) {
  digitalWrite(pumpPins[pumpIndex], status ? LOW : HIGH);
  pumpStatus[pumpIndex] = status;
}

void setAllPumpsStatus(bool status) {
  for (int i = 0; i < sizeof(pumpPins) / sizeof(pumpPins[0]); ++i) {
    setPumpStatus(i, status);
  }
}

BLYNK_WRITE(V11) {
  int selectedMenuItem = param.asInt();
  switch (selectedMenuItem) {
    case 0:
      currentRecipe = Recipe::ManuelleSteuerung;
      break;
    case 1:
      currentRecipe = Recipe::Reinigungsprogramm;
      break;
    case 2:
      currentRecipe = Recipe::CubaLibre;
      break;
    case 3:
      currentRecipe = Recipe::WodkaLemon;
      break;
    case 4:
      currentRecipe = Recipe::WodkaSprite;
      break;
    case 5:
      currentRecipe = Recipe::MalibuOrange;
      break;
    case 6:
      currentRecipe = Recipe::RumPunch;
      break;
    case 7:
      currentRecipe = Recipe::JackyCola;
      break;
    // Add more cases as needed
    default:
      currentRecipe = Recipe::Idle;
      break;
  }
}

void setup() {
  Serial.begin(57600);
  scale.begin(LOADCELL_DOUT_PIN, LOADCELL_SCK_PIN);
  pinMode(LOADCELL_DOUT_PIN, INPUT);
  pinMode(LOADCELL_SCK_PIN, OUTPUT);
  for (int pumpPin : pumpPins) {
    pinMode(pumpPin, OUTPUT);
    digitalWrite(pumpPin, HIGH);
  }

  Blynk.begin(BLYNK_AUTH_TOKEN, ssid, pass);
}

void loop() {
  Blynk.run();

  switch (currentRecipe) {
    case Recipe::ManuelleSteuerung:
      case_ManuelleSteuerung();
      break;
    case Recipe::Reinigungsprogramm:
      case_Reinigungsprogramm();
      break;
    case Recipe::CubaLibre:
      case_CubaLibre();
      break;
    case Recipe::WodkaLemon:
      case_WodkaLemon();
      break;
    case Recipe::WodkaSprite:
      case_WodkaSprite();
      break;
    case Recipe::MalibuOrange:
      case_MalibuOrange();
      break;
    case Recipe::RumPunch:
      case_RumPunch();
      break;
    case Recipe::JackyCola:
      case_JackyCola();
      break;
    // Add more cases as needed
    default:
      // Do nothing
      break;
  }
}

void case_ManuelleSteuerung() {
  for (int i = 0; i < sizeof(pumpPins) / sizeof(pumpPins[0]); ++i) {
    if (pumpenGestartet && pumpStatus[i]) {
      Serial.print("Pumpe ");
      Serial.print(i + 1);
      Serial.println(" läuft");
    }
  }
}

void case_Reinigungsprogramm() {
  // Implement cleaning program logic here
}

void case_CubaLibre() {
  // Implement Cuba Libre recipe logic here
}

void case_WodkaLemon() {
  // Implement Vodka Lemon recipe logic here
}

void case_WodkaSprite() {
  // Implement Vodka Sprite recipe logic here
}

void case_MalibuOrange() {
  // Implement Malibu Orange recipe logic here
}

void case_RumPunch() {
  // Implement Rum Punch recipe logic here
}

void case_JackyCola() {
  // Implement Jacky Cola recipe logic here
}

david_2018 · April 29, 2024, 7:07pm

All the is_ready() function does is a digitalRead of a status pin from the HX711, should not hurt to call that as often as you like, so no requirement for a delay().

The various cases for the drinks are very repetitive, should be able to do that with a single function that reads the recipe from an array (the recipe being the sequence of pumps and weights for each pump).

Rintin · April 29, 2024, 7:17pm

This looks quite promising.

system · October 26, 2024, 7:17pm

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

Topic		Replies	Views
Arduino und Blynk Deutsch	1	751	May 6, 2021
gui / code optimierung Deutsch	4	1587	May 6, 2021
Arduino per Blynk App steuern Deutsch	4	1101	May 6, 2021
Erste Versuche mit Arduino scheitern Deutsch	37	1607	September 17, 2022
Hallo.....ich benötige eure Hilfe....................!!!! Deutsch	16	5538	May 6, 2021

Code Optimization

Related topics