Mikrocontroller.net - Benutzerbeiträge [de]

Benutzer:Bome

2026-02-27T14:58:15Z

Bome:

Projektseiten auf ''mikrocontroller.net'' 
[[8bit-Computer: bo8h]] 
[[8bit-CPU: bo8]]

Homepage und Kontaktdaten: https://bo8h.de 
Besuchen Sie auch https://sedimal.de

Kontaktierung über ''mikrocontroller.net'' 
http://www.mikrocontroller.net/user/show/bome

Forenbeiträge mit Bezug zum Projekt 
[http://www.mikrocontroller.net/topic/297603 8bit-Computing mit FPGA] 
[http://www.mikrocontroller.net/topic/407050 Befehlssatz der bo8-CPU ...] 
[http://www.mikrocontroller.net/topic/244442 8bit-Rechner auf Spartan-3A-Starterkit] 
[http://www.mikrocontroller.net/topic/304134 Tester gesucht ...] 
[http://www.mikrocontroller.net/topic/347716 Gibt es eine Programmiersprache ...] 
Dazu: [[Eine Alternative zur while-Schleife]] 
[http://www.mikrocontroller.net/topic/250009 Hexadezimaler Ziffernsatz] 
[http://www.mikrocontroller.net/topic/goto_post/7292010 Hex-Ziffern auf 7-Segment-Anzeigen] 
[http://www.mikrocontroller.net/topic/429490 Einführung des Hexadezimalsystems] 
[http://www.mikrocontroller.net/topic/goto_post/2781885 Warum ist das Zoll ...]

Was mir sonst noch wichtig ist 
[https://freigeisterhaus.de/viewtopic.php?p=2186553#2186553 freigeisterhaus.de/Bewusstsein-ManyWorlds] 
[https://www.politik-forum.eu/viewtopic.php?f=19&t=48768&start=300#p4480607 www.politik-forum.eu/Was-ist-Bewusstsein?] 
[https://www.mikrocontroller.net/topic/254701 Viele-Welten-Hypothese] [https://www.mikrocontroller.net/topic/459906 Neuromorphe Schaltkreise] 
http://www.spektrum.de/artikel/1159808 
''Siehe Kommentar #11''

Zahlensysteme

2026-02-24T23:54:49Z

Bome: /* Übersicht */

== Übersicht ==
In der Programmierung werden vier Zahlensysteme verwendet:
'''dezimal''', '''hexadezimal''', '''oktal''', '''binär''' (besser: '''dual''').
{| border=1 cellspacing=0 cellpadding=4
!style="width:10em;"| Zahlensystem
!style="width:5em;"| Basis
!style="width:7em;"| Ziffern
|-
| dezimal || 10 || 0 .. 9
|-
| hexadezimal || 16 || 0 .. 9 A .. F
|-
| oktal || 8 || 0 .. 7
|-
| dual || 2 || 0 .. 1
|}

Die Zahlen 0-15

Eine einstellige Hexadezimalzahl entspricht einer vollständigen, zweistelligen Oktakzahl bzw. vierstelligen Dualzahl. Diese nennt man auch [[Nibble]]. Eine Dezimalzahl braucht dafür 2 Stellen, welche aber nicht voll ausgenutzt werden. Darum ist die Umrechnung von hexadezimal/oktal/dual in dezimal aufwändiger. Die nachfolgende Tabelle sollte jeder Programmierer auswendig kennen, diese ist das kleine 1x1 der Zahlensysteme

{| border=1 cellspacing=0 cellpadding=4 style="text-align:center;"
!style="width:5em;"| dezimal
!style="width:8em;"| hexadezimal
!style="width:3em;"| oktal
!style="width:3em;"| dual
|-
| 0 || 0 || 0 || 0000
|-
| 1 || 1 || 1 || 0001
|-
| 2 || 2 || 2 || 0010
|-
| 3 || 3 || 3 || 0011
|-
| 4 || 4 || 4 || 0100
|-
| 5 || 5 || 5 || 0101
|-
| 6 || 6 || 6 || 0110
|-
| 7 || 7 || 7 || 0111
|-
| 8 || 8 || 10 || 1000
|-
| 9 || 9 || 11 || 1001
|-
| 10 || A || 12 || 1010
|-
| 11 || B || 13 || 1011
|-
| 12 || C || 14 || 1100
|-
| 13 || D || 15 || 1101
|-
| 14 || E || 16 || 1110
|-
| 15 || F || 17 || 1111
|}

== Darstellung ==
=== Hexadezimal ===
'''Hexadezimal'''zahlen werden meistens (z. B. in [[C]] oder im [[AVR]]-[[Assembler]]) mit dem Prefix "0x" geschrieben, also z. B. 0x3A; auch anzutreffen ist die Schreibweise mit einem führenden "$" (z. B. $3A).

Die vierstellige hexadezimale Schreibweise wird gerne verwendet um zwei [[Digitaltechnik|Bytes]] zusammenzufassen: 
Bsp.: 0x010F => 01 ist das High Byte, 0F ist das Low Byte.

=== Oktal ===
'''Oktal'''zahlen schreibt man in [[C]] mit einer führenden "0".

C-Programmierer sollten sich die führende Null bei Oktalzahlen unbedingt merken, auch wenn sie keine Oktalzahlen verwenden wollen. Denn es bedeutet, dass man Dezimalzahlen nicht mit führenden Nullen schreiben darf. "64" und "064" sind zwei völlig verschiedene Zahlen. Das erste ist die dezimale Zahl 64, das zweite die oktale Zahl 64, was der dezimalen Zahl 52 entspricht. Das gilt auch für AVR-ASM.

=== Binär ===
'''Binär'''zahlen schreibt man im AVR-Assembler mit "0b" am Anfang, z. B. 0b00110100. In [[C]]-Programmen ist die direkte Eingabe von Binärzahlen nicht möglich, es lassen sich aber [[C Makros|Makros]] zu diesem Zweck schreiben. Einige Compiler verfügen über eine Spracherweiterung, bei der meist der Präfix "0b" für Binärzahlen benutzt wird.

=== Intel-Syntax ===
[[Assembler]] mit Intel-Syntax (z. B. für 80x86 oder [[8051]]) verwenden dagegen zur Kennzeichnung keinen Präfix sondern einen Postfix. Für Hexzahlen gilt also z. B. die Notation 0A5H, für Oktalzahlen 245O (oder 245Q) und für Binärzahlen dementsprechend 10100101B.

== Verschiedenes ==
=== Anmerkung zu Oktalzahlen ===
Oktalzahlen sind in der Mikrocontroller-Programmierung heute seltener anzutreffen. Praktisch sind sie vor allem dann, wenn Binärzahlen aus irgend einem Grund in Gruppen von jeweils drei Bit strukturiert sind. Das gilt z. B. für die Datei-Zugriffsrechte unter [[Unix]]/[[Linux]], die sich bequem durch Angabe einer Oktalzahl einstellen lassen (z. B. entspricht "751" dem Bitmuster "111 101 001" oder "rwxr-x--x" in der üblichen Zugriffsrecht-Darstellung.) .

=== Umrechnung ===
Viele Taschenrechner können die Zahlensysteme umrechnen, so auch der Windows-Taschenrechner oder der UNIX-Taschenrechner bc. Wie die Umrechnung mathematisch funktioniert, ist [http://www.tutorials.at/einfuehrung/03-zahlensysteme.html hier] beschrieben. Zur Umrechnung von Nachkommastellen siehe [https://www.studienservice.de/thema/dezimal-in-hexadezimal.71337/#post-1140103 hier].

== Siehe auch ==
* Forenthread [https://www.mikrocontroller.net/topic/429490 Einführung des Hexadezimalsystems] und Website [https://sedimal.de sedimal.de] mit der Intention der Einführung des hexadezimalen Zahlensystems im Alltag

[[Kategorie:Algorithmen und Arithmetik]]

Datei:Bo8h.zip

2026-02-13T21:47:26Z

Bome: Bome lud eine neue Version von Datei:Bo8h.zip hoch

Quelle: Josef Gnadl

Kopie des Download-Files von bo8h.de 
Bitte beachten Sie die Hinweise auf bo8h.de

Das Urheberrecht an allen Inhalten des Download-Files hat der Inhaber von bo8h.de, Josef Gnadl.
Er erklärt hiermit seinen im Rahmen der Gesetze weitestmöglichen Verzicht auf alle daraus entstehenden
Ansprüche, die Nutzung durch andere Personen zu beschränken oder für die Nutzung eine Vergütung zu fordern.

Die Version vom 2.Jan.2023 ist die letzte Version mit Terasic-DE1 und Waveshare-OpenEP4CE10.

Die Datei vom 14.Nov.2023 enthält versehentlich noch die vorherige Version von cpu.vhd und ram32.vhd.

Die Version vom 21.Okt.24 enthält in der Datei Hardware.txt für DE0-nano die Zuodnungen VGA/HS-S08, VGA/VS-S10, PS2/DAT-S34, PS2/CLK-S36. Diese Zuordnungen sind veraltet und falsch. Korrekt sind VGA/HS-S10, VGA/VS-S08, PS2/DAT-S36, PS2/CLK-S34.

Bei Klick auf den Zeitpunkt 27.Nov.2024 wird die '''vorherige''' Version heruntergeladen. ???
https://www.mikrocontroller.net/topic/573264

8bit-Computer: bo8h

2026-01-13T13:48:13Z

Bome:

''Erst-Autor:'' [[Benutzer:Bome|''bome'']]

=Übersicht=

Der 8bit-Rechner bo8h ist ein Rechner für FPGA-Boards.
Aktuelle Realisierungen gibt es auf folgenden Boards:

* '''Terasic Cyclone V GX Starterkit'''
* '''Terasic DE10-Lite Board'''

Die '''CPU bo8''' ist eine Eigenentwicklung und hat keine Interrupts.
Merkmale des Gesamtsystems sind der aus acht 64KByte-Seiten bestehende Adressraum,
eine an die Hardware angepasste Programmiersprache und taktgenau berechenbare Programmlaufzeiten.
Der Zeichensatz beinhaltet neben Buchstaben und Sonderzeichen einen Satz von sechzehn Ziffern,
wobei die Ziffern A bis F durch modifizierte Buchstaben dargestellt werden.

Der Rechner hat Bildschirm und Tastatur, nutzt [[RS232]] zum Daten-Austausch mit PC sowie eine SD-Karte.
Der [[VHDL]]-Code ist so geschrieben, dass leicht weitere Schnittstellen eingebaut werden können.

* Informationen und Downloads gibt es auf [https://bo8h.de/Home/ bo8h.de].
* Kopie des Download-Files von bo8h.de: [[Datei:Bo8h.zip]]
* Wiki-Artikel zur CPU: [[8bit-CPU: bo8]].
* Beitrag im '''Forum''' Projekte & Code: [http://www.mikrocontroller.net/topic/297603 8bit-Computing mit FPGA].

Das Gerät hat 4 freie virtuelle Slots mit je 64KByte, wobei je 32KByte
für Software vorgesehen sind. Damit haben Software-Entwickler die Möglichkeit,
Slot-Software in Eigen-Regie anzubieten. Zur Software-Entwicklung
auf PC gibt es einen in C geschriebenen Assembler und ein Emulations-Programm.

=Die CPU=

''Der Punkt in den Mnemonics steht für einen auf der Grundlinie liegenden Bindestrich.''

Der Akku '''A''' und das Erweiterungsregister '''B''' sind 8-bit, ebenso das Data-Register '''D'''. 
Das Doppelregister AB wird abkürzend mit '''K''' bezeichnet. 
Das Vorzeichenbit A7 wird abkürzend mit '''U''' bezeichnet.

Der Programmzähler '''P''' und die Adressregister '''X''', '''Y''', '''Z''' sind 16-bit. 
Das Register '''Q''' erhält bei Sprüngen die Rückkehradresse P+1. 
'''R''' ist Schleifen-Startadresse, '''S''' ist Schleifenzähler (16-bit).

Einziges Flag ist der Carry '''V'''. Bei bedingten Sprüngen kann ausserdem abgefragt werden, ob U/A/K Null ist.

Alle Speicherzugriffe sind 8bit-Zugriffe. 
GTMX lädt nach A den Inhalt der Speicherzelle, auf welche X zeigt. 
STMX speichert A in der Speicherzelle, auf welche X zeigt.

IXE inkrementiert X und tauscht A und B. 
DXE dekrementiert X und tauscht A und B.

Damit lassen sich 2-byte-Speicherzugriffe aufbauen 
nach dem Muster GTMX..IXE..GTMX und STMX..DXE..STMX. 
Es gibt hierfür die Assembler-Makros GTMXI und STMXD.

<pre>
GTMXI lädt eine Adresse von Position X
ST.Y überträgt die Adresse nach Y

GTMXI lädt eine Adresse von Position X
AD.X addiert X
ST.Y überträgt die zu X relative Adresse nach Y

J.. Sprung zu der Adresse, welche in K steht

GTA 59 lädt den Wert 0059 nach K
AD. 35 addiert 35 zu A
J.. Sprung nach 3559

Das lässt sich kürzer schreiben mit Assembler-Makro
/GTA 3559
J

GTR 59 lädt den Wert P+0059+3 nach K
AD. 35 addiert 35 zu A
J.. relativer Sprung nach P+3559+3

Das lässt sich kürzer schreiben mit Assembler-Makro
/GTR 3559
J

GT.Q lädt Rückkehradresse nach K
J Rücksprung aus Unterprogramm
</pre>

Wenn ein Unterprogramm selber J.. ausführen will für andere Zwecke als für den Rücksprung,
muss es vorher die Rückkehradresse sichern. Dazu kann es die Rückkehradresse aus Q laden,
anfangs steht sie aber auch in K und das Laden kann entfallen.

Ausser dem Sprungbefehl J.. gibt es die bedingten Sprünge mit 8bit-Sprungdistanz: 
O.cc nn (Vorwärtssprung falls cc) und B.cc nn (Rückwärtssprung falls cc).

Für schnelle Schleifen gibt es die Repeat-Befehle R.cc. 
Repeat-Befehle gibt es kombiniert mit Schleifenzähler-Dekrementieren und Adresse-Inkrementieren/Dekrementieren.
Die Schleifenstartadresse R wird gesetzt vor dem Schleifenanfang mittels S.RP oder mittels O.RP nn.
Bei letzterem wird gleichzeitig ein Vorwärtssprung ausgeführt. Damit sind Schleifen mit Hineinsprung (while-Schleifen) realisierbar.

Bei J.. wird die Zieladresse auch nach R übertragen. Das garantiert, dass R stets eine Adresse im Nahbereich
des Programmzählers enthält. Eine Anwendung hiervon ergibt sich beim Sprung in eine Tabelle, welche aus
O.WY nn -Befehlen (Vorwärtssprung always) besteht, wobei die O.WY nn alle zur
selben Adresse springen. Die dortige Routine kann durch Auswertung von R die Nummer des O.WY-Befehls ermitteln.

'''Adressierung mehrerer 64K-Seiten:'''

Zu jeder auf dem Adressbus ausgegebenen Adresse wird auf den Steuerleitungen angezeigt, von welchem der
Adressregister P, X, Y, Z sie kommt. Dadurch kann eine externe Logik jedem der Adressregister eine eigene
64K-Speicherseite zuordnen. Die CPU kann spezielle Steuersignale ausgeben, welche die externe Logik
zur Memory-Page-Umschaltung für eines der Adressregister veranlassen sollen.

Der Befehl H.. ist der einzige und universell einsetzbare IO-Befehl.
Es wird K auf dem Adressbus ausgegeben und der Datenbus nach A eingelesen.

Wenn auf H.. ein J.. folgt, dann wirkt H.. stattdessen als Präfix und bewirkt,
dass J.. mit einer Memory-Page-Umschaltung kombiniert wird. So kann die CPU von einer
64K-Seite in eine andere springen, ohne dass es einen gemeinsamen Speicherbereich geben muss.

Bei den Adressregistern X, Y, Z gibt es spezielle Befehle SW.X, SW.Y, SW.Z für die Memory-Page-Umschaltung.

=Die Gesamt-Hardware=

Es gibt acht Memory-Pages mit je 64KByte:

* Page 0: RAM frei vorgesehen als TextRAM
* Page 1: ROM (32K), Text-RAM (16K), Video-RAM (16K)
* Page 2: RAM1 Haupt-RAM
* Page 3: RAM2 Neben-RAM
* Page 4: Slot4
* Page 5: Slot5
* Page 6: Slot6
* Page 7: Slot7

Die 3bit-Register MP, MX, MY, MZ legen zusammen mit dem 2bit-Register SL fest, in welche der 8 Memory-Pages
das betreffende Adressregister P, X, Y, Z zeigt. MP, MX, MY, MZ können nur die Werte 0 bis 4 annehmen.
Wenn der Wert 4 ist, dann liefert SL die unteren 2bit für die Page-Auswahl.

Ausserdem gibt es die Schattenregister NP, NX, NY, NZ.
Das CPU-Signal zur Memory-Page-Umschaltung für eines der Adressregister
bewirkt den Austausch von M# und N#, wobei # hier für P, X, Y, Z steht.
Beim Sprung mit Memory-Page-Umschaltung  H..  J..  werden also MP und NP getauscht.
Die Schattenregister NP, NX, NY, NZ können über IO-Befehle H.. mit einem Wert 0 bis 4 geladen werden,
das Register SL mit einem Wert 0 bis 3.

Das Display ist 512 Pixel breit und 256 Pixel hoch, die Pixel sind zweiwertig.
Der Video-Generator liest in Dauerschleife das Video-RAM und erzeugt daraus die VGA-Signale.
Einen Hardware-Zeichengenerator gibt es nicht.
Die Software liest die Zeichen aus dem Text-RAM und schreibt deren Pixelmuster ins Video-RAM.
Die Textzeilen sind 64 Zeichen breit.
Durch Invertierung eines Flipflops können Text-RAM und Video-RAM ihre Rollen tauschen.
So kann die CPU im Text-RAM eine neue Grafik erstellen, während noch das alte Video-RAM angezeigt wird.

=Die Programmiersprache=

Der Compiler erzeugt einen Bytecode, welcher interpretativ abgearbeitet wird. Der
Bytecode besteht aus Aufrufen vorgefertigter Maschinenroutinen. Nur wenige dieser
Maschinenroutinen sind interner Teil der Sprache, die meisten liegen in den 4 Slots.

Die Sprache ist strikt imperativ. Es besteht eine direkte Eins-zu-Eins-Entsprechung zwischen dem Quelltext und
der Folge der Operationen im Bytecode. Es gibt im Quelltext keine arithmetischen oder logischen Ausdrücke.

Es gibt in dieser Sprache kein goto, kein break, kein continue, und in jedem Programm oder
Unterprogramm genau 1 return, nämlich am Ende des Programms oder Unterprogramms.

Die Strukturelemente sind folgende:

<pre>
Bedingte Anweisung: IF.c ... ENDF
Verzweigung: IF.c ... ELSE ... ENDE
Case-Struktur: CASE /nn ... NEXT /nn ... LAST
Do-while-Schleife: LOOP ... RP.c
While-Schleife: L.JP ... HERE ... RP.c
</pre>

c steht hier für die Sprungbedingung, nn steht für eine Zahl
fallend bis 00, NEXT /nn ist entsprechend mehrmals anzugeben. 
RP.c steht für wiederhole falls c.

Ebenso wie die Verzweigung zählt die Schleife mit Hineinsprung

<pre>
L.JP ... HERE ... RP.c
</pre>

als ein Block mit zwei Unterblöcken, die strenge Blockstruktur wird durch den Hineinsprung nicht durchbrochen.

Die Blockstruktur wird bei folgenden Operationen gebraucht:

<pre>
ACQU ... UACQ
FASN ... UFAS
BORR ... UBOR
BORX ... UBOR
</pre>

ACQU steht für Aquirieren von Residenten Variablen 
UACU macht das Aquirieren rückgängig

Residente Variable sind Variable, zB. vom Typ databox, welche ausserhalb des Programms dauerhaft im RAM
liegen. Sie sind über ihren Namen auffindbar und werden über ihre Nummer adressiert. ACQU bindet freie
Zeiger, welche im Programm vereinbart sind, an diese externen Variablen. Dadurch sind diese Variablen unter
Umgehung des Namens und der Nummer wie gewöhnliche im Programm vereinbarte Variable verfügbar.

FASN vergibt den Status "befestigt" an Variable vom Typ databox 
UFAS macht die Vergabe rückgängig.

Variable vom Typ databox, welche beim Start des Programms automatisch installiert werden
oder danach durch BORR/BORX installiert werden, sind von sich aus "befestigt". Das Installieren
kann aber auch durch Slot-Kommandos erfolgen, zB. wenn die Größe der databox
erst zur Laufzeit des Programms bekannt wird. Dann sind sie zunächst unbefestigt.

BORR leiht den von einer databox in RAM1 oder RAM2 belegten Speicherplatz an mehrere Variable aus,
welche vorher als nicht installiert vereinbart wurden und nach dem Ausleihen den Speicherplatz der databox überdecken.

BORX leiht einen Teil des Speicherplatzes einer databox ab einem Startindex an mehrere Variable aus.

In RAM1 sind die mehreren Variablen kurze Variable vom Typ data, oder selber
wieder vom Typ databox, in RAM2 sind sie stets wieder vom Typ databox.

Beim Ausleihen aus einer databox prüft BORR/BORX, ob die databox befestigt ist. Andernfalls
wäre sie verschiebbar oder könnte uninstalliert werden, so dass Schreibzugriffe auf die
durch das Ausleihen erzeugten Variablen Unheil anrichten könnten.

UBOR macht das Ausleihen rückgängig.

Bei den Operationen ACQU, FASN, BORR/BORX garantiert der Compiler,
dass das zugehörige UACQ, UFAS, UBOR im selben Block liegt.
Die jeweilige Operation und das zugehörige Rückgängigmachen bilden selber wieder
einen Block, jedoch können mehrere BORR/BORX-UBOR-Blöcke einander überkreuzen.

'''Ergänzung zu Sprungbedingungen:'''

Es kann abgefragt werden, ob eine 1-oder 2-Byte-Variable
Null ist und ob sie gleich ff bzw. ffff ist.

Die Kommandos =TT.Z und =TT.M können diese Bedingungen
speichern in einem speziellen Byte im RAM, dem TF-Merker.
Dazu schieben sie eine 1 oder 0 von oben auf den TF-Merker.
In gleicher Weise können Steckkarten-Kommandos nCOMMAND
beliebige Bedingungen ermitteln und speichern.

Es gibt bedingte Sprünge, welche die obersten 3 Bit des
TF-Merker mittels einer Wahrheitstabelle abfragen. Dabei
können bis zu 3 Bits wieder vom TF-Merker entfernt werden.

Mittels der Routinen =PP.r, =PZ.r, =PM.r ist es möglich,
solche Bedingungen in einer 1- oder 2-Byte-Variablen zu
speichern, zu verANDen und zu verORen. Damit lassen
sich beliebig komplexe Sprungbedingungen berechnen.

'''Unterprogramme:'''

In der Programmiersprache gibt es keine functions mit
Rückgabewert, sondern nur einfache Unterprogramme, bei
welchen alle Parameter gleichberechtigt sind. Es werden
ausschließlich Zeiger übergeben.

'''Variablen vom Typ FIX:'''

Ihre Startwerte sind Teil des Programmcodes und liegen dort am Ende.
Der gesamte Speicherbereich dieser Werte kann als "FIXBOX" vom
Programm abgetrennt werden und dann mittels eines speziellen
Werkzeugs bearbeitet werden.

[[Kategorie:FPGA-Projekte]]

8bit-Computer: bo8h

2026-01-12T21:16:18Z

Bome:

''Erst-Autor:'' [[Benutzer:Bome|''bome'']]

=Übersicht=

Der 8bit-Rechner bo8h ist ein Rechner für FPGA-Boards.
Aktuelle Realisierungen gibt es auf folgenden Boards:

* '''Terasic Cyclone V GX Starterkit'''
* '''Terasic DE10-Lite Board'''

Die '''CPU bo8''' ist eine Eigenentwicklung und hat keine Interrupts.
Merkmale des Gesamtsystems sind der aus acht 64KByte-Seiten bestehende Adressraum,
eine an die Hardware angepasste Programmiersprache und taktgenau berechenbare Programmlaufzeiten.
Der Zeichensatz beinhaltet neben Buchstaben und Sonderzeichen einen Satz von sechzehn Ziffern,
wobei die Ziffern A bis F durch modifizierte Buchstaben dargestellt werden.

Der Rechner hat Bildschirm und Tastatur, nutzt [[RS232]] zum Daten-Austausch mit PC sowie eine SD-Karte.
Der [[VHDL]]-Code ist so geschrieben, dass leicht weitere Schnittstellen eingebaut werden können.

* Informationen und Downloads gibt es auf [https://bo8h.de/Home/ bo8h.de].
* Kopie des Download-Files von bo8h.de: [[Datei:Bo8h.zip]]
* Wiki-Artikel zur CPU: [[8bit-CPU: bo8]].
* Beitrag im '''Forum''' Projekte & Code: [http://www.mikrocontroller.net/topic/297603 8bit-Computing mit FPGA].

Das Gerät hat 4 freie virtuelle Slots mit je 64KByte, wobei je 32KByte
für Software vorgesehen sind. Damit haben Software-Entwickler die Möglichkeit,
Slot-Software in Eigen-Regie anzubieten. Zur Software-Entwicklung
auf PC gibt es einen in C geschriebenen Assembler und ein Emulations-Programm.

=Die CPU=

''Der Punkt in den Mnemonics steht für einen auf der Grundlinie liegenden Bindestrich.''

Der Akku '''A''' und das Erweiterungsregister '''B''' sind 8-bit, ebenso das Data-Register '''D'''. 
Das Doppelregister AB wird abkürzend mit '''K''' bezeichnet. 
Das Vorzeichenbit A7 wird abkürzend mit '''U''' bezeichnet.

Der Programmzähler '''P''' und die Adressregister '''X''', '''Y''', '''Z''' sind 16-bit. 
Das Register '''Q''' erhält bei Sprüngen die Rückkehradresse P+1. 
'''R''' ist Schleifen-Startadresse, '''S''' ist Schleifenzähler (16-bit).

Einziges Flag ist der Carry '''V'''. Bei bedingten Sprüngen kann ausserdem abgefragt werden, ob U/A/K Null ist.

Alle Speicherzugriffe sind 8bit-Zugriffe. 
GTMX lädt nach A den Inhalt der Speicherzelle, auf welche X zeigt. 
STMX speichert A in der Speicherzelle, auf welche X zeigt.

IXE inkrementiert X und tauscht A und B. 
DXE dekrementiert X und tauscht A und B.

Damit lassen sich 2-byte-Speicherzugriffe aufbauen 
nach dem Muster GTMX..IXE..GTMX und STMX..DXE..STMX. 
Es gibt hierfür die Assembler-Makros GTMXI und STMXD.

<pre>
GTMXI lädt eine Adresse von Position X
ST.Y überträgt die Adresse nach Y

GTMXI lädt eine Adresse von Position X
AD.X addiert X
ST.Y überträgt die zu X relative Adresse nach Y

J.. Sprung zu der Adresse, welche in K steht

GTA 59 lädt den Wert 0059 nach K
AD. 35 addiert 35 zu A
J.. Sprung nach 3559

Das lässt sich kürzer schreiben mit Assembler-Makro
/GTA 3559
J

GTR 59 lädt den Wert P+0059+3 nach K
AD. 35 addiert 35 zu A
J.. relativer Sprung nach P+3559+3

Das lässt sich kürzer schreiben mit Assembler-Makro
/GTR 3559
J

GT.Q lädt Rückkehradresse nach K
J Rücksprung aus Unterprogramm
</pre>

Wenn ein Unterprogramm selber J.. ausführen will für andere Zwecke als für den Rücksprung,
muss es vorher die Rückkehradresse sichern. Dazu kann es die Rückkehradresse aus Q laden,
anfangs steht sie aber auch in K und das Laden kann entfallen.

Ausser dem Sprungbefehl J.. gibt es die bedingten Sprünge mit 8bit-Sprungdistanz: 
O.cc nn (Vorwärtssprung falls cc) und B.cc nn (Rückwärtssprung falls cc).

Für schnelle Schleifen gibt es die Repeat-Befehle R.cc. 
Repeat-Befehle gibt es kombiniert mit Schleifenzähler-Dekrementieren und Adresse-Inkrementieren/Dekrementieren.
Die Schleifenstartadresse R wird gesetzt vor dem Schleifenanfang mittels S.RP oder mittels O.RP nn.
Bei letzterem wird gleichzeitig ein Vorwärtssprung ausgeführt. Damit sind Schleifen mit Hineinsprung (while-Schleifen) realisierbar.

Bei J.. wird die Zieladresse auch nach R übertragen. Das garantiert, dass R stets eine Adresse im Nahbereich
des Programmzählers enthält. Eine Anwendung hiervon ergibt sich beim Sprung in eine Tabelle, welche aus
O.WY nn -Befehlen (Vorwärtssprung always) besteht, wobei die O.WY nn alle zur
selben Adresse springen. Die dortige Routine kann durch Auswertung von R die Nummer des O.WY-Befehls ermitteln.

'''Adressierung mehrerer 64K-Seiten:'''

Zu jeder auf dem Adressbus ausgegebenen Adresse wird auf den Steuerleitungen angezeigt, von welchem der
Adressregister P, X, Y, Z sie kommt. Dadurch kann eine externe Logik jedem der Adressregister eine eigene
64K-Speicherseite zuordnen. Die CPU kann spezielle Steuersignale ausgeben, welche die externe Logik
zur Memory-Page-Umschaltung für eines der Adressregister veranlassen sollen.

Der Befehl H.. ist der einzige und universell einsetzbare IO-Befehl.
Es wird K auf dem Adressbus ausgegeben und der Datenbus nach A eingelesen.

Wenn auf H.. ein J.. folgt, dann wirkt H.. stattdessen als Präfix und bewirkt,
dass J.. mit einer Memory-Page-Umschaltung kombiniert wird. So kann die CPU von einer
64K-Seite in eine andere springen, ohne dass es einen gemeinsamen Speicherbereich geben muss.

Bei den Adressregistern X, Y, Z gibt es spezielle Befehle SW.X, SW.Y, SW.Z für die Memory-Page-Umschaltung.

=Die Gesamt-Hardware=

Es gibt acht Memory-Pages mit je 64KByte:

* Page 0: RAM (frei)
* Page 1: ROM (32K), Text-RAM (16K), Video-RAM (16K)
* Page 2: Haupt-RAM
* Page 3: Zusatz-RAM
* Page 4: Slot4
* Page 5: Slot5
* Page 6: Slot6
* Page 7: Slot7

Die 3bit-Register MP, MX, MY, MZ legen zusammen mit dem 2bit-Register SL fest, in welche der 8 Memory-Pages
das betreffende Adressregister P, X, Y, Z zeigt. MP, MX, MY, MZ können nur die Werte 0 bis 4 annehmen. Wenn der Wert 4 ist, dann liefert SL die unteren 2bit für die Page-Auswahl.

Ausserdem gibt es die Schattenregister NP, NX, NY, NZ.
Das CPU-Signal zur Memory-Page-Umschaltung für eines der Adressregister
bewirkt den Austausch von M# und N#, wobei # hier für P, X, Y, Z steht.
Beim Sprung mit Memory-Page-Umschaltung  H..  J..  werden also MP und NP getauscht.
Die Schattenregister NP, NX, NY, NZ können über IO-Befehle H.. mit einem Wert 0 bis 4 geladen werden,
das Register SL mit einem Wert 0 bis 3.

Das Display ist 512 Pixel breit und 256 Pixel hoch, die Pixel sind zweiwertig.
Der Video-Generator liest in Dauerschleife das Video-RAM und erzeugt daraus die VGA-Signale.
Einen Hardware-Zeichengenerator gibt es nicht.
Die Software liest die Zeichen aus dem Text-RAM und schreibt deren Pixelmuster ins Video-RAM.
Die Textzeilen sind 64 Zeichen breit.
Durch Invertierung eines Flipflops können Text-RAM und Video-RAM ihre Rollen tauschen.
So kann die CPU im Text-RAM eine neue Grafik erstellen, während noch das alte Video-RAM angezeigt wird.

=Die Programmiersprache=

Der Compiler erzeugt einen Bytecode, welcher interpretativ abgearbeitet wird. Der
Bytecode besteht aus Aufrufen vorgefertigter Maschinenroutinen. Nur wenige dieser
Maschinenroutinen sind interner Teil der Sprache, die meisten liegen in den 4 Slots.

Die Sprache ist strikt imperativ. Es besteht eine direkte Eins-zu-Eins-Entsprechung zwischen dem Quelltext und
der Folge der Operationen im Bytecode. Es gibt im Quelltext keine arithmetischen oder logischen Ausdrücke.

Es gibt in dieser Sprache kein goto, kein break, kein continue, und in jedem Programm oder
Unterprogramm genau 1 return, nämlich am Ende des Programms oder Unterprogramms.

Die Strukturelemente sind folgende:

<pre>
Bedingte Anweisung: IF.c ... ENDF
Verzweigung: IF.c ... ELSE ... ENDE
Case-Struktur: CASE /nn ... NEXT /nn ... LAST
Do-while-Schleife: LOOP ... RP.c
While-Schleife: L.JP ... HERE ... RP.c
</pre>

c steht hier für die Sprungbedingung, nn steht für eine Zahl
fallend bis 00, NEXT /nn ist entsprechend mehrmals anzugeben. 
RP.c steht für wiederhole falls c.

Ebenso wie die Verzweigung zählt die Schleife mit Hineinsprung

<pre>
L.JP ... HERE ... RP.c
</pre>

als ein Block mit zwei Unterblöcken, die strenge Blockstruktur wird durch den Hineinsprung nicht durchbrochen.

Die Blockstruktur wird bei folgenden Operationen gebraucht:

<pre>
ACQU ... UACQ
FASN ... UFAS
BORR ... UBOR
BORX ... UBOR
</pre>

ACQU steht für Aquirieren von Residenten Variablen 
UACU macht das Aquirieren rückgängig

Residente Variable sind Variable, zB. vom Typ databox, welche ausserhalb des Programms dauerhaft im RAM
liegen. Sie sind über ihren Namen auffindbar und werden über ihre Nummer adressiert. ACQU bindet freie
Zeiger, welche im Programm vereinbart sind, an diese externen Variablen. Dadurch sind diese Variablen unter
Umgehung des Namens und der Nummer wie gewöhnliche im Programm vereinbarte Variable verfügbar.

FASN vergibt den Status "befestigt" an Variable vom Typ databox 
UFAS macht die Vergabe rückgängig.

Variable vom Typ databox, welche beim Start des Programms automatisch installiert werden
oder danach durch BORR/BORX installiert werden, sind von sich aus "befestigt". Das Installieren
kann aber auch durch Slot-Kommandos erfolgen, zB. wenn die Größe der databox
erst zur Laufzeit des Programms bekannt wird. Dann sind sie zunächst unbefestigt.

BORR leiht den von einer databox im Haupt-RRAM oder Zusatz-RAM belegten Speicherplatz an mehrere Variable aus,
welche vorher als nicht installiert vereinbart wurden und nach dem Ausleihen den Speicherplatz der databox überdecken.

BORX leiht einen Teil des Speicherplatzes einer databox ab einem Startindex an mehrere Variable aus.

Im Haupt-RAM sind die mehreren Variablen kurze Variable vom Typ data, oder selber
wieder vom Typ databox, im Zusatz-RAM sind sie stets wieder vom Typ databox.

Beim Ausleihen aus einer databox prüft BORR/BORX, ob die databox befestigt ist. Andernfalls
wäre sie verschiebbar oder könnte uninstalliert werden, so dass Schreibzugriffe auf die
durch das Ausleihen erzeugten Variablen Unheil anrichten könnten.

UBOR macht das Ausleihen rückgängig.

Bei den Operationen ACQU, FASN, BORR/BORX garantiert der Compiler,
dass das zugehörige UACQ, UFAS, UBOR im selben Block liegt.
Die jeweilige Operation und das zugehörige Rückgängigmachen bilden selber wieder
einen Block, jedoch können mehrere BORR/BORX-UBOR-Blöcke einander überkreuzen.

'''Ergänzung zu Sprungbedingungen:'''

Es kann abgefragt werden, ob eine 1-oder 2-Byte-Variable
Null ist und ob sie gleich ff bzw. ffff ist.

Die Kommandos =TT.Z und =TT.M können diese Bedingungen
speichern in einem speziellen Byte im RAM, dem TF-Merker.
Dazu schieben sie eine 1 oder 0 von oben auf den TF-Merker.
In gleicher Weise können Steckkarten-Kommandos nCOMMAND
beliebige Bedingungen ermitteln und speichern.

Es gibt bedingte Sprünge, welche die obersten 3 Bit des
TF-Merker mittels einer Wahrheitstabelle abfragen. Dabei
können bis zu 3 Bits wieder vom TF-Merker entfernt werden.

Mittels der Routinen =PP.r, =PZ.r, =PM.r ist es möglich,
solche Bedingungen in einer 1- oder 2-Byte-Variablen zu
speichern, zu verANDen und zu verORen. Damit lassen
sich beliebig komplexe Sprungbedingungen berechnen.

'''Unterprogramme:'''

In der Programmiersprache gibt es keine functions mit
Rückgabewert, sondern nur einfache Unterprogramme, bei
welchen alle Parameter gleichberechtigt sind. Es werden
ausschließlich Zeiger übergeben.

'''Variablen vom Typ FIX:'''

Ihre Startwerte sind Teil des Programmcodes und liegen dort am Ende.
Der gesamte Speicherbereich dieser Werte kann als "FIXBOX" vom
Programm abgetrennt werden und dann mittels eines speziellen
Werkzeugs bearbeitet werden.

[[Kategorie:FPGA-Projekte]]

8bit-Computer: bo8h

2026-01-12T21:03:38Z

Bome: Großer Umbau

''Erst-Autor:'' [[Benutzer:Bome|''bome'']]

=Übersicht=

Der 8bit-Rechner bo8h ist ein Rechner für FPGA-Boards.
Aktuelle Realisierungen gibt es auf folgenden Boards:

* '''Terasic Cyclone V GX Starterkit'''
* '''Terasic DE10-Lite Board'''

Die '''CPU bo8''' ist eine Eigenentwicklung und hat keine Interrupts.
Merkmale des Gesamtsystems sind der aus acht 64KByte-Seiten bestehende Adressraum,
eine an die Hardware angepasste Programmiersprache und taktgenau berechenbare Programmlaufzeiten.
Der Zeichensatz beinhaltet neben Buchstaben und Sonderzeichen einen Satz von sechzehn Ziffern,
wobei die Ziffern A bis F durch modifizierte Buchstaben dargestellt werden.

Der Rechner hat Bildschirm und Tastatur, nutzt [[RS232]] zum Daten-Austausch mit PC sowie eine SD-Karte.
Der [[VHDL]]-Code ist so geschrieben, dass leicht weitere Schnittstellen eingebaut werden können.

* Informationen und Downloads gibt es auf [https://bo8h.de/Home/ bo8h.de].
* Kopie des Download-Files von bo8h.de: [[Datei:Bo8h.zip]]
* Wiki-Artikel zur CPU: [[8bit-CPU: bo8]].
* Beitrag im '''Forum''' Projekte & Code: [http://www.mikrocontroller.net/topic/297603 8bit-Computing mit FPGA].

Das Gerät hat 4 freie virtuelle Slots mit je 64KByte, wobei je 32KByte
für Software vorgesehen sind. Damit haben Software-Entwickler die Möglichkeit,
Slot-Software in Eigen-Regie anzubieten. Zur Software-Entwicklung
auf PC gibt es einen in C geschriebenen Assembler und ein Emulations-Programm.

=Die CPU=

''Der Punkt in den Mnemonics steht für einen auf der Grundlinie liegenden Bindestrich.''

Der Akku '''A''' und das Erweiterungsregister '''B''' sind 8-bit, ebenso das Data-Register '''D'''. 
Das Doppelregister AB wird abkürzend mit '''K''' bezeichnet. 
Das Vorzeichenbit A7 wird abkürzend mit '''U''' bezeichnet.

Der Programmzähler '''P''' und die Adressregister '''X''', '''Y''', '''Z''' sind 16-bit. 
Das Register '''Q''' erhält bei Sprüngen die Rückkehradresse P+1. 
'''R''' ist Schleifen-Startadresse, '''S''' ist Schleifenzähler (16-bit).

Einziges Flag ist der Carry '''V'''. Bei bedingten Sprüngen kann ausserdem abgefragt werden, ob U/A/K Null ist.

Alle Speicherzugriffe sind 8bit-Zugriffe. 
GTMX lädt nach A den Inhalt der Speicherzelle, auf welche X zeigt. 
STMX speichert A in der Speicherzelle, auf welche X zeigt.

IXE inkrementiert X und tauscht A und B. 
DXE dekrementiert X und tauscht A und B.

Damit lassen sich 2-byte-Speicherzugriffe aufbauen 
nach dem Muster GTMX..IXE..GTMX und STMX..DXE..STMX. 
Es gibt hierfür die Assembler-Makros GTMXI und STMXD.

<pre>
GTMXI lädt eine Adresse von Position X
ST.Y überträgt die Adresse nach Y

GTMXI lädt eine Adresse von Position X
AD.X addiert X
ST.Y überträgt die zu X relative Adresse nach Y

J.. Sprung zu der Adresse, welche in K steht

GTA 59 lädt den Wert 0059 nach K
AD. 35 addiert 35 zu A
J.. Sprung nach 3559

Das lässt sich kürzer schreiben mit Assembler-Makro
/GTA 3559
J

GTR 59 lädt den Wert P+0059+3 nach K
AD. 35 addiert 35 zu A
J.. relativer Sprung nach P+3559+3

Das lässt sich kürzer schreiben mit Assembler-Makro
/GTR 3559
J

GT.Q lädt Rückkehradresse nach K
J Rücksprung aus Unterprogramm
</pre>

Wenn ein Unterprogramm selber J.. ausführen will für andere Zwecke als für den Rücksprung,
muss es vorher die Rückkehradresse sichern. Dazu kann es die Rückkehradresse aus Q laden,
anfangs steht sie aber auch in K und das Laden kann entfallen.

Ausser dem Sprungbefehl J.. gibt es die bedingten Sprünge mit 8bit-Sprungdistanz: 
O.cc nn (Vorwärtssprung falls cc) und B.cc nn (Rückwärtssprung falls cc).

Für schnelle Schleifen gibt es die Repeat-Befehle R.cc. 
Repeat-Befehle gibt es kombiniert mit Schleifenzähler-Dekrementieren und Adresse-Inkrementieren/Dekrementieren.
Die Schleifenstartadresse R wird gesetzt vor dem Schleifenanfang mittels S.RP oder mittels O.RP nn.
Bei letzterem wird gleichzeitig ein Vorwärtssprung ausgeführt. Damit sind Schleifen mit Hineinsprung (while-Schleifen) realisierbar.

Bei J.. wird die Zieladresse auch nach R übertragen. Das garantiert, dass R stets eine Adresse im Nahbereich
des Programmzählers enthält. Eine Anwendung hiervon ergibt sich beim Sprung in eine Tabelle, welche aus
O.WY nn -Befehlen (Vorwärtssprung always) besteht, wobei die O.WY nn alle zur
selben Adresse springen. Die dortige Routine kann durch Auswertung von R die Nummer des O.WY-Befehls ermitteln.

'''Adressierung mehrerer 64K-Seiten:'''

Zu jeder auf dem Adressbus ausgegebenen Adresse wird auf den Steuerleitungen angezeigt, von welchem der
Adressregister P, X, Y, Z sie kommt. Dadurch kann eine externe Logik jedem der Adressregister eine eigene
64K-Speicherseite zuordnen. Die CPU kann spezielle Steuersignale ausgeben, welche die externe Logik
zur Memory-Page-Umschaltung für eines der Adressregister veranlassen sollen.

Der Befehl H.. ist der einzige und universell einsetzbare IO-Befehl.
Es wird K auf dem Adressbus ausgegeben und der Datenbus nach A eingelesen.

Wenn auf H.. ein J.. folgt, dann wirkt H.. stattdessen als Präfix und bewirkt,
dass J.. mit einer Memory-Page-Umschaltung kombiniert wird. So kann die CPU von einer
64K-Seite in eine andere springen, ohne dass es einen gemeinsamen Speicherbereich geben muss.

Bei den Adressregistern X, Y, Z gibt es spezielle Befehle SW.X, SW.Y, SW.Z für die Memory-Page-Umschaltung.

=Die Gesamt-Hardware=

Es gibt acht Memory-Pages mit je 64KByte:

* Page 0: RAM (frei)
* Page 1: ROM (32K), Text-RAM (16K), Video-RAM (16K)
* Page 2: Haupt-RAM
* Page 3: Zusatz-RAM
* Page 4: Slot4
* Page 5: Slot5
* Page 6: Slot6
* Page 7: Slot7

Die 3bit-Register MP, MX, MY, MZ legen zusammen mit dem 2bit-Register SL fest, in welche der 8 Memory-Pages
das betreffende Adressregister P, X, Y, Z zeigt. MP, MX, MY, MZ können nur die Werte 0 bis 4 annehmen. Wenn der Wert 4 ist, dann liefert SL die unteren 2bit für die Page-Auswahl.

Ausserdem gibt es die Schattenregister NP, NX, NY, NZ.
Das CPU-Signal zur Memory-Page-Umschaltung für eines der Adressregister
bewirkt den Austausch von M# und N#, wobei # hier für P, X, Y, Z steht.
Beim Sprung mit Memory-Page-Umschaltung  H..  J..  werden also MP und NP getauscht.
Die Schattenregister NP, NX, NY, NZ können über IO-Befehle H.. mit einem Wert 0 bis 4 geladen werden,
das Register SL mit einem Wert 0 bis 3.

Das Display ist 512 Pixel breit und 256 Pixel hoch, die Pixel sind zweiwertig.
Der Video-Generator liest in Dauerschleife das Video-RAM und erzeugt daraus die VGA-Signale.
Einen Hardware-Zeichengenerator gibt es nicht.
Die Software liest die Zeichen aus dem Text-RAM und schreibt deren Pixelmuster ins Video-RAM.
Die Textzeilen sind 64 Zeichen breit.
Durch Invertierung eines Flipflops können Text-RAM und Video-RAM ihre Rollen tauschen.
So kann die CPU im Text-RAM eine neue Grafik erstellen, während noch das alte Video-RAM angezeigt wird.

=Die Programmiersprache=

Der Compiler erzeugt einen Bytecode, welcher interpretativ abgearbeitet wird. Der
Bytecode besteht aus Aufrufen vorgefertigter Maschinenroutinen. Nur wenige dieser
Maschinenroutinen sind interner Teil der Sprache, die meisten liegen in den 4 Slots.

Die Sprache ist strikt imperativ. Es besteht eine direkte Eins-zu-Eins-Entsprechung zwischen dem Quelltext und
der Folge der Operationen im Bytecode. Es gibt im Quelltext keine arithmetischen oder logischen Ausdrücke.

Es gibt in dieser Sprache kein goto, kein break, kein continue, und in jedem Programm oder
Unterprogramm genau 1 return, nämlich am Ende des Programms oder Unterprogramms.

Die Strukturelemente sind folgende:

<pre>
Bedingte Anweisung: IF.c ... ENDF
Verzweigung: IF.c ... ELSE ... ENDE
Case-Struktur: CASE /nn ... NEXT /nn ... LAST
Do-while-Schleife: LOOP ... RP.c
While-Schleife: L.JP ... HERE ... RP.c
</pre>

c steht hier für die Sprungbedingung, nn steht für eine Zahl
fallend bis 00, NEXT /nn ist entsprechend mehrmals anzugeben. 
RP.c steht für wiederhole falls c.

Ebenso wie die Verzweigung zählt die Schleife mit Hineinsprung

<pre>
L.JP ... HERE ... RP.c
</pre>

als ein Block mit zwei Unterblöcken, die strenge Blockstruktur wird durch den Hineinsprung nicht durchbrochen.

Die Blockstruktur wird bei folgenden Operationen gebraucht:

<pre>
ACQU ... UACQ
FASN ... UFAS
BORR ... UBOR
BORX ... UBOR
</pre>

ACQU steht für Aquirieren von Residenten Variablen 
UACU macht das Aquirieren rückgängig

Residente Variable sind Variable, zB. vom Typ databox, welche ausserhalb des Programms dauerhaft im RAM
liegen. Sie sind über ihren Namen auffindbar und werden über ihre Nummer adressiert. ACQU bindet freie
Zeiger, welche im Programm vereinbart sind, an diese externen Variablen. Dadurch sind diese Variablen unter
Umgehung des Namens und der Nummer wie gewöhnliche im Programm vereinbarte Variable verfügbar.

FASN vergibt den Status "befestigt" an Variable vom Typ databox 
UFAS macht die Vergabe rückgängig.

Variable vom Typ databox, welche beim Start des Programms automatisch installiert werden
oder danach durch BORR/BORX installiert werden, sind von sich aus "befestigt". Das Installieren
kann aber auch durch Slot-Kommandos erfolgen, zB. wenn die Größe der databox
erst zur Laufzeit des Programms bekannt wird. Dann sind sie zunächst unbefestigt.

BORR leiht den von einer databox in RAM1 belegten Speicherplatz an mehrere Variable aus, welche vorher als
nicht installiert vereinbart wurden und nach dem Ausleihen den Speicherplatz der databox überdecken.

BORX leiht einen Teil des Speicherplatzes einer databox ab einem Startindex an mehrere Variable aus.

Im Haupt-RAM sind die mehreren Variablen kurze Variable vom Typ data, oder selber
wieder vom Typ databox, im Zusatz-RAM sind sie stets wieder vom Typ databox.

Beim Ausleihen aus einer databox prüft BORR/BORX, ob die databox befestigt ist. Andernfalls
wäre sie verschiebbar oder könnte uninstalliert werden, so dass Schreibzugriffe auf die
durch das Ausleihen erzeugten Variablen Unheil anrichten könnten.

UBOR macht das Ausleihen rückgängig.

Bei den Operationen ACQU, FASN, BORR/BORX garantiert der Compiler,
dass das zugehörige UACQ, UFAS, UBOR im selben Block liegt.
Die jeweilige Operation und das zugehörige Rückgängigmachen bilden selber wieder
einen Block, jedoch können mehrere BORR/BORX-UBOR-Blöcke einander überkreuzen.

'''Ergänzung zu Sprungbedingungen:'''

Es kann abgefragt werden, ob eine 1-oder 2-Byte-Variable
Null ist und ob sie gleich ff bzw. ffff ist.

Die Kommandos =TT.Z und =TT.M können diese Bedingungen
speichern in einem speziellen Byte im RAM, dem TF-Merker.
Dazu schieben sie eine 1 oder 0 von oben auf den TF-Merker.
In gleicher Weise können Steckkarten-Kommandos nCOMMAND
beliebige Bedingungen ermitteln und speichern.

Es gibt bedingte Sprünge, welche die obersten 3 Bit des
TF-Merker mittels einer Wahrheitstabelle abfragen. Dabei
können bis zu 3 Bits wieder vom TF-Merker entfernt werden.

Mittels der Routinen =PP.r, =PZ.r, =PM.r ist es möglich,
solche Bedingungen in einer 1- oder 2-Byte-Variablen zu
speichern, zu verANDen und zu verORen. Damit lassen
sich beliebig komplexe Sprungbedingungen berechnen.

'''Unterprogramme:'''

In der Programmiersprache gibt es keine functions mit
Rückgabewert, sondern nur einfache Unterprogramme, bei
welchen alle Parameter gleichberechtigt sind. Es werden
ausschließlich Zeiger übergeben.

'''Variablen vom Typ FIX:'''

Ihre Startwerte sind Teil des Programmcodes und liegen dort am Ende.
Der gesamte Speicherbereich dieser Werte kann als "FIXBOX" vom
Programm abgetrennt werden und dann mittels eines speziellen
Werkzeugs bearbeitet werden.

[[Kategorie:FPGA-Projekte]]

8bit-CPU: bo8

2026-01-12T19:03:17Z

Bome: Neues Register D

''Erst-Autor:'' [[Benutzer:Bome|''bome'']]

Die CPU ist Teil eines Gesamt-Projekts: [[8bit-Computer: bo8h]]. 
Dort findet sich auch eine erläuternde Beschreibung der CPU.

Beitrag im Forum: [http://www.mikrocontroller.net/topic/407050 Befehlssatz der bo8-CPU] 
Dort findet sich auch einiges zur Wortbedeutung der Mnemonics.

Im folgenden Text steht der Punkt in den Mnemonics für einen 
hier nicht darstellbaren auf der Grundlinie liegenden Bindestrich.

<pre>
================================================================

P Q R S X Y Z K D V Bezeichnung: A7 = U
| | | | | | | |A | ' AB = K
| | | | | | | |B

P Programmzähler Q Rückkehradresse
X Adressregister R Schleifenstartadresse
Y Adressregister S Schleifenzähler
Z Adressregister A Akku B Erweiterung D Data V Carry

----------------------------------------------------------------
a0 .. af Adressleitungen - Tristate
d0 .. d7 Datenleitungen - Tristate
N0 .. N3 Typleitungen - permanente Ausgänge
RES REP Reset Repeat - Eingänge
C0 C1 Takt Takt - Eingänge

0 1 2 3 0 1 2 3 0
/ / / / / / / / /
--==------==------==------==------==---- Cx
[ tA [ tB [ tA [ tB [
====----====----====----====----====---- C0
--====----====----====----====----====-- C1

An beiden Eingängen C0 C1 kann Cx anliegen
Cx kann auch symmetrisch sein (Tastgrad 50%)
Oder es können verschiedene Takte C0 C1 anliegen
C0 liefert die fallende und C1 die steigende Flanke

Die Halbzyklen tA und tB bilden einen Vollzyklus (tA/tB).

Typleitungen ändern ihren Zustand zu Zeitpunkten 0 und 2
Adressen und Write-Daten sind gültig von Zeitpunkt 0 bis 2
Einlesen von Read-Daten zum Zeitpunkt 2

Einlesen von REP zu jedem Zeitpunkt 2 (Mitte eines Vollzyklus)
REP bewirkt Anhängen eines (AR/BN) oder eines weiteren (AR/BN)

RES muss enden mit Zeitpunkt 0 bis rechtzeitig vor Zeitpunkt 1
Zum Zeitpunkt 2 Einlesen der Startadresse nach P und R vom
Adressbus und des Akku A vom Datenbus. Folgender Zeitpunkt 0
Start des Programmms mit (FE/BN) für ersten OpCode.

----------------------------------------------------------------
Typ Name Funktion

0/tB BN normal tB inaktiv
1/tA AR repeat tA inaktiv - wiederhole input
2/tA KA Adressbus gibt K aus - Datenbus inaktiv
3/tA HA Adressbus gibt K aus - input A

4/tB BP memory-page-Umschaltung für P
5/tB BX memory-page-Umschaltung für X
6/tB BY memory-page-Umschaltung für Y
7/tB BZ memory-page-Umschaltung für Z

8/tA FE read / Adresse ist P / OP-Code
9/tA WX write / Adresse ist X
a/tA WY write / Adresse ist Y
b/tA WZ write / Adresse ist Z

c/tA RP read / Adresse ist P
d/tA RX read / Adresse ist X
e/tA RY read / Adresse ist Y
f/tA RZ read / Adresse ist Z

----------------------------------------------------------------
+0 +1 +2 +3 +4 +5 +6 +7

00- H.. ST.S SS.X ST.X SS.Y ST.Y SS.Z ST.Z
08- IX0 IX1 IX2 IX3 IX4 IX5 IX6 IX7
10- IY0 IY1 IY2 IY3 IY4 IY5 IY6 IY7
18- IZ0 IZ1 IZ2 IZ3 IZ4 IZ5 IZ6 IZ7
20- ZO.S SL.S ZO.X SL.X ZO.Y SL.Y ZO.Z SL.Z
28- DX0 DX1 DX2 DX3 DX4 DX5 DX6 DX7
30- DY0 DY1 DY2 DY3 DY4 DY5 DY6 DY7
38- DZ0 DZ1 DZ2 DZ3 DZ4 DZ5 DZ6 DZ7
40- O.VZ O.VS B.VZ B.VS O.UZ O.US B.UZ B.US
48- O.AZ O.AS B.AZ B.AS O.KZ O.KS B.KZ B.KS
50- O.WY O.RP B.WY B.CN GTR ADR GTA NOL
58- IKL DKL IXL DXL IYL DYL IZL DZL
60- AD. LV. AV. SV. GT. AN. XR. NR.
68- STMX LVMX AVMX SVMX GTMX ANMX XRMX NRMX
70- STMY LVMY AVMY SVMY GTMY ANMY XRMY NRMY
78- STMZ LVMZ AVMZ SVMZ GTMZ ANMZ XRMZ NRMZ
80- NO2 TK1 TK2 TK3 TK4 TK5 TK6 TK7
88- TK8 TK9 TKa TKb TKc TKd TKe TKf
90- NO1 TA1 TA2 TA3 TA4 TA5 TA6 TA7
98- ST.B LV.B AV.B SV.B GT.B AN.B XR.B NR.B
a0- EX.S LV.S AV.S SV.S GT.S LD.S AD.S SD.S
a8- EX.X ES.X SW.X RS.X GT.X LD.X AD.X SD.X
b0- EX.Y ES.Y SW.Y RS.Y GT.Y LD.Y AD.Y SD.Y
b8- EX.Z ES.Z SW.Z RS.Z GT.Z LD.Z AD.Z SD.Z
c0- R.VZ R.VS R.UZ R.US R.AZ R.AS R.KZ R.KS
c8- R.WY R.CN R.IX R.DX R.IY R.DY R.IZ R.DZ
d0- GH.S GL.S GH.X GL.X GH.Y GL.Y GH.Z GL.Z
d8- IC.S DC.S IXE DXE IYE DYE IZE DZE
e0- ST.D CP.V NE.U NE.V ZO.U ZO.V SE.U SE.V
e8- PV.A TZ.A PV.B TZ.B RD.A RU.A RD.B RU.B
f0- ZO.D GT.D ZO.A NE.A IV.A DV.A SL.K S.RP
f8- IC.K DC.K ZO.K NE.K IC.A DC.A GT.Q J..

00 .. 3f 1 Byte
40 .. 67 2 Byte
68 .. ff 1 Byte

00 .. 3f 1 Zyklus / Sonderfall 00
40 .. 53 2|3 Zyklen
54 .. 7f 2 Zyklen / Sonderfall 57
80 .. ff 1 Zyklus / Sonderfall 80

Während der Ausführung eines Befehls
wird der nachfolgende OpCode geladen.

----------------------------------------------------------------
nn ist zweites Byte eines 2-Byte-Befehls , % ist X|Y|Z

AN.B A <= A and B
NR.B A <= A nor B
XR.B A <= A xor B
AV.B A <= A+B+V V <= Carry
SV.B A <= A-B-V V <= Carry
LV.B A <= B-A-V V <= Carry
GT.B A <= B
ST.B B <= A

AN. nn A <= A and nn
NR. nn A <= A nor nn
XR. nn A <= A xor nn
AV. nn A <= A+nn+V V <= Carry
SV. nn A <= A-nn-V V <= Carry
LV. nn A <= nn-A-V V <= Carry
GT. nn A <= nn
AD. nn A <= A+nn

ANM% A <= A and (%)
NRM% A <= A nor (%)
XRM% A <= A xor (%)
AVM% A <= A+(%)+V V <= Carry
SVM% A <= A-(%)-V V <= Carry
LVM% A <= (%)-A-V V <= Carry
GTM% A <= (%)
STM% (%) <= A

AV.S K <= K+S+V V <= Carry
SV.S K <= K-S-V V <= Carry
LV.S K <= S-K-V V <= Carry

AD.S K <= K+S
SD.S K <= K-S
LD.S K <= S-K

AD.% K <= K+%
SD.% K <= K-%
LD.% K <= %-K

GT.S K <= S
ST.S S <= K
GT.% K <= %
ST.% % <= K

RS.% S <= %
SS.% % <= S

SL.K B <= A , A <= 0

SL.S S LowByte <= A , S HighByte <= 0
SL.% % LowByte <= A , % HighByte <= 0

GL.S A <= LowByte von S
GH.S A <= HighByte von S
GL.% A <= LowByte von %
GH.% A <= HighByte von %

EX.S Austausch K <> S
EX.% Austausch K <> %
ES.% Austausch S <> %

ZO.S S <= 0
ZO.% % <= 0

ZO.V V <= 0
SE.V V <= 1
NE.V V <= not V
CP.V V <= V xor U

ZO.U U <= 0
SE.U U <= 1
NE.U U <= not U

NE.A A wird logisch negiert
NE.K K wird logisch negiert
ZO.A A <= 0
ZO.K K <= 0

ZO.D D <= 0
ST.D D <= A
GT.D A <= D

IV.A A <= A+V V <= Carry
DV.A A <= A-V V <= Carry

IC.A A <= A+1
IC.K K <= K+1
IC.S S <= S+1

DC.A A <= A-1
DC.K K <= K-1
DC.S S <= S-1

PV.A A <= 8-fache Kopie von V , V <= 0
PV.B B <= 8-fache Kopie von V , V <= 0

TZ.A wenn nicht A=0 dann ( V <= 1 )
TZ.B wenn nicht B=0 dann ( V <= 1 )

RD.A A wird nach unten durch V rotiert
Resultat V7654321 V <= Bit0
RD.B B wird nach unten durch V rotiert
Resultat V7654321 V <= Bit0

RU.A A wird nach oben durch V rotiert
Resultat 6543210V V <= Bit7
RU.B B wird nach oben durch V rotiert
Resultat 6543210V V <= Bit7

TAs mit s= 1..7 A wird s Bitstellen nach oben verdreht
Resultat von TA3 ist 43210765

TKs mit s= 1..f K wird s Bitstellen nach oben verdreht

I%s mit s= 0..7 % <= %+s+1
D%s mit s= 0..7 % <= %-s-1

I%E % <= %+1 , und Austausch A <> B
D%E % <= %-1 , und Austausch A <> B

IKL nn K <= K+nn
DKL nn K <= K-nn
I%L nn % <= %+nn+1
D%L nn % <= %-nn-1

GTA nn K <= 00nn
GTR nn K <= P+nn+3
ADR nn K <= K+P+nn+3

NO1 no operation 1 Zyklus
NO2 no operation 2 Zyklen

NOL nn no operation 2+nn Zyklen falls nn > 0
NOL 00 K <= R 2 Zyklen

GT.Q K <= Q

S.RP R <= P+1
O.RP nn R <= P+2 P <= P+nn+3

Bedingung cc ist WY always
VZ V ist 0
VS V ist nicht 0
UZ U ist 0
US U ist nicht 0
AZ A ist 0
AS A ist nicht 0
KZ K ist 0
KS K ist nicht 0

O.cc nn wenn cc dann ( P <= P+nn+3 )
B.cc nn wenn cc dann ( P <= P-nn-1 )
B.CN nn wenn nicht S=0 dann ( P <= P-nn-1 , S <= S-1 )

R.cc wenn cc dann ( P <= R )
R.CN wenn nicht S=0 dann ( P <= R , S <= S-1 )
R.I% wenn nicht S=0 dann ( P <= R , S <= S-1 , % <= %+1 )
R.D% wenn nicht S=0 dann ( P <= R , S <= S-1 , % <= %-1 )

Bei O.VZ, O.VS, B.VZ, B.VS, R.VZ, R.VS wird V <= 0

Alle O-,B- Operationen dauern 3 Zyklen | 2 Zyklen
wenn der Sprung erfolgt | nicht erfolgt

J.. P <= K , R <= K , Q <= P+1 , K <= P+1

SW.% Nach dem Einlesen des folgenden OpCodes mit FE wird
statt eines BN ein B% ausgegeben. Das soll extern
eine memory-page-Umschaltung für % bewirken. Das
Resultat muss schon beim folgenden tA bereitstehen.

H.. Nach dem Einlesen des folgenden OpCodes mit FE wird
statt eines BN ein BP ausgegeben. Das soll extern
eine memory-page-Umschaltung für P bewirken. Das
Resultat muss schon beim folgenden tA bereitstehen.

Wenn der eingelesene folgende OpCode ein J.. ist,
ist H.. damit beendet. Dauer von H.. ist 1 Zyklus.

Wenn der OpCode kein J.. ist, folgt ein IO-Zyklus
(HA/BP). Das BP soll die memory-page-Umschaltung
für P wieder aufheben. Dauer von H.. ist 2 Zyklen.

Ausnahme: Wenn der OpCode wieder ein H.. ist,
folgt (KA/BN) statt (HA/BP). Danach bleibt die
CPU im Zustand BN bis ein Reset erfolgt.

</pre>

[[Kategorie: FPGA-Projekte]]

Datei:Bo8h.zip

2025-09-12T23:46:24Z

Bome: Bome lud eine neue Version von Datei:Bo8h.zip hoch

Eine Alternative zur while-Schleife

2025-08-12T12:39:02Z

Bome: Schlüsselwörter

''Erst-Autor:'' [[Benutzer:Bome|''bome'']]

Wenn bei einer while-Schleife das Ermitteln der Abbruchbedingung sehr umfangreich ist, wird man diese Ermittlung in eine Funktion packen mit der Abbruchbedingung als Rückgabewert, und in der Schleife den Rückgabewert abfragen. Es sind jedoch auch Programmiersprachen denkbar, welche anstelle von Funktionen lediglich einfache Unterprogramme mit gleichberechtigten Parametern ohne expliziten Rückgabewert erlauben. Eine Alternative zur while-Schleife, die beliebig umfangreiches Ermitteln der Abbruchbedingung erlaubt, ohne dass man das Ermitteln in eine Funktion auslagern muss, wäre die '''do-while-Schleife mit Einsprung''', deren Schlüsselwörter hier '''do-jp''' und '''there''' und '''while''' heissen sollen. '''while''' springt zum Start des Schleifenkörpers. '''do-jp''' springt zur Marke '''there'''.

'''do-jp''' 
   Schleifenkörper 
'''there''' 
   Ermitteln der Abbruchbedingung mit Ergebnis x=0 
'''while''' x>0

Das ersetzt die while-Schleife 
'''while''' test>0 
   Schleifenkörper

mit der separat vereinbarten Funktion test 
'''function''' test 
   Ermitteln der Abbruchbedingung mit Ergebnis x=0 
'''return('''x''')'''

Beitrag im Forum 
[https://www.mikrocontroller.net/topic/347716 Gibt es eine Programmiersprache mit diesem Schleifentyp?]

[[Kategorie:Algorithmen und Arithmetik]]
[[Kategorie:Programmiersprachen]]

8bit-CPU: bo8

2025-08-11T18:43:13Z

Bome:

''Erst-Autor:'' [[Benutzer:Bome|''bome'']]

Die CPU ist Teil eines Gesamt-Projekts: [[8bit-Computer: bo8h]]. 
Dort findet sich auch eine erläuternde Beschreibung der CPU.

Beitrag im Forum: [http://www.mikrocontroller.net/topic/407050 Befehlssatz der bo8-CPU] 
Dort findet sich auch einiges zur Wortbedeutung der Mnemonics.

Im folgenden Text steht der Punkt in den Mnemonics für einen 
hier nicht darstellbaren auf der Grundlinie liegenden Bindestrich.

<pre>
================================================================

P Q R S X Y Z K V Bezeichnung: A7 = U
| | | | | | | |A AB = K
| | | | | | | |B

P Programmzähler Q Rückkehradresse
X Adressregister R Schleifenstartadresse
Y Adressregister S Schleifenzähler
Z Adressregister A Akku B Erweiterung V Carry

----------------------------------------------------------------
a0 .. af Adressleitungen - Tristate
d0 .. d7 Datenleitungen - Tristate
N0 .. N3 Typleitungen - permanente Ausgänge
RES REP Reset Repeat - Eingänge
C0 C1 Takt Takt - Eingänge

0 1 2 3 0 1 2 3 0
/ / / / / / / / /
--==------==------==------==------==---- Cx
[ tA [ tB [ tA [ tB [
====----====----====----====----====---- C0
--====----====----====----====----====-- C1

An beiden Eingängen C0 C1 kann Cx anliegen
Cx darf auch symmetrisch sein (Tastgrad 50%)
Oder es können verschiedene Takte C0 C1 anliegen
C0 liefert die fallende und C1 die steigende Flanke

Die Halbzyklen tA und tB bilden einen Vollzyklus (tA/tB).

Typleitungen ändern ihren Zustand zu Zeitpunkten 0 und 2
Adressen und Write-Daten sind gültig von Zeitpunkt 0 bis 2
Einlesen von Read-Daten zum Zeitpunkt 2

Einlesen von REP zu jedem Zeitpunkt 2 (Mitte eines Vollzyklus)
REP bewirkt Anhängen eines (AR/BN) oder eines weiteren (AR/BN)

RES muss enden mit Zeitpunkt 0 bis rechtzeitig vor Zeitpunkt 1
Zum Zeitpunkt 2 Einlesen der Startadresse nach P und R vom
Adressbus und des Akku A vom Datenbus. Folgender Zeitpunkt 0
Start des Programmms mit (FE/BN) für ersten OpCode.

----------------------------------------------------------------
Typ Name Funktion

0/tB BN normal tB inaktiv
1/tA AR repeat tA inaktiv - wiederhole input
2/tA KA Adressbus gibt K aus - Datenbus inaktiv
3/tA HA Adressbus gibt K aus - input A

4/tB BP memory-page-Umschaltung für P
5/tB BX memory-page-Umschaltung für X
6/tB BY memory-page-Umschaltung für Y
7/tB BZ memory-page-Umschaltung für Z

8/tA FE read / Adresse ist P / OP-Code
9/tA WX write / Adresse ist X
a/tA WY write / Adresse ist Y
b/tA WZ write / Adresse ist Z

c/tA RP read / Adresse ist P
d/tA RX read / Adresse ist X
e/tA RY read / Adresse ist Y
f/tA RZ read / Adresse ist Z

----------------------------------------------------------------
+0 +1 +2 +3 +4 +5 +6 +7

00- H.. ST.S SS.X ST.X SS.Y ST.Y SS.Z ST.Z
08- IX0 IX1 IX2 IX3 IX4 IX5 IX6 IX7
10- IY0 IY1 IY2 IY3 IY4 IY5 IY6 IY7
18- IZ0 IZ1 IZ2 IZ3 IZ4 IZ5 IZ6 IZ7
20- ZO.S SL.S ZO.X SL.X ZO.Y SL.Y ZO.Z SL.Z
28- DX0 DX1 DX2 DX3 DX4 DX5 DX6 DX7
30- DY0 DY1 DY2 DY3 DY4 DY5 DY6 DY7
38- DZ0 DZ1 DZ2 DZ3 DZ4 DZ5 DZ6 DZ7
40- O.VZ O.VS B.VZ B.VS O.UZ O.US B.UZ B.US
48- O.AZ O.AS B.AZ B.AS O.KZ O.KS B.KZ B.KS
50- O.WY O.RP B.WY B.CN GTR ADR GTA NOL
58- IKL DKL IXL DXL IYL DYL IZL DZL
60- AD. LV. AV. SV. GT. AN. XR. NR.
68- STMX LVMX AVMX SVMX GTMX ANMX XRMX NRMX
70- STMY LVMY AVMY SVMY GTMY ANMY XRMY NRMY
78- STMZ LVMZ AVMZ SVMZ GTMZ ANMZ XRMZ NRMZ
80- NO2 TK1 TK2 TK3 TK4 TK5 TK6 TK7
88- TK8 TK9 TKa TKb TKc TKd TKe TKf
90- NO1 TA1 TA2 TA3 TA4 TA5 TA6 TA7
98- ST.B LV.B AV.B SV.B GT.B AN.B XR.B NR.B
a0- EX.S LV.S AV.S SV.S GT.S LD.S AD.S SD.S
a8- EX.X ES.X SW.X RS.X GT.X LD.X AD.X SD.X
b0- EX.Y ES.Y SW.Y RS.Y GT.Y LD.Y AD.Y SD.Y
b8- EX.Z ES.Z SW.Z RS.Z GT.Z LD.Z AD.Z SD.Z
c0- R.VZ R.VS R.UZ R.US R.AZ R.AS R.KZ R.KS
c8- R.WY R.CN R.IX R.DX R.IY R.DY R.IZ R.DZ
d0- GH.S GL.S GH.X GL.X GH.Y GL.Y GH.Z GL.Z
d8- IC.S DC.S IXE DXE IYE DYE IZE DZE
e0- ZO.U SE.U ZO.V SE.V CP.U NE.U CP.V NE.V
e8- PV.A TZ.A PV.B TZ.B RD.A RU.A RD.B RU.B
f0- ZO.A NE.A ZO.B NE.B IV.A DV.A SL.K S.RP
f8- IC.K DC.K ZO.K NE.K IC.A DC.A GT.Q J..

00 .. 3f 1 Byte
40 .. 67 2 Byte
68 .. ff 1 Byte

00 .. 3f 1 Zyklus / Sonderfall 00
40 .. 53 2|3 Zyklen
54 .. 7f 2 Zyklen / Sonderfall 57
80 .. ff 1 Zyklus / Sonderfall 80

Während der Ausführung eines Befehls
wird der nachfolgende OpCode geladen.

----------------------------------------------------------------
nn ist zweites Byte eines 2-Byte-Befehls , % ist X|Y|Z

AN.B A <= A and B
NR.B A <= A nor B
XR.B A <= A xor B
AV.B A <= A+B+V V <= Carry
SV.B A <= A-B-V V <= Carry
LV.B A <= B-A-V V <= Carry
GT.B A <= B
ST.B B <= A

AN. nn A <= A and nn
NR. nn A <= A nor nn
XR. nn A <= A xor nn
AV. nn A <= A+nn+V V <= Carry
SV. nn A <= A-nn-V V <= Carry
LV. nn A <= nn-A-V V <= Carry
GT. nn A <= nn
AD. nn A <= A+nn

ANM% A <= A and (%)
NRM% A <= A nor (%)
XRM% A <= A xor (%)
AVM% A <= A+(%)+V V <= Carry
SVM% A <= A-(%)-V V <= Carry
LVM% A <= (%)-A-V V <= Carry
GTM% A <= (%)
STM% (%) <= A

AV.S K <= K+S+V V <= Carry
SV.S K <= K-S-V V <= Carry
LV.S K <= S-K-V V <= Carry

AD.S K <= K+S
SD.S K <= K-S
LD.S K <= S-K

AD.% K <= K+%
SD.% K <= K-%
LD.% K <= %-K

GT.S K <= S
ST.S S <= K
GT.% K <= %
ST.% % <= K

RS.% S <= %
SS.% % <= S

SL.K B <= A , A <= 0

SL.S S LowByte <= A , S HighByte <= 0
SL.% % LowByte <= A , % HighByte <= 0

GL.S A <= LowByte von S
GH.S A <= HighByte von S
GL.% A <= LowByte von %
GH.% A <= HighByte von %

EX.S Austausch K <> S
EX.% Austausch K <> %
ES.% Austausch S <> %

ZO.S S <= 0
ZO.% % <= 0

ZO.V V <= 0
SE.V V <= 1
NE.V V <= not V
CP.V V <= V xor U

ZO.U U <= 0
SE.U U <= 1
NE.U U <= not U
CP.U U <= V xor U

NE.A A wird logisch negiert
NE.B B wird logisch negiert
NE.K K wird logisch negiert

ZO.A A <= 0
ZO.B B <= 0
ZO.K K <= 0

IV.A A <= A+V V <= Carry
DV.A A <= A-V V <= Carry

IC.A A <= A+1
IC.K K <= K+1
IC.S S <= S+1

DC.A A <= A-1
DC.K K <= K-1
DC.S S <= S-1

PV.A A <= 8-fache Kopie von V , V <= 0
PV.B B <= 8-fache Kopie von V , V <= 0

TZ.A wenn nicht A=0 dann ( V <= 1 )
TZ.B wenn nicht B=0 dann ( V <= 1 )

RD.A A wird nach unten durch V rotiert
Resultat V7654321 V <= Bit0
RD.B B wird nach unten durch V rotiert
Resultat V7654321 V <= Bit0

RU.A A wird nach oben durch V rotiert
Resultat 6543210V V <= Bit7
RU.B B wird nach oben durch V rotiert
Resultat 6543210V V <= Bit7

TAs mit s= 1..7 A wird s Bitstellen nach oben verdreht
Resultat von TA3 ist 43210765

TKs mit s= 1..f K wird s Bitstellen nach oben verdreht

I%s mit s= 0..7 % <= %+s+1
D%s mit s= 0..7 % <= %-s-1

I%E % <= %+1 , und Austausch A <> B
D%E % <= %-1 , und Austausch A <> B

IKL nn K <= K+nn+1
DKL nn K <= K-nn-1
I%L nn % <= %+nn+1
D%L nn % <= %-nn-1

GTA nn K <= 00nn
GTR nn K <= P+nn+3
ADR nn K <= K+P+nn+3

NO1 no operation 1 Zyklus
NO2 no operation 2 Zyklen

NOL nn no operation 2+nn Zyklen falls nn > 0
NOL 00 K <= R 2 Zyklen

GT.Q K <= Q

S.RP R <= P+1
O.RP nn R <= P+2 , P <= P+nn+3

Bedingung cc ist WY always
VZ V ist 0
VS V ist nicht 0
UZ U ist 0
US U ist nicht 0
AZ A ist 0
AS A ist nicht 0
KZ K ist 0
KS K ist nicht 0

O.cc nn wenn cc dann ( P <= P+nn+3 )
B.cc nn wenn cc dann ( P <= P-nn-1 )
B.CN nn wenn nicht S=0 dann ( P <= P-nn-1 , S <= S-1 )

R.cc wenn cc dann ( P <= R )
R.CN wenn nicht S=0 dann ( P <= R , S <= S-1 )
R.I% wenn nicht S=0 dann ( P <= R , S <= S-1 , % <= %+1 )
R.D% wenn nicht S=0 dann ( P <= R , S <= S-1 , % <= %-1 )

Bei O.VZ, O.VS, B.VZ, B.VS, R.VZ, R.VS wird V <= 0

Alle O-,B- Operationen dauern 3 Zyklen | 2 Zyklen
wenn der Sprung erfolgt | nicht erfolgt

J.. P <= K , R <= K , Q <= P+1 , K <= P+1

SW.% Nach dem Einlesen des folgenden OpCodes mit FE wird
statt eines BN ein B% ausgegeben. Das soll extern
eine memory-page-Umschaltung für % bewirken. Das
Resultat muss schon beim folgenden tA bereitstehen.

H.. Nach dem Einlesen des folgenden OpCodes mit FE wird
statt eines BN ein BP ausgegeben. Das soll extern
eine memory-page-Umschaltung für P bewirken. Das
Resultat muss schon beim folgenden tA bereitstehen.

Wenn der eingelesene folgende OpCode ein J.. ist,
ist H.. damit beendet. Dauer von H.. ist 1 Zyklus.

Wenn der OpCode kein J.. ist, folgt ein IO-Zyklus
(HA/BP). Das BP soll die memory-page-Umschaltung
für P wieder aufheben. Dauer von H.. ist 2 Zyklen.

Ausnahme: Wenn der OpCode wieder ein H.. ist,
folgt (KA/BN) statt (HA/BP). Danach bleibt die
CPU im Zustand BN bis ein Reset erfolgt.

</pre>

[[Kategorie: FPGA-Projekte]]

8bit-Computer: bo8h

2025-08-11T18:41:49Z

Bome:

''Erst-Autor:'' [[Benutzer:Bome|''bome'']]

=Übersicht=

Der 8bit-Rechner bo8h existiert bisher nur als Prototyp-Gerät
auf folgenden FPGA-Boards:
* '''Spartan-3A Starter Kit''' von Xilinx
* '''Spartan-3E Starter Board''' und
* '''Nexys2 Board''' von Digilent
* '''Terasic DE0 Board'''
* '''Terasic DE0-CV Board'''
* '''Terasic DE0-nano Board'''
* '''Terasic DE10-Lite Board'''
* '''Terasic Cyclone V GX Starterkit'''

Die Realisierung auf dem Spartan-3A Starter Kit funktioniert auch auf dem ''Spartan-3AN Starter Kit''. 
Das Spartan-3E Starter Board von Digilent ist baugleich mit dem Spartan-3E Starter Kit von Xilinx.

Die '''CPU bo8''' ist eine Eigenentwicklung und hat keine Interrupts. Merkmale des Gesamtsystems
sind der aus mehreren 64KByte-Seiten bestehende Adressraum, das Steckplatz-Konzept,
eine an die Hardware angepasste Programmiersprache und taktgenau berechenbare Programmlaufzeiten.
Der Zeichensatz beinhaltet neben Buchstaben und Sonderzeichen einen Satz von sechzehn Ziffern,
wobei die Ziffern A bis F durch modifizierte Buchstaben dargestellt werden.

Das Prototyp-Gerät besitzt Bildschirm und Tastatur, nutzt [[RS232]] zum Daten-Austausch mit PC
und hat eine SD-Karte mit selbstgestricktem Dateisystem.
Der [[VHDL]]-Code ist so geschrieben, dass leicht weitere Schnittstellen eingebaut werden können.

* Informationen und Downloads gibt es auf [https://bo8h.de/Home/ bo8h.de].
* Kopie des Download-Files von bo8h.de: [[Datei:Bo8h.zip]]
* Wiki-Artikel zur CPU: [[8bit-CPU: bo8]].
* Beitrag im '''Forum''' Projekte & Code: [http://www.mikrocontroller.net/topic/297603 8bit-Computing mit FPGA].
* Im ''embedded-projects-Journal 14''  gab es einen Artikel ''Ein 8bit-Rechner auf dem Spartan-3A-Starterkit''.

Das Prototyp-Gerät hat 4 freie virtuelle Steckplätze mit je 64KByte, wobei je 32KByte
für Software vorgesehen sind. Damit haben Software-Entwickler die Möglichkeit,
Steckkarten-Software in Eigen-Regie anzubieten. Zur Software-Entwicklung
auf PC gibt es einen in C geschriebenen Assembler und ein Emulations-Programm.

=Die CPU=

''Der Punkt in den Mnemonics steht für einen auf der Grundlinie liegenden Bindestrich.''

Der Akku '''A''' und das Erweiterungsregister '''B''' sind 8-bit. 
Das Doppelregister AB wird abkürzend mit '''K''' bezeichnet. 
Das Vorzeichenbit A7 wird abkürzend mit '''U''' bezeichnet.

Der Programmzähler '''P''' und die Adressregister '''X''', '''Y''', '''Z''' sind 16-bit. 
Das Register '''Q''' erhält bei Sprüngen die Rückkehradresse P+1. 
'''R''' ist Schleifen-Startadresse, '''S''' ist Schleifenzähler (16-bit).

Einziges Flag ist der Carry '''V'''. Bei bedingten Sprüngen kann ausserdem abgefragt werden, ob U/A/K Null sind.

Alle Speicherzugriffe sind 8bit-Zugriffe. 
GTMX lädt nach A den Inhalt der Speicherzelle, auf welche X zeigt. 
STMX speichert A in der Speicherzelle, auf welche X zeigt.

IXE inkrementiert X und tauscht A und B. 
DXE dekrementiert X und tauscht A und B.

Damit lassen sich 2-byte-Speicherzugriffe aufbauen 
nach dem Muster GTMX..IXE..GTMX und STMX..DXE..STMX. 
Es gibt hierfür die Assembler-Makros GTMXI und STMXD.

<pre>
GTMXI lädt eine Adresse von Position X
ST.Y überträgt die Adresse nach Y

GTMXI lädt eine Adresse von Position X
AD.X addiert X
ST.Y überträgt die zu X relative Adresse nach Y

J.. Sprung zu der Adresse, welche in K steht

GTA 59 lädt den Wert 0059 nach K
AD. 35 addiert 35 zu A
J.. Sprung nach 3559

Das lässt sich kürzer schreiben mit Assembler-Makro
/GTA 3559
J

GTR 59 lädt den Wert P+0059+3 nach K
AD. 35 addiert 35 zu A
J.. relativer Sprung nach P+3559+3

Das lässt sich kürzer schreiben mit Assembler-Makro
/GTR 3559
J

GT.Q lädt Rückkehradresse nach K
J Rücksprung aus Unterprogramm
</pre>

Wenn ein Unterprogramm selber J.. ausführen will für andere Zwecke als für den Rücksprung,
muss es vorher die Rückkehradresse sichern. Dazu kann es die Rückkehradresse aus Q laden,
anfangs steht sie aber auch in K und das Laden kann entfallen.

Ausser dem Sprungbefehl J.. gibt es die bedingten Sprünge mit 8bit-Sprungdistanz: 
O.cc nn (Vorwärtssprung falls cc) und B.cc nn (Rückwärtssprung falls cc).

Für schnelle Schleifen gibt es die Repeat-Befehle R.cc. 
Repeat-Befehle gibt es kombiniert mit Schleifenzähler-Dekrementieren und Adresse-Inkrementieren/Dekrementieren.
Die Schleifenstartadresse R wird gesetzt vor dem Schleifenanfang mittels S.RP oder mittels O.RP nn.
Bei letzterem wird gleichzeitig ein Vorwärtssprung ausgeführt. Damit sind Schleifen mit Hineinsprung (while-Schleifen) realisierbar.

Bei J.. wird die Zieladresse auch nach R übertragen. Das garantiert, dass R stets eine Adresse im Nahbereich
des Programmzählers enthält. Eine Anwendung hiervon ergibt sich beim Sprung in eine Tabelle, welche aus
O.WY nn -Befehlen (Vorwärtssprung always) besteht, wobei die O.WY nn alle zur
selben Adresse springen. Die dortige Routine kann durch Auswertung von R die Nummer des O.WY-Befehls ermitteln.

'''Adressierung mehrerer 64K-Seiten:'''

Zu jeder auf dem Adressbus ausgegebenen Adresse wird auf den Steuerleitungen angezeigt, von welchem der
Adressregister P, X, Y, Z sie kommt. Dadurch kann eine externe Logik jedem der Adressregister eine eigene
64K-Speicherseite zuordnen. Die CPU kann spezielle Steuersignale ausgeben, welche die externe Logik
zur Memory-Page-Umschaltung für eines der Adressregister veranlassen sollen.

Der Befehl H.. ist der einzige und universell einsetzbare IO-Befehl.
Es wird K auf dem Adressbus ausgegeben und der Datenbus nach A eingelesen.

Wenn auf H.. ein J.. folgt, dann wirkt H.. stattdessen als Präfix und bewirkt,
dass J.. mit einer Memory-Page-Umschaltung kombiniert wird. So kann die CPU von einer
64K-Seite in eine andere springen, ohne dass es einen gemeinsamen Speicherbereich geben muss.

Bei den Adressregistern X, Y, Z gibt es spezielle Befehle SW.X, SW.Y, SW.Z für die Memory-Page-Umschaltung.

=Die Gesamt-Hardware=

Es gibt vier Memory-Pages mit je 64KByte:

* Page 0: Aktiver Steckplatz
* Page 1: ROM (32K), Text-RAM (16K), Video-RAM (16K)
* Page 2: Haupt-RAM
* Page 3: Zusatz-RAM

Der aktive Steckplatz in Page 0 wird durch ein 3bit-Register SLT ausgewählt.
Neben Page 0 wird auch IO-Adressraum zugeteilt.
Die Steckkarten sollten ein Software-ROM und IO-Hardware enthalten.

Es gibt die 2bit-Register MP, MX, MY, MZ. Diese Register legen fest, in welche der vier Memory-Pages
das betreffende Adressregister P, X, Y, Z zeigt. Ausserdem gibt es die Schattenregister NP, NX, NY, NZ.
Das CPU-Signal zur Memory-Page-Umschaltung für ein bestimmtes Adressregister # bewirkt den
Austausch von M# und N#, wobei # hier für P, X, Y, Z steht.
Beim Sprung mit Memory-Page-Umschaltung  H..  J..  werden also MP und NP getauscht.
Die Schattenregister NP, NX, NY, NZ können über IO-Befehle H.. mit einem Wert 0 bis 3 geladen werden.

Das Display ist 512 Pixel breit und 256 Pixel hoch, die Pixel sind zweiwertig.
Der Video-Generator liest in Dauerschleife das Video-RAM und erzeugt daraus die VGA-Signale.
Einen Hardware-Zeichengenerator gibt es nicht.
Die Software liest die Zeichen aus dem Text-RAM und schreibt deren Pixelmuster ins Video-RAM.
Die Textzeilen sind 64 Zeichen breit.
Durch Invertierung eines Flipflops können Text-RAM und Video-RAM ihre Rollen tauschen.
So kann die CPU im Text-RAM eine neue Grafik erstellen, während noch das alte Video-RAM angezeigt wird.

=Die Programmiersprache=

Der Compiler erzeugt einen Zwischencode, welcher interpretativ abgearbeitet wird. Der
Zwischencode besteht aus Aufrufen vorgefertigter Maschinenroutinen. Nur wenige dieser
Maschinenroutinen sind interner Teil der Sprache, die meisten liegen in den 8 Steckkarten.

Die Sprache ist strikt imperativ. Es besteht eine direkte Eins-zu-Eins-Entsprechung zwischen dem Quelltext und
der Folge der Operationen im Zwischencode. Es gibt im Quelltext keine arithmetischen oder logischen Ausdrücke.

Es gibt in dieser Sprache kein goto, kein break, kein continue, und in jedem Programm oder
Unterprogramm genau 1 return, nämlich am Ende des Programms oder Unterprogramms.

Die Strukturelemente sind folgende:

<pre>
Bedingte Anweisung: IF.c ... ENDF
Verzweigung: IF.c ... ELSE ... ENDE
Case-Struktur: CASE /nn ... NEXT /nn ... LAST
Do-while-Schleife: LOOP ... RP.c
While-Schleife: L.JP ... HERE ... RP.c
</pre>

c steht hier für die Sprungbedingung, nn steht für eine Zahl
fallend bis 00, NEXT /nn ist entsprechend mehrmals anzugeben. 
RP.c steht für wiederhole falls c.

Ebenso wie die Verzweigung zählt die Schleife mit Hineinsprung

<pre>
L.JP ... HERE ... RP.c
</pre>

als ein Block mit zwei Unterblöcken, die strenge Blockstruktur wird durch den Hineinsprung nicht durchbrochen.

Die Blockstruktur wird bei folgenden Operationen gebraucht:

<pre>
ACQU ... UACQ
FASN ... UFAS
LN.1 ... RELS // LN.2 ... RELS
LX.1 ... RELS // LX.2 ... RELS
</pre>

ACQU steht für Aquirieren von Residenten Variablen 
UACU macht das Aquirieren rückgängig

Residente Variable sind Variable, zB. vom Typ databox, welche ausserhalb des Programms dauerhaft im RAM
liegen. Sie sind über ihren Namen auffindbar und werden über ihre Nummer adressiert. ACQU bindet freie
Zeiger, welche im Programm vereinbart sind, an diese externen Variablen. Dadurch sind diese Variablen unter
Umgehung des Namens und der Nummer wie gewöhnliche im Programm vereinbarte Variable verfügbar.

FASN vergibt den Status "befestigt" an Variable vom Typ databox 
UFAS macht die Vergabe rückgängig.

Variable vom Typ databox, welche beim Start des Programms automatisch installiert werden
oder danach durch LN/LX installiert werden, sind von sich aus "befestigt". Das Installieren
kann aber auch durch Steckkarten-Kommandos erfolgen, zB. wenn die Größe der databox
erst zur Laufzeit des Programms bekannt wird. Dann sind sie zunächst unbefestigt.

LN.1 leiht den von einer databox in RAM1 belegten Speicherplatz an mehrere Variable aus, welche vorher als
nicht installiert vereinbart wurden und nach dem Ausleihen den Speicherplatz der databox überdecken.

LX.1 leiht einen Teil des Speicherplatzes einer databox ab einem Startindex an mehrere Variable aus.

Entsprechend LN.2 und LX.2 für RAM2. In RAM1 sind die mehreren
Variablen kurze Variable vom Typ data, oder selber wieder vom
Typ databox, in RAM2 sind sie stets wieder vom Typ databox.

Beim Ausleihen aus einer databox prüft LN/LX, ob die databox befestigt ist. Andernfalls
wäre sie verschiebbar oder könnte uninstalliert werden, so dass Schreibzugriffe auf die
durch das Ausleihen erzeugten Variablen Unheil anrichten könnten.

RELS macht das Ausleihen rückgängig.

Bei den Operationen ACQU, FASN, LN/LX garantiert der Compiler,
dass das zugehörige UACQ, UFAS, RELS im selben Block liegt.
Die jeweilige Operation und das zugehörige Rückgängigmachen
bilden selber wieder einen Block.

'''Ergänzung zu Sprungbedingungen:'''

Es kann abgefragt werden, ob eine 1-oder 2-Byte-Variable
Null ist und ob sie gleich ff bzw. ffff ist.

Die Kommandos =TT.Z und =TT.M können diese Bedingungen
speichern in einem speziellen Byte im RAM, dem TF-Merker.
Dazu schieben sie eine 1 oder 0 von oben auf den TF-Merker.
In gleicher Weise können Steckkarten-Kommandos nCOMMAND
beliebige Bedingungen ermitteln und speichern.

Es gibt bedingte Sprünge, welche die obersten 3 Bit des
TF-Merker mittels einer Wahrheitstabelle abfragen. Dabei
können bis zu 3 Bits wieder vom TF-Merker entfernt werden.

Mittels der Routinen =PP.r, =PZ.r, =PM.r ist es möglich,
solche Bedingungen in einer 1- oder 2-Byte-Variablen zu
speichern, zu verANDen und zu verORen. Damit lassen
sich beliebig komplexe Sprungbedingungen berechnen.

'''Unterprogramme:'''

In der Programmiersprache gibt es keine functions mit
Rückgabewert, sondern nur einfache Unterprogramme, bei
welchen alle Parameter gleichberechtigt sind. Es werden
ausschließlich Zeiger übergeben.

'''Variablen vom Typ FIX:'''

Ihre Werte sind Teil des Programmcodes und liegen dort am Ende.
Der gesamte Speicherbereich dieser Werte kann als "FIXBOX" vom
Programm abgetrennt werden und dann mittels eines speziellen
Werkzeugs bearbeitet werden.

[[Kategorie:FPGA-Projekte]]

8bit-Computer: bo8h

2025-08-11T00:46:33Z

Bome:

''Erst-Autor:'' [[Benutzer:Bome|bome]]

=Übersicht=

Der 8bit-Rechner bo8h existiert bisher nur als Prototyp-Gerät
auf folgenden FPGA-Boards:
* '''Spartan-3A Starter Kit''' von Xilinx
* '''Spartan-3E Starter Board''' und
* '''Nexys2 Board''' von Digilent
* '''Terasic DE0 Board'''
* '''Terasic DE0-CV Board'''
* '''Terasic DE0-nano Board'''
* '''Terasic DE10-Lite Board'''
* '''Terasic Cyclone V GX Starterkit'''

Die Realisierung auf dem Spartan-3A Starter Kit funktioniert auch auf dem ''Spartan-3AN Starter Kit''. 
Das Spartan-3E Starter Board von Digilent ist baugleich mit dem Spartan-3E Starter Kit von Xilinx.

Die '''CPU bo8''' ist eine Eigenentwicklung und hat keine Interrupts. Merkmale des Gesamtsystems
sind der aus mehreren 64KByte-Seiten bestehende Adressraum, das Steckplatz-Konzept,
eine an die Hardware angepasste Programmiersprache und taktgenau berechenbare Programmlaufzeiten.
Der Zeichensatz beinhaltet neben Buchstaben und Sonderzeichen einen Satz von sechzehn Ziffern,
wobei die Ziffern A bis F durch modifizierte Buchstaben dargestellt werden.

Das Prototyp-Gerät besitzt Bildschirm und Tastatur, nutzt [[RS232]] zum Daten-Austausch mit PC
und hat eine SD-Karte mit selbstgestricktem Dateisystem.
Der [[VHDL]]-Code ist so geschrieben, dass leicht weitere Schnittstellen eingebaut werden können.

* Informationen und Downloads gibt es auf [https://bo8h.de/Home/ bo8h.de].
* Kopie des Download-Files von bo8h.de: [[Datei:Bo8h.zip]]
* Wiki-Artikel zur CPU: [[8bit-CPU: bo8]].
* Beitrag im '''Forum''' Projekte & Code: [http://www.mikrocontroller.net/topic/297603 8bit-Computing mit FPGA].
* Im ''embedded-projects-Journal 14''  gab es einen Artikel ''Ein 8bit-Rechner auf dem Spartan-3A-Starterkit''.

Das Prototyp-Gerät hat 4 freie virtuelle Steckplätze mit je 64KByte, wobei je 32KByte
für Software vorgesehen sind. Damit haben Software-Entwickler die Möglichkeit,
Steckkarten-Software in Eigen-Regie anzubieten. Zur Software-Entwicklung
auf PC gibt es einen in C geschriebenen Assembler und ein Emulations-Programm.

=Die CPU=

''Der Punkt in den Mnemonics steht für einen auf der Grundlinie liegenden Bindestrich.''

Der Akku '''A''' und das Erweiterungsregister '''B''' sind 8-bit. 
Das Doppelregister AB wird abkürzend mit '''K''' bezeichnet. 
Das Vorzeichenbit A7 wird abkürzend mit '''U''' bezeichnet.

Der Programmzähler '''P''' und die Adressregister '''X''', '''Y''', '''Z''' sind 16-bit. 
Das Register '''Q''' erhält bei Sprüngen die Rückkehradresse P+1. 
'''R''' ist Schleifen-Startadresse, '''S''' ist Schleifenzähler (16-bit).

Einziges Flag ist der Carry '''V'''. Bei bedingten Sprüngen kann ausserdem abgefragt werden, ob U/A/K Null sind.

Alle Speicherzugriffe sind 8bit-Zugriffe. 
GTMX lädt nach A den Inhalt der Speicherzelle, auf welche X zeigt. 
STMX speichert A in der Speicherzelle, auf welche X zeigt.

IXE inkrementiert X und tauscht A und B. 
DXE dekrementiert X und tauscht A und B.

Damit lassen sich 2-byte-Speicherzugriffe aufbauen 
nach dem Muster GTMX..IXE..GTMX und STMX..DXE..STMX. 
Es gibt hierfür die Assembler-Makros GTMXI und STMXD.

<pre>
GTMXI lädt eine Adresse von Position X
ST.Y überträgt die Adresse nach Y

GTMXI lädt eine Adresse von Position X
AD.X addiert X
ST.Y überträgt die zu X relative Adresse nach Y

J.. Sprung zu der Adresse, welche in K steht

GTA 59 lädt den Wert 0059 nach K
AD. 35 addiert 35 zu A
J.. Sprung nach 3559

Das lässt sich kürzer schreiben mit Assembler-Makro
/GTA 3559
J

GTR 59 lädt den Wert P+0059+3 nach K
AD. 35 addiert 35 zu A
J.. relativer Sprung nach P+3559+3

Das lässt sich kürzer schreiben mit Assembler-Makro
/GTR 3559
J

GT.Q lädt Rückkehradresse nach K
J Rücksprung aus Unterprogramm
</pre>

Wenn ein Unterprogramm selber J.. ausführen will für andere Zwecke als für den Rücksprung,
muss es vorher die Rückkehradresse sichern. Dazu kann es die Rückkehradresse aus Q laden,
anfangs steht sie aber auch in K und das Laden kann entfallen.

Ausser dem Sprungbefehl J.. gibt es die bedingten Sprünge mit 8bit-Sprungdistanz: 
O.cc nn (Vorwärtssprung falls cc) und B.cc nn (Rückwärtssprung falls cc).

Für schnelle Schleifen gibt es die Repeat-Befehle R.cc. 
Repeat-Befehle gibt es kombiniert mit Schleifenzähler-Dekrementieren und Adresse-Inkrementieren/Dekrementieren.
Die Schleifenstartadresse R wird gesetzt vor dem Schleifenanfang mittels S.RP oder mittels O.RP nn.
Bei letzterem wird gleichzeitig ein Vorwärtssprung ausgeführt. Damit sind Schleifen mit Hineinsprung (while-Schleifen) realisierbar.

Bei J.. wird die Zieladresse auch nach R übertragen. Das garantiert, dass R stets eine Adresse im Nahbereich
des Programmzählers enthält. Eine Anwendung hiervon ergibt sich beim Sprung in eine Tabelle, welche aus
O.WY nn -Befehlen (Vorwärtssprung always) besteht, wobei die O.WY nn alle zur
selben Adresse springen. Die dortige Routine kann durch Auswertung von R die Nummer des O.WY-Befehls ermitteln.

'''Adressierung mehrerer 64K-Seiten:'''

Zu jeder auf dem Adressbus ausgegebenen Adresse wird auf den Steuerleitungen angezeigt, von welchem der
Adressregister P, X, Y, Z sie kommt. Dadurch kann eine externe Logik jedem der Adressregister eine eigene
64K-Speicherseite zuordnen. Die CPU kann spezielle Steuersignale ausgeben, welche die externe Logik
zur Memory-Page-Umschaltung für eines der Adressregister veranlassen sollen.

Der Befehl H.. ist der einzige und universell einsetzbare IO-Befehl.
Es wird K auf dem Adressbus ausgegeben und der Datenbus nach A eingelesen.

Wenn auf H.. ein J.. folgt, dann wirkt H.. stattdessen als Präfix und bewirkt,
dass J.. mit einer Memory-Page-Umschaltung kombiniert wird. So kann die CPU von einer
64K-Seite in eine andere springen, ohne dass es einen gemeinsamen Speicherbereich geben muss.

Bei den Adressregistern X, Y, Z gibt es spezielle Befehle SW.X, SW.Y, SW.Z für die Memory-Page-Umschaltung.

=Die Gesamt-Hardware=

Es gibt vier Memory-Pages mit je 64KByte:

* Page 0: Aktiver Steckplatz
* Page 1: ROM (32K), Text-RAM (16K), Video-RAM (16K)
* Page 2: Haupt-RAM
* Page 3: Zusatz-RAM

Der aktive Steckplatz in Page 0 wird durch ein 3bit-Register SLT ausgewählt.
Neben Page 0 wird auch IO-Adressraum zugeteilt.
Die Steckkarten sollten ein Software-ROM und IO-Hardware enthalten.

Es gibt die 2bit-Register MP, MX, MY, MZ. Diese Register legen fest, in welche der vier Memory-Pages
das betreffende Adressregister P, X, Y, Z zeigt. Ausserdem gibt es die Schattenregister NP, NX, NY, NZ.
Das CPU-Signal zur Memory-Page-Umschaltung für ein bestimmtes Adressregister # bewirkt den
Austausch von M# und N#, wobei # hier für P, X, Y, Z steht.
Beim Sprung mit Memory-Page-Umschaltung  H..  J..  werden also MP und NP getauscht.
Die Schattenregister NP, NX, NY, NZ können über IO-Befehle H.. mit einem Wert 0 bis 3 geladen werden.

Das Display ist 512 Pixel breit und 256 Pixel hoch, die Pixel sind zweiwertig.
Der Video-Generator liest in Dauerschleife das Video-RAM und erzeugt daraus die VGA-Signale.
Einen Hardware-Zeichengenerator gibt es nicht.
Die Software liest die Zeichen aus dem Text-RAM und schreibt deren Pixelmuster ins Video-RAM.
Die Textzeilen sind 64 Zeichen breit.
Durch Invertierung eines Flipflops können Text-RAM und Video-RAM ihre Rollen tauschen.
So kann die CPU im Text-RAM eine neue Grafik erstellen, während noch das alte Video-RAM angezeigt wird.

=Die Programmiersprache=

Der Compiler erzeugt einen Zwischencode, welcher interpretativ abgearbeitet wird. Der
Zwischencode besteht aus Aufrufen vorgefertigter Maschinenroutinen. Nur wenige dieser
Maschinenroutinen sind interner Teil der Sprache, die meisten liegen in den 8 Steckkarten.

Die Sprache ist strikt imperativ. Es besteht eine direkte Eins-zu-Eins-Entsprechung zwischen dem Quelltext und
der Folge der Operationen im Zwischencode. Es gibt im Quelltext keine arithmetischen oder logischen Ausdrücke.

Es gibt in dieser Sprache kein goto, kein break, kein continue, und in jedem Programm oder
Unterprogramm genau 1 return, nämlich am Ende des Programms oder Unterprogramms.

Die Strukturelemente sind folgende:

<pre>
Bedingte Anweisung: IF.c ... ENDF
Verzweigung: IF.c ... ELSE ... ENDE
Case-Struktur: CASE /nn ... NEXT /nn ... LAST
Do-while-Schleife: LOOP ... RP.c
While-Schleife: L.JP ... HERE ... RP.c
</pre>

c steht hier für die Sprungbedingung, nn steht für eine Zahl
fallend bis 00, NEXT /nn ist entsprechend mehrmals anzugeben. 
RP.c steht für wiederhole falls c.

Ebenso wie die Verzweigung zählt die Schleife mit Hineinsprung

<pre>
L.JP ... HERE ... RP.c
</pre>

als ein Block mit zwei Unterblöcken, die strenge Blockstruktur wird durch den Hineinsprung nicht durchbrochen.

Die Blockstruktur wird bei folgenden Operationen gebraucht:

<pre>
ACQU ... UACQ
FASN ... UFAS
LN.1 ... RELS // LN.2 ... RELS
LX.1 ... RELS // LX.2 ... RELS
</pre>

ACQU steht für Aquirieren von Residenten Variablen 
UACU macht das Aquirieren rückgängig

Residente Variable sind Variable, zB. vom Typ databox, welche ausserhalb des Programms dauerhaft im RAM
liegen. Sie sind über ihren Namen auffindbar und werden über ihre Nummer adressiert. ACQU bindet freie
Zeiger, welche im Programm vereinbart sind, an diese externen Variablen. Dadurch sind diese Variablen unter
Umgehung des Namens und der Nummer wie gewöhnliche im Programm vereinbarte Variable verfügbar.

FASN vergibt den Status "befestigt" an Variable vom Typ databox 
UFAS macht die Vergabe rückgängig.

Variable vom Typ databox, welche beim Start des Programms automatisch installiert werden
oder danach durch LN/LX installiert werden, sind von sich aus "befestigt". Das Installieren
kann aber auch durch Steckkarten-Kommandos erfolgen, zB. wenn die Größe der databox
erst zur Laufzeit des Programms bekannt wird. Dann sind sie zunächst unbefestigt.

LN.1 leiht den von einer databox in RAM1 belegten Speicherplatz an mehrere Variable aus, welche vorher als
nicht installiert vereinbart wurden und nach dem Ausleihen den Speicherplatz der databox überdecken.

LX.1 leiht einen Teil des Speicherplatzes einer databox ab einem Startindex an mehrere Variable aus.

Entsprechend LN.2 und LX.2 für RAM2. In RAM1 sind die mehreren
Variablen kurze Variable vom Typ data, oder selber wieder vom
Typ databox, in RAM2 sind sie stets wieder vom Typ databox.

Beim Ausleihen aus einer databox prüft LN/LX, ob die databox befestigt ist. Andernfalls
wäre sie verschiebbar oder könnte uninstalliert werden, so dass Schreibzugriffe auf die
durch das Ausleihen erzeugten Variablen Unheil anrichten könnten.

RELS macht das Ausleihen rückgängig.

Bei den Operationen ACQU, FASN, LN/LX garantiert der Compiler,
dass das zugehörige UACQ, UFAS, RELS im selben Block liegt.
Die jeweilige Operation und das zugehörige Rückgängigmachen
bilden selber wieder einen Block.

'''Ergänzung zu Sprungbedingungen:'''

Es kann abgefragt werden, ob eine 1-oder 2-Byte-Variable
Null ist und ob sie gleich ff bzw. ffff ist.

Die Kommandos =TT.Z und =TT.M können diese Bedingungen
speichern in einem speziellen Byte im RAM, dem TF-Merker.
Dazu schieben sie eine 1 oder 0 von oben auf den TF-Merker.
In gleicher Weise können Steckkarten-Kommandos nCOMMAND
beliebige Bedingungen ermitteln und speichern.

Es gibt bedingte Sprünge, welche die obersten 3 Bit des
TF-Merker mittels einer Wahrheitstabelle abfragen. Dabei
können bis zu 3 Bits wieder vom TF-Merker entfernt werden.

Mittels der Routinen =PP.r, =PZ.r, =PM.r ist es möglich,
solche Bedingungen in einer 1- oder 2-Byte-Variablen zu
speichern, zu verANDen und zu verORen. Damit lassen
sich beliebig komplexe Sprungbedingungen berechnen.

'''Unterprogramme:'''

In der Programmiersprache gibt es keine functions mit
Rückgabewert, sondern nur einfache Unterprogramme, bei
welchen alle Parameter gleichberechtigt sind. Es werden
ausschließlich Zeiger übergeben.

'''Variablen vom Typ FIX:'''

Ihre Werte sind Teil des Programmcodes und liegen dort am Ende.
Der gesamte Speicherbereich dieser Werte kann als "FIXBOX" vom
Programm abgetrennt werden und dann mittels eines speziellen
Werkzeugs bearbeitet werden.

[[Kategorie:FPGA-Projekte]]

8bit-CPU: bo8

2025-08-10T18:48:27Z

Bome:

''Erst-Autor:'' [[Benutzer:Bome|bome]]

Die CPU ist Teil eines Gesamt-Projekts: [[8bit-Computer: bo8h]]. 
Dort findet sich auch eine erläuternde Beschreibung der CPU.

Beitrag im Forum: [http://www.mikrocontroller.net/topic/407050 Befehlssatz der bo8-CPU] 
Dort findet sich auch einiges zur Wortbedeutung der Mnemonics.

Im folgenden Text steht der Punkt in den Mnemonics für einen 
hier nicht darstellbaren auf der Grundlinie liegenden Bindestrich.

<pre>
================================================================

P Q R S X Y Z K V Bezeichnung: A7 = U
| | | | | | | |A AB = K
| | | | | | | |B

P Programmzähler Q Rückkehradresse
X Adressregister R Schleifenstartadresse
Y Adressregister S Schleifenzähler
Z Adressregister A Akku B Erweiterung V Carry

----------------------------------------------------------------
a0 .. af Adressleitungen - Tristate
d0 .. d7 Datenleitungen - Tristate
N0 .. N3 Typleitungen - permanente Ausgänge
RES REP Reset Repeat - Eingänge
C0 C1 Takt Takt - Eingänge

0 1 2 3 0 1 2 3 0
/ / / / / / / / /
--==------==------==------==------==---- Cx
[ tA [ tB [ tA [ tB [
====----====----====----====----====---- C0
--====----====----====----====----====-- C1

An beiden Eingängen C0 C1 kann Cx anliegen
Cx darf auch symmetrisch sein (Tastgrad 50%)
Oder es können verschiedene Takte C0 C1 anliegen
C0 liefert die fallende und C1 die steigende Flanke

Die Halbzyklen tA und tB bilden einen Vollzyklus (tA/tB).

Typleitungen ändern ihren Zustand zu Zeitpunkten 0 und 2
Adressen und Write-Daten sind gültig von Zeitpunkt 0 bis 2
Einlesen von Read-Daten zum Zeitpunkt 2

Einlesen von REP zu jedem Zeitpunkt 2 (Mitte eines Vollzyklus)
REP bewirkt Anhängen eines (AR/BN) oder eines weiteren (AR/BN)

RES muss enden mit Zeitpunkt 0 bis rechtzeitig vor Zeitpunkt 1
Zum Zeitpunkt 2 Einlesen der Startadresse nach P und R vom
Adressbus und des Akku A vom Datenbus. Folgender Zeitpunkt 0
Start des Programmms mit (FE/BN) für ersten OpCode.

----------------------------------------------------------------
Typ Name Funktion

0/tB BN normal tB inaktiv
1/tA AR repeat tA inaktiv - wiederhole input
2/tA KA Adressbus gibt K aus - Datenbus inaktiv
3/tA HA Adressbus gibt K aus - input A

4/tB BP memory-page-Umschaltung für P
5/tB BX memory-page-Umschaltung für X
6/tB BY memory-page-Umschaltung für Y
7/tB BZ memory-page-Umschaltung für Z

8/tA FE read / Adresse ist P / OP-Code
9/tA WX write / Adresse ist X
a/tA WY write / Adresse ist Y
b/tA WZ write / Adresse ist Z

c/tA RP read / Adresse ist P
d/tA RX read / Adresse ist X
e/tA RY read / Adresse ist Y
f/tA RZ read / Adresse ist Z

----------------------------------------------------------------
+0 +1 +2 +3 +4 +5 +6 +7

00- H.. ST.S SS.X ST.X SS.Y ST.Y SS.Z ST.Z
08- IX0 IX1 IX2 IX3 IX4 IX5 IX6 IX7
10- IY0 IY1 IY2 IY3 IY4 IY5 IY6 IY7
18- IZ0 IZ1 IZ2 IZ3 IZ4 IZ5 IZ6 IZ7
20- ZO.S SL.S ZO.X SL.X ZO.Y SL.Y ZO.Z SL.Z
28- DX0 DX1 DX2 DX3 DX4 DX5 DX6 DX7
30- DY0 DY1 DY2 DY3 DY4 DY5 DY6 DY7
38- DZ0 DZ1 DZ2 DZ3 DZ4 DZ5 DZ6 DZ7
40- O.VZ O.VS B.VZ B.VS O.UZ O.US B.UZ B.US
48- O.AZ O.AS B.AZ B.AS O.KZ O.KS B.KZ B.KS
50- O.WY O.RP B.WY B.CN GTR ADR GTA NOL
58- IKL DKL IXL DXL IYL DYL IZL DZL
60- AD. LV. AV. SV. GT. AN. XR. NR.
68- STMX LVMX AVMX SVMX GTMX ANMX XRMX NRMX
70- STMY LVMY AVMY SVMY GTMY ANMY XRMY NRMY
78- STMZ LVMZ AVMZ SVMZ GTMZ ANMZ XRMZ NRMZ
80- NO2 TK1 TK2 TK3 TK4 TK5 TK6 TK7
88- TK8 TK9 TKa TKb TKc TKd TKe TKf
90- NO1 TA1 TA2 TA3 TA4 TA5 TA6 TA7
98- ST.B LV.B AV.B SV.B GT.B AN.B XR.B NR.B
a0- EX.S LV.S AV.S SV.S GT.S LD.S AD.S SD.S
a8- EX.X ES.X SW.X RS.X GT.X LD.X AD.X SD.X
b0- EX.Y ES.Y SW.Y RS.Y GT.Y LD.Y AD.Y SD.Y
b8- EX.Z ES.Z SW.Z RS.Z GT.Z LD.Z AD.Z SD.Z
c0- R.VZ R.VS R.UZ R.US R.AZ R.AS R.KZ R.KS
c8- R.WY R.CN R.IX R.DX R.IY R.DY R.IZ R.DZ
d0- GH.S GL.S GH.X GL.X GH.Y GL.Y GH.Z GL.Z
d8- IC.S DC.S IXE DXE IYE DYE IZE DZE
e0- ZO.U SE.U ZO.V SE.V CP.U NE.U CP.V NE.V
e8- PV.A TZ.A PV.B TZ.B RD.A RU.A RD.B RU.B
f0- ZO.A NE.A ZO.B NE.B IV.A DV.A SL.K S.RP
f8- IC.K DC.K ZO.K NE.K IC.A DC.A GT.Q J..

00 .. 3f 1 Byte
40 .. 67 2 Byte
68 .. ff 1 Byte

00 .. 3f 1 Zyklus / Sonderfall 00
40 .. 53 2|3 Zyklen
54 .. 7f 2 Zyklen / Sonderfall 57
80 .. ff 1 Zyklus / Sonderfall 80

Während der Ausführung eines Befehls
wird der nachfolgende OpCode geladen.

----------------------------------------------------------------
nn ist zweites Byte eines 2-Byte-Befehls , % ist X|Y|Z

AN.B A <= A and B
NR.B A <= A nor B
XR.B A <= A xor B
AV.B A <= A+B+V V <= Carry
SV.B A <= A-B-V V <= Carry
LV.B A <= B-A-V V <= Carry
GT.B A <= B
ST.B B <= A

AN. nn A <= A and nn
NR. nn A <= A nor nn
XR. nn A <= A xor nn
AV. nn A <= A+nn+V V <= Carry
SV. nn A <= A-nn-V V <= Carry
LV. nn A <= nn-A-V V <= Carry
GT. nn A <= nn
AD. nn A <= A+nn

ANM% A <= A and (%)
NRM% A <= A nor (%)
XRM% A <= A xor (%)
AVM% A <= A+(%)+V V <= Carry
SVM% A <= A-(%)-V V <= Carry
LVM% A <= (%)-A-V V <= Carry
GTM% A <= (%)
STM% (%) <= A

AV.S K <= K+S+V V <= Carry
SV.S K <= K-S-V V <= Carry
LV.S K <= S-K-V V <= Carry

AD.S K <= K+S
SD.S K <= K-S
LD.S K <= S-K

AD.% K <= K+%
SD.% K <= K-%
LD.% K <= %-K

GT.S K <= S
ST.S S <= K
GT.% K <= %
ST.% % <= K

RS.% S <= %
SS.% % <= S

SL.K B <= A , A <= 0

SL.S S LowByte <= A , S HighByte <= 0
SL.% % LowByte <= A , % HighByte <= 0

GL.S A <= LowByte von S
GH.S A <= HighByte von S
GL.% A <= LowByte von %
GH.% A <= HighByte von %

EX.S Austausch K <> S
EX.% Austausch K <> %
ES.% Austausch S <> %

ZO.S S <= 0
ZO.% % <= 0

ZO.V V <= 0
SE.V V <= 1
NE.V V <= not V
CP.V V <= V xor U

ZO.U U <= 0
SE.U U <= 1
NE.U U <= not U
CP.U U <= V xor U

NE.A A wird logisch negiert
NE.B B wird logisch negiert
NE.K K wird logisch negiert

ZO.A A <= 0
ZO.B B <= 0
ZO.K K <= 0

IV.A A <= A+V V <= Carry
DV.A A <= A-V V <= Carry

IC.A A <= A+1
IC.K K <= K+1
IC.S S <= S+1

DC.A A <= A-1
DC.K K <= K-1
DC.S S <= S-1

PV.A A <= 8-fache Kopie von V , V <= 0
PV.B B <= 8-fache Kopie von V , V <= 0

TZ.A wenn nicht A=0 dann ( V <= 1 )
TZ.B wenn nicht B=0 dann ( V <= 1 )

RD.A A wird nach unten durch V rotiert
Resultat V7654321 V <= Bit0
RD.B B wird nach unten durch V rotiert
Resultat V7654321 V <= Bit0

RU.A A wird nach oben durch V rotiert
Resultat 6543210V V <= Bit7
RU.B B wird nach oben durch V rotiert
Resultat 6543210V V <= Bit7

TAs mit s= 1..7 A wird s Bitstellen nach oben verdreht
Resultat von TA3 ist 43210765

TKs mit s= 1..f K wird s Bitstellen nach oben verdreht

I%s mit s= 0..7 % <= %+s+1
D%s mit s= 0..7 % <= %-s-1

I%E % <= %+1 , und Austausch A <> B
D%E % <= %-1 , und Austausch A <> B

IKL nn K <= K+nn+1
DKL nn K <= K-nn-1
I%L nn % <= %+nn+1
D%L nn % <= %-nn-1

GTA nn K <= 00nn
GTR nn K <= P+nn+3
ADR nn K <= K+P+nn+3

NO1 no operation 1 Zyklus
NO2 no operation 2 Zyklen

NOL nn no operation 2+nn Zyklen falls nn > 0
NOL 00 K <= R 2 Zyklen

GT.Q K <= Q

S.RP R <= P+1
O.RP nn R <= P+2 , P <= P+nn+3

Bedingung cc ist WY always
VZ V ist 0
VS V ist nicht 0
UZ U ist 0
US U ist nicht 0
AZ A ist 0
AS A ist nicht 0
KZ K ist 0
KS K ist nicht 0

O.cc nn wenn cc dann ( P <= P+nn+3 )
B.cc nn wenn cc dann ( P <= P-nn-1 )
B.CN nn wenn nicht S=0 dann ( P <= P-nn-1 , S <= S-1 )

R.cc wenn cc dann ( P <= R )
R.CN wenn nicht S=0 dann ( P <= R , S <= S-1 )
R.I% wenn nicht S=0 dann ( P <= R , S <= S-1 , % <= %+1 )
R.D% wenn nicht S=0 dann ( P <= R , S <= S-1 , % <= %-1 )

Bei O.VZ, O.VS, B.VZ, B.VS, R.VZ, R.VS wird V <= 0

Alle O-,B- Operationen dauern 3 Zyklen | 2 Zyklen
wenn der Sprung erfolgt | nicht erfolgt

J.. P <= K , R <= K , Q <= P+1 , K <= P+1

SW.% Nach dem Einlesen des folgenden OpCodes mit FE wird
statt eines BN ein B% ausgegeben. Das soll extern
eine memory-page-Umschaltung für % bewirken. Das
Resultat muss schon beim folgenden tA bereitstehen.

H.. Nach dem Einlesen des folgenden OpCodes mit FE wird
statt eines BN ein BP ausgegeben. Das soll extern
eine memory-page-Umschaltung für P bewirken. Das
Resultat muss schon beim folgenden tA bereitstehen.

Wenn der eingelesene folgende OpCode ein J.. ist,
ist H.. damit beendet. Dauer von H.. ist 1 Zyklus.

Wenn der OpCode kein J.. ist, folgt ein IO-Zyklus
(HA/BP). Das BP soll die memory-page-Umschaltung
für P wieder aufheben. Dauer von H.. ist 2 Zyklen.

Ausnahme: Wenn der OpCode wieder ein H.. ist,
folgt (KA/BN) statt (HA/BP). Danach bleibt die
CPU im Zustand BN bis ein Reset erfolgt.

</pre>

[[Kategorie: FPGA-Projekte]]

8bit-Computer: bo8h

2025-08-10T18:30:01Z

Bome:

''Erst-Autor:'' [[Benutzer:Bome|bome]]

=Übersicht=

Der 8bit-Rechner bo8h existiert bisher nur als Prototyp-Gerät
auf folgenden FPGA-Boards:
* '''Spartan-3A Starter Kit''' von Xilinx
* '''Spartan-3E Starter Board''' und
* '''Nexys2 Board''' von Digilent
* '''Terasic DE0 Board'''
* '''Terasic DE0-CV Board'''
* '''Terasic DE0-nano Board'''
* '''Terasic DE10-Lite Board'''
* '''Terasic Cyclone V GX Starterkit'''

Die Realisierung auf dem Spartan-3A Starter Kit funktioniert auch auf dem ''Spartan-3AN Starter Kit''. 
Das Spartan-3E Starter Board von Digilent ist baugleich mit dem Spartan-3E Starter Kit von Xilinx.

Die '''CPU bo8''' ist eine Eigenentwicklung und hat keine Interrupts. Merkmale des Gesamtsystems
sind der aus mehreren 64KByte-Seiten bestehende Adressraum, das Steckplatz-Konzept,
eine an die Hardware angepasste Programmiersprache und taktgenau berechenbare Programmlaufzeiten.
Der Zeichensatz beinhaltet neben Buchstaben und Sonderzeichen einen Satz von sechzehn Ziffern,
wobei die Ziffern A bis F durch modifizierte Buchstaben dargestellt werden.

Das Prototyp-Gerät besitzt Bildschirm und Tastatur, nutzt [[RS232]] zum Daten-Austausch mit PC
und hat eine SD-Karte mit selbstgestricktem Dateisystem.
Der [[VHDL]]-Code ist so geschrieben, dass leicht weitere Schnittstellen eingebaut werden können.

* Informationen und Downloads gibt es auf [https://bo8h.de bo8h.de].
* Kopie des Download-Files von bo8h.de: [[Datei:Bo8h.zip]]
* Wiki-Artikel zur CPU: [[8bit-CPU: bo8]].
* Beitrag im '''Forum''' Projekte & Code: [http://www.mikrocontroller.net/topic/297603 8bit-Computing mit FPGA].
* Im ''embedded-projects-Journal 14''  gab es einen Artikel ''Ein 8bit-Rechner auf dem Spartan-3A-Starterkit''.

Das Prototyp-Gerät hat 4 freie virtuelle Steckplätze mit je 64KByte, wobei je 32KByte
für Software vorgesehen sind. Damit haben Software-Entwickler die Möglichkeit,
Steckkarten-Software in Eigen-Regie anzubieten. Zur Software-Entwicklung
auf PC gibt es einen in C geschriebenen Assembler und ein Emulations-Programm.

=Die CPU=

''Der Punkt in den Mnemonics steht für einen auf der Grundlinie liegenden Bindestrich.''

Der Akku '''A''' und das Erweiterungsregister '''B''' sind 8-bit. 
Das Doppelregister AB wird abkürzend mit '''K''' bezeichnet. 
Das Vorzeichenbit A7 wird abkürzend mit '''U''' bezeichnet.

Der Programmzähler '''P''' und die Adressregister '''X''', '''Y''', '''Z''' sind 16-bit. 
Das Register '''Q''' erhält bei Sprüngen die Rückkehradresse P+1. 
'''R''' ist Schleifen-Startadresse, '''S''' ist Schleifenzähler (16-bit).

Einziges Flag ist der Carry '''V'''. Bei bedingten Sprüngen kann ausserdem abgefragt werden, ob U/A/K Null sind.

Alle Speicherzugriffe sind 8bit-Zugriffe. 
GTMX lädt nach A den Inhalt der Speicherzelle, auf welche X zeigt. 
STMX speichert A in der Speicherzelle, auf welche X zeigt.

IXE inkrementiert X und tauscht A und B. 
DXE dekrementiert X und tauscht A und B.

Damit lassen sich 2-byte-Speicherzugriffe aufbauen 
nach dem Muster GTMX..IXE..GTMX und STMX..DXE..STMX. 
Es gibt hierfür die Assembler-Makros GTMXI und STMXD.

<pre>
GTMXI lädt eine Adresse von Position X
ST.Y überträgt die Adresse nach Y

GTMXI lädt eine Adresse von Position X
AD.X addiert X
ST.Y überträgt die zu X relative Adresse nach Y

J.. Sprung zu der Adresse, welche in K steht

GTA 59 lädt den Wert 0059 nach K
AD. 35 addiert 35 zu A
J.. Sprung nach 3559

Das lässt sich kürzer schreiben mit Assembler-Makro
/GTA 3559
J

GTR 59 lädt den Wert P+0059+3 nach K
AD. 35 addiert 35 zu A
J.. relativer Sprung nach P+3559+3

Das lässt sich kürzer schreiben mit Assembler-Makro
/GTR 3559
J

GT.Q lädt Rückkehradresse nach K
J Rücksprung aus Unterprogramm
</pre>

Wenn ein Unterprogramm selber J.. ausführen will für andere Zwecke als für den Rücksprung,
muss es vorher die Rückkehradresse sichern. Dazu kann es die Rückkehradresse aus Q laden,
anfangs steht sie aber auch in K und das Laden kann entfallen.

Ausser dem Sprungbefehl J.. gibt es die bedingten Sprünge mit 8bit-Sprungdistanz: 
O.cc nn (Vorwärtssprung falls cc) und B.cc nn (Rückwärtssprung falls cc).

Für schnelle Schleifen gibt es die Repeat-Befehle R.cc. 
Repeat-Befehle gibt es kombiniert mit Schleifenzähler-Dekrementieren und Adresse-Inkrementieren/Dekrementieren.
Die Schleifenstartadresse R wird gesetzt vor dem Schleifenanfang mittels S.RP oder mittels O.RP nn.
Bei letzterem wird gleichzeitig ein Vorwärtssprung ausgeführt. Damit sind Schleifen mit Hineinsprung (while-Schleifen) realisierbar.

Bei J.. wird die Zieladresse auch nach R übertragen. Das garantiert, dass R stets eine Adresse im Nahbereich
des Programmzählers enthält. Eine Anwendung hiervon ergibt sich beim Sprung in eine Tabelle, welche aus
O.WY nn -Befehlen (Vorwärtssprung always) besteht, wobei die O.WY nn alle zur
selben Adresse springen. Die dortige Routine kann durch Auswertung von R die Nummer des O.WY-Befehls ermitteln.

'''Adressierung mehrerer 64K-Seiten:'''

Zu jeder auf dem Adressbus ausgegebenen Adresse wird auf den Steuerleitungen angezeigt, von welchem der
Adressregister P, X, Y, Z sie kommt. Dadurch kann eine externe Logik jedem der Adressregister eine eigene
64K-Speicherseite zuordnen. Die CPU kann spezielle Steuersignale ausgeben, welche die externe Logik
zur Memory-Page-Umschaltung für eines der Adressregister veranlassen sollen.

Der Befehl H.. ist der einzige und universell einsetzbare IO-Befehl.
Es wird K auf dem Adressbus ausgegeben und der Datenbus nach A eingelesen.

Wenn auf H.. ein J.. folgt, dann wirkt H.. stattdessen als Präfix und bewirkt,
dass J.. mit einer Memory-Page-Umschaltung kombiniert wird. So kann die CPU von einer
64K-Seite in eine andere springen, ohne dass es einen gemeinsamen Speicherbereich geben muss.

Bei den Adressregistern X, Y, Z gibt es spezielle Befehle SW.X, SW.Y, SW.Z für die Memory-Page-Umschaltung.

=Die Gesamt-Hardware=

Es gibt vier Memory-Pages mit je 64KByte:

* Page 0: Aktiver Steckplatz
* Page 1: ROM (32K), Text-RAM (16K), Video-RAM (16K)
* Page 2: Haupt-RAM
* Page 3: Zusatz-RAM

Der aktive Steckplatz in Page 0 wird durch ein 3bit-Register SLT ausgewählt.
Neben Page 0 wird auch IO-Adressraum zugeteilt.
Die Steckkarten sollten ein Software-ROM und IO-Hardware enthalten.

Es gibt die 2bit-Register MP, MX, MY, MZ. Diese Register legen fest, in welche der vier Memory-Pages
das betreffende Adressregister P, X, Y, Z zeigt. Ausserdem gibt es die Schattenregister NP, NX, NY, NZ.
Das CPU-Signal zur Memory-Page-Umschaltung für ein bestimmtes Adressregister # bewirkt den
Austausch von M# und N#, wobei # hier für P, X, Y, Z steht.
Beim Sprung mit Memory-Page-Umschaltung  H..  J..  werden also MP und NP getauscht.
Die Schattenregister NP, NX, NY, NZ können über IO-Befehle H.. mit einem Wert 0 bis 3 geladen werden.

Das Display ist 512 Pixel breit und 256 Pixel hoch, die Pixel sind zweiwertig.
Der Video-Generator liest in Dauerschleife das Video-RAM und erzeugt daraus die VGA-Signale.
Einen Hardware-Zeichengenerator gibt es nicht.
Die Software liest die Zeichen aus dem Text-RAM und schreibt deren Pixelmuster ins Video-RAM.
Die Textzeilen sind 64 Zeichen breit.
Durch Invertierung eines Flipflops können Text-RAM und Video-RAM ihre Rollen tauschen.
So kann die CPU im Text-RAM eine neue Grafik erstellen, während noch das alte Video-RAM angezeigt wird.

=Die Programmiersprache=

Der Compiler erzeugt einen Zwischencode, welcher interpretativ abgearbeitet wird. Der
Zwischencode besteht aus Aufrufen vorgefertigter Maschinenroutinen. Nur wenige dieser
Maschinenroutinen sind interner Teil der Sprache, die meisten liegen in den 8 Steckkarten.

Die Sprache ist strikt imperativ. Es besteht eine direkte Eins-zu-Eins-Entsprechung zwischen dem Quelltext und
der Folge der Operationen im Zwischencode. Es gibt im Quelltext keine arithmetischen oder logischen Ausdrücke.

Es gibt in dieser Sprache kein goto, kein break, kein continue, und in jedem Programm oder
Unterprogramm genau 1 return, nämlich am Ende des Programms oder Unterprogramms.

Die Strukturelemente sind folgende:

<pre>
Bedingte Anweisung: IF.c ... ENDF
Verzweigung: IF.c ... ELSE ... ENDE
Case-Struktur: CASE /nn ... NEXT /nn ... LAST
Do-while-Schleife: LOOP ... RP.c
While-Schleife: L.JP ... HERE ... RP.c
</pre>

c steht hier für die Sprungbedingung, nn steht für eine Zahl
fallend bis 00, NEXT /nn ist entsprechend mehrmals anzugeben. 
RP.c steht für wiederhole falls c.

Ebenso wie die Verzweigung zählt die Schleife mit Hineinsprung

<pre>
L.JP ... HERE ... RP.c
</pre>

als ein Block mit zwei Unterblöcken, die strenge Blockstruktur wird durch den Hineinsprung nicht durchbrochen.

Die Blockstruktur wird bei folgenden Operationen gebraucht:

<pre>
ACQU ... UACQ
FASN ... UFAS
LN.1 ... RELS // LN.2 ... RELS
LX.1 ... RELS // LX.2 ... RELS
</pre>

ACQU steht für Aquirieren von Residenten Variablen 
UACU macht das Aquirieren rückgängig

Residente Variable sind Variable, zB. vom Typ databox, welche ausserhalb des Programms dauerhaft im RAM
liegen. Sie sind über ihren Namen auffindbar und werden über ihre Nummer adressiert. ACQU bindet freie
Zeiger, welche im Programm vereinbart sind, an diese externen Variablen. Dadurch sind diese Variablen unter
Umgehung des Namens und der Nummer wie gewöhnliche im Programm vereinbarte Variable verfügbar.

FASN vergibt den Status "befestigt" an Variable vom Typ databox 
UFAS macht die Vergabe rückgängig.

Variable vom Typ databox, welche beim Start des Programms automatisch installiert werden
oder danach durch LN/LX installiert werden, sind von sich aus "befestigt". Das Installieren
kann aber auch durch Steckkarten-Kommandos erfolgen, zB. wenn die Größe der databox
erst zur Laufzeit des Programms bekannt wird. Dann sind sie zunächst unbefestigt.

LN.1 leiht den von einer databox in RAM1 belegten Speicherplatz an mehrere Variable aus, welche vorher als
nicht installiert vereinbart wurden und nach dem Ausleihen den Speicherplatz der databox überdecken.

LX.1 leiht einen Teil des Speicherplatzes einer databox ab einem Startindex an mehrere Variable aus.

Entsprechend LN.2 und LX.2 für RAM2. In RAM1 sind die mehreren
Variablen kurze Variable vom Typ data, oder selber wieder vom
Typ databox, in RAM2 sind sie stets wieder vom Typ databox.

Beim Ausleihen aus einer databox prüft LN/LX, ob die databox befestigt ist. Andernfalls
wäre sie verschiebbar oder könnte uninstalliert werden, so dass Schreibzugriffe auf die
durch das Ausleihen erzeugten Variablen Unheil anrichten könnten.

RELS macht das Ausleihen rückgängig.

Bei den Operationen ACQU, FASN, LN/LX garantiert der Compiler,
dass das zugehörige UACQ, UFAS, RELS im selben Block liegt.
Die jeweilige Operation und das zugehörige Rückgängigmachen
bilden selber wieder einen Block.

'''Ergänzung zu Sprungbedingungen:'''

Es kann abgefragt werden, ob eine 1-oder 2-Byte-Variable
Null ist und ob sie gleich ff bzw. ffff ist.

Die Kommandos =TT.Z und =TT.M können diese Bedingungen
speichern in einem speziellen Byte im RAM, dem TF-Merker.
Dazu schieben sie eine 1 oder 0 von oben auf den TF-Merker.
In gleicher Weise können Steckkarten-Kommandos nCOMMAND
beliebige Bedingungen ermitteln und speichern.

Es gibt bedingte Sprünge, welche die obersten 3 Bit des
TF-Merker mittels einer Wahrheitstabelle abfragen. Dabei
können bis zu 3 Bits wieder vom TF-Merker entfernt werden.

Mittels der Routinen =PP.r, =PZ.r, =PM.r ist es möglich,
solche Bedingungen in einer 1- oder 2-Byte-Variablen zu
speichern, zu verANDen und zu verORen. Damit lassen
sich beliebig komplexe Sprungbedingungen berechnen.

'''Unterprogramme:'''

In der Programmiersprache gibt es keine functions mit
Rückgabewert, sondern nur einfache Unterprogramme, bei
welchen alle Parameter gleichberechtigt sind. Es werden
ausschließlich Zeiger übergeben.

'''Variablen vom Typ FIX:'''

Ihre Werte sind Teil des Programmcodes und liegen dort am Ende.
Der gesamte Speicherbereich dieser Werte kann als "FIXBOX" vom
Programm abgetrennt werden und dann mittels eines speziellen
Werkzeugs bearbeitet werden.

[[Kategorie:FPGA-Projekte]]

8bit-Computer: bo8h

2025-08-10T18:19:58Z

Bome:

''Erst-Autor:'' [[Benutzer:Bome|bome]]

=Übersicht=

Der 8bit-Rechner bo8h existiert bisher nur als Prototyp-Gerät
auf folgenden FPGA-Boards:
* '''Spartan-3A Starter Kit''' von Xilinx
* '''Spartan-3E Starter Board''' und
* '''Nexys2 Board''' von Digilent
* '''Terasic DE0 Board'''
* '''Terasic DE0-CV Board'''
* '''Terasic DE0-nano Board'''
* '''Terasic DE10-Lite Board'''
* '''Terasic Cyclone V GX Starterkit'''

Die Realisierung auf dem Spartan-3A Starter Kit funktioniert auch auf dem ''Spartan-3AN Starter Kit''. 
Das Spartan-3E Starter Board von Digilent ist baugleich mit dem Spartan-3E Starter Kit von Xilinx.

Die '''CPU bo8''' ist eine Eigenentwicklung und hat keine Interrupts. Merkmale des Gesamtsystems
sind der aus mehreren 64KByte-Seiten bestehende Adressraum, das Steckplatz-Konzept,
eine an die Hardware angepasste Programmiersprache und taktgenau berechenbare Programmlaufzeiten.
Der Zeichensatz beinhaltet neben Buchstaben und Sonderzeichen einen Satz von sechzehn Ziffern,
wobei die Ziffern A bis F durch modifizierte Buchstaben dargestellt werden.

Das Prototyp-Gerät besitzt Bildschirm und Tastatur, nutzt [[RS232]] zum Daten-Austausch mit PC
und hat eine SD-Karte mit selbstgestricktem Dateisystem.
Der [[VHDL]]-Code ist so geschrieben, dass leicht weitere Schnittstellen eingebaut werden können.

* Informationen und Downloads gibt es auf [https://bo8h.de bo8h.de].
* Kopie des Download-Files von bo8h.de: [[Datei:Bo8h.zip]]
* Wiki-Artikel zur CPU: [[8bit-CPU: bo8]].
* Beitrag im '''Forum''' Projekte & Code: [http://www.mikrocontroller.net/topic/297603 8bit-Computing mit FPGA].
* Im ''embedded-projects-Journal 14''  gab es einen Artikel ''Ein 8bit-Rechner auf dem Spartan-3A-Starterkit''.

Das Prototyp-Gerät hat 4 freie virtuelle Steckplätze mit je 64KByte, wobei je 32KByte
für Software vorgesehen sind. Damit haben Software-Entwickler die Möglichkeit,
Steckkarten-Software in Eigen-Regie anzubieten. Zur Software-Entwicklung
auf PC gibt es einen in C geschriebenen Assembler und ein Emulations-Programm.

=Die CPU=

''Der Punkt in den Mnemonics steht für einen auf der Grundlinie liegenden Bindestrich.''

Der Akku '''A''' und das Erweiterungsregister '''B''' sind 8-bit. 
Das Doppelregister AB wird abkürzend mit '''K''' bezeichnet. 
Das Vorzeichenbit A7 wird abkürzend mit '''U''' bezeichnet.

Der Programmzähler '''P''' und die Adressregister '''X''', '''Y''', '''Z''' sind 16-bit. 
Das Register '''Q''' erhält bei Sprüngen die Rückkehradresse P+1. 
'''R''' ist Schleifen-Startadresse, '''S''' ist Schleifenzähler (16-bit).

Einziges Flag ist der Carry '''V'''. Bei bedingten Sprüngen kann ausserdem abgefragt werden, ob U/A/K Null sind.

Alle Speicherzugriffe sind 8bit-Zugriffe. 
GTMX lädt nach A den Inhalt der Speicherzelle, auf welche X zeigt. 
STMX speichert A in der Speicherzelle, auf welche X zeigt.

IXE inkrementiert X und tauscht A und B. 
DXE dekrementiert X und tauscht A und B.

Damit lassen sich 2-byte-Speicherzugriffe aufbauen 
nach dem Muster GTMX..IXE..GTMX und STMX..DXE..STMX. 
Es gibt hierfür die Assembler-Makros GTMXI und STMXD.

<pre>
GTMXI lädt eine Adresse von Position X
ST.Y überträgt die Adresse nach Y

GTMXI lädt eine Adresse von Position X
AD.X addiert X
ST.Y überträgt die zu X relative Adresse nach Y

J.. Sprung zu der Adresse, welche in K steht

GTA 59 lädt den Wert 0059 nach K
AD. 35 addiert 35 zu A
J.. Sprung nach 3559

Das lässt sich kürzer schreiben mit Assembler-Makro
/GTA 3559
J

GTR 59 lädt den Wert P+0059+3 nach K
AD. 35 addiert 35 zu A
J.. relativer Sprung nach P+3559+3

Das lässt sich kürzer schreiben mit Assembler-Makro
/GTR 3559
J

GT.Q lädt Rückkehradresse nach K
J Rücksprung aus Unterprogramm
</pre>

Wenn ein Unterprogramm selber J.. ausführen will für andere Zwecke als für den Rücksprung,
muss es vorher die Rückkehradresse sichern. Dazu kann es die Rückkehradresse aus Q laden,
anfangs steht sie aber auch in K und das Laden kann entfallen.

Ausser dem Sprungbefehl J.. gibt es die bedingten Sprünge mit 8bit-Sprungdistanz: 
O.cc nn (Vorwärtssprung falls cc) und B.cc nn (Rückwärtssprung falls cc).

Für schnelle Schleifen gibt es die Repeat-Befehle R.cc. 
Repeat-Befehle gibt es kombiniert mit Schleifenzähler-Dekrementieren und Adresse-Inkrementieren/Dekrementieren.
Die Schleifenstartadresse R wird gesetzt vor dem Schleifenanfang mittels S.RP oder mittels O.RP nn.
Bei letzterem wird gleichzeitig ein Vorwärtssprung ausgeführt. Damit sind Schleifen mit Hineinsprung (while-Schleifen) realisierbar.

Bei J.. wird die Zieladresse auch nach R übertragen. Das garantiert, dass R stets eine Adresse im Nahbereich
des Programmzählers enthält. Eine Anwendung hiervon ergibt sich beim Sprung in eine Tabelle, welche aus
O.WY nn -Befehlen (Vorwärtssprung always) besteht, wobei die O.WY nn alle zur
selben Adresse springen. Die dortige Routine kann durch Auswertung von R die Nummer des O.WY-Befehls ermitteln.

'''Adressierung mehrerer 64K-Seiten:'''

Zu jeder auf dem Adressbus ausgegebenen Adresse wird auf den Steuerleitungen angezeigt, von welchem der
Adressregister P, X, Y, Z sie kommt. Dadurch kann eine externe Logik jedem der Adressregister eine eigene
64K-Speicherseite zuordnen. Die CPU kann spezielle Steuersignale ausgeben, welche die externe Logik
zur Memory-Page-Umschaltung für eines der Adressregister veranlassen sollen.

Der Befehl H.. ist der einzige und universell einsetzbare IO-Befehl.
Es wird K auf dem Adressbus ausgegeben und der Datenbus nach A eingelesen.

Wenn auf H.. ein J.. folgt, dann wirkt H.. stattdessen als Präfix und bewirkt,
dass J.. mit einer Memory-Page-Umschaltung kombiniert wird. So kann die CPU von einer
64K-Seite in eine andere springen, ohne dass es einen gemeinsamen Speicherbereich geben muss.

Bei den Adressregistern X, Y, Z gibt es spezielle Befehle SW.X, SW.Y, SW.Z für die Memory-Page-Umschaltung.

=Die Gesamt-Hardware=

Es gibt vier Memory-Pages mit je 64KByte:

* Page 0: Aktiver Steckplatz
* Page 1: ROM (32K), Text-RAM (16K), Video-RAM (16K)
* Page 2: Haupt-RAM
* Page 3: Zusatz-RAM

Der aktive Steckplatz in Page 0 wird durch ein 3bit-Register SLT ausgewählt.
Neben Page 0 wird auch IO-Adressraum zugeteilt.
Die Steckkarten sollten ein Software-ROM und IO-Hardware enthalten.

Es gibt die 2bit-Register MP, MX, MY, MZ. Diese Register legen fest, in welche der vier Memory-Pages
das betreffende Adressregister P, X, Y, Z zeigt. Ausserdem gibt es die Schattenregister NP, NX, NY, NZ.
Das CPU-Signal zur Memory-Page-Umschaltung für ein bestimmtes Adressregister # bewirkt den
Austausch von M# und N#, wobei # hier für P, X, Y, Z steht.
Beim Sprung mit Memory-Page-Umschaltung  H..  J..  werden also MP und NP getauscht.
Die Schattenregister NP, NX, NY, NZ können über IO-Befehle H.. mit einem Wert 0 bis 3 geladen werden.

Das Display ist 512 Pixel breit und 256 Pixel hoch, die Pixel sind zweiwertig.
Der Video-Generator liest in Dauerschleife das Video-RAM und erzeugt daraus die VGA-Signale.
Einen Hardware-Zeichengenerator gibt es nicht.
Die Software liest die Zeichen aus dem Text-RAM und schreibt deren Pixelmuster ins Video-RAM.
Die Textzeilen sind 64 Zeichen breit.
Durch Invertierung eines Flipflops können Text-RAM und Video-RAM ihre Rollen tauschen.
So kann die CPU im Text-RAM eine neue Grafik erstellen, während noch das alte Video-RAM angezeigt wird.

=Die Programmiersprache=

Der Compiler erzeugt einen Zwischencode, welcher interpretativ abgearbeitet wird. Der
Zwischencode besteht aus Aufrufen vorgefertigter Maschinenroutinen. Nur wenige dieser
Maschinenroutinen sind interner Teil der Sprache, die meisten liegen in den 8 Steckkarten.

Die Sprache ist strikt imperativ. Es besteht eine direkte Eins-zu-Eins-Entsprechung zwischen dem Quelltext und
der Folge der Operationen im Zwischencode. Es gibt im Quelltext keine arithmetischen oder logischen Ausdrücke.

Es gibt in dieser Sprache kein goto, kein break, kein continue, und in jedem Programm oder
Unterprogramm genau 1 return, nämlich am Ende des Programms oder Unterprogramms.

Die Strukturelemente sind folgende:

<pre>
Bedingte Anweisung: IF.c ... ENDF
Verzweigung: IF.c ... ELSE ... ENDE
Case-Struktur: CASE /nn ... NEXT /nn ... LAST
Do-while-Schleife: LOOP ... RP.c
While-Schleife: L.JP ... HERE ... RP.c
</pre>

c steht hier für die Sprungbedingung, nn steht für eine Zahl
fallend bis 00, NEXT /nn ist entsprechend mehrmals anzugeben. 
RP.c steht für wiederhole falls c.

Ebenso wie die Verzweigung zählt die Schleife mit Hineinsprung

<pre>
L.JP ... HERE ... RP.c
</pre>

als ein Block mit zwei Unterblöcken, die strenge Blockstruktur wird durch den Hineinsprung nicht durchbrochen.

Die Blockstruktur wird bei folgenden Operationen gebraucht:

<pre>
ACQU ... UACQ
FASN ... UFAS
LN.1 ... RELS // LN.2 ... RELS
LX.1 ... RELS // LX.2 ... RELS
</pre>

ACQU steht für Aquirieren von Residenten Variablen 
UACU macht das Aquirieren rückgängig

Residente Variable sind Variable, zB. vom Typ databox, welche ausserhalb des Programms dauerhaft im RAM
liegen. Sie sind über ihren Namen auffindbar und werden über ihre Nummer adressiert. ACQU bindet freie
Zeiger, welche im Programm vereinbart sind, an diese externen Variablen. Dadurch sind diese Variablen unter
Umgehung des Namens und der Nummer wie gewöhnliche im Programm vereinbarte Variable verfügbar.

FASN vergibt den Status "befestigt" an Variable vom Typ databox 
UFAS macht die Vergabe rückgängig.

Variable vom Typ databox, welche beim Start des Programms automatisch installiert werden
oder danach durch LN/LX installiert werden, sind von sich aus "befestigt". Das Installieren
kann aber auch durch Steckkarten-Kommandos erfolgen, zB. wenn die Größe der databox
erst zur Laufzeit des Programms bekannt wird. Dann sind sie zunächst unbefestigt.

LN.1 leiht den von einer databox in RAM1 belegten Speicherplatz an mehrere Variable aus, welche vorher als
nicht installiert vereinbart wurden und nach dem Ausleihen den Speicherplatz der databox überdecken.

LX.1 leiht einen Teil des Speicherplatzes einer databox ab einem Startindex an mehrere Variable aus.

Entsprechend LN.2 und LX.2 für RAM2. In RAM1 sind die mehreren
Variablen kurze Variable vom Typ data, oder selber wieder vom
Typ databox, in RAM2 sind sie stets wieder vom Typ databox.

Beim Ausleihen aus einer databox prüft LN/LX, ob die databox befestigt ist. Andernfalls
wäre sie verschiebbar oder könnte uninstalliert werden, so dass Schreibzugriffe auf die
durch das Ausleihen erzeugten Variablen Unheil anrichten könnten.

RELS macht das Ausleihen rückgängig.

Bei den Operationen ACQU, FASN, LN/LX garantiert der Compiler,
dass das zugehörige UACQ, UFAS, RELS im selben Block liegt.
Die jeweilige Operation und das zugehörige Rückgängigmachen
bilden selber wieder einen Block.

'''Ergänzung zu Sprungbedingungen:'''

Es kann abgefragt werden, ob eine 1-oder 2-Byte-Variable
Null ist und ob sie gleich ff bzw. ffff ist.

Die Kommandos =TT.Z und =TT.M können diese Bedingungen
speichern in einem speziellen Byte im RAM, dem TF-Merker.
Dazu schieben sie eine 1 oder 0 von oben auf den TF-Merker.
In gleicher Weise können Steckkarten-Kommandos nCOMMAND
beliebige Bedingungen ermitteln und speichern.

Es gibt bedingte Sprünge, welche die obersten 3 Bit des
TF-Merker mittels einer Wahrheitstabelle abfragen. Dabei
können bis zu 3 Bits wieder vom TF-Merker entfernt werden.

Mittels der Routinen =PP.r, =PZ.r, =PM.r ist es möglich,
solche Bedingungen in einer 1- oder 2-Byte-Variablen zu
speichern, zu verANDen und zu verORen. Damit lassen
sich beliebig komplexe Sprungbedingungen berechnen.

'''Unterprogramme:'''

In der Programmiersprache gibt es keine functions mit
Rückgabewert, sondern nur einfache Unterprogramme, bei
welchen alle Parameter gleichberechtigt sind. Es werden
ausschließlich Zeiger übergeben.

'''Variablen vom Typ FIX:'''

Ihre Werte sind Teil des Programmcodes und liegen dort am Ende.
Der gesamte Speicherbereich dieser Werte kann als "FIXBOX" vom
Programm abgetrennt werden und dann mittels eines speziellen
Werkzeugs bearbeitet werden.

[[Kategorie:FPGA-Projekte]]

8bit-CPU: bo8

2025-08-10T18:13:45Z

Bome:

8bit-Computer: bo8h

2025-08-10T11:42:08Z

Bome:

''von:''   Josef Gnadl ([[Benutzer:Bome|bome]])

=Übersicht=

Der 8bit-Rechner bo8h existiert bisher nur als Prototyp-Gerät
auf folgenden FPGA-Boards:
* '''Spartan-3A Starter Kit''' von Xilinx
* '''Spartan-3E Starter Board''' und
* '''Nexys2 Board''' von Digilent
* '''Terasic DE0 Board'''
* '''Terasic DE0-CV Board'''
* '''Terasic DE0-nano Board'''
* '''Terasic DE10-Lite Board'''
* '''Terasic Cyclone V GX Starterkit'''

Die Realisierung auf dem Spartan-3A Starter Kit funktioniert auch auf dem ''Spartan-3AN Starter Kit''. 
Das Spartan-3E Starter Board von Digilent ist baugleich mit dem Spartan-3E Starter Kit von Xilinx.

Die '''CPU bo8''' ist eine Eigenentwicklung und hat keine Interrupts. Merkmale des Gesamtsystems
sind der aus mehreren 64KByte-Seiten bestehende Adressraum, das Steckplatz-Konzept,
eine an die Hardware angepasste Programmiersprache und taktgenau berechenbare Programmlaufzeiten.
Der Zeichensatz beinhaltet neben Buchstaben und Sonderzeichen einen Satz von sechzehn Ziffern,
wobei die Ziffern A bis F durch modifizierte Buchstaben dargestellt werden.

Das Prototyp-Gerät besitzt Bildschirm und Tastatur, nutzt [[RS232]] zum Daten-Austausch mit PC
und hat eine SD-Karte mit selbstgestricktem Dateisystem.
Der [[VHDL]]-Code ist so geschrieben, dass leicht weitere Schnittstellen eingebaut werden können.

* Informationen und Downloads gibt es auf [https://bo8h.de bo8h.de].
* Kopie des Download-Files von bo8h.de: [[Datei:Bo8h.zip]]
* Wiki-Artikel zur CPU: [[8bit-CPU: bo8]].
* Beitrag im '''Forum''' Projekte & Code: [http://www.mikrocontroller.net/topic/297603 8bit-Computing mit FPGA].
* Im ''embedded-projects-Journal 14''  gab es einen Artikel ''Ein 8bit-Rechner auf dem Spartan-3A-Starterkit''.

Das Prototyp-Gerät hat 4 freie virtuelle Steckplätze mit je 64KByte, wobei je 32KByte
für Software vorgesehen sind. Damit haben Software-Entwickler die Möglichkeit,
Steckkarten-Software in Eigen-Regie anzubieten. Zur Software-Entwicklung
auf PC gibt es einen in C geschriebenen Assembler und ein Emulations-Programm.

=Die CPU=

''Der Punkt in den Mnemonics steht für einen auf der Grundlinie liegenden Bindestrich.''

Der Akku '''A''' und das Erweiterungsregister '''B''' sind 8-bit. 
Das Doppelregister AB wird abkürzend mit '''K''' bezeichnet. 
Das Vorzeichenbit A7 wird abkürzend mit '''U''' bezeichnet.

Der Programmzähler '''P''' und die Adressregister '''X''', '''Y''', '''Z''' sind 16-bit. 
Das Register '''Q''' erhält bei Sprüngen die Rückkehradresse P+1. 
'''R''' ist Schleifen-Startadresse, '''S''' ist Schleifenzähler (16-bit).

Einziges Flag ist der Carry '''V'''. Bei bedingten Sprüngen kann ausserdem abgefragt werden, ob U/A/K Null sind.

Alle Speicherzugriffe sind 8bit-Zugriffe. 
GTMX lädt nach A den Inhalt der Speicherzelle, auf welche X zeigt. 
STMX speichert A in der Speicherzelle, auf welche X zeigt.

IXE inkrementiert X und tauscht A und B. 
DXE dekrementiert X und tauscht A und B.

Damit lassen sich 2-byte-Speicherzugriffe aufbauen 
nach dem Muster GTMX..IXE..GTMX und STMX..DXE..STMX. 
Es gibt hierfür die Assembler-Makros GTMXI und STMXD.

<pre>
GTMXI lädt eine Adresse von Position X
ST.Y überträgt die Adresse nach Y

GTMXI lädt eine Adresse von Position X
AD.X addiert X
ST.Y überträgt die zu X relative Adresse nach Y

J.. Sprung zu der Adresse, welche in K steht

GTA 59 lädt den Wert 0059 nach K
AD. 35 addiert 35 zu A
J.. Sprung nach 3559

Das lässt sich kürzer schreiben mit Assembler-Makro
/GTA 3559
J

GTR 59 lädt den Wert P+0059+3 nach K
AD. 35 addiert 35 zu A
J.. relativer Sprung nach P+3559+3

Das lässt sich kürzer schreiben mit Assembler-Makro
/GTR 3559
J

GT.Q lädt Rückkehradresse nach K
J Rücksprung aus Unterprogramm
</pre>

Wenn ein Unterprogramm selber J.. ausführen will für andere Zwecke als für den Rücksprung,
muss es vorher die Rückkehradresse sichern. Dazu kann es die Rückkehradresse aus Q laden,
anfangs steht sie aber auch in K und das Laden kann entfallen.

Ausser dem Sprungbefehl J.. gibt es die bedingten Sprünge mit 8bit-Sprungdistanz: 
O.cc nn (Vorwärtssprung falls cc) und B.cc nn (Rückwärtssprung falls cc).

Für schnelle Schleifen gibt es die Repeat-Befehle R.cc. 
Repeat-Befehle gibt es kombiniert mit Schleifenzähler-Dekrementieren und Adresse-Inkrementieren/Dekrementieren.
Die Schleifenstartadresse R wird gesetzt vor dem Schleifenanfang mittels S.RP oder mittels O.RP nn.
Bei letzterem wird gleichzeitig ein Vorwärtssprung ausgeführt. Damit sind Schleifen mit Hineinsprung (while-Schleifen) realisierbar.

Bei J.. wird die Zieladresse auch nach R übertragen. Das garantiert, dass R stets eine Adresse im Nahbereich
des Programmzählers enthält. Eine Anwendung hiervon ergibt sich beim Sprung in eine Tabelle, welche aus
O.WY nn -Befehlen (Vorwärtssprung always) besteht, wobei die O.WY nn alle zur
selben Adresse springen. Die dortige Routine kann durch Auswertung von R die Nummer des O.WY-Befehls ermitteln.

'''Adressierung mehrerer 64K-Seiten:'''

Zu jeder auf dem Adressbus ausgegebenen Adresse wird auf den Steuerleitungen angezeigt, von welchem der
Adressregister P, X, Y, Z sie kommt. Dadurch kann eine externe Logik jedem der Adressregister eine eigene
64K-Speicherseite zuordnen. Die CPU kann spezielle Steuersignale ausgeben, welche die externe Logik
zur Memory-Page-Umschaltung für eines der Adressregister veranlassen sollen.

Der Befehl H.. ist der einzige und universell einsetzbare IO-Befehl.
Es wird K auf dem Adressbus ausgegeben und der Datenbus nach A eingelesen.

Wenn auf H.. ein J.. folgt, dann wirkt H.. stattdessen als Präfix und bewirkt,
dass J.. mit einer Memory-Page-Umschaltung kombiniert wird. So kann die CPU von einer
64K-Seite in eine andere springen, ohne dass es einen gemeinsamen Speicherbereich geben muss.

Bei den Adressregistern X, Y, Z gibt es spezielle Befehle SW.X, SW.Y, SW.Z für die Memory-Page-Umschaltung.

=Die Gesamt-Hardware=

Es gibt vier Memory-Pages mit je 64KByte:

* Page 0: Aktiver Steckplatz
* Page 1: ROM (32K), Text-RAM (16K), Video-RAM (16K)
* Page 2: Haupt-RAM
* Page 3: Zusatz-RAM

Der aktive Steckplatz in Page 0 wird durch ein 3bit-Register SLT ausgewählt.
Neben Page 0 wird auch IO-Adressraum zugeteilt.
Die Steckkarten sollten ein Software-ROM und IO-Hardware enthalten.

Es gibt die 2bit-Register MP, MX, MY, MZ. Diese Register legen fest, in welche der vier Memory-Pages
das betreffende Adressregister P, X, Y, Z zeigt. Ausserdem gibt es die Schattenregister NP, NX, NY, NZ.
Das CPU-Signal zur Memory-Page-Umschaltung für ein bestimmtes Adressregister # bewirkt den
Austausch von M# und N#, wobei # hier für P, X, Y, Z steht.
Beim Sprung mit Memory-Page-Umschaltung  H..  J..  werden also MP und NP getauscht.
Die Schattenregister NP, NX, NY, NZ können über IO-Befehle H.. mit einem Wert 0 bis 3 geladen werden.

Das Display ist 512 Pixel breit und 256 Pixel hoch, die Pixel sind zweiwertig.
Der Video-Generator liest in Dauerschleife das Video-RAM und erzeugt daraus die VGA-Signale.
Einen Hardware-Zeichengenerator gibt es nicht.
Die Software liest die Zeichen aus dem Text-RAM und schreibt deren Pixelmuster ins Video-RAM.
Die Textzeilen sind 64 Zeichen breit.
Durch Invertierung eines Flipflops können Text-RAM und Video-RAM ihre Rollen tauschen.
So kann die CPU im Text-RAM eine neue Grafik erstellen, während noch das alte Video-RAM angezeigt wird.

=Die Programmiersprache=

Der Compiler erzeugt einen Zwischencode, welcher interpretativ abgearbeitet wird. Der
Zwischencode besteht aus Aufrufen vorgefertigter Maschinenroutinen. Nur wenige dieser
Maschinenroutinen sind interner Teil der Sprache, die meisten liegen in den 8 Steckkarten.

Die Sprache ist strikt imperativ. Es besteht eine direkte Eins-zu-Eins-Entsprechung zwischen dem Quelltext und
der Folge der Operationen im Zwischencode. Es gibt im Quelltext keine arithmetischen oder logischen Ausdrücke.

Es gibt in dieser Sprache kein goto, kein break, kein continue, und in jedem Programm oder
Unterprogramm genau 1 return, nämlich am Ende des Programms oder Unterprogramms.

Die Strukturelemente sind folgende:

<pre>
Bedingte Anweisung: IF.c ... ENDF
Verzweigung: IF.c ... ELSE ... ENDE
Case-Struktur: CASE /nn ... NEXT /nn ... LAST
Do-while-Schleife: LOOP ... RP.c
While-Schleife: L.JP ... HERE ... RP.c
</pre>

c steht hier für die Sprungbedingung, nn steht für eine Zahl
fallend bis 00, NEXT /nn ist entsprechend mehrmals anzugeben. 
RP.c steht für wiederhole falls c.

Ebenso wie die Verzweigung zählt die Schleife mit Hineinsprung

<pre>
L.JP ... HERE ... RP.c
</pre>

als ein Block mit zwei Unterblöcken, die strenge Blockstruktur wird durch den Hineinsprung nicht durchbrochen.

Die Blockstruktur wird bei folgenden Operationen gebraucht:

<pre>
ACQU ... UACQ
FASN ... UFAS
LN.1 ... RELS // LN.2 ... RELS
LX.1 ... RELS // LX.2 ... RELS
</pre>

ACQU steht für Aquirieren von Residenten Variablen 
UACU macht das Aquirieren rückgängig

Residente Variable sind Variable, zB. vom Typ databox, welche ausserhalb des Programms dauerhaft im RAM
liegen. Sie sind über ihren Namen auffindbar und werden über ihre Nummer adressiert. ACQU bindet freie
Zeiger, welche im Programm vereinbart sind, an diese externen Variablen. Dadurch sind diese Variablen unter
Umgehung des Namens und der Nummer wie gewöhnliche im Programm vereinbarte Variable verfügbar.

FASN vergibt den Status "befestigt" an Variable vom Typ databox 
UFAS macht die Vergabe rückgängig.

Variable vom Typ databox, welche beim Start des Programms automatisch installiert werden
oder danach durch LN/LX installiert werden, sind von sich aus "befestigt". Das Installieren
kann aber auch durch Steckkarten-Kommandos erfolgen, zB. wenn die Größe der databox
erst zur Laufzeit des Programms bekannt wird. Dann sind sie zunächst unbefestigt.

LN.1 leiht den von einer databox in RAM1 belegten Speicherplatz an mehrere Variable aus, welche vorher als
nicht installiert vereinbart wurden und nach dem Ausleihen den Speicherplatz der databox überdecken.

LX.1 leiht einen Teil des Speicherplatzes einer databox ab einem Startindex an mehrere Variable aus.

Entsprechend LN.2 und LX.2 für RAM2. In RAM1 sind die mehreren
Variablen kurze Variable vom Typ data, oder selber wieder vom
Typ databox, in RAM2 sind sie stets wieder vom Typ databox.

Beim Ausleihen aus einer databox prüft LN/LX, ob die databox befestigt ist. Andernfalls
wäre sie verschiebbar oder könnte uninstalliert werden, so dass Schreibzugriffe auf die
durch das Ausleihen erzeugten Variablen Unheil anrichten könnten.

RELS macht das Ausleihen rückgängig.

Bei den Operationen ACQU, FASN, LN/LX garantiert der Compiler,
dass das zugehörige UACQ, UFAS, RELS im selben Block liegt.
Die jeweilige Operation und das zugehörige Rückgängigmachen
bilden selber wieder einen Block.

'''Ergänzung zu Sprungbedingungen:'''

Es kann abgefragt werden, ob eine 1-oder 2-Byte-Variable
Null ist und ob sie gleich ff bzw. ffff ist.

Die Kommandos =TT.Z und =TT.M können diese Bedingungen
speichern in einem speziellen Byte im RAM, dem TF-Merker.
Dazu schieben sie eine 1 oder 0 von oben auf den TF-Merker.
In gleicher Weise können Steckkarten-Kommandos nCOMMAND
beliebige Bedingungen ermitteln und speichern.

Es gibt bedingte Sprünge, welche die obersten 3 Bit des
TF-Merker mittels einer Wahrheitstabelle abfragen. Dabei
können bis zu 3 Bits wieder vom TF-Merker entfernt werden.

Mittels der Routinen =PP.r, =PZ.r, =PM.r ist es möglich,
solche Bedingungen in einer 1- oder 2-Byte-Variablen zu
speichern, zu verANDen und zu verORen. Damit lassen
sich beliebig komplexe Sprungbedingungen berechnen.

'''Unterprogramme:'''

In der Programmiersprache gibt es keine functions mit
Rückgabewert, sondern nur einfache Unterprogramme, bei
welchen alle Parameter gleichberechtigt sind. Es werden
ausschließlich Zeiger übergeben.

'''Variablen vom Typ FIX:'''

Ihre Werte sind Teil des Programmcodes und liegen dort am Ende.
Der gesamte Speicherbereich dieser Werte kann als "FIXBOX" vom
Programm abgetrennt werden und dann mittels eines speziellen
Werkzeugs bearbeitet werden.

[[Kategorie:FPGA-Projekte]]

8bit-CPU: bo8

2025-08-10T11:39:35Z

Bome:

''von:''   Josef Gnadl ([[Benutzer:Bome|bome]])

Die CPU ist Teil eines Gesamt-Projekts: [[8bit-Computer: bo8h]]. 
Dort findet sich auch eine erläuternde Beschreibung der CPU.

Meine Website zum Projekt: [https://bo8h.de bo8h.de]

Beitrag im Forum: [http://www.mikrocontroller.net/topic/407050 Befehlssatz der bo8-CPU] 
Dort findet sich auch einiges zur Wortbedeutung der Mnemonics.

Im folgenden Text steht der Punkt in den Mnemonics für einen 
hier nicht darstellbaren auf der Grundlinie liegenden Bindestrich.

<pre>
================================================================

P Q R S X Y Z K V Bezeichnung: A7 = U
| | | | | | | |A AB = K
| | | | | | | |B

P Programmzähler Q Rückkehradresse
X Adressregister R Schleifenstartadresse
Y Adressregister S Schleifenzähler
Z Adressregister A Akku B Erweiterung V Carry

----------------------------------------------------------------
a0 .. af Adressleitungen - Tristate
d0 .. d7 Datenleitungen - Tristate
N0 .. N3 Typleitungen - permanente Ausgänge
RES REP Reset Repeat - Eingänge
C0 C1 Takt Takt - Eingänge

0 1 2 3 0 1 2 3 0
/ / / / / / / / /
--==------==------==------==------==---- Cx
[ tA [ tB [ tA [ tB [
====----====----====----====----====---- C0
--====----====----====----====----====-- C1

An beiden Eingängen C0 C1 kann Cx anliegen
Cx darf auch symmetrisch sein (Tastgrad 50%)
Oder es können verschiedene Takte C0 C1 anliegen
C0 liefert die fallende und C1 die steigende Flanke

Die Halbzyklen tA und tB bilden einen Vollzyklus (tA/tB).

Typleitungen ändern ihren Zustand zu Zeitpunkten 0 und 2
Adressen und Write-Daten sind gültig von Zeitpunkt 0 bis 2
Einlesen von Read-Daten zum Zeitpunkt 2

Einlesen von REP zu jedem Zeitpunkt 2 (Mitte eines Vollzyklus)
REP bewirkt Anhängen eines (AR/BN) oder eines weiteren (AR/BN)

RES muss enden mit Zeitpunkt 0 bis rechtzeitig vor Zeitpunkt 1
Zum Zeitpunkt 2 Einlesen der Startadresse nach P und R vom
Adressbus und des Akku A vom Datenbus. Folgender Zeitpunkt 0
Start des Programmms mit (FE/BN) für ersten OpCode.

----------------------------------------------------------------
Typ Name Funktion

0/tB BN normal tB inaktiv
1/tA AR repeat tA inaktiv - wiederhole input
2/tA KA Adressbus gibt K aus - Datenbus inaktiv
3/tA HA Adressbus gibt K aus - input A

4/tB BP memory-page-Umschaltung für P
5/tB BX memory-page-Umschaltung für X
6/tB BY memory-page-Umschaltung für Y
7/tB BZ memory-page-Umschaltung für Z

8/tA FE read / Adresse ist P / OP-Code
9/tA WX write / Adresse ist X
a/tA WY write / Adresse ist Y
b/tA WZ write / Adresse ist Z

c/tA RP read / Adresse ist P
d/tA RX read / Adresse ist X
e/tA RY read / Adresse ist Y
f/tA RZ read / Adresse ist Z

----------------------------------------------------------------
+0 +1 +2 +3 +4 +5 +6 +7

00- H.. ST.S SS.X ST.X SS.Y ST.Y SS.Z ST.Z
08- IX0 IX1 IX2 IX3 IX4 IX5 IX6 IX7
10- IY0 IY1 IY2 IY3 IY4 IY5 IY6 IY7
18- IZ0 IZ1 IZ2 IZ3 IZ4 IZ5 IZ6 IZ7
20- ZO.S SL.S ZO.X SL.X ZO.Y SL.Y ZO.Z SL.Z
28- DX0 DX1 DX2 DX3 DX4 DX5 DX6 DX7
30- DY0 DY1 DY2 DY3 DY4 DY5 DY6 DY7
38- DZ0 DZ1 DZ2 DZ3 DZ4 DZ5 DZ6 DZ7
40- O.VZ O.VS B.VZ B.VS O.UZ O.US B.UZ B.US
48- O.AZ O.AS B.AZ B.AS O.KZ O.KS B.KZ B.KS
50- O.WY O.RP B.WY B.CN GTR ADR GTA NOL
58- IKL DKL IXL DXL IYL DYL IZL DZL
60- AD. LV. AV. SV. GT. AN. XR. NR.
68- STMX LVMX AVMX SVMX GTMX ANMX XRMX NRMX
70- STMY LVMY AVMY SVMY GTMY ANMY XRMY NRMY
78- STMZ LVMZ AVMZ SVMZ GTMZ ANMZ XRMZ NRMZ
80- NO2 TK1 TK2 TK3 TK4 TK5 TK6 TK7
88- TK8 TK9 TKa TKb TKc TKd TKe TKf
90- NO1 TA1 TA2 TA3 TA4 TA5 TA6 TA7
98- ST.B LV.B AV.B SV.B GT.B AN.B XR.B NR.B
a0- EX.S LV.S AV.S SV.S GT.S LD.S AD.S SD.S
a8- EX.X ES.X SW.X RS.X GT.X LD.X AD.X SD.X
b0- EX.Y ES.Y SW.Y RS.Y GT.Y LD.Y AD.Y SD.Y
b8- EX.Z ES.Z SW.Z RS.Z GT.Z LD.Z AD.Z SD.Z
c0- R.VZ R.VS R.UZ R.US R.AZ R.AS R.KZ R.KS
c8- R.WY R.CN R.IX R.DX R.IY R.DY R.IZ R.DZ
d0- GH.S GL.S GH.X GL.X GH.Y GL.Y GH.Z GL.Z
d8- IC.S DC.S IXE DXE IYE DYE IZE DZE
e0- ZO.U SE.U ZO.V SE.V CP.U NE.U CP.V NE.V
e8- PV.A TZ.A PV.B TZ.B RD.A RU.A RD.B RU.B
f0- ZO.A NE.A ZO.B NE.B IV.A DV.A SL.K S.RP
f8- IC.K DC.K ZO.K NE.K IC.A DC.A GT.Q J..

00 .. 3f 1 Byte
40 .. 67 2 Byte
68 .. ff 1 Byte

00 .. 3f 1 Zyklus / Sonderfall 00
40 .. 53 2|3 Zyklen
54 .. 7f 2 Zyklen / Sonderfall 57
80 .. ff 1 Zyklus / Sonderfall 80

Während der Ausführung eines Befehls
wird der nachfolgende OpCode geladen.

----------------------------------------------------------------
nn ist zweites Byte eines 2-Byte-Befehls , % ist X|Y|Z

AN.B A <= A and B
NR.B A <= A nor B
XR.B A <= A xor B
AV.B A <= A+B+V V <= Carry
SV.B A <= A-B-V V <= Carry
LV.B A <= B-A-V V <= Carry
GT.B A <= B
ST.B B <= A

AN. nn A <= A and nn
NR. nn A <= A nor nn
XR. nn A <= A xor nn
AV. nn A <= A+nn+V V <= Carry
SV. nn A <= A-nn-V V <= Carry
LV. nn A <= nn-A-V V <= Carry
GT. nn A <= nn
AD. nn A <= A+nn

ANM% A <= A and (%)
NRM% A <= A nor (%)
XRM% A <= A xor (%)
AVM% A <= A+(%)+V V <= Carry
SVM% A <= A-(%)-V V <= Carry
LVM% A <= (%)-A-V V <= Carry
GTM% A <= (%)
STM% (%) <= A

AV.S K <= K+S+V V <= Carry
SV.S K <= K-S-V V <= Carry
LV.S K <= S-K-V V <= Carry

AD.S K <= K+S
SD.S K <= K-S
LD.S K <= S-K

AD.% K <= K+%
SD.% K <= K-%
LD.% K <= %-K

GT.S K <= S
ST.S S <= K
GT.% K <= %
ST.% % <= K

RS.% S <= %
SS.% % <= S

SL.K B <= A , A <= 0

SL.S S LowByte <= A , S HighByte <= 0
SL.% % LowByte <= A , % HighByte <= 0

GL.S A <= LowByte von S
GH.S A <= HighByte von S
GL.% A <= LowByte von %
GH.% A <= HighByte von %

EX.S Austausch K <> S
EX.% Austausch K <> %
ES.% Austausch S <> %

ZO.S S <= 0
ZO.% % <= 0

ZO.V V <= 0
SE.V V <= 1
NE.V V <= not V
CP.V V <= V xor U

ZO.U U <= 0
SE.U U <= 1
NE.U U <= not U
CP.U U <= V xor U

NE.A A wird logisch negiert
NE.B B wird logisch negiert
NE.K K wird logisch negiert

ZO.A A <= 0
ZO.B B <= 0
ZO.K K <= 0

IV.A A <= A+V V <= Carry
DV.A A <= A-V V <= Carry

IC.A A <= A+1
IC.K K <= K+1
IC.S S <= S+1

DC.A A <= A-1
DC.K K <= K-1
DC.S S <= S-1

PV.A A <= 8-fache Kopie von V , V <= 0
PV.B B <= 8-fache Kopie von V , V <= 0

TZ.A wenn nicht A=0 dann ( V <= 1 )
TZ.B wenn nicht B=0 dann ( V <= 1 )

RD.A A wird nach unten durch V rotiert
Resultat V7654321 V <= Bit0
RD.B B wird nach unten durch V rotiert
Resultat V7654321 V <= Bit0

RU.A A wird nach oben durch V rotiert
Resultat 6543210V V <= Bit7
RU.B B wird nach oben durch V rotiert
Resultat 6543210V V <= Bit7

TAs mit s= 1..7 A wird s Bitstellen nach oben verdreht
Resultat von TA3 ist 43210765

TKs mit s= 1..f K wird s Bitstellen nach oben verdreht

I%s mit s= 0..7 % <= %+s+1
D%s mit s= 0..7 % <= %-s-1

I%E % <= %+1 , und Austausch A <> B
D%E % <= %-1 , und Austausch A <> B

IKL nn K <= K+nn+1
DKL nn K <= K-nn-1
I%L nn % <= %+nn+1
D%L nn % <= %-nn-1

GTA nn K <= 00nn
GTR nn K <= P+nn+3
ADR nn K <= K+P+nn+3

NO1 no operation 1 Zyklus
NO2 no operation 2 Zyklen

NOL nn no operation 2+nn Zyklen falls nn > 0
NOL 00 K <= R 2 Zyklen

GT.Q K <= Q

S.RP R <= P+1
O.RP nn R <= P+2 , P <= P+nn+3

Bedingung cc ist WY always
VZ V ist 0
VS V ist nicht 0
UZ U ist 0
US U ist nicht 0
AZ A ist 0
AS A ist nicht 0
KZ K ist 0
KS K ist nicht 0

O.cc nn wenn cc dann ( P <= P+nn+3 )
B.cc nn wenn cc dann ( P <= P-nn-1 )
B.CN nn wenn nicht S=0 dann ( P <= P-nn-1 , S <= S-1 )

R.cc wenn cc dann ( P <= R )
R.CN wenn nicht S=0 dann ( P <= R , S <= S-1 )
R.I% wenn nicht S=0 dann ( P <= R , S <= S-1 , % <= %+1 )
R.D% wenn nicht S=0 dann ( P <= R , S <= S-1 , % <= %-1 )

Bei O.VZ, O.VS, B.VZ, B.VS, R.VZ, R.VS wird V <= 0

Alle O-,B- Operationen dauern 3 Zyklen | 2 Zyklen
wenn der Sprung erfolgt | nicht erfolgt

J.. P <= K , R <= K , Q <= P+1 , K <= P+1

SW.% Nach dem Einlesen des folgenden OpCodes mit FE wird
statt eines BN ein B% ausgegeben. Das soll extern
eine memory-page-Umschaltung für % bewirken. Das
Resultat muss schon beim folgenden tA bereitstehen.

H.. Nach dem Einlesen des folgenden OpCodes mit FE wird
statt eines BN ein BP ausgegeben. Das soll extern
eine memory-page-Umschaltung für P bewirken. Das
Resultat muss schon beim folgenden tA bereitstehen.

Wenn der eingelesene folgende OpCode ein J.. ist,
ist H.. damit beendet. Dauer von H.. ist 1 Zyklus.

Wenn der OpCode kein J.. ist, folgt ein IO-Zyklus
(HA/BP). Das BP soll die memory-page-Umschaltung
für P wieder aufheben. Dauer von H.. ist 2 Zyklen.

Ausnahme: Wenn der OpCode wieder ein H.. ist,
folgt (KA/BN) statt (HA/BP). Danach bleibt die
CPU im Zustand BN bis ein Reset erfolgt.

</pre>

[[Kategorie: FPGA-Projekte]]

8bit-Computer: bo8h

2025-08-10T00:58:15Z

Bome:

''von:''   Josef Gnadl ([http://www.mikrocontroller.net/articles/Benutzer:Bome bome])

=Übersicht=

Der 8bit-Rechner bo8h existiert bisher nur als Prototyp-Gerät
auf folgenden FPGA-Boards:
* '''Spartan-3A Starter Kit''' von Xilinx
* '''Spartan-3E Starter Board''' und
* '''Nexys2 Board''' von Digilent
* '''Terasic DE0 Board'''
* '''Terasic DE0-CV Board'''
* '''Terasic DE0-nano Board'''
* '''Terasic DE10-Lite Board'''
* '''Terasic Cyclone V GX Starterkit'''

Die Realisierung auf dem Spartan-3A Starter Kit funktioniert auch auf dem ''Spartan-3AN Starter Kit''. 
Das Spartan-3E Starter Board von Digilent ist baugleich mit dem Spartan-3E Starter Kit von Xilinx.

Die '''CPU bo8''' ist eine Eigenentwicklung und hat keine Interrupts. Merkmale des Gesamtsystems
sind der aus mehreren 64KByte-Seiten bestehende Adressraum, das Steckplatz-Konzept,
eine an die Hardware angepasste Programmiersprache und taktgenau berechenbare Programmlaufzeiten.
Der Zeichensatz beinhaltet neben Buchstaben und Sonderzeichen einen Satz von sechzehn Ziffern,
wobei die Ziffern A bis F durch modifizierte Buchstaben dargestellt werden.

Das Prototyp-Gerät besitzt Bildschirm und Tastatur, nutzt [[RS232]] zum Daten-Austausch mit PC
und hat eine SD-Karte mit selbstgestricktem Dateisystem.
Der [[VHDL]]-Code ist so geschrieben, dass leicht weitere Schnittstellen eingebaut werden können.

* Informationen und Downloads gibt es auf [https://bo8h.de bo8h.de].
* Kopie des Download-Files von bo8h.de: [[Datei:Bo8h.zip]]
* Wiki-Artikel zur CPU: [[8bit-CPU: bo8]].
* Beitrag im '''Forum''' Projekte & Code: [http://www.mikrocontroller.net/topic/297603 8bit-Computing mit FPGA].
* Im ''embedded-projects-Journal 14''  gab es einen Artikel ''Ein 8bit-Rechner auf dem Spartan-3A-Starterkit''.

Das Prototyp-Gerät hat 4 freie virtuelle Steckplätze mit je 64KByte, wobei je 32KByte
für Software vorgesehen sind. Damit haben Software-Entwickler die Möglichkeit,
Steckkarten-Software in Eigen-Regie anzubieten. Zur Software-Entwicklung
auf PC gibt es einen in C geschriebenen Assembler und ein Emulations-Programm.

=Die CPU=

''Der Punkt in den Mnemonics steht für einen auf der Grundlinie liegenden Bindestrich.''

Der Akku '''A''' und das Erweiterungsregister '''B''' sind 8-bit. 
Das Doppelregister AB wird abkürzend mit '''K''' bezeichnet. 
Das Vorzeichenbit A7 wird abkürzend mit '''U''' bezeichnet.

Der Programmzähler '''P''' und die Adressregister '''X''', '''Y''', '''Z''' sind 16-bit. 
Das Register '''Q''' erhält bei Sprüngen die Rückkehradresse P+1. 
'''R''' ist Schleifen-Startadresse, '''S''' ist Schleifenzähler (16-bit).

Einziges Flag ist der Carry '''V'''. Bei bedingten Sprüngen kann ausserdem abgefragt werden, ob U/A/K Null sind.

Alle Speicherzugriffe sind 8bit-Zugriffe. 
GTMX lädt nach A den Inhalt der Speicherzelle, auf welche X zeigt. 
STMX speichert A in der Speicherzelle, auf welche X zeigt.

IXE inkrementiert X und tauscht A und B. 
DXE dekrementiert X und tauscht A und B.

Damit lassen sich 2-byte-Speicherzugriffe aufbauen 
nach dem Muster GTMX..IXE..GTMX und STMX..DXE..STMX. 
Es gibt hierfür die Assembler-Makros GTMXI und STMXD.

<pre>
GTMXI lädt eine Adresse von Position X
ST.Y überträgt die Adresse nach Y

GTMXI lädt eine Adresse von Position X
AD.X addiert X
ST.Y überträgt die zu X relative Adresse nach Y

J.. Sprung zu der Adresse, welche in K steht

GTA 59 lädt den Wert 0059 nach K
AD. 35 addiert 35 zu A
J.. Sprung nach 3559

Das lässt sich kürzer schreiben mit Assembler-Makro
/GTA 3559
J

GTR 59 lädt den Wert P+0059+3 nach K
AD. 35 addiert 35 zu A
J.. relativer Sprung nach P+3559+3

Das lässt sich kürzer schreiben mit Assembler-Makro
/GTR 3559
J

GT.Q lädt Rückkehradresse nach K
J Rücksprung aus Unterprogramm
</pre>

Wenn ein Unterprogramm selber J.. ausführen will für andere Zwecke als für den Rücksprung,
muss es vorher die Rückkehradresse sichern. Dazu kann es die Rückkehradresse aus Q laden,
anfangs steht sie aber auch in K und das Laden kann entfallen.

Ausser dem Sprungbefehl J.. gibt es die bedingten Sprünge mit 8bit-Sprungdistanz: 
O.cc nn (Vorwärtssprung falls cc) und B.cc nn (Rückwärtssprung falls cc).

Für schnelle Schleifen gibt es die Repeat-Befehle R.cc. 
Repeat-Befehle gibt es kombiniert mit Schleifenzähler-Dekrementieren und Adresse-Inkrementieren/Dekrementieren.
Die Schleifenstartadresse R wird gesetzt vor dem Schleifenanfang mittels S.RP oder mittels O.RP nn.
Bei letzterem wird gleichzeitig ein Vorwärtssprung ausgeführt. Damit sind Schleifen mit Hineinsprung (while-Schleifen) realisierbar.

Bei J.. wird die Zieladresse auch nach R übertragen. Das garantiert, dass R stets eine Adresse im Nahbereich
des Programmzählers enthält. Eine Anwendung hiervon ergibt sich beim Sprung in eine Tabelle, welche aus
O.WY nn -Befehlen (Vorwärtssprung always) besteht, wobei die O.WY nn alle zur
selben Adresse springen. Die dortige Routine kann durch Auswertung von R die Nummer des O.WY-Befehls ermitteln.

'''Adressierung mehrerer 64K-Seiten:'''

Zu jeder auf dem Adressbus ausgegebenen Adresse wird auf den Steuerleitungen angezeigt, von welchem der
Adressregister P, X, Y, Z sie kommt. Dadurch kann eine externe Logik jedem der Adressregister eine eigene
64K-Speicherseite zuordnen. Die CPU kann spezielle Steuersignale ausgeben, welche die externe Logik
zur Memory-Page-Umschaltung für eines der Adressregister veranlassen sollen.

Der Befehl H.. ist der einzige und universell einsetzbare IO-Befehl.
Es wird K auf dem Adressbus ausgegeben und der Datenbus nach A eingelesen.

Wenn auf H.. ein J.. folgt, dann wirkt H.. stattdessen als Präfix und bewirkt,
dass J.. mit einer Memory-Page-Umschaltung kombiniert wird. So kann die CPU von einer
64K-Seite in eine andere springen, ohne dass es einen gemeinsamen Speicherbereich geben muss.

Bei den Adressregistern X, Y, Z gibt es spezielle Befehle SW.X, SW.Y, SW.Z für die Memory-Page-Umschaltung.

=Die Gesamt-Hardware=

Es gibt vier Memory-Pages mit je 64KByte:

* Page 0: Aktiver Steckplatz
* Page 1: ROM (32K), Text-RAM (16K), Video-RAM (16K)
* Page 2: Haupt-RAM
* Page 3: Zusatz-RAM

Der aktive Steckplatz in Page 0 wird durch ein 3bit-Register SLT ausgewählt.
Neben Page 0 wird auch IO-Adressraum zugeteilt.
Die Steckkarten sollten ein Software-ROM und IO-Hardware enthalten.

Es gibt die 2bit-Register MP, MX, MY, MZ. Diese Register legen fest, in welche der vier Memory-Pages
das betreffende Adressregister P, X, Y, Z zeigt. Ausserdem gibt es die Schattenregister NP, NX, NY, NZ.
Das CPU-Signal zur Memory-Page-Umschaltung für ein bestimmtes Adressregister # bewirkt den
Austausch von M# und N#, wobei # hier für P, X, Y, Z steht.
Beim Sprung mit Memory-Page-Umschaltung  H..  J..  werden also MP und NP getauscht.
Die Schattenregister NP, NX, NY, NZ können über IO-Befehle H.. mit einem Wert 0 bis 3 geladen werden.

Das Display ist 512 Pixel breit und 256 Pixel hoch, die Pixel sind zweiwertig.
Der Video-Generator liest in Dauerschleife das Video-RAM und erzeugt daraus die VGA-Signale.
Einen Hardware-Zeichengenerator gibt es nicht.
Die Software liest die Zeichen aus dem Text-RAM und schreibt deren Pixelmuster ins Video-RAM.
Die Textzeilen sind 64 Zeichen breit.
Durch Invertierung eines Flipflops können Text-RAM und Video-RAM ihre Rollen tauschen.
So kann die CPU im Text-RAM eine neue Grafik erstellen, während noch das alte Video-RAM angezeigt wird.

=Die Programmiersprache=

Der Compiler erzeugt einen Zwischencode, welcher interpretativ abgearbeitet wird. Der
Zwischencode besteht aus Aufrufen vorgefertigter Maschinenroutinen. Nur wenige dieser
Maschinenroutinen sind interner Teil der Sprache, die meisten liegen in den 8 Steckkarten.

Die Sprache ist strikt imperativ. Es besteht eine direkte Eins-zu-Eins-Entsprechung zwischen dem Quelltext und
der Folge der Operationen im Zwischencode. Es gibt im Quelltext keine arithmetischen oder logischen Ausdrücke.

Es gibt in dieser Sprache kein goto, kein break, kein continue, und in jedem Programm oder
Unterprogramm genau 1 return, nämlich am Ende des Programms oder Unterprogramms.

Die Strukturelemente sind folgende:

<pre>
Bedingte Anweisung: IF.c ... ENDF
Verzweigung: IF.c ... ELSE ... ENDE
Case-Struktur: CASE /nn ... NEXT /nn ... LAST
Do-while-Schleife: LOOP ... RP.c
While-Schleife: L.JP ... HERE ... RP.c
</pre>

c steht hier für die Sprungbedingung, nn steht für eine Zahl
fallend bis 00, NEXT /nn ist entsprechend mehrmals anzugeben. 
RP.c steht für wiederhole falls c.

Ebenso wie die Verzweigung zählt die Schleife mit Hineinsprung

<pre>
L.JP ... HERE ... RP.c
</pre>

als ein Block mit zwei Unterblöcken, die strenge Blockstruktur wird durch den Hineinsprung nicht durchbrochen.

Die Blockstruktur wird bei folgenden Operationen gebraucht:

<pre>
ACQU ... UACQ
FASN ... UFAS
LN.1 ... RELS // LN.2 ... RELS
LX.1 ... RELS // LX.2 ... RELS
</pre>

ACQU steht für Aquirieren von Residenten Variablen 
UACU macht das Aquirieren rückgängig

Residente Variable sind Variable, zB. vom Typ databox, welche ausserhalb des Programms dauerhaft im RAM
liegen. Sie sind über ihren Namen auffindbar und werden über ihre Nummer adressiert. ACQU bindet freie
Zeiger, welche im Programm vereinbart sind, an diese externen Variablen. Dadurch sind diese Variablen unter
Umgehung des Namens und der Nummer wie gewöhnliche im Programm vereinbarte Variable verfügbar.

FASN vergibt den Status "befestigt" an Variable vom Typ databox 
UFAS macht die Vergabe rückgängig.

Variable vom Typ databox, welche beim Start des Programms automatisch installiert werden
oder danach durch LN/LX installiert werden, sind von sich aus "befestigt". Das Installieren
kann aber auch durch Steckkarten-Kommandos erfolgen, zB. wenn die Größe der databox
erst zur Laufzeit des Programms bekannt wird. Dann sind sie zunächst unbefestigt.

LN.1 leiht den von einer databox in RAM1 belegten Speicherplatz an mehrere Variable aus, welche vorher als
nicht installiert vereinbart wurden und nach dem Ausleihen den Speicherplatz der databox überdecken.

LX.1 leiht einen Teil des Speicherplatzes einer databox ab einem Startindex an mehrere Variable aus.

Entsprechend LN.2 und LX.2 für RAM2. In RAM1 sind die mehreren
Variablen kurze Variable vom Typ data, oder selber wieder vom
Typ databox, in RAM2 sind sie stets wieder vom Typ databox.

Beim Ausleihen aus einer databox prüft LN/LX, ob die databox befestigt ist. Andernfalls
wäre sie verschiebbar oder könnte uninstalliert werden, so dass Schreibzugriffe auf die
durch das Ausleihen erzeugten Variablen Unheil anrichten könnten.

RELS macht das Ausleihen rückgängig.

Bei den Operationen ACQU, FASN, LN/LX garantiert der Compiler,
dass das zugehörige UACQ, UFAS, RELS im selben Block liegt.
Die jeweilige Operation und das zugehörige Rückgängigmachen
bilden selber wieder einen Block.

'''Ergänzung zu Sprungbedingungen:'''

Es kann abgefragt werden, ob eine 1-oder 2-Byte-Variable
Null ist und ob sie gleich ff bzw. ffff ist.

Die Kommandos =TT.Z und =TT.M können diese Bedingungen
speichern in einem speziellen Byte im RAM, dem TF-Merker.
Dazu schieben sie eine 1 oder 0 von oben auf den TF-Merker.
In gleicher Weise können Steckkarten-Kommandos nCOMMAND
beliebige Bedingungen ermitteln und speichern.

Es gibt bedingte Sprünge, welche die obersten 3 Bit des
TF-Merker mittels einer Wahrheitstabelle abfragen. Dabei
können bis zu 3 Bits wieder vom TF-Merker entfernt werden.

Mittels der Routinen =PP.r, =PZ.r, =PM.r ist es möglich,
solche Bedingungen in einer 1- oder 2-Byte-Variablen zu
speichern, zu verANDen und zu verORen. Damit lassen
sich beliebig komplexe Sprungbedingungen berechnen.

'''Unterprogramme:'''

In der Programmiersprache gibt es keine functions mit
Rückgabewert, sondern nur einfache Unterprogramme, bei
welchen alle Parameter gleichberechtigt sind. Es werden
ausschließlich Zeiger übergeben.

'''Variablen vom Typ FIX:'''

Ihre Werte sind Teil des Programmcodes und liegen dort am Ende.
Der gesamte Speicherbereich dieser Werte kann als "FIXBOX" vom
Programm abgetrennt werden und dann mittels eines speziellen
Werkzeugs bearbeitet werden.

[[Kategorie:FPGA-Projekte]]

8bit-CPU: bo8

2025-08-10T00:53:50Z

Bome:

''von:''   Josef Gnadl ([http://www.mikrocontroller.net/articles/Benutzer:Bome bome])

Die CPU ist Teil eines Gesamt-Projekts: [[8bit-Computer: bo8h]]. 
Dort findet sich auch eine erläuternde Beschreibung der CPU.

Meine Website zum Projekt: [https://bo8h.de bo8h.de]

Beitrag im Forum: [http://www.mikrocontroller.net/topic/407050 Befehlssatz der bo8-CPU] 
Dort findet sich auch einiges zur Wortbedeutung der Mnemonics.

Im folgenden Text steht der Punkt in den Mnemonics für einen 
hier nicht darstellbaren auf der Grundlinie liegenden Bindestrich.

<pre>
================================================================

P Q R S X Y Z K V Bezeichnung: A7 = U
| | | | | | | |A AB = K
| | | | | | | |B

P Programmzähler Q Rückkehradresse
X Adressregister R Schleifenstartadresse
Y Adressregister S Schleifenzähler
Z Adressregister A Akku B Erweiterung V Carry

----------------------------------------------------------------
a0 .. af Adressleitungen - Tristate
d0 .. d7 Datenleitungen - Tristate
N0 .. N3 Typleitungen - permanente Ausgänge
RES REP Reset Repeat - Eingänge
C0 C1 Takt Takt - Eingänge

0 1 2 3 0 1 2 3 0
/ / / / / / / / /
--==------==------==------==------==---- Cx
[ tA [ tB [ tA [ tB [
====----====----====----====----====---- C0
--====----====----====----====----====-- C1

An beiden Eingängen C0 C1 kann Cx anliegen
Cx darf auch symmetrisch sein (Tastgrad 50%)
Oder es können verschiedene Takte C0 C1 anliegen
C0 liefert die fallende und C1 die steigende Flanke

Die Halbzyklen tA und tB bilden einen Vollzyklus (tA/tB).

Typleitungen ändern ihren Zustand zu Zeitpunkten 0 und 2
Adressen und Write-Daten sind gültig von Zeitpunkt 0 bis 2
Einlesen von Read-Daten zum Zeitpunkt 2

Einlesen von REP zu jedem Zeitpunkt 2 (Mitte eines Vollzyklus)
REP bewirkt Anhängen eines (AR/BN) oder eines weiteren (AR/BN)

RES muss enden mit Zeitpunkt 0 bis rechtzeitig vor Zeitpunkt 1
Zum Zeitpunkt 2 Einlesen der Startadresse nach P und R vom
Adressbus und des Akku A vom Datenbus. Folgender Zeitpunkt 0
Start des Programmms mit (FE/BN) für ersten OpCode.

----------------------------------------------------------------
Typ Name Funktion

0/tB BN normal tB inaktiv
1/tA AR repeat tA inaktiv - wiederhole input
2/tA KA Adressbus gibt K aus - Datenbus inaktiv
3/tA HA Adressbus gibt K aus - input A

4/tB BP memory-page-Umschaltung für P
5/tB BX memory-page-Umschaltung für X
6/tB BY memory-page-Umschaltung für Y
7/tB BZ memory-page-Umschaltung für Z

8/tA FE read / Adresse ist P / OP-Code
9/tA WX write / Adresse ist X
a/tA WY write / Adresse ist Y
b/tA WZ write / Adresse ist Z

c/tA RP read / Adresse ist P
d/tA RX read / Adresse ist X
e/tA RY read / Adresse ist Y
f/tA RZ read / Adresse ist Z

----------------------------------------------------------------
+0 +1 +2 +3 +4 +5 +6 +7

00- H.. ST.S SS.X ST.X SS.Y ST.Y SS.Z ST.Z
08- IX0 IX1 IX2 IX3 IX4 IX5 IX6 IX7
10- IY0 IY1 IY2 IY3 IY4 IY5 IY6 IY7
18- IZ0 IZ1 IZ2 IZ3 IZ4 IZ5 IZ6 IZ7
20- ZO.S SL.S ZO.X SL.X ZO.Y SL.Y ZO.Z SL.Z
28- DX0 DX1 DX2 DX3 DX4 DX5 DX6 DX7
30- DY0 DY1 DY2 DY3 DY4 DY5 DY6 DY7
38- DZ0 DZ1 DZ2 DZ3 DZ4 DZ5 DZ6 DZ7
40- O.VZ O.VS B.VZ B.VS O.UZ O.US B.UZ B.US
48- O.AZ O.AS B.AZ B.AS O.KZ O.KS B.KZ B.KS
50- O.WY O.RP B.WY B.CN GTR ADR GTA NOL
58- IKL DKL IXL DXL IYL DYL IZL DZL
60- AD. LV. AV. SV. GT. AN. XR. NR.
68- STMX LVMX AVMX SVMX GTMX ANMX XRMX NRMX
70- STMY LVMY AVMY SVMY GTMY ANMY XRMY NRMY
78- STMZ LVMZ AVMZ SVMZ GTMZ ANMZ XRMZ NRMZ
80- NO2 TK1 TK2 TK3 TK4 TK5 TK6 TK7
88- TK8 TK9 TKa TKb TKc TKd TKe TKf
90- NO1 TA1 TA2 TA3 TA4 TA5 TA6 TA7
98- ST.B LV.B AV.B SV.B GT.B AN.B XR.B NR.B
a0- EX.S LV.S AV.S SV.S GT.S LD.S AD.S SD.S
a8- EX.X ES.X SW.X RS.X GT.X LD.X AD.X SD.X
b0- EX.Y ES.Y SW.Y RS.Y GT.Y LD.Y AD.Y SD.Y
b8- EX.Z ES.Z SW.Z RS.Z GT.Z LD.Z AD.Z SD.Z
c0- R.VZ R.VS R.UZ R.US R.AZ R.AS R.KZ R.KS
c8- R.WY R.CN R.IX R.DX R.IY R.DY R.IZ R.DZ
d0- GH.S GL.S GH.X GL.X GH.Y GL.Y GH.Z GL.Z
d8- IC.S DC.S IXE DXE IYE DYE IZE DZE
e0- ZO.U SE.U ZO.V SE.V CP.U NE.U CP.V NE.V
e8- PV.A TZ.A PV.B TZ.B RD.A RU.A RD.B RU.B
f0- ZO.A NE.A ZO.B NE.B IV.A DV.A SL.K S.RP
f8- IC.K DC.K ZO.K NE.K IC.A DC.A GT.Q J..

00 .. 3f 1 Byte
40 .. 67 2 Byte
68 .. ff 1 Byte

00 .. 3f 1 Zyklus / Sonderfall 00
40 .. 53 2|3 Zyklen
54 .. 7f 2 Zyklen / Sonderfall 57
80 .. ff 1 Zyklus / Sonderfall 80

Während der Ausführung eines Befehls
wird der nachfolgende OpCode geladen.

----------------------------------------------------------------
nn ist zweites Byte eines 2-Byte-Befehls , % ist X|Y|Z

AN.B A <= A and B
NR.B A <= A nor B
XR.B A <= A xor B
AV.B A <= A+B+V V <= Carry
SV.B A <= A-B-V V <= Carry
LV.B A <= B-A-V V <= Carry
GT.B A <= B
ST.B B <= A

AN. nn A <= A and nn
NR. nn A <= A nor nn
XR. nn A <= A xor nn
AV. nn A <= A+nn+V V <= Carry
SV. nn A <= A-nn-V V <= Carry
LV. nn A <= nn-A-V V <= Carry
GT. nn A <= nn
AD. nn A <= A+nn

ANM% A <= A and (%)
NRM% A <= A nor (%)
XRM% A <= A xor (%)
AVM% A <= A+(%)+V V <= Carry
SVM% A <= A-(%)-V V <= Carry
LVM% A <= (%)-A-V V <= Carry
GTM% A <= (%)
STM% (%) <= A

AV.S K <= K+S+V V <= Carry
SV.S K <= K-S-V V <= Carry
LV.S K <= S-K-V V <= Carry

AD.S K <= K+S
SD.S K <= K-S
LD.S K <= S-K

AD.% K <= K+%
SD.% K <= K-%
LD.% K <= %-K

GT.S K <= S
ST.S S <= K
GT.% K <= %
ST.% % <= K

RS.% S <= %
SS.% % <= S

SL.K B <= A , A <= 0

SL.S S LowByte <= A , S HighByte <= 0
SL.% % LowByte <= A , % HighByte <= 0

GL.S A <= LowByte von S
GH.S A <= HighByte von S
GL.% A <= LowByte von %
GH.% A <= HighByte von %

EX.S Austausch K <> S
EX.% Austausch K <> %
ES.% Austausch S <> %

ZO.S S <= 0
ZO.% % <= 0

ZO.V V <= 0
SE.V V <= 1
NE.V V <= not V
CP.V V <= V xor U

ZO.U U <= 0
SE.U U <= 1
NE.U U <= not U
CP.U U <= V xor U

NE.A A wird logisch negiert
NE.B B wird logisch negiert
NE.K K wird logisch negiert

ZO.A A <= 0
ZO.B B <= 0
ZO.K K <= 0

IV.A A <= A+V V <= Carry
DV.A A <= A-V V <= Carry

IC.A A <= A+1
IC.K K <= K+1
IC.S S <= S+1

DC.A A <= A-1
DC.K K <= K-1
DC.S S <= S-1

PV.A A <= 8-fache Kopie von V , V <= 0
PV.B B <= 8-fache Kopie von V , V <= 0

TZ.A wenn nicht A=0 dann ( V <= 1 )
TZ.B wenn nicht B=0 dann ( V <= 1 )

RD.A A wird nach unten durch V rotiert
Resultat V7654321 V <= Bit0
RD.B B wird nach unten durch V rotiert
Resultat V7654321 V <= Bit0

RU.A A wird nach oben durch V rotiert
Resultat 6543210V V <= Bit7
RU.B B wird nach oben durch V rotiert
Resultat 6543210V V <= Bit7

TAs mit s= 1..7 A wird s Bitstellen nach oben verdreht
Resultat von TA3 ist 43210765

TKs mit s= 1..f K wird s Bitstellen nach oben verdreht

I%s mit s= 0..7 % <= %+s+1
D%s mit s= 0..7 % <= %-s-1

I%E % <= %+1 , und Austausch A <> B
D%E % <= %-1 , und Austausch A <> B

IKL nn K <= K+nn+1
DKL nn K <= K-nn-1
I%L nn % <= %+nn+1
D%L nn % <= %-nn-1

GTA nn K <= 00nn
GTR nn K <= P+nn+3
ADR nn K <= K+P+nn+3

NO1 no operation 1 Zyklus
NO2 no operation 2 Zyklen

NOL nn no operation 2+nn Zyklen falls nn > 0
NOL 00 K <= R 2 Zyklen

GT.Q K <= Q

S.RP R <= P+1
O.RP nn R <= P+2 , P <= P+nn+3

Bedingung cc ist WY always
VZ V ist 0
VS V ist nicht 0
UZ U ist 0
US U ist nicht 0
AZ A ist 0
AS A ist nicht 0
KZ K ist 0
KS K ist nicht 0

O.cc nn wenn cc dann ( P <= P+nn+3 )
B.cc nn wenn cc dann ( P <= P-nn-1 )
B.CN nn wenn nicht S=0 dann ( P <= P-nn-1 , S <= S-1 )

R.cc wenn cc dann ( P <= R )
R.CN wenn nicht S=0 dann ( P <= R , S <= S-1 )
R.I% wenn nicht S=0 dann ( P <= R , S <= S-1 , % <= %+1 )
R.D% wenn nicht S=0 dann ( P <= R , S <= S-1 , % <= %-1 )

Bei O.VZ, O.VS, B.VZ, B.VS, R.VZ, R.VS wird V <= 0

Alle O-,B- Operationen dauern 3 Zyklen | 2 Zyklen
wenn der Sprung erfolgt | nicht erfolgt

J.. P <= K , R <= K , Q <= P+1 , K <= P+1

SW.% Nach dem Einlesen des folgenden OpCodes mit FE wird
statt eines BN ein B% ausgegeben. Das soll extern
eine memory-page-Umschaltung für % bewirken. Das
Resultat muss schon beim folgenden tA bereitstehen.

H.. Nach dem Einlesen des folgenden OpCodes mit FE wird
statt eines BN ein BP ausgegeben. Das soll extern
eine memory-page-Umschaltung für P bewirken. Das
Resultat muss schon beim folgenden tA bereitstehen.

Wenn der eingelesene folgende OpCode ein J.. ist,
ist H.. damit beendet. Dauer von H.. ist 1 Zyklus.

Wenn der OpCode kein J.. ist, folgt ein IO-Zyklus
(HA/BP). Das BP soll die memory-page-Umschaltung
für P wieder aufheben. Dauer von H.. ist 2 Zyklen.

Ausnahme: Wenn der OpCode wieder ein H.. ist,
folgt (KA/BN) statt (HA/BP). Danach bleibt die
CPU im Zustand BN bis ein Reset erfolgt.

</pre>

[[Kategorie: FPGA-Projekte]]

Benutzer:Bome

2025-08-10T00:40:31Z

Bome:

Projektseiten auf ''mikrocontroller.net'' 
[[8bit-Computer: bo8h]] 
[[8bit-CPU: bo8]]

Homepage und Kontaktdaten: https://bo8h.de 
Die Domain bomerenzprojekt.de habe ich aufgegeben. 
Besuchen Sie auch https://sedimal.de 
Offtopic: https://invers-gendern.de

Kontaktierung über ''mikrocontroller.net'' 
http://www.mikrocontroller.net/user/show/bome

Forenbeiträge mit Bezug zum Projekt 
[http://www.mikrocontroller.net/topic/297603 8bit-Computing mit FPGA] 
[http://www.mikrocontroller.net/topic/407050 Befehlssatz der bo8-CPU ...] 
[http://www.mikrocontroller.net/topic/244442 8bit-Rechner auf Spartan-3A-Starterkit] 
[http://www.mikrocontroller.net/topic/304134 Tester gesucht ...] 
[http://www.mikrocontroller.net/topic/347716 Gibt es eine Programmiersprache ...] 
Dazu: [[Eine Alternative zur while-Schleife]] 
[http://www.mikrocontroller.net/topic/250009 Hexadezimaler Ziffernsatz] 
[http://www.mikrocontroller.net/topic/goto_post/7292010 Hex-Ziffern auf 7-Segment-Anzeigen] 
[http://www.mikrocontroller.net/topic/429490 Einführung des Hexadezimalsystems] 
[http://www.mikrocontroller.net/topic/goto_post/2781885 Warum ist das Zoll ...]

Was mir sonst noch wichtig ist 
[https://freigeisterhaus.de/viewtopic.php?p=2186553#2186553 freigeisterhaus.de/Bewusstsein-ManyWorlds] 
[https://www.politik-forum.eu/viewtopic.php?f=19&t=48768&start=300#p4480607 www.politik-forum.eu/Was-ist-Bewusstsein?] 
[https://www.mikrocontroller.net/topic/254701 Viele-Welten-Hypothese] [https://www.mikrocontroller.net/topic/459906 Neuromorphe Schaltkreise] 
http://www.spektrum.de/artikel/1159808 
''Siehe Kommentar #11''

Diskussion:Eine Alternative zur while-Schleife

2025-06-30T03:01:04Z

Bome: Pro-Argument

Ist doch überflüssig wie ein Kropf

Der allseits geschätzte frühere Moderator Karlheinz Buchegger fand die Schleife mit Einsprung immerhin "interessant":
https://www.mikrocontroller.net/topic/347716#4046801 --[[Benutzer:Bome|Bome]] ([[Benutzer Diskussion:Bome|Diskussion]]) 03:01, 30. Jun. 2025 (UTC)

Benutzer:Bome

2025-06-30T01:36:33Z

Bome: Artikel-Link

Projektseiten auf ''mikrocontroller.net'' 
[[8bit-Computer: bo8h]] 
[[8bit-CPU: bo8]]

Homepage und Kontaktdaten: https://www.bo8h.de 
Die Domain bomerenzprojekt.de habe ich aufgegeben. 
Besuchen Sie auch https://sedimal.de 
Offtopic: https://invers-gendern.de

Kontaktierung über ''mikrocontroller.net'' 
http://www.mikrocontroller.net/user/show/bome

Forenbeiträge mit Bezug zum Projekt 
[http://www.mikrocontroller.net/topic/297603 8bit-Computing mit FPGA] 
[http://www.mikrocontroller.net/topic/407050 Befehlssatz der bo8-CPU ...] 
[http://www.mikrocontroller.net/topic/244442 8bit-Rechner auf Spartan-3A-Starterkit] 
[http://www.mikrocontroller.net/topic/304134 Tester gesucht ...] 
[http://www.mikrocontroller.net/topic/347716 Gibt es eine Programmiersprache ...] 
Dazu: [[Eine Alternative zur while-Schleife]] 
[http://www.mikrocontroller.net/topic/250009 Hexadezimaler Ziffernsatz] 
[http://www.mikrocontroller.net/topic/goto_post/7292010 Hex-Ziffern auf 7-Segment-Anzeigen] 
[http://www.mikrocontroller.net/topic/429490 Einführung des Hexadezimalsystems] 
[http://www.mikrocontroller.net/topic/goto_post/2781885 Warum ist das Zoll ...]

Was mir sonst noch wichtig ist 
[https://freigeisterhaus.de/viewtopic.php?p=2186553#2186553 freigeisterhaus.de/Bewusstsein-ManyWorlds] 
[https://www.politik-forum.eu/viewtopic.php?f=19&t=48768&start=300#p4480607 www.politik-forum.eu/Was-ist-Bewusstsein?] 
[https://www.mikrocontroller.net/topic/254701 Viele-Welten-Hypothese] [https://www.mikrocontroller.net/topic/459906 Neuromorphe Schaltkreise] 
http://www.spektrum.de/artikel/1159808 
''Siehe Kommentar #11''

Eine Alternative zur while-Schleife

2025-06-11T11:52:09Z

Bome: textlich verbessert

Wenn bei einer while-Schleife das Ermitteln der Abbruchbedingung sehr umfangreich ist, wird man diese Ermittlung in eine Funktion packen mit der Abbruchbedingung als Rückgabewert, und in der Schleife den Rückgabewert abfragen. Es sind jedoch auch Programmiersprachen denkbar, welche anstelle von Funktionen lediglich einfache Unterprogramme mit gleichberechtigten Parametern ohne expliziten Rückgabewert erlauben. Eine Alternative zur while-Schleife, die beliebig umfangreiches Ermitteln der Abbruchbedingung erlaubt, ohne dass man das Ermitteln in eine Funktion auslagern muss, wäre die '''Schleife mit Einsprung''', deren Schlüsselwörter hier '''l-jp''' und '''there''' und '''repeat-if''' heissen sollen. '''repeat-if''' springt zum Start des Schleifenkörpers. '''l-jp''' springt zur Marke '''there'''.

'''l-jp''' 
   Schleifenkörper 
'''there''' 
   Ermitteln der Abbruchbedingung mit Ergebnis x=0 
'''repeat-if''' x>0

ersetzt die while-Schleife 
'''while''' test>0 
   Schleifenkörper

mit der separat vereinbarten Funktion test 
'''function''' test 
   Ermitteln der Abbruchbedingung mit Ergebnis x=0 
'''return('''x''')'''

Beitrag im Forum 
[https://www.mikrocontroller.net/topic/347716 Gibt es eine Programmiersprache mit diesem Schleifentyp?]

[[Kategorie:Algorithmen und Arithmetik]]
[[Kategorie:Programmiersprachen]]

Eine Alternative zur while-Schleife

2025-06-10T14:42:36Z

Bome: Link zum Forum

Wenn bei einer while-Schleife das Ermitteln der Abbruchbedingung sehr umfangreich ist, wird man diese Ermittlung in eine Funktion packen mit der Abbruchbedingung als Rückgabewert, und in der Schleife den Rückgabewert abfragen. Es sind jedoch auch Programmiersprachen denkbar, welche anstelle von Funktionen lediglich einfache Unterprogramme mit gleichberechtigten Parametern ohne expliziten Rückgabewert erlauben. In diesem Fall bietet sich als Alternative zur while-Schleife die '''Schleife mit Einsprung''' an, deren Schlüsselwörter hier '''l-jp''' und '''there''' und '''repeat-if''' heissen sollen. '''repeat-if''' springt zum Start des Schleifenkörpers. '''l-jp''' springt zur Marke '''there'''.

'''l-jp''' 
   Schleifenkörper 
'''there''' 
   Ermitteln der Abbruchbedingung mit Ergebnis x=0 
'''repeat-if''' x>0

ersetzt die while-Schleife 
'''while''' test>0 
   Schleifenkörper

mit der separat vereinbarten Funktion test 
'''function''' test 
   Ermitteln der Abbruchbedingung mit Ergebnis x=0 
'''return('''x''')'''

Beitrag im Forum 
[https://www.mikrocontroller.net/topic/347716 Gibt es eine Programmiersprache mit diesem Schleifentyp?]

[[Kategorie:Algorithmen und Arithmetik]]
[[Kategorie:Programmiersprachen]]

Eine Alternative zur while-Schleife

2025-06-10T12:42:45Z

Bome:

Wenn bei einer while-Schleife das Ermitteln der Abbruchbedingung sehr umfangreich ist, wird man diese Ermittlung in eine Funktion packen mit der Abbruchbedingung als Rückgabewert, und in der Schleife den Rückgabewert abfragen. Es sind jedoch auch Programmiersprachen denkbar, welche anstelle von Funktionen lediglich einfache Unterprogramme mit gleichberechtigten Parametern ohne expliziten Rückgabewert erlauben. In diesem Fall bietet sich als Alternative zur while-Schleife die '''Schleife mit Einsprung''' an, deren Schlüsselwörter hier '''l-jp''' und '''there''' und '''repeat-if''' heissen sollen. '''repeat-if''' springt zum Start des Schleifenkörpers. '''l-jp''' springt zur Marke '''there'''.

'''l-jp''' 
   Schleifenkörper 
'''there''' 
   Ermitteln der Abbruchbedingung mit Ergebnis x=0 
'''repeat-if''' x>0

ersetzt die while-Schleife 
'''while''' test>0 
   Schleifenkörper

mit der separat vereinbarten Funktion test 
'''function''' test 
   Ermitteln der Abbruchbedingung mit Ergebnis x=0 
'''return('''x''')'''

Forenbeitrag dazu: 
https://www.mikrocontroller.net/topic/347716

[[Kategorie:Algorithmen und Arithmetik]]
[[Kategorie:Programmiersprachen]]

Eine Alternative zur while-Schleife

2025-06-10T12:41:28Z

Bome:

Wenn bei einer while-Schleife das Ermitteln der Abbruchbedingung sehr umfangreich ist, wird man diese Ermittlung in eine Funktion packen mit der Abbruchbedingung als Rückgabewert, und in der Schleife den Rückgabewert abfragen . Es sind jedoch auch Programmiersprachen denkbar, welche anstelle von Funktionen lediglich einfache Unterprogramme mit gleichberechtigten Parametern ohne expliziten Rückgabewert erlauben. In diesem Fall bietet sich als Alternative zur while-Schleife die '''Schleife mit Einsprung''' an, deren Schlüsselwörter hier '''l-jp''' und '''there''' und '''repeat-if''' heissen sollen. '''repeat-if''' springt zum Start des Schleifenkörpers. '''l-jp''' springt zur Marke '''there'''.

'''l-jp''' 
   Schleifenkörper 
'''there''' 
   Ermitteln der Abbruchbedingung mit Ergebnis x=0 
'''repeat-if''' x>0

ersetzt die while-Schleife 
'''while''' test>0 
   Schleifenkörper

mit der separat vereinbarten Funktion test 
'''function''' test 
   Ermitteln der Abbruchbedingung mit Ergebnis x=0 
'''return('''x''')'''

Forenbeitrag dazu: 
https://www.mikrocontroller.net/topic/347716

[[Kategorie:Algorithmen und Arithmetik]]
[[Kategorie:Programmiersprachen]]

Eine Alternative zur while-Schleife

2025-06-10T01:47:22Z

Bome:

Wenn bei einer while-Schleife das Ermitteln der Abbruchbedingung sehr umfangreich ist, kann man diese Ermittlung in eine Funktion packen und der Funktion die Abbruchbedingung als Ergebnis zuweisen. Es sind jedoch auch Programmiersprachen denkbar, welche anstelle von Funktionen lediglich einfache Unterprogramme mit gleichberechtigten Parametern ohne explizites Ergebnis erlauben. In diesem Fall bietet sich als Alternative zur while-Schleife die '''Schleife mit Einsprung''' an, deren Schlüsselwörter hier '''l-jp''' und '''there''' und '''repeat-if''' heissen sollen. 
'''repeat-if''' springt zum Start des Schleifenkörpers. '''l-jp''' springt zur Marke '''there'''.

'''l-jp''' 
   Schleifenkörper 
'''there''' 
   Ermitteln der Abbruchbedingung mit Ergebnis x=0 
'''repeat-if''' x>0

ersetzt die while-Schleife 
'''while''' test>0 
   Schleifenkörper

mit der separat vereinbarten Funktion test 
'''function''' test 
   Ermitteln der Abbruchbedingung mit Ergebnis x=0 
'''return('''x''')'''

Forenbeitrag dazu: 
https://www.mikrocontroller.net/topic/347716

[[Kategorie:Algorithmen und Arithmetik]]
[[Kategorie:Programmiersprachen]]

Eine Alternative zur while-Schleife

2025-06-09T23:43:19Z

Bome: Kategorie

Wenn bei einer while-Schleife das Ermitteln der Abbruchbedingung sehr umfangreich ist, kann man diese Ermittlung in eine Funktion packen und der Funktion die Abbruchbedingung als Ergebnis zuweisen. Es sind jedoch auch einfache Programmiersprachen denkbar, welche anstelle von Funktionen lediglich Unterprogramme mit gleichberechtigten Parametern ohne explizites Ergebnis erlauben. In diesem Fall bietet sich als Alternative zur while-Schleife die '''Schleife mit Einsprung''' an, deren Schlüsselwörter hier '''l-jp''' und '''there''' und '''repeat-if''' heissen sollen. 
'''repeat-if''' springt zum Start des Schleifenkörpers. '''l-jp''' springt zur Marke '''there'''.

'''l-jp''' 
   Schleifenkörper 
'''there''' 
   Ermitteln der Abbruchbedingung mit Ergebnis x=0 
'''repeat-if''' x>0

ersetzt die while-Schleife 
'''while''' test>0 
   Schleifenkörper

mit der separat vereinbarten Funktion test 
'''function''' test 
   Ermitteln der Abbruchbedingung mit Ergebnis x=0 
'''return('''x''')'''

Forenbeitrag dazu: 
https://www.mikrocontroller.net/topic/347716

[[Kategorie:Algorithmen und Arithmetik]]
[[Kategorie:Programmiersprachen]]

Eine Alternative zur while-Schleife

2025-06-09T20:26:26Z

Bome: Schleife mit Einsprung

Wenn bei einer while-Schleife das Ermitteln der Abbruchbedingung sehr umfangreich ist, kann man diese Ermittlung in eine Funktion packen und der Funktion die Abbruchbedingung als Ergebnis zuweisen. Es sind jedoch auch einfache Programmiersprachen denkbar, welche anstelle von Funktionen lediglich Unterprogramme mit gleichberechtigten Parametern ohne explizites Ergebnis beinhalten. In diesem Fall bietet sich als Alternative zur while-Schleife die '''Schleife mit Einsprung''' an, deren Schlüsselworte hier '''l-jp''' und '''there''' und '''repeat-if''' heissen sollen.

'''l-jp''' 
   Schleifenkörper 
'''there''' 
   Ermitteln der Abbruchbedingung mit Ergebnis x=0 
'''repeat-if''' x>0

ersetzt die while-Schleife 
'''while''' test>0 
   Schleifenkörper

mit der separat vereinbarten Funktion test 
'''function''' test 
   Ermitteln der Abbruchbedingung mit Ergebnis x=0 
'''return('''x''')'''

Forenbeitrag dazu: 
https://www.mikrocontroller.net/topic/347716

[[Kategorie:Algorithmen und Arithmetik]]

Benutzer:Bome

2025-05-16T23:10:57Z

Bome:

Projektseiten auf ''mikrocontroller.net'' 
[[8bit-Computer: bo8h]] 
[[8bit-CPU: bo8]]

Homepage und Kontaktdaten: https://www.bo8h.de 
Die Domain bomerenzprojekt.de habe ich aufgegeben. 
Besuchen Sie auch https://sedimal.de 
Offtopic: https://invers-gendern.de

Kontaktierung über ''mikrocontroller.net'' 
http://www.mikrocontroller.net/user/show/bome

Forenbeiträge mit Bezug zum Projekt 
[http://www.mikrocontroller.net/topic/297603 8bit-Computing mit FPGA] 
[http://www.mikrocontroller.net/topic/407050 Befehlssatz der bo8-CPU ...] 
[http://www.mikrocontroller.net/topic/244442 8bit-Rechner auf Spartan-3A-Starterkit] 
[http://www.mikrocontroller.net/topic/304134 Tester gesucht ...] 
[http://www.mikrocontroller.net/topic/347716 Gibt es eine Programmiersprache ...] 
[http://www.mikrocontroller.net/topic/250009 Hexadezimaler Ziffernsatz] 
[http://www.mikrocontroller.net/topic/goto_post/7292010 Hex-Ziffern auf 7-Segment-Anzeigen] 
[http://www.mikrocontroller.net/topic/429490 Einführung des Hexadezimalsystems] 
[http://www.mikrocontroller.net/topic/goto_post/2781885 Warum ist das Zoll ...]

Was mir sonst noch wichtig ist 
[https://freigeisterhaus.de/viewtopic.php?p=2186553#2186553 freigeisterhaus.de/Bewusstsein-ManyWorlds] 
[https://www.politik-forum.eu/viewtopic.php?f=19&t=48768&start=300#p4480607 www.politik-forum.eu/Was-ist-Bewusstsein?] 
[https://www.mikrocontroller.net/topic/254701 Viele-Welten-Hypothese] [https://www.mikrocontroller.net/topic/459906 Neuromorphe Schaltkreise] 
http://www.spektrum.de/artikel/1159808 
''Siehe Kommentar #11''

Datei:Bo8h.zip

2025-02-03T21:45:06Z

Bome: Bome lud eine neue Version von Datei:Bo8h.zip hoch

Benutzer:Bome

2025-01-25T16:38:12Z

Bome: Links

Projektseiten auf ''mikrocontroller.net'' 
[[8bit-Computer: bo8h]] 
[[8bit-CPU: bo8]]

Homepage und Kontaktdaten: https://www.bo8h.de 
Die Domain bomerenzprojekt.de habe ich aufgegeben. 
Besuchen Sie auch https://sedimal.de

Kontaktierung über ''mikrocontroller.net'' 
http://www.mikrocontroller.net/user/show/bome

Forenbeiträge mit Bezug zum Projekt 
[http://www.mikrocontroller.net/topic/297603 8bit-Computing mit FPGA] 
[http://www.mikrocontroller.net/topic/407050 Befehlssatz der bo8-CPU ...] 
[http://www.mikrocontroller.net/topic/244442 8bit-Rechner auf Spartan-3A-Starterkit] 
[http://www.mikrocontroller.net/topic/304134 Tester gesucht ...] 
[http://www.mikrocontroller.net/topic/347716 Gibt es eine Programmiersprache ...] 
[http://www.mikrocontroller.net/topic/250009 Hexadezimaler Ziffernsatz] 
[http://www.mikrocontroller.net/topic/goto_post/7292010 Hex-Ziffern auf 7-Segment-Anzeigen] 
[http://www.mikrocontroller.net/topic/429490 Einführung des Hexadezimalsystems] 
[http://www.mikrocontroller.net/topic/goto_post/2781885 Warum ist das Zoll ...]

Was mir sonst noch wichtig ist 
[https://freigeisterhaus.de/viewtopic.php?p=2186553#2186553 freigeisterhaus.de/Bewusstsein-ManyWorlds] 
[https://www.politik-forum.eu/viewtopic.php?f=19&t=48768&start=300#p4480607 www.politik-forum.eu/Was-ist-Bewusstsein?] 
[https://www.mikrocontroller.net/topic/254701 Viele-Welten-Hypothese] [https://www.mikrocontroller.net/topic/459906 Neuromorphe Schaltkreise] 
http://www.spektrum.de/artikel/1159808 
''Siehe Kommentar #11''

Benutzer:Bome

2025-01-20T04:46:34Z

Bome:

Projektseiten auf ''mikrocontroller.net'' 
[[8bit-Computer: bo8h]] 
[[8bit-CPU: bo8]]

Homepage und Kontaktdaten: https://www.bo8h.de 
Die Domain bomerenzprojekt.de habe ich aufgegeben. 
Besuchen Sie auch https://sedimal.de

Kontaktierung über ''mikrocontroller.net'' 
http://www.mikrocontroller.net/user/show/bome

Forenbeiträge mit Bezug zum Projekt 
[http://www.mikrocontroller.net/topic/297603 8bit-Computing mit FPGA] 
[http://www.mikrocontroller.net/topic/407050 Befehlssatz der bo8-CPU ...] 
[http://www.mikrocontroller.net/topic/244442 8bit-Rechner auf Spartan-3A-Starterkit] 
[http://www.mikrocontroller.net/topic/304134 Tester gesucht ...] 
[http://www.mikrocontroller.net/topic/347716 Gibt es eine Programmiersprache ...] 
[http://www.mikrocontroller.net/topic/250009 Hexadezimaler Ziffernsatz] 
[http://www.mikrocontroller.net/topic/goto_post/7292010 Hex-Ziffern auf 7-Segment-Anzeigen] 
[http://www.mikrocontroller.net/topic/429490 Einführung des Hexadezimalsystems] 
[http://www.mikrocontroller.net/topic/goto_post/2781885 Warum ist das Zoll ...]

Was mir sonst noch wichtig ist 
[https://freigeisterhaus.de/viewtopic.php?p=2186553#2186553 freigeisterhaus.de/Bewusstsein-ManyWorlds] 
[https://www.politik-forum.eu/viewtopic.php?f=19&t=48768&start=300#p4480607 www.politik-forum.eu/Was-ist-Bewusstsein?] 
http://www.mikrocontroller.net/topic/254701 
http://www.spektrum.de/artikel/1159808 
''Siehe Kommentar #11''

Zahlensysteme

2025-01-20T03:24:34Z

Bome: /* Siehe auch */

== Übersicht ==
In der Programmierung werden vier Zahlensysteme verwendet:
'''dezimal''', '''hexadezimal''', '''oktal''', '''binär''' (besser: '''dual''').
{| border=1 cellspacing=0 cellpadding=4
! Zahlensystem
! Basis
! Ziffern
|-
|dezimal || 10 || 0 .. 9
|-
|hexadezimal || 16 || 0 .. 9, A .. F
|-
|oktal || 8 || 0 .. 7
|-
|dual || 2 || 0 .. 1
|}

Einige Zahlenbeispiele:
{| border=1 cellspacing=0 cellpadding=4
!dezimal
!hexadezimal
!oktal
!dual
|-
| 0 || 00 || 000 || 00000000
|-
| 1 || 01 || 001 || 00000001
|-
| 15 || 0F || 017 || 00001111
|-
| 100 || 64 || 144 || 01100100
|-
| 255 || FF || 377 || 11111111
|}

== Darstellung ==
=== Hexadezimal ===
'''Hexadezimal'''zahlen werden meistens (z. B. in [[C]] oder im [[AVR]]-[[Assembler]]) mit dem Prefix "0x" geschrieben, also z. B. 0x3A; auch anzutreffen ist die Schreibweise mit einem führenden "$" (z. B. $3A).

Die vierstellige hexadezimale Schreibweise wird gerne verwendet um zwei [[Digitaltechnik|Bytes]] zusammenzufassen: 
Bsp.: 0x010F => 01 ist das High Byte, 0F ist das Low Byte.

=== Oktal ===
'''Oktal'''zahlen schreibt man in [[C]] mit einer führenden "0".

C-Programmierer sollten sich die führende Null bei Oktalzahlen unbedingt merken, auch wenn sie keine Oktalzahlen verwenden wollen. Denn es bedeutet, dass man Dezimalzahlen nicht mit führenden Nullen schreiben darf. "64" und "064" sind zwei völlig verschiedene Zahlen. Das erste ist die dezimale Zahl 64, das zweite die oktale Zahl 64, was der dezimalen Zahl 52 entspricht. Das gilt auch für AVR-ASM.

=== Binär ===
'''Binär'''zahlen schreibt man im AVR-Assembler mit "0b" am Anfang, z. B. 0b00110100. In [[C]]-Programmen ist die direkte Eingabe von Binärzahlen nicht möglich, es lassen sich aber [[C Makros|Makros]] zu diesem Zweck schreiben. Einige Compiler verfügen über eine Spracherweiterung, bei der meist der Präfix "0b" für Binärzahlen benutzt wird.

=== Intel-Syntax ===
[[Assembler]] mit Intel-Syntax (z. B. für 80x86 oder [[8051]]) verwenden dagegen zur Kennzeichnung keinen Präfix sondern einen Postfix. Für Hexzahlen gilt also z. B. die Notation 0A5H, für Oktalzahlen 245O (oder 245Q) und für Binärzahlen dementsprechend 10100101B.

== Verschiedenes ==
=== Anmerkung zu Oktalzahlen ===
Oktalzahlen sind in der Mikrocontroller-Programmierung heute seltener anzutreffen. Praktisch sind sie vor allem dann, wenn Binärzahlen aus irgend einem Grund in Gruppen von jeweils drei Bit strukturiert sind. Das gilt z. B. für die Datei-Zugriffsrechte unter [[Unix]]/[[Linux]], die sich bequem durch Angabe einer Oktalzahl einstellen lassen (z. B. entspricht "751" dem Bitmuster "111 101 001" oder "rwxr-x--x" in der üblichen Zugriffsrecht-Darstellung.) .

=== Umrechnung ===
Viele Taschenrechner können die Zahlensysteme umrechnen, so auch der Windows-Taschenrechner oder der UNIX-Taschenrechner bc. Wie die Umrechnung mathematisch funktioniert, ist [http://www.tutorials.at/einfuehrung/03-zahlensysteme.html hier] beschrieben. Zur Umrechnung von Nachkommastellen siehe [https://www.studienservice.de/thema/dezimal-in-hexadezimal.71337/#post-1140103 hier].

== Siehe auch ==
* Forenthread [https://www.mikrocontroller.net/topic/429490 Einführung des Hexadezimalsystems] und Website [https://sedimal.de sedimal.de] mit der Intention der Einführung des hexadezimalen Zahlensystems im Alltag

[[Kategorie:Algorithmen und Arithmetik]]

Datei:Bo8h.zip

2024-12-28T13:59:06Z

Bome: Bome lud eine neue Version von Datei:Bo8h.zip hoch

8bit-Computer: bo8h

2024-12-24T14:23:33Z

Bome: /* Übersicht */ Weitere FPGA-Boards

''von:''   Josef Gnadl ([http://www.mikrocontroller.net/articles/Benutzer:Bome bome])

=Übersicht=

Der 8bit-Rechner bo8h existiert bisher nur als Prototyp-Gerät
auf folgenden FPGA-Boards:
* '''Spartan-3A Starter Kit''' von Xilinx
* '''Spartan-3E Starter Board''' und
* '''Nexys2 Board''' von Digilent
* '''Terasic DE0 Board'''
* '''Terasic DE0-CV Board'''
* '''Terasic DE0-nano Board'''
* '''Terasic DE10-Lite Board'''
* '''Terasic Cyclone V GX Starterkit'''

Die Realisierung auf dem Spartan-3A Starter Kit funktioniert auch auf dem ''Spartan-3AN Starter Kit''. 
Das Spartan-3E Starter Board von Digilent ist baugleich mit dem Spartan-3E Starter Kit von Xilinx.

Die '''CPU bo8''' ist eine Eigenentwicklung und hat keine Interrupts. Merkmale des Gesamtsystems
sind der aus mehreren 64KByte-Seiten bestehende Adressraum, das Steckplatz-Konzept,
eine an die Hardware angepasste Programmiersprache und taktgenau berechenbare Programmlaufzeiten.
Der Zeichensatz beinhaltet neben Buchstaben und Sonderzeichen einen Satz von sechzehn Ziffern,
wobei die Ziffern A bis F durch modifizierte Buchstaben dargestellt werden.

Das Prototyp-Gerät besitzt Bildschirm und Tastatur, nutzt [[RS232]] zum Daten-Austausch mit PC
und hat eine SD-Karte mit selbstgestricktem Dateisystem.
Der [[VHDL]]-Code ist so geschrieben, dass leicht weitere Schnittstellen eingebaut werden können.

* Informationen und Downloads gibt es auf [http://www.bo8h.de bo8h.de].
* Kopie des Download-Files von bo8h.de: [[Datei:Bo8h.zip]]
* Wiki-Artikel zur CPU: [[8bit-CPU: bo8]].
* Beitrag im '''Forum''' Projekte & Code: [http://www.mikrocontroller.net/topic/297603 8bit-Computing mit FPGA].
* Im ''embedded-projects-Journal 14''  gab es einen Artikel ''Ein 8bit-Rechner auf dem Spartan-3A-Starterkit''.

Das Prototyp-Gerät hat 4 freie virtuelle Steckplätze mit je 64KByte, wobei je 32KByte
für Software vorgesehen sind. Damit haben Software-Entwickler die Möglichkeit,
Steckkarten-Software in Eigen-Regie anzubieten. Zur Software-Entwicklung
auf PC gibt es einen in C geschriebenen Assembler und ein Emulations-Programm.

=Die CPU=

''Der Punkt in den Mnemonics steht für einen auf der Grundlinie liegenden Bindestrich.''

Der Akku '''A''' und das Erweiterungsregister '''B''' sind 8-bit. 
Das Doppelregister AB wird abkürzend mit '''K''' bezeichnet. 
Das Vorzeichenbit A7 wird abkürzend mit '''U''' bezeichnet.

Der Programmzähler '''P''' und die Adressregister '''X''', '''Y''', '''Z''' sind 16-bit. 
Das Register '''Q''' erhält bei Sprüngen die Rückkehradresse P+1. 
'''R''' ist Schleifen-Startadresse, '''S''' ist Schleifenzähler (16-bit).

Einziges Flag ist der Carry '''V'''. Bei bedingten Sprüngen kann ausserdem abgefragt werden, ob U/A/K Null sind.

Alle Speicherzugriffe sind 8bit-Zugriffe. 
GTMX lädt nach A den Inhalt der Speicherzelle, auf welche X zeigt. 
STMX speichert A in der Speicherzelle, auf welche X zeigt.

IXE inkrementiert X und tauscht A und B. 
DXE dekrementiert X und tauscht A und B.

Damit lassen sich 2-byte-Speicherzugriffe aufbauen 
nach dem Muster GTMX..IXE..GTMX und STMX..DXE..STMX. 
Es gibt hierfür die Assembler-Makros GTMXI und STMXD.

<pre>
GTMXI lädt eine Adresse von Position X
ST.Y überträgt die Adresse nach Y

GTMXI lädt eine Adresse von Position X
AD.X addiert X
ST.Y überträgt die zu X relative Adresse nach Y

J.. Sprung zu der Adresse, welche in K steht

GTA 59 lädt den Wert 0059 nach K
AD. 35 addiert 35 zu A
J.. Sprung nach 3559

Das lässt sich kürzer schreiben mit Assembler-Makro
/GTA 3559
J

GTR 59 lädt den Wert P+0059+3 nach K
AD. 35 addiert 35 zu A
J.. relativer Sprung nach P+3559+3

Das lässt sich kürzer schreiben mit Assembler-Makro
/GTR 3559
J

GT.Q lädt Rückkehradresse nach K
J Rücksprung aus Unterprogramm
</pre>

Wenn ein Unterprogramm selber J.. ausführen will für andere Zwecke als für den Rücksprung,
muss es vorher die Rückkehradresse sichern. Dazu kann es die Rückkehradresse aus Q laden,
anfangs steht sie aber auch in K und das Laden kann entfallen.

Ausser dem Sprungbefehl J.. gibt es die bedingten Sprünge mit 8bit-Sprungdistanz: 
O.cc nn (Vorwärtssprung falls cc) und B.cc nn (Rückwärtssprung falls cc).

Für schnelle Schleifen gibt es die Repeat-Befehle R.cc. 
Repeat-Befehle gibt es kombiniert mit Schleifenzähler-Dekrementieren und Adresse-Inkrementieren/Dekrementieren.
Die Schleifenstartadresse R wird gesetzt vor dem Schleifenanfang mittels S.RP oder mittels O.RP nn.
Bei letzterem wird gleichzeitig ein Vorwärtssprung ausgeführt. Damit sind Schleifen mit Hineinsprung (while-Schleifen) realisierbar.

Bei J.. wird die Zieladresse auch nach R übertragen. Das garantiert, dass R stets eine Adresse im Nahbereich
des Programmzählers enthält. Eine Anwendung hiervon ergibt sich beim Sprung in eine Tabelle, welche aus
O.WY nn -Befehlen (Vorwärtssprung always) besteht, wobei die O.WY nn alle zur
selben Adresse springen. Die dortige Routine kann durch Auswertung von R die Nummer des O.WY-Befehls ermitteln.

'''Adressierung mehrerer 64K-Seiten:'''

Zu jeder auf dem Adressbus ausgegebenen Adresse wird auf den Steuerleitungen angezeigt, von welchem der
Adressregister P, X, Y, Z sie kommt. Dadurch kann eine externe Logik jedem der Adressregister eine eigene
64K-Speicherseite zuordnen. Die CPU kann spezielle Steuersignale ausgeben, welche die externe Logik
zur Memory-Page-Umschaltung für eines der Adressregister veranlassen sollen.

Der Befehl H.. ist der einzige und universell einsetzbare IO-Befehl.
Es wird K auf dem Adressbus ausgegeben und der Datenbus nach A eingelesen.

Wenn auf H.. ein J.. folgt, dann wirkt H.. stattdessen als Präfix und bewirkt,
dass J.. mit einer Memory-Page-Umschaltung kombiniert wird. So kann die CPU von einer
64K-Seite in eine andere springen, ohne dass es einen gemeinsamen Speicherbereich geben muss.

Bei den Adressregistern X, Y, Z gibt es spezielle Befehle SW.X, SW.Y, SW.Z für die Memory-Page-Umschaltung.

=Die Gesamt-Hardware=

Es gibt vier Memory-Pages mit je 64KByte:

* Page 0: Aktiver Steckplatz
* Page 1: ROM (32K), Text-RAM (16K), Video-RAM (16K)
* Page 2: Haupt-RAM
* Page 3: Zusatz-RAM

Der aktive Steckplatz in Page 0 wird durch ein 3bit-Register SLT ausgewählt.
Neben Page 0 wird auch IO-Adressraum zugeteilt.
Die Steckkarten sollten ein Software-ROM und IO-Hardware enthalten.

Es gibt die 2bit-Register MP, MX, MY, MZ. Diese Register legen fest, in welche der vier Memory-Pages
das betreffende Adressregister P, X, Y, Z zeigt. Ausserdem gibt es die Schattenregister NP, NX, NY, NZ.
Das CPU-Signal zur Memory-Page-Umschaltung für ein bestimmtes Adressregister # bewirkt den
Austausch von M# und N#, wobei # hier für P, X, Y, Z steht.
Beim Sprung mit Memory-Page-Umschaltung  H..  J..  werden also MP und NP getauscht.
Die Schattenregister NP, NX, NY, NZ können über IO-Befehle H.. mit einem Wert 0 bis 3 geladen werden.

Das Display ist 512 Pixel breit und 256 Pixel hoch, die Pixel sind zweiwertig.
Der Video-Generator liest in Dauerschleife das Video-RAM und erzeugt daraus die VGA-Signale.
Einen Hardware-Zeichengenerator gibt es nicht.
Die Software liest die Zeichen aus dem Text-RAM und schreibt deren Pixelmuster ins Video-RAM.
Die Textzeilen sind 64 Zeichen breit.
Durch Invertierung eines Flipflops können Text-RAM und Video-RAM ihre Rollen tauschen.
So kann die CPU im Text-RAM eine neue Grafik erstellen, während noch das alte Video-RAM angezeigt wird.

=Die Programmiersprache=

Der Compiler erzeugt einen Zwischencode, welcher interpretativ abgearbeitet wird. Der
Zwischencode besteht aus Aufrufen vorgefertigter Maschinenroutinen. Nur wenige dieser
Maschinenroutinen sind interner Teil der Sprache, die meisten liegen in den 8 Steckkarten.

Die Sprache ist strikt imperativ. Es besteht eine direkte Eins-zu-Eins-Entsprechung zwischen dem Quelltext und
der Folge der Operationen im Zwischencode. Es gibt im Quelltext keine arithmetischen oder logischen Ausdrücke.

Es gibt in dieser Sprache kein goto, kein break, kein continue, und in jedem Programm oder
Unterprogramm genau 1 return, nämlich am Ende des Programms oder Unterprogramms.

Die Strukturelemente sind folgende:

<pre>
Bedingte Anweisung: IF.c ... ENDF
Verzweigung: IF.c ... ELSE ... ENDE
Case-Struktur: CASE /nn ... NEXT /nn ... LAST
Do-while-Schleife: LOOP ... RP.c
While-Schleife: L.JP ... HERE ... RP.c
</pre>

c steht hier für die Sprungbedingung, nn steht für eine Zahl
fallend bis 00, NEXT /nn ist entsprechend mehrmals anzugeben. 
RP.c steht für wiederhole falls c.

Ebenso wie die Verzweigung zählt die Schleife mit Hineinsprung

<pre>
L.JP ... HERE ... RP.c
</pre>

als ein Block mit zwei Unterblöcken, die strenge Blockstruktur wird durch den Hineinsprung nicht durchbrochen.

Die Blockstruktur wird bei folgenden Operationen gebraucht:

<pre>
ACQU ... UACQ
FASN ... UFAS
LN.1 ... RELS // LN.2 ... RELS
LX.1 ... RELS // LX.2 ... RELS
</pre>

ACQU steht für Aquirieren von Residenten Variablen 
UACU macht das Aquirieren rückgängig

Residente Variable sind Variable, zB. vom Typ databox, welche ausserhalb des Programms dauerhaft im RAM
liegen. Sie sind über ihren Namen auffindbar und werden über ihre Nummer adressiert. ACQU bindet freie
Zeiger, welche im Programm vereinbart sind, an diese externen Variablen. Dadurch sind diese Variablen unter
Umgehung des Namens und der Nummer wie gewöhnliche im Programm vereinbarte Variable verfügbar.

FASN vergibt den Status "befestigt" an Variable vom Typ databox 
UFAS macht die Vergabe rückgängig.

Variable vom Typ databox, welche beim Start des Programms automatisch installiert werden
oder danach durch LN/LX installiert werden, sind von sich aus "befestigt". Das Installieren
kann aber auch durch Steckkarten-Kommandos erfolgen, zB. wenn die Größe der databox
erst zur Laufzeit des Programms bekannt wird. Dann sind sie zunächst unbefestigt.

LN.1 leiht den von einer databox in RAM1 belegten Speicherplatz an mehrere Variable aus, welche vorher als
nicht installiert vereinbart wurden und nach dem Ausleihen den Speicherplatz der databox überdecken.

LX.1 leiht einen Teil des Speicherplatzes einer databox ab einem Startindex an mehrere Variable aus.

Entsprechend LN.2 und LX.2 für RAM2. In RAM1 sind die mehreren
Variablen kurze Variable vom Typ data, oder selber wieder vom
Typ databox, in RAM2 sind sie stets wieder vom Typ databox.

Beim Ausleihen aus einer databox prüft LN/LX, ob die databox befestigt ist. Andernfalls
wäre sie verschiebbar oder könnte uninstalliert werden, so dass Schreibzugriffe auf die
durch das Ausleihen erzeugten Variablen Unheil anrichten könnten.

RELS macht das Ausleihen rückgängig.

Bei den Operationen ACQU, FASN, LN/LX garantiert der Compiler,
dass das zugehörige UACQ, UFAS, RELS im selben Block liegt.
Die jeweilige Operation und das zugehörige Rückgängigmachen
bilden selber wieder einen Block.

'''Ergänzung zu Sprungbedingungen:'''

Es kann abgefragt werden, ob eine 1-oder 2-Byte-Variable
Null ist und ob sie gleich ff bzw. ffff ist.

Die Kommandos =TT.Z und =TT.M können diese Bedingungen
speichern in einem speziellen Byte im RAM, dem TF-Merker.
Dazu schieben sie eine 1 oder 0 von oben auf den TF-Merker.
In gleicher Weise können Steckkarten-Kommandos nCOMMAND
beliebige Bedingungen ermitteln und speichern.

Es gibt bedingte Sprünge, welche die obersten 3 Bit des
TF-Merker mittels einer Wahrheitstabelle abfragen. Dabei
können bis zu 3 Bits wieder vom TF-Merker entfernt werden.

Mittels der Routinen =PP.r, =PZ.r, =PM.r ist es möglich,
solche Bedingungen in einer 1- oder 2-Byte-Variablen zu
speichern, zu verANDen und zu verORen. Damit lassen
sich beliebig komplexe Sprungbedingungen berechnen.

'''Unterprogramme:'''

In der Programmiersprache gibt es keine functions mit
Rückgabewert, sondern nur einfache Unterprogramme, bei
welchen alle Parameter gleichberechtigt sind. Es werden
ausschließlich Zeiger übergeben.

'''Variablen vom Typ FIX:'''

Ihre Werte sind Teil des Programmcodes und liegen dort am Ende.
Der gesamte Speicherbereich dieser Werte kann als "FIXBOX" vom
Programm abgetrennt werden und dann mittels eines speziellen
Werkzeugs bearbeitet werden.

[[Kategorie:FPGA-Projekte]]

8bit-CPU: bo8

2024-12-14T13:28:42Z

Bome: Bessere Beschreibung des Takts

''von:''   Josef Gnadl ([http://www.mikrocontroller.net/articles/Benutzer:Bome bome])

Die CPU ist Teil eines Gesamt-Projekts: [[8bit-Computer: bo8h]]. 
Dort findet sich auch eine erläuternde Beschreibung der CPU.

Meine Website zum Projekt: http://www.bo8h.de

Beitrag im Forum: [http://www.mikrocontroller.net/topic/407050 Befehlssatz der bo8-CPU] 
Dort findet sich auch einiges zur Wortbedeutung der Mnemonics.

Im folgenden Text steht der Punkt in den Mnemonics für einen 
hier nicht darstellbaren auf der Grundlinie liegenden Bindestrich.

<pre>
================================================================

P Q R S X Y Z K V Bezeichnung: A7 = U
| | | | | | | |A AB = K
| | | | | | | |B

P Programmzähler Q Rückkehradresse
X Adressregister R Schleifenstartadresse
Y Adressregister S Schleifenzähler
Z Adressregister A Akku B Erweiterung V Carry

----------------------------------------------------------------
a0 .. af Adressleitungen - Tristate
d0 .. d7 Datenleitungen - Tristate
N0 .. N3 Typleitungen - permanente Ausgänge
RES REP Reset Repeat - Eingänge
C0 C1 Takt Takt - Eingänge

0 1 2 3 0 1 2 3 0
/ / / / / / / / /
--==------==------==------==------==---- Cx
[ tA [ tB [ tA [ tB [
====----====----====----====----====---- C0
--====----====----====----====----====-- C1

An beiden Eingängen C0 C1 kann Cx anliegen
Cx darf auch symmetrisch sein (Tastgrad 50%)
Oder es können verschiedene Takte C0 C1 anliegen
C0 liefert die fallende und C1 die steigende Flanke

Die Halbzyklen tA und tB bilden einen Vollzyklus (tA/tB).

Typleitungen ändern ihren Zustand zu Zeitpunkten 0 und 2
Adressen und Write-Daten sind gültig von Zeitpunkt 0 bis 2
Einlesen von Read-Daten zum Zeitpunkt 2

Einlesen von REP zu jedem Zeitpunkt 2 (Mitte eines Vollzyklus)
REP bewirkt Anhängen eines (AR/BN) oder eines weiteren (AR/BN)

RES muss enden mit Zeitpunkt 0 bis rechtzeitig vor Zeitpunkt 1
Zum Zeitpunkt 2 Einlesen der Startadresse nach P und R vom
Adressbus und des Akku A vom Datenbus. Folgender Zeitpunkt 0
Start des Programmms mit (FE/BN) für ersten OpCode.

----------------------------------------------------------------
Typ Name Funktion

0/tB BN normal tB inaktiv
1/tA AR repeat tA inaktiv - wiederhole input
2/tA KA Adressbus gibt K aus - Datenbus inaktiv
3/tA HA Adressbus gibt K aus - input A

4/tB BP memory-page-Umschaltung für P
5/tB BX memory-page-Umschaltung für X
6/tB BY memory-page-Umschaltung für Y
7/tB BZ memory-page-Umschaltung für Z

8/tA FE read / Adresse ist P / OP-Code
9/tA WX write / Adresse ist X
a/tA WY write / Adresse ist Y
b/tA WZ write / Adresse ist Z

c/tA RP read / Adresse ist P
d/tA RX read / Adresse ist X
e/tA RY read / Adresse ist Y
f/tA RZ read / Adresse ist Z

----------------------------------------------------------------
+0 +1 +2 +3 +4 +5 +6 +7

00- H.. ST.S SS.X ST.X SS.Y ST.Y SS.Z ST.Z
08- IX0 IX1 IX2 IX3 IX4 IX5 IX6 IX7
10- IY0 IY1 IY2 IY3 IY4 IY5 IY6 IY7
18- IZ0 IZ1 IZ2 IZ3 IZ4 IZ5 IZ6 IZ7
20- ZO.S SL.S ZO.X SL.X ZO.Y SL.Y ZO.Z SL.Z
28- DX0 DX1 DX2 DX3 DX4 DX5 DX6 DX7
30- DY0 DY1 DY2 DY3 DY4 DY5 DY6 DY7
38- DZ0 DZ1 DZ2 DZ3 DZ4 DZ5 DZ6 DZ7
40- O.VZ O.VS B.VZ B.VS O.UZ O.US B.UZ B.US
48- O.AZ O.AS B.AZ B.AS O.KZ O.KS B.KZ B.KS
50- O.WY O.RP B.WY B.CN GTR ADR GTA NOL
58- IKL DKL IXL DXL IYL DYL IZL DZL
60- AD. LV. AV. SV. GT. AN. XR. NR.
68- STMX LVMX AVMX SVMX GTMX ANMX XRMX NRMX
70- STMY LVMY AVMY SVMY GTMY ANMY XRMY NRMY
78- STMZ LVMZ AVMZ SVMZ GTMZ ANMZ XRMZ NRMZ
80- NO2 TK1 TK2 TK3 TK4 TK5 TK6 TK7
88- TK8 TK9 TKa TKb TKc TKd TKe TKf
90- NO1 TA1 TA2 TA3 TA4 TA5 TA6 TA7
98- ST.B LV.B AV.B SV.B GT.B AN.B XR.B NR.B
a0- EX.S LV.S AV.S SV.S GT.S LD.S AD.S SD.S
a8- EX.X ES.X SW.X RS.X GT.X LD.X AD.X SD.X
b0- EX.Y ES.Y SW.Y RS.Y GT.Y LD.Y AD.Y SD.Y
b8- EX.Z ES.Z SW.Z RS.Z GT.Z LD.Z AD.Z SD.Z
c0- R.VZ R.VS R.UZ R.US R.AZ R.AS R.KZ R.KS
c8- R.WY R.CN R.IX R.DX R.IY R.DY R.IZ R.DZ
d0- GH.S GL.S GH.X GL.X GH.Y GL.Y GH.Z GL.Z
d8- IC.S DC.S IXE DXE IYE DYE IZE DZE
e0- ZO.U SE.U ZO.V SE.V CP.U NE.U CP.V NE.V
e8- PV.A TZ.A PV.B TZ.B RD.A RU.A RD.B RU.B
f0- ZO.A NE.A ZO.B NE.B IV.A DV.A SL.K S.RP
f8- IC.K DC.K ZO.K NE.K IC.A DC.A GT.Q J..

00 .. 3f 1 Byte
40 .. 67 2 Byte
68 .. ff 1 Byte

00 .. 3f 1 Zyklus / Sonderfall 00
40 .. 53 2|3 Zyklen
54 .. 7f 2 Zyklen / Sonderfall 57
80 .. ff 1 Zyklus / Sonderfall 80

Während der Ausführung eines Befehls
wird der nachfolgende OpCode geladen.

----------------------------------------------------------------
nn ist zweites Byte eines 2-Byte-Befehls , % ist X|Y|Z

AN.B A <= A and B
NR.B A <= A nor B
XR.B A <= A xor B
AV.B A <= A+B+V V <= Carry
SV.B A <= A-B-V V <= Carry
LV.B A <= B-A-V V <= Carry
GT.B A <= B
ST.B B <= A

AN. nn A <= A and nn
NR. nn A <= A nor nn
XR. nn A <= A xor nn
AV. nn A <= A+nn+V V <= Carry
SV. nn A <= A-nn-V V <= Carry
LV. nn A <= nn-A-V V <= Carry
GT. nn A <= nn
AD. nn A <= A+nn

ANM% A <= A and (%)
NRM% A <= A nor (%)
XRM% A <= A xor (%)
AVM% A <= A+(%)+V V <= Carry
SVM% A <= A-(%)-V V <= Carry
LVM% A <= (%)-A-V V <= Carry
GTM% A <= (%)
STM% (%) <= A

AV.S K <= K+S+V V <= Carry
SV.S K <= K-S-V V <= Carry
LV.S K <= S-K-V V <= Carry

AD.S K <= K+S
SD.S K <= K-S
LD.S K <= S-K

AD.% K <= K+%
SD.% K <= K-%
LD.% K <= %-K

GT.S K <= S
ST.S S <= K
GT.% K <= %
ST.% % <= K

RS.% S <= %
SS.% % <= S

SL.K B <= A , A <= 0

SL.S S LowByte <= A , S HighByte <= 0
SL.% % LowByte <= A , % HighByte <= 0

GL.S A <= LowByte von S
GH.S A <= HighByte von S
GL.% A <= LowByte von %
GH.% A <= HighByte von %

EX.S Austausch K <> S
EX.% Austausch K <> %
ES.% Austausch S <> %

ZO.S S <= 0
ZO.% % <= 0

ZO.V V <= 0
SE.V V <= 1
NE.V V <= not V
CP.V V <= V xor U

ZO.U U <= 0
SE.U U <= 1
NE.U U <= not U
CP.U U <= V xor U

NE.A A wird logisch negiert
NE.B B wird logisch negiert
NE.K K wird logisch negiert

ZO.A A <= 0
ZO.B B <= 0
ZO.K K <= 0

IV.A A <= A+V V <= Carry
DV.A A <= A-V V <= Carry

IC.A A <= A+1
IC.K K <= K+1
IC.S S <= S+1

DC.A A <= A-1
DC.K K <= K-1
DC.S S <= S-1

PV.A A <= 8-fache Kopie von V , V <= 0
PV.B B <= 8-fache Kopie von V , V <= 0

TZ.A wenn nicht A=0 dann ( V <= 1 )
TZ.B wenn nicht B=0 dann ( V <= 1 )

RD.A A wird nach unten durch V rotiert
Resultat V7654321 V <= Bit0
RD.B B wird nach unten durch V rotiert
Resultat V7654321 V <= Bit0

RU.A A wird nach oben durch V rotiert
Resultat 6543210V V <= Bit7
RU.B B wird nach oben durch V rotiert
Resultat 6543210V V <= Bit7

TAs mit s= 1..7 A wird s Bitstellen nach oben verdreht
Resultat von TA3 ist 43210765

TKs mit s= 1..f K wird s Bitstellen nach oben verdreht

I%s mit s= 0..7 % <= %+s+1
D%s mit s= 0..7 % <= %-s-1

I%E % <= %+1 , und Austausch A <> B
D%E % <= %-1 , und Austausch A <> B

IKL nn K <= K+nn+1
DKL nn K <= K-nn-1
I%L nn % <= %+nn+1
D%L nn % <= %-nn-1

GTA nn K <= 00nn
GTR nn K <= P+nn+3
ADR nn K <= K+P+nn+3

NO1 no operation 1 Zyklus
NO2 no operation 2 Zyklen

NOL nn no operation 2+nn Zyklen falls nn > 0
NOL 00 K <= R 2 Zyklen

GT.Q K <= Q

S.RP R <= P+1
O.RP nn R <= P+2 , P <= P+nn+3

Bedingung cc ist WY always
VZ V ist 0
VS V ist nicht 0
UZ U ist 0
US U ist nicht 0
AZ A ist 0
AS A ist nicht 0
KZ K ist 0
KS K ist nicht 0

O.cc nn wenn cc dann ( P <= P+nn+3 )
B.cc nn wenn cc dann ( P <= P-nn-1 )
B.CN nn wenn nicht S=0 dann ( P <= P-nn-1 , S <= S-1 )

R.cc wenn cc dann ( P <= R )
R.CN wenn nicht S=0 dann ( P <= R , S <= S-1 )
R.I% wenn nicht S=0 dann ( P <= R , S <= S-1 , % <= %+1 )
R.D% wenn nicht S=0 dann ( P <= R , S <= S-1 , % <= %-1 )

Bei O.VZ, O.VS, B.VZ, B.VS, R.VZ, R.VS wird V <= 0

Alle O-,B- Operationen dauern 3 Zyklen | 2 Zyklen
wenn der Sprung erfolgt | nicht erfolgt

J.. P <= K , R <= K , Q <= P+1 , K <= P+1

SW.% Nach dem Einlesen des folgenden OpCodes mit FE wird
statt eines BN ein B% ausgegeben. Das soll extern
eine memory-page-Umschaltung für % bewirken. Das
Resultat muss schon beim folgenden tA bereitstehen.

H.. Nach dem Einlesen des folgenden OpCodes mit FE wird
statt eines BN ein BP ausgegeben. Das soll extern
eine memory-page-Umschaltung für P bewirken. Das
Resultat muss schon beim folgenden tA bereitstehen.

Wenn der eingelesene folgende OpCode ein J.. ist,
ist H.. damit beendet. Dauer von H.. ist 1 Zyklus.

Wenn der OpCode kein J.. ist, folgt ein IO-Zyklus
(HA/BP). Das BP soll die memory-page-Umschaltung
für P wieder aufheben. Dauer von H.. ist 2 Zyklen.

Ausnahme: Wenn der OpCode wieder ein H.. ist,
folgt (KA/BN) statt (HA/BP). Danach bleibt die
CPU im Zustand BN bis ein Reset erfolgt.

</pre>

[[Kategorie: FPGA-Projekte]]

Datei:Bo8h.zip

2024-12-12T16:43:02Z

Bome: Bome setzte Datei:Bo8h.zip auf eine alte Version zurück

Datei:Bo8h.zip

2024-12-01T22:21:49Z

Bome: Bome setzte Datei:Bo8h.zip auf eine alte Version zurück

8bit-CPU: bo8

2024-11-29T21:10:36Z

Bome: Repeat-Funktion

''von:''   Josef Gnadl ([http://www.mikrocontroller.net/articles/Benutzer:Bome bome])

Die CPU ist Teil eines Gesamt-Projekts: [[8bit-Computer: bo8h]]. 
Dort findet sich auch eine erläuternde Beschreibung der CPU.

Meine Website zum Projekt: http://www.bo8h.de

Beitrag im Forum: [http://www.mikrocontroller.net/topic/407050 Befehlssatz der bo8-CPU] 
Dort findet sich auch einiges zur Wortbedeutung der Mnemonics.

Im folgenden Text steht der Punkt in den Mnemonics für einen 
hier nicht darstellbaren auf der Grundlinie liegenden Bindestrich.

<pre>
================================================================

P Q R S X Y Z K V Bezeichnung: A7 = U
| | | | | | | |A AB = K
| | | | | | | |B

P Programmzähler Q Rückkehradresse
X Adressregister R Schleifenstartadresse
Y Adressregister S Schleifenzähler
Z Adressregister A Akku B Erweiterung V Carry

----------------------------------------------------------------
a0 .. af Adressleitungen - Tristate
d0 .. d7 Datenleitungen - Tristate
N0 .. N3 Typleitungen - permanente Ausgänge
RES REP Reset Repeat - Eingänge
C0 C1 Takt Takt - Eingänge

0 1 2 3 0 1 2 3 0
/ / / / / / / / /
====----====----====----====----====---- C0
--====----====----====----====----====-- C1
[ tA [ tB [ tA [ tB [

--==------==------==------==------==---- Cx

An Eingängen C0 C1 darf Cx statt C0 C1 anliegen
Cx darf auch symmetrisch sein (Tastgrad 50%)

Die Halbzyklen tA und tB bilden einen Vollzyklus (tA/tB).

Typleitungen ändern ihren Zustand zu Zeitpunkten 0 und 2
Adressen und Write-Daten sind gültig von Zeitpunkt 0 bis 2
Einlesen von Read-Daten zum Zeitpunkt 2

Einlesen von REP zu jedem Zeitpunkt 2 (Mitte eines Vollzyklus)
REP bewirkt Anhängen eines (AR/BN) oder eines weiteren (AR/BN)

RES muss enden mit Zeitpunkt 0 bis rechtzeitig vor Zeitpunkt 1
Zum Zeitpunkt 2 Einlesen der Startadresse nach P und R vom
Adressbus und des Akku A vom Datenbus. Folgender Zeitpunkt 0
Start des Programmms mit (FE/BN) für ersten OpCode.

----------------------------------------------------------------
Typ Name Funktion

0/tB BN normal tB inaktiv
1/tA AR repeat tA inaktiv - wiederhole input
2/tA KA Adressbus gibt K aus - Datenbus inaktiv
3/tA HA Adressbus gibt K aus - input A

4/tB BP memory-page-Umschaltung für P
5/tB BX memory-page-Umschaltung für X
6/tB BY memory-page-Umschaltung für Y
7/tB BZ memory-page-Umschaltung für Z

8/tA FE read / Adresse ist P / OP-Code
9/tA WX write / Adresse ist X
a/tA WY write / Adresse ist Y
b/tA WZ write / Adresse ist Z

c/tA RP read / Adresse ist P
d/tA RX read / Adresse ist X
e/tA RY read / Adresse ist Y
f/tA RZ read / Adresse ist Z

----------------------------------------------------------------
+0 +1 +2 +3 +4 +5 +6 +7

00- H.. ST.S SS.X ST.X SS.Y ST.Y SS.Z ST.Z
08- IX0 IX1 IX2 IX3 IX4 IX5 IX6 IX7
10- IY0 IY1 IY2 IY3 IY4 IY5 IY6 IY7
18- IZ0 IZ1 IZ2 IZ3 IZ4 IZ5 IZ6 IZ7
20- ZO.S SL.S ZO.X SL.X ZO.Y SL.Y ZO.Z SL.Z
28- DX0 DX1 DX2 DX3 DX4 DX5 DX6 DX7
30- DY0 DY1 DY2 DY3 DY4 DY5 DY6 DY7
38- DZ0 DZ1 DZ2 DZ3 DZ4 DZ5 DZ6 DZ7
40- O.VZ O.VS B.VZ B.VS O.UZ O.US B.UZ B.US
48- O.AZ O.AS B.AZ B.AS O.KZ O.KS B.KZ B.KS
50- O.WY O.RP B.WY B.CN GTR ADR GTA NOL
58- IKL DKL IXL DXL IYL DYL IZL DZL
60- AD. LV. AV. SV. GT. AN. XR. NR.
68- STMX LVMX AVMX SVMX GTMX ANMX XRMX NRMX
70- STMY LVMY AVMY SVMY GTMY ANMY XRMY NRMY
78- STMZ LVMZ AVMZ SVMZ GTMZ ANMZ XRMZ NRMZ
80- NO2 TK1 TK2 TK3 TK4 TK5 TK6 TK7
88- TK8 TK9 TKa TKb TKc TKd TKe TKf
90- NO1 TA1 TA2 TA3 TA4 TA5 TA6 TA7
98- ST.B LV.B AV.B SV.B GT.B AN.B XR.B NR.B
a0- EX.S LV.S AV.S SV.S GT.S LD.S AD.S SD.S
a8- EX.X ES.X SW.X RS.X GT.X LD.X AD.X SD.X
b0- EX.Y ES.Y SW.Y RS.Y GT.Y LD.Y AD.Y SD.Y
b8- EX.Z ES.Z SW.Z RS.Z GT.Z LD.Z AD.Z SD.Z
c0- R.VZ R.VS R.UZ R.US R.AZ R.AS R.KZ R.KS
c8- R.WY R.CN R.IX R.DX R.IY R.DY R.IZ R.DZ
d0- GH.S GL.S GH.X GL.X GH.Y GL.Y GH.Z GL.Z
d8- IC.S DC.S IXE DXE IYE DYE IZE DZE
e0- ZO.U SE.U ZO.V SE.V CP.U NE.U CP.V NE.V
e8- PV.A TZ.A PV.B TZ.B RD.A RU.A RD.B RU.B
f0- ZO.A NE.A ZO.B NE.B IV.A DV.A SL.K S.RP
f8- IC.K DC.K ZO.K NE.K IC.A DC.A GT.Q J..

00 .. 3f 1 Byte
40 .. 67 2 Byte
68 .. ff 1 Byte

00 .. 3f 1 Zyklus / Sonderfall 00
40 .. 53 2|3 Zyklen
54 .. 7f 2 Zyklen / Sonderfall 57
80 .. ff 1 Zyklus / Sonderfall 80

Während der Ausführung eines Befehls
wird der nachfolgende OpCode geladen.

----------------------------------------------------------------
nn ist zweites Byte eines 2-Byte-Befehls , % ist X|Y|Z

AN.B A <= A and B
NR.B A <= A nor B
XR.B A <= A xor B
AV.B A <= A+B+V V <= Carry
SV.B A <= A-B-V V <= Carry
LV.B A <= B-A-V V <= Carry
GT.B A <= B
ST.B B <= A

AN. nn A <= A and nn
NR. nn A <= A nor nn
XR. nn A <= A xor nn
AV. nn A <= A+nn+V V <= Carry
SV. nn A <= A-nn-V V <= Carry
LV. nn A <= nn-A-V V <= Carry
GT. nn A <= nn
AD. nn A <= A+nn

ANM% A <= A and (%)
NRM% A <= A nor (%)
XRM% A <= A xor (%)
AVM% A <= A+(%)+V V <= Carry
SVM% A <= A-(%)-V V <= Carry
LVM% A <= (%)-A-V V <= Carry
GTM% A <= (%)
STM% (%) <= A

AV.S K <= K+S+V V <= Carry
SV.S K <= K-S-V V <= Carry
LV.S K <= S-K-V V <= Carry

AD.S K <= K+S
SD.S K <= K-S
LD.S K <= S-K

AD.% K <= K+%
SD.% K <= K-%
LD.% K <= %-K

GT.S K <= S
ST.S S <= K
GT.% K <= %
ST.% % <= K

RS.% S <= %
SS.% % <= S

SL.K B <= A , A <= 0

SL.S S LowByte <= A , S HighByte <= 0
SL.% % LowByte <= A , % HighByte <= 0

GL.S A <= LowByte von S
GH.S A <= HighByte von S
GL.% A <= LowByte von %
GH.% A <= HighByte von %

EX.S Austausch K <> S
EX.% Austausch K <> %
ES.% Austausch S <> %

ZO.S S <= 0
ZO.% % <= 0

ZO.V V <= 0
SE.V V <= 1
NE.V V <= not V
CP.V V <= V xor U

ZO.U U <= 0
SE.U U <= 1
NE.U U <= not U
CP.U U <= V xor U

NE.A A wird logisch negiert
NE.B B wird logisch negiert
NE.K K wird logisch negiert

ZO.A A <= 0
ZO.B B <= 0
ZO.K K <= 0

IV.A A <= A+V V <= Carry
DV.A A <= A-V V <= Carry

IC.A A <= A+1
IC.K K <= K+1
IC.S S <= S+1

DC.A A <= A-1
DC.K K <= K-1
DC.S S <= S-1

PV.A A <= 8-fache Kopie von V , V <= 0
PV.B B <= 8-fache Kopie von V , V <= 0

TZ.A wenn nicht A=0 dann ( V <= 1 )
TZ.B wenn nicht B=0 dann ( V <= 1 )

RD.A A wird nach unten durch V rotiert
Resultat V7654321 V <= Bit0
RD.B B wird nach unten durch V rotiert
Resultat V7654321 V <= Bit0

RU.A A wird nach oben durch V rotiert
Resultat 6543210V V <= Bit7
RU.B B wird nach oben durch V rotiert
Resultat 6543210V V <= Bit7

TAs mit s= 1..7 A wird s Bitstellen nach oben verdreht
Resultat von TA3 ist 43210765

TKs mit s= 1..f K wird s Bitstellen nach oben verdreht

I%s mit s= 0..7 % <= %+s+1
D%s mit s= 0..7 % <= %-s-1

I%E % <= %+1 , und Austausch A <> B
D%E % <= %-1 , und Austausch A <> B

IKL nn K <= K+nn+1
DKL nn K <= K-nn-1
I%L nn % <= %+nn+1
D%L nn % <= %-nn-1

GTA nn K <= 00nn
GTR nn K <= P+nn+3
ADR nn K <= K+P+nn+3

NO1 no operation 1 Zyklus
NO2 no operation 2 Zyklen

NOL nn no operation 2+nn Zyklen falls nn > 0
NOL 00 K <= R 2 Zyklen

GT.Q K <= Q

S.RP R <= P+1
O.RP nn R <= P+2 , P <= P+nn+3

Bedingung cc ist WY always
VZ V ist 0
VS V ist nicht 0
UZ U ist 0
US U ist nicht 0
AZ A ist 0
AS A ist nicht 0
KZ K ist 0
KS K ist nicht 0

O.cc nn wenn cc dann ( P <= P+nn+3 )
B.cc nn wenn cc dann ( P <= P-nn-1 )
B.CN nn wenn nicht S=0 dann ( P <= P-nn-1 , S <= S-1 )

R.cc wenn cc dann ( P <= R )
R.CN wenn nicht S=0 dann ( P <= R , S <= S-1 )
R.I% wenn nicht S=0 dann ( P <= R , S <= S-1 , % <= %+1 )
R.D% wenn nicht S=0 dann ( P <= R , S <= S-1 , % <= %-1 )

Bei O.VZ, O.VS, B.VZ, B.VS, R.VZ, R.VS wird V <= 0

Alle O-,B- Operationen dauern 3 Zyklen | 2 Zyklen
wenn der Sprung erfolgt | nicht erfolgt

J.. P <= K , R <= K , Q <= P+1 , K <= P+1

SW.% Nach dem Einlesen des folgenden OpCodes mit FE wird
statt eines BN ein B% ausgegeben. Das soll extern
eine memory-page-Umschaltung für % bewirken. Das
Resultat muss schon beim folgenden tA bereitstehen.

H.. Nach dem Einlesen des folgenden OpCodes mit FE wird
statt eines BN ein BP ausgegeben. Das soll extern
eine memory-page-Umschaltung für P bewirken. Das
Resultat muss schon beim folgenden tA bereitstehen.

Wenn der eingelesene folgende OpCode ein J.. ist,
ist H.. damit beendet. Dauer von H.. ist 1 Zyklus.

Wenn der OpCode kein J.. ist, folgt ein IO-Zyklus
(HA/BP). Das BP soll die memory-page-Umschaltung
für P wieder aufheben. Dauer von H.. ist 2 Zyklen.

Ausnahme: Wenn der OpCode wieder ein H.. ist,
folgt (KA/BN) statt (HA/BP). Danach bleibt die
CPU im Zustand BN bis ein Reset erfolgt.

</pre>

[[Kategorie: FPGA-Projekte]]

Datei:Bo8h.zip

2024-11-29T16:24:23Z

Bome: Bome lud eine neue Version von Datei:Bo8h.zip hoch

Datei:Bo8h.zip

2024-11-28T00:32:12Z

Bome: Fehler bei Upload?

8bit-CPU: bo8

2024-11-27T14:00:51Z

Bome: Repeat-Funktion

''von:''   Josef Gnadl ([http://www.mikrocontroller.net/articles/Benutzer:Bome bome])

Die CPU ist Teil eines Gesamt-Projekts: [[8bit-Computer: bo8h]]. 
Dort findet sich auch eine erläuternde Beschreibung der CPU.

Meine Website zum Projekt: http://www.bo8h.de

Beitrag im Forum: [http://www.mikrocontroller.net/topic/407050 Befehlssatz der bo8-CPU] 
Dort findet sich auch einiges zur Wortbedeutung der Mnemonics.

Im folgenden Text steht der Punkt in den Mnemonics für einen 
hier nicht darstellbaren auf der Grundlinie liegenden Bindestrich.

<pre>
================================================================

P Q R S X Y Z K V Bezeichnung: A7 = U
| | | | | | | |A AB = K
| | | | | | | |B

P Programmzähler Q Rückkehradresse
X Adressregister R Schleifenstartadresse
Y Adressregister S Schleifenzähler
Z Adressregister A Akku B Erweiterung V Carry

----------------------------------------------------------------
a0 .. af Adressleitungen - Tristate
d0 .. d7 Datenleitungen - Tristate
N0 .. N3 Typleitungen - permanente Ausgänge
RES REP Reset Repeat - Eingänge
C0 C1 Takt Takt - Eingänge

0 1 2 3 0 1 2 3 0
/ / / / / / / / /
====----====----====----====----====---- C0
--====----====----====----====----====-- C1
[ tA [ tB [ tA [ tB [

--==------==------==------==------==---- Cx

An Eingängen C0 C1 darf Cx statt C0 C1 anliegen
Cx darf auch symmetrisch sein (Tastgrad 50%)

Die Halbzyklen tA und tB bilden einen Vollzyklus (tA/tB).

Typleitungen ändern ihren Zustand zu Zeitpunkten 0 und 2
Adressen und Write-Daten sind gültig von Zeitpunkt 0 bis 2
Einlesen von Read-Daten zum Zeitpunkt 2
Einlesen von REP bei HA zum Zeitpunkt 2

RES muss enden mit Zeitpunkt 0 bis rechtzeitig vor Zeitpunkt 1
Zum Zeitpunkt 2 Einlesen der Startadresse nach P und R vom
Adressbus und des Akku A vom Datenbus. Folgender Zeitpunkt 0
Start des Programmms mit (FE/BN) für ersten OpCode.

REP wird eingelesen zu Zeitpunkten 2 (Mitte eines Vollzyklus)
und bewirkt Anhängen eines (AR/BN) oder eines weiteren (AR/BN)

----------------------------------------------------------------
Typ Name Funktion

0/tB BN normal tB inaktiv
1/tA AR repeat tA inaktiv - wiederhole input
2/tA KA Adressbus gibt K aus - Datenbus inaktiv
3/tA HA Adressbus gibt K aus - input A

4/tB BP memory-page-Umschaltung für P
5/tB BX memory-page-Umschaltung für X
6/tB BY memory-page-Umschaltung für Y
7/tB BZ memory-page-Umschaltung für Z

8/tA FE read / Adresse ist P / OP-Code
9/tA WX write / Adresse ist X
a/tA WY write / Adresse ist Y
b/tA WZ write / Adresse ist Z

c/tA RP read / Adresse ist P
d/tA RX read / Adresse ist X
e/tA RY read / Adresse ist Y
f/tA RZ read / Adresse ist Z

----------------------------------------------------------------
+0 +1 +2 +3 +4 +5 +6 +7

00- H.. ST.S SS.X ST.X SS.Y ST.Y SS.Z ST.Z
08- IX0 IX1 IX2 IX3 IX4 IX5 IX6 IX7
10- IY0 IY1 IY2 IY3 IY4 IY5 IY6 IY7
18- IZ0 IZ1 IZ2 IZ3 IZ4 IZ5 IZ6 IZ7
20- ZO.S SL.S ZO.X SL.X ZO.Y SL.Y ZO.Z SL.Z
28- DX0 DX1 DX2 DX3 DX4 DX5 DX6 DX7
30- DY0 DY1 DY2 DY3 DY4 DY5 DY6 DY7
38- DZ0 DZ1 DZ2 DZ3 DZ4 DZ5 DZ6 DZ7
40- O.VZ O.VS B.VZ B.VS O.UZ O.US B.UZ B.US
48- O.AZ O.AS B.AZ B.AS O.KZ O.KS B.KZ B.KS
50- O.WY O.RP B.WY B.CN GTR ADR GTA NOL
58- IKL DKL IXL DXL IYL DYL IZL DZL
60- AD. LV. AV. SV. GT. AN. XR. NR.
68- STMX LVMX AVMX SVMX GTMX ANMX XRMX NRMX
70- STMY LVMY AVMY SVMY GTMY ANMY XRMY NRMY
78- STMZ LVMZ AVMZ SVMZ GTMZ ANMZ XRMZ NRMZ
80- NO2 TK1 TK2 TK3 TK4 TK5 TK6 TK7
88- TK8 TK9 TKa TKb TKc TKd TKe TKf
90- NO1 TA1 TA2 TA3 TA4 TA5 TA6 TA7
98- ST.B LV.B AV.B SV.B GT.B AN.B XR.B NR.B
a0- EX.S LV.S AV.S SV.S GT.S LD.S AD.S SD.S
a8- EX.X ES.X SW.X RS.X GT.X LD.X AD.X SD.X
b0- EX.Y ES.Y SW.Y RS.Y GT.Y LD.Y AD.Y SD.Y
b8- EX.Z ES.Z SW.Z RS.Z GT.Z LD.Z AD.Z SD.Z
c0- R.VZ R.VS R.UZ R.US R.AZ R.AS R.KZ R.KS
c8- R.WY R.CN R.IX R.DX R.IY R.DY R.IZ R.DZ
d0- GH.S GL.S GH.X GL.X GH.Y GL.Y GH.Z GL.Z
d8- IC.S DC.S IXE DXE IYE DYE IZE DZE
e0- ZO.U SE.U ZO.V SE.V CP.U NE.U CP.V NE.V
e8- PV.A TZ.A PV.B TZ.B RD.A RU.A RD.B RU.B
f0- ZO.A NE.A ZO.B NE.B IV.A DV.A SL.K S.RP
f8- IC.K DC.K ZO.K NE.K IC.A DC.A GT.Q J..

00 .. 3f 1 Byte
40 .. 67 2 Byte
68 .. ff 1 Byte

00 .. 3f 1 Zyklus / Sonderfall 00
40 .. 53 2|3 Zyklen
54 .. 7f 2 Zyklen / Sonderfall 57
80 .. ff 1 Zyklus / Sonderfall 80

Während der Ausführung eines Befehls
wird der nachfolgende OpCode geladen.

----------------------------------------------------------------
nn ist zweites Byte eines 2-Byte-Befehls , % ist X|Y|Z

AN.B A <= A and B
NR.B A <= A nor B
XR.B A <= A xor B
AV.B A <= A+B+V V <= Carry
SV.B A <= A-B-V V <= Carry
LV.B A <= B-A-V V <= Carry
GT.B A <= B
ST.B B <= A

AN. nn A <= A and nn
NR. nn A <= A nor nn
XR. nn A <= A xor nn
AV. nn A <= A+nn+V V <= Carry
SV. nn A <= A-nn-V V <= Carry
LV. nn A <= nn-A-V V <= Carry
GT. nn A <= nn
AD. nn A <= A+nn

ANM% A <= A and (%)
NRM% A <= A nor (%)
XRM% A <= A xor (%)
AVM% A <= A+(%)+V V <= Carry
SVM% A <= A-(%)-V V <= Carry
LVM% A <= (%)-A-V V <= Carry
GTM% A <= (%)
STM% (%) <= A

AV.S K <= K+S+V V <= Carry
SV.S K <= K-S-V V <= Carry
LV.S K <= S-K-V V <= Carry

AD.S K <= K+S
SD.S K <= K-S
LD.S K <= S-K

AD.% K <= K+%
SD.% K <= K-%
LD.% K <= %-K

GT.S K <= S
ST.S S <= K
GT.% K <= %
ST.% % <= K

RS.% S <= %
SS.% % <= S

SL.K B <= A , A <= 0

SL.S S LowByte <= A , S HighByte <= 0
SL.% % LowByte <= A , % HighByte <= 0

GL.S A <= LowByte von S
GH.S A <= HighByte von S
GL.% A <= LowByte von %
GH.% A <= HighByte von %

EX.S Austausch K <> S
EX.% Austausch K <> %
ES.% Austausch S <> %

ZO.S S <= 0
ZO.% % <= 0

ZO.V V <= 0
SE.V V <= 1
NE.V V <= not V
CP.V V <= V xor U

ZO.U U <= 0
SE.U U <= 1
NE.U U <= not U
CP.U U <= V xor U

NE.A A wird logisch negiert
NE.B B wird logisch negiert
NE.K K wird logisch negiert

ZO.A A <= 0
ZO.B B <= 0
ZO.K K <= 0

IV.A A <= A+V V <= Carry
DV.A A <= A-V V <= Carry

IC.A A <= A+1
IC.K K <= K+1
IC.S S <= S+1

DC.A A <= A-1
DC.K K <= K-1
DC.S S <= S-1

PV.A A <= 8-fache Kopie von V , V <= 0
PV.B B <= 8-fache Kopie von V , V <= 0

TZ.A wenn nicht A=0 dann ( V <= 1 )
TZ.B wenn nicht B=0 dann ( V <= 1 )

RD.A A wird nach unten durch V rotiert
Resultat V7654321 V <= Bit0
RD.B B wird nach unten durch V rotiert
Resultat V7654321 V <= Bit0

RU.A A wird nach oben durch V rotiert
Resultat 6543210V V <= Bit7
RU.B B wird nach oben durch V rotiert
Resultat 6543210V V <= Bit7

TAs mit s= 1..7 A wird s Bitstellen nach oben verdreht
Resultat von TA3 ist 43210765

TKs mit s= 1..f K wird s Bitstellen nach oben verdreht

I%s mit s= 0..7 % <= %+s+1
D%s mit s= 0..7 % <= %-s-1

I%E % <= %+1 , und Austausch A <> B
D%E % <= %-1 , und Austausch A <> B

IKL nn K <= K+nn+1
DKL nn K <= K-nn-1
I%L nn % <= %+nn+1
D%L nn % <= %-nn-1

GTA nn K <= 00nn
GTR nn K <= P+nn+3
ADR nn K <= K+P+nn+3

NO1 no operation 1 Zyklus
NO2 no operation 2 Zyklen

NOL nn no operation 2+nn Zyklen falls nn > 0
NOL 00 K <= R 2 Zyklen

GT.Q K <= Q

S.RP R <= P+1
O.RP nn R <= P+2 , P <= P+nn+3

Bedingung cc ist WY always
VZ V ist 0
VS V ist nicht 0
UZ U ist 0
US U ist nicht 0
AZ A ist 0
AS A ist nicht 0
KZ K ist 0
KS K ist nicht 0

O.cc nn wenn cc dann ( P <= P+nn+3 )
B.cc nn wenn cc dann ( P <= P-nn-1 )
B.CN nn wenn nicht S=0 dann ( P <= P-nn-1 , S <= S-1 )

R.cc wenn cc dann ( P <= R )
R.CN wenn nicht S=0 dann ( P <= R , S <= S-1 )
R.I% wenn nicht S=0 dann ( P <= R , S <= S-1 , % <= %+1 )
R.D% wenn nicht S=0 dann ( P <= R , S <= S-1 , % <= %-1 )

Bei O.VZ, O.VS, B.VZ, B.VS, R.VZ, R.VS wird V <= 0

Alle O-,B- Operationen dauern 3 Zyklen | 2 Zyklen
wenn der Sprung erfolgt | nicht erfolgt

J.. P <= K , R <= K , Q <= P+1 , K <= P+1

SW.% Nach dem Einlesen des folgenden OpCodes mit FE wird
statt eines BN ein B% ausgegeben. Das soll extern
eine memory-page-Umschaltung für % bewirken. Das
Resultat muss schon beim folgenden tA bereitstehen.

H.. Nach dem Einlesen des folgenden OpCodes mit FE wird
statt eines BN ein BP ausgegeben. Das soll extern
eine memory-page-Umschaltung für P bewirken. Das
Resultat muss schon beim folgenden tA bereitstehen.

Wenn der eingelesene folgende OpCode ein J.. ist,
ist H.. damit beendet. Dauer von H.. ist 1 Zyklus.

Wenn der OpCode kein J.. ist, folgt ein IO-Zyklus
(HA/BP). Das BP soll die memory-page-Umschaltung
für P wieder aufheben. Dauer von H.. ist 2 Zyklen.

Ausnahme: Wenn der OpCode wieder ein H.. ist,
folgt (KA/BN) statt (HA/BP). Danach bleibt die
CPU im Zustand BN bis ein Reset erfolgt.

</pre>

[[Kategorie: FPGA-Projekte]]

8bit-Computer: bo8h

2024-11-27T13:55:29Z

Bome: /* Übersicht */

''von:''   Josef Gnadl ([http://www.mikrocontroller.net/articles/Benutzer:Bome bome])

=Übersicht=

Habe einen 8bit-Rechner entwickelt und als Prototyp-Gerät realisiert
auf folgenden FPGA-Boards:
* '''Spartan-3A Starter Kit''' von Xilinx
* '''Spartan-3E Starter Board''' und
* '''Nexys2 Board''' von Digilent
* '''Terasic DE1 Board'''
* '''Terasic DE0 Board'''
* '''Terasic DE0-CV Board'''
* '''Terasic DE0-nano Board'''
* '''Waveshare OpenEP4CE10 Board'''

Die Realisierung auf dem Spartan-3A Starter Kit funktioniert auch auf dem ''Spartan-3AN Starter Kit''. 
Das Spartan-3E Starter Board von Digilent ist baugleich mit dem Spartan-3E Starter Kit von Xilinx.

Die CPU ist eine Eigenentwicklung. Merkmale des Gesamtsystems sind
der aus mehreren 64KByte-Seiten bestehende Adressraum, das Steckplatz-Konzept,
eine an die Hardware angepasste Programmiersprache und taktgenau berechenbare
Programmlaufzeiten. Der Zeichensatz beinhaltet einen hexadezimalen Ziffernsatz,
welcher für die Ziffern A..F spezielle Zeichen verwendet.

Das Prototyp-Gerät besitzt Bildschirm und Tastatur, nutzt [[RS232]] zum Daten-Austausch mit PC und hat eine SD-Karte mit selbstgestricktem Dateisystem.
Der [[VHDL]]-Code ist so geschrieben, dass leicht weitere Schnittstellen eingebaut werden können.

* Informationen und Downloads gibt es auf [http://www.bo8h.de bo8h.de].
* Kopie des Download-Files von bo8h.de: [[Datei:Bo8h.zip]]
* Wiki-Artikel zur CPU: [[8bit-CPU: bo8]].
* Beitrag im '''Forum''' Projekte & Code: [http://www.mikrocontroller.net/topic/297603 8bit-Computing mit FPGA].
* Im ''embedded-projects-Journal 14''  gibt es den Artikel ''Ein 8bit-Rechner auf dem Spartan-3A-Starterkit''.

Das Prototyp-Gerät hat 4 freie virtuelle Steckplätze mit je 64KByte, wobei je 32KByte
für Software vorgesehen sind. Damit haben Software-Entwickler die Möglichkeit,
Steckkarten-Software in Eigen-Regie anzubieten. Zur Software-Entwicklung
auf PC gibt es einen in C geschriebenen Cross-Assembler.

=Die CPU=

''Der Punkt in den Mnemonics steht für einen auf der Grundlinie liegenden Bindestrich.''

Der Akku '''A''' und das Erweiterungsregister '''B''' sind 8-bit. 
Das Doppelregister AB wird abkürzend mit '''K''' bezeichnet. 
Das Vorzeichenbit A7 wird abkürzend mit '''U''' bezeichnet.

Der Programmzähler '''P''' und die Adressregister '''X''', '''Y''', '''Z''' sind 16-bit. 
Das Register '''Q''' erhält bei Sprüngen die Rückkehradresse P+1. 
'''R''' ist Schleifen-Startadresse, '''S''' ist Schleifenzähler (16-bit).

Einziges Flag ist der Carry '''V'''. Bei bedingten Sprüngen kann ausserdem abgefragt werden, ob U/A/K Null sind.

Alle Speicherzugriffe sind 8bit-Zugriffe. 
GTMX lädt nach A den Inhalt der Speicherzelle, auf welche X zeigt. 
STMX speichert A in der Speicherzelle, auf welche X zeigt.

IXE inkrementiert X und tauscht A und B. 
DXE dekrementiert X und tauscht A und B.

Damit lassen sich 2-byte-Speicherzugriffe aufbauen 
nach dem Muster GTMX..IXE..GTMX und STMX..DXE..STMX. 
Es gibt hierfür die Assembler-Makros GTMXI und STMXD.

<pre>
GTMXI lädt eine Adresse von Position X
ST.Y überträgt die Adresse nach Y

GTMXI lädt eine Adresse von Position X
AD.X addiert X
ST.Y überträgt die zu X relative Adresse nach Y

J.. Sprung zu der Adresse, welche in K steht

GTA 59 lädt den Wert 0059 nach K
AD. 35 addiert 35 zu A
J.. Sprung nach 3559

Das lässt sich kürzer schreiben mit Assembler-Makro
/GTA 3559
J

GTR 59 lädt den Wert P+0059+3 nach K
AD. 35 addiert 35 zu A
J.. relativer Sprung nach P+3559+3

Das lässt sich kürzer schreiben mit Assembler-Makro
/GTR 3559
J

GT.Q lädt Rückkehradresse nach K
J Rücksprung aus Unterprogramm
</pre>

Wenn ein Unterprogramm selber J.. ausführen will für andere Zwecke als für den Rücksprung,
muss es vorher die Rückkehradresse sichern. Dazu kann es die Rückkehradresse aus Q laden,
anfangs steht sie aber auch in K und das Laden kann entfallen.

Ausser dem Sprungbefehl J.. gibt es die bedingten Sprünge mit 8bit-Sprungdistanz: 
O.cc nn (Vorwärtssprung falls cc) und B.cc nn (Rückwärtssprung falls cc).

Für schnelle Schleifen gibt es die Repeat-Befehle R.cc. 
Repeat-Befehle gibt es kombiniert mit Schleifenzähler-Dekrementieren und Adresse-Inkrementieren/Dekrementieren.
Die Schleifenstartadresse R wird gesetzt vor dem Schleifenanfang mittels S.RP oder mittels O.RP nn.
Bei letzterem wird gleichzeitig ein Vorwärtssprung ausgeführt. Damit sind Schleifen mit Hineinsprung (while-Schleifen) realisierbar.

Bei J.. wird die Zieladresse auch nach R übertragen. Das garantiert, dass R stets eine Adresse im Nahbereich
des Programmzählers enthält. Eine Anwendung hiervon ergibt sich beim Sprung in eine Tabelle, welche aus
O.WY nn -Befehlen (Vorwärtssprung always) besteht, wobei die O.WY nn alle zur
selben Adresse springen. Die dortige Routine kann durch Auswertung von R die Nummer des O.WY-Befehls ermitteln.

'''Adressierung mehrerer 64K-Seiten:'''

Zu jeder auf dem Adressbus ausgegebenen Adresse wird auf den Steuerleitungen angezeigt, von welchem der
Adressregister P, X, Y, Z sie kommt. Dadurch kann eine externe Logik jedem der Adressregister eine eigene
64K-Speicherseite zuordnen. Die CPU kann spezielle Steuersignale ausgeben, welche die externe Logik
zur Memory-Page-Umschaltung für eines der Adressregister veranlassen sollen.

Der Befehl H.. ist der einzige und universell einsetzbare IO-Befehl.
Es wird K auf dem Adressbus ausgegeben und der Datenbus nach A eingelesen.

Wenn auf H.. ein J.. folgt, dann wirkt H.. stattdessen als Präfix und bewirkt,
dass J.. mit einer Memory-Page-Umschaltung kombiniert wird. So kann die CPU von einer
64K-Seite in eine andere springen, ohne dass es einen gemeinsamen Speicherbereich geben muss.

Bei den Adressregistern X, Y, Z gibt es spezielle Befehle SW.X, SW.Y, SW.Z für die Memory-Page-Umschaltung.

=Die Gesamt-Hardware=

Es gibt vier Memory-Pages mit je 64KByte:

* Page 0: Aktiver Steckplatz
* Page 1: ROM (32K), Text-RAM (16K), Video-RAM (16K)
* Page 2: Haupt-RAM
* Page 3: Zusatz-RAM

Der aktive Steckplatz in Page 0 wird durch ein 3bit-Register SLT ausgewählt.
Neben Page 0 wird auch IO-Adressraum zugeteilt.
Die Steckkarten sollten ein Software-ROM und IO-Hardware enthalten.

Es gibt die 2bit-Register MP, MX, MY, MZ. Diese Register legen fest, in welche der vier Memory-Pages
das betreffende Adressregister P, X, Y, Z zeigt. Ausserdem gibt es die Schattenregister NP, NX, NY, NZ.
Das CPU-Signal zur Memory-Page-Umschaltung für ein bestimmtes Adressregister # bewirkt den
Austausch von M# und N#, wobei # hier für P, X, Y, Z steht.
Beim Sprung mit Memory-Page-Umschaltung  H..  J..  werden also MP und NP getauscht.
Die Schattenregister NP, NX, NY, NZ können über IO-Befehle H.. mit einem Wert 0 bis 3 geladen werden.

Das Display ist 512 Pixel breit und 256 Pixel hoch, die Pixel sind zweiwertig.
Der Video-Generator liest in Dauerschleife das Video-RAM und erzeugt daraus die VGA-Signale.
Einen Hardware-Zeichengenerator gibt es nicht.
Die Software liest die Zeichen aus dem Text-RAM und schreibt deren Pixelmuster ins Video-RAM.
Die Textzeilen sind 64 Zeichen breit.
Durch Invertierung eines Flipflops können Text-RAM und Video-RAM ihre Rollen tauschen.
So kann die CPU im Text-RAM eine neue Grafik erstellen, während noch das alte Video-RAM angezeigt wird.

=Die Programmiersprache=

Der Compiler erzeugt einen Zwischencode, welcher interpretativ abgearbeitet wird. Der
Zwischencode besteht aus Aufrufen vorgefertigter Maschinenroutinen. Nur wenige dieser
Maschinenroutinen sind interner Teil der Sprache, die meisten liegen in den 8 Steckkarten.

Die Sprache ist strikt imperativ. Es besteht eine direkte Eins-zu-Eins-Entsprechung zwischen dem Quelltext und
der Folge der Operationen im Zwischencode. Es gibt im Quelltext keine arithmetischen oder logischen Ausdrücke.

Es gibt in dieser Sprache kein goto, kein break, kein continue, und in jedem Programm oder
Unterprogramm genau 1 return, nämlich am Ende des Programms oder Unterprogramms.

Die Strukturelemente sind folgende:

<pre>
Bedingte Anweisung: IF.c ... ENDF
Verzweigung: IF.c ... ELSE ... ENDE
Case-Struktur: CASE /nn ... NEXT /nn ... LAST
Do-while-Schleife: LOOP ... RP.c
While-Schleife: L.JP ... HERE ... RP.c
</pre>

c steht hier für die Sprungbedingung, nn steht für eine Zahl
fallend bis 00, NEXT /nn ist entsprechend mehrmals anzugeben. 
RP.c steht für wiederhole falls c.

Ebenso wie die Verzweigung zählt die Schleife mit Hineinsprung

<pre>
L.JP ... HERE ... RP.c
</pre>

als ein Block mit zwei Unterblöcken, die strenge Blockstruktur wird durch den Hineinsprung nicht durchbrochen.

Die Blockstruktur wird bei folgenden Operationen gebraucht:

<pre>
ACQU ... UACQ
FASN ... UFAS
LN.1 ... RELS // LN.2 ... RELS
LX.1 ... RELS // LX.2 ... RELS
</pre>

ACQU steht für Aquirieren von Residenten Variablen 
UACU macht das Aquirieren rückgängig

Residente Variable sind Variable, zB. vom Typ databox, welche ausserhalb des Programms dauerhaft im RAM
liegen. Sie sind über ihren Namen auffindbar und werden über ihre Nummer adressiert. ACQU bindet freie
Zeiger, welche im Programm vereinbart sind, an diese externen Variablen. Dadurch sind diese Variablen unter
Umgehung des Namens und der Nummer wie gewöhnliche im Programm vereinbarte Variable verfügbar.

FASN vergibt den Status "befestigt" an Variable vom Typ databox 
UFAS macht die Vergabe rückgängig.

Variable vom Typ databox, welche beim Start des Programms automatisch installiert werden
oder danach durch LN/LX installiert werden, sind von sich aus "befestigt". Das Installieren
kann aber auch durch Steckkarten-Kommandos erfolgen, zB. wenn die Größe der databox
erst zur Laufzeit des Programms bekannt wird. Dann sind sie zunächst unbefestigt.

LN.1 leiht den von einer databox in RAM1 belegten Speicherplatz an mehrere Variable aus, welche vorher als
nicht installiert vereinbart wurden und nach dem Ausleihen den Speicherplatz der databox überdecken.

LX.1 leiht einen Teil des Speicherplatzes einer databox ab einem Startindex an mehrere Variable aus.

Entsprechend LN.2 und LX.2 für RAM2. In RAM1 sind die mehreren
Variablen kurze Variable vom Typ data, oder selber wieder vom
Typ databox, in RAM2 sind sie stets wieder vom Typ databox.

Beim Ausleihen aus einer databox prüft LN/LX, ob die databox befestigt ist. Andernfalls
wäre sie verschiebbar oder könnte uninstalliert werden, so dass Schreibzugriffe auf die
durch das Ausleihen erzeugten Variablen Unheil anrichten könnten.

RELS macht das Ausleihen rückgängig.

Bei den Operationen ACQU, FASN, LN/LX garantiert der Compiler,
dass das zugehörige UACQ, UFAS, RELS im selben Block liegt.
Die jeweilige Operation und das zugehörige Rückgängigmachen
bilden selber wieder einen Block.

'''Ergänzung zu Sprungbedingungen:'''

Es kann abgefragt werden, ob eine 1-oder 2-Byte-Variable
Null ist und ob sie gleich ff bzw. ffff ist.

Die Kommandos =TT.Z und =TT.M können diese Bedingungen
speichern in einem speziellen Byte im RAM, dem TF-Merker.
Dazu schieben sie eine 1 oder 0 von oben auf den TF-Merker.
In gleicher Weise können Steckkarten-Kommandos nCOMMAND
beliebige Bedingungen ermitteln und speichern.

Es gibt bedingte Sprünge, welche die obersten 3 Bit des
TF-Merker mittels einer Wahrheitstabelle abfragen. Dabei
können bis zu 3 Bits wieder vom TF-Merker entfernt werden.

Mittels der Routinen =PP.r, =PZ.r, =PM.r ist es möglich,
solche Bedingungen in einer 1- oder 2-Byte-Variablen zu
speichern, zu verANDen und zu verORen. Damit lassen
sich beliebig komplexe Sprungbedingungen berechnen.

'''Unterprogramme:'''

In der Programmiersprache gibt es keine functions mit
Rückgabewert, sondern nur einfache Unterprogramme, bei
welchen alle Parameter gleichberechtigt sind. Es werden
ausschließlich Zeiger übergeben.

'''Variablen vom Typ FIX:'''

Ihre Werte sind Teil des Programmcodes und liegen dort am Ende.
Der gesamte Speicherbereich dieser Werte kann als "FIXBOX" vom
Programm abgetrennt werden und dann mittels eines speziellen
Werkzeugs bearbeitet werden.

[[Kategorie:FPGA-Projekte]]

Datei:Bo8h.zip

2024-11-27T13:50:56Z

Bome: Bome lud eine neue Version von Datei:Bo8h.zip hoch

Datei:Bo8h.zip

2024-11-01T13:49:58Z

Bome: Fehler-Korrektur

Datei:Bo8h.zip

2024-10-21T20:00:12Z

Bome: Bome lud eine neue Version von Datei:Bo8h.zip hoch

Datei:Bo8h.zip

2024-06-11T19:13:32Z

Bome: Bome lud eine neue Version von Datei:Bo8h.zip hoch

8bit-CPU: bo8

2024-06-06T00:44:36Z

Bome: Funktion des REP-Signals geändert

''von:''   Josef Gnadl ([http://www.mikrocontroller.net/articles/Benutzer:Bome bome])

Die CPU ist Teil eines Gesamt-Projekts: [[8bit-Computer: bo8h]]. 
Dort findet sich auch eine erläuternde Beschreibung der CPU.

Meine Website zum Projekt: http://www.bo8h.de

Beitrag im Forum: [http://www.mikrocontroller.net/topic/407050 Befehlssatz der bo8-CPU] 
Dort findet sich auch einiges zur Wortbedeutung der Mnemonics.

Im folgenden Text steht der Punkt in den Mnemonics für einen 
hier nicht darstellbaren auf der Grundlinie liegenden Bindestrich.

<pre>
================================================================

P Q R S X Y Z K V Bezeichnung: A7 = U
| | | | | | | |A AB = K
| | | | | | | |B

P Programmzähler Q Rückkehradresse
X Adressregister R Schleifenstartadresse
Y Adressregister S Schleifenzähler
Z Adressregister A Akku B Erweiterung V Carry

----------------------------------------------------------------
a0 .. af Adressleitungen - Tristate
d0 .. d7 Datenleitungen - Tristate
N0 .. N3 Typleitungen - permanente Ausgänge
RES REP Reset Repeat - Eingänge
C0 C1 Takt Takt - Eingänge

0 1 2 3 0 1 2 3 0
/ / / / / / / / /
====----====----====----====----====---- C0
--====----====----====----====----====-- C1
[ tA [ tB [ tA [ tB [

--==------==------==------==------==---- Cx

An Eingängen C0 C1 darf Cx statt C0 C1 anliegen
Cx darf auch symmetrisch sein (Tastgrad 50%)

Die Halbzyklen tA und tB bilden einen Vollzyklus (tA/tB).

Typleitungen ändern ihren Zustand zu Zeitpunkten 0 und 2
Adressen und Write-Daten sind gültig von Zeitpunkt 0 bis 2
Einlesen von Read-Daten zum Zeitpunkt 2
Einlesen von REP bei HA zum Zeitpunkt 2

RES muss enden mit Zeitpunkt 0 bis rechtzeitig vor Zeitpunkt 1
Zum Zeitpunkt 2 Einlesen der Startadresse nach P und R vom
Adressbus und des Akku A vom Datenbus. Folgender Zeitpunkt 0
Start des Programmms mit (FE/BN) für ersten OpCode.

REP wird eingelesen in der Mitte eines IO-Zyklus (HA/BP) oder
eines Wait-Zyklus (AR/BN). REP bewirkt Anhängen eines (AR/BN).

----------------------------------------------------------------
Typ Name Funktion

0/tB BN normal tB inaktiv
1/tA AR repeat tA inaktiv - wiederhole input
2/tA KA Adressbus gibt K aus - Datenbus inaktiv
3/tA HA Adressbus gibt K aus - input A

4/tB BP memory-page-Umschaltung für P
5/tB BX memory-page-Umschaltung für X
6/tB BY memory-page-Umschaltung für Y
7/tB BZ memory-page-Umschaltung für Z

8/tA FE read / Adresse ist P / OP-Code
9/tA WX write / Adresse ist X
a/tA WY write / Adresse ist Y
b/tA WZ write / Adresse ist Z

c/tA RP read / Adresse ist P
d/tA RX read / Adresse ist X
e/tA RY read / Adresse ist Y
f/tA RZ read / Adresse ist Z

----------------------------------------------------------------
+0 +1 +2 +3 +4 +5 +6 +7

00- H.. ST.S SS.X ST.X SS.Y ST.Y SS.Z ST.Z
08- IX0 IX1 IX2 IX3 IX4 IX5 IX6 IX7
10- IY0 IY1 IY2 IY3 IY4 IY5 IY6 IY7
18- IZ0 IZ1 IZ2 IZ3 IZ4 IZ5 IZ6 IZ7
20- ZO.S SL.S ZO.X SL.X ZO.Y SL.Y ZO.Z SL.Z
28- DX0 DX1 DX2 DX3 DX4 DX5 DX6 DX7
30- DY0 DY1 DY2 DY3 DY4 DY5 DY6 DY7
38- DZ0 DZ1 DZ2 DZ3 DZ4 DZ5 DZ6 DZ7
40- O.VZ O.VS B.VZ B.VS O.UZ O.US B.UZ B.US
48- O.AZ O.AS B.AZ B.AS O.KZ O.KS B.KZ B.KS
50- O.WY O.RP B.WY B.CN GTR ADR GTA NOL
58- IKL DKL IXL DXL IYL DYL IZL DZL
60- AD. LV. AV. SV. GT. AN. XR. NR.
68- STMX LVMX AVMX SVMX GTMX ANMX XRMX NRMX
70- STMY LVMY AVMY SVMY GTMY ANMY XRMY NRMY
78- STMZ LVMZ AVMZ SVMZ GTMZ ANMZ XRMZ NRMZ
80- NO2 TK1 TK2 TK3 TK4 TK5 TK6 TK7
88- TK8 TK9 TKa TKb TKc TKd TKe TKf
90- NO1 TA1 TA2 TA3 TA4 TA5 TA6 TA7
98- ST.B LV.B AV.B SV.B GT.B AN.B XR.B NR.B
a0- EX.S LV.S AV.S SV.S GT.S LD.S AD.S SD.S
a8- EX.X ES.X SW.X RS.X GT.X LD.X AD.X SD.X
b0- EX.Y ES.Y SW.Y RS.Y GT.Y LD.Y AD.Y SD.Y
b8- EX.Z ES.Z SW.Z RS.Z GT.Z LD.Z AD.Z SD.Z
c0- R.VZ R.VS R.UZ R.US R.AZ R.AS R.KZ R.KS
c8- R.WY R.CN R.IX R.DX R.IY R.DY R.IZ R.DZ
d0- GH.S GL.S GH.X GL.X GH.Y GL.Y GH.Z GL.Z
d8- IC.S DC.S IXE DXE IYE DYE IZE DZE
e0- ZO.U SE.U ZO.V SE.V CP.U NE.U CP.V NE.V
e8- PV.A TZ.A PV.B TZ.B RD.A RU.A RD.B RU.B
f0- ZO.A NE.A ZO.B NE.B IV.A DV.A SL.K S.RP
f8- IC.K DC.K ZO.K NE.K IC.A DC.A GT.Q J..

00 .. 3f 1 Byte
40 .. 67 2 Byte
68 .. ff 1 Byte

00 .. 3f 1 Zyklus / Sonderfall 00
40 .. 53 2|3 Zyklen
54 .. 7f 2 Zyklen / Sonderfall 57
80 .. ff 1 Zyklus / Sonderfall 80

Während der Ausführung eines Befehls
wird der nachfolgende OpCode geladen.

----------------------------------------------------------------
nn ist zweites Byte eines 2-Byte-Befehls , % ist X|Y|Z

AN.B A <= A and B
NR.B A <= A nor B
XR.B A <= A xor B
AV.B A <= A+B+V V <= Carry
SV.B A <= A-B-V V <= Carry
LV.B A <= B-A-V V <= Carry
GT.B A <= B
ST.B B <= A

AN. nn A <= A and nn
NR. nn A <= A nor nn
XR. nn A <= A xor nn
AV. nn A <= A+nn+V V <= Carry
SV. nn A <= A-nn-V V <= Carry
LV. nn A <= nn-A-V V <= Carry
GT. nn A <= nn
AD. nn A <= A+nn

ANM% A <= A and (%)
NRM% A <= A nor (%)
XRM% A <= A xor (%)
AVM% A <= A+(%)+V V <= Carry
SVM% A <= A-(%)-V V <= Carry
LVM% A <= (%)-A-V V <= Carry
GTM% A <= (%)
STM% (%) <= A

AV.S K <= K+S+V V <= Carry
SV.S K <= K-S-V V <= Carry
LV.S K <= S-K-V V <= Carry

AD.S K <= K+S
SD.S K <= K-S
LD.S K <= S-K

AD.% K <= K+%
SD.% K <= K-%
LD.% K <= %-K

GT.S K <= S
ST.S S <= K
GT.% K <= %
ST.% % <= K

RS.% S <= %
SS.% % <= S

SL.K B <= A , A <= 0

SL.S S LowByte <= A , S HighByte <= 0
SL.% % LowByte <= A , % HighByte <= 0

GL.S A <= LowByte von S
GH.S A <= HighByte von S
GL.% A <= LowByte von %
GH.% A <= HighByte von %

EX.S Austausch K <> S
EX.% Austausch K <> %
ES.% Austausch S <> %

ZO.S S <= 0
ZO.% % <= 0

ZO.V V <= 0
SE.V V <= 1
NE.V V <= not V
CP.V V <= V xor U

ZO.U U <= 0
SE.U U <= 1
NE.U U <= not U
CP.U U <= V xor U

NE.A A wird logisch negiert
NE.B B wird logisch negiert
NE.K K wird logisch negiert

ZO.A A <= 0
ZO.B B <= 0
ZO.K K <= 0

IV.A A <= A+V V <= Carry
DV.A A <= A-V V <= Carry

IC.A A <= A+1
IC.K K <= K+1
IC.S S <= S+1

DC.A A <= A-1
DC.K K <= K-1
DC.S S <= S-1

PV.A A <= 8-fache Kopie von V , V <= 0
PV.B B <= 8-fache Kopie von V , V <= 0

TZ.A wenn nicht A=0 dann ( V <= 1 )
TZ.B wenn nicht B=0 dann ( V <= 1 )

RD.A A wird nach unten durch V rotiert
Resultat V7654321 V <= Bit0
RD.B B wird nach unten durch V rotiert
Resultat V7654321 V <= Bit0

RU.A A wird nach oben durch V rotiert
Resultat 6543210V V <= Bit7
RU.B B wird nach oben durch V rotiert
Resultat 6543210V V <= Bit7

TAs mit s= 1..7 A wird s Bitstellen nach oben verdreht
Resultat von TA3 ist 43210765

TKs mit s= 1..f K wird s Bitstellen nach oben verdreht

I%s mit s= 0..7 % <= %+s+1
D%s mit s= 0..7 % <= %-s-1

I%E % <= %+1 , und Austausch A <> B
D%E % <= %-1 , und Austausch A <> B

IKL nn K <= K+nn+1
DKL nn K <= K-nn-1
I%L nn % <= %+nn+1
D%L nn % <= %-nn-1

GTA nn K <= 00nn
GTR nn K <= P+nn+3
ADR nn K <= K+P+nn+3

NO1 no operation 1 Zyklus
NO2 no operation 2 Zyklen

NOL nn no operation 2+nn Zyklen falls nn > 0
NOL 00 K <= R 2 Zyklen

GT.Q K <= Q

S.RP R <= P+1
O.RP nn R <= P+2 , P <= P+nn+3

Bedingung cc ist WY always
VZ V ist 0
VS V ist nicht 0
UZ U ist 0
US U ist nicht 0
AZ A ist 0
AS A ist nicht 0
KZ K ist 0
KS K ist nicht 0

O.cc nn wenn cc dann ( P <= P+nn+3 )
B.cc nn wenn cc dann ( P <= P-nn-1 )
B.CN nn wenn nicht S=0 dann ( P <= P-nn-1 , S <= S-1 )

R.cc wenn cc dann ( P <= R )
R.CN wenn nicht S=0 dann ( P <= R , S <= S-1 )
R.I% wenn nicht S=0 dann ( P <= R , S <= S-1 , % <= %+1 )
R.D% wenn nicht S=0 dann ( P <= R , S <= S-1 , % <= %-1 )

Bei O.VZ, O.VS, B.VZ, B.VS, R.VZ, R.VS wird V <= 0

Alle O-,B- Operationen dauern 3 Zyklen | 2 Zyklen
wenn der Sprung erfolgt | nicht erfolgt

J.. P <= K , R <= K , Q <= P+1 , K <= P+1

SW.% Nach dem Einlesen des folgenden OpCodes mit FE wird
statt eines BN ein B% ausgegeben. Das soll extern
eine memory-page-Umschaltung für % bewirken. Das
Resultat muss schon beim folgenden tA bereitstehen.

H.. Nach dem Einlesen des folgenden OpCodes mit FE wird
statt eines BN ein BP ausgegeben. Das soll extern
eine memory-page-Umschaltung für P bewirken. Das
Resultat muss schon beim folgenden tA bereitstehen.

Wenn der eingelesene folgende OpCode ein J.. ist,
ist H.. damit beendet. Dauer von H.. ist 1 Zyklus.

Wenn der OpCode kein J.. ist, folgt ein IO-Zyklus
(HA/BP). Das BP soll die memory-page-Umschaltung
für P wieder aufheben. Dauer von H.. ist 2 Zyklen.

Ausnahme: Wenn der OpCode wieder ein H.. ist,
folgt (KA/BN) statt (HA/BP). Danach bleibt die
CPU im Zustand BN bis ein Reset erfolgt.

</pre>

[[Kategorie: FPGA-Projekte]]