[Deze
tutorial is nog lang niet af, kom regelmatig terug om te zien als
er al weer wat bij is geschreven]
Wat gaan we doen?
Leren programmeren in ASM. Deze tutorial is gemaakt door Wim (www.fast4ever.tk).
Mocht je nog vragen hebben dan kun je die altijd aan hem vragen:
fast4ever123@ hotmail.com.
Hoe gaan we het aanpakken? (laatst
geupdate: 13 Januari 2006)
Deze tutorial is nog under construction,
er kunnen dingen nog onvolledig zijn, er kunnen nog spellingsfouten
inzitten enzovoort. Tja,
ASM, was da voor e beest???? Gene schrik hebben! ik zal je dit beestje wel leren temmen.
Eerst een regel van het vak, PIK NOOIT AUTHEURSRECHTEN IN, geef de eer aan de echte maker of vermeld zijn naam als je (voor een deel) zijn progje letterlijk kopieerd.
Om te beginnen zullen we eens wat meer uitleg geven over waarom je in hemelsnaam in ASM zou gaan proggen:
- Het is een stuk sneller dan je BASIC programma'tjes.
- Je kan er alle functies van je toestel mee benutten.
- Je kan de linkpoort 'bedienen' wat met BASIC niet mogelijk is.
- Je kan het ram geheugen wissen als je de foute code intikt ( fijn toch eh? :p )
Natuurlijk zijn er ook 'nadelen':
- ASM is niet zo een simpele taal als BASIC (daarom ook de naam BASIC eh).
- Er bestaan niet echt 'handleidingen' voor.
- Je kan de programma's enkel op pc maken en daarna doorzenden (of overtypen voor de mensen die geen linkkabel hebben) naar je TI .
Nog even vermelden dat TI83+ ASM niet hetzelfde is als TI83ASM!
Je kan ze wel snel en simpel door kleine veranderingen aan te brengen gebruiken op je TI83
Wij gaan het dus hebben over TI83PlusAsm !!!
"Als je nu eens stopt met te zeveren over de voor en nadelen en ons het echte werk leert???"
Dat gaan we dan nu ook doen!
(Mocht het ernstig mis lopen en je TI83+ start niet meer op, klik dan hier om naar de helppagina te gaan.)
We beginnen met de STRUCTUUR van een asm programma.
Dit zal mischien gemakkelijker gaan aan de hand van een heel simpel voorbeeld:
#define B_CALL(xxx) rst 28h \ .dw xxx ;de hoofding
;
;
;Hier definieer je welke functies je gaat gebruiken
;
;
.org 9D95h ;op dit 'adres' start je ALTIJD je programma
;
;de body
;
.end ;hier stopt het
END
Even een paar puntjes duidelijk maken eh:
- .org => hier maak je duidelijk dat je programma begint (ALTIJD op adres '9D95h'!!!).
- de body => hier schrijf je dus wat onzin neer (sommigen noemen het een programma :p).
- .end => raad eens...hier maak je je TI duideljik dat het programma gedaan is.
- Als je tijdens je programma commentaar wil plaatsen om te weten wat je op die plaats ook alweer deed, kun je een ';' gebruiken, alles wat hierna staat zal niet door de compiler worden gelezen als code!.
Nu eens een voorbeeld geven van een gigantisch leuk programma (het wist je scherm!) (dan snappen jullie mischien al direct dat je net iets meer code nodig hebt dan 'clrhome' in BASIC)
#define B_CALL(xxx) rst 28h \ .dw xxx ;hier definieren we 'b_call()' waarmee je de instructies naar de processor kan sturen!
_clrlcdfull =4540h ;dit zijn de 'calls'(= commando's ) die we gaan gebruiken, die definieer je hier
_homeup =4558h
.org 9D95h ;even aan je TI laten weten dat hij op 9D95h moet beginnen om je progje te draaien
B_CALL(_homeup) ;het basisscherm bovenhalen
B_CALL(_clrlcdfull) ;het scherm wissen
ret ;even zeggen dat je hier terugkeert naar je normale TI operating system
.end ;einde van het programma
(in de ti83plus.inc >>zit bij de download! vind je alle calls met hun code bij! Je kan ze ook eeenn andere naam geven, zolang je dat maar definieërt! De naam is namelijk alleen maar een verwijzing naar de achterliggende code.) In tegenstelling tot vele andere 'talen' is dit één van de simpelste progjes die je kan maken!
Je kent het standaard "hello world" progje wel eh, dat zullen we zodadelijk ook eens maken.
Eerst wil ik even zeggen dat je de code in een txt bestand moet intypen (ik raad kladblok aan) en dan opslaan zoals: "naamvanjefile.z80" .
Nu zal ik jullie leren hoe je een ASM programma moet 'compilen', hiervoor heb ik al alle benodigde progjes bijeen gesprokkelt (spaart jullie echt heel wat zoekwerk uit!) en ook ben ik zelf nog met een progje bezig om het (nog) gemakkelijker te maken.
Downoad de ASSEMBLER.EXE-file van de TI83 plus download pagina.
Open de winzip self extracting file en volg de instructies.
Nu heb je de assembler klaar staan om te kunnen gebruiken.
Lees het bijgevoegde bestand (lees mij even!.txt) voor meer uitleg.
Plaats je '.z80' file in de map van de compiler!
Verander in "go.bat" z80file in de naam van je .Z80 bestand, sla op en sluit af.
Klik op go.bat => als je code geen fouten bevat krijg je een .hex file,anders een .lst file.
Indien je dus geen .hex file krijgt (PANIEK) moet je rustig blijven en het .lst bestand openen, hierin staan je fouten dan aangegeven => verbeteren en opnieuw compilen tot je een .hex file krijgt! Ik geef nog enkele tips hierover: zet altijd een enter tussen de labels, gebruik een tab om de code te typen,.org 9D95H en .end zet je altijd vlak tegen de kantlijn, en de rest moet je zelf achterhalen, normaal is dat logisch!
We hebben nu allemaal onze .hex file, die ziet er voor het bovenstaande progje zo uit als je het opent:
EF5845EF4045
C9
Start nu TI-Graph Link op en type in een leeg programma venster AsmPrgm (via de catalog functie!)
Druk enter om naar de volgende lijn te gaan en plak de code van de .hex file erbij.
sla dit progje nu op.
Nu komt 'THE BIG MOMENT' , we gaan het progje starten (best gebruik je hiervoor de flash debugger of een andere simulator als je zelf progjes gaat maken die je moet testen, anders kan je rekentoestel wel eens raar beginnen doen :p).
Op je TI83+ scherm tik je nu (ook via de catalog functie) "Asm(" in, druk dan op pgrm en kies je programma, druk op enter en het bolt!
er bestaan ook progjes die zelf gaan kijken of je een ASM of een basic progje wil draaien, dan hoef je niet altijd Asm( te selecteren uit de catalog lijst! (progje te vinden op de TI83+ downloadpagina)
als je alles goed gedaan hebt, dan wist het progje je scherm en keert dan terug naar je OS (de bekende "done" zie je nu).
Voila, dat was het dan wat compilen en omzetten naar je TI betreft!
Nu gaan we er van uit dat je een progje kan compilen en naar je TI zenden.
We zullen nu alleen nog aandacht schenken aan programmeercode zelf!
Nu gaan we het daarnet beloofde Hello world progje maken, lees de code maar eens!
#define B_CALL(xxxx) rst 28h \ .dw xxxx
;hieronder definiëren we de calls die we gaan gebruiken
_clrlcdfull =4540h
_homeup =4558h
_puts =450Ah
curRow = 844Bh
curCol = 844Ch
.org 9D95h
B_CALL(_clrlcdfull) ;wis het scherm
B_CALL(_homeup) ;breng het basisscherm naar boven
ld a,0 ;Laad 0 in het "a" register
ld (curCol),a ;Laad 0 in de y coördinaat
ld (curRow),a ;Laad 0 in de x coördinaat
ld hl,Hellotxt ;laad de text van het label in register "hl"
B_CALL(_puts) ;zet deze text op het scherm
ret ;terug naar OS
Hellotxt: ;hierin staat de text die je wil laten zien
.db "Hello world!",0
.end
Ik hoop dat iedereen ziet dat we onze kennis van ons eerste progje nu weer terug gebruiken om het scherm te wissen!
Nu eens direct een paar functies ineens, ik leg ze straks ook uit!
#define B_CALL(xxxx) rst 28h \ .dw xxxx
;hieronder definiëren we de calls die we gaan gebruiken
_clrlcdfull =4540h
_homeup =4558h
_puts =450Ah
_getkey = 4972h
;cursor kolom en rij
curRow = 844Bh
curCol = 844Ch
;dit zijn codes voor de TI toetsen
#DEFINE kEnter 05h
#DEFINE kClear 09h
;dit is voor de text te inverteren
textinverse =3
textflags =5
;voor de run-indicator aan en uit te zetten
_RunIndicOff =4570h
_RunIndicOn =456Dh
.org 9D95h
B_CALL(_RunIndicOff) ;de run-indicator uitzetten
B_CALL(_clrlcdfull) ;wis het scherm
B_CALL(_homeup) ;breng het basisscherm naar boven
ld a,0 ;Laad 0 in het "a" register
ld (curRow),a ;Laad 0 in de y coördinaat
ld (curCol),a ;Laad 0 in de x coördinaat
ld hl,Handleiding ;laad de text va het label in register "hl"
B_CALL(_puts) ;zet deze text op het scherm
Text1:
res 3,(iy+5) ;tekstinverse afzetten
B_CALL(_homeup)
ld a,0
ld (curRow),a
ld (curCol),a
ld hl,Hellotxt
B_CALL(_puts)
Zoektoets1:
B_CALL(_getkey) ;kijk of er een toets ingedrukt werd
cp kEnter
jp z,Text2 ;als de toets enter is: ga naar Text2
cp kClear
jp z,Quit ;als de toets clear is: ga naar Quit
jp Zoektoets1 ;deze handel herhalen
Text2:
set 3,(iy+5) ;tekstinverse aanzetten
B_CALL(_homeup)
ld a,0
ld (curRow),a
ld (curCol),a
ld hl,Hellotxt
B_CALL(_puts)
Zoektoets2:
B_CALL(_getkey)
cp kEnter
jp z,Text1
cp kClear
jp z,Quit
jp Zoektoets2
Quit:
B_CALL(_RunIndicOn) ;de run-indicator terug aanzetten
B_CALL(_clrlcdfull)
res 3,(iy+5) ;tekstinverse afzetten
ret ;terug naar OS
Hellotxt:
.db "Hello world!",0
Handleiding:
.db " "
.db "enter=inverteer "
.db "clear=einde ",0
.end
Compile en test deze code op je TI, dan snap je direct wat het doet!
Deze code is ook meteen een stukje langer natuurlijk, maar wel leerrijk!
De functies spreken voor zich (als je een beetje engels kent :p)
We zetten de tekstinverse flag aan en uit met 'set' en 'res', waarmee je eender welke bit kan aanzetten of uitzetten.
Om dat lopende streepje rechtsboven weg te krijgen gebruikten we runindicoff (-on).
Met 'jp' kunnen we naar een ander label springen, 'jp z,label' gebruik je meestal zo:
ld a,5
cp a,5
jp z,LabelaIsVijf
Hier laden we een waarde in a, we vergelijken ze met 'cp' met 5, en als dit verschil nul is (daarom die 'z', als je wil dat hij iets doet als er WEL verschil is word die 'z' 'nz') gaan we naar het label 'LabelaIsVijf'.
Ofwel zo:
jp LabelaIsVijf
Hier springen we gewon naar een label zonder voorwaarde!
Voila, nu kunnen we in principe zelf onze menu's al maken, waarbij je de keuze inverteert, maar, om jullie een beetje te helpen zal ik daarvan ook maar even een voorbeeldje geven zeker ;-).
Ik leg hierbij niets meet uit omdat je alle gebruikte instructies al zou moeten kennen na het vorige voorbeeld!
#define B_CALL(xxxx) rst 28h \ .dw xxxx
_clrlcdfull =4540h
_homeup =4558h
_puts =450Ah
_getkey =4972h
_newline =452Eh
curRow = 844Bh
curCol = 844Ch
kup =003h
kdown =004h
kenter =005h
k1 =08Fh
k2 =090h
k3 =091h
textinverse =3
textflags =5
_RunIndicOff =4570h
_RunIndicOn =456Dh
.org 9D95h
B_CALL(_RunIndicOff)
Menu1:
B_CALL(_clrlcdfull)
B_CALL(_homeup)
set 3,(iy+5)
ld hl,Titel
B_CALL(_puts)
B_CALL(_newline)
set 3,(iy+5)
ld hl,Keuze1
B_CALL(_puts)
res 3,(iy+5)
ld hl,Keuze2
B_CALL(_puts)
res 3,(iy+5)
ld hl,Keuze3
B_CALL(_puts)
Toets1:
B_CALL(_getkey)
cp kenter
jp z,Tekstkeuze1
cp kup
jp z,Menu3
cp kdown
jp z,Menu2
cp k1
jp z,Tekstkeuze1
cp k2
jp z,Tekstkeuze2
cp k3
jp z,Tekstkeuze3
jp Toets1
Menu2:
B_CALL(_clrlcdfull)
B_CALL(_homeup)
set 3,(iy+5)
ld hl,Titel
B_CALL(_puts)
B_CALL(_newline)
res 3,(iy+5)
ld hl,Keuze1
B_CALL(_puts)
set 3,(iy+5)
ld hl,Keuze2
B_CALL(_puts)
res 3,(iy+5)
ld hl,Keuze3
B_CALL(_puts)
Toets2:
B_CALL(_getkey)
cp kenter
jp z,Tekstkeuze2
cp kup
jp z,Menu1
cp kdown
jp z,Menu3
cp k1
jp z,Tekstkeuze1
cp k2
jp z,Tekstkeuze2
cp k3
jp z,Tekstkeuze3
jp Toets2
Menu3:
B_CALL(_clrlcdfull)
B_CALL(_homeup)
set 3,(iy+5)
ld hl,Titel
B_CALL(_puts)
B_CALL(_newline)
res 3,(iy+5)
ld hl,Keuze1
B_CALL(_puts)
res 3,(iy+5)
ld hl,Keuze2
B_CALL(_puts)
set 3,(iy+5)
ld hl,Keuze3
B_CALL(_puts)
res 3,(iy+5)
Toets3:
B_CALL(_getkey)
cp kenter
jp z,Tekstkeuze3
cp kup
jp z,Menu2
cp kdown
jp z,Menu1
cp k1
jp z,Tekstkeuze1
cp k2
jp z,Tekstkeuze2
cp k3
jp z,Tekstkeuze3
jp Toets3
Quit:
B_CALL(_RunIndicOn)
B_CALL(_clrlcdfull)
res 3,(iy+5)
ret
Titel:
.db " Mijn menu! ",0
Tekstkeuze1:
B_CALL(_newline)
res 3,(iy+5)
ld hl,Tekst1
jp Puts
Tekstkeuze2:
B_CALL(_newline)
res 3,(iy+5)
ld hl,Tekst2
jp Puts
Tekstkeuze3:
B_CALL(_newline)
res 3,(iy+5)
ld hl,Tekst3
jp Puts
Puts:
B_CALL(_puts)
B_CALL(_getkey)
jp Quit
Tekst1:
.db "Je koos keuze 1!",0
Tekst2:
.db "Je koos keuze 2!",0
Tekst3:
.db "Je koos keuze 3!",0
Keuze1:
.db "1.keuze 1 ",0
Keuze2:
.db "2.keuze 2 ",0
Keuze3:
.db "3.keuze 3 ",0
.end
Hier heb ik ook de functie NEWLINE gebruikt om voor de witregel te zorgen tussen de titel en de keuzes!
Even de 'handleiding' van dit proggie:
Druk op een cijfer om deze keuze te kiezen of kies met 'boven' en 'onder' welk nummer je wil en druk enter,onderaan komt nu je keuze te staan en als je nu eender welke toets drukt sluit het proggie af!
"Kon je ook geen kleine letters op je TI tikken?" zeker, dat is simpel, we maken hiervoor ook een progje natuurlijk!
Deze functie zit in het besturingssysteem, je moet ze alleen even aanzetten :p !
(als ze geactiveerd zijn => 2x alfa drukken om de kleine letters te typen)
De code hiervoor is op zich niet lang, maar het oog wil ook wat, dus maken we een mooi menu erbij dat in verhouding ontzettend lang is t.o.v. de eigenlijke code!
Veel plezier hiermee:
#define B_CALL(xxxx) rst 28h \ .dw xxxx
_clrlcdfull =4540h
_homeup =4558h
_puts =450Ah
_getkey =4972h
_newline =452Eh
_ClrTxtShd =454Ch ;Hiermee wis je textshadow (word nog uitgelegd)
curRow = 844Bh
curCol = 844Ch
kup =003h ;de hex waarden van de toetsen
kdown =004h
kenter =005h
k1 =08Fh
k2 =090h
k3 =091h
textinverse =3 ;om niet zoveel te hoeven te typen
textflags =5 ;vul ik direct de cijfertjes in eh
donePrgm =5 ;maar hier zie je dan wat ze betekenen!
doneflags =0
_RunIndicOff =4570h ;om de runindicator af te zetten
.org 9D95h
B_CALL(_RunIndicOff)
Menu1:
B_CALL(_clrlcdfull)
B_CALL(_homeup)
set 3,(iy+5)
ld hl,Titel
B_CALL(_puts)
B_CALL(_newline)
set 3,(iy+5)
ld hl,TekstKeuze1
B_CALL(_puts)
res 3,(iy+5)
ld hl,TekstKeuze2
B_CALL(_puts)
res 3,(iy+5)
ld hl,TekstKeuze3
B_CALL(_puts)
Toets1:
B_CALL(_getkey)
cp kenter
jp z,Keuze1
cp kup
jp z,Menu3
cp kdown
jp z,Menu2
cp k1
jp z,Keuze1
cp k2
jp z,Keuze2
cp k3
jp z,Quit
jp Toets1
Menu2:
B_CALL(_clrlcdfull)
B_CALL(_homeup)
set 3,(iy+5)
ld hl,Titel
B_CALL(_puts)
B_CALL(_newline)
res 3,(iy+5)
ld hl,TekstKeuze1
B_CALL(_puts)
set 3,(iy+5)
ld hl,TekstKeuze2
B_CALL(_puts)
res 3,(iy+5)
ld hl,TekstKeuze3
B_CALL(_puts)
Toets2:
B_CALL(_getkey)
cp kenter
jp z,Keuze2
cp kup
jp z,Menu1
cp kdown
jp z,Menu3
cp k1
jp z,Keuze1
cp k2
jp z,Keuze2
cp k3
jp z,Quit
jp Toets2
Menu3:
B_CALL(_clrlcdfull)
B_CALL(_homeup)
set 3,(iy+5)
ld hl,Titel
B_CALL(_puts)
B_CALL(_newline)
res 3,(iy+5)
ld hl,TekstKeuze1
B_CALL(_puts)
res 3,(iy+5)
ld hl,TekstKeuze2
B_CALL(_puts)
set 3,(iy+5)
ld hl,TekstKeuze3
B_CALL(_puts)
res 3,(iy+5)
Toets3:
B_CALL(_getkey)
cp kenter
jp z,Quit
cp kup
jp z,Menu2
cp kdown
jp z,Menu1
cp k1
jp z,Keuze1
cp k2
jp z,Keuze2
cp k3
jp z,Quit
jp Toets3
Quit:
res 5, (iy+0)
B_CALL(_clrlcdfull)
B_CALL(_ClrTxtShd)
res 3,(iy+5)
ld a,0
ld (CURCOL),a
ld (CURROW),a
ret
Titel:
.db " Kleine letters ",0
keuze1:
set 3, (iy+24h)
B_CALL(_clrlcdfull)
res 3,(iy+5)
ld a,0
ld (CURCOL),a
ld (CURROW),a
ld hl,TekstActiveer
B_CALL(_puts)
B_CALL(_getkey)
jp Quit
keuze2:
res 3, (iy+24h)
B_CALL(_clrlcdfull)
res 3,(iy+5)
ld a,0
ld (curRow),a
ld (curCol),a
ld hl,TekstDeactiveer
B_CALL(_puts)
B_CALL(_getkey)
jp Quit
TekstActiveer:
.db "Kleine letters "
.db "geactiveerd ",0
TekstDeactiveer:
.db "Kleine letters "
.db "gedeactiveerd ",0
TekstKeuze1:
.db "1.Aan zetten ",0
TekstKeuze2:
.db "2.Af zetten ",0
TekstKeuze3:
.db "3.Sluiten ",0
.end
Dit is ons eerste 'nuttige' progje dat we gemaakt hebben, merk op dat we weeral verder gebouwd hebben op de basis van het vorige, dus als je dit nu nog steeds niet snapt dan moet je eens terug vanaf het begin beginnen lezen, want veel ga ik niet uitleggen!
Om de 'kleine letters' aan te zetten hebben we een bepaalde bit om moeten zetten : '3, (iy+24h)' (in de include file staan ze allemaal! Dit leg ik later wel uit.)en dat deden we weeral met 'set ...' en 'res ...'.
De korste code om de letters te activeren is :
.org 9D93h
set 3, (iy+24h)
ret
.end
Als we deze compilen ziet de hex-code (deze kan je zo overtikken op je TI, wel niet 'Asmprgm' vergeten hé) er zo uit:
FDCB24DEC9 (om te activeren)
FDCB249EC9 (om te deactiveren)
Nu zien we dat we maar één teken moeten veranderen om ze aan of uit te zetten!
Om even terug te komen op dar set-res gedoe, je zal al wel gemerkt hebben dat 'Done' niet komt als het programma stopt, de flags hiervoor vind je in de code. Deze moet je net gelijk de tekstinverse-flags gewoon RESetten! Ook hebben we '_ClrTxtShd' (Clear Text Shadow) gebruikt om de in de buffer achtergebleven tekst te wissen. Laat deze call maar eens weg en test de code dan,je ziet dat op de plaats waar een a gestaan heeft (als je cursor op die plaats staat) een a zal zien! Dit willen we niet eh! Daarom best aan het einde van elk programma toevoegen, net zoals je de cursor even terug op plaats 0,0 zet, zo hoef je niet eerst op clr te duwen na je programma om 'fatsoenlijk' verder te kunnen werken!
Ook wis je altijd even je scherm en zet je de tekstinverse af om het fijner te maken voor de gebruiker van je progje!
Een ander paar mouwen nu, je weet dat je TI na x-aantal seconden uitvalt als je er niets op doet. Omdat we ASM kennen is dit (natuurlijk) te manipuleren. We kunnen in het geheugenplaatsje waar de tijd tot uitvallen in staat 1 zetten, dan zal je TI na +/- 1sec uitvallen. LET OP: "We zouden ook 0 kunnen nemen voor een directe uitval, niet?" > NEE dit gaat niet, als je het niet gelooft dan probeer je het zelf maar eens! Hieronder staat dan de zeer simpele code van een progje voor de kortste tijd tot uitval die mogelijk is:
apdTimer =8449h
.org 9D95h
ld a,1
ld (apdTimer),a
ret
.end
Merk op dat we hier ook alweer geen 'B_call(xxxx)' gebruiken, net zoals bij de korte versie om de kleine letters te activeren!
"Als We dat kunnen , kunnen we dan niet veel meer 'saboteren'?" Ja, dit gaat zeker ;-)
We kunnen ook het contrast aanpassen op net dezelfde manier dan het vorige progje (natuurlijk wel een ander adres waar we iets in zetten éh!). Dit voorbeeld is in de maak, maar nu even iets leukers, de linkpoort... Dit klein voorbeeldje heb ik klaar, maar moet nog getest worden, dus nog even geduld!
De andere voorbeelden moet ik nog even schrijven, dus nog even geduld!
Als er nog vragen zijn mail me dan op host@fast4ever.tk !
_____..--++UNDER CONSTRUCTION++--..____________-_-'_--- © fast4ever --'-'__
[Deze tutorial is
nog lang niet af, kom regelmatig terug om te zien als er al weer
wat bij is geschreven]
|
