/*
Alle Funktionen sind In Ordung, der Speicher wird richtig angesprochen und lässt sich wunderbar auslesen, nur das Schreiben funktioniert nicht. Pinbelegung, Verbindungen, Lötstellen alle überprüft und für i.O. befunden, als Fehlerquelle ausgeschlossen. Sonst könnte man ja auch nichts SINNVOLLES auslesen ;)

*/

#define CE 48
#define OE 52
#define WE 50


int adressLines[19] = {53, 51, 49, 47, 45, 43, 41, 39, 37, 35, 33, 31, 27, 25, 23, 22, 24, 26, 30}; // Pins der Adressleitungen, A0 (LSB) = 53
int ioLines[8] = {32, 34, 36, 38, 40, 42, 44, 46}; // Pins der I/O Leitungen, I/O(0)(LSB) = 32
byte data; // Daten für/vom Flash-Speicher
long adress; // Variable,die die Speicheradresse enthält(32 Bit)


void setup(){
  Serial.begin(9600);
  adress = 0; //Adresse zurücksetzen
  
  for(int x3 = 0; x3 <= 18; x3++){ // Adressleitungen als Output konfigurieren
  pinMode(adressLines[x3], OUTPUT);}
  
  for(int x4 = 0; x4 <= 7; x4++){ // I/O-Leitungen als INPUT konfigurieren
  pinMode(ioLines[x4], INPUT);}
}

void loop(){
  /*
  Serial.print(readData(adress), DEC);
  Serial.print(",");
  Serial.println(readData(adress), BIN);
  adress++;
  delay(100);
  */
  delay(10);
  ChipErase();
  delay(6000); //Egal, wie lange ich verzögere, es bleibt das gleiche Ergebnis!
  
  while(adress <= 10000){ //Bloss zum debuggen
  delay(10);
  Serial.println(readData(adress), BIN);
  //Serial.write(readData(adress));
  adress++;
  delay(4);
  }
  
}

void writeAdress(word adressIntern){ // Funktion, um die betreffenden Adressleitungen Low/High zu setzen
  for(int x = 0; x <= 15; x++){ // Von 0 bis 15, also 16 Bits
      if(bitRead(adressIntern, x) == 1){
       digitalWrite(adressLines[x], HIGH); 
      }
      else if(bitRead(adressIntern, x) == 0){
       digitalWrite(adressLines[x], LOW); 
      }
  }
}

byte readData(word adressIntern2){
  if(adressIntern2 <= 512000){ // Testen, ob die Adresse im Adressraum liegt
  digitalWrite(CE, LOW); // Zuerst, CE und OE auf Logic-Low legen
  digitalWrite(OE, LOW); // ^
  digitalWrite(WE, HIGH); //WE sollte beim Lesevorgang immer auf HIGH sein
  
  writeAdress(adressIntern2); //Adresse anlegen
  
  for(int x2 = 0; x2 <= 7; x2++){ // I/O Leitungen abfragen
    if(digitalRead(ioLines[x2]) == HIGH){
     bitWrite(data, x2, 1); // Und dementsprechend das Byte "data" manipulieren(setzen)
    }
    else if(digitalRead(ioLines[x2]) == LOW){
     bitWrite(data, x2, 0); 
    }
  }
  
  return data;
  }
 else{
  return 0b00000000; // 0 bei Überschreiten des Adressraumes zurueckgeben
 } 
}

void StandBy(boolean OnOFF){
  //Wenn CE High ist, liegt der CMOS Standby Mode vor
  if(OnOFF == true){
  digitalWrite(CE, HIGH);}
  else{
  digitalWrite(CE, LOW);}
}

void ChipErase(){ //(byte data, word adressIntern3)
  for(int x5 = 0; x5 <= 7; x5++){
  pinMode(ioLines[x5], INPUT);} // I/O Lines als Input setzen
  
  // Zum allgemeinen Aufrufen einer Command Sequence muss WE und CE auf Logic-Low und OE auf Logic-High liegen
  digitalWrite(CE, LOW);
  digitalWrite(WE, LOW); // WE High?
  digitalWrite(OE, HIGH);
  //delay?
  
  // First Cycle
  digitalWrite(WE, HIGH);
  
  //digitalWrite(CE, HIGH); // Schwachsinn, deshalb auskommentiert
  //digitalWrite(CE, LOW);
  
  writeAdress(0b010101010101); // 0x555 schreiben
  digitalWrite(WE, LOW); // Adresse latchen
  ioLinesWrite(0b10101010); // 0xAA an die I/O Lines anlegen
  digitalWrite(WE, HIGH);
  writeAdress(0b001010101010); // 0x2AA für Chip erase
  digitalWrite(CE, HIGH); 
  ioLinesWrite(0b00000000); // Wieder auf 0 setzen 
  digitalWrite(CE, LOW);
  digitalWrite(WE, LOW); // Sektoradresse gelatched
  ioLinesWrite(0b01010101); // 0x55 für Chip Erase
  digitalWrite(WE, HIGH);
  ioLinesWrite(0b00000000); // Wieder auf 0 setzen
  digitalWrite(CE, HIGH);
  digitalWrite(WE, LOW);
  digitalWrite(CE, LOW);
  
  // Second Cycle
  digitalWrite(WE, HIGH);
  writeAdress(0b010101010101); // 0x555 schreiben
  digitalWrite(WE, LOW); // Adresse latchen
  ioLinesWrite(0b10000000); // 0x80 an die I/O Lines anlegen
  digitalWrite(WE, HIGH);
  writeAdress(0b010101010101); // 0x555 für Chip erase
  digitalWrite(CE, HIGH); 
  ioLinesWrite(0b00000000); // Wieder auf 0 setzen 
  digitalWrite(CE, LOW);
  digitalWrite(WE, LOW); // Sektoradresse gelatched
  ioLinesWrite(0b10101010); // 0xAA für Chip Erase
  digitalWrite(WE, HIGH);
  ioLinesWrite(0b00000000); // Wieder auf 0 setzen
  digitalWrite(CE, HIGH);
  digitalWrite(WE, LOW);
  digitalWrite(CE, LOW);
   
  // Erase Comand Cycle
  digitalWrite(WE, HIGH);
  writeAdress(0b001010101010); // 0x2AA schreiben
  digitalWrite(WE, LOW); // Adresse latchen
  ioLinesWrite(0b01010101); // 0x55 an die I/O Lines anlegen
  digitalWrite(WE, HIGH);
  writeAdress(0b010101010101); // 0x555 für Chip erase
  digitalWrite(CE, HIGH); 
  ioLinesWrite(0b00000000); // Wieder auf 0 setzen 
  digitalWrite(CE, LOW);
  digitalWrite(WE, LOW); // Sektoradresse gelatched
  ioLinesWrite(0b10100000); // 0x10 für Chip Erase
  digitalWrite(WE, HIGH);
  ioLinesWrite(0b00000000); // Wieder auf 0 setzen
  digitalWrite(CE, LOW); 
  writeAdress(0b000000000010); // Irgendeine gültige, nicht geschützte Adresse 
  digitalWrite(OE, LOW);
  
  delay(100);
  for(int x7 = 0; x7 <= 7; x7++){
  pinMode(ioLines[x7], OUTPUT);} // I/O Lines als OUTPUT setzen
  
  /* Testweise nachsehen, ob der Toggle Pin aktiv ist und der Erase Alg. noch aktiv ist
  while(digitalRead(ioLines[7] == LOW)){
   // delay?
  }
  */
  
  for(int x8 = 0; x8 <= 7; x8++){
  pinMode(ioLines[x8], INPUT);} // I/O Lines als Input setzen
  // Auf Anfangsbedingungungen setzen
  
  
}

void ioLinesWrite(byte dataIntern){ //Hilfsfunktion
  for(int x6 = 0; x6 <= 7; x6++){ // I/O Leitungen abfragen
    if(bitRead(dataIntern, x6) == 1){ 
     digitalWrite(ioLines[x6], HIGH);
     }
    else if(bitRead(dataIntern, x6) == 0){
     digitalWrite(ioLines[x6], LOW); 
    }
  }
}