Régóta gondolkodtam egy saját számítógép megépítésén, és mostanra jutottam el odáig, hogy meg is tudjam valósítani. Az elkészítésben nagy segítséget nyújtott a SEM és a műhelyük, ahonnan alkatrészeket kaptam, és hibajavítás céljából egy nyákot is legyártottam.
A cikk egy saját tervezésű processzorról fog szólni, amit a Digit tárgyban már megismert regiszterek, számlálók és multiplexerek segítségével sikerült összeraknom. Igyekeztem a lehető legegyszerűbb (azaz legkevesebb hibalehetőséget tartalmazó) áramkört létrehozni.
A processzor két 10×10 cm-es nyákból áll, az egyiken a vezérlő egység, a másikon az aritmetikai egység kapott helyet. Maga a processzor 4-bites (azaz 0 és 15 közötti számokkal dolgozik). Az eredeti változatban sajnos elég sok hibát találtam, de az ide feltöltött tervrajzokban ezek már javítva vannak. Jelenleg a bemenetre 4 kapcsolót, a kimenetre pedig 4 LED-et raktam, de ez akár shift regiszterekkel is bővíthető.
Schematic: aritmetikai egység, vezérlő egység
Utasításkészlet:
Aritmetikai utasítások esetén az egyik operandus a 4-bites akkumulátor (A) regiszer vagy a 0. A másik operandus lehet egy szám, az INPUT külső bemenet, vagy egy adat a memóriából, illetve ezek kettes komplensei (azaz -1 -szeresei).
- add/sub: összeadás és kivonás (modulo 16), az átvitelbit minden műveletvégzés után alaphelyzetbe állítódik
- and/or/xor: bitműveletek
- mov: adatmozgatás, az A regiszer tartalma a megadott címre kerül az adatmemóriába, vagy az OUTPUT kimeneti regiszterbe
- jmp: ugrás, a programszámláló (PC) regiszter átállítása
- jz/jnz: feltételes ugrás, csak akkor ugrik, ha A zérus, illetve nem zérus
Az utasítások formátuma “utasítás érték”, pl. “add 5“, de az assembler bonyolultabb parancsokat is ismer, amiket visszaalakít a processzor számára érthetővé, pl. “inc @0” (ami C-ben ezt jelenti: memory[0]++ ) helyett “and 0, or @0, add 1, mov @0“.
Aritmetikai egység:
Itt található az adatmemória, amiben 16 darab 4-bites érték tárolható. A memória adatbuszán található még egy three-state buffer is, hogy írni és olvasni is lehessen belőle. Minden aritmetikai utasítás után számolás eredménye az A regiszterbe kerül. Ha “mov OUTPUT” utasítás érkezik, akkor az OUTPUT kimeneti regiszterbe másolódik az A regiszter értéke.
Maga a számítást végző rész egy mindössze 3 darab logikai kapus (azaz AND, OR, XOR) IC-ből álló kombinációs hálózat, ami az eredményt bitenként számítja ki, és beleshifteli az A regiszterbe. A bitek számítása között keletkező átvitelt és az eredmény zérusságát egy külön státuszregiszterben tárolom, ahonnan csak a zérus (Z) jelet vezettem ki. Emiatt egy műveletvégzés 4 órajelet igényel.
A maradék IC multiplexer, ami arra szolgál, hogy a operandust (szám, memória vagy INPUT) és a megfelelő művelet eredményét (add/sub, and, or vagy xor) kiválassza, illetve hogy a műveletek elején a carry és zero flageket alaphelyzetbe állítsa.
Vezérlő egység:
A feladata, hogy a programmemóriában az éppen a programszámláló (PC) által kijelölt címen található utasításnak megfelelően állítsa elő a vezérlőjeleket az aritmetikai egység számára. A PC regiszer két darab számlálóból áll, így összesen 256 utasítás megcímzésére alkalmas. A programmemória adat- és címvezetékei ki vannak vezetve, hogy pl. egy Arduino-val lehessen rá a programot feltölteni.
Egy aritmetikai számoláshoz 4 órajel szükséges, de még az aktuális utasítást több memóriacímről is ki kell olvasni (mivel minden utasítás 12 bites, de a memóriának csak 8 adatvezetéke van), ezért az egyszerűség kedvéért minden utasításnak 8 órajelnyi időt adtam, és egy számláló alsó 3 bite segítségével állítottam elő a vezérlőjeleket (pl. az adatmemória írása, az A regiszer léptetése, stb.).
Az itt található gombokkal lehet resetelni, és a végrehajtást szünetelni.
Példaprogramok (erős idegzetűeknek):
Az Arduinonak csak az a szerepe, hogy feltöltse a programokat, és még debuggerként is használható. Feltéve, hogy a program már beíródott a programmemóriába, csak egy külső órajel kell a működéshez, amit szintén az Arduino szolgáltat.
Egyszerű számláló, ami a bemenetről beolvasott számnak megfelelő ciklusnyit várakozik:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 |
/* ezt valósítja meg a kód: counter = 0; while(true){ delay = INPUT; while(delay--) {} OUTPUT = counter++; } */ alias delay @0 //változók deklarálása alias counter @1 eq counter, 0 //értékadás loop: //ez egy címke eq delay, INPUT delayloop: jz break dec delay jmp delayloop break: eq OUTPUT, counter inc counter jmp loop |
Megszámolja az 1-es biteket a bemeneten (popcount):
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
alias db @0 alias i @1 popcount: eq i, INPUT eq db, 0 loop: ld i jz exit and 0b1000 jz skip_inc inc db skip_inc: ld i add i mov i jmp loop exit: eq OUTPUT, db jmp popcount |
Pszeudovéletlenszám-generátor:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 |
/* lsfr -- linear-feedback shift register részletek: https://en.wikipedia.org/wiki/Linear-feedback_shift_register 15-ös periódusú 4-bites számsorozat előállítása while(true){ if (i & 1) { i = (i >> 1) ^ feed; } else { i = (i >> 1); } } a "feed" értéke csak 9 vagy 0xC lehet */ alias i @0 //így lehet változókat deklarálni alias j @1 //segédváltozó alias feed 9 //ez egy konstans nop init: eq i, INPUT //az INPUT nem lehet 0 lsfr: eq OUTPUT, i //először j = i >> 1 értéket kell kiszámítani //mivel nincs jobbra shiftelés, ezért bitvadászat következik //j = 0 eq j, 0 //j += i&0b1000 ? 0b0100 : 0 tst i, 0b1000 jz skip1 ld j add 0b0100 mov j skip1: //j += i&0b0100 ? 0b0010 : 0 tst i, 0b0100 jz skip2 ld j add 0b0010 mov j skip2: //j += i&0b0010 ? 0b0001 : 0 tst i, 0b0010 jz skip3 ld j add 0b0001 mov j skip3: //most már: j = i >> 1 tst i, 1 jnz if jz else //if(i&1){ if: //i = j^feed ld j xor feed mov i jmp endif //}else{ else: //i = j eq i, j //} endif: jmp lsfr |
