/*

  BITTE ERSTELLEN SIE SICH VORAB EINE PRIVATE KOPIE, DAZU
  AUF "SAVE AS" GEHEN.

  Aufgabenbeschreibung:
  Es soll eine Steuerung aufgebaut werden, welche einen einfachen
  Reaktionstester umsetzt.
  Die Steuerung soll auf einem µC (AT-Mega 328, Arduino Uno)
  realisiert werden.

  Folgende Pin Belegung ist zu beachten
  Port B
  Bit 0/1/2/3/4/5/6/7
  Bez Res/Res/Res/Res/Res/Res/Res/Res

  Port D
  Bit 0/1/2/3/4/5/6/7
  Bez Res/Res/xTaster/Res/yBlue/Res/yYellow/Res

  R1) Ein Taster ist angeschlossen und das Signal des Tasters
  wird als xTaster in der Pin Belegung abgebildet.

  R2) Es seien zwei LEDs angeschlossen, eine gelbe und eine blaue. Diese
  sind durch über die Anschlüsse yBlue und yYellow in der Pin Belegung
  abgebildet. Die beiden anderen LEDs dienen zur Überprüfung, ob Sie
  reservierte Bits geändert haben.

  R3) Der Reaktionstester soll fortwährend laufen, bis ein Fehler
  in der HAS auftritt.

  R4) Der Reaktionstester soll die Funktion void randomWait(void)
  aufrufen, welche eine zufällige Zeit wartet. Sobald die Zeit abgelaufen
  ist, soll die gelbe LED angeschaltet werden. Dies ist für den
  Anwender das Zeichen, so schnell wie möglich auf den Taster zu drücken.
  War die Reaktionszeit schneller als die bisherige Bestzeit des
  Users, soll die blaue LED für eine Sekunde leuchten. Die gelbe LED
  soll zeitgleich erlöschen.
  Dies können Sie über die Funktion delay([Zeit in ms]) erreichen. War die
  Zeit schlechter als die Bestzeit, soll die gelbe LED erlöschen, sobald
  der User den Taster losgelassen hat. Die blaue LED soll in diesem
  Fall nicht aufleuchten.

  R5) Die Datenrichtungen sollen in einer InitIO() Funktion eingestellt werden.

  R6) Alle Ihnen zur Verfügung stehenden Ausgänge sollen zu Beginn für
  einen Zyklus auf 1 und dann auf 0 initialisiert werden. Dies soll in der initIO() geschehen.

  R7) Nutzen Sie zum Lesen und Schreiben der digitalen Ein- und
  Ausgänge die Funktionen InputByte und OutputByte der HAS.

  R8) Wird beim Einlesen oder Ausgeben über die HAS ein Fehlerwert
  zurückgegeben, sollen blaue und gelbe LED aufleuchten.

  R9) Reservierte Bits dürfen nicht in Wert oder Datenrichtung geändert werden.
  Ausgänge sind rücklesbar.

  ACHTUNG:
  Bitte nutzen Sie anstatt des bekannten int main(void) Aufbaus
  eine void setup() + void loop() Struktur, wie folgend dargestellt.

  Die Funktion setup() wird dabei bei der Abarbeitung einmal durchlaufen
  und die Funktion loop() anschließend permanent.

*/
// typ bool ist bereits deklariert
typedef unsigned char uint8_t;
typedef unsigned char BYTE;
typedef enum {PB, PC, PD} PORT;
typedef enum {K0 = 0, K1, K2, K3, K4, K5, K6, K7} CHANNEL;

#define Y_POS K6
#define B_POS K4
#define T_POS K2

void preSetup(void) {
  // Pseudo-Funktion soll testen, ob reservierte Bits geändert wurden
  BYTE PDval = 0b00000000;
  BYTE PBval = 0b00100000;

  DDRD = 0b00000010; // Output := 1, Input := 0
  DDRB = 0b00100100; // Output := 1, Input := 0

  OutputByte(PD, PDval);
  OutputByte(PB, PBval);
}

BYTE InputByte (PORT PortName, BYTE* ReadValue) {
  // Hardwareabstraktionsschicht, Einlesen und Abspeichern an Adresse ReadValue
  if (PortName == PB) {
    *ReadValue = PINB;
  }
  else if (PortName == PC) {
    *ReadValue = PINC;
  }
  else if (PortName == PD) {
    *ReadValue = PIND;
  }

  // Pseudo Error Code Generation
  int returnVal = 0;
  int randNumber = random(100); // Random number for error code
  if (randNumber < 3) returnVal = randNumber; // Return Value depending on random number
  return (returnVal);
}

BYTE OutputByte (PORT PortName, BYTE WriteValue) {
  // Hardwareabstraktionsschicht, Ausgabe des Bytes WriteValue am Port PortName
  if (PortName == PB) {
    PORTB = WriteValue;
  }
  else if (PortName == PC) {
    PORTC = WriteValue;
  }
  else if (PortName == PD) {
    PORTD = WriteValue;
  }

  // Pseudo Error Code Generation
  int returnVal = 0;
  int randNumber = random(100); // Random number for error code
  if (randNumber > 98) returnVal = randNumber; // Return Value depending on random number
  return (returnVal);

}

void randomWait(void) {
  int randMilliSec = 3000 + random(20000); // Value between 3000 and 23000 ms
  delay(randMilliSec);
}
BYTE InitIO() {

  DDRD |= (1 << B_POS) | (1 << Y_POS);
  DDRD &= ~(1 << T_POS);


  return 0;
}

void setup() {
  // Code, der nur einmal ausgeführt wird
}

void loop() {
  // Pseudofunktion zum Testen, ob reservierte Bits geaendert wurden
  // Rote LED darf nicht leuchten, Gruene muss leuchten
  preSetup();
  InitIO();
  int err = 0;
  int bZeit = 0;
  int aZeit = 0;
  BYTE PDval = 0x00;
  BYTE mask = 0x00;
  BYTE PDOut = 0x00;

  mask |= (1 << T_POS);


  while (1) {
    aZeit = 0;
    randomWait();
    err += InputByte(PD, &PDval);



    //bool T = (PDval & (1 << T_POS))>0;


    while ((PDval & mask) != mask) {

      aZeit++;

      PDOut |= (1 << Y_POS);
      OutputByte(PD, PDOut);
      err += InputByte(PD, &PDval);
      //T = (PDval & (1 << T_POS))>0;
      

    }

    if (aZeit < bZeit) {

      bZeit = aZeit;

      PDOut |= (1 << B_POS);
      err += OutputByte(PD, PDOut);
      delay(1000);
      PDOut &= ~(1 << B_POS);
      err += OutputByte(PD, PDOut);

    } else if (bZeit == 0) {

      bZeit = aZeit;


    }
    PDOut &= ~(1 << Y_POS);

    err += OutputByte(PD, PDOut);


  }
  // Ab hier Ihr Code

  // Do nothing more, wegen Umstrickung main() --> loop(), nach Fehler
  // "Abbruch"
  while (1) {
  }

}