/*
Author: Gregor Mausser
Title: Stoppuhr_ESP32_1.0
Technische Daten:
  RGB funtioniert
  Button und millis (Tastenprellen) funtioniert 
  Buzzer funktioniert (Piepst während der Startfrequenz)
  OLED Display funktioniert (ausgabe der Zeiten; schreibt "START")
  Umrechnung von ms auf min:sec funktioniert
  Zahlenformatierung funkioniert
  DIP Switch 8 Pins 1, 2 und 3 funktionieren
  Ultraschallsensoren sind angeschlossen aber haben noch keine "Funktion"
  Brechnung für den Travel:
    usedTravel = Travel - distance 
  Gleitender mittelwert
*/
  
//Bibliothek für den Display einfügen
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>


//Pins definieren
  //RGB
  const int RGBred = 6;
  const int RGBgreen = 5;
  const int RGBblue = 4;
  //Button
  const int ButtonPin = 18;   //Start/Stop der Stoppuhr
  //DIP Switch 8
  const int SwitchPin1 = 40;  //Stoppuhr ja/nein
  const int SwitchPin2 = 39;  //measureSuspensionFront ja/nein
  const int SwitchPin3 = 38;  //measureSuspensionRear ja/nein  
  //Buzzer
  const int BuzzerPin = 3;

  //Ultraschall-Sensor Dämpfer/Rear-Suspension
  const int TrigRear = 12;  //Ultraschall Senden 
  const int EchoRear = 13;  //Reflektiertes Signal aufnehmen 
  //Ultraschall-Sensor Fork/Front-Suspension
  const int TrigFront = 10; //Ultraschall Senden
  const int EchoFront = 11; //Reflektiertes Signal aufnehmen

//Breite und Höhe vom OLED-Display festlegen
const int ScreenHeight = 32;
const int ScreenWidth = 128;

//Variablen defieren
  bool startMeasures = LOW; //begint die Messungen
  bool endMeasures = LOW; //beendet die Messungen
  int buttoncount = 0;      //zählt wie oft der Button gedrückt wurde
  int buzzercount = 0;      //zählt wie oft der Buzzer in der Startsequenz ausgelöst wurde
  int minute;             
  int times = 1;            //Zählt die gespeicherten Zeiten   
  //Variablen für die Distanzmessung
  const float air = 0.03432;          //Schallgeschwindigkeit für luft
  long distanceFront;                 //Variable für den übrigen Federweg der Gabel
  long distanceRear;                  //Variable für den übrigen Federweg des Dämpfers
  int TravelFront = 200;              //max. Federweg der Gabel (in mm)  
  int TravelRear = 200;               //max. Federweg des Dämpfers (in mm)
  float usedTravelFront;              //Variable für den genuzte Federweg der Gabel
  float usedTravelRear;               //Variable für den genuzte Federweg des Dämpfers

  //Variablen für millis
  bool lastReading = HIGH;     
  bool stableState = HIGH;     

  unsigned long lastDebounceTime = 0;         
  const unsigned long debounceDelay = 30;  

  //Variablen für den Timer mit millis()
  unsigned long starttime = 0;  //Wann der Timer anfängt zu zählen 
  unsigned long endtime = 0;    //Wann der Timer stoppt

Adafruit_SSD1306 display(ScreenWidth, ScreenHeight, &Wire, - 1);

void setup() {
  Serial.begin(115200);
  Serial.println("Hello, ESP32-S2!");
  //Pins eine Funktion zuweisen
    //RGB
    pinMode(RGBred, OUTPUT);
    pinMode(RGBgreen, OUTPUT);
    pinMode(RGBblue, OUTPUT);
    //Button
    pinMode(ButtonPin, INPUT_PULLUP);
    //DIP Switch 8
    pinMode(SwitchPin1, INPUT_PULLUP);
    pinMode(SwitchPin2, INPUT_PULLUP);
    pinMode(SwitchPin3, INPUT_PULLUP);
    //Buzzer
    pinMode(BuzzerPin, OUTPUT);
    //Ultraschallsensor
    pinMode(TrigRear, OUTPUT);
    pinMode(EchoRear, INPUT);
    pinMode(TrigFront, OUTPUT);
    pinMode(EchoFront, INPUT);
  
  //RGB ausschalten
  digitalWrite(RGBred, LOW);
  digitalWrite(RGBgreen, LOW);
  digitalWrite(RGBblue, LOW);
  
  Wire.begin();   //wichtig für den Display start
  //Display starten
  if(!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) { 
    Serial.println(F("Display Fehler!"));
    while(true);
  }
  display.clearDisplay();
  display.display();
}

//Funktion zum einstellen der RGB-Led und der Dauer/delay()
void RGBsetting(int red, int green, int blue, int time){
    analogWrite(RGBred, red);
    analogWrite(RGBgreen, green);
    analogWrite(RGBblue, blue);
    delay(time);
}


void loop() {
  display.setTextSize(3);
  display.setTextColor(WHITE);
  display.setCursor(0, 10);
  if (digitalRead(SwitchPin1) == LOW || digitalRead(SwitchPin2) == LOW || digitalRead(SwitchPin3) == LOW) {
    bool reading = digitalRead(ButtonPin);

    if (reading != lastReading) {
      lastDebounceTime = millis();
    }

    if ((millis() - lastDebounceTime) > debounceDelay) {
      if (reading != stableState) {
        stableState = reading;

        if (stableState == LOW) {    
          buttoncount++;
          Serial.println(buttoncount);
          
          switch(buttoncount) {
            case 0:

            case 1:
              display.clearDisplay();
              display.display();
              //Stoppuhr starten
              if (digitalRead(SwitchPin1) == LOW) {
                RGBsetting(255, 0, 0, 5000);
                for (int i = 1; i <= 4; i++){
                  RGBsetting(0, 0, 0, 500);
                  tone(BuzzerPin, 215, 500);
                  RGBsetting(255, 0, 0, 500);
                  buzzercount++;
                  if (buzzercount >= 4) {
                    RGBsetting(0, 0, 0, 500);
                    tone(BuzzerPin, 215, 1500);
                    RGBsetting(255, 0, 0, 500);
                    buzzercount = 0;
                  }
                }
                //stoppuhr Starten millis
                starttime = millis();
                display.println("START");
                display.display();
                RGBsetting(0, 255, 0, 3000);
                RGBsetting(0, 0, 0, 0);
                display.clearDisplay();
                display.display();
                digitalWrite(SwitchPin1, LOW);
              }
              //measureSuspensionFront starten
              if (digitalRead(SwitchPin2) == LOW) {
                //Sender kurz ausschalten um Störungen des Signal zu vermeiden
                digitalWrite(TrigFront, LOW);
                delay(5);

                //alle 10 Microsekunden ein Signal senden
                digitalWrite(TrigFront, HIGH);
                delayMicroseconds(10);
                digitalWrite(TrigFront, LOW);
                //Zeitmessen bis das Signal zurückkommt
                long timeFront = pulseIn(EchoFront, HIGH);
                // Entfernung in cm berechnen = Zeit/2 -> nur eine Strecke
                distanceFront = (timeFront / 2) * air;
                distanceFront *= 10;  //in mm Umrechnen
                if (distanceFront <= TravelFront)  {
                  //genutzten Federweg berechnen
                  Serial.println(distanceFront);
                  usedTravelFront = TravelFront - distanceFront;
                  Serial.println(usedTravelFront);
                }

                else  {
                  RGBsetting(255, 165, 0, 200);
                  RGBsetting(0, 0, 0, 200);
                }
              }

          
              
              //measureSuspensionRear starten
              if (digitalRead(SwitchPin3) == LOW) {
                //Sender kurz ausschalten um Störungen des Signal zu vermeiden
                digitalWrite(TrigRear, LOW);
                delay(5);

                //alle 10 Microsekunden ein Signal senden
                digitalWrite(TrigRear, HIGH);
                delayMicroseconds(10);
                digitalWrite(TrigRear, LOW);
                //Zeitmessen bis das Signal zurückkommt
                long timeRear = pulseIn(EchoRear, HIGH);
                // Entfernung in cm berechnen = Zeit/2 -> nur eine Strecke
                distanceRear = (timeRear / 2) * air;
                distanceRear *= 10;  //in mm Umrechnen
                if (distanceRear <= TravelRear) {
                  //genutzten Federweg berchnen
                  Serial.println(distanceRear);
                  usedTravelRear = TravelRear - distanceRear;
                  Serial.println(usedTravelRear);
                }
              
                else  {
                  RGBsetting(255, 165, 0, 200);
                  RGBsetting(0, 0, 0, 200);
                }
              }
              break;
            case 2:
              //Stoppuhr stoppen
              if (digitalRead(SwitchPin1) == LOW) {    
                endtime = millis();
                float time = endtime - starttime;
                time = time/1000;
                minute = time / 60;
                time = time - minute*60;
                display.print(minute);  
                display.print(":");
                if (time <= 9)  {
                  display.print("0");
                }
                display.println(time, 0);  
                display.display();
                RGBsetting(255, 255, 0, 250);

                buttoncount = 0;
                  
              }
              
              buttoncount = 0;
              break;
            default:
              Serial.println("Es ist einFehler aufgetreten!!");
              buttoncount = 0;
              Serial.println("Der buttoncount wurde auf 0 zurückgesetzt");
            }   
//-----------------------------------------------------------------------         
        }
      }
    }
    lastReading = reading;
  }



//-----------------------------------------------------------------------------------
  delay(10); // this speeds up the simulation
}