Hallo, schön dass du dir diese Seite anschaust.
Damit du besser verstehst, wie diese Anwendung funktioniert, hier einmal die Basics:
Ganz oben findest du eine Reihe mit Kontrollknöpfen. Jeder Knopf hat seine eigene Funktion.
Der Computer ist in mehrere Bausteine aufgeteilt. Jeder Baustein hat eine eigene spezielle Funktion. Ein echter Computer ist natürlich deutlich komplizierter, aber so ist der PC deutlich verständlicher.
Im Arbeitsspeicher wird das Programm gespeichert. Jeder Eintrag ist dabei in ein Low-Byte und ein High-Byte unterteilt. Dadurch kann man in einem Eintrag die Instruktion und Addresse einfacher unterscheiden.
Siehe Befehle
Wie der Name es schon sagt, steuert und verwaltet die Control Unit alle Vorgänge im Computer. Das passiert dadurch, dass eine Instruktion in viele kleine µCodes aufgeteilt wird.
Diese µCodes sind in der Tabelle aufgeführt. Jede Instruktion besteht hier aus bis zu 10 µCodes.
Bei einem Befehl z.B. 001 00000 ist die Instruktion in den ersten drei Stellen zu finden. Dieser Wert wird dann mit 10 multipliziert und in den µCode Counter geladen.
In diesem Fall stände dann 0010 im Counter.
In der Tabelle sind dann alle Befehle für die Instruktion 001 zu finden.
Die Arithmetik Logic Unit ist hier sehr einfach aufgebaut.
Sie kann den Akkumulator nur erhöhen oder erniedrigen. Dafür können Werte aber direkt vom Datenbus geladen werden.
Über den Datenbus können Daten und Befehle zwischen RAM, Control Unit und ALU übertragen werden.
Über diesen Bus kann die Control Unit steuern, welcher Wert im RAM ausgewählt wird.
Bei normalen Rechnern sind hier natürlich noch deutlich mehr Werte angeschlossen.
Ein Befehl besteht aus einer Instruktion und einem Argument. Deshalb sind im RAM und im Instruction Register alle Werte separiert.
0 0 0 0 0 0 0 0
Instr Argument
Eine Instruktion kann nicht direkt ausgeführt werden. Deshalb wird sie durch mehrere kleine Befehle, sog. µCodes zusammengesetzt.
| µCode | Beschreibung |
|---|---|
| ProgCounter -> AddrBus | Lade den Wert des Programm Counters in den Adressbus |
| InstrReg -> ProgCounter | Lade das Argument des Instruktionsregisters in den Programm Counter |
| ProgCounter ++ | Erhöhe den Wert des Programm Counter um 1 |
| Acc == 0 => InstReg -> ProgCounter | Wenn der Wert des Akkumulators 0 ist, dann lade das Arggument des Instruktionsregisters in den Programm Counter |
| Ram -> DataBus | Schreibe den aktuellen Wert aus den RAM auf den Datembus |
| DataBus -> Ram | Schreibe den Wert des Datenbus in die momentane Stelle des RAM |
| DataBus -> InstReg | Lade den Befehl vom Datenbus in das Instruktionsregister |
| DataBus -> Acc | Lade den Wert vom Datenbus in den Akkumulator der ALU |
| Acc -> DataBus | Schreibe den Wert vom Akkumulator auf den Datenbus |
| Acc ++ | Erhöhe den Wert des Akkumulators um 1 |
| Acc -- | Verringere den Wert des Akkumulators um 1 |
| InstReg -> µCounter | Nehme das Argument des Befehls im Instruktionsregister, füge am Ende eine 0 an und Lade ihn in den µCounter |
| InstReg -> AddrBus | Lade das Argument im Instruktionsregister in den Addressbus |
| µCounter = 0 | Setzte den µCounter zurück |
Im Moment ist dieser Code noch nicht ordentlich genug, dass es Sinn hat ihn zu veröffentlichen.
Dieses Projekt ist angelehnt an den Johnny-Simulator.
Hello. In order for you to understand what this App does, I want to show you some basics of this app.
At the top of the application you can see a row of control buttons:
This computer is made up by multiple blocks like any other neumann-maschiene. Every block has it's own unique set of functions. A normal computer is much more complex than this, but the principle is the same.
The current programm is stored in the RAM. Every entry is seperated as mentioned in entry.
As the name suggests, the control unit manages everything that is done. To know what needs to be done it has a list of µCodes that gets executed when a instruction is requested.
These µCodes can be found in the table. Every instruction consists of up to 10 µCodes.
When a entry is executed, the first three digits (the instruction) gets multiplied by 10. This now is written into the µCounter and the µCodes for it get's executed.
Example:
When the entry 001 00000 gets executed, the µCounter would be set to 0010. Now every µCode starting at location 0010 in the µCodes gets executed.
The Arithmetic Logic Unit is pretty simple in this case.
The ALU can only increment or decrement the accumulator. But it can read numbers from databus.
Via the Databus values and entrys can be transported between RAM, Control Unit and ALU.
With the addressbus the Control Unit can control which value is selected in RAM. On a normal computer there are a lot mor things attached to this bus.
Each entry consits of a instruction and an argument. That's why the entrys in RAM and in µCodes are displayed seperatly.
0 0 0 0 0 0 0 0
Instr Argument
Every instruction consists of a list of µCodes. Here is an explanaition for all of them:
| µCode | Description |
|---|---|
| ProgCounter -> AddrBus | Load the value from programm counter to addressbus |
| InstrReg -> ProgCounter | Load the argument from instruction register to programm counter |
| ProgCounter ++ | Increment programm counter by 1 |
| Acc == 0 => InstReg -> ProgCounter | If the accumulator is 0 then write the argument from instruction register to programm counter |
| Ram -> DataBus | Load selected value from RAM to databus |
| DataBus -> Ram | Write value from databus to selected value in RAM |
| DataBus -> InstReg | Write entry from databus to instruction register |
| DataBus -> Acc | Write value from databus to accumulator |
| Acc -> DataBus | Load value from accumulator to databus |
| Acc ++ | Increment accumulator by 1 |
| Acc -- | Decrement accumulator by 1 |
| InstReg -> µCounter | Take the instruction from instruction register, add a 0 at the tail and write it to µCounter |
| InstReg -> AddrBus | Write the argument from instruction register to addressbus |
| µCounter = 0 | Set µCounter to 0 |
At the moment the code for this project isn't good enough to share it online.
This project is my take on Johnny-Simulator.