From 66a67ef4f6f82650f18a6b724351f4249c76d78c Mon Sep 17 00:00:00 2001 From: christian Date: Wed, 20 Dec 2023 16:40:11 +0100 Subject: [PATCH] Initial-Commit --- .../Programmcounter_Rev1.0.ino | 361 +++++++++ .../Programmcounter_Rev1.1_8-BIT.ino | 734 ++++++++++++++++++ SRAM-Driver/SRAM-Driver.ino | 231 ++++++ 3 files changed, 1326 insertions(+) create mode 100644 Programmcounter_Rev1.0/Programmcounter_Rev1.0.ino create mode 100644 Programmcounter_Rev1.1_8-BIT/Programmcounter_Rev1.1_8-BIT.ino create mode 100644 SRAM-Driver/SRAM-Driver.ino diff --git a/Programmcounter_Rev1.0/Programmcounter_Rev1.0.ino b/Programmcounter_Rev1.0/Programmcounter_Rev1.0.ino new file mode 100644 index 0000000..201dc7d --- /dev/null +++ b/Programmcounter_Rev1.0/Programmcounter_Rev1.0.ino @@ -0,0 +1,361 @@ +#define analogPin_H 600 + + +int OUTPUT0 = 52; // Datapin0 +int OUTPUT1 = 50; // Datapin1 +int OUTPUT2 = 48; // Datapin2 +int OUTPUT3 = 46; // Datapin3 + +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 + + +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; + + + +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, 4, 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; + } + } + +} + +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; + } + } + + Serial.print("Ausgabe: 0x0"); + Serial.println(byte, HEX); + +} + +void resetBus() +{ + digitalWrite(OUTPUT0, HIGH); + digitalWrite(OUTPUT1, HIGH); + digitalWrite(OUTPUT2, HIGH); + digitalWrite(OUTPUT3, HIGH); +} + +char PCReg_readInput() +{ + +} + + + +void setup() { + pinMode(OUTPUT0, OUTPUT); + pinMode(OUTPUT1, OUTPUT); + pinMode(OUTPUT2, OUTPUT); + pinMode(OUTPUT3, OUTPUT); + pinMode(analogPin0, INPUT); + + pinMode(controlPin1, OUTPUT); + pinMode(controlPin2, OUTPUT); + pinMode(controlPin3, OUTPUT); + pinMode(controlPin4, OUTPUT); + + digitalWrite(controlPin1, HIGH); + digitalWrite(controlPin2, HIGH); + digitalWrite(controlPin3, HIGH); + digitalWrite(controlPin4, HIGH); + + digitalWrite(OUTPUT0, HIGH); + digitalWrite(OUTPUT1, HIGH); + digitalWrite(OUTPUT2, HIGH); + digitalWrite(OUTPUT3, HIGH); + + Serial.begin(9600); +} + + + +void loop() { +/* + readBus(4,0); + PCReg_set(0x0F); + delay(200); + readBus(4,0); + PCReg_set(0x0E); + delay(200); + readBus(4,0); + PCReg_set(0x0D); + delay(200); + readBus(4,0); + PCReg_set(0x0C); + delay(200); + readBus(4,0); + PCReg_set(0xB); + delay(200); + readBus(4,0); + PCReg_set(0x0A); + delay(200); + readBus(4,0); + PCReg_set(0x09); + delay(200); + readBus(4,0); + PCReg_set(0x08); + delay(200); + readBus(4,0); + PCReg_set(0x07); + delay(200); + readBus(4,0); + PCReg_set(0x06); + delay(200); + readBus(4,0); + PCReg_set(0x05); + delay(200); + readBus(4,0); + PCReg_set(0x04); + delay(200); + readBus(4,0); + PCReg_set(0x03); + delay(200); + readBus(4,0); + PCReg_set(0x02); + delay(200); + readBus(4,0); + PCReg_set(0x01); + delay(200); + readBus(4,0); + PCReg_set(0x00); + delay(200); + readBus(4,0); + + //PCReg_set(0x02); + +*/ +/* +if(counter <= 2) +{ + + PCReg_reset(); + for(int i=0; i <= 14;i++) + { + PCReg_increment(); + readBus(4,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(4,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) + { + PCReg_set(0x0F); + delay(200); + readBus(4,0); + PCReg_set(0x0E); + delay(200); + readBus(4,0); + PCReg_set(0x0D); + delay(200); + readBus(4,0); + PCReg_set(0x0C); + delay(200); + readBus(4,0); + PCReg_set(0xB); + delay(200); + readBus(4,0); + PCReg_set(0x0A); + delay(200); + readBus(4,0); + PCReg_set(0x09); + delay(200); + readBus(4,0); + PCReg_set(0x08); + delay(200); + readBus(4,0); + PCReg_set(0x07); + delay(200); + readBus(4,0); + PCReg_set(0x06); + delay(200); + readBus(4,0); + PCReg_set(0x05); + delay(200); + readBus(4,0); + PCReg_set(0x04); + delay(200); + readBus(4,0); + PCReg_set(0x03); + delay(200); + readBus(4,0); + PCReg_set(0x02); + delay(200); + readBus(4,0); + PCReg_set(0x01); + delay(200); + readBus(4,0); + PCReg_set(0x00); + delay(200); + readBus(4,0); + } + else { + Serial.println("Unbekannter Befehl!"); + } + + + } + + +} diff --git a/Programmcounter_Rev1.1_8-BIT/Programmcounter_Rev1.1_8-BIT.ino b/Programmcounter_Rev1.1_8-BIT/Programmcounter_Rev1.1_8-BIT.ino new file mode 100644 index 0000000..8f737e4 --- /dev/null +++ b/Programmcounter_Rev1.1_8-BIT/Programmcounter_Rev1.1_8-BIT.ino @@ -0,0 +1,734 @@ +#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); + */ + + } + } + + +} diff --git a/SRAM-Driver/SRAM-Driver.ino b/SRAM-Driver/SRAM-Driver.ino new file mode 100644 index 0000000..5fa429d --- /dev/null +++ b/SRAM-Driver/SRAM-Driver.ino @@ -0,0 +1,231 @@ +int RAM_Addr0 = A0; +int RAM_Addr1 = A1; +int RAM_Addr2 = A2; +int RAM_Addr3 = A3; +int RAM_Addr4 = A4; +int RAM_Addr5 = A5; +int RAM_Addr6 = A6; +int RAM_Addr7 = A7; + +int RAM_Data0 = A8; +int RAM_Data1 = A9; +int RAM_Data2 = A10; +int RAM_Data3 = A11; +int RAM_Data4 = A12; +int RAM_Data5 = A13; +int RAM_Data6 = A14; +int RAM_Data7 = A15; + +int analogPin_H = 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 +int val4 = 0; // Variable, die den gelesenen Wert speichert +int val5 = 0; // Variable, die den gelesenen Wert speichert +int val6 = 0; // Variable, die den gelesenen Wert speichert +int val7 = 0; // Variable, die den gelesenen Wert speichert + +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(RAM_Data0); // Pin einlesen + if(debug == 0x01) Serial.println(val0); + if(val0 > analogPin_H) byte += 0x01; + break; + case 1: + val1 = analogRead(RAM_Data1);// Pin einlesen + if(debug == 0x01) Serial.println(val1); + if(val1 > analogPin_H) byte += 0x02; + break; + case 2: + val2 = analogRead(RAM_Data2); // Pin einlesen + if(debug == 0x01) Serial.println(val2); + if(val2 > analogPin_H) byte += 0x04; + break; + case 3: + val3 = analogRead(RAM_Data3); // Pin einlesen + if(debug == 0x01) Serial.println(val3); + if(val3 > analogPin_H) byte += 0x08; + break; + case 4: + val4 = analogRead(RAM_Data4); // Pin einlesen + if(debug == 0x01) Serial.println(val3); + if(val4 > analogPin_H) byte += 0x10; + break; + case 5: + val5 = analogRead(RAM_Data5); // Pin einlesen + if(debug == 0x01) Serial.println(val3); + if(val5 > analogPin_H) byte += 0x20; + break; + case 6: + val6 = analogRead(RAM_Data6); // Pin einlesen + if(debug == 0x01) Serial.println(val3); + if(val6 > analogPin_H) byte += 0x40; + break; + case 7: + val7 = analogRead(RAM_Data7); // Pin einlesen + if(debug == 0x01) Serial.println(val3); + if(val7 > analogPin_H) byte += 0x80; + break; + } + } + + Serial.print("0x"); + Serial.println(byte, HEX); + +} + +void readRAMAddr(int bus_size, char debug) +{ + unsigned char byte = 0; + + for(int i=0;i <= bus_size;i++) + { + switch(i) + { + case 0: + val0 = analogRead(RAM_Addr0); // Pin einlesen + if(debug == 0x01) Serial.println(val0); + if(val0 > analogPin_H) byte += 0x01; + break; + case 1: + val1 = analogRead(RAM_Addr1);// Pin einlesen + if(debug == 0x01) Serial.println(val1); + if(val1 > analogPin_H) byte += 0x02; + break; + case 2: + val2 = analogRead(RAM_Addr2); // Pin einlesen + if(debug == 0x01) Serial.println(val2); + if(val2 > analogPin_H) byte += 0x04; + break; + case 3: + val3 = analogRead(RAM_Addr3); // Pin einlesen + if(debug == 0x01) Serial.println(val3); + if(val3 > analogPin_H) byte += 0x08; + break; + case 4: + val4 = analogRead(RAM_Addr4); // Pin einlesen + if(debug == 0x01) Serial.println(val3); + if(val4 > analogPin_H) byte += 0x10; + break; + case 5: + val5 = analogRead(RAM_Addr5); // Pin einlesen + if(debug == 0x01) Serial.println(val3); + if(val5 > analogPin_H) byte += 0x20; + break; + case 6: + val6 = analogRead(RAM_Addr6); // Pin einlesen + if(debug == 0x01) Serial.println(val3); + if(val6 > analogPin_H) byte += 0x40; + break; + case 7: + val7 = analogRead(RAM_Addr7); // Pin einlesen + if(debug == 0x01) Serial.println(val3); + if(val7 > analogPin_H) byte += 0x80; + break; + } + } + + Serial.print("0x"); + Serial.println(byte, HEX); + +} + + +void setup() { + // put your setup code here, to run once: + + pinMode(RAM_Addr0, INPUT); + pinMode(RAM_Addr1, INPUT); + pinMode(RAM_Addr2, INPUT); + pinMode(RAM_Addr3, INPUT); + pinMode(RAM_Addr4, INPUT); + pinMode(RAM_Addr5, INPUT); + pinMode(RAM_Addr6, INPUT); + pinMode(RAM_Addr7, INPUT); + + pinMode(RAM_Data0, INPUT); + pinMode(RAM_Data1, INPUT); + pinMode(RAM_Data2, INPUT); + pinMode(RAM_Data3, INPUT); + pinMode(RAM_Data4, INPUT); + pinMode(RAM_Data5, INPUT); + pinMode(RAM_Data6, INPUT); + pinMode(RAM_Data7, INPUT); + + Serial.begin(9600); + +} + +void loop() { + + //Serial.println("Starte Programm:"); + delay(1000); + + Serial.print("Lese: "); + readBus(8, 0x00); + Serial.print("an Adresse: "); + readRAMAddr(8,0x00); + Serial.println(); + + 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("setdata\n") == 0) + { + Serial.println("Schreibe 0xFF"); + + pinMode(RAM_Data0, OUTPUT); + digitalWrite(RAM_Data0, HIGH); + pinMode(RAM_Data1, OUTPUT); + digitalWrite(RAM_Data1, HIGH); + pinMode(RAM_Data2, OUTPUT); + digitalWrite(RAM_Data2, HIGH); + pinMode(RAM_Data3, OUTPUT); + digitalWrite(RAM_Data3, HIGH); + pinMode(RAM_Data4, OUTPUT); + digitalWrite(RAM_Data4, HIGH); + pinMode(RAM_Data5, OUTPUT); + digitalWrite(RAM_Data5, HIGH); + pinMode(RAM_Data6, OUTPUT); + digitalWrite(RAM_Data6, HIGH); + pinMode(RAM_Data7, OUTPUT); + digitalWrite(RAM_Data7, HIGH); + + Serial.println("Warte 4 Sekunden"); + delay(4000); + + pinMode(RAM_Data0, INPUT); + pinMode(RAM_Data1, INPUT); + pinMode(RAM_Data2, INPUT); + pinMode(RAM_Data3, INPUT); + pinMode(RAM_Data4, INPUT); + pinMode(RAM_Data5, INPUT); + pinMode(RAM_Data6, INPUT); + pinMode(RAM_Data7, INPUT); + + } + } + + //Serial.println(analogRead(RAM_Data0)); + // put your main code here, to run repeatedly: + + +}