4-bit CPU

Ik dacht gister, laat ik eens wat anders doen dan met een pic spelen... Ik zat wat op YT te kijken naar projectjes en opeens kwam een 4 bit 'rekenmachien' voorbij die ze een 4 bit computer noemden. Hierdoor kwam ik op het idee om het te gaan proberen: een simpele 4-bit cpu.

Zo heb ik me gister een beetje verdiept in cpu's en heb gekeken of ik een blokschema/datapad van de cpu kon tekenen. Dit is wel gelukt. Nu is mijn vraag of dit voor een 4-bit cpu met 8-adressen, 4-bit opcode en 4-bit operands bruikbaar is: (ik heb de tekening zelf getekend en ontworpen... Fouten of 'onmogelijkheden' hoor ik graag!)
https://dl.dropboxusercontent.com/u/59298953/Afbeeldingen/CO/zjSuBix.png
PC = program counter
P. M. = program memory
IR = instruction register
cont. logic = control logic (verzorgt de cycli en de enables/writes)
opc = opcode
opr = operand
+ 1 = 'opteller' voor program counter

Ik had ook al een mogelijke instructieset in gedachte:

code:


0  MOVLA              |opr -> A                       |0 4bOPR
1  MOVLB              |opr -> B                       |1 4bOPR
2  MOVAF              |A -> ram[opr]                  |2 8bADR
3  MOVBF              |B -> ram[opr]                  |3 8bADR
4  MOVFA              |ram[opr] -> A                  |4 8bADR
5  MOVFB              |ram[opr] -> B                  |5 8bADR
6  GOTO / JMP         |pc = opr                       |6 8bADR
7  GOTOIF / JMPIF     |pc = opr als (STATUS.Z = 0)    |7 8bADR
8  ADD                |A + B -> A                     |8 
9  SUB                |A - B -> A                     |9 
A  AND                |A ^ B -> A                     |A 
B  OR                 |A V B -> A                     |B 
C  XOR                |A XOR B -> A                   |C 
D  NOTA               |-(A) -> A                      |D 
E  NOTB               |-(B) -> A                      |E 
F  NOP                |A -> A                         |F 

INPUT -> 4bOPC 4bOPR / 4bOPC 8bADR

Is dit iets bruikbaars?

Ik wil het graag eerst helemaal gesimuleerd hebben in logisim zodat ik eerst helemaal bezig kan zijn met het logische gedeelte en later pas met de tijd, spanning, stroom enz... En dan hoef ik ook geen horden breadboards te kopen of enorm lastige prints te ontwerpen.

Alvast bedankt!

Joppe

Wees altijd vrolijk!

Op zich zou je dit heel mooi in VHDL of Verilog kunnen programmeren. Je kunt het dan dmv een HDL simulator als Modelsim volledig simuleren. Aanpassingen zijn snel te maken. Eventueel kun je later nog instructies toevoegen, of er een 8 bitter van maken.

"We cannot solve our problems with the same thinking we used when we created them" - Albert Einstein

Is VHDL en Verilog niet syntax-gestuurd (voor een FPGA)? Want dat ben ik niet echt van plan... Dan zit ik weer met het programeren (niet dat het erg is... maar ik wilde een keer iets anders).

Wees altijd vrolijk!

Ja, dat is het. Het zijn beide HDL wat gebruikt wordt voor FPGA en ASIC design. Maar nu simuleer je toch ook? Wat je in HDL hebt opgeschreven, kun je altijd nog in logische poortjes gaan opbouwen. 'T is maar een ideetje.

"We cannot solve our problems with the same thinking we used when we created them" - Albert Einstein

Ja... je hebt wel gelijk... maar ik ga het toch in logisim proberen (ja... ik ben koppig :p ) maar ik hou het in mijn achterhoofd!!

En is de architectuur bruikbaar voor wat ik wil? (ik wil gewoon een werkende cpu, hij hoeft dus niks byzonders te kunnen...) Ik heb het namelijk niet van internet ofzo... Ik heb een pic-datapad erbij gepakt (waar ik niet zo heel veel van snapte...) en geprobeerd zelf iets te tekenen waar ik wèl iets van snapte ;)

Wees altijd vrolijk!

Ik heb op internet meerdere van dergelijke projecten gezien, sommige erg indrukwekkend. Ik zal je de links sturen, mogelijkerwijs heb je er iets aan.

De eerste die ik ooit tegenkwam. De site lijkt inmidels offline, maar is nog te benaderen via archive.org:

MyCPU: http://web.archive.org/web/20070122083000/http://mycpu.eu/

Erg compleet, een indrukwekkende prestatie (niet helemaal wat jij van plan bent, maar de bouwer ervan kanje vast goed op weg helpen met vragen). Je kunt er remote (Telnet/SSH) op inloggen: de Magic-1 op http://www.homebrewcpu.com/

En verder nog "wire-wrap galore": http://www.bigmessowires.com/bmow1/
en: http://www.holmea.demon.co.uk/Mk1/Architecture.htm

Leuk altijd die projecten "omdat het kan" :)

Success ermee!

Ps. Mijn first post op circuits online!. Na een hoop lezen nu maar eens terug typen.. :)

Een paar van die cpu's ben ik ook al tegen gekomen, maar MyCpu nog niet. Het is een mooi ding! Die is alleen iets (nou... zeg maar veel) te ingewikkeld voor me ;p (Videokaart etc). Al die architecturen lijken MIJ te ingewikkeld... (misschien is het dat niet... maar je moet je wel even bedenken dat ik 16 jaar ben en niet alles weet van de inwendige pc).

(MyCpu.eu doet het bij mij gewoon hoor)

En het schema wat ik heb getekend lijkt mij te maken. (Alu en registers zijn niet zo ingewikkeld. Alleen de CL is denk ik lastig). En met een Algemeen Databus en een adresbus begrijp ik niet helemaal...

Wees altijd vrolijk!

Ja ik snap dat die projecten wat te ver gaan voor als een een eerste 4bit ontwerpje wil maken. Met vragen kun je denk ik wel goed terecht bij de heren die al dat moois in elkaar gefrutselt hebben.

nog iets wat met zo te binnen schiet. (iets wat ik zelf zou doen als ik een project als jij zou aanvangen)

Je kunt eens kijken naar emulatoren van bestaande (zoals 4004, 6502, 6800, 8080 of Z80) processoren of fictieve ontwerpen. Het kan leerzaam zijn te kijken hoe anderen dit oplossen.

Verder is het interessant om inderdaad VHDL beschrijvingen te bekijken van processor cores, daar deze direct de hardware beschrijven. (je kunt ze geautomatiseerd omzetten naar een schema met logica erin) Een van de simpelste ontwerpen is deze: http://opencores.org/project,mcpu (pdf beschrijving: http://www.opencores.org/svnget,mcpu?file=/web_uploads/mcpu-doc.pdf)

op opencores.org staan sowieso nog tientallen CPU designs in VHDL/Verilog formaat ter bestudering.

Hmm, bestaande ontwerpen zijn veel te complex voor de TS. Niet doen. Gewoon wat eenvoudigs opzetten en kijken wat er gebeurt in de simulator.
Ps, er is een ander topic in CO waar iemand ook zo fanatiek bezig ging. Heb je die al gezien?

"We cannot solve our problems with the same thinking we used when we created them" - Albert Einstein

@flipflop: nee, die heb ik nog niet gezien. Ik kan hem zo snel niet vinden via zoeken. Heb jij misschien de link?

Wees altijd vrolijk!
GJ_

Moderator

Als je nog simpeler wil kun je ook een naar een 1-bitter kijken. De MC14500 was vroeger nogal een populair ding.

@GJ_ : Die ziet er interessant uit... Ik denk dat ik er wel wat ideetjes uit kan halen! (Maar overgaan op een 1 bit cpu zie ik niet zo zitten.... maar dat ligt aan mij :p maar de architectuur ziet er niet al te ingewikkeld uit. Ik zal de manual maar eens doorspitten :) )

Wees altijd vrolijk!

Op 5 januari 2013 17:23:14 schreef GJ_:
Als je nog simpeler wil kun je ook een naar een 1-bitter kijken. De MC14500 was vroeger nogal een populair ding.

Daar heb ik een PLC mee gebouwd.

1-st law of Henri: De wet van behoud van ellende. 2-nd law of Henri: Ellende komt nooit alleen.
GJ_

Moderator

LEUK!!! Daar was ie ook voor bedoeld :-) Heb je daar nog wat van? (niet in dit topic)

Ja staat op een van de CO posts "show your projects", dat board met al die lakdraadjes, misschien weet je het nog wel?

-edit-: Hier staat ie ergens, helemaal onderaan:
http://www.circuitsonline.net/forum/view/103304/30

[Bericht gewijzigd door henri62 op zondag 6 januari 2013 13:34:44 (33%)

1-st law of Henri: De wet van behoud van ellende. 2-nd law of Henri: Ellende komt nooit alleen.

Een 8-bit CPU is niet veel ingewikkelder dan een 4-bitter, je zal sowieso toch minimaal een vergelijkbare hoeveelheid logica nodig hebben voor decoderen van verschillende instructies, timen van gebeurtenissen, etc.

Je zou ook een bestaande 8-bitter kunnen pakken (zoals een 8080? of nog antieker? ik roep maar wat), en de instructie set nog wat strippen om de zaak 'simpel' te houden. Of uitgaan van een CPU die bedoeld is om in een kleine CPLD te zetten (zie OpenCores).

Voordeel van een bestaande CPU is dat kant-en-klare tools voor het grijpen liggen om software voor je systeempje te schrijven. En afhankelijk van hoever je 't uitbouwt, misschien zelfs iets 'nuttigs' als spelletjes erop spelen. ;)

Een eerder soortgelijk topic op CO: Zelfbouw CPU+ram+program memory (surprise surprise, ligt ook al weer een tijdje stil)

Misschien ook interessant: From NAND to Tetris

Meestal verzanden dit soort projecten in drijfzand (al die details vragen echt doorzettingsvermogen voor je wat interessants werkend hebt), maar:

Leuk altijd die projecten "omdat het kan" :)

Success ermee!

Inderdaad! En op z'n minst leerzaam.

Gister avond ben ik weer een beetje bezig geweest. En ik ben weer een stuk verder. In logisim heb ik nu een werkende CPU gemaakt.
https://dl.dropboxusercontent.com/u/59298953/Afbeeldingen/CO/RdrX.png
Blauw: Adres bus
Groen: Data bus
Rood: Reset
Paars: Opcode
Roze: Alu code
Oranje: Alu flags (zitten nog niet in logisim)
Appeltjesgroen: Workregister datalijnen (W->ALU en ALU->W)
Geel: Control lijnen

Ik heb de instructieset iets aangepast. Ik ben van plan een I/O bank te maken in het RAM. met de opcode 0x00 kan je van bank wisselen. Ook dit zit nog niet in logisim.

Foto's hoe het in Logisim er uit ziet:

https://dl.dropboxusercontent.com/u/59298953/Afbeeldingen/CO/1Y0yWJX.png
De cpu zelf

https://dl.dropboxusercontent.com/u/59298953/Afbeeldingen/CO/8nQbi.png
ROM. Ik weet, er is geen IR. Ik had problemen met de GOTO instruction. Hij fetchte de volgende instruction ook (dus bijvoorbeeld;
GOTO 0x00
MOVLA 0x0F

Hij voerde dan MOVLA 0x0F ook uit. Weet iemand hoe ik dit kan oplossen?)
De Data en het Adres zitten niet in de zelfde nibbles in de operand (4b opcode, 4b data, 8b adres -> de hele instruction is dus 16b)

https://dl.dropboxusercontent.com/u/59298953/Afbeeldingen/CO/sG5Ch.png
RAM. (als het nodig kan ik hem ook met een bidirectioneel ram maken)

https://dl.dropboxusercontent.com/u/59298953/Afbeeldingen/CO/GATn.png
De W-registers (A/B)

https://dl.dropboxusercontent.com/u/59298953/Afbeeldingen/CO/iSkbW5hM.png
De ALU. De flags zijn hier nog niet in verwerkt.

https://dl.dropboxusercontent.com/u/59298953/Afbeeldingen/CO/Mya.png
De control logic. Ik kijk hier gewoon of de opcode exact hetzelfde is als 0, 1, 2, enz... Het systeem is een 'eentact' ... (hij fetcht dus bij elke klokpuls)

De nieuwe instructieset:

code:


0x00  BANK   | 0B--
0x01  MOVLA  | 0L--
0x02  MOVLB  | 2L--
0x03  MOVAF  | 3-AA
0x04  MOVBF  | 4-AA
0x05  MOVFA  | 5-AA
0x06  MOVFB  | 6-AA
0x07  GOTO   | 7OAA
0x08  ADD    | 8---
0x09  SUB    | 9---
0x0a  AND    | a---
0x0b  OR     | b---
0x0c  XOR    | c---
0x0d  NOTA   | d---
0x0e  NOTB   | e---
0x0f  NOP    | f---

L = literal
A = Adres
O = Option (GOTO bij ALU-Flags)
B = Banknummer

Het logisim bestand: http://www.2shared.com/file/9Ve6wAcL/CPU4.html

EDIT:

Ik heb de bankswitching in de RAM gezet:
https://dl.dropboxusercontent.com/u/59298953/Afbeeldingen/CO/Qg71o9.png
Bank 1 moet dan de I/O voorstellen

de control logic met bankswitching
https://dl.dropboxusercontent.com/u/59298953/Afbeeldingen/CO/fNh.png

http://www.2shared.com/file/b3Cy8_P-/CPU5.html

Wees altijd vrolijk!