// Zapfwellenstatus über Analogeingang mit Spannung der Anliegenden Fequenz auswerten und schalten
// Für Signalsteckdose nach Din 9684 bzw Din Iso 11786
// Belegung Zapfwelle auf Pin 3 der Signalsteckdose

// Hardware Arduino Leonardo oder Pro Micro + Spannungsteiler oder mit Spannungssensor-Arduino-Gleichstrom-0-25V
// Werte sind je nach Hardware anzupassen

// rev00: Stand 18.02.2024
// rev01: Stand 19.02.2024 - Zapfwellensignal integrieren
// rev02: Stand 08.03.2024 - Änderung der Tasterfunktionen im Modus Hubwerk
// rev03: Stand 19.03.2024 - Implementierung des Displays, Serial Monitor entfernen
// rev04: Stand 02.04.2024 - case 1, 2 und 0 fertiggestellt
// rev05: Stand 07.04.2024 - poti für HubHoehe integriert

#include <Arduino.h>
#include <Keyboard.h>
#include <U8glib.h>

//U8GLIB_SH1106_128X64 u8g(13, 11, 10, 9); // SW SPI Com: SCK = 13, MOSI(SDA) = 11, CS = 10, A0(DC) = 9
U8GLIB_SSD1306_128X64 u8g(U8G_I2C_OPT_DEV_0 | U8G_I2C_OPT_NO_ACK | U8G_I2C_OPT_FAST); // Fast I2C / TWI

int Wahl1 = 7;
int Wahl2 = 6;
int Wahl3 = 5;

int Einstellung;
//int LED = 2; // Arduino Micro
int LED = 4; // Arduino Nano
bool reset = 5;

/* Arduino Micro
  int BtnMan = A0;
  int BtnHub = A4;
  int BtnZapf = A5;
  int analogInputZW = A6; */

// Arduino Nano
int BtnMan = 2;
int BtnHub = A6;
int BtnZapf = A7;
int analogInputZW = A0;
const int HubHoehePin = A3;
const float referenceSpannung = 5.0;
float HubHoeheSpannungALT;

float SpannungHubIST;
float SpannungHubALT;

bool MarkOn = false;
bool lastMarkOn = false;
bool lastButtonState = HIGH;
bool HubwerkState = false;
bool lastHubwerkState = HIGH;

//float HubHoehe = 12;
float Messwert;
float SpannungProzent;

int values = 0;

#define anzahlMittelWerte 15 //<-------------------------------------------- Festlegen der Menge an Werte die in den Mittelwert einfliesen
int werte[anzahlMittelWerte], zaehlerMittelWerte = 0;

float UmdrehZW = 0;

void draw(void)
{
  u8g.setContrast(200);
  u8g.setFont(u8g_font_6x10);
  u8g.setColorIndex(1);

  u8g.drawStr(0, 10, "EINSTELLUNGEN:");
  u8g.drawHLine(0, 12, 164);
  u8g.drawStr(0, 27, "1.) Manuell");
  u8g.drawStr(0, 37, "2.) Hubwerk");
  u8g.drawStr(0, 47, "3.) Zapfwelle");
}

void drawManuell(void)
{
  u8g.setContrast(200);
  u8g.setFont(u8g_font_6x10);
  u8g.setColorIndex(1);

  u8g.drawStr(0, 10, "Manuell:");
  u8g.drawHLine(0, 12, 164);
}

void drawHubwerk(void)
{
  u8g.setContrast(200);
  u8g.setFont(u8g_font_6x10);
  u8g.setColorIndex(1);

  u8g.drawStr(0, 10, "Hubwerk:");
  u8g.drawHLine(0, 12, 164);
}

void drawZapfwelle(void)
{
  u8g.setContrast(200);
  u8g.setFont(u8g_font_6x10);
  u8g.setColorIndex(1);

  u8g.drawStr(0, 10, "Zapfwelle:");
  u8g.drawHLine(0, 12, 164);
  u8g.drawStr(0, 25, "ZW-Drehzahl:");
  u8g.setFont(u8g_font_fub25);
  u8g.setPrintPos(30, 60);
  u8g.print(UmdrehZW);
}

void MarkierungHub() {
  if (MarkOn) {
    u8g.drawStr(0, 28, "Markierung: aktiv!");
  } else {
    u8g.drawStr(0, 28, "Markierung: inaktiv!");
  }
}

float HubHoehe()
{
  int Value = analogRead(HubHoehePin);
  int prozent = map(Value, 0, 1023, 100, 0);
  float HubHoeheSpannung = (Value / 1023.0) * (referenceSpannung - 0.1);

  char buffer[10];
  sprintf(buffer, "%d", prozent);
  u8g.drawStr(0, 38, "Hubhoehe Mark.: ");
  u8g.drawStr(97, 38, buffer);
  u8g.drawStr(110, 38, " %");
 /*if (HubHoeheSpannung != HubHoeheSpannungALT)
  {
    Serial.print("Prozent: ");
    Serial.print(prozent);
    Serial.print(" - Spannung: ");
    Serial.print(HubHoeheSpannung, 2);
    Serial.println(" V");

    delay(50);
    HubHoeheSpannungALT = HubHoeheSpannung;
  }*/
  return HubHoeheSpannung;
}

void Hubwerk(void)
// Hubwerk oben = aus = 1,5V; Hubwerk unten = ein = 6V
// Dieser Wert muß mit der Hubhöhe (Einschalthöhe) angepasst werden

{
  //float HubHoeheSpannung = HubHoehe();

  if (SpannungHubIST > HubHoehe())
  {
    u8g.drawStr(0, 48, "Hubwerk: unten!");
    HubwerkState = LOW;
  }
  if (SpannungHubIST <= HubHoehe())
  {
    u8g.drawStr(0, 48, "Hubwerk: oben!");
    HubwerkState = HIGH;
  }
}

void resetDisplay(void)
{
  // Setze das Display zurück
  digitalWrite(reset, LOW);  // Aktiviere Reset
  delay(10);                 // kurze Verzögerung
  digitalWrite(reset, HIGH); // Deaktiviere Reset
  delay(10);                 // kurze Verzögerung
}

void setup()
{
  // put your setup code here, to run once:

  //Keyboard.begin();
  Serial.begin(9600);

  pinMode(Wahl1, INPUT_PULLUP);
  pinMode(Wahl2, INPUT_PULLUP);
  pinMode(Wahl3, INPUT_PULLUP);

  pinMode(BtnMan, INPUT_PULLUP);
  pinMode(BtnHub, INPUT_PULLUP);
  pinMode(BtnZapf, INPUT_PULLUP);

  pinMode(LED, OUTPUT);
  pinMode(reset, OUTPUT);

  pinMode(analogInputZW, INPUT);

}

void loop()
{
  // put your main code here, to run repeatedly:

  resetDisplay();

  if (digitalRead(Wahl1) == LOW)
  {
    Einstellung = 1;
  }
  if (digitalRead(Wahl2) == LOW)
  {
    Einstellung = 2;
  }
  if (digitalRead(Wahl3) == LOW)
  {
    Einstellung = 3;
  }
  if (digitalRead(Wahl1) == HIGH && digitalRead(Wahl2) == HIGH && digitalRead(Wahl3) == HIGH)
  {
    Einstellung = 0;
  }

  int buttonState = digitalRead(BtnMan);

  Messwert = analogRead(BtnHub);             // Spannungswert am analogen Eingang auslesen
  SpannungProzent = map(Messwert, 0, 1023, 100, 0); // Umwandeln des Sensorwertes mit Hilfe des "map" Befehls. Da der Map-Befehl keine Kommastellen ausgibt, wird hier vorerst mit größeren Zahlen gearbeitet.
  //SpannungHubIST = SpannungProzent / 5;                  // Das Ergebnis wird nun durch 5 geteilt, um die Anzeige als korrekten Wert mit einer Nachkommastelle ausgeben zu können.
  SpannungHubIST = (Messwert / 1023) * referenceSpannung;
  /*if (SpannungHubIST != SpannungHubALT) 
  {
  Serial.print("Prozent: ");
  Serial.print(SpannungProzent);
  Serial.print(" - Spannung: ");
  Serial.print(SpannungHubIST, 2);
  Serial.println(" V");
  delay(50);
  SpannungHubALT = SpannungHubIST;
  }*/


  values = analogRead(analogInputZW); // Messwerte am analogen Pin als "values" definieren
  float UmdrehZW = mittelWert(values);

  switch (Einstellung)
  {
    case 1:
      u8g.firstPage();
      do {
        drawManuell();
        // Markierung();
        MarkierungHub();
        Hubwerk();
      }
      while (u8g.nextPage());

      if (buttonState == LOW && lastButtonState == HIGH)
      {
        MarkOn = !MarkOn;
        delay(100);
      }
      lastButtonState = buttonState;
      if (MarkOn != lastMarkOn)
      {
        lastMarkOn = MarkOn;
        if (MarkOn)
        {
          Serial.println("m on");
          digitalWrite(LED, HIGH);
        } else
        {
          Serial.println("m off");
          digitalWrite(LED, LOW);
        }
      }
      else if (buttonState == HIGH && lastButtonState == LOW)
      {
        lastButtonState = buttonState;
      }
      break;

    case 2:
      u8g.firstPage();
      do
      {
        drawHubwerk();
        //Markierung();
        MarkierungHub();
        Hubwerk();
      } while (u8g.nextPage());

      HubHoehe();

      // Umschalten von MarkOn basierend auf Taster- oder Hubwerk-Zustand
      if ((buttonState == LOW && lastButtonState == HIGH && lastMarkOn == false)
          || (buttonState == LOW && lastButtonState == HIGH && lastMarkOn == true)
          || (HubwerkState == LOW && lastHubwerkState == HIGH && lastMarkOn == false)
          || (HubwerkState == HIGH && lastHubwerkState == LOW && lastMarkOn == true)) {
        MarkOn = !MarkOn; // Umschalten von MarkOn
        delay(50); // Entprellen
      }

      // Speichern der aktuellen Zustände für den nächsten Durchlauf
      lastButtonState = buttonState;
      lastHubwerkState = HubwerkState;

      // Überprüfen, ob sich MarkOn geändert hat
      if (MarkOn != lastMarkOn) {
        lastMarkOn = MarkOn;
        if (MarkOn) {
          // Wenn MarkOn ist true, schalte die LED ein
          Serial.println("LED einschalten");
          digitalWrite(LED, HIGH);
        } else {
          // Wenn MarkOn false ist, schalte die LED aus
          Serial.println("LED ausschalten");
          digitalWrite(LED, LOW);
        }
      }


      break;

    case 3:
      u8g.firstPage();
      do
      {
        drawZapfwelle();
        //Markierung();
      } while (u8g.nextPage());

      break;
    case 0:
      u8g.firstPage();
      do
      {
        draw();
      } while (u8g.nextPage());
      if (MarkOn)
      {
        Serial.println("m off");
        digitalWrite(LED, LOW);
        MarkOn = !MarkOn;
        lastMarkOn = MarkOn;
      }
      break;
  }
}

float mittelWert(int neuerWert)
{

  float mittel, summe = 0;

  werte[zaehlerMittelWerte] = neuerWert;
  for (int k = 0; k < anzahlMittelWerte; k++)
    summe += werte[k];
  mittel = (float)summe / anzahlMittelWerte;
  zaehlerMittelWerte++;
  if (zaehlerMittelWerte >= anzahlMittelWerte)
    zaehlerMittelWerte = 0;

  return mittel;
}