Hallo,
ich habe zum Einstieg gleich mal eine Frage. Im Rahmen eines Informatikprojektes muss ich einen Volladdierer simulieren. Dabei gibt es drei Klassen. Die Klasse "Nand" simuliert Nand-Gatter.
Aufbau: Der Addierer hat drei Eingänge (Signale). Diese werden über Nand Gatter wieder über Signale zu einer Reihe Nand-Gatter geschleust und am Ende am Endsignal ausgegeben. Seht am besten selbst, ich habe schon sehr umfangreich kommentiert:
Zunächst die Anfangs gegebene Klasse functional simulator. sie erzeugt nur objekte von den klassen und verbindet ein und ausgänge.
dabei haben nand gatter beliebig viele eingänge und nur einen ausgang.
Signale bekommen nur einen Namen zugewiesen.
Hier meine Implementierung der Klasse Nand:
und der Klasse Signal
Problem nun: In meinen Augen habe ich die Aufgabe fast gelöst, nur muss ein Objekt der Klasse Signal dem Nand über die dafür eingerichtete Methode "calcAusgang" mitteilen, dass es nun neu rechnen solle!
Ich hoffe da steht nicht zu viel Code..
Danke im Voraus,
Adrian
ich habe zum Einstieg gleich mal eine Frage. Im Rahmen eines Informatikprojektes muss ich einen Volladdierer simulieren. Dabei gibt es drei Klassen. Die Klasse "Nand" simuliert Nand-Gatter.
Aufbau: Der Addierer hat drei Eingänge (Signale). Diese werden über Nand Gatter wieder über Signale zu einer Reihe Nand-Gatter geschleust und am Ende am Endsignal ausgegeben. Seht am besten selbst, ich habe schon sehr umfangreich kommentiert:
Zunächst die Anfangs gegebene Klasse functional simulator. sie erzeugt nur objekte von den klassen und verbindet ein und ausgänge.
dabei haben nand gatter beliebig viele eingänge und nur einen ausgang.
Signale bekommen nur einen Namen zugewiesen.
Java:
/**
* Klasse FunctionalSimulator ist ein einfacher Logiksimulator, der nur
* Nand-Gatter simulieren kann und keine Zeitverz�gerungen ber�cksichtigt.
* Die zu simulierende Schaltung wird im Konstruktor der Klasse erzeugt.
* Es handelt sich hierbei um einen einfachen Volladdierer.
* Zum Testen Ihrer Klassen <CODE>Nand</CODE> und <CODE>Signal</CODE> m�ssen Sie
* einfach nur eine Instanz dieser Klasse erzeugen und dann die Methode
* <CODE>simulate()</CODE> aufrufen.
* @author Christian Hochberger, TU Dresden
* @version 1.0 Erste Fassung
*/
public class FunctionalSimulator {
// Eing�nge (i1-i3) und Ausg�nge (s1,s0) der Schaltung
Signal i1,i2,i3,s1,s0;
// Innere Signale, geben das invertierte Signal der Eing�nge an
Signal ni1,ni2,ni3;
// Innere Signale, die bei der Berechnung der Summe ben�tigt werden
Signal t1,t2,t3,t4,t5,t6,t7;
// Nand-Gatter zum Invertieren der Eing�nge
Nand inv1,inv2,inv3;
// Nand-Gatter zur Berechnung der Summe
Nand n1,n2,n3,n4,n5,n6,n7,n8,n9;
/**
* Konstruktor, der die zu simulierende Schaltung aufbaut.
* Simuliert wird ein einfache Volladdierer.
*/
public FunctionalSimulator() {
// Alle Signale anlegen
// Der Konstruktor bekommt einen Signalnamen als Parameter
i1=new Signal("i1");
i2=new Signal("i2");
i3=new Signal("i3");
ni1=new Signal("ni1");
ni2=new Signal("ni2");
ni3=new Signal("ni3");
s1=new Signal("s1");
s0=new Signal("s0");
t1=new Signal("t1");
t2=new Signal("t2");
t3=new Signal("t3");
t4=new Signal("t4");
t5=new Signal("t5");
t6=new Signal("t6");
t7=new Signal("t7");
// Alle Gatter anlegen
// Parameter des Konstruktors ist die Anzahl von Eing�ngen
// Die Inverter sind sozusagen entartete Nand-Gatter (1 Eingang)
inv1=new Nand(1);
inv2=new Nand(1);
inv3=new Nand(1);
n1=new Nand(3);
n2=new Nand(3);
n3=new Nand(3);
n4=new Nand(3);
n5=new Nand(3);
n6=new Nand(3);
n7=new Nand(3);
n8=new Nand(4);
n9=new Nand(4);
// Inverter mit Ein- und Ausg�ngen verbinden.
// Die Methode setInput() des Gatters bekommt die Nummer des Eingangs
// und das Signal, mit dem dieser Eingang verbunden werden soll.
inv1.setInput(0,i1);
// Die Methode setOutput() bekommt nur ein Signal, welches durch diesen
// Ausgang bestimmt wird
inv1.setOutput(ni1);
inv2.setInput(0,i2);
inv2.setOutput(ni2);
inv3.setInput(0,i3);
inv3.setOutput(ni3);
// Die Nand-Gatter zur Summenberechnung richtig verbinden
n1.setInput(0,ni1);
n1.setInput(1,ni2);
n1.setInput(2,i3);
n1.setOutput(t1);
n2.setInput(0,ni1);
n2.setInput(1,i2);
n2.setInput(2,ni3);
n2.setOutput(t2);
n3.setInput(0,ni1);
n3.setInput(1,i2);
n3.setInput(2,i3);
n3.setOutput(t3);
n4.setInput(0,i1);
n4.setInput(1,ni2);
n4.setInput(2,ni3);
n4.setOutput(t4);
n5.setInput(0,i1);
n5.setInput(1,ni2);
n5.setInput(2,i3);
n5.setOutput(t5);
n6.setInput(0,i1);
n6.setInput(1,i2);
n6.setInput(2,ni3);
n6.setOutput(t6);
n7.setInput(0,i1);
n7.setInput(1,i2);
n7.setInput(2,i3);
n7.setOutput(t7);
// n8 und n9 berechnen die eigentlichen Ausg�nge
n8.setInput(0,t1);
n8.setInput(1,t2);
n8.setInput(2,t4);
n8.setInput(3,t7);
n8.setOutput(s0);
n9.setInput(0,t3);
n9.setInput(1,t5);
n9.setInput(2,t6);
n9.setInput(3,t7);
n9.setOutput(s1);
// Die Signale s1 und s0 sind mit keinen weiteren Gattern verbunden.
// Sorgen Sie daf�r, dass in diesem Fall eine Wert�nderung dieser
// Signale ausgegeben wird.
}
/**
* Diese Methode f�hrt die eigentliche Simulation durch. Dazu werden den
* Eingangssignalen (i1,i2,i3) einfach nur neue Werte zugeordnet. Diese
* Wert�nderungen propagieren sich dann durch die Schaltung bis zum Ausgang
* und werden dort ausgegeben.
*/
public void simulate() {
// Zun�chst alle Eing�nge auf false setzen (ist zwar schon nach dem)
// Erzeugen des Gatters so, aber durch ein erneutes Setzen werden
// die inneren Signale der Schaltung vern�nftig berechnet)
i1.setValue(false);
i2.setValue(false);
i3.setValue(false);
// Eingang i1 auf true: Dadurch sollte als Summe s1=false und s0=true
// herauskommen. Es ist aber normal, dass �nderungen an s1 und s0 mehrfach
// ausgegeben werden, bevor das Endergebnis herauskommt.
System.out.println("==== i1 -> true");
i1.setValue(true);
// Eingang i1 und i2 auf true: Dadurch sollte als Summe s1=true und
// s0=false herauskommen.
System.out.println("==== i2 -> true");
i2.setValue(true);
// Eingang i1,i2 und i3 auf true: Dadurch sollte als Summe s1=true und
// s0=true herauskommen.
System.out.println("==== i3 -> true");
i3.setValue(true);
// Eingang i1 und i3 auf true: Dadurch sollte als Summe s1=true und
// s0=false herauskommen.
System.out.println("==== i2 -> false");
i2.setValue(false);
// Eingang i3 auf true: Dadurch sollte als Summe s1=false und
// s0=true herauskommen.
System.out.println("==== i1 -> false");
i1.setValue(false);
// Eingang i2 und i3 auf true: Dadurch sollte als Summe s1=true und
// s0=false herauskommen.
System.out.println("==== i2 -> true");
i2.setValue(true);
}
/**
* Main Methode dieser Klasse. Sie m�ssen das im Moment noch nicht
* verstehen. Diese Methode wird ben�tigt, wenn Sie den Simulator ohne
* BlueJ laufen lassen wollen. Wenn Sie diese Klasse in BlueJ nutzen,
* dann ignorieren Sie diese Methode einfach.
*/
public static void main(String[] args) {
FunctionalSimulator s=new FunctionalSimulator();
s.simulate();
}
}Hier meine Implementierung der Klasse Nand:
Java:
public class Nand {
// --------------- Datenfelder ---------------
private Signal[] signale; // Array mit signalen
private Signal ausgang; // Es existiert nur ein Ausgang.
private boolean ausgangswert; // Hilfsgröße, die dann auf Signal "Ausgang" übertragen wird.
// --------------- Konstruktor ---------------
public Nand (int eingaenge) { // Functional simulator ruft konstruktor auf
signale = new Signal[eingaenge]; // Array für signale: eingangszahl = anzahl felder setzen
this.ausgangswert = false; // Ausgang zunächst mal auf false..
}
// --------------- Methoden ---------------
public void setInput (int eingang, Signal signalname) {
signale[eingang] = signalname; // Dem Nand Gatter wird am Eingang "eingangsnummer" das Signal "signalname" zugeordnet.
signalname.nandName ( adresse dieses nands ) // Hier vielleicht der Versuch, dem Signal zu sagen, wie das Nand zu referenzieren ist..
}
public void setOutput(Signal ausgang){
this.ausgang = ausgang; // Dem Nand Gatter wird ein Signal des Typs Signal an seinem (einzigen) Ausgang zugeordnet.
}
public void calcAusgang () {
int trueeingaenge = 0; // Methodenvariable: Zähler für die "true" geschalteten Eingänge
for (Signal wert : signale) {
if (wert.eingeschaltet() == true) {trueeingaenge++; // Zählt wahr geschaltete eingänge: dafür gibt es eine methode in "Signal",
// damit NAND auch einen boolean Wert zurückbekommt
};
}
if (trueeingaenge == 0) {this.ausgangswert = true;} // Wenn alle eingänge falsch, ausgang wahr (nand.)
else {this.ausgangswert = false;} // sonst nicht.
ausgang.setValue (ausgangswert); // Übertrage den Wert am Ausgang auf das richtige Signal. "ausgang" ist vom Typ Signal
// und ist ein Platzhalter für das Ausgangssignal. setValue setzt den Wert.
}
}und der Klasse Signal
Java:
public class Signal {
// --------------- Datenfelder ---------------
private String name; // Name des Signals
private boolean an; // Ist das Signal an oder aus?
// --------------- Konstruktor ---------------
// Klasse Signal übernimmt Name als Parameter
// Das Signal kann an oder aus sein (boolean wert), anfangs aus.
public Signal (String name) {
this.name = name;
an = false;
}
// --------------- Methoden ---------------
public boolean eingeschaltet () { // gibt zurück ob signal an oder aus
if (an == true) {return true;}
else {return false;}
}
public void setValue (boolean an) { // Zustand (an/aus) setzen
if (an == this.an && this.name.startsWith("s")) { // nur summenänderungen zeigen. Summen starten mit "s".
System.out.println(name + " -> " + an);
//Ausgabe: aktualisierter zustand des ausgangs (!) "name"
this.an = an; // neuen wert des signals setzen
};
}
}Problem nun: In meinen Augen habe ich die Aufgabe fast gelöst, nur muss ein Objekt der Klasse Signal dem Nand über die dafür eingerichtete Methode "calcAusgang" mitteilen, dass es nun neu rechnen solle!
Ich hoffe da steht nicht zu viel Code..
Danke im Voraus,
Adrian
