Sonntag, 14. August 2011

CP/M 2.2

Es wird langsam :-) Wie man in diesem Screenshot sehen kann,
CP/M 2.2 auf meinem Z80-System
läuft ein rudimentäres CP/M auf meinem Z80. Ich hatte Probleme, geeignete CP/M-Systemdateien zu finden. Auf dieser Seite findet man Quellen zu Z80CCP und P2DOS, welches ein nachprogrammiertes CCP und BDOS ist mit kleinen Erweiterungen. Diese Quellen habe ich leicht angepasst, damit sie mit dem TNIASM assembliert werden können und ein einfaches BIOS mit den Funktionen CONIN, CONOUT, CONST, SETDMA, SELDSK geschrieben.

Mit meinem Windowsprogramm "Programmer" kann ich über den dsPIC auf der Z80-Platine in den RAM und ROM schreiben. So habe ich also CP/M in den RAM an die jeweiligen Adressen geladen. Ein kleines Monitorprogramm, welches auf dem Z80 läuft, gibt mir die Möglichkeit, CP/M auf eine CF-Karte zu schreiben oder CP/M von der Karte in den Speicher zu laden und CP/M zu starten.

CCP nimmt nun Eingaben entgegen, aber das BIOS ist noch nicht weit genug implementiert, um von CF-Karte zu lesen oder schreiben. Ich kann also keine Programme starten, es funktionieren nur die in CCP implementierten Befehle. Ich muss noch ein kleines Dateisystem auf der Karte erstellen, welches CP/M dann als Laufwerk zu sehen bekommt. Dazu muss ich aber erstmal verstehen, wie das alles so funktioniert :-)

Wenn es läuft, werde ich hier im Blog die entsprechenden Assemblerfiles posten, z.B. der IDE-Treiber, die UART-Routinen, die angepassten CP/M-Dateien, usw.

Sonntag, 31. Juli 2011

IDE-Platine läuft

Ich kann es selber kaum glauben, es ist vollbracht! :-) Die IDE-Platine läuft. Ich kann die Laufwerks-ID auslesen und einen Sektor lesen oder schreiben. Hier ein paar Bilder dazu:


Die bestückte/unbestückte Platine
Die IDE-Platine mit CF-Karte
Das ganze System in Aktion

Ich verwende einen CF-IDE-Adapter. Auf diese Weise habe ich einen recht günstigen Massenspeicher, der im Gegensatz zu Festplatten lautlos läuft. Und ich brauche nur 5V, im Gegensatz zu ner SD-Karte, die mit 3,3V betrieben wird oder einer Festplatte, die zusätzlich 12V braucht.

Dienstag, 5. Juli 2011

Ein paar Links

Um mal wieder etwas zu posten (IDE-Platine ist noch nicht fertig), hier ein paar Links:

Der Z80-Assembler, den ich nutze (Win32):
http://www.tni.nl/products/tniasm.html

Ein C-Compiler, den ich in Zukunft nutzen möchte:
http://sdcc.sourceforge.net/

Andere Z80 Projekte im Netz:
http://www.cosam.org/projects/z80/index.html
http://www.nathandumont.com/node/216
http://benryves.com/projects/z80computer
http://z80homebrew.blogspot.com/

Samstag, 28. Mai 2011

Propeller

Beim Surfen bin ich vor einige Zeit auf den Propeller von Parallax gestoßen. Das ist ein ungewöhnlicher Mikrocontroller, mit dem ich wohl die Z80-Grafik realisieren werde.
Er hat folgende Eigenschaften:
  • 32 Bit
  • Acht Kerne
  • 80 MHz Takt
  • 32 KB RAM
  • 32 KB ROM
  • 32 IO-Pins
  • 40-Pin DIP-Package/44-Pin LQFP-Package
  • Hardware-Videogenerator (auch VGA)
Jawohl, das Teil hat acht Kerne, sogenannte COGs, jeder COG hat 2 KB eigenes RAM und 32 KB für alle zusammen. Im ROM ist unter Anderem eine Bitmap-Schriftart abgelegt sowie ein paar Tabellen für sin/cos.
Alle acht COGs laufen parallel mit eigenem Code, der Zugriff auf das Main-RAM wird vom sogenannten Hub geregelt. Dieser lässt reihum die COGs auf das Main-RAM zugreifen.

Es gibt keine Interrupts, und quasi keine Hardware-Peripherie (außer Timer). Das bedeutet, dass jegliche Funktionalität in Software realisiert wird. Für die meisten Anwendungen wie ADC, DAC, SPI, I2C, usw. gibt es Bibliotheken auf der Parallax-Webseite herunterzuladen. Da alles in Software läuft, kann jeder Pin jede Funktion übernehmen. Die fehlenden Interrupts werden dadurch ersetzt, dass jeder COG genau eine Aufgabe erledigt, und zwar durch Polling. So würde man einen COG für UART widmen, einen für SPI usw.

Auf der Paralax-Webseite findet man mehr Information und die Datenblätter.

IDE-Schnittstelle

Ich hatte endlich mal wieder die Muse, etwas an der IDE-Schnittstelle weiterzuarbeiten. Als Vorlage habe ich nun Phil Rustons PRIDE-Interface genommen. Mein erster eigener Entwurf wäre etwas komplexer geworden und hätte bestimmt den einen oder anderen Bug eingebaut, daher gehe ich mit diesem Design auf Nummer sicher ;-)
So sieht das Layout aus:
Mal wieder ein wahres Kunstwerk ;-) Beim Layouten fiel mir wieder auf: Das Wichtigste am Routen ist die Platzierung der Bauteile. Wenn man das geschickt angeht, ist das Routen fast ein Kinderspiel.

Ich muss nochmal gründlich die Schaltung durchgehen und dann werde ich sie fertigen lassen.

Dienstag, 3. Mai 2011

Ein Schritt Richtung CP/M

Ich habe mich entschieden, CP/M auf meinem Z80-Rechner zum Laufen zu bringen. CP/M ist ein altes Betriebssystem (quasi der "Vater" von MS-DOS), welches hauptsächlich auf den guten alten 8-Bit-Systemen zum Einsatz kam. Dazu sind zwei weitere Dinge nötig: Am Beginn des Adressraumes muss RAM sein, und ich benötige einen Massenspeicher. Das erste Problem ist gelöst, mit einer einfachen Schaltungserweiterung lässt sich nun der ROM deaktivieren. Die kleine Platine, die eigentlich nur ein Oder-Gatter und ein Transistor enthält, lässt sich auf den 3er-Pinheader auf die Platine aufstecken, es sind glücklicherweise keine Änderungen auf der Main-Platine nötig:



Massenspeicher ist etwas aufwändiger: Ich hatte vor, SD-Karten als Massenspeicher zu verwenden. Nur irgendwie will meine dazu gebastelte Platine nicht funktionieren, die SD-Karte antwortet einfach nicht. Daher habe ich das jetzt (verzweifelt) aufgegeben und möchte mir nun eine IDE-Schnittstelle basteln. Diese ist erstaunlich simpel! Der Charme der IDE-Schnittstelle besteht nicht nur darin, Festplatten an mein System anzubinden, sondern auch darin, CompactFlash-Karten nutzen zu können. Über einen einfachen Adapter lässt sich CF an IDE anschließen! Und es gibt wiederum einen CF-zu-SD-Karten-Adapter, so dass mir theoretisch auch SD-Karten zur Verfügung stünden.

Es gibt dabei zwei Schwierigkeiten zu überwinden: Der ATA/IDE-Datenbus ist 16-Bit breit (im Gegensatz zum 8-Bit Z80) und Daten werden von der IDE-Schnittstelle bei steigender Flanke der /RD bzw. /WR-Signale "gesampelt", was zu Timingproblemen führt.

Glücklicherweise gibt es ein paar Projekte im Netz, von denen ich mir was abgucken kann. Jetzt muss ich mich nur noch entscheiden, ob ich die Platine auf Lochraster aufbaue oder wieder fertigen lasse. Das Problem mit den Lochraster-Platinen ist, dass ich einfach keine wirklich gute Methode habe, solche Platinen selber zu bauen. Und mit Kupferlackdraht gibt es auch häufig Probleme wie schlechte Lötstellen, angeschmorter Lack usw.

Donnerstag, 24. Februar 2011

Interrupts

Interrupts sind ne feine Sache. Wenn ein Computer Peripheriegeräte wie Tastatur, Maus, UART u.Ä. verwendet, müsste er theoretisch zyklisch diese Geräte abfragen, ob sie neue Daten zur Verfügung haben. Wenn man also schnell auf einen Tastendruck reagieren will, müsste man entsprechend häufig die Tastatur abfragen, um die Reaktionszeit klein zu halten. Dieses ständige Abfragen nennt man Polling. Die Zeit, die für's Polling draufgeht, steht dann nicht mehr für das eigentlich laufende Programm zur Verfügung. Deswegen nimmt man (meistens) ein anderes Prinzip, nämlich Interrupts. Der Z80 hat einen Interrupt-Pin (eigentlich zwei, aber ich benutze nur einen). Der liegt im Normalfall auf High-Pegel. Wird nun eine Taste gedrückt, so wird von der Tastatur der High-Pegel auf low gezogen. Der Prozessor merkt dadurch, dass etwas passiert ist, um das er sich kümmern sollte. Dann kann er die Peripherie "auslesen", um festzustellen, was passiert ist. Er liest also die Tastatur nur dann aus, wenn wirklich eine Taste gedrückt wurde.
Der Z80 hat drei Interrupt-Modi. Modus 0 wurde aus Kompatibilitätsgründen zum Intel 8080 beibehalten. Löst das Gerät einen Interrupt aus, so bekommt es die Möglichkeit, eine Instruktion auf den Datenbus zu legen, die der Prozessor dann ausführt. Dies ist meistens der RST-Befehl, mit dem man ich glaube acht verschiedene (aber a priori festgelegte) Stellen in der Speicherseite 0 anspringen kann.
Im Modus 1 springt der Prozessor im Interruptfall pauschal zu 0x38. Und Modus 2 ist der flexibelste Modus: Der Programmierer legt im Speicher eine Tabelle mit Interruptvektoren an. In das Register I lädt er die Nummer der Speicherseite, in der sich die Tabelle befindet. Beim Interrupt legt nun das Gerät eine Nummer auf dem Datenbus, die dem Eintrag in der Tabelle entspricht. Der Z80 liest nun diesen Interruptvektor ein und springt an diese Adresse. Dort befindet sich dann die entsprechende Routine, die bspw. die Tastatur ausliest. Auf diese Weise lassen sich 128 verschiedene Interrupt-Routinen anspringen.
Soviel zur Theorie. Ich wollte ja eigentlich den Modus 2 benutzen, doch ich habe nen Layoutfehler drauf. Das wird so nicht klappen, weswegen ich erstmal mit Modus 1 Vorlieb nehme. Nur ein Interrupt ist besser als gar keiner :-) Das Problem ist folgendes: Der Interrupt wird ausgelöst. Der Prozessor weiß jedoch erstmal gar nicht, wer denn die Interruptleitung runtergezogen hat, er sieht nur, dass sie low ist. Deswegen löst er einen IORequest parallel zu einem M1 Zyklus aus. Dies signalisiert dem Interrupt-Gerät, nun die Nummer des Interruptvektors auf den Datenbus zu legen. Ich habe nicht bedacht, dass er ja gar keine Geräteadresse auf den Datenbus legt, weswegen kein entsprechendes Chipselect ausgelöst wird.
Ich hätte sogar alle nötigen Logikgatter auf der IOBoard-Platine noch frei um das zu fixen, jedoch wäre das mit einem SMD-Beinchenbiegen und rumpfuschen verbunden, das ist mir erstmal zu heikel. Hab kein Bock, mir wieder ein Pad abzureissen wie bei der Main-Platine. Interrupt-Modus 1 reicht mir erstmal :-)

Dienstag, 22. Februar 2011

Assembler-Spaß

Wo ich ja nun endlich ein funktionierendes System habe, kann ich mich mal etwas dem Z80-Assembler widmen. Das ist schon eine kleine Umstellung, wenn man sonst nur C programmiert und auch "in C" denkt. Die ersten Routinen, die ich programmiert habe, sind natürlich String über UART senden und String vom UART empfangen. Da mein Z80-Computer ein sehr freundlicher ist, wird man auch gleich angenehm begrüßt :-) Das sieht dann im Terminal so aus:

Ist er nicht nett? Ok- zugegeben nicht sehr spektakulär ;-) Aber es läuft auf meiner Hardware und ich habe jedes Byte selbst programmiert!

Und weil's so praktisch ist, hier ein Screenshot meines Programmers, mit dem ich den EEProm (und auch den RAM) lesen und schreiben kann:


Lädt man ein assembliertes Binary, so gibt der Programmer erstmal den Inhalt als Hex aus. Im Offset-Eingabefeld kann man das Startoffset eingeben, wo die Bytes hingeschrieben werden sollen. Mit "write" werden die Bytes an den dsPIC (über UART) auf der Mainplatine geschickt. Der schreibt dann die Bytes an die gewünschte Stelle in den EEProm (oder RAM).
Durch "release" entlässt der dsPIC den Z80 wieder aus dem Reset und der neue Code wird vom Z80 direkt ausgeführt.

Montag, 21. Februar 2011

Es funzt!!

Mann mann, das war frustrierend! Manchmal hat die Schaltung funktioniert, sprich der Z80 hat über den UART mit mir gesprochen. Dann habe ich kleine Änderungen an der Z80-Software gemacht, nämlich Code in Subroutinen gepackt, die mit dem call-Befehl aufgerufen werden. Dann hat es sporadisch funktioniert, aber nach einem Reset wieder nicht. Dann habe ich die alte, funktionierende Version aufgespielt, die dann aber plötzlich nicht mehr funktionierte. Sehr seltsam, genau wie bei meiner alten, selbstverdrahteten Platine! Also habe ich heute eine kleine Display-Platine gebastelt, um zu schauen, ob diese denn ansprechbar ist. Hier trat das gleiche Phänomen auf. Das Problem musste also auf der Main-Platine liegen.
Mir ist dann aufgefallen, das die Masse der Displayplatine unsauber war. Und siehe da: Eine kalte Lötstelle an einer Steckbuchse auf dem Mainboard. Doch das hat das Problem immer noch nicht beseitigt. Da nur Probleme bei Aufrufen von Subroutinen auftraten, bin ich dann endlich mal auf die Idee gekommen, den RAM-Baustein zu testen. Bei einem Lese-/Schreibtest hat sich dann rausgestellt, dass der manchmal Daten nicht richtig speichert. Das erklärt auch, warum der Z80 Probleme mit den Subroutinen hatte. Denn beim Subroutinen-call wird der PC (Program Counter) auf den Stack kopiert, der sich im RAM befindet. Und wenn der RAM den Wert nicht richtig speichert, wird beim return der PC nicht korrekt zurückgesetzt und der Z80 springt sonstwo hin.
Die UART-Platine funktioniert nun auch wie gewünscht.

Hier ein Foto der Display-Platine:

Donnerstag, 17. Februar 2011

Main-Platine bestückt und erste Tests

Ich habe gerade den dsPIC zum Laufen gebracht. Ich hatte ein paar Fehler in die µC-Firmware eingebaut, damit ich zwei Stunden lang Debuggen üben kann ;-) Nun lässt sich aber endlich per dsPIC der RAM und das EEPROM lesen und schreiben. Desweiteren kann er einen Takt mit Hilfe des integrierten Timers erzeugen, mit dem ich den Z80 betreiben kann, für Single-Step z.B. Das Testprogramm aus einem meiner ersten Posts habe ich dann in den EEPROM programmiert und den Z80 erfolgreich damit laufen lassen. Das scheint also zu klappen. Hoffentlich finde ich am WE Zeit, das IO-Board zu bestücken!

Hier sieht man das bestückte Mainboard von unten:
Blöderweise hatte ich das NAND (der kleine Käfer oben in der Mitte) falsch rum draufgelötet. Also musste ich ihn wieder runterlöten. Dabei habe ich ein Pad abgerissen. Hier sieht man die Korrektur in Nahaufnahme und etwas Fädeldraht, mit dem ich das betroffene Beinchen verbunden habe:
Der Fädeldraht passt praktischer Weise genau durch die durchkontaktierte Via.

So sieht die Oberseite der Platine ohne DIL-ICs aus:
Der rote PicKit3 ist ein Gerät, um (ds-)PICs zu Programmieren und zu Debuggen. Sehr zu empfehlen, vor allem, weil es preislich dem Hobbybastler entgegen kommt.

Und so sieht der Aufbau derzeit aus:

Dienstag, 15. Februar 2011

Platinen sind angekommen!

Endlich sind sie da, die beiden Platinen! Ich habe begonnen, die ersten Komponenten zu bestücken. So sieht sie aus:

Ganz hinten sitzt der Max232 für die serielle Schnittstelle RS232, der größte IC ist der dsPIC30F4012, und die beiden kleinen rechten IC's sind Schieberegister, in die der dsPIC Adressbits reinschiebt, um den Speicher zu adressieren. Morgen geht's weiter!!

Sonntag, 6. Februar 2011

CPLD-Programmer

Heute habe ich es endlich getan: Der JTAG-Programmer für Xilinx CPLDs ist bestückt! Die Platine dazu und zu einem Testboard für den XC9536 habe ich hier schon seit einem halben Jahr rumliegen. Mir fehlte nur bisher die Muse dazu, das endlich mal aufzubauen und zu testen.
Links im Bild ist der JTAG-Programmer. Und ja, das ist ein 25poliger Sub-D-Stecker für die parallele Schnittstelle :-) Die beiden ICs sind Bustreiber 74HC125. Die rechte Platine ist das Testboard für den XC9536. Die fertigen Layouts findet man schnell im Netz, einfach nach "xc9536 jtag programmer" suchen.
Die Software zur Programmierung so eines CPLDs ist von der Xilinx-Seite frei herunterladbar. Sie nennt sich ISE Webpack und hat mal eben flotte 3 GB. Sie ist nicht ganz so einfach zu bedienen, aber ich habe es geschafft, ein Test-Programm auf den CPLD zu brennen. Da ich mich irgendwann eh mal mit FPGAs beschäftigen möchte, ist das hier schon eine ganz gute Einarbeitung. Mit dem Webpack lassen sich nämlich auch die Xilinx-FPGAs programmieren.

Während die Z80-Platinen in der Fertigung sind, werde ich mir dann erstmal CPLD-Programmierung mit VHDL/Verilog zu gemüte führen. Irgendwann möchte ich nämlich eine kleine "Grafikkarte" für den Z80 basteln. Und dafür könnte sich so ein CPLD ganz gut eignen glaube ich.

Samstag, 5. Februar 2011

Layout fertig

Es ist geschafft, das Layout steht. Ich habe nicht alles auf ein Board gepackt, sondern das auf zwei verteilt. Das Main-Board mit CPU, Speicher und dsPIC, sowie das IO-Board mit dem 74HC138 für das ChipSelect und dem 16c550.
Jetzt checke ich nochmal alles durch und werde dann nächste Woche die Boards in die Fertigung geben. Na hoffentlich ist kein Fehler drauf, sonst wäre das ein teurer Spaß...

So sieht das Main-Board jetzt aus:
Z80 Main-Board
Wie man sieht, ein zweilagiges Board mit SMD und DIL-Mischbestückung. Bei den 74er Bausteinen bin ich auf SMD gewechselt, um die Boardfläche klein zu halten. Den Z80 und den Speicher gibt's leider nicht als SMD, jedenfalls nicht bei Reichelt.

Sonntag, 30. Januar 2011

Neuer Aufbau

Ich kann einen Teilerfolg vermelden. Die UART-Platine hat (mehr oder weniger) funktioniert. Ich habe ein Programm geschrieben, welches über die serielle Schnittstelle empfangene Zeichen als Echo zurücksendet. Hat wunderbar funktioniert. Die ersten paar Minuten. Doch dann sind seltsame Probleme aufgetreten, und der UART hat keinen Mucks mehr von sich gegeben. Beim Messen mit dem Oszilloskop habe ich dann blöderweise nen Kurzschluss auf dem UART-Board verursacht, das hat die Isolation der 5V-Leitung beschädigt und evtl. noch andere Leitungen. Da ich mit dem Aufbau sowieso unzufrieden bin, (u.A. weil sich schlecht messen lässt), werde ich mir eine Platine fertigen lassen. Dann bin ich auch meine Drahtigel los. Mal sehen, ob ich das Layout dafür in der kommenden Woche fertig bekomme.

Sonntag, 23. Januar 2011

IO Select

Zur Erzeugung der Chip Selects der Peripherie muss ebenfalls ein Adressdecoder her. Dafür bietet sich der 74HC138 an, ein 3-8 Multiplexer mit invertierenden Ausgängen. Auf sehr einfache Weise lassen sich so Chip Selects für 8 verschiedene Geräte erzeugen, die jeweils 32 Byte Adressraum zur Verfügung haben. Den UART lege ich einfachheitshalber auf IO-Adresse 0x00.

IO-Decoder
Die Verdrahtung ist einfach:
Der 16C550 lässt sich direkt an den Bus anschließen. Die meisten Bussignale liegen als low- und high-active vor. Die Interruptleitung ist high-active.

Mittwoch, 19. Januar 2011

Serial Board

Als nächstes kommt die serielle Schnittstellenkarte dran. Ich habe einen Z80-SIO und einen 16C550. Der Z80-SIO ist jener Baustein, der früher typischerweise in Verbindung mit einer Z80-CPU für RS232 benutzt wurde. Der 16C550 ist ebenfalls schon älter, wird aber heute noch auf seriellen Erweiterungskarten für den PC verbaut.
Ich kenne beide Chips nicht. Die Datenblätter sind beide ziemlich komplex, ich bin noch unendschieden, welchen der beiden ich verwenden werde.
Der SIO wurde ja zur Verwendung mit dem Z80 designt, aber es gibt nicht allzu viel Infos dazu im Netz. Zum 16C550 findet man deutlich mehr, und er ist nicht ganz so komplex.

Erster Erfolg!

Endlich hab ich den Z80 dazu bewegt, das zu tun was ich sage!! :-) Das Testprogramm ist erfolgreich gelaufen.
Die bidirektionalen Bustreiber (74HC245) der RAM-Karte und der CPU-Karte haben manchmal gegeneinander getrieben. Das hätte ich gar nicht richtig gemerkt, da das nur im Memory-Refresh-Zyklus geschehen ist. Das Symptom war dabei, dass sich der dsPIC resettet hat. Gut, dass die Bustreiber kurzschlussfest zu sein scheinen, jedenfalls ist keiner kaputt gegangen... Ach ja, Empfehlung: Datenblätter ganz genau lesen, das erspart viel Frustration und abkotzen!!

Ich poste hier schon mal die Schematics der beiden Boards:
RAM-Board

CPU-Board
Und in Natura sieht das jetzt so aus:
CPU-Board Rückseite

RAM-Board


Gesamter Aufbau
Mit diesem Aufbau kann man bisher noch nicht so viel anfangen:
Ein dsPIC ist über die serielle Schnittstelle mit meinem PC verbunden. Über Terminal kann ich nun dem PIC sagen, die Bustreiber der RAM-Karte hochohmig zu schalten. So kann dann das EEPROM und den RAM gelesen und beschrieben werden, ohne mit der CPU in Konflikt zu geraten.
Ansonsten "lebt" die CPU in ihrem eigenen Mikrokosmos und hat keinen Kontakt zu Aussenwelt, was das Ganze noch etwas nutzlos erscheinen lässt ;-)
Das wird sich aber bald ändern, denn als nächstes ist eine serielle Karte geplant, mit der die Kommunikation zwischen dem Z80 und einem PC möglich wird.

Dienstag, 18. Januar 2011

Erstes Testprogramm

Wenn die beiden Boards fertig sind und (hoffentlich!) auch noch funzen, muss der Z80 ja auch was zum Ausführen bekommen. Ich habe leider nur etwas Ahnung von Assembler, da muss ich mich noch reinfuchsen. Aber als Erstes werde ich wohl folgendes Programm in den ROM schreiben:

(1) LD A,37     
(2) LD (9509), A
(3) HALT        

Zeile (1) lädt die Zahl 37 in den Akku. Zeile (2) schreibt den Akkuinhalt an Speicheradresse 9509. Und Zeile (3) hält den Prozessor an.

Das als Opcodes sieht dann folgendermaßen aus:

Addr      Codes   
0x00      3E 25   
0x02      32 25 25
0x05      76      

Wenn alles geklappt hat, sollte dann an Position 9509 des RAMs die Zahl 37 stehen.

Resetschaltung

Die Resetschaltung der CPU ist sehr wichtig, wie ich feststellen musste. Denn das Resetsignal muss ein paar CPU-Takte lang sein, damit der Reset wirklich vollständig durchgeführt wird. Folgende Schaltung verwende ich für den CPU-Reset:
Der Schalter zieht bei Druck !RESET sofort auf Masse. Lässt man den Schalter los, so lädt sich der Kondensator "langsam" wieder auf 5V auf. Der Schmitt-Trigger sorgt mit seiner Hysterese für ein ständig gültiges TTL-Signal. Eine Tastenentprellung bekommt man auch gleich mitgeliefert.

Montag, 17. Januar 2011

Memory Management

Beim Z80 sind die Adressräume für Speicher und externer Peripherie getrennt. Dies vereinfacht das Memory Management etwas, da beim Speicher nur noch entschieden werden muss, ob EEPROM oder RAM angesprochen werden soll.
Nun hat das EEPROM 8192 Byte Speicherkapazität und soll an den Anfang des Adressraums "gemapt" werden. Adressen von 0..8191 sprechen also das EEPROM an, 8192-65535 adressieren den RAM.
Mit folgender Schaltung wird das Chip Select generiert:

Simple Z80-MMU
Auf Pin 2-3 wird ein Jumper gesteckt. Das Signal !MREQ ist low active und signalisiert einen "Memory Request". Sind die Adressleitungen A13, A14, A15 und !MREQ low, so wird !ROM_CS runter gezogen, welches an !CS des EEPROMS angeschlossen ist. Ist eine der Adressleitungen high, so wird !RAM_CS runter gezogen und so der RAM selektiert.

Das EEPROM:
Und der RAM:

A16 ist auf GND gelegt. Später werde ich evtl. dies um eine Banken-Logik erweitern, um mehr Speicher ansprechen zu können. Dazu muss ich mir aber erst noch ein paar Gedanken machen, wie das funktionieren könnte.