//Beschreibung und Infos unten.

//Bibliothek/////////////// Bibliotheken //////////////////////////////////

#include <Wire.h>
#include <LiquidCrystal_I2C.h> // Displaybibliothek
LiquidCrystal_I2C lcd(0x27, 20, 4); // Displayadresse (0x27, 20, 4)
#include <SoftwareSerial.h>  // GSM Modul Bibliothek
SoftwareSerial SIM900(7, 8);  // GSM Pin Zuordnung


//Variablen/////////////// Variablen //////////////////////////////////////

// Eingang Pin-Definitionen
const int lengthpotiPin = A0;  //Eingang vom Schlauchlängenpoti (A0)
const int pressurePin = A1;  // Eingang vom Wasserdrucksensor (A1)
const int rpmPin = 2;  // Eingang vom Drehzahlmesser Hallssensor (2)
const int laengetastPin = 3; // Eingang vom Taster für die Längenübernahme(12)
const int startschaltPin = 10; // Eingang vom Startschalter (10)

// Ausgang Pin-Definitionen
const byte powerUPpin = 9;  // Ausgang für den Start des GSM Moduls (9)
const int pressureledPin = 11; // Ausgang Blaue LED Wasserdruck zu niedrig (11)
const int rpmstatledPin = 13; // Ausgang Rote LED Drehzahl (13)
const int startledPin = 4;  // Ausgang Grüne LED START (4)

// Tachometer-Variablen
int count; //Zählt die Umdrehunggen des Reedkontakts
unsigned long distcount = 0; //Zählt die Umdrehunggen des Reedkontakts nach Startschalter
volatile int rpmCount = 0; // (0)
unsigned long lastTimeTacho = 0; // (0)
unsigned long currentTime = 0; // (0)
float wheelCircumference = 0.004019; // Bewegung des Schlauches nach einem Takt des Reedkontaktes (0.00425)
const int numReadings = 10; // Anzahl der Werte für den gleitenden Durchschnitt (15)
float readings[numReadings]; // Array für die Drehzahlwerte
int readIndex = 0; // Index für das Drehzahlarray (0)
float total = 0; // Summe der Drehzahlwerte (0)
float RPM = 0; // Durchschnitt der Drehzahlerte (0)
float speedMPerMin; // Geschwindikkeit pro Minute
float speedMPerHour; // Geschwindikkeit pro Stunde
float distcountlenghtsumm = 80000; // (80000) 
unsigned long lastPrintTime = 0; // Letzte Zeit, zu der die Geschwindigkeit angezeigt wurde (0)
const unsigned long printInterval = 100; // Intervall für die Aktualisierung der Anzeige in Millisekunden (100)
volatile unsigned long lastDebounceTime = 0; // Zeitstempel des letzten gültigen Interrupts
const unsigned long debounceDelay = 200; // Mindestzeit in Millisekunden zwischen zwei gültigen Interrupts(200)
int ledtakten; // Rote Led blinkt bei RPM

// Längen- und Druckvariablen
int tasterstatus = 0;  // Tasterabfrage für die Längenübernahme(0)
unsigned long lastTime2 = 0; // Interruptzeit für Taster(0)
int gezlaenge;  // Zum Beginn ausgezogene Schlauchlänge
int laengeval; // Eingelesener Wert des Längenpotis
int laengevalsmooth; // geglätteter Wert des Längenpotipins
float lengthstored = 357;  // aktuelle Schlauchlänge bei Tasterübernahme (357)
float lengthaktual = 357;  // aktuelle Schlauchlänge (357)
const int minpressure = 5;  // Mindestwasserdruck in Bar (5)
const int restorepressure = 6;  // Mindestwasserdruck in Bar zur SMS Wiederscharfschaltung (6)
float druckval = 0.0; // Eingelesener Wert des Drucksensors (0.0)
float druck = 80;  // Wasserdruck (80 für 10bar als Startdruck um zu verhindern dass SMS beim Start versendet wird)

// SMS-Variablen
int SMSminlaenge = 12; // Variable für die Auslösung der SMS bei unterschreiten der Mindestlänge(12)
bool isSMSSent = false; // Sperrvariable für das senden von mehrmaligen SMS (false)
bool isDruckSMSSent = false; // Sperrvariable für das senden von mehrmaligen SMS beim Druck (false)
bool isLaengeSMSSent = false; // Sperrvariable für das senden von mehrmaligen SMS bei der Laenge (false)
bool isRPMSMSSent = false; // Sperrvariable für das senden von mehrmaligen SMS bei RPM (false)
bool isPressureRestored = true; // Variable für das wiedererreichen des Betriebsdrucks (true)
bool isLaengeRestored = true; // Variable für das wiedererreichen der Mindestlänge (true)
bool isRPMRestored = true; // Variable für das wiedererreichen der Drehzahl (true)
String incoming_sms = "";

// Taster-Variablen
volatile unsigned long pressTime = 0;
volatile unsigned long releaseTime = 0;
volatile bool pressed = false; // Taster wurde gedrückt (false)
volatile bool debounceActive = false; // Taster Entprellung aktiv (false)
const unsigned long debounceDelay2 = 300; // Taster Entprellungszeit (300)
unsigned long pressDuration; // Taster gedrückte Zeit

// Sonstige-Variablen
float endein = 0;  // Dezimalstunden bis Kompletteinzug (0)
int hours; // Stunden bis Kompletteinzug
int minutes; // Minuten bis Kompletteinzug
int schalterstatus = 0;  // Startschalterabfrage(0)
int backlightcount = 1; // Display Hintergrundbelecuhtung Counter (1)
const unsigned long displayUpdateInterval = 200; // (200)
unsigned long lastDisplayUpdateTime = 0; // (0)
bool firststart = true;  // Variable für den ersten Start (true)
float version = 2.3; // Versionsangabe des Code

String message = "";
char caracter=0;
//////////////////////////////////////////////////////////////////////////////////////
//////////////////////////// Funktion Setup //////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////

void setup() {
  Serial.begin(9600); // Start Serial Monitor
  pinMode(lengthpotiPin, INPUT_PULLUP); // INPUT_PULLUP 
  pinMode(pressurePin, INPUT); // INPUT
  pinMode(rpmPin, INPUT_PULLUP); // INPUT_PULLUP
  pinMode(laengetastPin, INPUT_PULLUP); // INPUT_PULLUP
  pinMode(startschaltPin, INPUT_PULLUP); // INPUT_PULLUP
  pinMode(pressureledPin, OUTPUT); // OUTPUT
  pinMode(startledPin, OUTPUT); // OUTPUT
  pinMode(rpmstatledPin, OUTPUT); // OUTPUT
  
//Setup/////////////// Setup Display //////////////////////////////////////////////////////////////////////////////////////////

  lcd.init();
  lcd.backlight();
  lcd.setCursor(0, 0);
  lcd.print("Powering up GSM     ");
  lcd.setCursor(0, 1);
  lcd.print("Rainstar v " + String(version) +"      ");
  lcd.setCursor(0, 2);
  lcd.print("R. K. 2024  ");
  lcd.setCursor(0, 3);
  lcd.print("SIM:+43xxxxxxxxxxxxx");
  delay(100);
  digitalWrite(rpmstatledPin, HIGH); // LED Test
  digitalWrite(startledPin, HIGH); // LED Test
  digitalWrite(pressureledPin, HIGH); // LED Test
  
//Setup/////////////// Setup GPRS Modul //////////////////////////////////////////////////////////////////////////////////////////

  SIM900.begin(19200); // (19200)
  delay(1000); // (1000)
  SIM900.println("AT+CMGF=1");
  delay(1000); // (1000)
  SIM900.println("AT+CNMI=1,2,0,0,0"); //SIM900.println("AT+CNMI=2,2,0,0,0");
  delay(1000); // (1000)
  SIM900.flush();
  pinMode(powerUPpin, OUTPUT);
  powerUp_GSM();
  delay(200); // (200)
  
//Setup//////////////// Setup Tacho //////////////////////////////////////////////////////////////////////////////////////////

  attachInterrupt(digitalPinToInterrupt(rpmPin), rpmCountISR, FALLING); // Interrupt bei fallender Flanke des Reedkontakts
  for (int i = 0; i < numReadings; i++) { // Initialisiere das Array für den gleitenden Durchschnitt
    readings[i] = 0;
  }

//Setup/////////////// Setup Längentaster //////////////////////////////////////////////////////////////////////////////////////////

  attachInterrupt(digitalPinToInterrupt(laengetastPin), buttonISR, CHANGE); 
 }

//////////////////////////////////////////////////////////////////////////////////////
//////////////////////////// Ende Setup //////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////


/////////////////////////////////////////////////////////////////////////////////////
////////////////////////////// Funktion Loop ///////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////

void loop() {

//Loop/////////////// Aufrufen der Funktionen ////////////////////////////////////////////////////////////////////////////////////////// 
  
startup();
//delay(200);  
startschalter();
  //delay(200);
sendSMSauto();
  //delay(200);


//Loop/////////////// GSM Modul auf SMS prüfen //////////////////////////////////////////////////////////////////////////////////////////
 
  if (SIM900.available()) {
    char c = SIM900.read();
    message += c;
    Serial.print(c);

    // Prüfe auf Ende der Nachricht
    if (c == '\n') {
      processMessage(message);
      message = "";
    }
  }
//Loop/////////////// Tastzeitabfrage Längentaster //////////////////////////////////////////////////////////////////////////////////////////
 
if (pressed) {
    pressDuration = releaseTime - pressTime; 
    if (pressDuration > 1000) { 
      storelenght();
    } else {
       if (backlightcount == 1) {
       lcd.noBacklight();
       backlightcount = 0;
     } else {
       lcd.backlight();
       backlightcount = 1;
	  }
    }
    pressed = false; // Status zurücksetzen 
  } 
 
//Loop/////////////// LCD Datenausgabe //////////////////////////////////////////////////////////////////////////////////////////
   
 if (millis() - lastDisplayUpdateTime >= displayUpdateInterval) { // Aktualisieren des Displays
  lastDisplayUpdateTime = millis();
  updateDisplay();
 }
 
//Loop/////////////// Aufrufen der Funktionen ////////////////////////////////////////////////////////////////////////////////////////// 
    
  pressure();
  //delay(200);
  laenge();
  //delay(200);   
  startcount();
  //delay(200);
  laufzeitende();
  //delay(200);
  timemapping(endein);
  //delay(200);
  tacho();
  //delay(200);
  //serienmonitor();
  //delay(200);
}

///////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////// ENDE LOOP /////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////


///////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////// Funktionen /////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////

///Funktion/////////////// Erster Start und Routine //////////////////////////////////////////////////////////////////////////////////////////

void startup() {
  if(firststart == true) { 
   digitalWrite(rpmstatledPin, LOW);
   digitalWrite(startledPin, LOW);
   digitalWrite(pressureledPin, LOW);
   lcd.setCursor(0, 0);
   lcd.print("GSM powered up      ");
   lcd.setCursor(0, 1);
   lcd.print("Ready to Irrigate   ");
   delay(2000); // (2000) Anzeigedauer
   lcd.clear();
   firststart = false;   
  }
 }  

//Funktion/////////////// Serial Monitor Abfragen //////////////////////////////////////////////////////////////////////////////////////////
  
 void serienmonitor() {  
 
 //Serial.print("laengeval:");
 //Serial.print(laengeval); 
 //Serial.print("  ");
 //Serial.print("laengevalsmooth:");
 //Serial.println(laengevalsmooth); 
 
 //Serial.print("distcount:                ");
 //Serial.print(distcount); 
 
 //Serial.print("pressDuration             "); 
 //Serial.print(pressDuration); 
   
   
 //Serial.print("pressTime                 ");  
 //Serial.println(pressTime);

 //Serial.print("releaseTime               ");  
 //Serial.println(releaseTime);
  
 //Serial.print("pressed                   ");  
 //Serial.println(pressed);

 //Serial.print("lastTime2                 ");  
 //Serial.println(lastTime2);  
   
 //Serial.print("Tasterstatus:             ");
 //Serial.println(tasterstatus);
   
 //Serial.print("bool firststart           "); 
 //Serial.println( firststart);
 //Serial.println(" m/h                    ");    
   
 //Serial.print("restorepressure:          ");
 //Serial.print(restorepressure);   
 //Serial.println(" bar                    ");
  
 //Serial.print("isPressureRestored:       ");
 //Serial.println(isPressureRestored);  
  
 //Serial.print("isSMSSent:                ");
 //Serial.println(isSMSSent); 
  
 //Serial.print("isDruckSMSSent:           ");
 //Serial.println(isDruckSMSSent); 
   
 //Serial.print("Ausgezogene Laenge:       ");
 //Serial.print(gezlaenge); 
 //Serial.println(" m                      ");
  
 //Serial.print("Aktuelle Laenge:          ");
 //Serial.print(lengthaktual); 
 //Serial.println(" m                      ");
  
 //Serial.print("speedMPerHour:        ");
 //Serial.print(speedMPerHour); 
 //Serial.println("                        "); 
   
 //Serial.print("RPM:   ");
 //Serial.print(RPM); 
 //Serial.println(" m/h                    ");
  
 //Serial.print("Wasserdruck:              ");
 //Serial.print(druck / 10); 
 //Serial.println(" bar                    ");
  
 //Serial.print("Ende in:                  "); 
 //Serial.print((endein * 100) / 100.0); 
 //Serial.println(" std                    "); 
   
 //Serial.println("                        ");
}

//Funktion/////////////// Funktion Ausgezogene Länge mit Poti //////////////////////////////////////////////////////////////////////////////////////////

void laenge() {
  laengeval = analogRead(lengthpotiPin);
  laengevalsmooth = 0.95 * laengevalsmooth + 0.05 * analogRead(lengthpotiPin); // Glätten des Potizitterns
  gezlaenge = map(laengevalsmooth, 220, 20, 390, 0);  // Umrechnung des Rohpotiwerts des Potis, Ohm in Meter (230, 30, 390, 0)  
}

//Funktion/////////////// Funktion Taster drücken für Längenübernahme gezogen als aktuell //////////////////////////////////////////////////////////////////////////////////////////

void storelenght() {
     lengthaktual = gezlaenge;
     lengthstored = lengthaktual;
     distcountlenghtsumm = (lengthstored / wheelCircumference);
     distcount = 0;
     delay(200);
     lcd.clear();
     lcd.setCursor(0, 0);
     lcd.println("                    ");
     lcd.setCursor(0, 1);
     lcd.println("                    ");
     lcd.setCursor(0, 2);
     lcd.println("                    ");
     lcd.setCursor(0, 3);
     lcd.println("Laenge uebernommen  ");
     delay(200); //(200)
     tasterstatus = 0;
     lcd.clear();
 }

//Funktion/////////////// Funktion Längetaster ISR //////////////////////////////////////////////////////////////////////////////////////////

void buttonISR() {
  if (debounceActive) {
    return; // Ignoriere Interrupts während Debounce-Zeit
  } 
  debounceActive = true;
  delay(debounceDelay2); // Einfacher Debounce
  if (digitalRead(laengetastPin) == LOW) {
    pressTime = millis();
  } else {
    releaseTime = millis();
    pressed = true;
  }
  debounceActive = false;
}

//Funktion/////////////// Funktion Startschalter //////////////////////////////////////////////////////////////////////////////////////////

void startcount() { 
  if (schalterstatus == 0 && RPM > 1) { // Wenn Schalter EIN und Drehzahl größer 1 >> beginne mit herunterrechnen der Meter
    lengthaktual = distcountlenghtsumm * wheelCircumference;
    distcountlenghtsumm = (lengthstored / wheelCircumference) - distcount;  
  }
}

void startschalter () { // Wenn Startschalter EIN >> LED Grün
  schalterstatus = digitalRead(startschaltPin);
  if (schalterstatus == 0) {
    digitalWrite(startledPin, HIGH);
  } else {
    digitalWrite(startledPin, LOW);
  } 
}  

//Funktion/////////////// Funktion Wasserdruck //////////////////////////////////////////////////////////////////////////////////////////

void pressure() {
  if (druck / 10 < minpressure) { // Wenn Wasserdruck min.erreicht >> LED BLAU
    digitalWrite(pressureledPin, LOW); 
  } else {
    digitalWrite(pressureledPin, HIGH);
  }
  druckval = analogRead(pressurePin);
  druck = map(druckval, 105, 900, 0, 100); // Umrechnung des Druckrohwerts vom Sensor, Ohm in Bar (105, 900, 0, 100.0)
}

//Funktion/////////////// Tachometer //////////////////////////////////////////////////////////////////////////////////////////

void tacho() {  
 currentTime = millis();
 unsigned long timeDifference = currentTime - lastTimeTacho;

 if (timeDifference >= 1000) { // Berechne RPM und Geschwindigkeit alle 1000 ms
  noInterrupts(); // Deaktiviere Interrupts vor dem Lesen der rpmCount-Variable
  count = rpmCount;
  rpmCount = 0;
  interrupts(); // Aktiviere Interrupts wieder
  
  lastTimeTacho = currentTime;

  if (count > 0) {
    RPM = (count / (timeDifference / 60000.0)); 
    speedMPerMin = (RPM * wheelCircumference); // Berechne Geschwindigkeit in m/min
    speedMPerHour = speedMPerMin * 60.0; // Konvertiere Geschwindigkeit zu m/h
    total = total - readings[readIndex]; // Entferne den ältesten Wert aus der Summe
    readings[readIndex] = speedMPerHour; // Setze den neuen Wert ins Array
    total = total + speedMPerHour; // Füge den neuen Wert zur Summe hinzu
    readIndex = readIndex + 1; // Index weiterzählen, falls notwendig zum Anfang zurücksetzen
    if (readIndex >= numReadings) {
      readIndex = 0;
    }
    RPM = total / numReadings; // Berechne den Durchschnitt
    if (RPM < 0.1) { // Hier kannst du die Mindestgeschwindigkeit anpassen (1.0),(setzt den Durchschnitt auf 0, wenn er kleiner als eine Mindestgeschwindigkeit ist)
      RPM = 0;
    }
  } else {
    RPM = 0; // Wenn keine neuen Impulse empfangen wurden, setze den Durchschnitt auf 0
  }
  if (currentTime - lastPrintTime >= printInterval) { // Überprüfe, ob es Zeit ist, die Geschwindigkeit anzuzeigen
    lastPrintTime = currentTime;
   }
}
  if (ledtakten == 1) { //Wenn Drehzahl vorhanden >> LED ROT
    digitalWrite(rpmstatledPin, HIGH);
    delay(50);
    ledtakten = 0;
  } else {
    digitalWrite(rpmstatledPin, LOW);
    
  }
 } 

//Funktion/////////////// Funktion Tachometer ISR //////////////////////////////////////////////////////////////////////////////////////////

void rpmCountISR() {
    noInterrupts();
    unsigned long currentTime = millis();
    if ((currentTime - lastDebounceTime) > debounceDelay) { // Nur Signale akzeptieren, die weiter als debounceDelay auseinanderliegen
        rpmCount++;
        if (schalterstatus == 0) {
            distcount++;
            ledtakten = 1;
        }
        lastDebounceTime = currentTime;
    }
    interrupts();
}

//Funktion/////////////// Funktion Laufzeitende in Std //////////////////////////////////////////////////////////////////////////////////////////

void laufzeitende() { // errechnet die restliche Laufzeit bis der Schlauch eingezogen komplett eingezogen wird
  if (RPM > 0) {
    endein = (lengthaktual / RPM);
    } 
  else {
    endein = 0;
  }
}

void timemapping(float decimalHours) { // Umrechnung der Dezimalstunden in Stunden und Minuten
  hours = (int)decimalHours; // Extrahiere die Stunden
  minutes = (decimalHours - hours) * 60; // Berechne die Minuten  
}

//Funktion/////////////// Funktion Display //////////////////////////////////////////////////////////////////////////////////////////

void updateDisplay() {
    lcd.setCursor(0, 0);
    lcd.print("Einzug: ");
    lcd.setCursor(8, 0);
    lcd.print(RPM);
    lcd.print(" m/h  ");
    lcd.setCursor(0, 1);
    lcd.print(">>");
    lcd.print(lengthaktual);
    lcd.setCursor(8, 1);
    lcd.print("<<");
    lcd.print(" von ");
    lcd.print(gezlaenge);
    lcd.print("m ");
    lcd.setCursor(0, 2);
    lcd.print(">>");
    lcd.print(hours);
    lcd.print("h ");
    lcd.print(minutes); 
    lcd.print("m  ");
    lcd.setCursor(9, 2);
    lcd.print("<<");
    lcd.setCursor(12, 2);
    lcd.print(druck / 10);
    lcd.print("bar "); 
    lcd.setCursor(0, 3);
    lcd.print("Takte ");
    lcd.print(distcount);   
}


//Funktion/////////////// SMS Senden bei externer Anfrage bei Text "ALL" //////////////////////////////////////////////////////////////////////////////////////////
void processMessage(String msg) {
  // Prüfe, ob die empfangene Nachricht "ALL" enthält
  if (msg.indexOf("ALL") != -1) {
    Serial.println("Nachricht enthält 'ALL'");
    // Füge hier deinen Code zum Senden einer SMS hinzu
    sendSMSALL();
  }
}

void sendSMSALL() { 
  SIM900.print("AT+CMGS=\"+43XXXXXXXXXX\"\r");
  delay(1000);
  SIM900.print("Rainstar v" + String(version) + "\n");
      lcd.clear();
      lcd.print("                    ");
      lcd.setCursor(0, 1);
      lcd.print("sende ALL SMS       ");
      lcd.setCursor(0, 2);
      lcd.print("                    ");
      lcd.setCursor(0, 3);
      lcd.print("                    ");  
      delay(1000); // (1000)
      lcd.clear();
      SIM900.print(RPM);
      SIM900.println(" m/h  ");
      SIM900.print(lengthaktual);
      SIM900.println(" m");
      SIM900.print(hours);
      SIM900.print("h ");
      SIM900.print(minutes); 
      SIM900.println("min");
      SIM900.print(druck / 10);
      SIM900.println(" bar ");
      SIM900.print(distcount);
      SIM900.print(" Takte ");
      delay(1000); // (1000)
      SIM900.write(26);
      lcd.clear();
      incoming_sms = ""; // Zurücksetzen des Eingangs    
	if (incoming_sms.endsWith("\n")){ // Nachrichtenanzeige zurücksetzen wenn die SMS vollständig gelesen wurde
		incoming_sms = "";
	}
  }
 


//Funktion/////////////// SMS Automatisch //////////////////////////////////////////////////////////////////////////////////////////

void sendSMSauto() {  
if (druck / 10 > restorepressure) { 
 isPressureRestored = true;
 isDruckSMSSent = false; // Setzt die SMS Variable Druck zurück
 }
if (lengthaktual > SMSminlaenge) { 
 isLaengeRestored = true;
 isLaengeSMSSent = false; // Setzt die SMS Variable Länge zurück
 } 
if (RPM > 0) { 
 isRPMRestored = true;
 isRPMSMSSent = false; // Setzt die SMS Variable Drehzahl zurück
 }   
if (schalterstatus == 0) {
   if (isDruckSMSSent == false) {  
    if (druck / 10 < minpressure && !isDruckSMSSent) { // Sende SMS wenn der Druck unter den Mindestdruck gefallen ist.
    lcd.setCursor(0, 0);
    lcd.print("                    ");
    lcd.setCursor(0, 1);
    lcd.print("sende Druck SMS     ");
    lcd.setCursor(0, 2);
    lcd.print("                    ");
    lcd.setCursor(0, 3);
    lcd.print("                    ");  
    sendSMS("Der Druck betraegt nur mehr " + String(druck / 10) + "bar");
    delay(1000); // (1000)
    lcd.clear();
    isDruckSMSSent = true;
    isPressureRestored = false; // überprüft ob der Mindestdruck wieder erreicht wurde
    }
   }
   if (isLaengeSMSSent == false) { 
    if (lengthaktual < SMSminlaenge && !isLaengeSMSSent) {  // Sende SMS wenn die Länge unter die Mindestlänge gefallen ist.
    lcd.setCursor(0, 0);
    lcd.print("                    ");
    lcd.setCursor(0, 1);
    lcd.print("sende Laenge SMS    ");
    lcd.setCursor(0, 2);
    lcd.print("                    ");
    lcd.setCursor(0, 3);
    lcd.print("                    ");  
    sendSMS("Die Laenge betraegt nur mehr " + String(lengthaktual) + "m");
    delay(1000); // (1000)
    lcd.clear();
    isLaengeSMSSent = true;
    isLaengeRestored = false; // überprüft ob die Mindestlänge wieder erreicht wurde
    }
   }  
   if (isRPMSMSSent == false) { 
    if (RPM == 0) {  // Sende SMS wenn die Drehzahl auf 0 gefallen ist.
    lcd.setCursor(0, 0);
    lcd.print("                    ");
    lcd.setCursor(0, 1);
    lcd.print("sende Drehzahl SMS  ");
    lcd.setCursor(0, 2);
    lcd.print("                    ");
    lcd.setCursor(0, 3);
    lcd.print("                    ");  
    sendSMS("Die Geschwindigkeit bretraegt nur mehr " + String(RPM) + "m/std");
    lcd.clear();
    delay(1000); // (1000)
    isRPMSMSSent = true;
    isRPMRestored = false; // überprüft ob die Mindestdrehzahl wieder erreicht wurde
	}    
   }
  }  
 }

//Funtion/////////////// Funktion SMS //////////////////////////////////////////////////////////////////////////////////////////

void sendSMS(String message) {
  if (!isSMSSent || isSMSSent) {
    SIM900.print("AT+CMGF=1\r");
    delay(200); // (200)
    SIM900.println("AT+CMGS=\"+43XXXXXXXXXXX\"");
    delay(200); // (200)
    SIM900.println(message);
    delay(200); // (200)
    SIM900.println((char)26);
    delay(200); // (200)
    SIM900.println();
    delay(1000); // (5000)
    isSMSSent = true;
  }
}

//Funktion/////////////// Funktion GSM Modul PowerUp Prezedur //////////////////////////////////////////////////////////////////////////////////////////
void powerUp_GSM() {  
  digitalWrite(powerUPpin, LOW);
  delay(100); // (6000)
  digitalWrite(powerUPpin, HIGH);
  delay(500); // (2000)
  digitalWrite(powerUPpin, LOW);
  delay(1000); // (1000)
}

///////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////// ENDE /////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////


/* Dieses Projekt wurde von Rudolf K. erstellt.
 * Arduino soll verschiedene Daten und Kenngrößen von einer Bauer Rainstar Bewässerungsanlage auf einem Display anzeigen und per Gsm Modul an die Telefonnummer 06763721081 senden.
 * Dadurch kann der Empfänger dieser Daten den Zustand der Anlage erkennen.
 * 
 * 
 * /////Beschreibung:
 * Die Turbine wird mittels Wasserdruck in Bewegung gesetzt. Eine verstellbare Variatordüse leitet den Strahl auf die Turbine, dabei kann man die Umdrehungsgeschwindigkeit mech. variabel einstellen.
 * Der Getriebekasten wird mittels Treibriemen von der Turbine angetrieben.
 * Der Abtrieb des Getriebekastens treibt mittels Kette eine Trommel an die den Schlauch dabei einrollt.
 * Die Beregnungseinheit der Bewässerungsanlage wird mittels Schlepper ausgezogen
 * Der Schlauch wird nun mit einer zuvor eingestellten Geschwindigkeit automatisch eingerollt.
 * Bei Schlauchende wird der Schlaucheinzug mechanisch auf Stillstand geschalten.
 * 
 * ////Aufgaben an die Steuerung:
 * Mittels Reedkontakt am Getriebe soll die Drehzahl ermittelt werden und als umgerechneter Wert m/h auf dem Display angezeigt werden.
 * Die Einzugsgeschwindigkeit soll mit der aktuellen Schlauchlänge verrechnet werden um die Restzeit zum erreichen des kompletten Einzugs des Schlauchs am Display angezeigt werden.
 * Mittels Drehpotentiometer soll die Länge des ausgezogenen Schlauchs am Display einzustellen sein.
 * Mittels Drucktaster soll dieser Wert bei drücken von mindestens 1s drücken übernommen werden.
 * Mittels Startschalter soll die ausgezogene Länge lt. momentanen Einzug heruntergerechnet werden. (Dadurch kann die aktuelle Schlauchlänge ermittelt werden)
 * Mittels Startschalter soll das Gsm Modul aktiv geschaltet werden.
 * Nach Start soll beim unterschreiten von 10 m aktueller Schlauchlänge eine SMS gesendet werden.
 * Nach Start soll beim unterschreiten von 4 bar Wasserdruck eine SMS gesendet werden. Beim wiedererreichen von 5 bar soll die SMS Funktion wieder scharfgeschaltet werden.
 * Nach Start soll bei Ausfall des Drehzahlsignals eine SMS gesendet werden
 * Nach Start soll bei aktiver Anfrage von einem SMS mit der Nachricht " ALL " folgende Daten an das anfordernde Handy wieder zurückgesendet werden.
 *  Aktuelle Schlauchlänge
 *  Aktueller Wasserdruck
 *  Restzeit bis erreichen des kompletten Einzugs des Schlauchs.
 * Eine rote Led soll leuchten wenn sich das Getriebe dreht.
 * Eine blaue Led soll leuchten wenn der Wasserdruck über dem Mindestdruck ist.
 * Eine grüne Led zeigt den Start der Zählung und die aktivierte SMS Funktion an.
 * Beim ersten Start der Steuerung soll eine Info des Gsm Moduls und die Vesion des Codes am Display angezeigt werden.
 * Mittels Drucktaster soll die Displayhintergrundbeleuchtung bei kurzen drücken unter 1s Ein- und Ausgeschltet werden.
 *
 * ////Benötigte Daten auf dem Display:
 * Wasserdruck in bar
 * Einzugsgeschwindigkeit des Schlauchs in m/Stunde
 * Ausgezogene Schlauchlänge
 * Restliche Schlauchlänge in m
 * Zeit bis Einzugsende in hh:mm
 * 
 * 
 * ////Module, Sensoren und Komponenten:
 * Schaltschrank IP65 Sichttür Industriegehäuse 210 x 280 x 130 mm verzinkter Montageplatte transparent Tür mit umlaufender Dichtung Gehäuse Leergehäuse ABS Kunststoff leer Schrank ARLI 21 x 28 x 13 cm
 *          https://www.amazon.de/Schaltschrank-Industriegeh%C3%A4use-Montageplatte-Verriegelung-ARLI/dp/B01EZPZB04/ref=sr_1_10?__mk_de_DE=%C3%85M%C3%85%C5%BD%C3%95%C3%91&crid=9VCNR0DIYPKI&keywords=geh%C3%A4use%2Bwasserdicht&qid=1656665598&sprefix=geh%C3%A4use%2Bwasserdicht%2Caps%2C74&sr=8-10&th=1
 * Arduino UNO
 * Display: AZDelivery HD44780 2004 LCD Display Bundle Grün 4x20 
 *          https://www.amazon.de/AZDelivery-HD44780-Display-Zeichen-Schnittstelle/dp/B07N8CGM9G/ref=sr_1_9?__mk_de_DE=%C3%85M%C3%85%C5%BD%C3%95%C3%91&crid=2L0T87VYIL3CE&keywords=display%2Brobot%2Barduino&qid=1656664597&sprefix=display%2Brobot%2Barduino%2Caps%2C72&sr=8-9&th=1
 * GSM Modul SIM900
 * G1/4"Drucksensor, DC 5V Edelstahl Drucksensor für Wasser Luft Gas Heizöl Diesel(0-150PSI)
 *          https://www.amazon.de/Drucksensor-Edelstahl-Wasser-Heiz%C3%B6l-0-150PSI/dp/B07YZKZHNJ/ref=sr_1_1_sspa?__mk_de_DE=%C3%85M%C3%85%C5%BD%C3%95%C3%91&crid=2NSPRRHUMQY4P&keywords=drucksensor%2B150psi%2B5v&qid=1656665854&refinements=p_76%3A419123031&rnid=419121031&rps=1&sprefix=drucksensor%2B150psi%2B5v%2Caps%2C79&sr=8-1-spons&smid=A2YV8RMOY2PTG4&spLa=ZW5jcnlwdGVkUXVhbGlmaWVyPUEzRFBFMVY1UkM3RVhaJmVuY3J5cHRlZElkPUEwNjg3ODY1MUJTWjNTQjlCS1lOMyZlbmNyeXB0ZWRBZElkPUExMDM3NDI1Mk1IUDRLQ0w3S0hDSSZ3aWRnZXROYW1lPXNwX2F0ZiZhY3Rpb249Y2xpY2tSZWRpcmVjdCZkb05vdExvZ0NsaWNrPXRydWU&th=1
 *          Anschluß: Rot 5V, Schwarz Masse, Grün Signal
 * Hallsensor Sick RZC1-04ZRS-KRD (1060130)(zur Erfassung der Umdreungsgeschwindigkeit des Getriebes)
 * Led für die Getriebedrehzahl ROT
 * Led für den Start der Einzugsmessung GRÜN
 * Led für den korrekten Wasserdruck Blau
 * 3Stk 1KOhm Vorwiderstand für die LED´s
 * Taster für die Übernahme der Schlauchlänge
 * Schalter für den Start
 * 1Stk 10kOhm Drehpotentiometer Keenso 10K Ohms Potentiometer Kit, 3590S-2-103L Drehdrahtgewickelt Präzisionspotentiometer mit 10 Umdrehungen Zählzifferblatt und Drehknopf
 *        https://www.amazon.de/Keenso-Potentiometer-Drehdrahtwicklung-Pr%C3%A4zisionspotentiometer-3590S-2-103L/dp/B07QY856TX/ref=sr_1_2_sspa?__mk_de_DE=%C3%85M%C3%85%C5%BD%C3%95%C3%91&crid=33CX3FISHO1ZC&keywords=Pr%C3%A4zisionspotentiometer+1k&qid=1656665461&sprefix=pr%C3%A4zisionspotentiometer+1k%2Caps%2C63&sr=8-2-spons&psc=1&smid=A2BTSZU32SZ5O4&spLa=ZW5jcnlwdGVkUXVhbGlmaWVyPUFENUlOVlFKQVhTNVQmZW5jcnlwdGVkSWQ9QTAzNDU4NDVYWVMwQ1lTMUw0VSZlbmNyeXB0ZWRBZElkPUEwMjUwODI1MVdCVkxNSVA0VllCMCZ3aWRnZXROYW1lPXNwX2F0ZiZhY3Rpb249Y2xpY2tSZWRpcmVjdCZkb05vdExvZ0NsaWNrPXRydWU=  
 *    
 * ////Verkabelung:   
 *  Displayanschluss: SCL=A5, SDA=A4, Rot=5V, Braun=GND,  
 *  Potianschluß: Braun=A0, Blau=GND, Schwarz=5V,  
 *  Taster: GND, 3,  
 *  Startschalter: GND, 10,
 *  Drucksensor: Rot=5V, Schwarz=GND, Grün=A1,  
 *  Led Rot: GND, 13,
 *  Led Grün: GND, 4,
 *  Led Blau: GND, 11,
 *  GSM Modul: W=7, SW=8,   
 *  Reedkontakt: GND, 5V, 2;
 */