#include <Arduino.h>
#include <AccelStepper.h>   

// Stepper A4988
// AccelStepper Setup für A4988 (DRIVER-Modus)
AccelStepper stepper(AccelStepper::DRIVER, A2, A3); // STEP an A2, DIR an A3

// Variablen für den Stepper
long current_steps = 0;
long previous_steps = 0;
int stepper_speed = 0;

// Belegung der Led_pins
const byte pin_led_start = 12;
const byte pin_led_left_driection = 11;
const byte pin_led_right_direction = 10;
byte led_pins[3] = {pin_led_start, pin_led_left_driection, pin_led_right_direction};

// Definieren von veränderlichen Variablen für die LEDs
bool led_start = false;
bool led_left = false;
bool led_right = false;
bool leds[3] = {led_start, led_left, led_right};

// Timer für die LEDs
unsigned long led_millis = 0;

// Belegung der Taster
const byte pin_button_start = 9;
const byte pin_button_left = 8;
const byte pin_button_right = 7;
byte button_pins[3] = {pin_button_start, pin_button_left, pin_button_right};

// Definieren on veränderlichen Variablen für die Taster

// Start-Taster 
bool button_read_start = false;
bool button_on_start = false;
bool switch_start = false;
unsigned long button_start_millis = 0;

// Taster Drehrichtung links
bool button_read_left = false;
bool button_on_left = false;
bool switch_left = false;
unsigned long button_left_millis = 0;

// Taster Drehrichtung rechts
bool button_read_right = false;
bool button_on_right = false;
bool switch_right = false;
unsigned long button_right_millis = 0;

// Variablen für das Dauerdrehen
bool turn_left = false;
bool turn_right = false;

// Belegung des Potentiometers
const byte pin_poti = A0;

// Belegung der Ausgänge zur Steuerung des A4988
const byte pin_enable = 6;
const byte pin_MS1 = 5;
const byte pin_MS2 = 4;
const byte pin_MS3 = 3;
const byte pin_reset = 2;
const byte pin_sleep = A1;
const byte pin_step = A2;
const byte pin_dir = A3;
byte pins_A4988[8] = {pin_enable, pin_MS1, pin_MS2, pin_MS3, pin_reset, pin_sleep, pin_step, pin_dir};

// flags für die A4988-Treiberkarte
bool enable = false;
bool MS1 = false;
bool MS2 = false;
bool MS3 = false;
bool reset = false;
bool sleep = false;
bool A4988_card[6] = {enable, MS1, MS2, MS3, reset, sleep};

// Timer für den Seriellen Monitor 
unsigned long serial_millis = 0;

// Setzen der State-Machine

enum current_operation_state {
  system_off,                     //(0)
  system_standby,                 //(1)

  one_revolution_left,            //(2)
  one_revolution_right,           //(3)

  rotation_left,                  //(4)
  rotation_right,                 //(5)
};

current_operation_state operation_state = system_off;

void update_serial_monitor();
void update_button_start();
void update_button_left();
void update_button_right();
void update_operation_state();
void execute_operation_states();
void control_stepper();
void execute_outputs();


void setup() {

  // Starten des Seriellen Monitors
  Serial.begin(9600);

  // Setzen der Einstellungen für den Stepper-Motor
  stepper.setMaxSpeed(1000);
  stepper.setAcceleration(100);
  stepper.setCurrentPosition(0);

  // A4988 aktivieren
  digitalWrite(pin_step, LOW);   // Sicherstellen, dass kein Impuls anliegt
  digitalWrite(pin_enable, LOW); // Treiber aktivieren
  digitalWrite(pin_sleep, HIGH); // Sleep-Modus deaktivieren
  digitalWrite(pin_reset, HIGH); // Reset deaktivieren

  // Setzen der Ausgänge für die LEDs
  for (byte i = 0; i < 3; i++) {
    pinMode(led_pins[i], OUTPUT);
  }

  // Setzen der Eingänge für die Taster
  for (byte i = 0; i < 3; i++) {
    pinMode(button_pins[i], INPUT_PULLUP);
  }

  // Setzen der Ausgänge für die Treiber-Karte
  for (byte i = 0; i < 8; i++) {
    pinMode(pins_A4988[i], OUTPUT);
  }
}

void loop() {

  // Abruf der Funktionen

update_serial_monitor();

update_button_start();

update_button_left();

update_button_right();

update_operation_state();

execute_operation_states();

control_stepper();

execute_outputs();

}

//======================================================//
//====================Functions=========================//
//======================================================//

void update_serial_monitor() {

  // Timer für diesen Abschnitt
  unsigned long serial_timer = millis() - serial_millis;

  if (serial_timer > 200) {

    Serial.print("T.st: ");
    Serial.print(switch_start);

    Serial.print("  T.1_left: ");
    Serial.print(switch_left);

    Serial.print("  T.1_right: ");
    Serial.print(switch_right);

    Serial.print("  T.inf_left: ");
    Serial.print(turn_left);

    Serial.print("  T.inf_right: ");
    Serial.print(turn_right);

    Serial.print("  Cur.pos: ");
    Serial.print(current_steps);

    Serial.print("  Op: ");
    Serial.println(operation_state);

    serial_millis = millis();
  }
}

//======================================================//
//====================Functions=========================//
//======================================================//

void update_button_start() {

  // Timer für diesen Abschnitt
  unsigned long button_start_timer = millis() - button_start_millis;

  // Auslesen des Inputs
  button_read_start = digitalRead(button_pins[0]);

  if (button_read_start) {
    button_start_millis = millis();
  }

  if (!button_read_start && !button_on_start && button_start_timer > 20) {
    button_on_start = true;
  }

  if (button_read_start && button_on_start) {
    button_on_start = false;
    switch_start = !switch_start;
  }
}

//======================================================//
//====================Functions=========================//
//======================================================//

void update_button_left() {

    // Timer für diesen Abschnitt
    unsigned long button_left_timer = millis() - button_left_millis;

    // Auslesen des Inputs
    button_read_left = digitalRead(button_pins[1]);
  
    if (button_read_left) {
      button_left_millis = millis();
    }
  
    if (!button_read_left && !button_on_left && button_left_timer > 20) {
      button_on_left = true;
    }
  
    if (button_read_left && button_on_left) {
      button_on_left = false;

      if (button_left_timer < 500) {
        switch_left = !switch_left;
      }
    }

    if (button_left_timer > 500 && !button_read_left) {
      turn_left = true;
    } else {
      turn_left = false;
    }
}

//======================================================//
//====================Functions=========================//
//======================================================//

void update_button_right() {

    // Timer für diesen Abschnitt
    unsigned long button_right_timer = millis() - button_right_millis;

    // Auslesen des Inputs
    button_read_right = digitalRead(button_pins[2]);
  
    if (button_read_right) {
      button_right_millis = millis();
    }
  
    if (!button_read_right && !button_on_right && button_right_timer > 20) {
      button_on_right = true;
    }
  
    if (button_read_right && button_on_right) {
      button_on_right = false;

      if (button_right_timer < 500) {
      switch_right = !switch_right;
      }
    }

    if (button_right_timer > 500 && !button_read_right) {
      turn_right = true;
    } else {
      turn_right = false;
    }
}

//======================================================//
//====================Functions=========================//
//======================================================//

void update_operation_state() {

  if (switch_start) {

    switch(operation_state) {

      case system_standby:
      if (switch_left) {
        operation_state = one_revolution_left;
      } else if (switch_right) {
        operation_state = one_revolution_right;
      } else if (turn_left) {
        operation_state = rotation_left;
      } else if (turn_right) {
        operation_state = rotation_right;
      }
      break;

      case one_revolution_left:
      if (!switch_left) {
        operation_state = system_standby;
      }
      break;

      case one_revolution_right:
      if (!switch_right) {
        operation_state = system_standby;
      } break;

      case rotation_left:
      if (!turn_left) {
        operation_state = system_standby;
      }
      break;

      case rotation_right:
      if (!turn_right) {
        operation_state = system_standby;
      }
      break;

      default:
      operation_state = system_standby;
      break;

    }
  } else {
    operation_state = system_off;
  }
}

//======================================================//
//====================Functions=========================//
//======================================================//

void execute_operation_states() {

  // Timer für diesen Abschnitt
  unsigned long led_timer = millis() - led_millis;

  switch (operation_state) {

    case system_off:
    for (byte i = 0; i < 3; i++) {
      leds[i] = false;
    }
    break;

    case system_standby:
    leds[0] = true;
    leds[1] = false;
    leds[2] = false;
    break;

    case one_revolution_left:
    leds[0] = true;
    leds[1] = true;
    leds[2] = false;
    break;

    case one_revolution_right:
    leds[0] = true;
    leds[1] = false;
    leds[2] = true;
    break;

    case rotation_left:
    leds[0] = true;
    if (led_timer > 250) {
      leds[1] = !leds[1];
      led_millis = millis();
    }
    leds[2] = false;
    break;

    case rotation_right: 
    leds[0] = true;
    leds[1] = false;
    if (led_timer > 250) {
      leds[2] = !leds[2];
      led_millis = millis();
    }
    break;
  }
}

//======================================================//
//====================Functions=========================//
//======================================================//

void control_stepper() {

  // Variablen für diesen Abschnitt

  current_steps = stepper.currentPosition();

  switch(operation_state) {

    case system_off:
    digitalWrite(pin_enable, HIGH);
    break;

    case system_standby:
    digitalWrite(pin_enable, LOW);
    break;

    case one_revolution_left:
    stepper.moveTo(-200);
    stepper.run();
    if (current_steps <= -200) {
      stepper.setCurrentPosition(0);
      switch_left = false;
    }
    break;

    case one_revolution_right:
    stepper.moveTo(200);
    stepper.run();
    if (current_steps >= 200) {
      stepper.setCurrentPosition(0);
      switch_right = false;
    }
    break;

    case rotation_left:
    stepper.setSpeed(-750);
    stepper.runSpeed();
    break;

    case rotation_right:
    stepper.setSpeed(750);
    stepper.runSpeed();
    break;
  }
}

//======================================================//
//====================Functions=========================//
//======================================================//

void execute_outputs() {

  for (byte i = 0; i < 3; i++) {
    digitalWrite(led_pins[i], leds[i]);
  }
}

//======================================================//
//====================Functions=========================//
//======================================================//