/*  Bewaesserung_Slave  Arduino Nano V3
Version 1.0.0:
 -- Schnitstelle I2C eingerichtet
 -- Ultraschallmessung
Version 1.0.2:
  -- serielle Schnittstelle einbinden
  -- <Bef_Pumpe_ein> <Bef_Pumpe_aus>  über seriell, I2C
  -- <Pumpe_Zustand> über seriell, I2C
  -- <Min_Wasser>, <Max_Wasser>  über I2C
  -- <Debug_ausgabe:1>  seriell
Version 1.0.3:
  -- umbau Serielle Schnittstelle
Version 1.0.4:
  -- Automatik aus
  -- Handbetrieb
  -- Min_Wasser blockiert den Pumpen ein befehl
Version 1.0.6:
  -- Timer einbauen statt delay
  -- auf unsigned long myTimer;  // Sonst gibt es Probleme --
Version 1.0.7:
  -- Struct Befehle einbauen
  -- Serial.println(F("  ... "));  und Serial.print(F(" ... "));   -- zur Reduzierung des globalrn Speicherplatzes
Version 1.0.8:
  -- I2c Befehle eingebaut
Version 1.0.9:
  -- Eingänge mit Pullup Widerständen versehen
    pinMode(Wasser_min_port,INPUT_PULLUP);
    pinMode(Wasser_max_port,INPUT_PULLUP);
    pinMode(Handbetrieb_port,INPUT_PULLUP);
    pinMode(Automatik_port,INPUT_PULLUP);
Version 1.0.10:
    Ventil 1 und 2  D10, D11
Version 1.0.11:
  void recvWithStartEndMarkers_I2c_seriell(char startMarker, char endMarker, char erkennung) {
  // Soll die beiden verbinden: recvWithStartEndMarkers, recvWithStartEndMarkers_I2c
  ----------  noch offen 
        const byte numChars = 30;  // Anzahl der maximalen Zeichen im String
        const byte numStrings = 10;
        char ReceivedChars[numChars];
        char TempChars[numChars];  // temporary array for use when parsing
        char ReceivedChars_i2c[numChars];
        char TempChars_i2c[numChars];  // temporary array for use when parsing
        ------------  ersetzten
************  OFFEN  
  --  Testfunktionen über Serielle Schnitstelle und i2c einbinden

  --  Pumpe, Ventil eigenen Funktion
  --  Pumpe Ventil option2 lokal und MQTT
  --  Pumpe und Ventil ,müssen beode lokal ausgegeben werden ( Steuersignal)
  --  
  --  Zeitsteuerung Pumpe
*/
#include <Wire.h>

String Prog_Titel ="Bewaesserung_Slave";
String Prog_Version ="1.0.11";
String Prog_Datum ="06.08.2023";


#define trigger 3 // Arduino Pin an HC-SR04 Trig
#define echo 2    // Arduino Pin an HC-SR04 Echo
int getEntfernungGD();
int getEntfernung();
int Wasserstand=0;

int ADC_port_1 = A0;  // ADC Port (ESP hat nur 1 Port)
int ADC_port_2 = A1;  // ADC Port (ESP hat nur 1 Port)
int ADC_port_3 = A2;  // ADC Port (ESP hat nur 1 Port)
int ADC_port_4 = A3;  // ADC Port (ESP hat nur 1 Port)

struct Sensor
{
  int Sensor_num;
  float Wert;
  float Mittelwert;
  float Mittel[15];
  bool min_erreicht;
  bool min_erreicht_merk;
  bool max_erreicht;
  bool max_erreicht_merk;
};


int SENS_1_Min =  500;
int SENS_1_Max  = 800; 

const int Max_Sensor= 4;
struct Sensor Sensor_Daten[Max_Sensor] = 
{
  // Sensoren_num,Wert,Mittelwert,float Mittel[15];min_erreicht;min_erreicht_merk;max_erreicht;max_erreicht_merk;
  { 1,0,0,{0,0,0,0,0,0,0,0,0,0,0,0},false,false,false,false},
  { 2,0,0,{0,0,0,0,0,0,0,0,0,0,0,0},false,false,false,false},
  { 3,0,0,{0,0,0,0,0,0,0,0,0,0,0,0},false,false,false,false},  
  { 4,0,0,{0,0,0,0,0,0,0,0,0,0,0,0},false,false,false,false} 
};


int Handbetrieb_port = 7 ;
int Automatik_port = 8 ;
boolean Max_Wasser= false;
boolean Min_Wasser= false; 
int Pumpe_port = 4 ;//7; // D4;
bool Wasser_min_erreicht = 0;
int Wasser_min_port = 5; // D5;
bool Wasser_max_erreicht = 0;
int Wasser_max_port = 6; //D6;

int Ventil_1_port = 10; // D10;
int Ventil_2_port = 11; // D11;
void Pumpensteuerung(bool &bef_Pumpe, bool &Pumpe_zuszand, bool &Pumpe_merk,bool &Feuchte_1_max, bool &Feuchte_2_max,bool &Handbetrieb, bool &Test, bool &Ventil_1, bool &Ventil_2, bool &Wasser_min );


// Timer
struct Timer
{
  unsigned long myTimer;   // aktuelle Stand
  unsigned myTimeout;  // Timerzeit
 };

struct Timer MW_sensor_1_Takt ={0, 10000 };  // in welchen Takt soll der Messwert eingelesen werden
struct Timer Mld_1_Takt ={0, 20000 };  // in welchen Takt soll der Messwert eingelesen werden
struct Timer Mld_2_Takt ={0, 20000 };  // in welchen Takt soll der Messwert eingelesen werden
struct Timer Mld_3_Takt ={0, 20000 };  // in welchen Takt soll der Messwert eingelesen werden


 struct Befehle
{
  int Befehl_num;
  String Name;
  bool Hand_ein;  // 1= ein
  bool Test_ein; //  1= ein
  bool BEF_EIN;  // 1= Befehl ein geschickt
  bool BEF_AUS;  // 1= Befehl aus geschickt
  bool Bef_EIN_ausfuehren;  // wenn bedienung erfüllt, wird auf 1 gesetzt, erst bei bEfehlsausführung wird auf 0 gesetzt
  bool Bef_AUS_ausfuehren;  // wenn bedienung erfüllt, wird auf 1 gesetzt, erst bei bEfehlsausführung wird auf 0 gesetzt
  bool Zustand_EIN_AUS;  // falls Rückmeldung vorhanden wird dies mit der Rückmeldung auf  gesetzt, bzw. nach dem Befehl senden
  bool Merk_EIN_AUS;  // Merker der den letzten Zustand noch weiß, um nicht ständig einen Befehl rauszuschicken
  bool Ausgabe_lokal_MQTT;  // Ausgabe des Befehls über MQTT oder über lokale Hardware
  unsigned long BEF_Zeit;  // Ausgabezeit eines Befehls
  unsigned long  BEF_Zeit_akt;  // beinhaltet die aktuelle Zeit
} ;

const int Max_Befehle= 5;

struct Befehle Befehl_Daten[Max_Befehle] = 
{
  // Nummer, Name, Hand_ein, Test_ein , BEF_EIN, BEF_AUS, Bef_EIN_ausführen, Bef_AUS_ausführen,Zustand_EIN,Zustand_AUS,Merk_EIN,Merk_AUS,BEF_Zeit;
  { 0,"Pumpe_1"    ,0,0,0,0,0,0,0,0,1,20000,0},
  { 1,"Handbetrieb",0,0,0,0,0,0,0,0,1,1000,0},
  { 2,"Automatik"  ,0,0,0,0,0,0,0,0,1,1000,0},
  { 3,"Ventil_1",0,0,0,0,0,0,0,0,1,1000,0},
  { 4,"Ventil_2"  ,0,0,0,0,0,0,0,0,1,1000,0}
};

void Info_Var();
void Sensor_zuweisen(String words[0],String Name);
// 1_0_11 void recvWithStartEndMarkers(char startMarker, char endMarker);
// 1_0_11 void recvWithStartEndMarkers_I2c(char startMarker, char endMarker);
void recvWithStartEndMarkers_I2c_seriell(char startMarker, char endMarker, char erkennung); // 1_0_11
void parseData(String Quelle);
void showParsedData();
void auswerten_und_zuweisen_Variablen_werte(String words[]);

// ### serielle Eingabe von Befehlen
const byte numChars = 30;  // Anzahl der maximalen Zeichen im String
const byte numStrings = 10;
char ReceivedChars[numChars];
char TempChars[numChars];  // temporary array for use when parsing
char ReceivedChars_i2c[numChars];
char TempChars_i2c[numChars];  // temporary array for use when parsing

// variables to hold the parsed data

char messageFromPC[numChars] = { 0 };  // hier steht der String, bis zum ":" , wenn kein : dann der Ganze als String
int integerFromPC = 0;                // erster Wert nach dem Doppelpunkt als Integer
float floatFromPC = 0.0;              // zweiter Wert nach dem Doppelpunkt als Float
char messageFromPC_i2c[numChars] = { 0 };  // hier steht der String, bis zum ":" , wenn kein : dann der Ganze als String
int integerFromPC_i2c = 0;                // erster Wert nach dem Doppelpunkt als Integer
float floatFromPC_i2c = 0.0;   

String titel= "";

bool newData = false;
bool newData_i2c = false;
bool Info_Variablen = false;
bool debug_ausgabe = true;

void setup() {
  Wire.begin(8);                /* join i2c bus with address 8 */
  Wire.onReceive(receiveEvent); /* register receive event */
  Wire.onRequest(requestEvent); /* register request event */
  Serial.begin(9600);           /* start serial for debug */
  // Ultraschall
  pinMode(trigger, OUTPUT);
  pinMode(echo, INPUT);
  digitalWrite(trigger, HIGH); //Signal abschalten
  pinMode(Pumpe_port,OUTPUT);
  pinMode(Ventil_1_port,OUTPUT);
  pinMode(Ventil_2_port,OUTPUT);
  pinMode(Wasser_min_port,INPUT_PULLUP);
  pinMode(Wasser_max_port,INPUT_PULLUP);
  pinMode(Handbetrieb_port,INPUT_PULLUP);
  pinMode(Automatik_port,INPUT_PULLUP);
  int entfernung=getEntfernung();
  int mittelwert= getEntfernungGD();
  Wasserstand = entfernung;
  Wasser_min_erreicht=digitalRead(!Wasser_min_port);
 
  Wasser_max_erreicht=digitalRead(!Wasser_max_port);
  ///Pumpe in einen definierten Zustand bringen
  Befehl_Daten[0].BEF_AUS =1;  // Pumpe wird ausgeschaltet, falls noch ein
  // Automatik aus  in einen definierten Zustand bringen
  Befehl_Daten[2].Merk_EIN_AUS = 0;
  Befehl_Daten[2].Zustand_EIN_AUS = 0;
  // Handbetrieb aus  in einen definierten Zustand bringen
  Befehl_Daten[1].Merk_EIN_AUS = 0;
  Befehl_Daten[1].Zustand_EIN_AUS = 0;
}

void loop() {
  recvWithStartEndMarkers_I2c_seriell('<', '>', 'S'); // 1_0_11
  // 1_0_11 recvWithStartEndMarkers('<', '>');  // hiere wird geprüft ob ein Befehl eingegeben
  if (  newData== true) {
     if (debug_ausgabe == true) { Serial.println(F("in newData == true: "));}
     //Serial.print (" ReceivedChars: ");Serial.println (ReceivedChars);
     strcpy(TempChars, ReceivedChars);
     //Serial.print (" TempChars: ");Serial.println (TempChars);
     // this temporary copy is necessary to protect the original data
     //   because strtok() used in parseData() replaces the commas with \0
     parseData("Seriell");
     parseData_zuweisen();
     showParsedData();
     newData = false;
     //split_string(messageFromPC, ",");
  }
  
  if (millis() > MW_sensor_1_Takt.myTimer + MW_sensor_1_Takt.myTimeout) {
    MW_sensor_1_Takt.myTimer = millis();
    //Serial.print("MW_sensor_1_Takt_erreicht: ");Serial.println(MW_sensor_1_Takt.myTimer );
    //Serial.print("MW_sensor_1_Takt.myTimer + MW_sensor_1_Takt.myTimeout: ");Serial.println(MW_sensor_1_Takt.myTimer + MW_sensor_1_Takt.myTimeout );

 
    Sensor_Daten[1].Wert = sensor_v1(ADC_port_1);
    Serial.print(F("Sensor_1______: ")); Serial.println(Sensor_Daten[1].Wert, 1);
    Sensor_Daten[1].Mittelwert =  Mittelwertbildung(Sensor_Daten[1].Mittel,&Sensor_Daten[1].Wert);
    Serial.print(F("Sensor_1_Mittelwert: ")); Serial.println(Sensor_Daten[1].Mittelwert, 1);       
    min_max_bildung(Sensor_Daten[1].Mittelwert ,SENS_1_Min, SENS_1_Max, Sensor_Daten[1].max_erreicht);



    int entfernung=getEntfernung();
    int mittelwert= getEntfernungGD();
    Wasserstand = entfernung;
    Serial.write("Entfernung:");
    Serial.print(entfernung, DEC) ;
    Serial.write(" , Mittelwert (gewichtet): ");
    Serial.print(mittelwert, DEC) ;
    Serial.write(" cm\n");
    Wasser_min_erreicht=!digitalRead(Wasser_min_port);
    //if (debug_ausgabe == true) {Serial.print("+++++++++++++Wasser_min_erreicht: ");Serial.println(Wasser_min_erreicht);}

    Wasser_max_erreicht=!digitalRead(Wasser_max_port);
    // if (debug_ausgabe == true) {Serial.print("+++++++++++++Wasser_max_erreicht: ");Serial.println(Wasser_max_erreicht);}
    //Pumpensteuerung(Bef_Pumpe_ein, Pumpe_ein, Pumpe_ein_merk,Sensor_Daten[1].max_erreicht, Sensor_Daten[1].max_erreicht,Pumpe_Handbetrieb, Pumpe_ein_test, Ventil_1_ein,Ventil_2_ein, Wasser_min_erreicht ) ;
    // if (debug_ausgabe) {Serial.print("+++++Wasser_min_erreicht: ");Serial.println(Wasser_min_erreicht);}
  }
  //****
  // int Befehl_num;
  //   String Name;
  //   bool Hand_ein;  // 1= ein
  //   bool Test_ein; //  1= ein
  //   bool BEF_EIN;  // 1= Befehl ein geschickt
  //   bool BEF_AUS;  // 1= Befehl aus geschickt
  //   bool Bef_EIN_ausfuehren;  // wenn bedienung erfüllt, wird auf 1 gesetzt, erst bei bEfehlsausführung wird auf 0 gesetzt
  //   bool Bef_AUS_ausfuehren;  // wenn bedienung erfüllt, wird auf 1 gesetzt, erst bei bEfehlsausführung wird auf 0 gesetzt
  //   bool Zustand_EIN_AUS;  // falls Rückmeldung vorhanden wird dies mit der Rückmeldung auf  gesetzt, bzw. nach dem Befehl senden
  //   bool Merk_EIN_AUS;  // Merker der den letzten Zustand noch weiß, um nicht ständig einen Befehl rauszuschicken
  //   int BEF_Zeit;  // Ausgabezeit eines Befehls
  //   bool Ausgabe_lokal_MQTT;  // Au

  //   struct Befehle Befehl_Daten[Max_Befehle] = 
  //++++
  if (digitalRead(Handbetrieb_port)) {
    Befehl_Daten[1].Zustand_EIN_AUS = 1;
  }
  //Befehl_Daten[1].Hand_ein = digitalRead(Handbetrieb_port);
  //Handbetrieb = digitalRead(Handbetrieb_port);
  if (digitalRead(Automatik_port)) {
    Befehl_Daten[2].Zustand_EIN_AUS = 1;
  }
  //Befehl_Daten[2].Hand_ein = digitalRead(Automatik_port);
  //if (Handbetrieb_merk != Handbetrieb )  {
  if (!Wasser_min_erreicht) {
    if (Befehl_Daten[0].Zustand_EIN_AUS) {
      //Serial.print("Befehl_Daten[0].Bef_AUS_ausfuehren:");Serial.println(Befehl_Daten[0].Zustand_EIN_AUS);
      Befehl_Daten[0].Bef_AUS_ausfuehren =1;
    }
    
  }
  // Pumpe nach einer gewissen Zeit wieder abschalten
  if (Befehl_Daten[0].Zustand_EIN_AUS) {

    //Serial.print(millis());Serial.print("  ");
    //Serial.println((Befehl_Daten[0].BEF_Zeit_akt+ Befehl_Daten[0].BEF_Zeit));
    //Serial.println(Befehl_Daten[0].BEF_Zeit);
    //Serial.println(Befehl_Daten[0].BEF_Zeit_akt);
    if (millis() > (Befehl_Daten[0].BEF_Zeit_akt + Befehl_Daten[0].BEF_Zeit)) {
      Serial.println(" Timer start");
      //Befehl_Daten[0].BEF_Zeit_akt = millis();
      Befehl_Daten[0].BEF_AUS= 1;   // Wenn die Zeit abgelaufen ist, wird Pumpe ausgeschalten
      Befehl_Daten[1].BEF_AUS= 1;   // Falls in Handbetrieb eingeschalten wurde, wird dieser auch beneendet
    }
  }
  // Pumpe ein_aus ***************************
  if (Befehl_Daten[0].BEF_EIN)  {  // Befehl Pumpe ein angekommen
    //Befehl_Daten[0].BEF_Zeit_akt = millis();
     Serial.print(millis());Serial.print("  ");Serial.println(Befehl_Daten[0].BEF_Zeit_akt+ Befehl_Daten[0].BEF_Zeit);
    Serial.println(Befehl_Daten[0].BEF_Zeit);
    Serial.println(F("Pumpe_EIN_Befehl_angekommen"));
    Serial.print(F("Pumpe_EIN_Befehl_angekommen zustand merk"));Serial.println(Befehl_Daten[0].Merk_EIN_AUS);
    if (!Befehl_Daten[0].Merk_EIN_AUS )  {  // wenn auf aus ist
    Serial.print(F("Pumpe_EIN_Befehl_angekommen vor Wasser: "));Serial.println(Wasser_min_erreicht);    

      if (Wasser_min_erreicht) {
          Serial.println(F("Pumpe_EIN_Befehl_angekommen nach Wasser: "));    

        Befehl_Daten[0].Bef_EIN_ausfuehren =1;  // Pumpe befehl auf ein gesetzt
        Befehl_Daten[1].Bef_EIN_ausfuehren = 1;   // auf Handbetrieb umschalten
        Befehl_Daten[2].Bef_AUS_ausfuehren =1;  // Automatik ausschalten
      }
      
    }
    Befehl_Daten[0].BEF_EIN = 0;   // Befehl zurücksetzen
  }
  if (Befehl_Daten[0].BEF_AUS)  {  // Befehl Pumpe aus angekommen
  Serial.println(F("Pumpe_AUS_Befehl_angekommen"));
    // Handbetrieb wurde ausgeschalten
    // Pumpe ausschalten, Automatik einschalten
    Befehl_Daten[0].Bef_AUS_ausfuehren =1;  // Pumpe befehl auf ein gesetzt
    Befehl_Daten[2].Bef_EIN_ausfuehren =1;  // Automatik einschalten
    Serial.print(F("Pumpe_AUS:"));  Serial.println(Befehl_Daten[0].Hand_ein);
    Befehl_Daten[0].BEF_AUS = 0;   // Befehl zurücksetzen
  }

// Ventil ein_aus ***************************

   if (Befehl_Daten[3].BEF_EIN)  {  // Befehl Ventil1 ein angekommen
    //Befehl_Daten[0].BEF_Zeit_akt = millis();
    Serial.println(F("Ventil1_EIN_Befehl_angekommen"));
    Serial.print(F("Ventil1_EIN_Befehl_angekommen zustand merk: "));Serial.println(Befehl_Daten[3].Merk_EIN_AUS);
    if (!Befehl_Daten[3].Merk_EIN_AUS )  {  // wenn auf aus ist
      Serial.print(F("Ventil1_EIN_Befehl_angekommen: "));
      Befehl_Daten[3].Bef_EIN_ausfuehren =1;  // Ventil1 befehl auf ein gesetzt
    }
    Befehl_Daten[3].BEF_EIN = 0;   // Befehl zurücksetzen
  }
  if (Befehl_Daten[3].BEF_AUS)  {  // Befehl Ventil1 aus angekommen
    Serial.println(F("Ventil1_AUS_Befehl_angekommen"));
    Befehl_Daten[3].Bef_AUS_ausfuehren =1;  // Ventil1 befehl auf ein gesetzt
    Serial.print(F("Ventil1_AUS: "));  Serial.println(Befehl_Daten[3].Hand_ein);
    Befehl_Daten[3].BEF_AUS = 0;   // Befehl zurücksetzen
  }
   if (Befehl_Daten[4].BEF_EIN)  {  // Befehl Ventil2 ein angekommen
    //Befehl_Daten[0].BEF_Zeit_akt = millis();
    Serial.println(F("Ventil2_EIN_Befehl_angekommen"));
    Serial.print(F("Ventil2_EIN_Befehl_angekommen zustand merk"));Serial.println(Befehl_Daten[4].Merk_EIN_AUS);
    if (!Befehl_Daten[4].Merk_EIN_AUS )  {  // wenn auf aus ist
      Serial.print(F("Ventil2_EIN_Befehl_angekommen: "));
      Befehl_Daten[4].Bef_EIN_ausfuehren =1;  // Ventil2 befehl auf ein gesetzt
    }
    Befehl_Daten[4].BEF_EIN = 0;   // Befehl zurücksetzen
  }
  if (Befehl_Daten[4].BEF_AUS)  {  // Befehl Ventil2 aus angekommen
    Serial.println(F("Ventil2_AUS_Befehl_angekommen"));
    Befehl_Daten[4].Bef_AUS_ausfuehren =1;  // Ventil2 befehl auf ein gesetzt
    Serial.print(F("Ventil2_AUS: "));  Serial.println(Befehl_Daten[3].Hand_ein);
    Befehl_Daten[4].BEF_AUS = 0;   // Befehl zurücksetzen
  }

// Handbetrieb
  if (Befehl_Daten[1].BEF_EIN)  {  // Befehl Hand ein angekommen
    Serial.println(F("Hand_EIN_Befehl_angekommen"));

    Serial.print(F("Hand_EIN_Befehl_angekommen zustand merk: "));Serial.println(Befehl_Daten[1].Merk_EIN_AUS);    
    if (!Befehl_Daten[1].Merk_EIN_AUS )  {  // wenn auf aus ist
    Serial.print(F("Hand_EIN_Befehl_angekommen vor Wasser: "));Serial.println(Wasser_min_erreicht);    
      
      if (Wasser_min_erreicht) {
        Befehl_Daten[0].Bef_EIN_ausfuehren =1;  // Pumpe befehl auf ein gesetzt
        Befehl_Daten[1].Bef_EIN_ausfuehren = 1;   // auf Handbetrieb umschalten
        Befehl_Daten[2].Bef_AUS_ausfuehren =1;  // Automatik ausschalten
        Serial.println(F("Hand_EIN_Befehl_angekommen + Wasser min"));
      }      
    }
    Befehl_Daten[1].BEF_EIN = 0;   // Befehl zurücksetzen 
  }
   
  // Automatik Ein -- Aus ****************
  
  if (Befehl_Daten[2].BEF_EIN)  {  //Befehl kommt an
    Serial.println(F("Automatik_EIN_Befehl_angekommen"));
    if (Befehl_Daten[2].Merk_EIN_AUS != 1) { // Vergleich Merker ob nicht schon da
      Serial.println(F("Automatik_EIN_Befehl_nach Merker"));
      Befehl_Daten[2].Bef_EIN_ausfuehren =1; //Auto Befehl ein ausführen
      Befehl_Daten[1].Bef_AUS_ausfuehren =0; //Hand Bef_aus ausführen
      Befehl_Daten[0].Bef_AUS_ausfuehren =1;  // Pumpe wird ausgeschaltet, falls noch ein
      
    }
    Befehl_Daten[2].BEF_EIN = 0;   // Befehl zurücksetzen
  } else if (Befehl_Daten[2].BEF_AUS)  {  //Befehl kommt an
    Serial.print(F("Automatik_AUS_Befehl_angekommen:"));  
    if (Befehl_Daten[2].Merk_EIN_AUS) { // Vergleich Merker ob nicht schon da
      Befehl_Daten[2].Bef_AUS_ausfuehren =1; //Auto Befehl ein ausführen
      
    }
    Befehl_Daten[2].BEF_AUS = 0;   // Befehl zurücksetzen
  }
   //  Automatik ein und Handbetrieb ein !!!!  darf nicht sein
  if ((Befehl_Daten[1].Merk_EIN_AUS == 1) && (Befehl_Daten[2].Merk_EIN_AUS == 1)){
    Serial.println(F("Automatik_&& Hand:")); 
    Befehl_Daten[1].Merk_EIN_AUS = 0;
    Befehl_Daten[2].Merk_EIN_AUS = 0;
    Befehl_Daten[1].Zustand_EIN_AUS = 0;
    Befehl_Daten[2].Zustand_EIN_AUS = 0;
  }
//*****************************************************************


// Befehle ausführen

  if (Befehl_Daten[1].Bef_EIN_ausfuehren) {  // Handbetrieb einschalten
    Serial.println(F("HAND_EIN_Befehl_ausgeführt"));
    Befehl_Daten[1].Zustand_EIN_AUS = 1;   // Rückmeldung auf ein setzen
    Befehl_Daten[1].Bef_EIN_ausfuehren = 0;  // Ausführbefehl zurücksetzen
    Befehl_Daten[1].Merk_EIN_AUS = 1;
    Befehl_Daten[2].Zustand_EIN_AUS = 0;
    Befehl_Daten[2].Merk_EIN_AUS = 0;
  }
   if (Befehl_Daten[1].Bef_AUS_ausfuehren) {  // Handbetrieb ausschalten
    Serial.println(F("HAND_AUS_Befehl_ausgeführt"));
    Befehl_Daten[1].Zustand_EIN_AUS = 0;   // Rückmeldung auf aus setzen
    Befehl_Daten[1].Bef_AUS_ausfuehren = 0;  // Ausführbefehl zurücksetzen
    Befehl_Daten[1].Merk_EIN_AUS = 0;
  }
  if (Befehl_Daten[0].Bef_EIN_ausfuehren) {  // Pumpe einschalten
    Serial.println(F("PUMPE_EIN_Befehl_ausgeführt"));
    Befehl_Daten[0].BEF_Zeit_akt = millis();
    digitalWrite(Pumpe_port,HIGH);
    Befehl_Daten[0].Zustand_EIN_AUS = 1;   // Rückmeldung auf ein setzen
    Befehl_Daten[0].Bef_EIN_ausfuehren = 0;  // Ausführbefehl zurücksetzen
    Befehl_Daten[0].Merk_EIN_AUS = 1;
  }
  if (Befehl_Daten[0].Bef_AUS_ausfuehren) {  // Pumpe einschalten
    Serial.println(F("PUMPE_AUS_Befehl_ausgeführt"));
    digitalWrite(Pumpe_port,LOW);
    Befehl_Daten[0].Zustand_EIN_AUS = 0;   // Rückmeldung auf ein setzen
    Befehl_Daten[0].Bef_AUS_ausfuehren = 0;  // Ausführbefehl zurücksetzen
    Befehl_Daten[0].Merk_EIN_AUS = 0;
  }
  if (Befehl_Daten[2].Bef_EIN_ausfuehren) {  // Pumpe einschalten
    Serial.println(F("AUTOMATIK_EIN_Befehl_ausgeführt"));
    Befehl_Daten[2].Zustand_EIN_AUS = 1;   // Rückmeldung auf ein setzen
    Befehl_Daten[2].Bef_EIN_ausfuehren = 0;  // Ausführbefehl zurücksetzen
    Befehl_Daten[2].Merk_EIN_AUS = 1;
    Befehl_Daten[1].Zustand_EIN_AUS = 0;
    Befehl_Daten[1].Merk_EIN_AUS = 0;
  }
  if (Befehl_Daten[2].Bef_AUS_ausfuehren) {  // Pumpe einschalten
    Serial.println(F("AUTOMATIK_AUS_Befehl_ausgeführt"));
    Befehl_Daten[2].Zustand_EIN_AUS = 0;   // Rückmeldung auf ein setzen
    Befehl_Daten[2].Bef_AUS_ausfuehren = 0;  // Ausführbefehl zurücksetzen
    Befehl_Daten[2].Merk_EIN_AUS = 0;
  }

  if (Befehl_Daten[3].Bef_EIN_ausfuehren) {  // Ventil1 einschalten
    Serial.println(F("Ventil1_EIN_Befehl_ausgeführt"));
    digitalWrite(Ventil_1_port,HIGH);
    Befehl_Daten[3].Zustand_EIN_AUS = 1;   // Rückmeldung auf ein setzen
    Befehl_Daten[3].Bef_EIN_ausfuehren = 0;  // Ausführbefehl zurücksetzen
    Befehl_Daten[3].Merk_EIN_AUS = 1;
  }
  if (Befehl_Daten[3].Bef_AUS_ausfuehren) {  // Ventil1 einschalten
    Serial.println(F("Ventil1_AUS_Befehl_ausgeführt"));
    digitalWrite(Ventil_1_port,LOW);
    Befehl_Daten[3].Zustand_EIN_AUS = 0;   // Rückmeldung auf ein setzen
    Befehl_Daten[3].Bef_AUS_ausfuehren = 0;  // Ausführbefehl zurücksetzen
    Befehl_Daten[3].Merk_EIN_AUS = 0;
  }
 
  if (Befehl_Daten[4].Bef_EIN_ausfuehren) {  // Ventil2 einschalten
    Serial.println(F("Ventil2_EIN_Befehl_ausgeführt"));
    digitalWrite(Ventil_2_port,HIGH);
    Befehl_Daten[4].Zustand_EIN_AUS = 1;   // Rückmeldung auf ein setzen
    Befehl_Daten[4].Bef_EIN_ausfuehren = 0;  // Ausführbefehl zurücksetzen
    Befehl_Daten[4].Merk_EIN_AUS = 1;
  }
  if (Befehl_Daten[4].Bef_AUS_ausfuehren) {  // Ventil2 einschalten
    Serial.println(F("Ventil2_AUS_Befehl_ausgeführt"));
    digitalWrite(Ventil_2_port,LOW);
    Befehl_Daten[4].Zustand_EIN_AUS = 0;   // Rückmeldung auf ein setzen
    Befehl_Daten[4].Bef_AUS_ausfuehren = 0;  // Ausführbefehl zurücksetzen
    Befehl_Daten[4].Merk_EIN_AUS = 0;
  }
  // if (digitalRead(Pumpe_port)) {
  //   Befehl_Daten[2].Zustand_EIN_AUS = 1;
  // }
  //Befehl_Daten[2].Zustand_EIN_AUS =digitalRead(Pumpe_port);
  //if (debug_ausgabe == true) {Serial.println(digitalRead(Pumpe_port));}
  //if (debug_ausgabe == true) {Serial.print("PPPPPPPPPPumpe_Zustand: ");Serial.println(Befehl_Daten[2].Zustand_EIN_AUS);}
}

// function that executes whenever data is received from master
void receiveEvent(int howMany) {
  //I2C Empänger
  if (debug_ausgabe == true) {Serial.print(F("howMany:"));Serial.println(howMany); }
//  while (0 <Wire.available()) {
//     char c = Wire.read();      /* receive byte as a character */
//     Serial.print(c);           /* print the character */
//   }
    //************
  // 1_0_11 static byte ndx_i2c = 0;
  recvWithStartEndMarkers_I2c_seriell('<', '>', 'I'); // 1_0_11
  // 1_0_11 recvWithStartEndMarkers_I2c('<', '>');  // hier wird geprüft ob ein Befehl eingegeben
  //if (debug_ausgabe == true) {Serial.print(F("ReceivedChars_i2c:  ")); Serial.println(ReceivedChars_i2c);}
  
  if ( newData_i2c == true) {
    //if (debug_ausgabe == true) { Serial.println("in newData_i2c == true: ");}
    //if (debug_ausgabe == true) {Serial.print("ReceivedChars_i2c: ");Serial.println(String(ReceivedChars_i2c).length());}
    strcpy(TempChars_i2c, ReceivedChars_i2c);
    //if (debug_ausgabe == true) {Serial.print (" TempChars_i2c: ");Serial.println (TempChars_i2c);}
    // this temporary copy is necessary to protect the original data
    //   because strtok() used in parseData() replaces the commas with \0
    //parseData("I2C");
    // parseData_zuweisen();
    //showParsedData();
    // newData_i2c = false;
    // split_string(messageFromPC, ",");
  // 1_0_11 ndx_i2c=0;
  }

  //******************************
 if (debug_ausgabe == true) {Serial.println();  }           /* to newline */
}

// function that executes whenever data is requested from master
void requestEvent() {
  //if (debug_ausgabe == true) {Serial.print (" requestEvent: ");Serial.println (Wasserstand);}
  //snprintf(TempChars_i2c,31,"<Wasserstand:%d>",Wasserstand); 
  // "The %d burritos are %s degrees F", numBurritos, tempStr
  Serial.println(F("empfangenen_daten:" ));Serial.println(ReceivedChars_i2c);
  //Wire.write("<Hello NodeMCU Willi>");  /*send string on request */
  if (strcmp(ReceivedChars_i2c, "Wasserstand") == 0) {
   snprintf(TempChars_i2c,31,"<%d>",Wasserstand);
   //Serial.println (strcmp(ReceivedChars_i2c, "Wasserstand") == 0);
   Wire.write(TempChars_i2c);  /*send string on request */


   //***
  } else if (strcmp(ReceivedChars_i2c, "Sensor_1") == 0) {
    snprintf(TempChars_i2c,31,"<%d>",Sensor_Daten[1].Mittelwert);
    Wire.write(TempChars_i2c);  /*send string on request */
    Serial.println(F("Sensor_1: angekommen"));
  } else if (strcmp(ReceivedChars_i2c, "Sensor_2") == 0) {
    snprintf(TempChars_i2c,31,"<%d>",Sensor_Daten[2].Mittelwert);
    Wire.write(TempChars_i2c);  /*send string on request */
    Serial.println(F("Sensor_2: angekommen"));
  } else if (strcmp(ReceivedChars_i2c, "Sensor_3") == 0) {
    snprintf(TempChars_i2c,31,"<%d>",Sensor_Daten[3].Mittelwert);
    Wire.write(TempChars_i2c);  /*send string on request */
    Serial.println(F("Sensor_3: angekommen"));

  } else if (strcmp(ReceivedChars_i2c, "Min_Wasser") == 0) {
    snprintf(TempChars_i2c,31,"<%d>",Wasser_min_erreicht);
    Wire.write(TempChars_i2c);  /*send string on request */
    Serial.println(F("Min_wasser: angekommen"));
  } else if (strcmp(ReceivedChars_i2c, "Max_Wasser") == 0) {
    snprintf(TempChars_i2c,31,"<%d>",Wasser_max_erreicht);

    Wire.write(TempChars_i2c);  /*send string on request */
    Serial.println(F("Max_wasser: angekommen"));


  } else if (strcmp(ReceivedChars_i2c, "Pumpe_bef_ein") == 0) {
    Befehl_Daten[0].BEF_EIN =1;
      /*send string on request */
    snprintf(TempChars_i2c,31,"verstanden");
    Wire.write(TempChars_i2c);
    Serial.println(F("Pumpe_bef_ein: angekommen"));
  } else if (strcmp(ReceivedChars_i2c, "Pumpe_bef_aus") == 0) {
    Befehl_Daten[0].BEF_AUS=1;
    snprintf(TempChars_i2c,31,"verstanden");
    Wire.write(TempChars_i2c); /*send string on request */
    Serial.println(F("Pumpe_bef_aus: angekommen"));
  } else if (strcmp(ReceivedChars_i2c, "Pumpe_Zustand") == 0) {
    snprintf(TempChars_i2c,31,"<%d>",Befehl_Daten[0].Zustand_EIN_AUS);
    Wire.write(TempChars_i2c);  /*send string on request */
    Serial.println(F("Pumpe_Zustand: angekommen"));

  } else if (strcmp(ReceivedChars_i2c, "Ventil_1_bef_ein") == 0) {
    //snprintf(TempChars_i2c,31,"<%d>",Bef_Pumpe_ein);
    Befehl_Daten[3].BEF_EIN=1;
    snprintf(TempChars_i2c,31,"verstanden");
    Wire.write(TempChars_i2c);
    Serial.println(F("Ventil_1_bef_ein: angekommen"));
  } else if (strcmp(ReceivedChars_i2c, "Ventil_1_bef_aus") == 0) {
    //snprintf(TempChars_i2c,31,"<%d>",Bef_Pumpe_ein);
    Befehl_Daten[3].BEF_AUS=1;
    snprintf(TempChars_i2c,31,"verstanden");
    Wire.write(TempChars_i2c);
    Serial.println(F("Ventil1_bef_aus: angekommen"));
  } else if (strcmp(ReceivedChars_i2c, "Ventil1_Zustand") == 0) {
    snprintf(TempChars_i2c,31,"<%d>",Befehl_Daten[3].Zustand_EIN_AUS);
    Wire.write(TempChars_i2c);  /*send string on request */
    Serial.println(F("Ventil1_Zustand: angekommen"));

  } else if (strcmp(ReceivedChars_i2c, "Ventil_2_bef_ein") == 0) {
    Befehl_Daten[4].BEF_EIN=1;
    snprintf(TempChars_i2c,31,"verstanden");
    Wire.write(TempChars_i2c);
    Serial.println(F("Ventil2_bef_ein: angekommen"));
  } else if (strcmp(ReceivedChars_i2c, "Ventil_2_bef_aus") == 0) {
    Befehl_Daten[4].BEF_AUS=1;
    snprintf(TempChars_i2c,31,"verstanden");
    Wire.write(TempChars_i2c);
    //Wire.write(TempChars_i2c);  /*send string on request */
    Serial.println(F("Ventil2_bef_aus: angekommen"));
  } else if (strcmp(ReceivedChars_i2c, "Ventil2_Zustand") == 0) {
    snprintf(TempChars_i2c,31,"<%d>",Befehl_Daten[4].Zustand_EIN_AUS);
    Wire.write(TempChars_i2c);  /*send string on request */
    Serial.println(F("Ventil2_Zustand: angekommen"));

  } else if (strcmp(ReceivedChars_i2c, "Bef_Pumpe_ausgabezeit:" + integerFromPC ) == 0) {
    // -1 bedeutet
    //snprintf(TempChars_i2c,31,"<%d>",Bef_Pumpe_ausgabezeit:);
    //Befehl_Daten[0].BEF_Zeit =1;
    snprintf(TempChars_i2c,31,"verstanden");
    Wire.write(TempChars_i2c);
    //Wire.write(TempChars_i2c);  /*send string on request */
    Serial.println(F("Bef_Pumpe_ausgabezeit: angekommen"));
  
  } else if (strcmp(ReceivedChars_i2c, "Bef_Handbetrieb_ein") == 0) {
    Befehl_Daten[1].BEF_EIN   =1;
    // snprintf(TempChars_i2c,31,"<%d>", Befehl_Daten[1].Bef_EIN_ausfuehren);
    // Wire.write(TempChars_i2c);  /*send string on request */
    snprintf(TempChars_i2c,31,"verstanden");
    Wire.write(TempChars_i2c);
    Serial.println(F("Handbetrieb: angekommen"));
  } else if (strcmp(ReceivedChars_i2c, "Bef_Automatik_ein") == 0) {
    Befehl_Daten[2].BEF_EIN   =1;
    snprintf(TempChars_i2c,31,"verstanden");
    Wire.write(TempChars_i2c);
    //snprintf(TempChars_i2c,31,"<%d>",Befehl_Daten[2].Zustand_EIN_AUS);
    //Wire.write(TempChars_i2c);  /*send string on request */
    Serial.println(F("Automatik rückmeldung: angekommen"));
  } else if (strcmp(ReceivedChars_i2c, "Bef_Automatik_aus") == 0) {
    Befehl_Daten[2].BEF_AUS = 1;
    snprintf(TempChars_i2c,31,"verstanden");
    Wire.write(TempChars_i2c);
    //snprintf(TempChars_i2c,31,"<%d>",Befehl_Daten[2].Zustand_EIN_AUS);
    //Wire.write(TempChars_i2c);  /*send string on request */
    Serial.println(F("Automatik rückmeldung: angekommen"));
  } else if (strcmp(ReceivedChars_i2c, "Automatik") == 0) {
    //Automatik_fern=false;
    snprintf(TempChars_i2c,31,"<%d>",Befehl_Daten[2].Zustand_EIN_AUS);
    Serial.println(TempChars_i2c);
    Wire.write(TempChars_i2c);
    Serial.println(F("Automatik: angekommen"));   
  } else if (strcmp(ReceivedChars_i2c, "Handbetrieb") == 0) {
    //Automatik_fern=false;
    snprintf(TempChars_i2c,31,"<%d>",Befehl_Daten[1].Zustand_EIN_AUS);
    Wire.write(TempChars_i2c);
    Serial.println(F("Handbetrieb: angekommen"));     

  } else {
    Serial.print ("was anderes angekommen: ");Serial.println (ReceivedChars_i2c);
  }
}


// Entfernung in cm über gewöhnlichen Ultraschallsensor mit Echo und Trigger messen
int getEntfernung(){ 
 
 long entfernung=0;
 long zeit=0;

 digitalWrite(trigger, LOW); 
 delayMicroseconds(3);
 noInterrupts();
 digitalWrite(trigger, HIGH); //Trigger Impuls 10 us
 delayMicroseconds(10);
 digitalWrite(trigger, LOW); 
 zeit = pulseIn(echo, HIGH); // Echo-Zeit messen
 interrupts(); 
 
 zeit = (zeit/2); // Zeit halbieren
 entfernung = zeit / 29.1; // Zeit in Zentimeter umrechnen
 //entfernung = entfernung + 20;
 return(entfernung); 
}



//Entfernung Gleitender Durchschnitt (gewichtet)
int getEntfernungGD(){ 
  int alt=0;
  int mittel;
  int entf;
  int i;

  delay(10);
  alt=getEntfernung();
  delay(10);
  for (i=0; i<10; i++)
  {
    entf=getEntfernung();
    mittel=(0.8*alt) + (0.2*entf);
    alt=mittel;
    delay(10);
  }
  return (mittel);
}

float sensor_v1(unsigned int ADC_port) {
  // Sensor_V1  =  ohne
  
  float t;
  float sensorValue = 0;
  sensorValue = analogRead(ADC_port);
  float berechneter_Wert = 0;
  if (debug_ausgabe == true) { Serial.print(F(" Sensor_wert: ")); Serial.println(sensorValue); }
  berechneter_Wert = sensorValue;
  return berechneter_Wert;
}

float Mittelwertbildung(float *MW_Werte, float *Wert){
  if (debug_ausgabe == true) {Serial.print(F("Mittelwertbildung:im Unterprogramm: "));}
  float Mittelwert = 0;
  //Serial.print(F("Wert:  "));Serial.println(*Wert);
  // Mittelwertbildung
/*  ich benötige bei temperatur und Helligkeit jeweils einen Wert zwei Werte in abständen
Diese müssen die Kriterien erfüllen um das Rollo auszulösen
Definieren:  Array_list mit den Messwerten ( alle min ein Wert addieren hinzufügen  
  immmer den letzen hinten rausschieben und den neuen schreiben
  aus allen den Mittelwert bilden  -- wenn der den grenzwert erreicht, wird eine Boole gesetzt
- bool Temp_mittel_erreicht
*/
  //int Anzahl_Werte = sizeof(MW_Werte)/ sizeof(float);
  // Serial.print(F(" sizeof(MW_Werte):  "));  Serial.println(sizeof(MW_Werte)); 
  // Serial.print(F(" sizeof(float):  "));  Serial.println(sizeof(sizeof(float))); 
  // Serial.print(F("Mittelwert: anzahl_Werte: "));Serial.println(Anzahl_Werte);
  for (int i = 1; i< 15; ++i) {
      MW_Werte[i-1] =MW_Werte[i];
      //Serial.println(MW_Werte[i]);
    }
    MW_Werte[15-1]= *Wert;
  for (int i = 0; i< 15; ++i) {
      MW_Werte[i-1] = MW_Werte[i];
      
      Mittelwert = Mittelwert + MW_Werte[i];
      // if (debug_ausgabe == true) {Serial.print(F("i:wert: Mittelwert_summe: "));Serial.print(i);}
      // if (debug_ausgabe == true) {Serial.print(F(" wert: "));MW_Werte[i];}
      // if (debug_ausgabe == true) {Serial.print(F(" Mittelwert_summe: "));Serial.print(Serial.println(Mittelwert));}
     
    }
  Serial.println(Mittelwert);  
  if (Mittelwert > 0){
    Mittelwert = Mittelwert/15;
  } else {
    Mittelwert = 0;
  }
  
  //if (debug_ausgabe == true) {Serial.print(F(" Mittelwert: "));Serial.print(Serial.println(Mittelwert));}

return Mittelwert;
}

void min_max_bildung(float wert,float Wert_max, float Wert_min,  bool &max) {
  if (int(wert) > Wert_max) {
      max = true;
    } else if (int(wert) < Wert_min) {
      max = false;
    }
}

void recvWithStartEndMarkers_I2c_seriell(char startMarker, char endMarker, char erkennung) {
  // Soll die beiden verbinden: recvWithStartEndMarkers, recvWithStartEndMarkers_I2c
  // Marker: char startMarker = '<'; char endMarker = '>';
  // char erkennung : I für I2c, S für Seriell
    //if (debug_ausgabe == true) { Serial.println(F("void recvWithStartEndMarkers_I2c_seriell")); }
  static boolean recvInProgress = false;
  static byte ndx = 0;
  char rc;
  
  if (erkennung == 'S') {
    while (Serial.available() > 0 && newData == false) {
      rc = Serial.read();
      if (debug_ausgabe == true) { Serial.println(String(rc)); }
      //if (debug_ausgabe == true) { Serial.println("Serial.available() > 0 && newData == false"); }
      if (recvInProgress == true) {
        if (rc != endMarker) {
          if (debug_ausgabe == true) { Serial.println(F("rc != endMarker")); }
          ReceivedChars[ndx] = rc;
          ndx++;
          if (ndx >= numChars) {
            ndx = numChars - 1;
          }
        } else {
          if (debug_ausgabe == true) { Serial.println(F("rc === endMarker")); }
          ReceivedChars[ndx] = '\0';  // terminate the string
          recvInProgress = false;
          ndx = 0;
          newData = true;
        }
      }

      else if (rc == startMarker) {
        recvInProgress = true;
      }
    }
  } else if (erkennung == 'I' ){
    while (Wire.available())  {
      //i2c_rcv = Wire.read();
      rc = Wire.read();
      //if (debug_ausgabe == true) { Serial.println(String(rc)); }
      //if (debug_ausgabe == true) { Serial.println(F("Serial.available() > 0 && newData_i2c == false")); }
      if (recvInProgress == true) {
        //Serial.print(F(" RC_i2c_empang:")); Serial.println( rc);
        if (rc != endMarker) {
          //if (debug_ausgabe == true) { Serial.println(F("rc != endMarker")); }
          ReceivedChars_i2c[ndx] = rc;
          ndx++;
          if (ndx >= numChars) {
            ndx = numChars - 1;
          }
        } else {
          if (debug_ausgabe == true) { Serial.println(F("rc === endMarker")); }
          ReceivedChars_i2c[ndx] = '\0';  // terminate the string
          recvInProgress = false;
          ndx = 0;
          newData_i2c = true;
        }
      } else if (rc == startMarker) {
        Serial.print(F(" startMarker:")); Serial.println( rc);
  
        recvInProgress = true;
      } else {
        Serial.print(F(" ????:")); Serial.println( rc);
  
      }
    }
  }

}

/*  1_0_11 void recvWithStartEndMarkers(char startMarker, char endMarker) {
  //if (debug_ausgabe == true) { Serial.println("void recvWithStartEndMarkers"); }
  static boolean recvInProgress = false;
  static byte ndx = 0;
  //char startMarker = '<';
  //char endMarker = '>';
  char rc;
  //char messageFromPC[numChars] = { 0 };  // hier steht der String, bis zum ":" , wenn kein : dann der Ganze als String
  integerFromPC = 0;     // zurücksetzen der Werte
  floatFromPC = 0.0;     // zurücksetzen der Werte

  while (Serial.available() > 0 && newData == false) {
    rc = Serial.read();
    //if (debug_ausgabe == true) { Serial.println(String(rc)); }
    //if (debug_ausgabe == true) { Serial.println("Serial.available() > 0 && newData == false"); }
    if (recvInProgress == true) {
      if (rc != endMarker) {
        //if (debug_ausgabe == true) { Serial.println("rc != endMarker"); }
        ReceivedChars[ndx] = rc;
        ndx++;
        if (ndx >= numChars) {
          ndx = numChars - 1;
        }
      } else {
        //if (debug_ausgabe == true) { Serial.println("rc === endMarker"); }
        ReceivedChars[ndx] = '\0';  // terminate the string
        recvInProgress = false;
        ndx = 0;
        newData = true;
      }
    }

    else if (rc == startMarker) {
      recvInProgress = true;
    }
  }
} 1_0_11 */


/*  1_0_11 void recvWithStartEndMarkers_I2c(char startMarker, char endMarker) {
  //if (debug_ausgabe == true) { Serial.println("void recvWithStartEndMarkers"); }
  static boolean recvInProgress_i2c = false;
  static byte ndx_i2c = 0;
  //char startMarker = '<';
  //char endMarker = '>';
  char rc;

  while (Wire.available())  {
    //i2c_rcv = Wire.read();
    rc = Wire.read();
    //if (debug_ausgabe == true) { Serial.println(String(rc)); }
    //if (debug_ausgabe == true) { Serial.println(F("Serial.available() > 0 && newData_i2c == false")); }
    if (recvInProgress_i2c == true) {
      //Serial.print(F(" RC_i2c_empang:")); Serial.println( rc);
      if (rc != endMarker) {
        //if (debug_ausgabe == true) { Serial.println(F("rc != endMarker")); }
        ReceivedChars_i2c[ndx_i2c] = rc;
        ndx_i2c++;
        if (ndx_i2c >= numChars) {
          ndx_i2c = numChars - 1;
        }
      } else {
        if (debug_ausgabe == true) { Serial.println(F("rc === endMarker")); }
        ReceivedChars_i2c[ndx_i2c] = '\0';  // terminate the string
        recvInProgress_i2c = false;
        ndx_i2c = 0;
        newData_i2c = true;
      }
    } else if (rc == startMarker) {
      Serial.print(F(" startMarker:")); Serial.println( rc);
 
      recvInProgress_i2c = true;
    } else {
      Serial.print(F(" ????:")); Serial.println( rc);
 
    }
  }
  

     //if (debug_ausgabe == true) { Serial.print("receivedChars1");Serial.println(ReceivedChars_i2c); }
 
}   1_0_11 */  


void parseData(String Quelle) {  // split the data into its parts
  //char buffer*;
  int uebrige_Zeichen;
  //uebrige_Zeichen= sizeof(ReceivedChars);
  //uebrige_Zeichen = String(ReceivedChars).length();
    //if (debug_ausgabe == true) {Serial.print(" TempChars  : ");Serial.println(TempChars);}
    //if (debug_ausgabe == true) {Serial.print(" uebrige_Zeichen = String(ReceivedChars).length();  : ");Serial.println(uebrige_Zeichen);}
    //if (debug_ausgabe == true) {Serial.print("länge von TempChars: ");Serial.println(String(TempChars).length());}
    if (debug_ausgabe == true) { Serial.println(F("void parseData ")); }
    int index = 0;
    
    //***** für I2C
    
    if (Quelle == "I2C") {
      
      strcpy(TempChars, TempChars_i2c);
      strcpy(ReceivedChars, ReceivedChars_i2c);
      Serial.println(TempChars);
      Serial.println(TempChars_i2c);
    }


    char* strtokIndx;  // this is used by strtok() as an index
    //if (debug_ausgabe == true) { Serial.print("länge von ReceivedChars: ");Serial.println(String(ReceivedChars).length());  }
    //if (debug_ausgabe == true) { Serial.print("ReceivedChars: ");Serial.println(ReceivedChars);  }
    strtokIndx = strtok(TempChars, ":");  // get the first part - the string
    uebrige_Zeichen= sizeof(strtokIndx);
    //if (debug_ausgabe == true) {Serial.print(" uebrige_Zeichen = String(strtokIndx).length();  : ");Serial.println(uebrige_Zeichen);}

    //if (debug_ausgabe == true) {Serial.print(" strtokIndx: ");Serial.println(strtokIndx);}
    //if (debug_ausgabe == true) { Serial.print("länge von TempChars: ");Serial.println(String(TempChars).length());  }
    uebrige_Zeichen = uebrige_Zeichen - 1 ;   // ein Zeichen für den :
    //if (debug_ausgabe == true) { Serial.print("uebrige_Zeichen:mmmm ");Serial.println(uebrige_Zeichen);  }
    int hilf_tempchar = 0;
    hilf_tempchar = String(TempChars).length();
    // if (debug_ausgabe == true) { Serial.print("hilf_tempchar: ");Serial.println(hilf_tempchar);  }
    // if (debug_ausgabe == true) {Serial.print(" strlen(TempChars) : ");Serial.println(strlen(TempChars));}
    // if (debug_ausgabe == true) {Serial.print(" strlen(ReceivedChars) : ");Serial.println(strlen(ReceivedChars));}
    uebrige_Zeichen = strlen(ReceivedChars) - 1 -  strlen(TempChars);   // ein Zeichen für den :
    //if (debug_ausgabe == true) { Serial.print("uebrige_Zeichen:nach: ");Serial.println(uebrige_Zeichen);  }




    if (strlen(TempChars)>0) {   // wenn der text vor dem : länger istals 0 --> dann gibt es einen Text
      strcpy(messageFromPC, strtokIndx);    // copy it to messageFromPC
      //strcpy(mystring_test, strtokIndx);
      // if (debug_ausgabe == true) { Serial.print("messageFromPC: ");Serial.println(messageFromPC);  }
      // if (debug_ausgabe == true) { Serial.print("länge von messageFromPC: ");Serial.println(String(messageFromPC).length());  }
     
      if (uebrige_Zeichen>0) { // dann gigt es Zeichen nnach dem :  --> Es gibt zumindest einen integer
        //if (debug_ausgabe == true) { Serial.print("uebrige_Zeichen>0 ");Serial.println(uebrige_Zeichen);  }
      
        strtokIndx = strtok(NULL, ",");    // this continues where the previous call left off
      //if (debug_ausgabe == true) {Serial.print(" strtokIndx: ");Serial.println(strtokIndx);}

        integerFromPC = atoi(strtokIndx);  // convert this part to an integer
        if (uebrige_Zeichen>0) {
          // if (debug_ausgabe == true) { Serial.print("uebrige_Zeichen>0 ");Serial.println(uebrige_Zeichen);  }
          // if (debug_ausgabe == true) { Serial.print("integerFromPC: ");Serial.println(integerFromPC);  }
          
          String test =String(integerFromPC);
          int test_int = test.length();
            uebrige_Zeichen = uebrige_Zeichen - 1 - test_int;  // ein Zeichen für den ,
            if (debug_ausgabe == true) { Serial.print(F("uebrige_Zeichen: "));Serial.println(uebrige_Zeichen);  }
        if (uebrige_Zeichen>0) {
          strtokIndx = strtok(NULL, ",");
          floatFromPC = atof(strtokIndx);  // convert this part to a float
          if (debug_ausgabe == true) { Serial.print(F("floatFromPC: "));Serial.println(floatFromPC);  }
          if (debug_ausgabe == true) { Serial.print(F("länge von floatFromPC: "));Serial.println(String(floatFromPC).length());  }
          }
        }
      }
    }
}

void showParsedData() {
  Serial.print(F("Message "));
  Serial.println(messageFromPC);
  Serial.print(F("Integer "));
  Serial.println(integerFromPC);
  Serial.print(F("Float "));
  Serial.println(floatFromPC);
}

int char_vergleich(char* messageFromPC, char* vergleichstext) {
  int ergebnis = 0;
  String mystring(messageFromPC);  // wird benötigt umd die Text_Länge von messageFromPC zu bestimmen
  char Empfang_vergl[mystring.length()] {0};
  snprintf(Empfang_vergl,mystring.length()+1,vergleichstext);
  ergebnis = strcmp(messageFromPC,Empfang_vergl);
  return ergebnis;
}

void parseData_zuweisen() {
  ///  !!!!!!!!!  funtioniert nicht richtig !!!!!
// hier werden individuell Werte an Variablen zugewiesen
  String mystring(messageFromPC);  // wird benötigt umd die Text_Länge von messageFromPC zu bestimmen
  int ergebnis= 0;
  //ergebnis=  char_vergleich(messageFromPC,"Pumpe_bef_ein");
  //Serial.print(F("ergebnis: "));Serial.println(ergebnis);
  // if ((ergebnis= char_vergleich(messageFromPC,"Pumpe_bef_ein"))== 0){
  //   Serial.print(F("erfolg auf ganzer Länge: "));//Serial.println(Empfang_vergl);
  // }
  char Empfang_vergl[mystring.length()] {0};
  snprintf(Empfang_vergl,mystring.length()+1,"Pumpe_bef_ein");


//////
//snprintf(Empfang_vergl,mystring.length()+1,"Pumpe_bef_ein");
//  }else if ( strcmp(messageFromPC,Empfang_vergl)== 0) {
  //if ((ergebnis= char_vergleich(messageFromPC,"Pumpe_bef_ein"))== 0){

//****************
 // ab da alt !!!!!!!!
 

  //Serial.print(F("sizeof messageFromPC: "));Serial.println(sizeof messageFromPC);
  //Serial.print(F("messageFromPC: "));Serial.println(messageFromPC);
  Serial.print(F("Empfang_vergl: "));Serial.println(Empfang_vergl);
  //Serial.print(F("Empfang_ein:   "));Serial.println(Empfang_ein);
  Serial.print(F("strcmp(messageFromPC,Empfang_vergl):   "));Serial.println(strcmp(messageFromPC,Empfang_vergl));
  Serial.print(F("****xxx****:   "));Serial.println(strcmp(messageFromPC,(snprintf(Empfang_vergl,mystring.length()+1,"Pumpe_bef_ein"))));
 //
 //snprintf(Empfang_vergl,mystring.length()+1,"Pumpe_bef_ein");
 //if( strcmp(messageFromPC,Empfang_vergl)== 0) {
 if( strcmp(messageFromPC,(snprintf(Empfang_vergl,mystring.length()+1,"Pumpe_bef_ein")))== 0) {
    Serial.print(F(" ##############Pumpe_bef_ein übergabe: "));
  }  else {
    Serial.print(F("ungleich: "));Serial.println(Empfang_vergl);Serial.print(F(" : "));
  }

  if (debug_ausgabe == true) { Serial.print(F("Ankunft parseData_zuweisen:"));Serial.println(messageFromPC);}
  // if (mystring == "Pumpe_ein_test") {
  //   Serial.print(F(" ##############Pumpe_bef_ein übergabe: "));
  //   //Hell_sonnen_wert = integerFromPC;
  // }
  //for (int i = 0; )
  char test[30] {0};
  char testvergleich[30] {0};
 
  //if (  strcmp(snprintf(test,31,messageFromPC),snprintf(testvergleich,31,"Pumpe_ein"))==0){
  //   if(integerFromPC==1) {
  //     Befehl_Daten[0].BEF_EIN = 1;
  //   } else {
  //     Befehl_Daten[0].BEF_AUS = 1;
  //   }
  //} else

  // strcmp(snprintf(test,30,messageFromPC),snprintf(testvergleich,30,"Pumpe_ein_test"));
  // Serial.print(F(" ##############Test übergabe: ")); Serial.print(test);
  // //printCharArray(test, sizeof test);
  // Serial.println(sizeof test);
  // Serial.println(sizeof messageFromPC);
  // if (test == snprintf(testvergleich,31,"Pumpe_ein_test")) {
  //     Serial.print(F(" ##############Pumpe_bef_ein übergabe: "));
  // }

  if (  strcmp(snprintf(test,31,messageFromPC),snprintf(testvergleich,31,"Pumpe_bef_ein"))==0){
    Befehl_Daten[0].BEF_EIN = 1;
    Befehl_Daten[0].BEF_AUS = 0;
    Serial.print(F("*******************Pumpe_bef_ein"));
  //} else if ((ergebnis= char_vergleich(messageFromPC,"Pumpe_bef_aus"))== 0){
  } else if(  strcmp(snprintf(test,31,messageFromPC),snprintf(testvergleich,31,"Pumpe_bef_aus"))==0){
    //} else if (  strcmp(Empfang_vergl,snprintf(Empfang_vergl,mystring.length()+1,"Pumpe_bef_aus"))==0){
    Befehl_Daten[0].BEF_AUS = 1;
    Befehl_Daten[0].BEF_EIN = 0;
    Serial.print(F("*******************Pumpe_bef_aus"));
  //} else if ((ergebnis= char_vergleich(messageFromPC,"Ventil_1_bef_ein"))== 0){
  } else if (  strcmp(snprintf(test,31,messageFromPC),snprintf(testvergleich,31,"Ventil_1_bef_ein"))==0){
    Befehl_Daten[3].BEF_EIN = 1; 
    Befehl_Daten[3].BEF_AUS = 0;
    Serial.print(F("*******************Ventil_1_bef_ein"));
  //} else if ((ergebnis= char_vergleich(messageFromPC,"Ventil_1_bef_aus"))== 0){
  } else if (  strcmp(snprintf(test,31,messageFromPC),snprintf(testvergleich,31,"Ventil_1_bef_aus"))==0){
    Befehl_Daten[3].BEF_EIN = 0; 
    Befehl_Daten[3].BEF_AUS = 1;
    Serial.print(F("*******************Ventil_1_bef_aus"));
  //} else if ((ergebnis= char_vergleich(messageFromPC,"Ventil_2_bef_ein"))== 0){
  } else if (  strcmp(snprintf(test,31,messageFromPC),snprintf(testvergleich,31,"Ventil_2_bef_ein"))==0){
    Befehl_Daten[4].BEF_EIN = 1; 
    Befehl_Daten[4].BEF_AUS = 0;
    Serial.print(F("*******************Ventil_2_bef_ein"));
  //} else if ((ergebnis= char_vergleich(messageFromPC,"Ventil_2_bef_aus"))== 0){
  } else if (  strcmp(snprintf(test,31,messageFromPC),snprintf(testvergleich,31,"Ventil_2_bef_aus"))==0){
    Befehl_Daten[4].BEF_EIN = 0; 
    Befehl_Daten[4].BEF_AUS = 1;
    Serial.print(F("*******************Ventil_2_bef_aus"));
  }
  if (  strcmp(snprintf(test,31,messageFromPC),snprintf(testvergleich,31,"Pumpe_ein_test"))==0){
    
    Befehl_Daten[0].Test_ein = integerFromPC;
  } else if (  strcmp(snprintf(test,31,messageFromPC),snprintf(testvergleich,31,"Debug_ausgabe"))==0){
    if (integerFromPC ==1) {
        debug_ausgabe = true;
    } else {
        debug_ausgabe = false;
    }
    
    Serial.println(F("***********************debug_ausgabe: Seriell_angekommen"));Serial.println(debug_ausgabe);
  //} else if (mystring ==  "Bef_Pumpe_aus")  { 
  // } else if (  strcmp(snprintf(test,31,messageFromPC),snprintf(testvergleich,31,"Bef_Pumpe_aus"))==0){
  //   Befehl_Daten[0].BEF_AUS = 1;
  //   Serial.println(F("***********************Bef_Pumpe_aus: Seriell_angekommen"));
  // } else if (  strcmp(snprintf(test,31,messageFromPC),snprintf(testvergleich,31,"Bef_Pumpe_ein"))==0){
  //   Befehl_Daten[0].BEF_EIN = 1;
  //   Serial.println(F("***********************Bef_Pumpe_ein: Seriell_angekommen"));
  } else if (  strcmp(snprintf(test,31,messageFromPC),snprintf(testvergleich,31,"Bef_Handbertrieb_ein"))==0){
    Befehl_Daten[1].BEF_EIN = 1;
    Serial.println(F("***********************Bef_Handbertrieb_ein: Seriell_angekommen"));
  } else if (  strcmp(snprintf(test,31,messageFromPC),snprintf(testvergleich,31,"Bef_Handbertrieb_aus"))==0){
    Befehl_Daten[1].BEF_AUS = 1;
    Serial.println(F("***********************Bef_Handbertrieb_aus: Seriell_angekommen"));
  } else if (  strcmp(snprintf(test,31,messageFromPC),snprintf(testvergleich,31,"Bef_Automatik_ein"))==0){
    Befehl_Daten[2].BEF_EIN = 1;
    Serial.println(F("***********************Bef_Automatik_ein: Seriell_angekommen"));
  } else if (  strcmp(snprintf(test,31,messageFromPC),snprintf(testvergleich,31,"Bef_Automatik_aus"))==0){
    Befehl_Daten[2].BEF_AUS = 1;
    Serial.println(F("***********************Bef_Automatik_aus: Seriell_angekommen"));
  
 
//************




 
 
 
 /////////
  // } else if (  strcmp(snprintf(test,31,messageFromPC),snprintf(testvergleich,31,"Bef_Ventil_1_ein"))==0){
  //   if(integerFromPC==1) {
  //     Befehl_Daten[3].BEF_EIN = 1;
  //   } else {
  //     Befehl_Daten[3].BEF_AUS = 1;
  //   }
  //   Serial.println(F("***********************Bef_Ventil_1_ein: Seriell_angekommen"));
  // // } else if (  strcmp(snprintf(test,31,messageFromPC),snprintf(testvergleich,31,"Bef_Ventil1_aus"))==0){
  // //   Befehl_Daten[3].BEF_AUS = 1;
  // //   Serial.println(F("***********************Bef_Ventil1_aus: Seriell_angekommen"));
  // } else if (  strcmp(snprintf(test,31,messageFromPC),snprintf(testvergleich,31,"Bef_Ventil2_ein"))==0){
  //   if(integerFromPC==1) {
  //     Befehl_Daten[4].BEF_EIN = 1;
  //   } else {
  //     Befehl_Daten[4].BEF_AUS = 1;
  //   }
  //   Serial.println(F("***********************Bef_Ventil2_ein: Seriell_angekommen"));
  } else if (  strcmp(snprintf(test,31,messageFromPC),snprintf(testvergleich,31,"Info_Pumpe_1"))==0){
    //Serial.println("<Pumpe_1," + String(cfg.PUMPE_AUSGABE) + "," + String(cfg.PUMPE_MQTT_Adresse)+ "," + String(cfg.VENTIL_1_AUSGABE)+ "," + String(cfg.Ventil_1_MQTT_Adresse)+ "," + String(cfg.VENTIL_2_AUSGABE)+ "," + String(cfg.Ventil_2_MQTT_Adresse)+">");
  //} else if (mystring == "Pumpe_Zustand") { 
  } else if (  strcmp(snprintf(test,31,messageFromPC),snprintf(testvergleich,31,"Pumpe_Zustand"))==0){
    Serial.print(F("Pumpe_Zustand: "));Serial.println (Befehl_Daten[0].Zustand_EIN_AUS);
  //  } else if (mystring == "Min_Wasser") {
  } else if (  strcmp(snprintf(test,31,messageFromPC),snprintf(testvergleich,31,"Min_Wasser"))==0){
    Serial.print(F("Min_Wasser: "));Serial.println (Wasser_min_erreicht);
  //  } else if (mystring == "Max_Wasser") {
  } else if (  strcmp(snprintf(test,31,messageFromPC),snprintf(testvergleich,31,"Max_Wasser"))==0){
    Serial.print(F("Max_Wasser: "));Serial.println (Wasser_max_erreicht);
  } else {
    Serial.print(F(" keine zugehörige Variable gefunden:"));
    Serial.print(F("["));
    Serial.print(snprintf(test,31,messageFromPC));
    Serial.println(F("]"));
    //Serial.print(mystring.length());
  }
}

// ################## Text in Array splitten
void split_string(char TextToSplit[], String Trennzeichen) {
  // Hier wird ein langer String erhalten
  // mit , getrennt und als Array abgespeichert
  if (debug_ausgabe == true) { Serial.println(F("bin im void split_string(String TextToSplit, char Trennzeichen)")); }
  int i;
  char delimiter[] = ",";

  char* p;
  char string[numChars];  // max 128 Zeichen
    //char string[128];  // max 128 Zeichen

  String test = "";
  titel= "";
  test = TextToSplit;
  String words[numStrings];  //max 10 Strings
  //String words[10];  //max 10 Strings
  //Serial.println(test);
  test.toCharArray(string, sizeof(string));
  i = 0;
  p = strtok(string, delimiter);
  titel = p;
  while (p && i < numStrings)
  //while(p && i < 10)
  {
    p = strtok(NULL, delimiter);
    words[i] = p;
    ++i;
  }
  // nur für die Ausgabe
  for (i = 0; i < numStrings; ++i)
  //for(i = 0; i < 10; ++i)
  {
    //Serial.print("die Länge der Variable ist; ");
    //Serial.println(words[i].length());
    if (words[i].length() > 0)  // Abbruch wenn die
    {
      Serial.print(F("die Variable lautet; "));
      Serial.println(words[i]);
      Serial.println(words[i].length());
    }
  }
  Serial.println (titel);
  //auswerten_und_zuweisen_Variablen_werte(words,titel);
  return;
}

void auswerten_und_zuweisen_Variablen_werte(String words[],String titel)  // zum Werte zuweisen auf Variablen
{
  if (debug_ausgabe == true) { Serial.println(F("void auswerten_und_zuweisen_Variablen_werte( String words[])")); }
   // Hier wird ein langer String erhalten
  // mit , getrennt und alsArray abgespeichert
   char trennzeichen[] = "_";  //" statt "_"
   //char string_werte[2];  // max 20 Zeichen lang
  char test[numChars];
   Serial.print(F("titel: "));Serial.println(titel);
   //String string_werte[2];  //max 10 Strings
   int titel_nr = 0;
   
   //String words[numStrings];  //max 10 Strings
   //String words[10];  //max 10 Strings
   //Serial.println(test);
   char *p;
   titel.toCharArray(test, sizeof(test));
   Serial.print(F("String___ " ));Serial.println(test);
   Serial.print(F("String_länge___ " ));Serial.println(sizeof(test));
   int i;
   i = 0;
   p = strtok(test, trennzeichen);
   Serial.print(F("p___ " ));Serial.println(p);
 
  if ((String(p) == "_Wasserstand")||(String(p) == "_min_Wasser") )
  {
    Serial.println(F("p == Sensor"));
    Sensor_zuweisen(words,titel);
  }
  
}

void Sensor_zuweisen(String words[],String Name) {
  if (debug_ausgabe == true) { Serial.println(F("void Sensor_zuweisen(String words[],String Name)")); }
  Serial.println(words[0]);
  Serial.println(Name);
//  MQTT: Bewaesserung/Befehle/  Sensor_1,Büro,500,700,1000
//  <Sensor_1,Büro, 400, 660, 3, 4, 5000>
// Name, titel,min, max ,zeit
  if(Name == "Sensor_1") {
    
    Serial.println(F("DATEN beim Zuweisen")) ;   
    Serial.println(F("words[0]"));
    Serial.println( words[0]) ;   
    Serial.println(F("words[1]"));
    Serial.println(  words[1]);
    Serial.println(F("words[2]"));
    Serial.println( words[2]);
    Serial.println(F("words[3]"));
    Serial.println( words[3]);
  } else if (Name == "Sensor_2") {
    
  } else if (Name == "Pumpe_1") {
    
    
  }
  
}