#define analogPin_H 600

/*OLD
int OUTPUT0 = 52; // Datapin0
int OUTPUT1 = 50; // Datapin1
int OUTPUT2 = 48; // Datapin2
int OUTPUT3 = 46; // Datapin3
*/
//NEW

int OUTPUT0 = 52; // Datapin0
int OUTPUT1 = 50; // Datapin1
int OUTPUT2 = 48; // Datapin2
int OUTPUT3 = 46; // Datapin3
int OUTPUT4 = 44; // Datapin4
int OUTPUT5 = 42; // Datapin5
int OUTPUT6 = 40; // Datapin6
int OUTPUT7 = 38; // Datapin7


/*OLD
int controlPin1 = 44; // Clock Signal PC-Register
int controlPin2 = 42; // Reset PC-Register
int controlPin3 = 40; // Multiplexer DataIN/InkrementerIn
int controlPin4 = 38; // Multiplexer BusIN / PC IN
*/
//NEW
int controlPin1 = 53; // Clock Signal PC-Register
int controlPin2 = 51; // Reset PC-Register
int controlPin3 = 49; // Multiplexer DataIN/InkrementerIn
int controlPin4 = 47; // Multiplexer BusIN / PC IN
int controlPin5 = 45; // Unused
int controlPin6 = 43; // Unused
int controlPin7 = 41; // Unused
int controlPin8 = 39; // Unused

int RAM_adr0 = 25;
int RAM_adr1 = 27;
int RAM_adr2 = 29;
int RAM_adr3 = 31;

int RAM_d0 = 24;
int RAM_d1 = 26;
int RAM_d2 = 28;
int RAM_d3 = 30;

int RAM_chip_enable = 32;
int RAM_write_enable = 35;

int RAM_output_enable = 33;

int analogPin4 = A8; // 3,3 Volt Integer-Wert größer 650!!!
int analogPin5 = A9; // 3,3 Volt Integer-Wert größer 650!!!
int analogPin6 = A10; // 3,3 Volt Integer-Wert größer 650!!!
int analogPin7 = A11; // 3,3 Volt Integer-Wert größer 650!!!

int analogPin0 = A12; // 3,3 Volt Integer-Wert größer 650!!!
int analogPin1 = A13; // 3,3 Volt Integer-Wert größer 650!!!
int analogPin2 = A14; // 3,3 Volt Integer-Wert größer 650!!!
int analogPin3 = A15; // 3,3 Volt Integer-Wert größer 650!!!



int val0 = 0; // Variable, die den gelesenen Wert speichert
int val1 = 0; // Variable, die den gelesenen Wert speichert
int val2 = 0; // Variable, die den gelesenen Wert speichert
int val3 = 0; // Variable, die den gelesenen Wert speichert

char on = 0x01;
char SerialIncoming = 0x00;
static int counter = 0;

//Tests the setBUS function incl. Relayoutputs on MEGA R3
void Test_D_OUTPUT(int length)
{
  unsigned char byte = 0x00;
  for(int i=0;i<=length-1;i++)
  {
    delay(100);
    setBus(byte, 8, 0);
    Serial.print("Ausgabe: ");
    Serial.println(byte, HEX);
    byte += 1;
  }
}

void PCReg_clock()
{
    digitalWrite(controlPin1, LOW);
    delay(75);
    digitalWrite(controlPin1, HIGH);
    delay(275);
}

void PCReg_reset()
{
    digitalWrite(controlPin2, LOW);
    delay(75);
    digitalWrite(controlPin2, HIGH);
    delay(275);
}

void PCReg_set(char byte)
{
    PCReg_reset();
    digitalWrite(controlPin4, LOW);
    digitalWrite(controlPin3, LOW);
    setBus(byte, 8, 0);
    PCReg_clock();
    digitalWrite(controlPin4, HIGH);    
    digitalWrite(controlPin3, HIGH);

}

void PCReg_increment()
{
      digitalWrite(controlPin3, HIGH);
      digitalWrite(controlPin4, LOW);
      delay(11);  
      PCReg_clock();
}

int PCReg_count(int counter)
{
  for(int i=1;i <= counter; i++)
  {
    PCReg_increment();
  }
}

void setBus(char Input, int bus_size, char debug)
{
  for(int i=0;i <= bus_size;i++)
  {
  int t = bitRead(Input, i);
    switch(i)
    {
      case 0:
        if(t == 1) digitalWrite(OUTPUT0, LOW);
        else if (t == 0) digitalWrite(OUTPUT0, HIGH);
      break;
      case 1:
        if(t == 1) digitalWrite(OUTPUT1, LOW);
        else if (t == 0) digitalWrite(OUTPUT1, HIGH);
      break;
      case 2:
        if(t == 1) digitalWrite(OUTPUT2, LOW);
        else if (t == 0) digitalWrite(OUTPUT2, HIGH);
      break;
      case 3:
        if(t == 1) digitalWrite(OUTPUT3, LOW);
        else if (t == 0) digitalWrite(OUTPUT3, HIGH);
      break;
      case 4:
        if(t == 1) digitalWrite(OUTPUT4, LOW);
        else if (t == 0) digitalWrite(OUTPUT4, HIGH);
      break;
      case 5:
        if(t == 1) digitalWrite(OUTPUT5, LOW);
        else if (t == 0) digitalWrite(OUTPUT5, HIGH);
      break;
      case 6:
        if(t == 1) digitalWrite(OUTPUT6, LOW);
        else if (t == 0) digitalWrite(OUTPUT6, HIGH);
      break;
      case 7:
        if(t == 1) digitalWrite(OUTPUT7, LOW);
        else if (t == 0) digitalWrite(OUTPUT7, HIGH);
      break;      
    }
  }

}

void readBus(int bus_size, char debug)
{
  unsigned char byte = 0;

  for(int i=0;i <= bus_size;i++)
  {
    switch(i)
    {
      case 0:
        val0 = analogRead(analogPin0); // Pin einlesen
        if(debug == 0x01) Serial.println(val0);
        if(val0 > analogPin_H) byte += 0x01;
        break;
      case 1:
        val1 = analogRead(analogPin1);// Pin einlesen
        if(debug == 0x01) Serial.println(val1);
        if(val1 > analogPin_H) byte += 0x02;
        break;
      case 2:
        val2 = analogRead(analogPin2); // Pin einlesen
        if(debug == 0x01) Serial.println(val2);
        if(val2 > analogPin_H) byte += 0x04;
        break;
      case 3:
        val3 = analogRead(analogPin3); // Pin einlesen
        if(debug == 0x01) Serial.println(val3);
        if(val3 > analogPin_H) byte += 0x08;
        break;
      case 4:
        val3 = analogRead(analogPin4); // Pin einlesen
        if(debug == 0x01) Serial.println(val3);
        if(val3 > analogPin_H) byte += 0x08;
        break;
      case 5:
        val3 = analogRead(analogPin2); // Pin einlesen
        if(debug == 0x01) Serial.println(val3);
        if(val3 > analogPin_H) byte += 0x08;
        break;
      case 6:
        val3 = analogRead(analogPin6); // Pin einlesen
        if(debug == 0x01) Serial.println(val3);
        if(val3 > analogPin_H) byte += 0x08;
        break;
      case 7:
        val3 = analogRead(analogPin7); // Pin einlesen
        if(debug == 0x01) Serial.println(val3);
        if(val3 > analogPin_H) byte += 0x08;
        break;        
    }
  }

  Serial.print("Ausgabe: 0x0");
  Serial.println(byte, HEX);

}

void resetBus()
{
  digitalWrite(OUTPUT0, HIGH);
  digitalWrite(OUTPUT1, HIGH);
  digitalWrite(OUTPUT2, HIGH);
  digitalWrite(OUTPUT3, HIGH);
  digitalWrite(OUTPUT4, HIGH);
  digitalWrite(OUTPUT5, HIGH);
  digitalWrite(OUTPUT6, HIGH);
  digitalWrite(OUTPUT7, HIGH);
}

char PCReg_readInput()
{

}
unsigned char byte_buffer = 0x00;
char RAM_readbyte(char adr, int bus_size)
{
  byte_buffer = 0x00;
  digitalWrite(RAM_write_enable, HIGH); 
  digitalWrite(RAM_chip_enable, LOW); 
  delay(5);

  digitalWrite(RAM_adr0, LOW);
  digitalWrite(RAM_adr1, LOW);
  digitalWrite(RAM_adr2, LOW);
  digitalWrite(RAM_adr3, LOW);

  for(int i=0;i <= bus_size;i++)
    {
    int t = bitRead(adr, i);
      switch(i)
      {
        case 0:
          if(t == 1) digitalWrite(RAM_adr0, HIGH);
          else if (t == 0) digitalWrite(RAM_adr0, LOW);
        break;
        case 1:
          if(t == 1) digitalWrite(RAM_adr1, HIGH);
          else if (t == 0) digitalWrite(RAM_adr1, LOW);
        break;
        case 2:
          if(t == 1) digitalWrite(RAM_adr2, HIGH);
          else if (t == 0) digitalWrite(RAM_adr2, LOW);
        break;
        case 3:
          if(t == 1) digitalWrite(RAM_adr3, HIGH);
          else if (t == 0) digitalWrite(RAM_adr3, LOW);
        break;/*
        default:
        digitalWrite(RAM_adr0, LOW);
        digitalWrite(RAM_adr1, LOW);
        digitalWrite(RAM_adr2, LOW);
        digitalWrite(RAM_adr3, LOW);
        break;    */      
      }

    }
  digitalWrite(RAM_output_enable, LOW);
    //Serial.print(digitalRead(RAM_d0));
    if(digitalRead(RAM_d0) == HIGH) byte_buffer += 1;
    //Serial.print(digitalRead(RAM_d1));
    if(digitalRead(RAM_d1) == HIGH) byte_buffer += 2;
    //Serial.print(digitalRead(RAM_d2));
    if(digitalRead(RAM_d2) == HIGH) byte_buffer += 4;
    //Serial.print(digitalRead(RAM_d3));
    if(digitalRead(RAM_d3) == HIGH) byte_buffer += 8;
    Serial.print("Gelesen: ");
    Serial.print(byte_buffer, HEX);    
    Serial.println("");

 

    //if(digitalRead(RAM_d0) == HIGH) buffer += 1;
    //if(digitalRead(RAM_d1) == HIGH) buffer += 2;
    //if(digitalRead(RAM_d2) == HIGH) buffer += 4;
    //if(digitalRead(RAM_d3) == HIGH) buffer += 8;

     //Serial.println(buffer);


    delay(250);
    digitalWrite(RAM_output_enable, HIGH);
    
        digitalWrite(RAM_adr0, LOW);
        digitalWrite(RAM_adr1, LOW);
        digitalWrite(RAM_adr2, LOW);
        digitalWrite(RAM_adr3, LOW);
        //digitalWrite(RAM_output_enable, LOW);
}

void RAM_writebyte(char adr, char byte, int bus_size)
{
  digitalWrite(RAM_d0, LOW);
  digitalWrite(RAM_d1, LOW);
  digitalWrite(RAM_d2, LOW);
  digitalWrite(RAM_d3, LOW);

  for(int i=0;i <= bus_size;i++)
    {
    int t = bitRead(adr, i);
      switch(i)
      {
        case 0:
          if(t == 1) digitalWrite(RAM_adr0, HIGH);
          else if (t == 0) digitalWrite(RAM_adr0, LOW);
        break;
        case 1:
          if(t == 1) digitalWrite(RAM_adr1, HIGH);
          else if (t == 0) digitalWrite(RAM_adr1, LOW);
        break;
        case 2:
          if(t == 1) digitalWrite(RAM_adr2, HIGH);
          else if (t == 0) digitalWrite(RAM_adr2, LOW);
        break;
        case 3:
          if(t == 1) digitalWrite(RAM_adr3, HIGH);
          else if (t == 0) digitalWrite(RAM_adr3, LOW);
        break;
        default:

        break;        
      }
    }

delay(5);

for(int i=0;i <= bus_size;i++)
  {
  int t = bitRead(byte, i);
    switch(i)
    {
      case 0:
        if(t == 1) digitalWrite(RAM_d0, HIGH);
        else if (t == 0) digitalWrite(RAM_d0, LOW);
      break;
      case 1:
        if(t == 1) digitalWrite(RAM_d1, HIGH);
        else if (t == 0) digitalWrite(RAM_d1, LOW);
      break;
      case 2:
        if(t == 1) digitalWrite(RAM_d2, HIGH);
        else if (t == 0) digitalWrite(RAM_d2, LOW);
      break;
      case 3:
        if(t == 1) digitalWrite(RAM_d3, HIGH);
        else if (t == 0) digitalWrite(RAM_d3, LOW);
      break;
      default:
      break;
    }
  }
digitalWrite(RAM_write_enable, LOW);
  
delay(15);

digitalWrite(RAM_write_enable, HIGH);
delay(15);
      digitalWrite(RAM_d0, LOW);
      digitalWrite(RAM_d1, LOW);
      digitalWrite(RAM_d2, LOW);
      digitalWrite(RAM_d3, LOW);
      /*
        digitalWrite(RAM_adr0, LOW);
        digitalWrite(RAM_adr1, LOW);
        digitalWrite(RAM_adr2, LOW);
        digitalWrite(RAM_adr3, LOW);*/
}

void test(void)
{

    digitalWrite(RAM_d0, LOW);
    digitalWrite(RAM_d1, LOW);
    digitalWrite(RAM_d2, LOW);
    digitalWrite(RAM_d3, LOW);

    digitalWrite(RAM_d0, LOW);    
    digitalWrite(RAM_d1, LOW);    
    digitalWrite(RAM_d2, LOW);    
    digitalWrite(RAM_d3, HIGH);    

  digitalWrite(RAM_adr0, HIGH);
  digitalWrite(RAM_adr1, LOW);
  digitalWrite(RAM_adr2, LOW);
  digitalWrite(RAM_adr3, LOW);



  Serial.println("Schreibe 0xFF!");

  delay(100);
  digitalWrite(RAM_write_enable, LOW);
  delay(100);
  digitalWrite(RAM_write_enable, HIGH);
  delay(1000);
  pinMode(RAM_d0, INPUT);
  digitalWrite(RAM_d0, LOW);    
  pinMode(RAM_d1, INPUT);
  digitalWrite(RAM_d1, LOW);    
  pinMode(RAM_d2, INPUT);
  digitalWrite(RAM_d2, LOW);    
  pinMode(RAM_d3, INPUT);
  digitalWrite(RAM_d3, LOW); 
  
  delay(1000);
  digitalWrite(RAM_adr0, LOW);
  delay(1000);
  digitalWrite(RAM_adr0, HIGH);
  delay(1000);
  digitalWrite(RAM_output_enable, LOW);
  Serial.println("RAM Ausgang aktiv!");
  Serial.println(digitalRead(RAM_d3));
  delay(1000);
  digitalWrite(RAM_output_enable, HIGH);
  Serial.println("RAM Ausgang deaktiviert!");
  delay(1000);


}


void setup() {
  pinMode(OUTPUT0, OUTPUT);
  pinMode(OUTPUT1, OUTPUT);
  pinMode(OUTPUT2, OUTPUT);
  pinMode(OUTPUT3, OUTPUT);
  pinMode(OUTPUT4, OUTPUT);
  pinMode(OUTPUT5, OUTPUT);
  pinMode(OUTPUT6, OUTPUT);
  pinMode(OUTPUT7, OUTPUT);  

  pinMode(analogPin0, INPUT); 
  pinMode(analogPin1, INPUT); 
  pinMode(analogPin2, INPUT); 
  pinMode(analogPin3, INPUT); 

  pinMode(controlPin1, OUTPUT);
  pinMode(controlPin2, OUTPUT);
  pinMode(controlPin3, OUTPUT);
  pinMode(controlPin4, OUTPUT);
  pinMode(controlPin5, OUTPUT);
  pinMode(controlPin6, OUTPUT);
  pinMode(controlPin7, OUTPUT);
  pinMode(controlPin8, OUTPUT); 

  //RAM Control
  pinMode(RAM_adr0, OUTPUT);
  pinMode(RAM_adr1, OUTPUT);
  pinMode(RAM_adr2, OUTPUT);
  pinMode(RAM_adr3, OUTPUT);
  pinMode(RAM_d0, INPUT);
  pinMode(RAM_d1, INPUT);
  pinMode(RAM_d2, INPUT);
  pinMode(RAM_d3, INPUT); 

  digitalWrite(RAM_d0, LOW);
  digitalWrite(RAM_d1, LOW);
  digitalWrite(RAM_d2, LOW);
  digitalWrite(RAM_d3, LOW);

  pinMode(RAM_chip_enable, OUTPUT);
  pinMode(RAM_write_enable, OUTPUT); 
  pinMode(RAM_output_enable, OUTPUT); 

  digitalWrite(RAM_write_enable, HIGH);
  digitalWrite(RAM_chip_enable, LOW); 
  digitalWrite(RAM_output_enable, HIGH); 

  digitalWrite(controlPin1, HIGH);
  digitalWrite(controlPin2, HIGH);
  digitalWrite(controlPin3, HIGH);
  digitalWrite(controlPin4, HIGH);
  digitalWrite(controlPin5, HIGH);
  digitalWrite(controlPin6, HIGH);
  digitalWrite(controlPin7, HIGH);
  digitalWrite(controlPin8, HIGH);

  digitalWrite(OUTPUT0, HIGH);
  digitalWrite(OUTPUT1, HIGH);
  digitalWrite(OUTPUT2, HIGH);
  digitalWrite(OUTPUT3, HIGH);
  digitalWrite(OUTPUT4, HIGH);
  digitalWrite(OUTPUT5, HIGH);
  digitalWrite(OUTPUT6, HIGH);
  digitalWrite(OUTPUT7, HIGH);

  Serial.begin(9600);
}



void loop() {

  //RAM_writebyte(0x00, 0xFF, 4);

/*
if(counter <= 2)
{ 
 
    PCReg_reset();
    for(int i=0; i <= 14;i++) 
    {
      PCReg_increment(); 
      readBus(8,0);
    } 
    counter++;

    Serial.println("Zählvorgang abgeschlossen!"); 
    Serial.print("Durchgangnr.: ");
    Serial.println(counter, DEC);
} 
  else if(counter == 2)
  {
    Serial.println("Setze PC zurück!");
    PCReg_reset();
    counter++;
  }
else {  
  Serial.println("Programm abgeschlossen!");

  delay(1000);}

  
*/
  if (Serial.available() > 0) {
    // Lies das eingehende Byte:
    //SerialIncoming = Serial.read();
    
    String buffer = Serial.readString();
    
    // Ausgeben:
    Serial.print("I received: ");
    Serial.println(buffer);

    

    if(buffer.compareTo("PC_inc\n") == 0)
    {
      Serial.println("Starte Programm!");
      PCReg_increment();
    }

    else if(buffer.compareTo("PC_reset\n") == 0)
    {
      PCReg_reset();
      Serial.println("Befehl ausgeführt");
    }

    else if(buffer.compareTo("readBus\n") == 0)
    {
      readBus(8,0);
      Serial.println("Befehl ausgeführt");
    }
    else if(buffer.compareTo("PC_countto\n") == 0)
    {
      PCReg_reset();
      PCReg_count(8);
      Serial.println("Befehl ausgeführt");
    }

    else if(buffer.compareTo("PC_countdown\n") == 0)
    {
      unsigned char byte = 0xFF;

      for(int i=0;i <= byte;i++)
      {
        PCReg_set(byte);
        byte -= 1;
        delay(10);
        readBus(8,0);
      }
    }

    else if(buffer.compareTo("TEST_DATA_OUTPUT\n") == 0)
    {
      Test_D_OUTPUT(256);
    }

    else if(buffer.compareTo("testdata\n") == 0)
    {
      Test_D_OUTPUT(256);
    }

    else if(buffer.compareTo("RAM_read\n") == 0)
    {
      char adr = 0x00;
      for(int i=0;i<=15;i++)
      {
        Serial.print("Lese an Adresse: ");
        Serial.println(adr, HEX);
        RAM_readbyte(adr, 4);
        delay(10);
        adr++;
      }

      delay(1000);  
      Serial.println("RAM gelesen!!!");    
    }

    else if(buffer.compareTo("ramwrite\n") == 0)
    {
      char byte = 0x00;
      char adr = 0x00;

      for(int i=0;i<=15;i++)
      {
        Serial.print("Schreibe: ");
        Serial.print(byte, HEX);
        Serial.print(" an Adresse:");
        Serial.println(adr, HEX);
        RAM_writebyte(adr,byte,4);
        delay(5);
        adr++;
        byte++;
      }

      Serial.println("RAM geschrieben!!!");
    }

    else if(buffer.compareTo("ramclear\n") == 0)
    {
      char byte = 0x00;
      char adr = 0x00;

      for(int i=0;i<=15;i++)
      {
        Serial.print("Schreibe: ");
        Serial.print(byte, HEX);
        Serial.print(" an Adresse:");
        Serial.println(adr, HEX);
        RAM_writebyte(adr,0x00,4);
        delay(5);
        adr++;
      }

    }
    else if(buffer.compareTo("test\n") == 0)
    {
      //test();
      //RAM_writebyte(0xFF, 0xFF, 4);
      unsigned char byte = 0x00;
      unsigned char adr = 0x00;
      for(int i = 0; i <= 15; i++)
      {
      RAM_writebyte(adr, byte, 4);
      byte++;
      adr++;
      }


      Serial.println("Daten geschrieben!");
      delay(1000);
      Serial.println("RAM wird gelesen!!!");
      delay(1000);      
      adr = 0x00;
      byte= 0x00;
      for(int i = 0; i <= 15; i++)
      {
      RAM_readbyte(adr, 4);

      setBus(byte_buffer, 8, 0);

      adr++;
      }      
      /*
      delay(1000);
      digitalWrite(RAM_output_enable, LOW);
      Serial.println("RAM Ausgang aktiv!");
      Serial.println(digitalRead(RAM_d0));
      Serial.println(digitalRead(RAM_d1));
      Serial.println(digitalRead(RAM_d2));
      Serial.println(digitalRead(RAM_d3));
      delay(1000);
      digitalWrite(RAM_output_enable, HIGH);
      Serial.println("RAM Ausgang deaktiviert!");
      delay(1000);
      */
      Serial.println("TEST RAM Schreib-/Lesevorgang beendet!");
    }    


    else {
      Serial.println("Unbekannter Befehl!");
      
        

      /*
      digitalWrite(controlPin1, LOW);
      digitalWrite(controlPin2, LOW);
      digitalWrite(controlPin3, LOW);
      digitalWrite(controlPin4, LOW);
      digitalWrite(controlPin5, LOW);
      digitalWrite(controlPin6, LOW);
      digitalWrite(controlPin7, LOW);
      digitalWrite(controlPin8, LOW);
      */

    }
    }

    
}