Des Doktors Bastelstube

Hallöchen,
hiermit mache ich hier meine Bastelstube für interessierte Leute auf (blue).
Ich habe mich schon immer für Low-Level Programmierung und auch praktische Implementierung interessiert, aber jetzt habe ich bedingt durch Studium und persönliche Interessen genug Wissen gesammelt, um die Ideen auch zu realisieren.

Generell möchte ich mit Mikroprozessoren/Mikrocontrollern rumspielen und kleine oder größere Computersysteme aufbauen. Aber auch Behilfsprogramme schreiben z.B. zur Simulation, um meine Kenntnisse in OOP Programmierung aufzufrischen (zu viel C in letzter Zeit geschrieben :P). Besonders eine Simulation des U830C (oder eine FPGA Implementation) peile ich an. Außerdem endlich mal richtig löten lernen.

Als klassisches erste Projekt baue ich ein Z80 System, aber wenn man schonmal leichten Zugang zu Osttechnik hat, nutze ich natürlich einen originalen UB880D, den in der DDR produzierten und voll zum Z80 kompatiblen Klon. Außer ein paar kleinere Dinge wie Flags fast gleich. Dazu natürlich die passenden aus der DDR stammenden ICs für Seriellen Output, Parallelen Output und Counter Circuit. Für andere Teile des Systems werde ich durchaus neuere Teile benutzen. Ebay nach alten AND Gates oder etc. zu durchsuchen will ich jetzt nicht wirklich. Und alter SRAM oder DRAM hmm ma schauen. Aber schöne Gehäuse haben sie ja.

Timeline für den UB880D:

Angepeilte Features:

Wie man sieht, ich habe mir viel vorgenommen. Wie fern ich das alles realisieren werde, keine Ahnung, mal sehen wie ich meine Lebenszeit investiere. Oder ob ich weiter shitposte . Die FuckUp Tools schreiben sich nicht von selber. Würde aber auf jedenfall mal gerne auf einen alten Z80 "moderne" Krypto ausführen und messen wie lange das dauert, vor allem die nicht-optimierte Krypto vs. die optimierten Algorithmen. Wenn man schonmal aus diesem Bereich kommt

Generell, werde ich vorerst Sachen auf ein Breadboard stecken, bevor es auf die Lochrasterplatte geht. Vorher muss ich immerhin alles etwas ausprobieren.

Werde hier in und wieder Updates posten, wer interessiert ist kann sie ja lesen. Inklusive Bilder/Videos/Code. Damit auch jeder meine miserablen Strukturierungsfähigkeiten betrachten kann.
Oder Fragen stellen.

Andere Projekte die in der Pipeline sind für später(e Jahre):

Da ich zeitnah erstmal in Amerika bin, habe ich zurzeit nicht viel Zeit für große Aufbauten. Trotzdem wollte ich ein paar Grundbausteine testen.

Dazu habe ich mir erstmal 3 UB880D bestellt (damit für Ersatz gesorgt ist), sowie die CTC,SIO,PIO und die DMA. Außerdem habe ich zurzeit ein mittel großes Breadboard samt Steckerverbindungen oder flexiblen Steckerkabeln zur Verfügung. Ich habe mich für den Testaufbau für die Kabel entschieden. Sieht zwar bescheiden und unübersichtlich aus aber ist schneller umzubauen und flexibler.
Da jeder Ausgang des UB880D nur eine TTL Last treiben kann, habe ich für erste Tests nur eine LED mit 1k Resistor geschaltet, um den Load relativ gering zu halten.
Um mir nicht um jeden mA Gedanken zu machen, werde ich die Ausgänge der CPU buffern. Die Buffer der 74er Serie (SN74LS244) haben genug Power um dann spätere Logik zu treiben, ohne mir Gedanken über irgendetwas zu machen.

Der erste Aufbau ist ein Funktionscheck. Dazu fungiert der UB880D als übertriebener Zähler. Die Datenleitungen werden auf GND gepullt, der Opcode 0x00 stellt ein NOP dar. Die Addressleitungen werden gebuffert und an LEDs geschaltet. Nach jeder Ausführung (4 Takte pro NOP) wird eine neue inkrementiere Adresse angelegt. Das kann man dann an den LEDs ablesen. Als Stromversorgung und einfache CLK dient ein Arduino. Der RESET Eingang (Aktiv low) kann per Schalter getoggelt werden. Er sollte mindestens 4 Takte aktiv sein, sonst droht undefined behavior.

Schaltplan (basiert auf: http://www.z80.info/z80test0.htm):

Korrektur: Natürlich 470 Ohm nicht 470 kOhm

Und so sieht das ganze in der Realität aus:

Aber ohne CLK und Versorgungsleitungen. Natürlich funktioniert das ganze auch.

Zitat von Xaar

ANSI-Symbole? Schon auf die USA vorbereiten?

Fritzing kann nur ANSI anscheinend Bin auf dem Mac unterwegs und Fritzing habe ich hier schon seit einiger Zeit drauf. Will aber ne Alternative, weil das Zeichnen damit nicht so intuitiv ist. Dann auch mit IEC Symbolen

Kleines Update:
Heute habe ich wahrscheinlich die letzte große Bestellung für dieses Jahr gemacht...

Darunter 2 mal ein 32k SRAM mit 8-Bit Wortbreite, um somit die 64K RAM zu füllen. Sowie zwei EEPROMS, eine als Backup. Das Gute bei der neueren Variante der EEPROMs ist, dass der Write-Pulse nichtmehr auf 1000 ns begrenzt ist, sondern das Maximum freisteht. Ich kann also entspannt ein kleines Arduino Programm schreiben, welches mir die ROM beschreibt.
Weiterhin sind noch ein Quarzoszillator 2MHz dabei und ein paar Low-Power LEDs, die nur 2mA Strom benötigen. Sehr gut, um meinen Buffer nicht zu überlasten, denn der kann nur 28mA maximal.
Ich werde versuchen noch vorm Wegfliegen ein kleines Testprogramm auf die EEPROM zu schreiben und es tatsächlich auf den UB880D auszuführen.
Auch habe ich heute noch zwei 68x10 geschossen. Damit bin ich jetzt mit jeglicher Art von Prozessoren von 4-Bit bis 32-Bit eingedeckt.

Wenn ich dann mal was angeschlossen habe poste ich mal wieder was.

Zitat von Xaar

"jegliche Art"? Auch i4004, i4040 und i8008?

Jede Bit Architektur einen
Ich geb kein kleines Vermögen für 4004 aus... Dann musste ein russischer AMD 2901 herhalten. Wobei ist ja nur eine glorifizierte ALU

Außerdem stört mich am 8008 und 8080 die verschiedenen Versorgungsspannungen :p

Also zu einem 4004 sag ich nicht nein

Ich bin froh bis jetzt zu Prozessoren gegriffen zu haben, die nur 5V Volt brauchen und nur einen CLK Input ohne Phi1,Phi2. Natürlich ist das nicht so kompliziert, aber ich habe gerade nicht so viele ICs hier rumfliegen, um das schnell zu realisieren. Und nur 3,3V oder 5V Supply. Wenn ich wieder da bin und mehr Zeit habe, werde ich mich damit aber auch beschäftigen

Habe mir auch mal wieder Gedanken zum U830C gemacht und eine gute Lösung gefunden, das Verhalten des Chips festzustellen. Ein Arduino Mega hat genug I/O Pins, um sie an alle Pins der CPU anzuschließen. Damit könnte ich alle Parts simulieren und genau sehen, wie der Prozessor funktioniert. Das werde ich im Dezember in Angriff nehmen.

In etwa genau einem Monat bin ich aus Amerika zurück und werde wieder rumbasteln.

In der Zwischenzeit wurde ich von meinen Kurs aufgezwungen eine "WebApp" zu schreiben (was hat das eigentlich mit Systemprogramming zu tun, naja hinterfragen wir den Syllabus mal nicht). Da ich zu unkreativ für ein Spiel bin, und keine ToDo Liste oder Memeschrott implementieren will (FuckUp Utilities 9000?) habe ich mich dazu entschieden eine kleine VM zu schreiben für einen kleinen imaginären Prozessor. Wollte euch mal als Feedback rekrutieren

Zurzeit befindet sich Stack8 noch in der "Alpha" Phase. Aber am 4. Dezember ist Deadline und deswegen wird das recht schnell gehen. Die grundlegende VM und Assembler ist implementiert, dazu ein kleiner 4:3 Screen (Wortwörtlich 40 mal 30 Pixel) und ein Speicher und Stack Debugger. Das ganze heißt Stack8, weil der User nur 8KB Speicher bekommt, zudem benutzt die CPU die Stackarchitektur (Interner Stack statt Register) mit Tiefe 8 und besitzt nur 8 Instruktionen. Die Datenbreite ist 8-Bit, obviously. Meiner Meinung nach sollte das ganze auch Turingkomplett sein, heißt mit den Instruktionen kann man alles berechnen was man will.

Das Instructionset ist noch nicht ausgereift, will aber morgen den finalen Entwurf machen, nachdem ich ein bisschen rumgeforscht habe.
Zurzeit ist implementiert:

push -> pusht Inhalt einer absoluten Adresse auf den Stack
pop -> popt den obersten Eintrag auf den Stack in eine absolute Adresse 
nand -> Nand auf den obersten beiden Einträgen
add -> Add ohne Carry auf den obersten beiden Einträgen
lfsh -> Left Shift auf den obersten Einträgen (1. Eintrag = Shiftamount, 2. Eintrag = to be shifted) -> Wird rausgeschmissen, da synthesierbar
jmple -> Jump if less or equal zur absoluten Adresse (Signed Comparison)
pushi -> pusht Inhalt des Pointers in der absoluten Adresse auf den Stack (TODO)
popi -> pusht den obersten Eintrag auf den Stack in die Adresse, auf die der Pointer zeigt, der an der absoluten Adresse liegt (TODO)
---
db -> pseudoinstruction, sagt dem Assembler, dass hier Daten liegen
[0-9a-zA-Z]+: -> Label
#[0-9]+ -> Absolute Adresse
----
Adresse 6991 - 8191: Screenmemory

Der Assembler ist caseinsentiv und parst das ganze sehr freizügig. Viele Leerzeichen oder überflüssige Argumente machen dem Assembler kein Problem. Bei Problemen wird aber zurzeit nur in die Webkonsole geloggt. Safari und Edge wollen noch nicht richtig, aber Firefox und Chrome machen 0 Probleme.

Bugs sind mir ein paar bekannt, z.B. wenn ein Label ganz am Anfang steht, kommt der Assembler nicht drauf klar stattdessen #0 schreiben. Auch kann mit "db" zurzeit nur 2 Einträge gleichzeitig definiert werden. "db 5,6" schreibt 5 und 6 in zwei aufeinanderfolgende Speicherzellen. "db 5,6,7" ignoriert die 7.

Ein Beispielprogramm:

push var1
push var2
add
pop var1
push var1
pop #7000
jmple #0
var1:
db 0
var2:
db 5

Das Programm addiert immer weiter 5 auf var1 (also 5, 10, 15...) schreibt das ganze dann in Adresse 7000, was dazu führt dass ein Pixel beschrieben wird (RRRGGGBB Format).

Baustelle ist zurzeit das Design. Bootstrap will nicht so wie ich will, und mobil sieht das ganze leider sehr bescheiden aus. Wenn sich einer Webdesign auskennt, ich nehme Tipps gerne an. Bezüglich Webdesign benutze ich nur Bootstrap internals, also kein externes Style CSS. Die Skripte sind zurzeit in die Webseite integriert, werden aber später ausgelagert. Wahrscheinlich werde ich auch noch den Programm Counter in den Memory Space Mappen, um vielleicht das Springe dynamischer zu machen.

FAQ:
Warum?
->Wollte schon immer mein eigenes Brainfuck

Die Testseite:
http://185.177.21.162/style.html

Wer sich traut damit mal für 2 Minuten rumzuspielen oder wer mir helfen will, dass Webdesign auch auf kleinen Bildschirmen zum laufen zu kriegen, kann ja hier mal seinen Senf reinschreiben.

Zitat von DosAmp

SNIP

Imho ist der beste Weg dafür, sich irgendwo Platz zu reservieren um dann temporär Werte dahin auszulagern. Genau wie bei 32-Bit x86, wo nicht alles in EAX,EBX,ECX und EDX passt.

Wenn ich heute pushi und popi implementiere kann man das ganze auch kompakter schreiben, indem man sich eine schöne Loop baut, die den Pointer zum Screen inkrementiert. Man muss nur das Carry beachten, bzw. selber berechnen.

Den LeftShift wollte ich vielleicht rauswerfen, um ihn stattdessen durch ein jmple (unsigned) zu ersetzen. Bin aber noch am überlegen, ob ich das mache oder nicht. Vielleicht kann man mit Tricks signed comparison mit einer unsigned operation machen. Bin da für Vorschläge offen. Man könnte natürlich Add rauswerfen, da man es per NAND synthesieren kann, aber so böse bin dann auch nicht. Ein bisschen Komfort muss sein.

Als Guide, wie man aus Nand und Add alles zusammenbauen kann übrigens:
http://bisqwit.iki.fi/story/howto/bitmath/
https://en.wikipedia.org/wiki/NAND_logic

Ich kann man mich ja mal an deinem Programm versuchen, ob ich es hinkriege. Wäre ein geiles Beispielprogramm. Denke mit ein bisschen reservierten Speicher kriegt man das hin. Sonst notfalls die Stacktiefe erhöhen

Zitat von Chrisse

SNIP

Ja die Regex hab ich gestern Abend hier schnell reingehauen, hab die nicht überprüft, aber kann das editieren.

Der Assembler sollte sich über nicht vorhandene Labels beschweren, aber das wird in die Konsole geloggt und noch nicht auf der Webseite angezeigt. Außerdem sagt er dir noch nicht, welches Label er nicht findet. Aber das steht auf der TODO Liste.
Der zweite Vorschlag klingt auch gut, sicherlich realisierbar, da ich die Instruktion ja sowieso dekodiere.

Okay ich habe heute wieder rumgebastelt und das Update sollte die Qualität des Codens ziemlich verbessern.

Neu:
Zeilennummern:
Damit das ganze ein bisschen schöner aussieht

Assemblerwarnungen:
Wenn ihr Blödsinn macht, sagt euch der Assembler jetzt auf der Webseite, was ihm nicht passt. Zurzeit per alert(blabla).

Label Offsets:
Ihr deklariert beispielsweise "var: db 0,5" aber wie kommt man jetzt an die 5? Man kann jetzt statische Offsets deklarieren z.B. "push var+1", das heißt man geht von der Adresse von var (im Beispiel zeigt sie auf 0) zur nächsten. Ohne Limitierung.
Bald wird man auch mehr als 2 Einträge deklarieren können.

Neue Instructions:
Neu hinzugekommen:

pushi -> pusht Inhalt des Pointers in der absoluten Adresse auf den Stack
popi ->pusht den obersten Eintrag auf den Stack in die Adresse, auf die der Pointer zeigt, der an der absoluten Adresse liegt
---
Pseudoinstruktionen:
[0-9a-zA-Z]+(\+[0-9]+)? : Label (+ Offset in Dezimal)
dp : Sagt dem Assembler hier soll ein einzelner(!) Pointer abgelegt werden. Zwei Bytepositionen werden beschrieben. Pointersize = 13 Bit

Bugfixes:
Ein Label kann jetzt auch am Start stehen, dass macht keine Probleme mehr

Allgemeine Info:
Das Instruktionsformat ist wie folgt:
Opcode 3 Bit | 13 Bit Absolute Adresse/ignoriert
Alle Instruktionen sind 2 Byte groß. 8KB können mit 13 Bit adressiert werden. Daher sind DB Instruktionen zurzeit auch nur auf 2 Einträge beschränkt.

Wieder ein kleines Beispielprogramm:

start:
push tmp
push toAdd
add
pop tmp
push tmp
popi screen
push toAdd+1
push screen+1
add
pop screen+1
jmple start
tmp:
db 0
toAdd:
db 5,1
screen:
dp 6991

Was macht das Programm? In einer Endlosschleife wird ein Wert immer um 5 inkrementiert, dann wird das ganze über einen indirekten pop auf den Screen geschrieben. Danach hole ich mir die unteren 8 Bit der Screenadresse und inkrementiere sie um 1. Somit wird im nächsten Durchlauf ein anderes Pixel beschrieben. Naja, bis die unteren 8 Bit überlaufen. Ein Add+Carry muss man sich selber bauen (siehe meine Links weiter oben), was aber einfach ist. Quasi eine Krüppelversion von DosAmps Programm. Aber wir kommen der Sache schon näher . Die Lookup Table Version sollte sich jetzt mit ein paar Tricks (Add+Carry) gut implementieren lassen. Ich will aber das richtige Regenbogenprogramm zum Laufen kriegen .

Morgen setze ich mich weiter ran, vielleicht implementiere ich den Debugging Vorschlag von Chrisse. Wahrscheinlich setze ich mich aber morgen erstmal an die Share Funktion, damit man Programme speichern kann. Würde das eigentlich nicht machen, muss aber laut Vorgabe eine Datenbank benutzen .

Ich lade wieder alle ein das Ding mal für 5 Minuten auszutesten . Freue mich über jedes Programm .

http://185.177.21.162/style.html <-- Hier geht der Spaß los

Firefox und Chrome approved.

Zusammengebaute Instruktionen - Bibliothek
Hier ist eine kleine Liste von Instruktionen, die ich schon synthetisiert habe. Zum Copy-Pasten, damit es bei euch ein bisschen schneller geht. Da der LeftShift wahrscheinlich morgen rausgekickt wird und um eine unsigned jmple Variante ersetzt wird, habe ich ihn auch schon in die Liste aufgenommen. Die Operationen enthalten Beispielzahlen

NOT:


push x
push x
nand
x:
db 0
----
AND:


push x
push y
nand
push x
push y
nand
nand
x:
db 5
y:
db 7
----
OR:


push x
push x
nand
push y
push y
nand
nand
x:
db 5
y:
db 7
----
NOR:


push x
push x
nand
push y
push y
nand
nand
pop z
push z
push z
nand
x:
db 5
y:
db 7
z:
db 0
----
XOR:


push x
push y
nand
pop z
push x
push z
nand
push y
push z
nand
nand
x:
db 5
y:
db 7
z:
db 0
----
XNOR:


push x
push x
nand
push y
push y
nand
nand
push x
push y
nand
nand
x:
db 5
y:
db 7
----
NEG/2er Kompliment:


push x
push x
nand
push one
add
x:
db 5
one:
db 1
----
SUB:


push y
push y
nand
push one
add
push x
add
x:
db 7
y:
db 5
one:
db 1
----
TEST SIGN:


push toTest
push signMask
nand
push toTest
push signMask
nand
nand
push signMask
add
push zero
jmple isNegative
push itIsPositive //code is executed when positive
isNegative:
push itIsNegative //code is executed when negative
toTest:
db 130
signMask:
db 128
zero:
db 0
itIsPositive:
db 42
itIsNegative:
db 24
----
LEFT SHIFT BY 1:


push x
push x
add
x:
db 5
----

Nochmal ein kleines Update meinerseits für diejenige die es interessiert...

Habe die Seite und die VM nochmal geändert und aufgemotzt. Die Run-Funktion läuft jetzt schneller. Außerdem ist lfsh rausgeflogen und wurde um jump on unsigned less or equal jmpule ersetzt. Außerdem habe ich einen Bug beseitigt, bei dem leere Zeilen die Labelauflösung behindern.

Außerdem ist jetzt möglich Programme zu teilen und fremde Programm über einen Mausklick zu laden.
Share: http://185.177.21.162/community.php

Habe zwei Programme schon abgespeichert. Darunter eine Programm, was den ganzen Screen mit allen Farben füllt.

Nach meiner kurzen Exkursion in meine Stack8 VM, bin ich seit Anfang des Jahres wieder beim ursprünglichen Thema. Nachdem ich mir ein größeres Breadboard besorgt habe, um die grundlegende Schaltung aufzubauen, sowie eine Hand voll verschiedener 74xx ICs kann ich weiter an den Ausbau gehen.

Dazu habe ich meine Schaltung vom August komplett abgebaut, und auf dem größeren Breadboard neu angefangen. Der Platz sollte für einen sehr einfachen Z80 Rechner reichen, der auf ROM/RAM zugreifen kann.

Um den Load auf die CPU möglichst gering zu halten, wandern alle Adressleitungen und später auch alle Datenleitungen durch einen Buffer, der die CPU mit der Außenwelt verbindet. Die Adressleitungen sind dauerhaft durchgeschaltet, der Buffer für die Datenleitung wird je nach dem ob gelesen wird oder geschrieben wird, die eine oder andere Seite durchlassen.

Zurzeit sind schon alle Adressleitungen an den Buffer angebunden. Da die Adressleitungen leider nicht so schön liegen, sieht das ganze etwas chaotisch aus. Die Datenleitungen sind immer noch auf dauerhaft 0x00 (NOP) geschaltet. Unter den Buffer habe ich auch einen Decoder aufgebaut, der entscheidet, ob es RAM oder ROM sein darf. Ich habe mich für einen einfachen 32K/32K Split entschieden.

Bilder (Achtung große Auflösung):
Ohne Beschriftung

Mit Beschriftung

Desweiteren habe ich mir einen Arduino Mega Klon angeschafft. In einer ziemlich hässlichen Schaltung benutze ich ihn um eine EEPROM zu programmieren. Den Code zum Auslesen und Schreiben habe ich dabei "schnell" selber geschrieben. Kleinere Probleme gab es, da die Arduino Pins beim Anschalten kurz in einem undefinierten Zustand sind, wurden mir auch immer random werte beim Start reingeschrieben. Wenn die EEPROM aber später erst dazu geschaltet wird läuft alles rund.
Zurzeit habe ich das Programm "NOP;NOP;NOP;NOP;HALT" reingeschrieben, um später die Funktionalität zu prüfen.

Mehr später.

Der Z80 ist jetzt endlich am laufen...

Über die letzten zwei Wochen habe ich einen 555 Timer installiert, der mit unglaublichen 14 Hz den Z80 antreibt. Also ist der Z80 jetzt unabhängig und braucht keinen Arduino mehr zum starten.
Hinter den Adressbuffern habe ich die EEPROM (zurzeit nur 8k, später 32k) und den 32k SRAM installiert. Das Memory Layout ist also 50:50.

Weil die Pins an den ICs leider nicht so angeordnet sind, dass ich schöne Schaltungen bauen kann, gehen die Steckbrücken jetzt quasi kreuz und quer. Eigentlich wollte ich alles farbkodieren, aber mit den vorgefertigten Steckbrücken geht das schwer. Dazu bräuchte ich ne Kabelrolle, wo ich mir die richtigen Längen abschneiden kann. Aber ich blicke da tatsächlich noch durch.
Das größte Chaos herrscht über der EEPROM, weil die Leitungen A0 bis A4 auch irgendwie zum SRAM müssen. Und Leitungen A8-A12 zur EEPROM. Die ungenutzten Eingänge vom Adressbuffer habe ich auch genutzt um die Read und Write Enable Line zu puffern.
Der Datenbus besteht aus flexiblen Kabeln, die die Daten auf die andere Seite übertragen.

Dort habe ich einen Datenbuffer aufgebaut, der immer nur eine Richtung durchlässt, je nachdem ob ein Read oder Write durchgeführt werden soll.

Um direkt alle Teile des Systems zu testen habe ich ein kleines Program geschrieben, was erstmal 32 NOPs ausführt und dann HL mit 0x8000 (erste RAM Adresse) lädt und dann den Wert 42 dort speichert. Danach wird auf die Zelle zugegriffen und der Wert im Akkumulator gespeichert. Anschließend wird der Wert über die OUT Anweisung an eine I/O Adresse geschickt und danach gehalten.

Um den Wert abzufangen hängt der Arduino an der IOREQ Line und wartet auf die I/O Anweisung, dann greift er die Daten ab und schickt sie über Serial an meinen Computer. Quasi eine sehr primitive Parallel/Serial.

Das nächste Ziel ist es, das ganze jetzt auf eine Prototyp Platine zu löten. Dann kann ich auch eine eigene UART anschließen usw. . Aber zuerst steht noch ein Vortrag an, wo ich das Setup gerne nutzen würde um einen kryptographischen Angriff zu demonstrieren. Dazu schreibe ich am Wochenende das Programm.