// spezielle debug-Tools dein Code steht ab ca Zeile 45

// MACRO-START * MACRO-START * MACRO-START * MACRO-START * MACRO-START * MACRO-START *
// a detailed explanation how these macros work is given in this tutorial
// https://forum.arduino.cc/t/comfortable-serial-debug-output-short-to-write-fixed-text-name-and-content-of-any-variable-code-example/888298
// # define A0 14
#define dbg(myFixedText, variableName) \
  Serial.print( F(#myFixedText " "  #variableName"=") ); \
  Serial.println(variableName);

#define dbgi(myFixedText, variableName,timeInterval) \
  { \
    static unsigned long intervalStartTime; \
    if ( millis() - intervalStartTime >= timeInterval ){ \
      intervalStartTime = millis(); \
      Serial.print( F(#myFixedText " "  #variableName"=") ); \
      Serial.println(variableName); \
    } \
  }

#define dbgc(myFixedText, variableName) \
  { \
    static long lastState; \
    if ( lastState != variableName ){ \
      Serial.print( F(#myFixedText " "  #variableName" changed from ") ); \
      Serial.print(lastState); \
      Serial.print( F(" to ") ); \
      Serial.println(variableName); \
      lastState = variableName; \
    } \
  }

#define dbgcf(myFixedText, variableName) \
  { \
    static float lastState; \
    if ( lastState != variableName ){ \
      Serial.print( F(#myFixedText " "  #variableName" changed from ") ); \
      Serial.print(lastState); \
      Serial.print( F(" to ") ); \
      Serial.println(variableName); \
      lastState = variableName; \
    } \
  }
// MACRO-END * MACRO-END * MACRO-END * MACRO-END * MACRO-END * MACRO-END * MACRO-END *


#include <MobaTools.h>

// int schritte_def = 200;  //wieviele schritte pro umdrehung 1,8° pro Schritt
// Stepper motor(schritte_def, pinDir_A, pinDir_B); //brauche ich diese ZEile?

const int STEPS_UMDREHUNG = 200;
MoToStepper myStepper( STEPS_UMDREHUNG, STEPDIR );

//Taster
const int duenn  = 8;
const int endschalter = 9;
const int dick   = 10;
const int start  = 11;
const int mittel = 12;
const int zwick  = 13;

//Motor TB6600
const byte dirPin = 5;
const byte stepPin = 4;
const byte enaPin = 6;

//variable für Taster damit man weiß dass es normalerweise low ist
int switchStateStart  = 1;
int switchStateZwick  = 1;
int switchStateStopp  = 1;
int switchStateDuenn  = 1;
int switchStateMittel = 1;
int switchStateDick   = 1;
int switchStateEndschalter = 1; //der ENdschalter ist in echt ein öffner weil er defekt ist und ich noch einen neuen bestellen muss
int modusduenn  = 1;
int modusmittel = 1;
int modusdick   = 1;

int SchrittAnzahl = 1;
int i = 0; // damit ich den Taster zählen kann
int t = 0;

byte SchrittNr;

bool referenzErreicht = false;

//         1234567890123456789
const byte Moduswahl            = 0;
const byte Startanfahren        = 1;
const byte warte_start_zwicke   = 2;
const byte Fingererkennen       = 3;
const byte Fingererneut   = 4;
// const byte Stopp          = 5;
const byte Referenzfahrt  = 6;

const byte losgelassen = HIGH;
const byte gedrueckt = LOW;

// array mit den Namen der cases gleiche Reihenfolge
// => die Indexnummer des Arrays entspricht der SchrittNr
// => kompakter Code zum Ausgeben der case-namen
const char stateName[][24] = {
  "Moduswahl",        // array-element 0
  "Startanfahren",      // array-element 1
  "warte_start_zwicke", // array-element 2
  "Fingererkennen",   // array-element 3
  "Fingererneut",     // array-element 4
  "Stopp",            // array-element 5
  "Referenzfahrt"     // array-element 6
};




void setup() {
  Serial.begin(115200);
  Serial.print("Setup-Start");
  PrintFileNameDateTime();

  // motor.setSpeed(50);
  // digitalWrite(pinPWM_A, HIGH); //warum muss A und B high sein?
  // digitalWrite(pinPWM_B, HIGH);

  pinMode(zwick, INPUT_PULLUP);
  pinMode(start, INPUT_PULLUP);
  // pinMode(stopp, INPUT_PULLUP);
  pinMode(duenn, INPUT_PULLUP);
  pinMode(mittel, INPUT_PULLUP);
  pinMode(dick, INPUT_PULLUP);
  pinMode(endschalter, INPUT_PULLUP);

  //Motor pins
  pinMode(enaPin, OUTPUT);
  pinMode(stepPin, OUTPUT);
  pinMode(dirPin, OUTPUT);
  digitalWrite(enaPin, HIGH);
  myStepper.attach(stepPin, dirPin);
  myStepper.attachEnable( enaPin, 10, LOW );  // Enable Pin aktivieren ( LOW=aktiv )

  //Treiberaktivieren -> LOW aktiviert ihn
  digitalWrite(enaPin, LOW);

  SchrittNr = Moduswahl;
  Serial.println("Warte auf Moduswahl");
}

void TasterEinlesen() {

  // dbgc: NUR wenn sich der Wert der Variablen GEÄNDERT hat
  // dann EINMAL ausgeben (aber NICHT dauernd)

  switchStateDuenn       = digitalRead(duenn);
  dbgc("01", switchStateDuenn);

  switchStateMittel      = digitalRead(mittel);
  dbgc("02", switchStateMittel);

  switchStateDick        = digitalRead(dick);
  dbgc("03", switchStateDick);

  switchStateStart       = digitalRead(start);
  dbgc("04", switchStateStart);

  switchStateZwick       = digitalRead(zwick);
  dbgc("05", switchStateZwick);

  switchStateEndschalter = digitalRead(endschalter);
  dbgc("06", switchStateEndschalter);

  // switchStateStopp       = digitalRead(stopp);
  // dbgc("07", switchStateStopp);

}

void myStateMachine() {

  printIfStateChanged(SchrittNr); // wenn sich die SchrittNr geändert hat dann einmal ausgeben

  switch (SchrittNr) {
    case Moduswahl:
      // einmal alle auf losgelassen setzen
      modusduenn  = losgelassen;
      modusmittel = losgelassen;
      modusdick   = losgelassen;

      if (switchStateDuenn == gedrueckt) { //um die Tasten zu merken und den Modus gewählt zu halten
        modusduenn = gedrueckt;
        SchrittAnzahl = 600;
        Serial.println("Modus dünn");
        modusmittel = losgelassen;
        modusdick = losgelassen;
        SchrittNr = Startanfahren;
      }

      if (switchStateMittel == gedrueckt) {
        modusmittel = gedrueckt;
        SchrittAnzahl = 500;
        Serial.println("Modus mittel");
        modusduenn = losgelassen;
        modusdick = losgelassen;
        SchrittNr = Startanfahren;
      }

      if (switchStateDick == gedrueckt) {
        modusdick = gedrueckt;
        SchrittAnzahl = 400;
        Serial.println("Modus dick");
        modusduenn = losgelassen;
        modusmittel = losgelassen;
        SchrittNr = Startanfahren;
      }
      // am Ende einmal SchrittNr setzen

      break;

    case Startanfahren:
      //if (switchStateEndschalter == losgelassen) {
      if (!referenzErreicht) {
        SchrittNr = Referenzfahrt;
        break;
      }

      if (switchStateStart == gedrueckt && switchStateEndschalter == gedrueckt) {
        delay(250);
        digitalWrite(dirPin, HIGH); //Richtung festlegen-> HIGH vorwärts
        for (int d = 0; d < SchrittAnzahl; d++) { //so sollte sich der Motor um die Schrittzahl drehen
          digitalWrite(stepPin, HIGH);
          delayMicroseconds(2000); //das regelt die Geschwindigkeit
          digitalWrite(stepPin, LOW);
          delayMicroseconds(2000);
        }
        // motor.step(SchrittAnzahl);
        Serial.println("Motordreht runter");
        SchrittNr = warte_start_zwicke;
      }

      break;

    case warte_start_zwicke:
      if (switchStateStart == gedrueckt && switchStateZwick == gedrueckt) {
        digitalWrite(dirPin, HIGH);
        for (int d = 0; d < 1000 - SchrittAnzahl; d++) { //so sollte sich der Motor um die Schrittzahl drehen
          digitalWrite(stepPin, HIGH);
          delayMicroseconds(500);
          digitalWrite(stepPin, LOW);
          delayMicroseconds(500);
        }
        // motor.step(1000 - SchrittAnzahl);
        Serial.println("Motordreht runter");
        delay(50);
        digitalWrite(dirPin, LOW);
        for (int d = 0; d < 1000 + SchrittAnzahl; d++) { //so sollte sich der Motor um die Schrittzahl drehen
          digitalWrite(stepPin, HIGH);
          delayMicroseconds(500);
          digitalWrite(stepPin, LOW);
          delayMicroseconds(500);
        }
        // motor.step(-1000 + SchrittAnzahl);
        Serial.println("Motordreht rauf");
        delay(250);// kann ich so mein problem von unten beheben??
        SchrittNr = Fingererkennen;
      }
      // if (switchStateStart==losgelassen){ //ich hätte gerne dass wenn der Finger vom Sensor genommen wird, der Motor wieder neu anfahren muss. muss ich zu "startanfahren" oder muss ich zu " referenzfahrt"
      //     SchrittNr = Fingererkennen;
      // } das Funktioniert leider nicht so wie ich es geplant hatte
      break;

    case Fingererkennen:
      if (switchStateStart == losgelassen) {
        SchrittNr = Referenzfahrt;
      }
      if (switchStateStart == gedrueckt) {
        SchrittNr = warte_start_zwicke;
      }
      break;

    // case Stopp: //das Funktioniert leider auch nicht weil er so wie ich vermute noch in einem Schritt festhängt?
    //   if (switchStateStopp == gedrueckt) {
    //     motor.step(0);
    //     Serial.println("Motorstopp");
    //     SchrittNr = Referenzfahrt;        // hier wäre es interessant dass man einen neuen Modus wählen kann. Daumennagel sind meist dicker als kleine Finger nägel.
    //   }
    //   break;

    case Referenzfahrt:
      if (switchStateEndschalter == losgelassen) {
        myStepper.setSpeed(200);
        myStepper.rotate(-1);
        Serial.println("Fahre zum Referenzschalter");
        while (switchStateEndschalter != gedrueckt) {
          switchStateEndschalter = digitalRead(endschalter);
        }
        myStepper.stop();
        myStepper.setZero();
        Serial.println("Referenz erreicht Start drücken");
        referenzErreicht = true;
        SchrittNr = Startanfahren;
      }
      break;
  }
}


void printIfStateChanged(byte actualState) {
  static byte lastState;

  if (lastState != actualState) { // wenn sich die SchrittNr geändert hat dann einmal ausgeben
    Serial.print("state changed from ");
    Serial.print(stateName[lastState]);
    Serial.print(" to ");
    Serial.print(stateName[actualState]);
    Serial.println();
    // update lastState => wird erst dann wieder ausgegeben wenn sich die
    // SchrittNr wieder geändert hat
    lastState = actualState;
  }
}


void loop() { //schreib ich hier statt loop stateMachine? das habe ich im Internet gefunden?

  TasterEinlesen();
  myStateMachine();

}

// helper-functions
void PrintFileNameDateTime() {
  Serial.println( F("Code running comes from file ") );
  Serial.println( F(__FILE__) );
  Serial.print( F("  compiled ") );
  Serial.print( F(__DATE__) );
  Serial.print( F(" ") );
  Serial.println( F(__TIME__) );
}