logo

   
  > Tutorials > ASM Tutorial    
 

[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]

 
- - Linkkabel.nl is een onderdeel van ROFAR - © 2003-2013 - Contact