735 lines
17 KiB
C++
735 lines
17 KiB
C++
#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);
|
|
*/
|
|
|
|
}
|
|
}
|
|
|
|
|
|
}
|