Der Gigatron TTL Computer

Vor einigen Wochen bin ich im Internet über einen Artikel betreffend den Gigatron TTL Computer gestolpert (https://gigatron.io/), ein Computer, angeblich völlig ohne CPU. Tatsächlich soll er nur aus einem EPROM, einem statischen RAM und einen Haufen TTL ICs bestehen. Gleichzeitig soll er allerdings einen VGA Farbvideo Ausgang haben, Sound, Spiele-Controller und sogar Blinken-Lights. Ausgeliefert wird das Ding als Bausatz für 150 €. Nicht ganz preiswert, aber interessant genug für mich, um ihn zu bestellen.

Zu den Bildern noch ein Hinweis: Die Sockel für die TTL ICs sind NICHT dabei, sondern von mir zugekauft. Sockel wurden nur für das EPROM und das RAM mitgeliefert!

Nach vier Tagen löten und Basteln (insgesamt jedoch maximal 4 Stunden) war der TTL Computer komplett aufgebaut und funktioniert perfekt.

So sieht das Ding dann komplett aus. Die blauen IC-Sockel habe ich dann doch noch durch schwarze ersetzt.

Blinkenlights auf dem noch nicht vollständig bestückten Computer.

Autorennen. Gar nicht mal so schlecht, die Geschwindigkeit.

Selbst programmiert habe ich ihn noch nicht, aber auch das geht. Im Gigatron-Forum kann man schon von Tetris und sogar Schach-Programmen lesen.

Jalousien-Schalter selbstgebaut

Endlich komme ich mal wieder dazu, ein paar Zeilen in diesen Blog zu schreiben. Grund dafür ist eine Bastelei, die ich euch nicht vorenthalten möchte.
Wir haben im Haus eine ganze Menge Jalousien, die mit einem elektrischen Antrieb ausgestattet sind. Dieser Antrieb besteht aus einem Motor, der (vom Schutzleiter abgesehen) drei Anschlüsse hat: 230 Volt zwischen den Anschlüssen 1 und 2 rollt die Jalousie hoch, 230 Volt zwischen den Anschlüssen 1 und 3 rollt die Jalousie runter. Bei der Erstinstallation stand ich im Elektrofachmarkt vor der Wahl entweder einen ganz normalen Doppeltaster für 10€ oder einen Jalousienschalter für 50€ zu nehmen. Bei neun Schaltern kommt da schon einiges zusammen. Ich entschied mich aus finanziellen Gründen für die einfachen Doppeltaster, die bislang seit sechs Jahren ihren Dienst verrichten. Etwas nervig ist nur, dass die Motoren eben nur so lange laufen, wie man auf die Taste drückt. Ferner passiert es hauptsächlich mir immer wieder, dass ich mit meinen breiten Wurstfingern auch schon mal auf beide Taster gleichzeitig drücke, was ein hässliches Geräusch aus dem Jalousienkasten zur Folge hat. Und zu guter Letzt schwebte mir noch etwas vor, das ganze fernbedienbar zu machen (z. B. automatisiert nach Sonnenstand oder Temperaturdifferenz).
Das neue System sollte so funktionieren, dass ein kurzer Druck auf einen Taster dafür sorgt, dass die Jalousie selbständig ganz nach oben oder unten rollt. In dem Jalousiekasten sind Endschalter montiert, sodass der Motor die Jalousie nicht weiter drehen kann, als es mechanisch möglich ist. Betätigt man während dieser automatisch Fahrt eine der beiden Tasten, so soll der Motor sofort anhalten. Ein langer Druck auf den Taster soll genau dasselbe bewirken, wie die jetzigen Taster: Der Motor läuft nur so lange, wie man die Taste gedrückt hält. Werden irgendwann einmal beide Tasten gedrückt, dann hält der Motor sofort an und es müssen erst beide Taster losgelassen werden. Alles in allem ein Fall für einen Mikrocontroller.
Nun ist in einer Hohlwanddose nicht beliebig viel Platz, sodass 50Hz-Transformatoren von vornherein aussscheiden. Schaltnetzteile wären möglich, aber unnötig kompliziert und teuer. Da die gesamte Schaltung berührungssicher hinter dem Schalter in der Hohlwanddose eingebaut ist, fiel meine Wahl auf ein Kondensatornetzteil. Es ist simpel, einfach, jedoch ohne galvanische Trennung. Allerdings möchte ich niemanden ohne ausreichende Erfahrung im Umgang mit der Netzspannung empfehlen, dies nachzubauen.

Ich möchte nun erklären, wie dieses Netzteil funktioniert: Links oben wird die Zuleitung aus dem Sicherungskasten angeschlossen, dabei ist unerheblich, wo der Null-Leiter und wo die Phase angeschlossen sind. Vom Anschluss 1 ausgehend befindet sich als erstes eine Sicherung in der Zuleitung: Ein Kondensatornetzteil kann immer einmal durchschlagen. Man darf nicht denken, dass auf der Netzleitung ausschließlich eine reine 230V Sinus-Spannung anliegt. Hier gibt es aufmodulierte Zeitsignale für Nachtstromspeichersteuerungen, induzierte Spannungsspitzen in Höhen bis zu 2kV und andere kurze Impulse, die bis zu 6kV hoch sein können. Für ein herkömmliches Transformatornetzteil sind diese Spannungsspitzen quasi unsichtbar, denn der Transformator ist viel zu träge, um diesen Spitzen folgen zu können. Allerdings folgen daraus einige Konsequenzen für den Hauptakteur eines Kondensatornetzteiles, hier C1: Es muss sich um einen MKP-Typen handeln, die zum einen impulsfest sind und zum anderen über gewisse Selbstheilungseigenchaften verfügen. Die Spannungsfestigkeit muss 630V für Gleichstrom und 250V für Wechselstrom betragen.
Der Vorwiderstand R1 begrenzt noch einmal die hin und wieder auftretenden Spannungsspitzen. Ferner sorgt er dafür, dass beim Einschalten dieser Schaltung im Spannungsmaximum der Ladestrom des Kondensators nicht die Sicherung auslöst. Die Widerstände R2 und R3 (die keinesfalls durch einen einzelnen Widerstand ersetzt werden dürfen) tragen dafür Sorge, dass nach dem Abschalten der Netzspannung der Kondensator C1 innerhalb kürzester Zeit soweit entladen ist, dass man bei Berührung keinen elektrischen Schlag mehr bekommt.
Im weiteren Verlauf der Schaltung wird es eher altbacken: An eine Zenerdiode 12V/1,3W, welche die Spannung auf 12V nach oben und -0,7V nach unten erstmalig begrenzt, schließt sich eine normale Diode D2 an, welche die Spannung nochmals begrenzt auf 11,3V nach oben und 0V nach unten. Daran schließen sich dann der Siebelko C2, ein Spannungsregler, ein Ladeelko C3 und ein kleiner 100nF Kondensator C4 zur Unterdrückung von Schwingungen des Spannungsreglers.

Auch im rechten Teil der Schaltung ist keinerlei Magie zu erkennen: Links oben die +5 Zuleitung, darunter die 0V Leitung unten ganz unten links die 230V von der Sicherung.
Links am ATTiny kann man die drei Anschlüsse für den Doppeltaster erkennen. Auf der rechten Seite befinden sich zwei klassische Triac-Schalter, die ich noch kurz erläutern möchte. Sofern der ATTiny an seinen Port-Pins PB0 oder PB1 eine logische "1", also irgendetwas zwischen 4,5 und 5V  anlegt, befindet sich zwischen dem Gate-Anschluss des Triacs und dem Anschluss MT1 eine Spannung von kleiner als 0,7V. Diese Spannung braucht dieser Triac, der TIC206 zum Zünden. Sobald der ATTiny aber eine 0 an seinen Portpins schaltet, kann der Triac zünden und somit den Jalousienmotor mit Strom versorgen.
Ein weiteres Schaltungsdetail befindet sich rechts vom Triac, der sogenannte Snubber oder auch Boucherot-Glied: Es soll hochfrequente Störimpulse verhindern, die beim Schalten induktiver Lasten (Jalousienmotor) auftreten können. Diese Störimpulse können sich zum einen auf andere Geräte im Haushalt auswirken, den Rundfunkempfang (auch der Nachbarn) stören und auch dazu führen, dass der Triac "über Kopf" zündet, d. h. auch ohne Zündimpuls geht der Triac in den leitenden Zustand.

Dies war die erste Version meiner Jalousien-Steuerung, die ich anschließend noch einmal modifiziert habe: Der Doppeltaster war so angeschlossen, dass der gemeinsame Anschluss auf Pin 1, der Auf-Taster an Pin 2 und der Ab-Taster an Pin 3 des Steckers (zweites Bild ganz links) lag.
Den gemeinsamen Anschluss habe ich dann an den GND-Anschluss des ATTiny gelegt, während ich in den Ports die internen Pull-Up Widerstände eingeschaltet hatte. So kann ich auch mit zwei Anschlüssen beide Schalter abfragen. Nun ist ein Anschluss frei geworden, allerdings reichte das noch nicht: Ich hatte immer noch einen Anschluss zuwenig. Ich tauschte daher den ATTiny22 gegen einen ATTiny 25, dessen RESET-Anschluss sich auch als weiterer Portpin benutzen ließ. Des weiteren verfügt der ATTiny25 über eine SPI Schnittstelle, die ich zum Ansteuern des Funkmodul RFM01-433 Empfangsmodul benötigte. Damit habe ich nun endlich, was ich immer haben wollte: Eine intelligente Jalousiensteurung, bei der ein kurzer Tastendruck reicht, um die Jalousie vollständig hoch oder runter zu fahren, anstatt dass ich die ganze Zeit über mit dem Finger auf dem Taster dabei stehen muss. Und zum anderen konnte ich nun die Jalousie (oder auch mehrere) mit einem Funksignal steuern.
Wie ich das ganze Paket dann in die Hohlwanddose gequetscht habe, ist eine andere Geschichte.

Gehversuche mit dem CPLD

Ich bin ja normalerweise ein eher ruhiger (manche sagen: phlegmatischer) Zeitgenosse. Aber heute Abend bin ich fast wahnsinnig geworden, mit diesem Scheiß von Xilinx. Mit Scheiß meine ich konkret: Die Verbindung von der ISE zum Programmierkabel. Man kann doch nicht den Linux-Standard-USB Treiber nehmen, nicht doch. Es muss ein proprietärer eigener Rotz sein, der mit nichts kompatibel ist (und der auch nicht funktioniert). Glücklicherweise gibt es noch andere Nerds, denen das auf die Nerven ging, und die einen Wrapper geschrieben haben, sodass die ISE direkt auf den Linux-USB Treiber zugreift.
Dennoch brauchte ich zwei Stunden um heraus zu finden, dass das Parallelport-Kabel nur dann funktionieren kann, wenn es an einem echten (sprich: PC-eingebauten) Parallelport angeschlossen ist. Steckkarten oder USB->Parallel Kabel werden von der ISE einfach ignoriert. Welch grandioser Schwachsinn, da ja keiner der heute ausgelieferten PCs noch eine parallele Schnittstelle hat.
Aber ich habe ja das USB Programmiergerät bekommen. Es dauerte eine weitere Stunde, bis ich diesen mit allen Treibern bestückt hatte und die ISE das Teil erkannte. Was ein Krampf.
Schlussendlich funktionierte aber auch das, und ich wagte mich daran, das Programmiergerät an die von mir zusammen gelötete CPLD-Karte anzustöpseln. Kurzes Innehalten: Kein Qualm, kein Geruch, alles leuchtet noch... Weiter im Text. Nun die ISE starten und den Chip suchen lassen - siehe da: Die ISE erkennt den Chip.
Mutig schrieb ich einen kleinen Zähler und hängte die Ausgänge an die acht Leuchtdioden. Bösartigerweise war im Pollin Handbuch zu den Pinnummern des CPLD ein Fehler, weshalb sich die ISE hartnäckig weigerte, den Pin 98 des CPLD an die LED #1 anzuschließen. Ein Blick in den Schaltplan (mit einer starken Lupe) zeigte den Fehler: Es ist Pin 97. Das also korrigiert, neu compiliert und den Chip programmiert. "Successfully". Hurra. Nur leider leuchteten nun alle acht LEDs.
Hmm, ja, klar doch: Bei 16 MHz Taktfrequenz sieht man da nicht viel, also wurde aus einem 8-Bit Zähler ein 16-Bit, dann ein 24-Bit und schließlich ein 27-Bit Zähler. Die höchsten acht Bits habe ich jeweils an die LEDs geschaltet.
Dies ist das Programm:

module Counter(
    input clock,
    output [7:0] led
    );

reg [26:0] zaehler;

always @(posedge clock) begin
  zaehler = zaehler + 1;
end

initial begin
  zaehler = 0;
end

assign led[7:0] = zaehler[26:19];

endmodule

Und so sieht es dann aus:

Genug für heute, sonst werde ich noch übermütig :-)

Es werde Hardware

Heute bei diesem schönen Wetter mal keine tiefschürfenden philosophischen Gedanken, sondern solides Handwerk. Gestern bekam ich mit der Post nämlich ein kleines Päckchen aus Fernost, worin sich der langersehnte Xilinx USB Programmer befand:

Mit dabei ein USB Kabel und eine Menge Steck-Adapter, um sowohl FPGAs als auch CPLDs programmieren zu können. Jetzt brauchen wir "nur" noch einen CPLD. Und den haben wir ja, zumindest als Bausatz:

Zwei Stunden Bastelarbeit und ein gut eingeschenktes Glas (alkoholfreies) Weizenbier bei bestem Wetter auf der Terrasse und der Drops war gelutscht.

Soviel für heute.

Es wird langsam konkret

Nachdem ich mich nun damit angefreundet habe, einen CPLD für die Ansteuerung der CF-Karte zu verwenden, konnte ich den Schaltplan damit erst einmal komplettieren. Ein erster Versuch eines Layouts scheiterte noch kläglich, auf nur zwei Lagen war da nichts zu machen.
Ich hatte aber zum einen noch einige 74er Bausteine auf dem Board, die nur zur Hälfte, bzw zu einem sechstel verwendet wurden. Da der CPLD aber noch eine Menge freier Leitungen hatte, konnte ich im Xilinx ISE Tool auch noch diese beiden ICs komplett in den CPLD abbilden. Auch der Frequenzteiler durch 4, der den Takt für die serielle Schnittstelle erzeugt, wurde durch den CPLD ersetzt. Damit sieht der Schaltplan um die CPU nun wie folgt aus:

Der Schalplan für den CPLD und die CF-Karte:

Die serielle Schnittstelle:

Ein erstes Layout sieht wie folgt aus:

Wie man erkennt, passt alles wunderbar auf 100 cm² Platinenfläche. Das ist natürlich nur ein erster Rohentwurf, hauptsächlich als Nachweis, dass das Ganze überhaupt noch zweiseitig zu layouten ist. Als nächstes kommen noch die vielen kleinen Details, wie z. B.

• Einige Status-LEDs an die Stirnseite, 
• Ein Netzteil, wenn ich das mal so nennen darf, das es erlaubt, das System entweder mit 8 - 12 Volt Gleich- oder Wechselspannung zu betreiben 
• Reset-Taster nach vorne
• Stützkondensatoren direkt an die Spannungsversorgung der ICs
• Alles, an was ich hier noch nicht gedacht habe.

Und dann muss die Platine auch noch Realität werden. Aus einer Anzeige in der Amateurfunkzeitung CQ DL habe ich einen heißen Kandidaten: IMDES. Der derzeitige Preis für die oben abgebildete Platine liegt bei 16 Euronen, doppelseitig und durchkontaktiert wohlverstanden. Kein Mindestbestellwert, hauptsächlich kleine Stückzahlen. Für uns Bastler ideal.

In diesem Sinne

Frohe Ostern

CF-Karte und CPLD Teil II

Nachdem ich nun ein Wochenende in Ruhe drüber nachdenken konnte, wie ich denn dieses Riesen-CPLD vereinfachen kann, ist mir eine Idee gekommen. Den Adressbus brauche ich nicht wirklich durch das CPLD zu routen, da die Adressinformationen die ganze Zeit über an der CF-Karte anliegen können. Unter dieser Bedingung komme ich zu einem etwas einfacherem Verilog-Programm:

module CF_Card_Interface(
clk,
data_z8,
data_cf,
iorq,
wr,
rd,
cfrd,
cfwr,
cfsel,
z8wait,
cpld_selected);

input clk;
inout [7:0] data_z8;
inout [7:0] data_cf;
input iorq;
input wr;
input rd;
output cfrd;
reg cfrd = 1;
output cfwr;
reg cfwr = 1;
output cfsel;
reg cfsel = 1;
output z8wait;
reg z8wait = 1;
reg [5:0] counter;
reg [7:0] data_z8_reg;
reg [7:0] data_cf_reg;
input cpld_selected;

wire cpld_sel = (iorq == 0 && cpld_selected == 1);
wire z8_io_read = (rd == 0 && cpld_sel == 1) ? 1 : 0;
wire z8_io_write = (wr == 0 && cpld_sel == 1) ? 1 : 0;

assign data_z8 = (z8_io_read == 1) ? data_z8_reg : 8'bzzzzzzzz;
assign data_cf = (z8_io_write == 1) ? data_cf_reg : 8'bzzzzzzzz;

always @(negedge clk) begin
if (!z8_io_read && !z8_io_write) begin
counter = 0;
cfrd = 1;
cfwr = 1;
cfsel = 1;
z8wait = 1;
end else begin
case(counter)
0: begin
z8wait = 0;
if (wr == 0) begin
data_cf_reg = data_z8;
end
end
3: if (rd == 0) begin
cfrd = 0;
cfsel = 0;
end else begin
cfsel = 0;
cfwr = 0;
end
 13: if (rd == 0) begin
data_z8_reg = data_cf;
end
 14: begin
cfsel = 1;
cfrd = 1;
cfwr = 1;
end
 15: begin
z8wait = 1;
end
endcase
counter = counter + 1;
end
end
endmodule

Nachdem ich diese Änderungen im Xilinx ISE eingegeben hatte und nach einem passenden CPLD fahnden ließ, lautete die Antwort tatsächlich XC9536, der kleinste aller CPLDs von Xilinx. Bei Reichelt für € 1,80 in einem VQFP-44 Gehäuse (quadratischer SMD) zu bekommen.
Leider hat die ISE bei dem automatischen Fitting die Zuordnung der Pins recht willkürlich vorgenommen, um die Funktionsbausteine gleichmäßig auszunutzen. Da wird nun noch eine Menge Handarbeit erforderlich sein, um die Pins so gut wie möglich zu sortieren, damit noch ein sinnvolles Platinenlayout möglich ist. Aber diese Hürde wäre dann auch schon mal genommen.
Dann wäre der übernächste Schritt in der Tat die Fertigung der Platine. Es geht voran.

So einfach geht's mit CF-Karten nun auch wieder nicht

Das war nun auch zu schön um wahr zu sein. Die Demo-Schaltung mit einem Microcontroller und einer direkt dort angeschlossenen CF-Karte funktioniert leider nur deshalb, weil der Microcontroller die CF-Karte erstens mit Port-Bausteinen und zweitens auch noch langsam genug anspricht. Wenn man, wie in meinem Falle, die CF Karte direkt an den Adress- und Datenbus anschließen möchte, dann sollte man auch einen Blick in die Timing-Diagramme werfen. Und genau hier zeigen sich ein unschönes und zwei hässliche Probleme:

1. Die CF-Karte erwartet die Adress-Informationen auf den Leitungen A0..A2 70ns vor dem eigentlichen Schreib- oder Leseimpuls (hier IORQ und RD oder WR). Der Z8S180 legt bei einem 33 MHz Takt die Adress-Informationen aber gerade einmal 5ns vor dem Zugriff auf den Bus.
2. Die CF-Karte braucht relativ lange nach dem Abfall der Schreib- Lesesignale, bis es den Datenbus wieder freigibt (in den Tri-State geht). Immerhin bis zu 30ns, laut Datenblatt. In der Zeit ist der Z8 schon beinahe wieder am nächsten Befehl.
3. Unschön, aber mit einigen -zig Wait-States zu regeln ist die relativ lange Wartezeit von bis zu 290ns auf die Daten aus der CF-Karte.

Ich habe spaßeshalber diesen Zugriffsmechanismus einmal für einen CPLD in Verilog geschrieben und durchsimuliert. Hier ist das Programm:

module CF_Card_Interface(
  clk,
  addr_in,
  addr_compare,
  addr_out,
  data_z8,
  data_cf,
  iorq,
  wr,
  rd,
  cfrd,
  cfwr,
  cfsel,
  z8wait);

input clk;
input [7:0] addr_in;
input [4:0] addr_compare;
output [2:0] addr_out;
reg [2:0] addr_out;
inout [7:0] data_z8;
inout [7:0] data_cf;
input iorq;
input wr;
input rd;
output cfrd;
reg cfrd;
output cfwr;
reg cfwr;
output cfsel;
reg cfsel;
output z8wait;
reg z8wait;
reg [5:0] counter;
reg [7:0] data_z8_reg;
reg [7:0] data_cf_reg;

wire cpld_sel = (iorq == 0 && addr_compare == addr_in[7:3]) ? 1 : 0;
wire z8_io_read = (rd == 0 && cpld_sel == 1) ? 1 : 0;
wire z8_io_write = (wr == 0 && cpld_sel == 1) ? 1 : 0;

assign data_z8 = (z8_io_read == 1) ? data_z8_reg : 8'bzzzzzzzz;
assign data_cf = (z8_io_write == 1) ? data_cf_reg : 8'bzzzzzzzz;

always @(negedge clk) begin

  if (!z8_io_read && !z8_io_write) begin

    counter = 0;

    cfrd = 1;

    cfwr = 1;

    cfsel = 1;

    z8wait = 1;

  end else begin

    case(counter) 

      0: begin

        addr_out <= addr_in[2:0];

        z8wait = 0;

        if (wr == 0) begin

          data_cf_reg = data_z8;

        end

      end

      3: if (rd == 0) begin

        cfrd = 0;

        cfsel = 0;

      end else begin

        cfsel = 0;

        cfwr = 0;

      end

      13: if (rd == 0) begin

        data_z8_reg = data_cf;

      end

      14: begin

        cfsel = 1;

        cfrd = 1;

        cfwr = 1;

      end

      15: begin

        z8wait = 1;

        end

      endcase

      counter = counter + 1;

    end

  end

endmodule

Soweit das Modul. Das Modul-Interface ist gleichzeitig die Pin-Beschreibung des CPLD. Ich möchte die Pins hier im einzelnen beschreiben.

Clk ist der Ausgang Phi des Z8S180 und somit ein 33 MHz Taktsignal.

Addr_In sind die Adressleitungen A0...A7 der CPU, Data_z8 ist der Datenbus der CPU.

Addr_Compare ist mit einem 5-stelligen DIP-Schalter verbunden, über den von außen der Adressbereich des Bausteins eingestellt werden kann.

IORQ, WR und RD sind die low-aktiven Schreib-/Lesesignale der CPU.

Z8WAIT ist das low-aktive WAIT Signal an die CPU.

Die restlichen Leitungen Addr_Out, Data_CF, CFWR, CFRD und CFSEL sind mit der CF-Karte verbunden.

Und so sieht das ganze dann auf dem Logic-Analyzer aus. Hier zuerst ein Schreibzugriff.

In dem Moment, in dem der Z8 Adresse und IORD anlegt, erkennt man, dass das interne Signal CPLD_SEL aktiv wird. Bei der nächsten fallenden Flanke des CLK-Signals (bei 120ns) werden sowohl Adress- und Datenleitungen für die CF-Karte beschickt, als auch ein WAIT-Signal an die Z8 gesendet.

3 CLK Zyklen später (also 90ns) werden sowohl CFSEL als auch CFWR aktiviert, also der Schreibvorgang in die CF-Karte gestartet. Laut Datenblatt der CF-Karte darf dies frühestens 70ns nach dem stabilen Anlegen der Adresse geschehen.

Gut 300ns später (die CF-Karte braucht 290ns für den Schreibvorgang), werden CFSEL und CFWR wieder deaktiviert. Damit sich nun der Datenbus der CF-Karte beruhigen kann, wird noch einmal ein CLK-Zyklus gewartet, bevor das WAIT-Signal zur Z8 wieder deaktiviert wird. Die Z8 läuft daraufhin wieder an und beendet den Schreibvorgang.

Hier dasselbe für den Lesezugriff:

Der Unterschied liegt hier am Ende des Lesezyklus. 300ns nachdem der CPLD der CF-Karte das Lesesignal gegeben hat, werden die Daten der CF-Karte auf den Datenbus des Prozessors gelegt. Bis dahin ist der Status auf dem Datenbus nicht definiert. Danach wird der Z8 wieder aus dem Wartezustand geholt und der Ablauf ist analog zum Schreibzugriff.

Leider ist mein Programm für die kleinen CPLDs schon zu kompliziert, sodass mit die Xilinx-ISE Workbench einen XC108-PC84 vorschlägt, einen Klotz, größer als die eigentliche CPU. Ich werde mal versuchen, ob ich dasselbe auch mit herkömmlichen TTL Bausteinen zusammen setzen kann. Wird zwar bestimmt genauso groß, wie der CPLD, dafür aber preiswerter und ohne großen Aufwand.