// Anlegen der benötigten Bibliotheken
#include <Arduino.h>
#include <LiquidCrystal_I2C.h>
#include <OneWire.h>
#include <DallasTemperature.h>

// Adresse für den LCD
LiquidCrystal_I2C lcd(0x27, 20, 4);

// Pins für den Stepper-Treiber
const byte STEP_PIN = 8;
const byte DIR_PIN = 7;

// Variablen für den Treiber
unsigned long step_interval_setpoint = 1000;
unsigned long stepper_millis = 0;
int current_step = 0;
int target_step = 0;
int effective_steps = 0;

// Pin für den DS18B20-Datenpin
#define ONE_WIRE_BUS A1

// OneWire-Objekt erstellen
OneWire oneWire(ONE_WIRE_BUS);

// DallasTemperature-Objekt erstellen
DallasTemperature sensors(&oneWire);

// Variable für den ds18b20
float temperature = 0;

// Setzen des SetPoints
byte setpoint_temperature = 20;

// Belegung für die LEDs
const byte red_led_pin = 13;
const byte green_led_pin = 12;
byte led_pins[2] = {red_led_pin, green_led_pin};

// Belegung der Taster
const byte start_button_pin = 11;
const byte decrease_button_pin = 10;
const byte increase_button_pin = 9;
byte button_pins[3] = {start_button_pin, decrease_button_pin, increase_button_pin};

// Variablen für den Start-Button
bool button1_read = false;
bool button1_on = false;
bool switch1 = false;
unsigned long button1_millis = 0;

// Variablen für die Setpoint_Buttons
unsigned long decrease_millis = 0;
unsigned long increase_millis = 0;

// Belgung für den Potentiometer
const byte poti_pin = A0;

// Belegung des Relais
const byte relais1_pin = 6;

// Benötigte Timer
unsigned long serial_millis = 0;
unsigned long fan_millis = 0;

// Initialisierung der State-Maschine

// Gültig für das gesamte System
enum current_operation_state {

  system_switched_off,
  cooling_disabled,
  cooling_enabled
};
current_operation_state operation_state = system_switched_off;

// Steuerung für den Lüftervorgang
enum current_fan_state {

  fan_operation_stopped,
  open_fan_shaft,
  start_fan,
  fan_in_operation,
  stop_fan,
  close_fan_shaft
};
current_fan_state fan_state = fan_operation_stopped;

byte previous_fan_state = fan_operation_stopped;

// Vorausdeklaration der Void-Abschnitte
void update_serial_monitor();
void update_lcd_display();
void read_ds18b20();
void update_button_start();
void update_setpoint();
void manage_operation_state();
void manage_fan_state();
void execute_fan_state();
void manage_stepper_motor();


void setup() {

  // Starten des Serial_Monitors
  Serial.begin(9600);
  Serial.println("Serial_Monitor gestartet");

  // Ausgänge für den Stepper-Motor
  Serial.println("Setzen des STEP: ");
  Serial.print("PIN: ");
  pinMode(STEP_PIN, OUTPUT);
  Serial.print(STEP_PIN);
  Serial.println(" auf OUTPUT gesetzt.");

  Serial.println("Setzen des DIR: ");
  Serial.print("PIN: ");
  pinMode(DIR_PIN, OUTPUT);
  Serial.print(DIR_PIN);
  Serial.println(" auf OUTPUT gesetzt.");

  // Setzen der Outputs für die LEDs
  Serial.println("Setzen der LED OUTPUTS: ");
  for (byte i = 0; i < 2; i++) {
    Serial.print("PIN: ");
    pinMode(led_pins[i], OUTPUT);
    Serial.print(led_pins[i]);
    Serial.println(" auf OUTPUT gesetzt.");
  }

  // Setzen der Inputs für die Taster
  Serial.println("Setzen der Button Inputs: ");
  for (byte i = 0; i < 3; i++) {
    Serial.print("PIN: ");
    pinMode(button_pins[i], INPUT_PULLUP);
    Serial.print(button_pins[i]);
    Serial.println(" auf INPUT-PULLUP gesetzt.");
  }

  // Setzen des Inputs für den Poti
  Serial.println("Setzen des POTI Input: ");
  Serial.print("PIN: ");
  pinMode(poti_pin, INPUT);
  Serial.print(poti_pin);
  Serial.println(" auf INPUT gesetzt.");

  // Setzen des Outputs für das Relais
  Serial.println("Setzen des Relais Output: ");
  Serial.print("PIN: ");
  pinMode(relais1_pin, OUTPUT);
  Serial.print(relais1_pin);
  Serial.println(" auf OUTPUT gesetzt.");

  // DallasTemperature-Sensoren initialisieren
  sensors.begin();
  Serial.println("DS18B20 Temperatur-Sensor Test");

  // Initialisierung des LCD
  lcd.begin(20, 4);
  lcd.backlight();
  Serial.println("LCD-Display initialisiert");
}

void loop()
{

  // Abruf der Funktionfür das Display
  update_lcd_display();

  // Abruf der Funktion zum Auslesen der Inputs
  read_ds18b20();

  // Abruf der Funktion zum Auslesen des Start-Buttons
  update_button_start();

  // Abruf der Funktion zum Setzen des SetPoint
  update_setpoint();

  // Abruf der Funktion für den Operation_State
  manage_operation_state();

  // Abruf der Funktion für den Fan_State
  manage_fan_state();

  // Abruf der Funktion zum Ausführen des Fan_State
  execute_fan_state();

  // Abruf der Funktion für den Stepper-Motor
  manage_stepper_motor();

  // Abruf der Funktion für den Seriellen Monitor
  update_serial_monitor();
}

//====================================================================//
//==============================FUNCTIONS=============================//
//====================================================================//

void update_serial_monitor() {

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

  if (serial_timer > 250) {

    Serial.print("switch1: ");
    Serial.print(switch1);

    Serial.print(" temperature: ");
    Serial.print(temperature);

    Serial.print(" SP: ");
    Serial.print(setpoint_temperature);

    Serial.print(" op_state: ");
    Serial.print(operation_state);

    Serial.print(" fan_state: ");
    Serial.print(fan_state);

    Serial.print(" M_Sp.: ");
    Serial.print(step_interval_setpoint);

    Serial.print(" St.Sr.: ");
    Serial.print(effective_steps);

    Serial.print(" Prev.: ");
    Serial.println(previous_fan_state);

    serial_millis = millis();
  }
}

//====================================================================//
//==============================FUNCTIONS=============================//
//====================================================================//

void update_lcd_display() {}

//====================================================================//
//==============================FUNCTIONS=============================//
//====================================================================//

void read_ds18b20() {

  // Sensoren auffordern, Temperatur zu messen
  sensors.requestTemperatures();

  // Temperatur vom ersten Sensor auslesen
  temperature = sensors.getTempCByIndex(0);
}

//====================================================================//
//==============================FUNCTIONS=============================//
//====================================================================//

void update_button_start() {

  // Varisblen für diesen Abschnitt
  unsigned long button1_timer = millis() - button1_millis;
  button1_read = digitalRead(button_pins[0]);

  if (button1_read) {
    button1_millis = millis();
  }

  if (!button1_read && !button1_on && button1_timer > 20) {
    button1_on = true;
  }

  if (button1_read && button1_on) {
    button1_on = false;
    switch1 = !switch1;
  }
}

//====================================================================//
//==============================FUNCTIONS=============================//
//====================================================================//

void update_setpoint() {

  // Variablen für diesen Abschnitt
  int poti_raw = analogRead(poti_pin);
  bool decrease_button = digitalRead(button_pins[1]);
  bool incease_button = digitalRead(button_pins[2]);
  unsigned long decrease_timer = millis() - decrease_millis;
  unsigned long increase_timer = millis() - increase_millis;

  if (!decrease_button && decrease_timer > 250) {
    setpoint_temperature--;
    decrease_millis = millis();
  }

  if (!incease_button && increase_timer > 250) {
    setpoint_temperature++;
    increase_millis = millis();
  }

  step_interval_setpoint = map(poti_raw, 0, 1023, 0, 800);
}

//====================================================================//
//==============================FUNCTIONS=============================//
//====================================================================//

void manage_operation_state() {

  if (switch1) {

    if (temperature > (setpoint_temperature + 1)) {
      operation_state = cooling_enabled;
    }

    if (temperature < (setpoint_temperature - 1)) {
      operation_state = cooling_disabled;
    }
  } else {
    operation_state = system_switched_off;
  }
}

//====================================================================//
//==============================FUNCTIONS=============================//
//====================================================================//

void manage_fan_state() {

  // Variablen für diesen Abschnitt
  unsigned long fan_timer = millis() - fan_millis;

  if (operation_state == cooling_enabled) {

    switch(fan_state) {

      case open_fan_shaft:
      if (effective_steps == 50) {
        fan_millis = millis();
        fan_state = start_fan;
      }
      break;

      case start_fan:
      if (fan_timer > 500) {
        fan_millis = millis();
        fan_state = fan_in_operation;
      }
      break;

      case fan_in_operation:
      fan_millis = millis();
      break;

      default:
      fan_state = open_fan_shaft;
      fan_millis = millis();
    }
  }

  if (operation_state == cooling_disabled) {

    switch(fan_state) {

      case fan_in_operation:
      if (fan_timer > 1500) {
        fan_millis = millis();
        fan_state = stop_fan;
      }
      break;

      case stop_fan:
      if (fan_timer > 1500) {
        fan_millis = millis();
        fan_state = close_fan_shaft;
      }
      break;

      case close_fan_shaft:
      if (effective_steps == 0) {
        fan_millis = millis();
        fan_state = fan_operation_stopped;
      }
      break;

      case fan_operation_stopped:
      fan_millis = millis();
    }
  }

  if (operation_state == system_switched_off) {
    fan_state = fan_operation_stopped;
  }
}

//====================================================================//
//==============================FUNCTIONS=============================//
//====================================================================//

void execute_fan_state() {

  switch(fan_state) {

    case fan_operation_stopped:
    target_step = 0;
    digitalWrite(led_pins[0], HIGH);
    digitalWrite(led_pins[1], LOW);
    digitalWrite(relais1_pin, LOW);
    break;

    case open_fan_shaft:
    target_step = 100;
    digitalWrite(led_pins[0], LOW);
    digitalWrite(led_pins[1], HIGH);
    digitalWrite(relais1_pin, LOW);
    break;

    case start_fan:
    target_step = 100;
    digitalWrite(led_pins[0], LOW);
    digitalWrite(led_pins[1], HIGH);
    digitalWrite(relais1_pin, HIGH);
    break;

    case fan_in_operation:
    target_step = 100;
    digitalWrite(led_pins[0], LOW);
    digitalWrite(led_pins[1], HIGH);
    digitalWrite(relais1_pin, HIGH);
    break;

    case stop_fan:
    target_step = 100;
    digitalWrite(led_pins[0], LOW);
    digitalWrite(led_pins[1], HIGH);
    digitalWrite(relais1_pin, LOW);
    break;

    case close_fan_shaft:
    target_step = 0;
    digitalWrite(led_pins[0], LOW);
    digitalWrite(led_pins[1], HIGH);
    digitalWrite(relais1_pin, LOW);
    break;
  }
}

//====================================================================//
//==============================FUNCTIONS=============================//
//====================================================================//

void manage_stepper_motor() {

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

  if (stepper_timer > step_interval_setpoint) {

    if (current_step < target_step) {
      digitalWrite(DIR_PIN, HIGH);
      digitalWrite(STEP_PIN, HIGH);
      delayMicroseconds(5);
      digitalWrite(STEP_PIN, LOW);

      current_step++;

    }

    if (current_step > target_step) {
      digitalWrite(DIR_PIN, LOW);
      digitalWrite(STEP_PIN, HIGH);
      delayMicroseconds(5);
      digitalWrite(STEP_PIN, LOW);

      current_step--;

    }
  }

  effective_steps = current_step / 2;
}

//====================================================================//
//==================================END===============================//
//====================================================================//