/*
Flipled.
Erik Simons
30/05/2024
*/
// Bibliotheken
#include <AltSoftSerial.h>

// enums MOETEN ALTIJD ALS EERSTE AANGEGEVEN WORDEN!!
enum status {RIJZEND, HOOG, DALEND, LAAG};

//Alle classes

class Led {
 /* De class led heeft:
*2 public atributes: poort en output. De namen spreken voor zichzelf
*4 methods:
-> aan    : doet de led branden
-> uit    : doet de led uit
-> toggle : wisselt van aan naar uit en andersom.
-> lees   : geeft de toestand van de led aan in output.*/
  public:
    int poort;
    int output;

    //Methods van de class Led
    void aan()
    {
      digitalWrite(poort, HIGH);
      output = HIGH;
    }

    void uit()
    {
      digitalWrite(poort, LOW);
      output = LOW;
    }

    void toggle()
    {
      digitalWrite(poort, !digitalRead(poort));
      output = !output;
    }
    int lees()
    {
      return output;
    }

    //constructor van class Led:
    Led (int a, int b) {
      poort = a;
      output = b;
      pinMode(poort, output);
    }
};
class Knop {
 /*De class knop heeft:
*3 private attributes: 
->vorige = is de vorige waarde
->offon  = is de huidige toestand
->poort  = spreekt voor zichzelf
*1 method:
->lees = retourneert de flank in de vorm een ENUM */
  private:
    int  vorige;
    int poort;
    int offon;
  public:
    status flanK;

    //Methods van de class Knop
    int lees()
    {
      offon = digitalRead(poort);
      if (vorige < offon) {
        flanK = RIJZEND;
      }
      if (vorige > offon) {
        flanK = DALEND;
      }
      if (vorige == offon and offon == HIGH) {
        flanK = HOOG;
      }
      if (vorige == offon and offon == LOW) {
        flanK = LAAG;
      }
      vorige = offon;
      return flanK;
    }
    //constructor van class Knop:
    Knop (int c, int d, status eflank) {
      poort = c;
      offon = d;
      flanK = eflank;
    }
};

class Pot {
/* De class pot heeft :
*4 public attributes:
-> poort    = spreekt voor zichzelf
-> laagst   = de laagst mogelijke waarde die mag geretourneerd worden
-> hoogst   = de hoogst mogelijk waarde die mag geretouneerd worden
-> waarde   = de waarde die geretouneerd zal worden (dus tussen laagst en hoogst)
*1 method:
-> lees = leest de pot uit ,herschaald die en retouneerd ze in waarde.*/
  public:
    int poort;
    int laagst;
    int hoogst;
    int waarde;
    //Methods van de class Pot
    int lees() {
      waarde = map(analogRead(poort), 0, 1023, laagst, hoogst);
      return waarde;
    }
    // constructor van de class Pot
    Pot (int e, int f, int g) {
      poort = e;
      laagst = f;
      hoogst = g;
    }
};

//Constanten
const int PIN_ROOD = 12;
const int PIN_GROEN = 6;
const int PIN_POT = A0;
const int PIN_KNOP = 7;

//Variabelen
int aanUit;
int dimming=0;

// speciale variabelen
status flanK ;//flanK kan nu enkel de waarden RIJZEND, HOOG, DALEND en LAAG hebben
// Zie de enum van status hierboven.


//Aanmaken van objecten
Led Groen(PIN_GROEN, OUTPUT);
Knop Digitaal(PIN_KNOP,aanUit,flanK);
Pot Dim(PIN_POT,0,255);
AltSoftSerial altSerial;  // We maken een nieuwe UART aan


void setup() {
  // put your setup code here, to run once:
  Serial.begin (9600);
   altSerial.begin(9600); 
 
}


void loop() {
  // put your main code here, to run repeatedly:
  Groen.aan();
  Digitaal.lees();
  dimming=Dim.lees();
  Serial.print(Digitaal.flanK);
  Serial.print("  Dimming->");
  Serial.println(dimming);
  analogWrite(PIN_ROOD,dimming);
  delay(100);

}