Poolsteuerung 3-Wege-Ventil_Pumpe_Pumpe

Hallo Leute,
ich bin neu hier und falle gleich mal mit der Tür ins Haus.
Ich habe mir eine Poolsteuerung gebastelt, nur funktioniert sie nicht.
Im Sketch zu sehen sind die ganzen Dinge fürs Display, zum auslesen und anzeigen der Sensorwerte. Das funktioniert auch soweit alles super.
Ich habe das Problem das mein “Loop” völlig verrückt spielt.
Dokumentiere ich den Automatik Teil aus, funktioniert der Manuelle Teil ohne Probleme, nur wenn ich ihn wieder rein hole spiele meine Millis() völlig verrückt. sicher habe ich nur etwas übersehen oder etwas grundlegendes noch nicht richtig verstanden.
Es wäre super wenn jemand mal drüber schauen kann und mir helfen könnte.

Ich habe im Sketch alles Wichtige versucht zu dokumentieren.

Gruß und Danke im Voraus.
Norman

// Solarsteuerung für Poolpumpe. Hierbei werden ein Lichtsensor, ein Temperatursensor und ein Regesensor zur Auswertung und anschließender Ein/Ausschaltung eines Relais verwendet.
// Erstellt von Norman Brandl, 31.03.2021

#include <Wire.h>
#include "SSD1306Ascii.h"
#include "SSD1306AsciiWire.h"
#include <BH1750FVI.h>
#include <Adafruit_Sensor.h>
#include <DHT.h>
#include <DHT_U.h>

#define DHT22_PIN 2 //Temperatursensor
#define DHTTYPE    DHT22     // DHT 22 (AM2302)
#define RST_PIN -1 // Definiere Reset_PIN.
#define I2C_ADDRESS 0x3C // 0X3C+SA0 - 0x3C or 0x3D
SSD1306AsciiWire oled; //Display

BH1750FVI LightSensor(BH1750FVI::k_DevModeContLowRes);
DHT dht(DHT22_PIN, DHT22);//Temperatursensor

int Taster = 4;
int LED = 3;
int Tasterstatus = 0;
int wert1;
int Relais1 = 11;                                                      // 3 Wegeventil
int Relais2 = 12;                                                      // Kollektorpumpe
int Relais3 = 10;                                                      // Wärmepumpe
double lux_alt;
uint16_t lux;
float h_alt;
float t_alt;
float Volt;


unsigned long currentMillis;
unsigned long previousMillis;
unsigned long oledMillis;


long oled_akt = 5000;                                                   // Wartezeit OLED
long Volt_akt = 60000;                                                  // Wartezeit Spannungssensor
unsigned long Startzeit = 0;                                                       // Wert zum internen rechnen
unsigned long Pumpzeit = 0;                                            // Wert zum internen rechnen
unsigned long Ventilstellzeit = 0;

double sollTemp = 19;                                                   // Temperatur, Auslöser zum Einschalten
double minTemp = 17;                                                    // Temperatur, Auslöser zum Ausschalten
uint16_t sollLux = 3500;                                                // Lichtsensor, Auslöser zum Einschalten
uint16_t minLux = 2000;                                                 // Lichtsensor, Auslöser zum Ausschalten
double Regen_an = 70;                                                   // Regensensor, Auslöser zum Einschalten
double Regen_aus = 90;                                                  // Regensensor, Auslöser zum Ausschalten
double Einschaltspannung = 12.5;                                        // Spannungssensor, Auslöden zum Einschalten
double Ausschaltspannung = 11.2;                                        // Spannungssensor, Auslöden zum Ausschalten

boolean Kollektorpumpe;
boolean Waermepumpe;
boolean Getastet;
boolean fertig;
boolean automatik;
boolean fertig_Automatik;
boolean Ventil_umgestellt;
boolean Ventil_zurueckgestellt;
boolean Startzeit_Automatik;
boolean Ventilstellzeit_Automatik;

uint8_t col0 = 0;                                                       // First value column
uint8_t col1 = 0;                                                       // Last value column.
uint8_t rows;                                                           // Rows per line.
//------------------------------------------------------------------------------
void setup() {
  const char* label[] = {"Temp:", "Feuchte:", "Licht:", "U ="};           //vor den Werten
  const char* units[] = {"   C", "   \45", "   Lux", "   Volt" };         // nach den Werten
  Wire.begin();
  Wire.setClock(400000L);
  Serial.begin(9600);

#if RST_PIN >= 0
  oled.begin(&Adafruit128x64, I2C_ADDRESS, RST_PIN);
#else // RST_PIN >= 0
  oled.begin(&Adafruit128x64, I2C_ADDRESS);
#endif // RST_PIN >= 0

  // oled.setFont(Callibri15);
  oled.setFont(Arial14);
  // oled.setFont(Callibri11_bold);
  // oled.setFont(TimesNewRoman13);
  // oled.setFont(Arial_bold_14);
  // oled.setFont(Callibri11);
  // oled.setFont(Callibri11_italic);
  // oled.setFont(Corsiva_12);
  // oled.setFont(fixed_bold10x15);
  // oled.setFont(TimesNewRoman16);
  // oled.setFont(TimesNewRoman16_italic);
  // oled.setFont(utf8font10x16);
  // oled.setFont(ZevvPeep8x16);


  oled.setLetterSpacing(2);                             // Buchstabenabstand.

  oled.clear();

  // Setup
  for (uint8_t i = 0; i < 4; i++) {
    oled.println(label[i]);
    uint8_t w = oled.strWidth(label[i]);
    col0 = col0 < w ? w : col0;
  }

  col0 += 3;                                          // Nachzeilen
  col1 = col0 + oled.strWidth("99.9") + 2;            // Schriftweite
  rows = oled.fontRows();                             // Zeilenöhe


  for ( uint8_t i = 0; i < 4; i++) {
    oled.setCursor(col1 + 1, i * rows);               // schreibe
    oled.print(units[i]);
  }
  delay(3000);
  pinMode(Relais1, OUTPUT);                           // Hier wird Relais1 angeschlossen
  pinMode(Relais2, OUTPUT);                           // Hier wird Relais2 angeschlossen
  pinMode(Relais3, OUTPUT);                           // Hier wird Relais3 angeschlossen
  pinMode (LED, OUTPUT);                              // Hier wird die Status LED für Tip Betrieb angeschlossen
  pinMode(wert1, INPUT);                              // Wert zum rechnen der Temperatur
  pinMode(Taster, INPUT_PULLUP);                      // Hier wird der Taster angeschlossen

  dht.begin();
  LightSensor.begin();


  Serial.println(sollLux);
  Serial.println(Regen_an);
  Serial.println(sollTemp);
  Serial.println(Ausschaltspannung);


}
//------------------------------------------------------------------------------
void clearValue(uint8_t row) {
  oled.clear(col0, col1, row, row + rows - 1);
}
//------------------------------------------------------------------------------
void loop()
{
  currentMillis = millis();                           // Zeitschleife setzen


  if ( currentMillis - previousMillis > Volt_akt ) {
    previousMillis = currentMillis;
    wert1 = analogRead (A1);
    Volt = ((wert1 / 40.6086956522));

  }



  if ( currentMillis - oledMillis > oled_akt )
  {


    oledMillis = currentMillis;
    clearValue(0);
    oled.print(dht.readTemperature(), 1);
    clearValue(rows);
    oled.print(dht.readHumidity(), 1);
    clearValue(2 * rows);
    oled.print(lux = LightSensor.GetLightIntensity(), 1);
    clearValue(3 * rows);
    oled.print(Volt, 1);




    // Serial Print .... Ausgabe auf dem Computer

    Serial.println(dht.readTemperature(), 1);
    Serial.println(dht.readHumidity(), 1);
    Serial.println(lux);
    Serial.println(dht.readHumidity(), 1);
    Serial.println(wert1);
    Serial.println(Volt);
  }
  //------------------------------------------------------------------------------ Hier folgen die Grundbedingungen um das 3 Wegeventil zu schalten ------------------------------------------------------------------------------
  if (automatik == false) {
    if (Getastet == false) {                                         // Wenn der Taster nicht gedrückt ist aber die Sensoren die Bedingungen erfüllen
      if ((lux = LightSensor.GetLightIntensity() >= sollLux) && (dht.readHumidity() <= Regen_an) && (dht.readTemperature() >= sollTemp) && (Volt >= Einschaltspannung))       //... wenn alle erfüllt sind
        Serial.println("Kollektorpumpe true");
      Startzeit_Automatik = millis();                               // Timer nullen
      Ventilstellzeit_Automatik = 9000;                             // Timerzeit in mS (1min = 60000 mS) 1,5 min um das 3 Wegeventil zu schalten
      digitalWrite(Relais3, HIGH);                                  // Wärmepumpe aus
      Serial.println("Wärmepumpe aus");
    }
    if (millis() - Startzeit_Automatik <= Ventilstellzeit_Automatik){
      digitalWrite(Relais1, LOW);                                   // 3-Wegeventil-Ventil wird auf Kollektorkreis umgestellt
      Serial.println("3-Wege-Ventil auf Kollektorpumpe");
    }
    if (millis() - Startzeit_Automatik >= Ventilstellzeit_Automatik){
      digitalWrite(Relais2, LOW);                                   // Kollektorpumpe an
      Serial.println("Kollektorpumpe On");
    }
    else if ((lux = LightSensor.GetLightIntensity() <= minLux) || (dht.readHumidity() >= Regen_aus) || (dht.readTemperature() <= minTemp) || (Volt <= Ausschaltspannung)) { // sonst wenn eine nicht erfüllt ist
      digitalWrite(Relais1, HIGH);                                  // 3-Wege-Ventil wird auf Wärmepumpenkreis umgestellt
      Serial.println("3-Wege-Ventil auf Wärmepumpe");
      digitalWrite(Relais2, HIGH);                                  // Kollektorpumpe aus
      Serial.println("Kollektorpumpe Off");
      fertig_Automatik = true;
    }
    if (fertig_Automatik == true){
      if (millis() - Startzeit_Automatik >= Ventilstellzeit_Automatik )
        digitalWrite(Relais3, LOW);                                   //Wärmepumpe an
      Serial.println("Wärmepumpe On");
      automatik = true;
    }
  }
  //------------------------------------------------------------------------------------------- Taster -------------------------------------------------------------------------------------------------------------------
  Tasterstatus = digitalRead(Taster);
  if (Tasterstatus == LOW) {                                          // Taster gedrückt und Spannung > Einschaltspannung
    Startzeit = millis();                                             // Timer nullen
    Ventilstellzeit = 9000;                                           // Timerzeit in mS (1min = 60000 mS) 1,5 min um das 3 Wegeventil zu schalten
    Pumpzeit = 20000;                                                 // Timerzeit in mS (1min = 60000 mS) 1,5 min um das 3 Wegeventil zu schalten
    Getastet = true;                                                  // manuelle Umschaltung des 3 Wegeventils erfüllt
    automatik = false;
    Serial.println("Taster gedrückt");
  }
  if (Getastet == true) {
    if (millis() - Startzeit <= Ventilstellzeit + Pumpzeit)
      digitalWrite(LED, HIGH);                                          // Taster LED AN
    digitalWrite(Relais3, HIGH);                                      // Wärmepumpe aus
    Serial.println("Wärmepumpe aus");
    digitalWrite(Relais1, LOW);                                       // 3-Wegeventil-Ventil auf Kollektorkreis
    Serial.println("3-Wege-Ventil auf Kollektorpumpe");

  }
  if (millis() - Startzeit >= Ventilstellzeit) {
    Serial.println("Ventil umgestellt");
    digitalWrite(Relais2, LOW);                                       // Kollektorpumpe an
    Serial.println("Kollektorpumpe an");
  }
  else                                                                // ansonsten
  {
    if (millis() - Startzeit >= Pumpzeit + Ventilstellzeit) {
      digitalWrite(LED, LOW);                                         // Taster LED aus
      digitalWrite(Relais1, HIGH);                                    // 3-Wege-Ventil auf Wärmepumpenkreis
      Serial.println("3-Wege-Ventil auf Wärmepumpe");
      digitalWrite(Relais2, HIGH);                                    // Kollektorpumpe aus
      Serial.println("Kollektorpumpe aus");
      fertig = true;
    }
    if (fertig == true) {
      if (millis() - Startzeit >= Ventilstellzeit)
        Ventil_zurueckgestellt = true;
      Serial.println("Ventil zurückgestellt");
    }
    if (Ventil_zurueckgestellt == true) {
      if (millis() - Startzeit >= Ventilstellzeit + Ventilstellzeit + Pumpzeit)
        digitalWrite(Relais3, LOW);                                     // Wärmepumpe an
      Serial.println("Wärmepumpe an");
      Waermepumpe = true;
      Getastet = false;

    }
  }
}

Hallo
dann zeige mal deinen Sketch, damit wir dir helfen können.
Den Sketch im IDE mit crtl+T formatieren und hier in </> Code Tags, siehe hier im Editor oben in der Mitte, reinkopieren,

Ich hab schon lauter Kommas und Klammern im Hirn.
Diese Art von Programmieren ist für einen CNC Fräser nichts. :slight_smile:

Oje,
Spaghetticode angerichtet an einem Salat von Kommas und Klammern :nerd_face:

sag ich doch.
Ich habs nach bestem Wissen und Gewissen versucht. :crazy_face: :crazy_face:

einmal durchfegen und dabei Datenstrukturen, Funktionen und einen Endlichen Automaten anlegen.
Vielleicht kann man auch mit Klassen arbeiten, aber die überfordern meine mindere intellektuelle Struktur. :wink:

Wenn ich wüsste wo ich ansetzen muss, wäre es alles sehr einfach. Ich hab schon so oft drüber geschaut dass ich mittlerweile Blind für etwaige Fehler bin.
Deshalb bitte ich ja hier um Hilfe.

Gruß Norman

Mein Standardrezept:
Als Basis studiere das EVA-Prinzip und danach nehme ein Stück Papier und konstruiere einen PAP. Daraus ergeben sich die Datenstrukturen und Funktionen, die benötigt werden.

Dazu bin ich aber zu weit weg von der Materie.

Ich habe mal kurz draufgeschaut; vielleicht finde ich nachher noch mehr. Aber es gibt da nicht nur ein Problem.

Dieses Konstrukt hier will mir so gar nicht gefallen (siehe auch hier):

(lux = LightSensor.GetLightIntensity() >= sollLux)

Da würde ich der Klarheit wegen die Zuweisung tatsächlich vor dem if ausführen lassen:

lux = LightSensor.GetLightIntensity();
if ((lux = LightSensor.GetLightIntensity() >= sollLux) && (dht.readHumidity() <= Regen_an) && (dht.readTemperature() >= sollTemp) && (Volt >= Einschaltspannung)) 

Das kommt vier mal vor.

Startzeit_Automatik und Ventilstellzeit_Automatik sind bei Dir boolean - die sollten beide unsigned long sein. Das hier und ein paar Vergleiche können so nicht funktionieren:

			Startzeit_Automatik = millis();                               // Timer nullen
			Ventilstellzeit_Automatik = 9000;                             // Timerzeit in mS (1min = 60000 mS) 1,5 min um das 3 Wegeventil zu schalten

Gruß Walter

Du meinst bestimmt

if ((lux  >= sollLux) && (dht.readHumidity() <= Regen_an) && (dht.readTemperature() >= sollTemp) && (Volt >= Einschaltspannung))

Gruß Tommy

Jaaa - natürlich.
Verdammte Copy-Schluderei.

Ja, die Auswertung der Sensoren hat funktioniert. Ich habe das ganze vorher laufen gehabt ohne die Steuerung des 3-Wege-Ventils.
Da kann man sicher Ordnung rein bringen aber grundsätzlich muss es erst einmal Funktionieren. :open_mouth:

So hat mein Programm vor dem Einbinden des Ventils ausgesehen. Das hat soweit funktioniert.

// Solrsteuerung für Poolpumpe. Hierbei werden ein Lichtsensor, ein Temperatursensor und ein Regesensor zur Auswertung und anschließender Ein/Ausschaltung eines Relais verwendet.
// Erstellt von Norman Brandl, 13.05.2020

#include <Wire.h>
#include "SSD1306Ascii.h"
#include "SSD1306AsciiWire.h"
#include <BH1750FVI.h>
#include <Adafruit_Sensor.h>
#include <DHT.h>
#include <DHT_U.h>

#define DHT22_PIN 2 //Temperatursensor
#define DHTTYPE    DHT22     // DHT 22 (AM2302)
#define RST_PIN -1 // Definiere Reset_PIN.
#define I2C_ADDRESS 0x3C // 0X3C+SA0 - 0x3C or 0x3D
SSD1306AsciiWire oled; //Display

BH1750FVI LightSensor(BH1750FVI::k_DevModeContLowRes);
DHT dht(DHT22_PIN, DHT22);//Temperatursensor

int Taster = 4;
int LED = 3;
int Tasterstatus = 0;
int wert1;
int Relais1 = 11;
int Relais2 = 12;
double lux_alt;
uint16_t lux;
float h_alt;
float t_alt;
float Volt;


unsigned long currentMillis;
unsigned long previousMillis;
unsigned long oledMillis;


long oled_akt = 5000;// Wartezeit OLED
long Volt_akt = 60000; // Wartezeit Spannungssensor
long myTimer = 0; //Wert zum internen rechnen
unsigned long myTimeout = 0;// Wert zum internen rechnen

double sollTemp = 19; // Temperatur, Auslöser zum Einschalten
double minTemp = 17; // Temperatur, Auslöser zum Ausschalten
uint16_t sollLux = 3500; // Lichtsensor, Auslöser zum Einschalten
uint16_t minLux = 2000; // Lichtsensor, Auslöser zum Ausschalten
double Regen_an = 70; // Regensensor, Auslöser zum Einschalten
double Regen_aus = 90; // Regensensor, Auslöser zum Ausschalten
double Einschaltspannung = 12.5; // Spannungssensor, Auslöden zum Einschalten
double Ausschaltspannung = 11.2; // Spannungssensor, Auslöden zum Ausschalten

boolean manuell;


uint8_t col0 = 0;  // First value column
uint8_t col1 = 0;  // Last value column.
uint8_t rows;      // Rows per line.
//------------------------------------------------------------------------------
void setup() {
  const char* label[] = {"Temp:", "Feuchte:", "Licht:", "U ="}; //vor den Werten
  const char* units[] = {"   C", "   \45", "   Lux", "   Volt" }; // nach den Werten
  Wire.begin();
  Wire.setClock(400000L);
  Serial.begin(9600);

#if RST_PIN >= 0
  oled.begin(&Adafruit128x64, I2C_ADDRESS, RST_PIN);
#else // RST_PIN >= 0
  oled.begin(&Adafruit128x64, I2C_ADDRESS);
#endif // RST_PIN >= 0

  // oled.setFont(Callibri15);
  oled.setFont(Arial14);
  // oled.setFont(Callibri11_bold);
  // oled.setFont(TimesNewRoman13);
  // oled.setFont(Arial_bold_14);
  // oled.setFont(Callibri11);
  // oled.setFont(Callibri11_italic);
  // oled.setFont(Corsiva_12);
  // oled.setFont(fixed_bold10x15);
  // oled.setFont(TimesNewRoman16);
  // oled.setFont(TimesNewRoman16_italic);
  // oled.setFont(utf8font10x16);
  // oled.setFont(ZevvPeep8x16);

  // Buchstabenabstand.
  oled.setLetterSpacing(2);

  oled.clear();

  // Setup
  for (uint8_t i = 0; i < 4; i++) {
    oled.println(label[i]);
    uint8_t w = oled.strWidth(label[i]);
    col0 = col0 < w ? w : col0;
  }
  // Nachzeilen.
  col0 += 3;
  // Pixeleinstellung.
  col1 = col0 + oled.strWidth("99.9") + 2;
  // Zeilenöhe
  rows = oled.fontRows();

  // schreibe
  for ( uint8_t i = 0; i < 4; i++) {
    oled.setCursor(col1 + 1, i * rows);
    oled.print(units[i]);
  }
  delay(3000);
  pinMode(Relais1, OUTPUT);//Hier wird Relais1 angeschlossen
  pinMode(Relais2, OUTPUT);//Hier wird Relais2 angeschlossen
  pinMode (LED, OUTPUT); // Hier wird die Status LED für Tip Betrieb angeschlossen
  pinMode(wert1, INPUT);  // Wert zum rechnen der Temperatur
  pinMode(Taster, INPUT_PULLUP); // Hier wird der Taster angeschlossen

  dht.begin();
  LightSensor.begin();


  Serial.println(sollLux);
  Serial.println(Regen_an);
  Serial.println(sollTemp);
  Serial.println(Ausschaltspannung);


}
//------------------------------------------------------------------------------
void clearValue(uint8_t row) {
  oled.clear(col0, col1, row, row + rows - 1);
}
//------------------------------------------------------------------------------
void loop()
{
  currentMillis = millis(); // Zeitschleife setzen


  if ( currentMillis - previousMillis > Volt_akt ) {
    previousMillis = currentMillis;
    wert1 = analogRead (A1);
    Volt = ((wert1 / 40.6086956522));

  }



  if ( currentMillis - oledMillis > oled_akt )
  {


    oledMillis = currentMillis;
    clearValue(0);
    oled.print(dht.readTemperature(), 1);
    clearValue(rows);
    oled.print(dht.readHumidity(), 1);
    clearValue(2 * rows);
    oled.print(lux = LightSensor.GetLightIntensity(), 1);
    clearValue(3 * rows);
    oled.print(Volt, 1);




    // Serial Print .... Ausgabe auf dem Computer

    Serial.println(dht.readTemperature(), 1);
    Serial.println(dht.readHumidity(), 1);
    Serial.println(lux);
    Serial.println(dht.readHumidity(), 1);
    Serial.println(wert1);
    Serial.println(Volt);
  }
  //----------------------------------------------- Hier folgen die Bedingungen ------------------------------------------------------------------------------------------------------------------------------------------

  {
    if (manuell == false)
      if ((lux = LightSensor.GetLightIntensity() >= sollLux) && (dht.readHumidity() <= Regen_an) && (dht.readTemperature() >= sollTemp) && (Volt >= Einschaltspannung)) //... wenn alle erfüllt sind
      {
        digitalWrite(Relais1, LOW); //...soll Relais einschalten.
        Serial.println("AN");
      }
      else if ((lux = LightSensor.GetLightIntensity() <= minLux) || (dht.readHumidity() >= Regen_aus) || (dht.readTemperature() <= minTemp) || (Volt <= Ausschaltspannung))  // sonst wenn eine nicht erfüllt ist
      {
        digitalWrite(Relais1, HIGH); //...soll Relais ausschalten.
        Serial.println("AUS");
      }
  }
  //---------------------------------------------- Manuelles einschalten der Pumpe ---------------------------------------------------------------------------------------------------------------------------------------
  Tasterstatus = digitalRead(Taster);
  if ((Tasterstatus == LOW) && (Volt >= Einschaltspannung))
  {
    myTimer = millis(); // Timer mit Knopfdruck nullen
    myTimeout = 420000; // Timerzeit in mS (1min = 60000 mS)
    manuell = true;
  }
  if (manuell == true)
    if (millis() - myTimer < myTimeout)
    {
      digitalWrite(LED, HIGH);
      digitalWrite(Relais1, LOW);
    }
    else
    {
      digitalWrite(LED, LOW);
      digitalWrite(Relais1, HIGH);
      manuell = false;
    }
}

Auch wenn hier zwischendurch schon was aufgeschlagen ist…

Ich hab jetzt wirklich versucht in 40 Minuten aus Deinem Code irgend was rauszulesen.
Und geschafft.
Das Ergebnis ist aber eher ein Mißerfolg.

Du hast in Kommentaren reingeschrieben, was im Code steht.
Da ist nichts erklärt.
Nur mal als Beispiel:

  pinMode(wert1, INPUT);  // Wert zum rechnen der Temperatur

Mit was rechnest Du da? Mit dem Pin?

Hier hauts dann ganz weg:

    wert1 = analogRead (A1);
    Volt = ((wert1 / 40.6086956522));
      digitalWrite(Relais3, HIGH);  // Wärmepumpe aus
      Serial.println("Wärmepumpe aus");

Warum heisst das Relais3 so und nicht waermepumpe?
Das geht mit allen Relais so…

Dann unerklärliche Dinge:

  if (Tasterstatus == LOW)   { // Taster gedrückt und Spannung > Einschaltspannung

Welche Einschaltspannung? Nu bitte nicht die, die da oben mit 12.5 angegeben ist, sondern wo Du die herholst…

Dann ganz grobe Schnitzer, die sich eingeschlichen haben:

    if (fertig_Automatik == true) 
    {
      if (millis() - Startzeit_Automatik >= Ventilstellzeit_Automatik )
        digitalWrite(Relais3, LOW);                                   //Wärmepumpe an
      Serial.println("Wärmepumpe On");
      automatik = true;
    }

Das digitalWrite geht mit der zweiten Bedingung; der Rest ist immer erfüllt, wenn fertig_Automatik == true ist.
Heisst: Du bekommst IMMMER auf der Seriellen Ausgabe das Wärmepumpe On angezeigt und die bool automatik wird IMMER auf true gesetzt. - Also noch bevor die Stellzeit erreicht ist…

Derart hast Du noch mehr. Viel mehr.

Und warum müssen immer soo viele Schmuck-Zeilen verwendet werden und Leerzeichen gibt es auch en mass :wink:

… wie mein Einstieg aussehen würde…
“Tasterstatus” ist unnütz. Die ganzen bools für Kollektorpumpe, Wärmepumpe etc. sind auch überflüssig. Den Zustand kannst Du zur Laufzeit am Pin abrufen.

Der Rest ist erstmal nur übernommen und mit “vermuteten” Klammern versehen.
Der grosse Posten ist vor dem Setup.

Das kompiliert ganz bestimmt nicht, aber dann hast was zum aufräumen - wenn der wieder kompiliert, dann kannst ja den Code wieder einstellen und dann schaun wa mal…

#include <Wire.h>
#include "SSD1306Ascii.h"
#include "SSD1306AsciiWire.h"
#include <BH1750FVI.h>
#include <Adafruit_Sensor.h>
#include <DHT.h>
#include <DHT_U.h>

const byte DHT22_PIN = 2; //Temperatursensor
const byte LEDPin = 3;
const byte TasterPin = 4;
const byte spannungsPin = A1;
const byte WaermepumpePin = 10;
const byte 3WegeventilPin = 11;
const byte KollektorpumpePin = 12;

#define DHTTYPE    DHT22     // DHT 22 (AM2302)
#define RST_PIN -1 // Definiere Reset_PIN.
#define I2C_ADDRESS 0x3C // 0X3C+SA0 - 0x3C or 0x3D
SSD1306AsciiWire oled; //Display

BH1750FVI LightSensor(BH1750FVI::k_DevModeContLowRes);
DHT dht(DHT22_PIN, DHT22);//Temperatursensor

bool Tasterstatus = false;
double lux_alt;
uint16_t lux;
float h_alt;
float t_alt;
float Volt;

unsigned long currentMillis;
unsigned long previousMillis;
unsigned long oledMillis;
unsigned long Startzeit = 0;                 // Wert zum internen rechnen
const unsigned long oledWait = 5000;         // Wartezeit OLED
const unsigned long VoltWait = 60000;        // Wartezeit Spannungssensor
const unsigned long Pumpzeit = 20000;        // Timerzeit in mS (1min = 60000 mS) 1,5 min um das 3 Wegeventil zu schalten
const unsigned long Ventilstellzeit = 9000;  // Timerzeit in mS (1min = 60000 mS) 1,5 min um das 3 Wegeventil zu schalten

const double sollTemp = 19;            // Temperatur, Auslöser zum Einschalten
const double minTemp = 17;             // Temperatur, Auslöser zum Ausschalten
const uint16_t sollLux = 3500;         // Lichtsensor, Auslöser zum Einschalten
const uint16_t minLux = 2000;          // Lichtsensor, Auslöser zum Ausschalten
const double Regen_an = 70;            // Regensensor, Auslöser zum Einschalten
const double Regen_aus = 90;           // Regensensor, Auslöser zum Ausschalten
const double Einschaltspannung = 12.5; // Spannungssensor, Auslöden zum Einschalten
const double Ausschaltspannung = 11.2; // Spannungssensor, Auslöden zum Ausschalten

boolean Kollektorpumpe;
boolean Waermepumpe;
boolean Getastet;
boolean fertig;
boolean automatik;
boolean fertig_Automatik;
boolean Ventil_umgestellt;
boolean Ventil_zurueckgestellt;
boolean Startzeit_Automatik;
boolean Ventilstellzeit_Automatik;

uint8_t col0 = 0;                                                       // First value column
uint8_t col1 = 0;                                                       // Last value column.
uint8_t rows;                                                           // Rows per line.
//------------------------------------------------------------------------------
void setup() {
  const char* label[] = {"Temp:", "Feuchte:", "Licht:", "U ="};           //vor den Werten
  const char* units[] = {"   C", "   \45", "   Lux", "   Volt" };         // nach den Werten
  Wire.begin();
  Wire.setClock(400000L);
  Serial.begin(9600);

#if RST_PIN >= 0
  oled.begin(&Adafruit128x64, I2C_ADDRESS, RST_PIN);
#else // RST_PIN >= 0
  oled.begin(&Adafruit128x64, I2C_ADDRESS);
#endif // RST_PIN >= 0

  // oled.setFont(Callibri15);
  oled.setFont(Arial14);
  // oled.setFont(Callibri11_bold);
  // oled.setFont(TimesNewRoman13);
  // oled.setFont(Arial_bold_14);
  // oled.setFont(Callibri11);
  // oled.setFont(Callibri11_italic);
  // oled.setFont(Corsiva_12);
  // oled.setFont(fixed_bold10x15);
  // oled.setFont(TimesNewRoman16);
  // oled.setFont(TimesNewRoman16_italic);
  // oled.setFont(utf8font10x16);
  // oled.setFont(ZevvPeep8x16);


  oled.setLetterSpacing(2);                             // Buchstabenabstand.

  oled.clear();

  // Setup
  for (uint8_t i = 0; i < 4; i++) {
    oled.println(label[i]);
    uint8_t w = oled.strWidth(label[i]);
    col0 = col0 < w ? w : col0;
  }

  col0 += 3;                                          // Nachzeilen
  col1 = col0 + oled.strWidth("99.9") + 2;            // Schriftweite
  rows = oled.fontRows();                             // Zeilenöhe


  for ( uint8_t i = 0; i < 4; i++) {
    oled.setCursor(col1 + 1, i * rows);               // schreibe
    oled.print(units[i]);
  }
  delay(3000);
  pinMode(3WegeventilPin, OUTPUT);                           // Hier wird 3Wegeventil angeschlossen
  pinMode(KollektorpumpePin, OUTPUT);                           // Hier wird Kollektorpumpe angeschlossen
  pinMode(WaermepumpePin, OUTPUT);                           // Hier wird Waermepumpe angeschlossen
  pinMode (LED, OUTPUT);                              // Hier wird die Status LED für Tip Betrieb angeschlossen
  pinMode(spannungsPin, INPUT);                              // Wert zum rechnen der Temperatur
  pinMode(TasterPin, INPUT_PULLUP);                      // Hier wird der Taster angeschlossen

  dht.begin();
  LightSensor.begin();


  Serial.println(sollLux);
  Serial.println(Regen_an);
  Serial.println(sollTemp);
  Serial.println(Ausschaltspannung);


}
//------------------------------------------------------------------------------
void clearValue(uint8_t row) {
  oled.clear(col0, col1, row, row + rows - 1);
}
//------------------------------------------------------------------------------
void loop()
{
  currentMillis = millis();                           // Zeitschleife setzen
  if ( currentMillis - previousMillis > VoltWait ) {
    previousMillis = currentMillis;
    wert1 = analogRead (A1);
    Volt = ((wert1 / 40.6086956522));
  }
  if ( currentMillis - oledMillis > oledWait )
  {
    oledMillis = currentMillis;
    clearValue(0);
    oled.print(dht.readTemperature(), 1);
    clearValue(rows);
    oled.print(dht.readHumidity(), 1);
    clearValue(2 * rows);
    oled.print(lux = LightSensor.GetLightIntensity(), 1);
    clearValue(3 * rows);
    oled.print(Volt, 1);

    // Serial Print .... Ausgabe auf dem Computer

    Serial.println(dht.readTemperature(), 1);
    Serial.println(dht.readHumidity(), 1);
    Serial.println(lux);
    Serial.println(dht.readHumidity(), 1);
    Serial.println(wert1);
    Serial.println(Volt);
  }

  if (automatik == false)
  {
    if (Getastet == false)
    { // Wenn der Taster nicht gedrückt ist aber die Sensoren die Bedingungen erfüllen
      if ((lux = LightSensor.GetLightIntensity() >= sollLux) && (dht.readHumidity() <= Regen_an) && (dht.readTemperature() >= sollTemp) && (Volt >= Einschaltspannung))       //... wenn alle erfüllt sind
        Serial.println("Kollektorpumpe true");
      Startzeit_Automatik = millis();                               // Timer nullen
      Ventilstellzeit_Automatik = 9000;                             // Timerzeit in mS (1min = 60000 mS) 1,5 min um das 3 Wegeventil zu schalten
      digitalWrite(WaermepumpePin, HIGH);                                  // Wärmepumpe aus
      Serial.println("Wärmepumpe aus");
    }
    if (millis() - Startzeit_Automatik <= Ventilstellzeit_Automatik)
    {
      digitalWrite(3WegeventilPin, LOW);                                   // 3-Wegeventil-Ventil wird auf Kollektorkreis umgestellt
      Serial.println("3-Wege-Ventil auf Kollektorpumpe");
    }
    if (millis() - Startzeit_Automatik >= Ventilstellzeit_Automatik)
    {
      digitalWrite(KollektorpumpePin, LOW);                                   // Kollektorpumpe an
      Serial.println("Kollektorpumpe On");
    }
    else if ((lux = LightSensor.GetLightIntensity() <= minLux) || (dht.readHumidity() >= Regen_aus) || (dht.readTemperature() <= minTemp) || (Volt <= Ausschaltspannung))
    { // sonst wenn eine nicht erfüllt ist
      digitalWrite(3WegeventilPin, HIGH);                                  // 3-Wege-Ventil wird auf Wärmepumpenkreis umgestellt
      Serial.println("3-Wege-Ventil auf Wärmepumpe");
      digitalWrite(KollektorpumpePin, HIGH);                                  // Kollektorpumpe aus
      Serial.println("Kollektorpumpe Off");
      fertig_Automatik = true;
    }
    if (fertig_Automatik == true)
    {
      if (millis() - Startzeit_Automatik >= Ventilstellzeit_Automatik )
        digitalWrite(WaermepumpePin, LOW);                                   //Wärmepumpe an
      Serial.println("Wärmepumpe On");
      automatik = true;
    }
  }

  if (digitalRead(Taster) == LOW)   
  {   // Taster gedrückt und Spannung > Einschaltspannung
    Startzeit = millis();                                             // Timer nullen
    Getastet = true;                                                  // manuelle Umschaltung des 3 Wegeventils erfüllt
    automatik = false;
    Serial.println("Taster gedrückt");
  }
  if (Getastet == true)
  {
    if (millis() - Startzeit <= Ventilstellzeit + Pumpzeit)
    {
      digitalWrite(LED, HIGH);                                          // Taster LED AN
      digitalWrite(WaermepumpePin, HIGH);                                      // Wärmepumpe aus
      Serial.println("Wärmepumpe aus");
      digitalWrite(3WegeventilPin, LOW);                                       // 3-Wegeventil-Ventil auf Kollektorkreis
      Serial.println("3-Wege-Ventil auf Kollektorpumpe");
    }
  }
  if (millis() - Startzeit >= Ventilstellzeit)
  {
    Serial.println("Ventil umgestellt");
    digitalWrite(KollektorpumpePin, LOW);                                       // Kollektorpumpe an
    Serial.println("Kollektorpumpe an");
  }
  else                                                                // ansonsten
  {
    if (millis() - Startzeit >= Pumpzeit + Ventilstellzeit)
    {
      digitalWrite(LED, LOW);                                         // Taster LED aus
      digitalWrite(3WegeventilPin, HIGH);                                    // 3-Wege-Ventil auf Wärmepumpenkreis
      Serial.println("3-Wege-Ventil auf Wärmepumpe");
      digitalWrite(KollektorpumpePin, HIGH);                                    // Kollektorpumpe aus
      Serial.println("Kollektorpumpe aus");
      fertig = true;
    }
    if (fertig == true)
    {
      if (millis() - Startzeit >= Ventilstellzeit)
      {
        Ventil_zurueckgestellt = true;
        Serial.println("Ventil zurückgestellt");
      }
    }
    if (Ventil_zurueckgestellt == true)
    {
      if (millis() - Startzeit >= Ventilstellzeit + Ventilstellzeit + Pumpzeit)
      {
        digitalWrite(WaermepumpePin, LOW);
        Serial.println("Wärmepumpe an");
        Waermepumpe = true;
        Getastet = false;
      }
    }
  }
}

Auch wenn hier zwischendurch schon was aufgeschlagen ist…

Ich hab jetzt wirklich versucht in 40 Minuten aus Deinem Code irgend was rauszulesen.
Und geschafft.
Das Ergebnis ist aber eher ein Mißerfolg.

Du hast in Kommentaren reingeschrieben, was im Code steht.
Da ist nichts erklärt.
Nur mal als Beispiel:

Erst einmal Danke.
Die Einschaltspannung habe ich erst einmal heraus genommen damit ich in meinem Wohnzimmer den Taster simulieren kann.

  pinMode(wert1, INPUT);  // Wert zum rechnen der Temperatur

ist mein Spannungssensor. Die Werte die der ausschmeißt habe ich dann unten in die Reelle Spannung umgerechnet.

 wert1 = analogRead (A1);
    Volt = ((wert1 / 40.6086956522));

ist mein Spannungssensor. Die Zahl ist nur dazu da das er mir auch das anzeigt was tatsächlich noch in meiner PV Batterie drin ist.
Die Leerzeichen und Zeilen habe ich für mich zur besseren Übersichtlichkeit gesetzt.
Damit ich mir als nicht Kenner, nicht nen Wolf suchen muss.

Umgemodelt und kompiliert.
Leider geht er aus der Taster Schleife nicht mehr heraus.

#include <Wire.h>
#include "SSD1306Ascii.h"
#include "SSD1306AsciiWire.h"
#include <BH1750FVI.h>
#include <Adafruit_Sensor.h>
#include <DHT.h>
#include <DHT_U.h>

const byte DHT22_PIN = 2; //Temperatursensor
const byte LEDPin = 3;
const byte TasterPin = 4;
const byte Wert1Pin = A1;
const byte WaermepumpePin = 10;
const byte WegeventilPin = 11;
const byte KollektorpumpePin = 12;

#define DHTTYPE    DHT22     // DHT 22 (AM2302)
#define RST_PIN -1 // Definiere Reset_PIN.
#define I2C_ADDRESS 0x3C // 0X3C+SA0 - 0x3C or 0x3D
SSD1306AsciiWire oled; //Display

BH1750FVI LightSensor(BH1750FVI::k_DevModeContLowRes);
DHT dht(DHT22_PIN, DHT22);//Temperatursensor

bool Tasterstatus = false;
double lux_alt;
uint16_t lux;
float h_alt;
float t_alt;
float Volt;

unsigned long currentMillis;
unsigned long previousMillis;
unsigned long oledMillis;
unsigned long Startzeit = 0;                 // Wert zum internen rechnen
const unsigned long oledWait = 5000;         // Wartezeit OLED
const unsigned long VoltWait = 60000;        // Wartezeit Spannungssensor
const unsigned long Pumpzeit = 20000;        // Timerzeit in mS (1min = 60000 mS) 1,5 min um das 3 Wegeventil zu schalten
const unsigned long Ventilstellzeit = 9000;  // Timerzeit in mS (1min = 60000 mS) 1,5 min um das 3 Wegeventil zu schalten

const double sollTemp = 19;            // Temperatur, Auslöser zum Einschalten
const double minTemp = 17;             // Temperatur, Auslöser zum Ausschalten
const uint16_t sollLux = 3500;         // Lichtsensor, Auslöser zum Einschalten
const uint16_t minLux = 2000;          // Lichtsensor, Auslöser zum Ausschalten
const double Regen_an = 70;            // Regensensor, Auslöser zum Einschalten
const double Regen_aus = 90;           // Regensensor, Auslöser zum Ausschalten
const double Einschaltspannung = 12.5; // Spannungssensor, Auslöden zum Einschalten
const double Ausschaltspannung = 11.2; // Spannungssensor, Auslöden zum Ausschalten

boolean Kollektorpumpe;
boolean Waermepumpe;
boolean Getastet;
boolean fertig;
boolean automatik;
boolean fertig_Automatik;
boolean Ventil_umgestellt;
boolean Ventil_zurueckgestellt;
boolean Startzeit_Automatik;
boolean Ventilstellzeit_Automatik;


uint8_t col0 = 0;                                                       // First value column
uint8_t col1 = 0;                                                       // Last value column.
uint8_t rows;                                                           // Rows per line.
//------------------------------------------------------------------------------
void setup() {
  const char* label[] = {"Temp:", "Feuchte:", "Licht:", "U ="};           //vor den Werten
  const char* units[] = {"   C", "   \45", "   Lux", "   Volt" };         // nach den Werten
  Wire.begin();
  Wire.setClock(400000L);
  Serial.begin(9600);

#if RST_PIN >= 0
  oled.begin(&Adafruit128x64, I2C_ADDRESS, RST_PIN);
#else // RST_PIN >= 0
  oled.begin(&Adafruit128x64, I2C_ADDRESS);
#endif // RST_PIN >= 0

  // oled.setFont(Callibri15);
  oled.setFont(Arial14);
  // oled.setFont(Callibri11_bold);
  // oled.setFont(TimesNewRoman13);
  // oled.setFont(Arial_bold_14);
  // oled.setFont(Callibri11);
  // oled.setFont(Callibri11_italic);
  // oled.setFont(Corsiva_12);
  // oled.setFont(fixed_bold10x15);
  // oled.setFont(TimesNewRoman16);
  // oled.setFont(TimesNewRoman16_italic);
  // oled.setFont(utf8font10x16);
  // oled.setFont(ZevvPeep8x16);


  oled.setLetterSpacing(2);                             // Buchstabenabstand.

  oled.clear();

  // Setup
  for (uint8_t i = 0; i < 4; i++) {
    oled.println(label[i]);
    uint8_t w = oled.strWidth(label[i]);
    col0 = col0 < w ? w : col0;
  }

  col0 += 3;                                          // Nachzeilen
  col1 = col0 + oled.strWidth("99.9") + 2;            // Schriftweite
  rows = oled.fontRows();                             // Zeilenöhe


  for ( uint8_t i = 0; i < 4; i++) {
    oled.setCursor(col1 + 1, i * rows);               // schreibe
    oled.print(units[i]);
  }
  delay(3000);
  pinMode(WegeventilPin, OUTPUT);                           // Hier wird 3Wegeventil angeschlossen
  pinMode(KollektorpumpePin, OUTPUT);                           // Hier wird Kollektorpumpe angeschlossen
  pinMode(WaermepumpePin, OUTPUT);                           // Hier wird Waermepumpe angeschlossen
  pinMode (LEDPin, OUTPUT);                              // Hier wird die Status LED für Tip Betrieb angeschlossen
  pinMode(Wert1Pin, INPUT);                              // Wert zum rechnen der Spannung
  pinMode(TasterPin, INPUT_PULLUP);                      // Hier wird der Taster angeschlossen

  dht.begin();
  LightSensor.begin();


  Serial.println(sollLux);
  Serial.println(Regen_an);
  Serial.println(sollTemp);
  Serial.println(Ausschaltspannung);


}
//------------------------------------------------------------------------------
void clearValue(uint8_t row) {
  oled.clear(col0, col1, row, row + rows - 1);
}
//------------------------------------------------------------------------------
void loop()
{
  currentMillis = millis();                           // Zeitschleife setzen
  if ( currentMillis - previousMillis > VoltWait ) {
    previousMillis = currentMillis;
    Volt = ((Wert1Pin / 40.6086956522));
  }
  if ( currentMillis - oledMillis > oledWait )
  {
    oledMillis = currentMillis;
    clearValue(0);
    oled.print(dht.readTemperature(), 1);
    clearValue(rows);
    oled.print(dht.readHumidity(), 1);
    clearValue(2 * rows);
    oled.print(lux = LightSensor.GetLightIntensity(), 1);
    clearValue(3 * rows);
    oled.print(Volt, 1);

    // Serial Print .... Ausgabe auf dem Computer

    Serial.println(dht.readTemperature(), 1);
    Serial.println(dht.readHumidity(), 1);
    Serial.println(lux);
    Serial.println(dht.readHumidity(), 1);
    Serial.println(Volt);
  }

  if (automatik == false)
  {
    if (Getastet == false)
    { // Wenn der Taster nicht gedrückt ist aber die Sensoren die Bedingungen erfüllen
      if ((lux = LightSensor.GetLightIntensity() >= sollLux) && (dht.readHumidity() <= Regen_an) && (dht.readTemperature() >= sollTemp) && (Volt >= Einschaltspannung))       //... wenn alle erfüllt sind
        Serial.println("Kollektorpumpe true");
      Startzeit_Automatik = millis();                               // Timer nullen
      digitalWrite(WaermepumpePin, HIGH);                                  // Wärmepumpe aus
      Serial.println("Wärmepumpe aus");
    }
    if (millis() - Startzeit_Automatik <= Ventilstellzeit_Automatik)
    {
      digitalWrite(WegeventilPin, LOW);                                   // 3-Wegeventil-Ventil wird auf Kollektorkreis umgestellt
      Serial.println("3-Wege-Ventil auf Kollektorpumpe");
    }
    if (millis() - Startzeit_Automatik >= Ventilstellzeit_Automatik)
    {
      digitalWrite(KollektorpumpePin, LOW);                                   // Kollektorpumpe an
      Serial.println("Kollektorpumpe On");
    }
    else if ((lux = LightSensor.GetLightIntensity() <= minLux) || (dht.readHumidity() >= Regen_aus) || (dht.readTemperature() <= minTemp) || (Volt <= Ausschaltspannung))
    { // sonst wenn eine nicht erfüllt ist
      digitalWrite(WegeventilPin, HIGH);                                  // 3-Wege-Ventil wird auf Wärmepumpenkreis umgestellt
      Serial.println("3-Wege-Ventil auf Wärmepumpe");
      digitalWrite(KollektorpumpePin, HIGH);                                  // Kollektorpumpe aus
      Serial.println("Kollektorpumpe Off");
      fertig_Automatik = true;
    }
    if (fertig_Automatik == true)
    {
      if (millis() - Startzeit_Automatik >= Ventilstellzeit_Automatik )
        digitalWrite(WaermepumpePin, LOW);                                   //Wärmepumpe an
      Serial.println("Wärmepumpe On");
      automatik = true;
    }
  }

  if (digitalRead(TasterPin) == LOW && (Volt >= Einschaltspannung))
  { // Taster gedrückt und Spannung > Einschaltspannung
    Startzeit = millis();                                             // Timer nullen
    Getastet = true;                                                  // manuelle Umschaltung des 3 Wegeventils erfüllt
    automatik = false;
    Serial.println("Taster gedrückt");
  }
  if (Getastet == true)
  {
    if (millis() - Startzeit <= Ventilstellzeit + Pumpzeit)
    {
      digitalWrite(LEDPin, HIGH);                                          // Taster LED AN
      digitalWrite(WaermepumpePin, HIGH);                                      // Wärmepumpe aus
      Serial.println("Wärmepumpe aus");
      digitalWrite(WegeventilPin, LOW);                                       // 3-Wegeventil-Ventil auf Kollektorkreis
      Serial.println("3-Wege-Ventil auf Kollektorpumpe");
    }
  }
  if (millis() - Startzeit >= Ventilstellzeit)
  {
    Serial.println("Ventil umgestellt");
    digitalWrite(KollektorpumpePin, LOW);                                       // Kollektorpumpe an
    Serial.println("Kollektorpumpe an");
  }
  else                                                                // ansonsten
  {
    if (millis() - Startzeit >= Pumpzeit + Ventilstellzeit)
    {
      digitalWrite(LEDPin, LOW);                                         // Taster LED aus
      digitalWrite(WegeventilPin, HIGH);                                    // 3-Wege-Ventil auf Wärmepumpenkreis
      Serial.println("3-Wege-Ventil auf Wärmepumpe");
      digitalWrite(KollektorpumpePin, HIGH);                                    // Kollektorpumpe aus
      Serial.println("Kollektorpumpe aus");
      fertig = true;
    }
    if (fertig == true)
    {
      if (millis() - Startzeit >= Ventilstellzeit)
      {
        Ventil_zurueckgestellt = true;
        Serial.println("Ventil zurückgestellt");
      }
    }
    if (Ventil_zurueckgestellt == true)
    {
      if (millis() - Startzeit >= Ventilstellzeit + Ventilstellzeit + Pumpzeit)
      {
        digitalWrite(WaermepumpePin, LOW);
        Serial.println("Wärmepumpe an");
        Waermepumpe = true;
        Getastet = false;
      }
    }
  }
}
boolean Startzeit_Automatik;
...
Startzeit_Automatik = millis(); 

Ich bin raus.

warum? sind doch nur 2 Schaltkreise. und um die zu unterscheiden mit _Automatik.

Nein.
Mach mal bitte folgendes:

In der IDE unter DATEI - VOREINSTELLUNGEN
einen Haken rein bei: Ausführliche Ausgabe während () Kompilierung
Und da drunter machst Du in dem Feld Compilerwarnungen auf ALLE.

Dann kompilieren.

Alles das, was da dann rot ist, ist aufzuarbeiten warum das so ist und wie das behoben werden kann.

ein BOOLEAN kann nur zwei Zustände. Da passt nie und nimmer ein millis() rein…

Sowas gibt es noch mehr.

Ich hab nur weder die verwendeten lib’s noch sonst irgendwas, um das sinnvoll antesten zu können, geschweige denn zu kompilieren.

Wenn der Code Dich nicht mehr warnt, dann kannst weiter machen - oder musst hoffen, das das hier jemand für Dich übernimmt…

aber es wird…