#include <Arduino.h>

#include <OneWire.h>
#include <LiquidCrystal_I2C.h>
#include <Servo.h>
#include <HX711.h>

// Adressierung des LCD
LiquidCrystal_I2C lcd(0x27, 20, 4);

// Belegung der Aktuatoren

// Servo-Objekt erstellen
Servo servo;

// Belegung der Waage
#define DOUT A1
#define CLK A0

// Erstelle ein HX711-Objekt
HX711 scale;

// Belegung der Eingänge
#define NOT_AUS_input 2
#define start_button_input 4
#define lichtschranke_input 6

// Belegung der Ausgänge
#define led_green 7
#define led_red 8
#define motor_f 3
#define servo_pin 5

// Variablen für den Start-Taster
bool button_on = false;
bool button_read = false;
bool switch0 = false;

// Variable für die Lichtschranke
bool lichtschranke = false;

// Variable für den NOT-Aus
bool NOT_AUS = false;

// Variablen für die Waage
long weight_raw = 0;
long weight = 0;

// Variablen für den Servo
int servo_winkel = 90;

// Variablen für die led's
bool led_red_v = false;
bool led_green_v = false;

// Variable für den Motor
bool motor_f_v = false;

// Varaiblen für die Counter
byte counter_1 = 0;
byte counter_2 = 0;

// Setzen der Timer
unsigned long serial_millis = 0;
unsigned long button_millis = 0;
unsigned long servo_millis = 0;
unsigned long lcd_millis = 0;
unsigned long weight_millis = 0;
unsigned long operation_millis = 0;
unsigned long counter_millis = 0;

// Setzen der Netzwerke
enum operation_state {
  anlage_aus,
  anlage_im_betrieb,
  warte_auf_lichtschranke,
  foerderband_anhalten,
  wiegen,
  objekt_erkannt,
  sortieren,
  sortierarm_on,
  sortierarm_off,
};
operation_state operation_state = anlage_aus;

// Vorausdeklaration der Abschnitte
void update_serial_monitor();
void update_lcd();
void manage_toggle_switch();
void set_weight();
void handle_servo();
void manage_states();
void update_states();



void setup() {

  // Servo mit Pin 15 des Arduino verbinden
  servo.attach(servo_pin);

  // Initialisiere HX711 mit DOUT und CLK
  scale.begin(DOUT, CLK);

  // Initialisierung des LCD
  lcd.init();
  lcd.backlight();

  // Setzen der inputs
  pinMode(NOT_AUS_input, INPUT_PULLUP);
  pinMode(start_button_input, INPUT_PULLUP);
  pinMode(lichtschranke_input, INPUT_PULLUP);

  // Setzen der Outputs
  pinMode(led_green, OUTPUT);
  pinMode(led_red, OUTPUT);
  pinMode(motor_f, OUTPUT);

  // Initialisierung des Serial_Monitors
  Serial.begin(9600);
}

void loop() {

  // Abruf der Funktion für den Serial_Montor
  update_serial_monitor();

  // Abruf der Funktion für den lcd
  update_lcd();

  // Abruf der Funktion für den Taster
  manage_toggle_switch();

  // Abruf der Funktion für die Waage
  set_weight();

  // Abruf der Funktion für den Sortier-Servo
  handle_servo();

  // Abruf der Funktionen für die Zustände
  manage_states();

  // Abruf der Funktion für das Updaten
  update_states();
}

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

// Funktion für den Serial_Montor
void update_serial_monitor() {

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

  if (serial_timer > 250) {

    Serial.print(" Switch0 == ");
    Serial.println(switch0);

    Serial.print(" Gewicht == ");
    Serial.print(weight);

    Serial.print(" lichtschranke == ");
    Serial.print(lichtschranke);

    Serial.print(" operation_state == ");
    Serial.print(operation_state);

    Serial.print(" NOT_AUS == ");
    Serial.print(NOT_AUS);

    serial_millis = millis();
  }
}

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

// Funktion für den lcd
void update_lcd() {


  

  lcd.setCursor(0, 0);
  lcd.print("Ein-Taster =");

  lcd.setCursor(0, 1);
  lcd.print("Gewicht    =");
  lcd.setCursor(17, 1);
  lcd.print("gr.");

  lcd.setCursor(0, 2);
  lcd.print("Zaehler1   =");
  lcd.setCursor(0, 3);
  lcd.print("Zaehler2   =");

  lcd.setCursor(13, 2);
  lcd.print(counter_1);
  lcd.setCursor(13, 3);
  lcd.print(counter_2);


  
  if (switch0) {
  lcd.setCursor(13, 0);
  lcd.print("AN ");
  } else {
  lcd.setCursor(13, 0);
  lcd.print("AUS");
  }

  switch (operation_state) {

    case objekt_erkannt:
    if (weight < 1000) {
      lcd.setCursor(13, 1);
      lcd.print("      ");
      lcd.setCursor(13, 1);
      lcd.print(weight);
    }
    lcd.setCursor(13, 1);
    lcd.print(weight);
  }
}

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

// Funktion für den Taster
void manage_toggle_switch() {

  // Variablen für diesen Abschnitt
  button_read = digitalRead(start_button_input);
  unsigned long button_timer = millis() - button_millis;

  if (button_read == true) {
    button_millis = millis();
  }

  if (button_read == false && button_on == false && button_timer > 20) {
    button_on = true;
  }

  if (button_read == true && button_on == true) {
    button_on = false;
    switch0 = !switch0;
  }
}

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

// Funktion für die Waage
void set_weight() {

    if (scale.is_ready()) {
      weight_raw = scale.get_units();
    }

  weight = map(weight_raw, 0, 2100, 0, 5000);
  }


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

// Funktion für den Sortier-Servo
void handle_servo() {

  // Variablen für diesen Abschnitt


  switch (operation_state) {

    case sortierarm_on:
    servo_winkel = 0;
    break;

    case sortierarm_off:
    servo_winkel = 90;
    break;
  }

   servo.write(servo_winkel); 
}

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

// Funktionen für die Zustände
void manage_states() {
  // Variablen für diesen Abschnitt
  NOT_AUS = !digitalRead(NOT_AUS_input);
  lichtschranke = digitalRead(lichtschranke_input);
  unsigned long operation_timer = millis() - operation_millis;

  if (switch0 == true && NOT_AUS == true) {

    switch (operation_state) {

      case anlage_im_betrieb:
      if (operation_timer > 1000) {
        operation_state = warte_auf_lichtschranke;
      }
      break;

      case warte_auf_lichtschranke:
        if (lichtschranke == false) {
          operation_state = foerderband_anhalten;
          operation_millis = millis();
        }
        break;

      case foerderband_anhalten:
        if (operation_timer > 1000) {
          operation_state = wiegen;
          operation_millis = millis();
        }
        break;

      case wiegen:
        if (operation_timer > 1000) {
          operation_state = objekt_erkannt;
          operation_millis = millis();
          counter_millis = millis();
        }
        break;

      case objekt_erkannt:
        if (weight > 2500 && operation_timer > 1000) {
          operation_state = sortierarm_on;
          operation_millis = millis();
          counter_1++;
        } else if (weight < 2500 && operation_timer > 1000) {  
            operation_state = anlage_im_betrieb;
            operation_millis = millis();
            counter_2++;
        }
        break;

      case sortierarm_on:
        if (operation_timer > 3000) {
          operation_state = sortierarm_off;
          operation_millis = millis();
        }
        break;

      case sortierarm_off:
        if (servo_winkel == 90) {
          operation_state = anlage_im_betrieb;
          operation_millis = millis();
        }
        break;

      default:
        operation_state = anlage_im_betrieb;
        operation_millis = millis();
    }
  } else {
    operation_state = anlage_aus;
  }
}


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

// Funktion für das Updaten
void update_states() {

  switch (operation_state) {

    case anlage_aus:
    led_red_v = true;
    led_green_v = false;
    motor_f_v = false;
    servo_winkel = 90;
    break;

    case anlage_im_betrieb:
    led_red_v = false;
    led_green_v = true;
    motor_f_v = true;
    break;

    case warte_auf_lichtschranke:
    led_red_v = false;
    led_green_v = true;
    motor_f_v = true;
    break;

    case foerderband_anhalten:
    led_red_v = false;
    led_green_v = true;
    motor_f_v = false;
    break;

    case wiegen:
    led_red_v = false;
    led_green_v = true;
    motor_f_v = false;
    break;

    case objekt_erkannt:
    led_red_v = false;
    led_green_v = true;
    motor_f_v = true;
    break;
  }


  digitalWrite(led_green, led_green_v);
  digitalWrite(led_red, led_red_v);
  digitalWrite(motor_f, motor_f_v);
}

//===================================================//
//=======================ENDE========================//
//===================================================//