ARRAYFORTHARRAYFORTHDit artikel is geschreven voor de HCC!Forth interessegroep.
Dit is de tweede versie van dit artikel. Het ziet er het beste uit met Mozilla Firefox.
De eerste versie heeft Leon Konings laten zien tijdens een presentatie voor
de HCC!Forth interessegroep d.d. 14-8-2010.
Website: http://www.forth.hccnet.nl/
Inleiding
Leiden, 14 september 2010
Chuck Moore heeft samen met enige vrienden het nieuwe bedrijf Green Arrays, Inc. opgericht.
In dit bedrijf wordt hard gewerkt aan nieuwe "Multicore Processors".
Op de website zijn simulators voor de verschillende chips te vinden.
Deze kunnen door een ieder gratis worden gedownload.
Eerst beschrijf ik, hoe de installatie in zijn werk gaat.
In een cursus schrijft de lezer een kort arrayForth programma.
Hierbij leert de lezer veel over de tekstverwerker.
Vervolgens wordt het programma getest in de simulator.
Hierbij leert de lezer enige eigenschappen van de simulator.
arrayForth is overigens afgeleid van colorForth.
De tekstverwerker en simulator zijn beide geschreven in colorForth.
Ik behoud mij het recht voor dit artikel in de toekomst te wijzigen.
Dit artikel is gemaakt met de "ActionOutline" tekstverwerker van Green Parrots: http://www.greenparrots.com/.
Kijk vooral voor meer informatie op: http://www.greenarraychips.com/home/documents/greg/cf-intro.htm
Zelf ben ik een beginner op het gebied van colorForth.
Reacties zijn van harte welkom.
Leon Konings
+31 (0)71 5216531
De arrayForth omgeving werkt bij mij op Microsoft Windows XP/Vista.
De versie, die in dit artikel gebruikt wordt is:
http://www.greenarraychips.com/home/documents/greg/code/af-34k2-ga144-1-10-PD.zip
Volg de volgende link om de laatste versie te downloaden:
http://www.greenarraychips.com/home/documents/greg/cf-releases.htm
Deze cursus gaat er van uit dat het qwerty toetsenbord wordt gebruikt.
Ik zelf gebruik sinds kort bij voorkeur het dvorak toetsenbord, maar toen ik de
cursus begon te maken was ik nog niet zo ver.
Voor een nieuweling (zoals ik) is het handig om met de qwerty indeling te beginnen.
Probeer niet te veel nieuwe dingen tegelijk te leren!
Start C:\Forth\ga144\Okad2-41-pd.exe op.
Er verschijnt een versie van ColorForth.
Deze versie bevat ook de simulator voor de GA144-1.10 chip.
Door het console venster te sluiten kunnen beide vensters gesloten worden. Ctrl-C sluit dit venster.
Simpel alternatief in het ColorForth venster:
Type: bye
In het geval van typefouten:
Type: <backspace> (D.w.z. druk de backspace toets in!)
Type het woord vervolgens opnieuw.
Type: <esc> (D.w.z. druk de escape toets in!)
Als er al iets ingetikt is eerst de <backspace> toets indrukken!
Even testen of het werkt:
Type: 1 <spatiebalk> 2 <enter>
De spatiebalk en de enter-toets doen hetzelfde.
Links onder staat de stack in vette gele letters.
Stack: 1 2
Type: +
Stack: 1 2 123 (123 staat voor +)
Type: <spatiebalk>
Stack: 3
Type: <F1>
Rechtsonder is nu de tekst "hex" verschenen.
Type: 1d5
1d5 staat nu linksonder (op de stack).
Type: <F1>
Nu wordt het getal op de stack decimaal weergegeven: 469
<F1> schakelt dus over van decimaal naar hexadecimaal en vice versa.
Het schrijven van een programma in arrayForth is niet eenvoudig.
De ColorForth editor en de GA144 chips zijn zeer innovatief.
Voor deze tutorial heb ik gekozen voor een simpel programma.
De simpele functie f(x) = 2(x+3) + 3(x+5) wordt over drie processoren verdeeld.
Deze processoren worden "nodes" genoemd.
De resultaten worden in een vierde processor op de stack gezet.
De nodes zijn genummerd. Voor de GA144:
linksonder = 000
rechtsonder = 017
linksboven = 700
rechtsboven = 717
De hele matrix heeft 8 rijen en 18 kolommen, en ziet er zo uit:
700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717
600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617
500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517
400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417
300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317
200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217
100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117
000 001 002 003 004 005 006 007 008 009 010 011 012 013 014 015 016 017
De poorten zijn de verbindingen tussen de nodes.
Zij heten: left up down right
Iedere node is dus met zijn vier buren verbonden.
Indien een node aan de rand ligt, kan er bij enige nodes
een verbinding met de buitenwereld gemaakt worden.
Up = hex 145
Down = hex 115
up
700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717
down
600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617
up
500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517
down
400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417
up
300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317
down
200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217
up
100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117
down
000 001 002 003 004 005 006 007 008 009 010 011 012 013 014 015 016 017
up
Left = 175
Right = 1d5
700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717
600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617
l 500 r 501 l 502 r 503 l 504 r 505 l 506 r 507 l 508 r 509 l 510 r 511 l 512 r 513 l 514 r 515 l 516 r 517 l
e 400 i 401 e 402 i 403 e 404 i 405 e 406 i 407 e 408 i 409 e 410 i 411 e 412 i 413 e 414 i 415 e 416 i 417 e
f 300 g 301 f 302 g 303 f 304 g 305 f 306 g 307 f 308 g 309 f 310 g 311 f 312 g 313 f 314 g 315 f 316 g 317 f
t 200 h 201 t 202 h 203 t 204 h 205 t 206 h 207 t 208 h 209 t 210 h 211 t 212 h 213 t 214 h 215 t 216 h 217 t
100 t 101 102 t 103 104 t 105 106 t 107 108 t 109 110 t 111 112 t 113 114 t 115 116 t 117
000 001 002 003 004 005 006 007 008 009 010 011 012 013 014 015 016 017
We gebruiken voor iedere node twee blokken.
Het eerste blok bevat het programma.
Het tweede zogenaamde schaduwblok is bestemd voor commentaar.
Eerst openen we blok 200.
Type: 200 <spatiebalk> edit <spatiebalk>
De tekstverwerker is actief. Rechts onder verschijnt een blok met gele tekst:
t yrgx
cdfj ludr
ab k -mc+
x.i
Type: <spatiebalk>
Het gele blok verdwijnt. De tekstverwerker is inactief.
Type: e
Het gele blok is er weer. De tekstverwerker is actief.
De toetsen:
t yrgx
cdfj ludr
ab k -mc+
x.i
Corresponderen op een qwerty toetsenbord met:
r uiop
asdf jkl;
zx v m,./
n <spatiebalk> <alt>
Dit overzicht geeft aan welke betekenis bepaalde toetsen hebben in de ColorForth tekstverwerker.
cdfj correspondeert met de toetsen: asdf
ludr correspondeert met de toetsen: jkl;
enzovoorts...
In deze cursus wordt bijvoorbeeld gezegd:
Type: a{c}
Type dan: a
{c} is de ColorForth betekenis van de letter a.
calc1
Start met het schrijven van het programma.
Eerst de naam:
Type: r{t} calc1 <spatiebalk> <esc>
De naam is commentaar. Commentaar is wit.
De oranje "pacman" aanwijzer staat achter calc1.
Verwijder dit woord weer:
Type: n{x}
Het woord staat nu in het geheugen. Haal het terug:
Type: <alt>
Er staat weer:
calc1
Verander de kleur van het woord drie maal:
Type: a{c}
calc1 Geel
Type: a{c}
calc1 Groen
Type: a{c}
calc1 Wit
Onder andere handig om code uit te schakelen door er commentaar van te maken.
calc1 0 org br
Type: e <spatiebalk> U bent weer in de tekstverwerker.
Type: u{y} 0 <spatiebalk> org <spatiebalk> <esc>
0 org betekent dat het programma in deze node start op adres 0.
Gele tekst wordt onmiddelijk uitgevoerd.
Type: x{b} br <spatiebalk> <esc>
br in blauw zorgt voor twee carriage returns..
calc x-x' 3 . + dup + ;
Dit woord berekent 2(x+3).
De naam van het woord is rood:
Type: i{r} calc <spatiebalk> <esc>
Het stack commentaar is wit:
Type: r{t} x-x' <spatiebalk> <esc>
De rest van dit woord is groen:
Type: o{g} 3 <spatiebalk> . <spatiebalk>
+ <spatiebalk> dup <spatiebalk> + <spatiebalk> ; <spatiebalk> <esc>
main 1 . + dup calc !b main ;
Dit woord is recursief. Een eeuwigdurende loop. Main roept main "eeuwig" aan.
De naam van het woord is rood:
Type: i{r} main <spatiebalk>
Na een rood woord springt de tekstverwerker automatisch op groen.
Er is dus geen <esc> o{g} nodig.
De rest van dit woord is groen:
Type: 1 <spatiebalk> . <spatiebalk> + <spatiebalk>
dup <spatiebalk> calc <spatiebalk> !b <spatiebalk>
main <spatiebalk> ; <spatiebalk> <esc>
init right 1d5 b! indent
De naam van het woord is rood:
Type: i{r} init <spatiebalk>
De tekstverwerker springt automatisch op groen.
Type: right <spatiebalk>
<F1> zet de hex mode aan.
De 1 in 1d5 zet de num mode aan.
Type: <F1> 1d5 <spatiebalk> <F1> b! <spatiebalk><esc>
1d5 is commentaar en moet dus wit worden:
Type: j{l} (De packman staat nu achter 1d5)
Type: a{c}
1d5 moet nu wit zijn.
Type: ;{r} (De packman staat nu achter b!)
indent zorgt voor een carriage return plus indent en is blauw:
Type: x{b} indent <spatiebalk> esc
-1 main ; br
-1 is numeriek, maar de - zorgt voor text mode. Tik dus eerst de 1 in!
Type: o{g} 1- <spatiebalk> main <spatiebalk> ; <spatiebalk> <esc>
br in blauw zorgt voor twee carriage returns:
Type: x{b} br <spatiebalk> esc
a9 org init ;
Deze regel zorgt ervoor dat bij het starten van het programma het forth woord init als eerste wordt uitgevoerd.
a9 is een hexadecimaal nummer.
<F1> zet de hex mode aan en uit.
De a in a9 text mode veroorzaken.
Tik om dit te voorkomen eerst een 0, dus 0a9.
De voorloopnul verdwijnt automatisch.
Type: u{y} <F1> 0a9 <F1> <spatiebalk> org <spatiebalk> <esc>
De laatste groene woorden:
Type: g{o} init <spatiebalk> ; <spatiebalk> <esc>
Verlaat de tekstverwerker:
Type: <spatiebalk>
Bewaar al het werk:
Type: save <spatiebalk>
Terug naar tekstverwerker.
Type: e
Eerst openen we blok 200.
De tekstverwerker heeft onthouden, dat dit het laatst gewijzigde blok was.
Type: e <spatiebalk>
of
Type: 200 <spatiebalk> edit <spatiebalk>
Ga nu naar het schaduwblok.
Type: p{x} <spatiebalk>
We zijn nu in blok 201. Het schaduwblok.
Type: p{x} <spatiebalk>
We zijn weer in blok 200.
Type: p{x} <spatiebalk>
We zijn weer in blok 201. Het schaduwblok. Alle oneven blokken zijn schaduwblokken.
Deze blokken zijn bedoeld voor het geven van commentaar.
Wij gaan hier een klein stukje commentaar in zetten.
calc x 3 + 2*
De tekst in een schaduwblok wordt nooit uitgevoerd,
en is alleen bedoeld als commentaar.
calc is rood:
Type: i{r} calc <spatiebalk> <esc>
De rest is commentaar, en dus wit:
Type: r{t} x <spatiebalk> 3 <spatiebalk> + <spatiebalk>
De 2 veroorzaakt de numerieke mode.
Dit is niet de bedoeling.
Het `-teken zet de tekstmode aan:
Type: `2* <spatiebalk> <esc> <spatiebalk>
U heeft de tekstverwerker verlaten.
Het programma calc2 is bijna hetzelfde als calc1.
Wij gaan calc1 dus kopiëren, en vervolgens aanpassen.
Ga eerst naar blok 200.
Type: 200 <spatiebalk> edit <spatiebalk> <spatiebalk>
of
Type: 200 <spatiebalk> list <spatiebalk>
Als het goed is, is de tekstverwerker nu niet actief.
Type: 202 <spatiebalk> copy <spatiebalk>
We zijn nu in blok 202.
De blokken 202 en 203 bevatten nu dezelfde tekst als 200 en 201.
Het schaduwblok is dus ook mee gekopieerd.
Type: e <spatiebalk> U bent weer in de tekstverwerker.
Navigeren door het blok is noodzakelijk om het aan te kunnen passen.
Navigatie gebeurt met de ludr {jkl;} toetsen.
De betekenis van deze toetsen is respectievelijk:
Engels: left - up - down - right
Nederlands: links omhoog omlaag rechts
omhoog = 8 x links
omlaag = 8 x rechts
Indien de oranje pacman aanwijzer niet zichtbaar is,
is het handig om k{u} in te tikken tot hij zichtbaar is.
Type: <spatiebalk> U verlaat de tekstverwerker.
Type: e <spatiebalk> U bent weer in de tekstverwerker.
De toetsen m{-} en /{+} bladeren respectievelijk 2 blokken terug en vooruit.
De toets p{x}
Type: <spatiebalk> U verlaat de tekstverwerker.
calc2 0 org br
Type: e <spatiebalk> U bent weer in de tekstverwerker.
Wij gaan nu het eerste woord veranderen:
1. Pacman achter calc1
2. Type: x{n} (calc1 verdwijnt)
3. Type: r{t} calc2 <spatiebalk> <esc>
calc x-x' 5 . + dup 2* + ;
1. Pacman achter 3
2. Type: x{n} (De 3 verdwijnt)
3. Type: o{g} 5 <spatiebalk> <esc>
1. Pacman achter dup
2. Type: o{g} `2* <spatiebalk> <esc>
init left 175 b! indent
1. Pacman achter right
2. Type: x{n} (right verdwijnt)
3. Type: o{g} left <spatiebalk> <esc>
1. Pacman achter 1d5
2. Type: x{n} (1d5 verdwijnt)
3. Type: r{t} <F1> 175 <spatiebalk> <F1> <esc>
Verlaat de tekstverwerker:
Type: <spatiebalk>
Bewaar al het werk:
Type: save <spatiebalk>
Terug naar tekstverwerker.
Type: e
Open de tekstverwerker in blok 204.
accumulator 0 org br
Type: r{t} accumulator <spatiebalk> <esc>
Type: y{u} 0 <spatiebalk> org <spatiebalk> <esc>
Type: b{x} br <spatiebalk> <esc>
rsinit down 115 a! ;
Type: i{r} rsinit <spatiebalk> (De kleur is nu groen)
Type: down <spatiebalk> a! <spatiebalk> ; <spatiebalk> <esc>
Voeg nu nog als commentaar 115 toe voor a!
Type: j(l) j(l)
Type: r{t} <F1> 115 <spatiebalk> <F1> <esc>
rs! ! ;
Ga met de pacman achter de ; staan.
Type: i{r} rs! <spatiebalk> (De kleur is nu groen)
Type: ! <spatiebalk> ; <spatiebalk> <esc>
c1@ right 1d5 b! @b ;
Type: i{r} c1@ <spatiebalk> (De kleur is nu groen)
Type: right <spatiebalk> b! <spatiebalk> @b <spatiebalk> ; <spatiebalk> <esc>
Voeg nu nog als commentaar 1d5 toe voor de b!
Type: j(l) j(l) j(l)
Type: r{t} <F1> 1d5 <spatiebalk> <esc>
Deze regel is gedeeltelijk hetzelfde als de volgende regel.
We kopieëren alvast het bruikbare gedeelte:
Type: ;(r) ;(r) ;(r) (De pacman staat nu achter de ;)
Type: v{k} v{k} v{k}
De tekst-stack bevat nu: ; @b b!
c2@ left 175 b! @b ; br
Ga met de pacman achter de ; staan.
Type: i{r} c2@ <spatiebalk> (De kleur is nu groen)
Type: left <spatiebalk> <esc>
Type: r{t} <F1> 175 <spatiebalk> <F1> <esc>
Haal de drie woorden van de tekst-stack:
Type: <alt>{i} <alt>{i} <alt>{i} (Nu zijn de woorden b!, @b en ; in de tekst geplakt.)
Type: b{x} br <spatiebalk> <esc>
main c1@ + c2@ + rs! 0 cr
main is een recursief woord in een eeuwig durende loop.
De resultaten worden uit calc1 en calc2 gehaald, en doorgegeven aan results.
Type: i{r} main <spatiebalk> (De kleur is nu groen)
Type: c1@ <spatiebalk> + <spatiebalk> c2@ <spatiebalk> + <spatiebalk> rs! <spatiebalk> <esc>
Type: b{x} cr <spatiebalk> <esc>
main ; br
Type: o{g} main <spatiebalk> ; <spatiebalk> <esc>
Type: b{x} br <spatiebalk> <esc>
init rsinit 0 main ; br
init zet een 0 op de stack en start main.
Type: i{r} init <spatiebalk> (De kleur is nu groen)
Type: rsinit <spatiebalk> 0 <spatiebalk> main <spatiebalk> ; <esc>
Type: b{x} br <spatiebalk> <esc>
a9 org init ;
Deze regel zorgt ervoor dat bij het starten van het programma het forth woord init als eerste wordt uitgevoerd.
a9 is een hexadecimaal nummer.
<F1> zet de hex mode aan.
De a in a9 text mode veroorzaken.
Tik om dit te voorkomen eerst een 0, dus 0a9.
De voorloopnul verdwijnt automatisch.
Type: u{y} <F1> 0a9 <spatiebalk> <F1> org <esc>
De laatste groene woorden:
Type: g{o} init <spatiebalk> ; <spatiebalk> <esc>
Verlaat de tekstverwerker:
Type: <spatiebalk>
Bewaar al het werk:
Type: save <spatiebalk>
Terug naar tekstverwerker.
Type: e
results 0 org br
Type: r{t} results <spatiebalk> <esc>
Type: y{u} 0 <spatiebalk> org <spatiebalk> <esc>
Type: b{x} br <spatiebalk> <esc>
main @b main ; cr
main is een recursief woord in een eeuwig durende loop.
Er worden getallen uit de "accumulator" gehaald,
deze getallen kunnen wij straks zien in de simulator.
Type: i{r} main <spatiebalk> (De kleur is nu groen)
Type:@b <spatiebalk> main <spatiebalk> ; <spatiebalk> <esc>
Type: b{x} br <spatiebalk> <esc>
init down b! main ; 115 br
Type: i{r} init <spatiebalk> (De kleur is nu groen)
Type:b! <spatiebalk> main <spatiebalk> ; <spatiebalk> <esc>
Type: r{t} <F1> 115 <spatiebalk> <F1> <esc>
Type: b{x} br <spatiebalk> <esc>
a9 org init ;
Deze regel zorgt ervoor dat bij het starten van het programma het forth woord init als eerste wordt uitgevoerd.
a9 is een hexadecimaal nummer.
<F1> zet de hex mode aan.
De a in a9 text mode veroorzaken.
Tik om dit te voorkomen eerst een 0, dus 0a9.
De voorloopnul verdwijnt automatisch.
Type: u{y} <F1> 0a9 <spatiebalk> org <esc>
De laatste groene woorden:
Type: g{o} init <spatiebalk> ; <spatiebalk> <esc>
Verlaat de tekstverwerker:
Type: <spatiebalk>
Bewaar al het werk:
Type: save <spatiebalk>
Terug naar tekstverwerker.
Type: e
f(x) = 2(x+3) + 3(x+5)
decimal
calc1 calc2 result
x 2(x+3) 3(x+5) +
0 6 15 21
1 8 18 26
2 10 21 31
3 12 24 36
4 14 27 41
5 16 30 46
6 18 33 51
7 20 36 56
8 22 39 61
9 24 42 66
hex
calc1 calc2 result
x 2(x+3) 3(x+5) +
0 6 f 15
1 8 12 1a
2 a 15 1f
3 c 18 24
4 e 1b 29
5 10 1e 2e
6 12 21 33
7 14 24 38
8 16 27 3d
9 18 2a 42
Als alles goed gaat staan de resultaten na 493 stappen
op de stack in de "results" node [505]. Deze resultaten
zijn uiteraard zichtbaar in hexadecimaal.
Tussenresultaten zijn tijdelijk zichtbaar in de andere drie
gebruikte nodes.
De broncode, die wij geschreven hebben, dient nog aangeroepen te worden door de simulator.
Wij gebruiken blok 1302 hiervoor.
custom test code br
Zet de packman achter "code":
Type: x{b} br <spatiebalk> <esc>
calc1 404 node 200 load cr
Type: r{t} calc1 <spatiebalk> <esc>
Type: u{y} 404 <spatiebalk> node <spatiebalk> 200 <spatiebalk> load <spatiebalk> <esc>
Type: x{b} cr <spatiebalk> <esc>
accumulator 405 node 204 load cr
Type: r{t} accumulator <spatiebalk> <esc>
Type: u{y} 405 <spatiebalk> node <spatiebalk> 204 <spatiebalk> load <spatiebalk> <esc>
Type: x{b} cr <spatiebalk> <esc>
calc2 406 node 202 load cr
Type: r{t} calc2 <spatiebalk> <esc>
Type: u{y} 406 <spatiebalk> node <spatiebalk> 202 <spatiebalk> load <spatiebalk> <esc>
Type: x{b} cr <spatiebalk> <esc>
results 505 node 206 load
Type: r{t} results <spatiebalk> <esc>
Type: u{y} 505 <spatiebalk> node <spatiebalk> 206 <spatiebalk> load <spatiebalk> <esc>
Verlaat de tekstverwerker:
Type: <spatiebalk>
Bewaar al het werk:
Type: save <spatiebalk>
Terug naar tekstverwerker.
Type: e
Als het goed is blok 1302 nu actief in de tekstverwerker.
Blader naar blok 1300:
Type: m{-}
custom code 1302 load exit br
In regel 3 achter "custom code 1302 load" staat het woord "exit".
Dit woord is wit, en dus commentaar.
Wij maken er een geel woord van:
Ga met de pacman achter exit staan:
Type: a{c}
Dit woord werkt nu.
Het heeft de functie om het blok onmiddelijk te verlaten.
De rest van de broncode in dit blok wordt nu niet meer uitgevoerd.
Verlaat de tekstverwerker:
Type: <spatiebalk>
Bewaar al het werk:
Type: save <spatiebalk>
Terug naar tekstverwerker.
Type: e
Type: so of softsim
Er wordt een zeer fraai overzicht vertoond.
Om de simulator te verlaten:
Type: <spatiebalk>
De simulator heeft met de tekstverwerker gemeen,
dat er rechtsonder een overzicht komt waaruit af te lezen is,
wat de beschikbare functies zijn,
en welke vingers deze functies aanroepen.
Het ziet er als volgt uit:
++ ludr
fgs ludr
-- oudw
.
Deze toetsen corresponderen op een qwerty toetsenbord met:
qw uiop
sdf jkl;
zx m,./
<spatiebalk>
De 8x18 = 144 packman tekens rechtsboven staan voor de nodes.
De blauwe rechthoek bevat 32 nodes.
Deze 32 nodes zijn linksboven zichtbaar.
Met de bovenste ludr toetsen kan men de rechthoek verplaatsten.
Er wordt dan linksboven een andere groep van 32 nodes zichtbaar.
Bij de actieve nodes zijn de packman tekens rood.
Hier staat informatie over onder andere stacks en registers van 4x8 = 32 nodes.
De eerste drie cijfers linksboven in ieder blok zijn samen het nummer van de node.
De drie cijfers rechtsonder staan voor het b-register.
De vijf cijfers in de rij daarboven staan voor het a-register.
De bovenste rij groene cijfers staan voor het bovenste cijfer op de stack.
De rij groene cijfers daaronder staat voor het tweede cijfer op de stack.
Voor meer informatie staat er een link over de simulator onder meer...
Rechts onder het overzicht met de 144 nodes staat in rode cijfers de node die momenteel de focus heeft.
De middelste ludr toetsen verplaatsen de focus naar een andere node.
Voor het testen van ons programma dient node 505 de focus te krijgen.
Gebruik hiervoor de middelste ludr toetsen.
Maak de volgende nodes links in het overzicht met de 32 nodes zichtbaar:
505
404 405 406
Gebruik hiervoor de bovenste ludr toetsen.
Het uitvoeren van de volgende stap ("clock cycle") gebeurd in de simulator met de f{s} toets.
De grootte van de stap staat standaard op 1, en dat is prima voor deze simulatie.
U kunt de simulatie dus uitvoeren door een aantal maal de f{s} toets in te drukken.
Hieronder is in een aantal afbeeldingen aangegeven, hoe de simulatie er na een bepaald aantal stappen uitziet.
In deze simulatie is de kracht van de GA144 zichtbaar:
Het parallel uitvoeren van meerdere berekeningen.
Ook is het geweldig, dat dit alles binnen één kleine chip gebeurd.
Voor meer informatie...
Complete broncode in html. Ziet er goed uit!
Type: 176 <spatiebalk> load <spatiebalk>
Type: 0 <spatiebalk> 1440 <spatiebalk> .html <spatiebalk>
Hier wordt een bestand "cf.html" aangemaakt met de inhoud van blok 0 tot blok 1440.
Het bestand komt bij de andere bestanden te staan.
In mijn configuratie: C:\Forth\ga144\cf.html
De kleuren zijn iets anders, om beter te kunnen printen.
"Index file". Een overzicht van de inhoud van de blokken.
Bevat alle kopregels.
Type: 76 <spatiebalk> load <spatiebalk>
Type: 0 <spatiebalk> 1500 <spatiebalk> index <spatiebalk>
Hier wordt een bestand "OkadSim.log" aangemaakt met de inhoud van blok 0 tot blok 1500.
Het bestand komt bij de andere bestanden te staan.
In mijn configuratie: C:\Forth\ga144\OkadSim.log
Genereer png bestand.
Type: png <spatiebalk>
