// LCD1602 to Arduino Uno connection example
#include <OneButton.h> // fuer Tasterfunktionen

#include <LiquidCrystal.h>
#include "TimerOne.h"
#include "Timer.h"
#include <EEPROM.h> // fuer Wertespeichernung auch nach Trennung vom Strom

Timer timer;  // für Gabellichtschranke
Timer anzeige_timer;  // für V-einstellung bei laufendem Motor
Timer abbruch_timer; // Erkennen von Bruch
Timer end_timer;  // zum Motor ausschalten
Timer prufung_ges;  // für den gesammten Prüfvorgang
int TAF=0 ;//Timer-Anzeige-Funktion > bestimmt den Anzeigetext
int TS=2500;// Timer-Stop
int Abbruchzeit=10000;//  20s oder länger?
int at=0;// Abbruchtimer Anzeige inaktiv

// LCD-Display:
const int rs = 12, en = 11, d4 = 7, d5 = 6, d6 = 5, d7 = 4;
LiquidCrystal lcd(rs, en, d4, d5, d6, d7);

// Motor:
int motor = 10;  
int geschwindigkeit = 0;
int v=0;
// Encoder:
int clkPin = 2;
int dtPin = 9;
int state_clk;
int old_state_clk;
int state_dt;
int counter = 0;
int mon=0; //Motor aus/läuft

//Variablen für Tasteraktionen
int st=0; // aktiv für starten bzw stoppen des Motors, null bei bei PWmoeglich
int pw=0; // Programmwahl (nicht) möglich
int p=EEPROM.read(13);//> bei Wokwisim.p wählen(1,2,3 oder4)
int res=0;// (0 reset nicht möglich; 1 reset mögl(falls sw&Tastergedr);2>..)
int rt=0; //reset true
int b=1;//,b=1 Programmbestätigung,b=2 Intervallbestätigung, b=3 in V-Wahlmodus, b=4 zwischenschritt für p4 
int a=1;//Anfang..
int ra=0;//Resetabbruch

//Programm
int n=25;// Auto-Speicherintervalle  
int nWahl=0;
long us=0;              //Anzahl bei der Test bestanden, ev. automatisch gestoppt
int SPO; //Speicherort aktuell
int SPOneu;
int SPO1,SPO2,SPO3,SPO4; //für temp. Abspeichern um nicht bei jedem Progrwechsel suchen zu müssen
int TasterBlau   =  8; // hier nötig für Stromausfall, da bei Neustart der Simulation EEpromwerte verloren gehen!

//Taster
int Taster   =  13;//lang(+RE):PW, kurz Start/stop bzw Resetausführen
int sw = 1;
OneButton Taster1(Taster, true);
OneButton SW(sw, true);

// Gabellichtschranke:
int sensor = 3; // in Wokwi grüner Taster anstelle Gabellichtschranke!!
int sensor_state;
unsigned long anzahl_umdrehungen = 0;
long Bneu; //neue Biegungen seit letzter Zwischenspeicherung
long LSDG_gesamt;

//Speicherung
long SPW=0;// Speicherwert 
int m; //Marker
long M=1073741824; //Markierung in den aktuellen Speicherwerten um genauen SPO im Abschnitt zu finden
int SPOl=0;//nied.SPO> Programmabhängig
int SPOh;
long z=1; // zählt Speichervorgänge am selben SPO > Wechsel spätestens nach 255 da 8bit Speicherplatz (long SPW von Stelle 22 bis 29) 
long zl=z<<22;
long cz=1069547520;// bereinigt alles außer z-Anteil

// Zeichen für LCD
byte Oder[8] = {
   B01010,
   B01010,
   B01010,
   B01010,
   B01010,
   B01010,
   B01010,
   B01010
};

byte Play[8] = {
   B00000,
   B10000,
   B11000,
   B11100,
   B11110,
   B11100,
   B11000,
   B10000
};

byte Pfeil[8] = {// Pfeil nach unten
   B00000,
   B00100,
   B00100,
   B00100,
   B00100,
   B10101,
   B01110,
   B00100
};
byte Drehsymli[8] = {// Drehsymbol linker Teil
   B00111,
   B01000,
   B10000,
   B10000,
   B10000,
   B10000,
   B01000,
   B00111
};
byte Drehsymre[8] = {//Drehsymbol rechter Teil
  B10000,
   B01000,
   B00100,
   B10101,
   B01110,
   B00100,
   B01000,
   B10000 
};
byte NQ[8] = {// Zu erreichende Anzahl>Prüfende
   B11111,
   B00000,
   B10001,
   B11001,
   B10101,
   B10101,
   B10011,
   B10001
};
byte Speicher[8] = { // Mitte Symbol Speicherintervall
   B00100,
   B00100,
   B11111,
   B01110,
   B00100,
   B00000,
   B10001,
   B11111
};
byte Stop[8] = {
   B00000,
   B00000,
   B00000,
   B01110,
   B01110,
   B01110,
   B00000,
   B00000
};


void setup() {
  Serial.begin(9600);
  lcd.begin(16, 2);

  for(int i=0;i<900;i++){ // für Wokwi- Simulation
  EEPROM.write(i,0);
  }
EEPROM.write(248,64);//gewählte Angfangswerte Markierung für Test
EEPROM.write(251,77);//gesp. Zählwert für Test
EEPROM.write(472,64);
EEPROM.write(475,13);
EEPROM.write(692,64);
EEPROM.write(695,107);
EEPROM.write(24,64);
EEPROM.write(27,9);//..
eepromWriteLong(50, 4);//n für Flexiprogramm
eepromWriteLong(77, 8);//v für Flexi                  ...bis hier nur für Wokwi

// Symbole
  lcd.createChar(0, Pfeil);
  lcd.createChar(1, Drehsymli);
  lcd.createChar(2, Drehsymre);
  lcd.createChar(3, Play);
  lcd.createChar(4, Oder);
  lcd.createChar(5, NQ);
  lcd.createChar(6, Speicher);
  lcd.createChar(7, Stop);


   //Taster 
  pinMode(TasterBlau,INPUT_PULLUP);//Stromausfall

  pinMode(Taster,INPUT_PULLUP);   //mit internem Pullup
  pinMode(sw,INPUT_PULLUP); 
  Taster1.attachClick(StartStopReset); //ein Klick
  Taster1.attachLongPressStart(PWmoeglich); // wird angezeigt, auch wenn Taster noch gedrückt

 // Taster1.setPressTicks(800); //  Standardwert 1000
  Taster1.setClickTicks(500); // Standardwert 600
 // Taster1.setDebounceTicks(50); // Standardwerte 50

  SW.attachClick(Bestaetigung); //ein Klick
  SW.attachLongPressStart(ResetAnfrage); //lange gedrückt
  n=eepromReadLong(4); 
  programm(p); //
// LCD-Display: Anzeige zu Beginn>identisch Programmwahl
  AnzeigeProgrammwahl();


  // PWM benötigt höhere Frequenz, um im nicht hörbaren Bereich zu liegen:
  // Setzt Timer1 (Pin 9 und 10) auf 31300 Hz:
  TCCR1B = TCCR1B & 0b11111000 | 0x01;  
  // TCCR1B = Timer1 Counter Control Register B 
  // 0b11111000: Kombination der letzten 3 Bits bestimmt Taktzeit --> 1 Hz
  // 0x01 --> setzt Frequenz auf 31300 Hz

  // Encoder:
  pinMode(clkPin,INPUT); 

 // Interrupt für Encoder:
  attachInterrupt(digitalPinToInterrupt(clkPin), P_I_V_R_wahl, CHANGE);
  pinMode(dtPin,INPUT);

  // Erste Poition des Encoders auslesen:
  old_state_clk = digitalRead(clkPin);

  // Motor:
  pinMode(motor, OUTPUT);  

  // Gabellichtschranke:
  pinMode(sensor, INPUT);
  digitalWrite(sensor, HIGH);

// Interrupt für Gabellichtschranke:
  attachInterrupt(digitalPinToInterrupt(sensor), gabellichtschranke_steuerung, FALLING);
}


void P_I_V_R_wahl(){    // Programm-, Intervall-,Geschwindigkeits-,Resetwahl
  // Zweite Position des Encoders auslesen:
 
  state_clk = digitalRead(clkPin);
  state_dt = digitalRead(dtPin);
 
  // erste Position des Encoders mit zweiter vergleichen:
 if(state_clk != old_state_clk){ // Drehung erkannt

  if(res==2){  // Wahl: Reset durchführen oder Abbrechen?

   if(rt==0){ // Entscheidung für Ausführung
    lcd.setCursor(0, 1);
    lcd.print("Ja  ");
    ra=0;
    rt=1; // Reset durchführen aktiv
   }
   else{ // Entscheidung für Abbruch 
    rt=0;
    lcd.setCursor(0,1);
    lcd.print("Nein "); 
    ra=1;// Abbruch aktiv 
   } 
  }

  else if(pw==1){   //Programmwahl wurde aktiviert Taster> mind.2s gedrückt
    st=0; anzahl_umdrehungen=0;// erst hier> bleibt bei direkter bestätigung erhalten
    if(digitalRead (Taster)==LOW){ // Taster noch gedrückt!!> Programm wählbar
     if(state_dt != state_clk){ //erkennt Rechtsdrehung
      p--;
        if(p==0){
         p=4;
        }
     }
     else{ //Linksdrehung RE
        p++;
       if(p==5){
        p=1;
        } 
       }    
    AnzeigeProgrammwahl();// Anzeige während Programmwahl
    b=1;
    }
    else {  // Taster nicht gedrückt
    HinweisTasterPW(); 
    }
  }

  else if(p==4){   // Flexiprogramm bereits ausgewählt
   if(b==2){            // Wahl des Speicherintervalls
      if(state_dt != state_clk)// Rechtsdrehung
    { nWahl=nWahl-25;
      if(nWahl<25){
        nWahl=25;
      }
    }
    else{ 
       nWahl=nWahl+25;       
      if(nWahl>=1000){ // größter wählbarer Wert
        nWahl=1000;
      }              
    }
    AnzeigeIntervallwahl();
    
   }
   else{    // n bereits bestätigt> Geschwindigkeitswahl möglich

    if(b==3){// Modus Geschwindigkeitswahl
    if(state_dt != state_clk)// Rechtsdrehung
   
   {
      counter --;
      geschwindigkeit = geschwindigkeit - 5;
       
    }
    else{
      counter ++;
      geschwindigkeit = geschwindigkeit + 5;
      
    }
     if(mon==1){// zur V-Anzeige während Motor läuft
      anzeige_timer.start();}  // Timer um veränderung der Geschwindigkeit auch bei laufendem Motor lesen zu können
      TAF=1; TS=2000;// V-Anzeige 2 s lang nach letzter Änderung
    // Geschwindigkeit des Motors darf nicht höher als 255 sein
    if(geschwindigkeit > 255){
      geschwindigkeit = 255;
    }
    
    // Geschwindigkeit des Motors darf nicht negativ sein
    if(geschwindigkeit < 0){
      geschwindigkeit = 0;
    }
    v=geschwindigkeit; // wird aber noch nicht ausgegeben!!> Taster für Start
    if(mon==0){
      v=0;
    }
   
    analogWrite(motor,v);
   
   if(mon==0)
     //{AnzeigeV_Wahl();} // Anzeige der Geschwindigkeit mit Optionen bei Motorstillstand
     { //lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print("v=");
       lcd.print(geschwindigkeit);// muss  wieder verschwinden
       //delay(1500);// funktioniert hier nicht! >> Timer nutzen!!??
       //AnzeigeBiegevorgaenge();
     }
     //{ AnzeigeBiegevorgaenge();}
    
    // Motor läuft maximal auf Display:
    if(geschwindigkeit >= 255){
      lcd.setCursor(0, 0);
      lcd.print("max     ");
    }

   // Alte Position wird zur aktuellen Position (Encoder): 
   old_state_clk = state_clk;
  }
 }

  }else{
   
  }
 }
}

void gabellichtschranke_steuerung(){  
  // Timer für Motor Ausschaltung wird gestoppt und gestartet:
  end_timer.stop();
  abbruch_timer.stop();
 
  // Timer blockiert Gabellichtschranke Kontakte für 100 ms:  
  if(timer.read() > 100 || timer.read() == 0){
    timer.stop();
    timer.start();
  }
  // Hochzählen der Anzahl der Undrehungen:
  if(timer.read() == 0){

   if(v!=0){// kein zählen bei Motorstillstand
    if  (LSDG_gesamt>4193303){  //Puffer?//4194303
      HinweisSpeicherMax(); 
       mon=0;
       analogWrite(motor,0);
     } 
   else if  (p=!4 && LSDG_gesamt>=us){  //
      
     AnzeigePruefende();
     }
     else{

     anzahl_umdrehungen++; //
     Bneu++;//
     LSDG_gesamt=Bneu + (LSDGausSPW(eepromReadLong(SPO)));

     
     if (anzahl_umdrehungen %n == 0 ){//wird nur in größeren Intervallen regelmäßig übertragen/gesichert, da EPROM nur ca.100.000  neu beschreibbar ist, aber zur Absicherung bei Stromausfall
     Wertespeicherung();
     }
       AnzeigeBiegevorgaenge();
      }
   }  
    end_timer.start();
    abbruch_timer.start();
  }
}

long eepromReadLong(int adr) {        //Long aus EEPROM lesen
// long int Wert aus 4 Byte EEPROM lesen
// Eingabe : adr bis adr+3
// Ausgabe : long Wert
// 
// Matthias Busse 23.5.2014 Version 1.0

long lo=0;

  for(int i=0;i< 3;i++){
    lo += EEPROM.read(adr+i);
    lo = lo << 8;
  }
  lo += EEPROM.read(adr+3);
  return lo;
} // eepromReadLong

void eepromWriteLong(long lo, int adr) {        //Long in EEPROM schreiben
// long Wert in das EEPROM schreiben  
// Eingabe : adr Speicherplatz 
// Eingabe : lo Zahl, Wertebereich -2.147.483.648 bis 2.147.483.647
//
// Matthias Busse 23.5.2014 Version 1.0

byte by;

  for(int i=0;i< 4;i++) {
    by = (lo >> ((3-i)*8)) & 0x000000ff; 
    EEPROM.write(adr+i, by);
  }
} // eepromWriteLong


void PWmoeglich(){ // ausgelöst durch T1 lange gedrückt
  
   if(res==2){ 
  } 
  else if(res==1){
 ResetWahl();
  }
  else{ // für Programmwahl
    if(mon==1){ // solange Motor noch läuft Hinweis
     anzeige_timer.start();
    TAF=3; TS=3000;// HinweisMotorStopPW();//>Timer..
    }
    else{  //Motor aus
  pw=1; // Programmwahl über Drehregler möglich
  st=0;b=1;// neu für Direktbestätigung des vorhandenan Programms
     if(p==4){ 
      }
    AnzeigeProgrammwahl();

    }
  } 
}


void StartStopReset(){
 
 anzeige_timer.stop();
 
 if(a==1){ //zu Beginn Hinweis,dass erst ein Programm bestätigt werden muss
  HinweisStartProgBest();
 }
 else{
  if(ra==1){}
  else if(rt==1){}
 
  else if(res==1){ 
  ResetWahl();
  }

  else{ // nicht im Resetmodus
   if(st==1){ // starten/stop über T1 möglich
    if ((p=!4) &&(LSDGausSPW(eepromReadLong(SPO))>=us)){  //
     AnzeigePruefende();
     } 
    else{
     if(v==0){
     at=1;// Anzeige einmalig ermöglicht
     v=geschwindigkeit;
     mon=1;
     abbruch_timer.start();
     lcd.clear();
     lcd.setCursor(0, 1);
       lcd.print("              on");
    }
    else{v=0; //Motor stoppt
    abbruch_timer.stop();// nötig wenn Motor normal gestoppt wird
    if (p==4)
     {if(eepromReadLong(8)!=geschwindigkeit) {eepromWriteLong(geschwindigkeit,8);} // beim Ausschalten letztes n & v sichern
     if(eepromReadLong(4)!=nWahl)  {eepromWriteLong(nWahl,4);}  // wenn nicht schon identisch vorhanden
     } 
     if(LSDGausSPW(eepromReadLong(SPO))!=LSDG_gesamt){    //  genauen Zählwert abgleichen& speichern --> sobald Geschwindigkeit auf Null ist, wird der exakte Wert gespeichert  
     Wertespeicherung();}
     AnzeigeBiegevorgaenge();
    mon=0;}

    analogWrite(motor,v);
    }
  pw=0;
  
  if(st==0){}
 }
}
}
}

void programm(int p){
  if(p==1){
    geschwindigkeit=210; // <bisherige Tests
    
    SPOl=20;
    if(SPO1==0){ // SPO1 ist nur nach Neustart Null, wird bei erster Programmanwahl gesucht
    SPOsuche(SPOl);}// setzt SPO 
    else{
    
    SPO=SPO1;

     }
   
    SPO1=SPO; //SPO wird für SPO1 übernommen
 

    n=500;//25000;Testz. // Fehler pro Stromausfall maximal 1/1000
    us= 500000;
  }
  if(p==2){
    geschwindigkeit=255;// bis jetzt noch nicht festgelegt<Tests
  
    SPOl=244;
     
      if(SPO2==0){ 
    SPOsuche(SPOl);}// setzt SPO 
    else{
     SPO=SPO2; 
     }
  
 SPO2=SPO; //SPO wird für
      
  
      n=100; //5000;zu Testzwecken nur 15 // Fehler pro Stromausfall maximal 1/1000
      us= 100000;
  }
  if(p==3){
    geschwindigkeit=255;//<Tests
   
   SPOl=468;
     
      if(SPO3==0){ 
    SPOsuche(SPOl);}// setzt SPO 
    else{
     SPO=SPO3; 
     }
  
   SPO3=SPO; //SPO wird für
     
      n=50;//2500;Test  // Fehler pro Stromausfall maximal 1/1000
      us=100; //50000;// Für Anzeige-Test 100
  }
  if(p==4){
   
    SPOl=692;
     
    if(SPO4==0){ 
      SPOsuche(SPOl);
    }// setzt SPO 
    else{
     SPO=SPO4; 
     }
   
     SPO4=SPO; //SPO wird für
   
    geschwindigkeit=eepromReadLong(8);
    nWahl=eepromReadLong(4);
    n=nWahl;
  }
}


void Bestaetigung(){ //sw kurz

 a=0;
 
 if(ra==1){  //bei Resetabbruch durch Wahl Nein
    v=0; //direkter start 
    res=0; // um Reset zu verlassen
    st=1; // weißt Taster1 start/stopp-Funktion zu
    ra=0; // danach Resetabbruch wieder deaktiviert
    AnzeigeResetAbbruch();
    delay(1500);
    AnzeigeP_bestaetigt();
  }
  else if(rt==1){  // Reset wird durchgeführt(nach Wahl Ja)
    
    Zaehlerreset();// Resetfunktion
    rt=0;
    res=0;// um Resetoption zu verlassen
    v=0; // direkter Start
    st=1; // weißt Taster1 start/stopp-Funktion zu
    AnzeigeResetErfolg();
    delay(1500);
    AnzeigeP_bestaetigt();
   
  }
 
 else if(b==1){ // SW dient zur Programmbestätigung 
  //p4=0;//   !!??
  if(mon==1||(st==1 && p<4) ){ // erneutes Ausführen ,soll nur bei P4 und Motorstillstand möglich sein
   } // 
  else{      // normaler Beginn
  st=1;        // >Start und stopp möglich
  v=0;         // um bei Klick direkt zu starten 
  pw=0;        //PWmoeglich aus> wird durch langen Druck automatisch reaktiviert
  programm(p); // Programmübergabe
  //anzahl_umdrehungen=0; //aktuelle Biegungen wieder ab Null gezählt// erst bei Dreherkennung> Programm wird sicher verändert
  EEPROM.write(13, p);// ProgrammNr. gespeichert> Abfrage zu Beginn
  if(p==4){// Spezielle Anweisung und 1 Schritt weiter
 
  b=4;
  }
  
  // else      //  Bestätigung des gew.Programm mit vorgeg/gewählten Werten
   // Anzeige Programmbestätigt
   AnzeigeP_bestaetigt();
  }
 }
 else if(b==4){
    nWahl=eepromReadLong(4);
    AnzeigeIntervallwahl();
    b=2; //Übergang zu Intervallwahl
    v=0; // nötig?
    st=0;//start soll erst nach v-Wahl möglich sein
 }
 else if(b==2){ //Intervall bestätigt>>FlexiProg Geschwindigkeitswahl
  n=nWahl; // gewähltes Intervall wird übergeben > gespeichert erst nach start
  geschwindigkeit= eepromReadLong(8);// zu letzt verwendete Geschwindigkeit im Flexiprogramm
 // Anzeige Geschwindigkeitswahl
  
   AnzeigeV_Wahl();
    b=3;
    st=1;
    v=0;// für direkten Start!
 }
  
}

void ResetAnfrage(){
  //  wird erst nach xs aktiv
 if(rt==1){} 
 else if(ra==1){} 
 else{ // Reset nicht aktiv
  if(a==1){ //Anfang bevor ein Programm bestätigt
  //AnzeigeAnfangOB();
  }
  else if(mon==1){ 
    anzeige_timer.start();
    TAF=2; TS=3000;// HinweisMotorStopRes();//
    }
  else{
    if(digitalRead (Taster)==LOW){ 
     res=1;
    } 
   else{
    HinweisTasterRes();
    }
  }
 }
}

void ResetWahl(){
 if(digitalRead (sw)==LOW){
  res=2;
  ra=1;
  AnzeigeResetWunsch();
 }
  else{res=0;}
}


void Zaehlerreset()  
{ 

 if(LSDGausSPW(eepromReadLong(SPO))!=0){    //  genauen Zählwert abgleichen& speichern --> sobald Geschwindigkeit auf Null ist, wird der exakte Wert gespeichert  
      LSDG_gesamt=0; 
      Wertespeicherung();
      anzahl_umdrehungen=0; //
       }      
}

void SPOsuche(int SPOl){
  SPOh=SPOl+220;//224; // Test 32!
 
  for(int i=SPOl;i<SPOh;i=i+4){ //liest nacheinander alle möglichen Anfänge (jeweils bit 30 des long)
    
     m= bitRead(EEPROM.read(i),6);
     
   if (m==0){
    }

     if(m==1){
       SPO=i;// wird hier an temp. Variable als Speicherort übergeben>
       
       SPW=eepromReadLong(SPO);

       break;
     }
     else if(i==SPOl+224){ //
         lcd.setCursor(0, 0);
       lcd.print(">SPO nicht gefunden!! ");
     }
    }

}

void PrintZahlRechts(long z, int stelle, int zeile){//Achtung größte Zahl 6_stellig!!
  int startpunkt;
  if(z>=100000){
    startpunkt=0;
   }
   else if(z>=10000){
    startpunkt=1;
   }
   else if(z>=1000){
    startpunkt=2;
   }
   else if(z>=100){
    startpunkt=3;
   }
   else if(z>=10){
    startpunkt=4;

   }
   else if(z>=0){
    startpunkt=5;
   }
  lcd.setCursor(stelle+startpunkt,zeile); 
  lcd.print( z ); 
}

// Werte aus/für Speichervorgang
long LSDGausSPW(long SPW){
  long LSDG=SPW& 4194303;//(2^21+..2^0) löscht Markierung und Speicherv.zahl aus SPW
return LSDG;
}

long SPWoLSDG(long SPW){
  long SPWoLS=SPW & ~4194303; //LS-Anteil gelöscht
  return SPWoLS;
}

long SPW_neu(long SPW,long LSDG){
    long SPWn;
    SPWn=(SPWoLSDG( SPW))|LSDG;
    return SPWn;
}

void Programmtext(int p){
  if(p==1){
    lcd.print("Band gebogen");
  }
  else if(p==2){
    lcd.print("Band gerade");
  }
  else if(p==3){
    lcd.print("Draht");
  }
  else
  {lcd.print("FlexiProgramm");}
}
void Text1(){
  lcd.setCursor(5,0); //lcd.print("arduinospielwiese.de");
    Programmtext(p);
   lcd.print(" N" "\366" " loeschen? "    );
}

void Wertespeicherung(){
SPW=(eepromReadLong(SPO));
     zl=SPW&cz;
     z=zl>>22;
     z=z+1;//
      
     if(z<=250){                  //512??){   <Test 4!//Zahl der Speicherungen am gleichen Ort hintereiander
       zl=z<<22;
       SPW=zl|M |LSDG_gesamt; 
       
         eepromWriteLong(SPW,SPO); //LSDG wird an SPO hinterlegt
      }
     else { //Zurücksetzen des Speicherungen-Zählers für Beginn an neuem SPO
        z=1;
        zl=z<<22;
        SPW=zl|M |LSDG_gesamt;
        
        SPOneu=SPO+4;
        if(SPOneu>SPOh){ //falls letzter SPO für dieses Programm erreicht>Rücksprung auf ersten
          SPOneu=SPOl;      
        } 
                              
        eepromWriteLong(SPW,SPOneu);// Wert an neuem SPO gespeichert
        
        eepromWriteLong(0,SPO);// Werte am alten SPO gelöscht
        SPO=SPOneu;
       
        if(p==1){
          SPO1=SPO;
        }
        else if(p==2){
          SPO2=SPO;
        }
        else if(p==3){
          SPO3=SPO;
        }
        else{
          SPO4=SPO;
        }
      }
      Bneu=0; 
}

void HinweisSpeicherMax(){
   lcd.setCursor(0, 0);
   lcd.print("Speichermax. !! ");
   lcd.setCursor(0, 1);
   lcd.print("bitte Reset durchfuehren");
}

void HinweisMotorStopPW(){
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("f""\365""r Programmwahl     ");
  lcd.setCursor(0, 1);
  lcd.print("Motor stoppen    ");
  
}

void HinweisStartProgBest(){
  lcd.setCursor(0, 1);
  lcd.print("P mit sw ");// besser ohne P?
  lcd.write(byte(0));
  lcd.print(" bestaetigen     "); 
}

void HinweisTasterRes(){
    lcd.clear();
    lcd.setCursor(0, 0);
     lcd.print("f""\365""r Resetwahl");
    lcd.setCursor(0, 1);
    lcd.print("T1");//
    lcd.write(byte(0));
    lcd.print(" + SW");// 
    lcd.write(byte(0));
    delay(3000);
    lcd.clear();    
    lcd.setCursor(9, 1);
    lcd.write(byte(3));//
    lcd.print("T1 ");// 
    lcd.write(byte(0));
    lcd.setCursor(0, 0);
    Programmtext(p);
    lcd.print("");
}

void HinweisMotorStopRes(){
    lcd.clear();   
    lcd.setCursor(0, 0);
     lcd.print("f""\365""r Resetwahl");
    lcd.setCursor(0, 1);
    lcd.print("Motor stoppen");
    delay(2500);
    AnzeigeP_bestaetigt();
    delay(2500);
}

void HinweisTasterPW(){
  lcd.setCursor(0, 0);
  lcd.print("f""\365""r Programmwahl"); 
  lcd.setCursor(0,1);
  lcd.print("T1");
  lcd.write(byte(0));
  lcd.print(" + RE ");
  lcd.write(byte(1));
  lcd.write(byte(2)); 

}


void AnzeigeResetWunsch(){
 
  lcd.setCursor(0, 1); // 2.Zeile immer fest
  lcd.print("Nein            "); 
  lcd.setCursor(5, 1);
  lcd.print("SW"); 
  lcd.write(byte(0));
  lcd.write(byte(4));//oder
  lcd.print("  RE"); 
  lcd.write(byte(1));
  lcd.write(byte(2));
  
  lcd.setCursor(0, 0); // Alternativtext zu scroll-Text
  lcd.print("N");
  lcd.write("\366""           ");
  lcd.setCursor(3, 0);
  Programmtext(p);
  lcd.print("                ");
  delay(2000);
  lcd.setCursor(3, 0);
  lcd.print(" loeschen?     ");

}



    String Progtext(int p){
      String ProgText;
  if(p==1){
    ProgText=("Band gebogen ");
  }
  else if(p==2){
    ProgText=("Band gerade  ");
  }
  else if(p==3){
    ProgText=("Draht        ");
  }
  else
  {ProgText=("FlexiProgramm");}
  return(ProgText);
}

void AnzeigeResetAbbruch(){
  lcd.setCursor(0, 0);
  lcd.print("Reset        ");
  lcd.setCursor(0, 1);
  lcd.print("abgebrochen       ");
}

void AnzeigeResetErfolg(){
lcd.clear();
lcd.print("Reset ");
lcd.setCursor(0, 1);
lcd.print("erfolgreich!!");

}

void AnzeigeProgrammwahl(){
  lcd.clear();
  lcd.setCursor(0, 0);
  Programmtext(p);
  lcd.setCursor(0, 1);
  lcd.print("SW");
  lcd.write(byte(0));
  lcd.setCursor(6, 1);
  lcd.write(byte(4));//Doppeltpfeil als Symbol für Änderung
  lcd.print(" T1");
  lcd.write(byte(0));
  lcd.print("+RE");
  lcd.write(byte(1));
  lcd.write(byte(2));
}

void AnzeigeBiegevorgaenge(){ //alternativ Anzeige START/STOP Modus + Anweisung
  lcd.clear();
  if(anzeige_timer.read()>0 && anzeige_timer.read() <= TS){
   if(TAF==1){
     lcd.setCursor(0, 0);
    lcd.print( "v=");
    lcd.print(geschwindigkeit);
   }
   else if(TAF==2){
    HinweisMotorStopRes(); 
   }
   else if(TAF==3){
    HinweisMotorStopPW(); 
   }
  }
 
  else{ //  Anzeige im normalen Zählbetrieb
  lcd.setCursor(0, 0);
  lcd.print( "N");
  lcd.write("\366");// Summenzeichen
  //lcd.print( LSDGausSPW(eepromReadLong(SPO)));
   PrintZahlRechts(LSDGausSPW(eepromReadLong(SPO)),2,0);
  lcd.setCursor(8, 0);
  lcd.print( "/");
  lcd.write(byte(5));// Symbol für zuerreichende Anzahl>Prüfungsende
  lcd.setCursor(0, 1);
  lcd.print( "N ");
  //lcd.print(anzahl_umdrehungen );//Anzeige durchlaufend wechselnd >Anweisung für Start
  PrintZahlRechts(anzahl_umdrehungen,2,1);
  //lcd.setCursor(9,0);
  //lcd.print(us);
  PrintZahlRechts(us,10,0);
  if(p==4){  
  lcd.setCursor(10, 0);
  lcd.print( "          ");// kein us vorgegeben
  }
  if(v==0){
    lcd.setCursor(12, 1);
    lcd.write(byte(3));
    lcd.print("T1");
    lcd.write(byte(0));
  }
  if(v==geschwindigkeit){
   lcd.setCursor(12, 1);
   lcd.write(byte(7));
   lcd.print("T1");
   lcd.write(byte(0));
  }
 }
}

void AnzeigeP_bestaetigt(){
  lcd.clear();
  if(p==4){
    lcd.setCursor(0, 0);
  lcd.print( "weiter od. Reset");
  lcd.setCursor(0, 1);
  lcd.print("SW");
  lcd.write(byte(0));
  lcd.setCursor(6, 1);
  lcd.write(byte(4));
  lcd.print("  SW");
  lcd.write(byte(0));
  lcd.print("+T1");
  lcd.write(byte(0));
  }
  else{
  lcd.setCursor(0, 0);
  lcd.print("Start od. Reset");
  lcd.setCursor(0, 1);
  lcd.write(byte(3));
  lcd.print("T1");
  lcd.write(byte(0));
  lcd.setCursor(6, 1);
  lcd.write(byte(4));
  lcd.print("  SW");
  lcd.write(byte(0));
  lcd.print("+T1");
  lcd.write(byte(0));
  }
}

void AnzeigeIntervallwahl(){
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("(");//("gew. SpIntervall");
  lcd.write(byte(6));
  lcd.print(")");
  lcd.print(nWahl);
  lcd.setCursor(0, 1);
  lcd.print("SW ");
  lcd.write(byte(0));
  lcd.setCursor(9, 1);
  lcd.write(byte(4));// Symbol für Änderung
  lcd.print(" RE");
  lcd.write(byte(1));
  lcd.write(byte(2));
}


void AnzeigeV_Wahl(){
  if(mon==1){} // andere Anzeige wenn in p4 Motor läuft!
  else
  {
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("v=");
  lcd.print(geschwindigkeit);
  lcd.setCursor(0, 1);
  lcd.write(byte(3));
  lcd.print("T1");
  lcd.write(byte(0));
  lcd.setCursor(10, 1);
  lcd.write(byte(4));
  lcd.print(" RE");
  lcd.write(byte(1));
  lcd.write(byte(2));
  }
    
}

void AnzeigeAbbruch(){
  Wertespeicherung();// Extraspeicherung für exakten Abbruchwert
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Pr""\365""fung Abbruch!");
  lcd.setCursor(0, 1);
    lcd.print( "N""\366");
   lcd.print( LSDGausSPW(eepromReadLong(SPO)));
    //lcd.print( LSDG_gesamt );
    lcd.print( "            ");
    lcd.setCursor(15, 1);
    lcd.print( "X");
}

void AnzeigePruefende(){
    mon=0;
    abbruch_timer.stop();// reaktiviert durch LSDG ?
    at=0;
    analogWrite(motor,0);// Funktionen in Anzeige, da sie an mehreren Stellen ebenso benötigt werden
    lcd.setCursor(0, 0);
    lcd.print( "Pr""\365""fung beendet ""\350");
    lcd.setCursor(0, 1);
    lcd.print( "N""\366");
   // Wertespeicherung();//
    lcd.print( LSDGausSPW(eepromReadLong(SPO))     );// LSDG_gesamt..genauer?
    lcd.print( "  o.B.          "); // Text zu lang für große us-Werte..!
    lcd.setCursor(15, 1);
    lcd.print( "\xBC");
    
}

void loop() {
  SW.tick();
  
  if(abbruch_timer.read()> Abbruchzeit){
    if(at==1){
    analogWrite(motor,0);// Motor stoppen 
    abbruch_timer.stop(); // besser hier oder bei start..?
    AnzeigeAbbruch();
    at=0; // verhindert ständige Erneuerung
    v=0;// für direkten Start..erwünscht?> sonst zwei mal Drücken für Start nötig>erst gestoppter Motor
    mon=0;//>PW möglich!! :)
    } 
    else{}
    
  }
  if(anzeige_timer.read() > TS){  //für temporäre Anzeigen
    anzeige_timer.stop();}
    
  //SW.tick();
  Taster1.tick();
  delay (10);
   /* Serial.print("abb:"); 
    Serial.println(abb); 
    /*Serial.print("n-Wahl:");
    Serial.println(eepromReadLong(4)); 
    Serial.print("SPW:"); 
    Serial.println(SPW,BIN); 
    Serial.print("SPW1:"); 
    Serial.println(eepromReadLong(20),BIN);
    Serial.print("SPW2:"); 
    Serial.println(eepromReadLong(244),BIN);
    Serial.print("SPW3:"); 
    Serial.println(eepromReadLong(468),BIN);
    Serial.print("SPW4:"); 
    Serial.println(eepromReadLong(692),BIN);*/

   /* Serial.print("LSDG_gesamt:"); 
    Serial.println(LSDG_gesamt); 
    Serial.print("davon bereits gespeichert: ");
    Serial.println( LSDGausSPW(eepromReadLong(SPO))); 
    /* Serial.print("Anzahl Umdrehungen aktuell:"); 
    Serial.println( anzahl_umdrehungen);
    Serial.print("P: "); 
    Serial.println(p);
     Serial.print("SPOl: "); 
    Serial.println(SPOl);
    Serial.print("SPO1: "); 
    Serial.println(SPO1);
    Serial.print("SPO2: "); 
    Serial.println(SPO2);
    Serial.print("SPO3: "); 
    Serial.println(SPO3);
    Serial.print("SPO4: "); 
    Serial.println(SPO4);
     Serial.print("SPO: "); 
    Serial.println(SPO);*/
   /*  Serial.print("b: "); 
    Serial.println(b);
     Serial.print("ra: "); 
    Serial.println(ra); 
    Serial.print("rt: "); 
    Serial.println(rt);
     Serial.print("z: "); 
    Serial.println(z);
    Serial.print("Taster: "); 
    Serial.println(digitalRead (Taster));*/
  }