#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_automatic = 0;
unsigned long stepper_millis = 0;

// Zu verändernde Variablen
int speed_automatic = 1000;
int stepper_speed_manual = 300;
byte acceleration = 5;

// Belegung der Led_pins
const byte pin_led_start = 10;
const byte pin_led_left_driection = 12;
const byte pin_led_right_direction = 11;
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};

byte led_start_var = 0;
byte var_flag = false;
unsigned long var_millis = 0;

// 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;

// Counter für die Modis
byte modi_counter = 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;

// 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};

// Setzen der State-Machine
enum current_operation_state {

  system_off,

  manual_operation,

  automatic_operation
};

current_operation_state operation_state = system_off;

enum current_stepper_operation {

  stepper_standby,

  spin_left,
  spin_right,

  constant_left,
  constant_right
};

current_stepper_operation stepper_operation = stepper_standby;


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();

// Setzen globaler Timer
unsigned long serial_millis = 0;


void setup() {

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

  // Setzen der Einstellungen für den Stepper-Motor
  stepper.setMaxSpeed(1500);
  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
  digitalWrite(pin_MS1, LOW);
  digitalWrite(pin_MS2, LOW);
  digitalWrite(pin_MS3, LOW);

  // 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() {

  unsigned long serial_timer = millis() - serial_millis;

  if (serial_timer > 250) {
    
    Serial.print(" Modi = ");
    Serial.print(operation_state);

    Serial.print(" Stepper = ");
    Serial.print(stepper_operation);

    Serial.print(" S.Taster = ");
    Serial.print(switch_start);

    Serial.print(" L.Taster = ");
    Serial.print(switch_left);

    Serial.print(" R.Taster = ");
    Serial.print(switch_right);

    Serial.print(" Speed_auto ");
    Serial.println(stepper_speed_automatic);

    serial_millis = millis();
  }
}

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

void update_button_start() {

  // Variablen für diesen Abschnitt
  unsigned long button_start_timer = millis() - button_start_millis;
  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;
    modi_counter++;
  }

  if (modi_counter > 2) {
    modi_counter = 0;
  }
}

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

void update_button_left() {

  // Variablen für diesen Abschnitt
  unsigned long button_left_timer = millis() - button_left_millis;
  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;
    switch_left =! switch_left;
  }
}

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

void update_button_right() {

    // Variablen für diesen Abschnitt
  unsigned long button_right_timer = millis() - button_right_millis;
  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;
    switch_right =! switch_right;
  }
}

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

void update_operation_state() {

  if (modi_counter == 0) {
    operation_state = system_off;
    stepper_operation = stepper_standby;
  }

  if (modi_counter == 1) {
    operation_state = manual_operation;
    if (operation_state == manual_operation && !button_read_left && button_read_right) {
      stepper_operation = spin_left;
    } else if (operation_state == manual_operation && !button_read_right && button_read_left) {
      stepper_operation = spin_right;
    } else {
      stepper_operation = stepper_standby;
    }
  }

  if (modi_counter == 2) {
    operation_state = automatic_operation;
    if (operation_state == automatic_operation && switch_left && !switch_right) {
      stepper_operation = constant_left;
      switch_right = false;
    } else if (operation_state == automatic_operation && switch_right && !switch_left) {
      stepper_operation = constant_right;
      switch_left = false;
    } else {
      stepper_operation = stepper_standby;
      switch_left = false;
      switch_right = false;
    }
  }
}

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

void execute_operation_states() {

  // Variablen für diesen Abschnitt
  unsigned long var_timer = millis() - var_millis;
  unsigned long stepper_timer = millis() - stepper_millis;

  switch(operation_state) {

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

    case manual_operation:
    if (var_timer > 2 && led_start_var < 255 && var_flag == false) {
      led_start_var++;
      var_millis = millis();
    } 
    
    if (led_start_var == 255) {
      var_flag = true;
    } 
    
    if (var_timer > 2 && led_start_var > 0 && var_flag == true) {
      led_start_var--;
      var_millis = millis();
    }

    if (led_start_var == 0) {
      var_flag = false;
    }

    if (stepper_operation == spin_left) {
      leds[1] = true;
      leds[2] = false;
    } else if (stepper_operation == spin_right) {
      leds[1] = false;
      leds[2] = true;
    } else {
      leds[1] = false;
      leds[2] = false;
    }

    switch_left = false;
    switch_right = false;
    break;

    case automatic_operation: 

    led_start_var = 255;

    if (stepper_operation == constant_left) {
      leds[1] = true;
      leds[2] = false;
    } else if (stepper_operation == constant_right) {
      leds[1] = false;
      leds[2] = true;
    } else {
      leds[1] = false;
      leds[2] = false;
    }
    break;
  }

  switch(stepper_operation) {

    case stepper_standby:
    stepper_speed_automatic = 0;
    break;

    case constant_left:
    if (stepper_speed_automatic > -speed_automatic && stepper_timer > acceleration) {
      stepper_speed_automatic--;
      stepper_millis = millis();
    }
    break;

    case constant_right:
    if (stepper_speed_automatic < speed_automatic && stepper_timer > acceleration) {
      stepper_speed_automatic++;
      stepper_millis = millis();
    }
    break;
  }

  
}

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

void control_stepper() {

  switch(stepper_operation) {

    case stepper_standby:
    digitalWrite(pin_enable, HIGH);
    digitalWrite(pin_sleep, LOW);
    break;

    case spin_left:
    digitalWrite(pin_enable, LOW);
    digitalWrite(pin_sleep, HIGH);
    stepper.setSpeed(-stepper_speed_manual);
    stepper.runSpeed();
    break;

    case spin_right:
    digitalWrite(pin_enable, LOW);
    digitalWrite(pin_sleep, HIGH);
    stepper.setSpeed(stepper_speed_manual);
    stepper.runSpeed();
    break;

    case constant_left:
    digitalWrite(pin_enable, LOW);
    digitalWrite(pin_sleep, HIGH);
    stepper.setSpeed(stepper_speed_automatic);
    stepper.runSpeed();
    break;

    case constant_right:
    digitalWrite(pin_enable, LOW);
    digitalWrite(pin_sleep, HIGH);
    stepper.setSpeed(stepper_speed_automatic);
    stepper.runSpeed();
    break;
  }
}

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

void execute_outputs() {

  digitalWrite(led_pins[1], leds[1]);
  digitalWrite(led_pins[2], leds[2]);
  analogWrite(led_pins[0], led_start_var);

}

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