Dag mensen,

Alle draden omtrent soortgelijke onderwerpen heb ik al doorgelezen, maar nergens heb ik het perfect passende antwoord kunnen vinden. Het gaat om het volgende:

Als ik een basic programma dat ik in binair formaat wil opslaan lukt dat gewoon, ook het terugladen met BLOAD gaat goed, maar als ik run typ of BLOAD"programma.bin",R dan verdwijnt het programma als sneeuw voor de zon. Zelfs met de pokes die in het programma.ldr bestand worden voorgeladen:

De listing van het diagnosegedeelte van mijn programma:

Bepalen van de BSAVE adressen:

1080 BEGINADR=PEEK(&HF676)+PEEK(&HF677)*256-1
1090 EINDADR=PEEK(&HF6C2)+PEEK(&HF6C3)*256-1
1100 CLS:PRINT"* * * * * Diagnostische modus * * * * *"
1110 PRINT
1120 PRINT"Bsave beginadres: "BEGINADR
1130 PRINT"Bsave eindadres:  "EINDADR

Verderop in het programma maakt deze het bestand programma.bin en programma.ldr aan:

1210 BB$=BST$+"programma.bin"
1220 BSAVE BB$,BEGINADR,EINDADR
1230 BL$=BST$+"programma.ldr"
1240 OPENBL$FOROUTPUTAS#1
1250 PRINT #1,"10 CLS"
1260 PRINT #1,"20 PRINT"+CHR$(34)+"Geheugensegmenten worden insgesteld enhet programma wordt geladen..."+CHR$(34)
1270 PRINT #1,"30 POKE&h676,"PEEK(&H676)
1280 PRINT #1,"40 POKE&h677,"PEEK(&H677)
1290 PRINT #1,"50 POKE&h6c2,"PEEK(&H6C2)
1300 PRINT #1,"60 POKE&h6c3,"PEEK(&H6C3)
1310 PRINT #1,"70 BLOAD"CHR$(34)BB$CHR$(34)",R"
1320 CLOSE

Waarbij het bestand programma.ldr er als volgt uit ziet zoals ook de bedoeling naar mijn idee is:

10 CLS
20 PRINT"Geheugensegmenten worden insgesteld en het programma wordt geladen..."
30 POKE&H676, 205 
40 POKE&H677, 221 
50 POKE&H6C2, 64 
60 POKE&H6C3, 24 
70 BLOAD"a:programma.bin",R

Ik vermoed dat ik nog meer pokes moet plaatsen in het programma.ldr bestand, maar weet niet welke. Wie kan mij dit vertellen?

Eerlijk gezegd heb ik normaal gesproken niet zoveel problemen met BASIC. Het hele punt is dat ik nooit het ASM startadres verander (dat is wat je volgens mij doet met die peek/poke &HF676/&HF677, om de top van BASIC te bepalen).

*kwartje valt*
Ik weet niet of je dit opzettelijk hebt gedaan, maar in je programmaregels 1260-1300 en in programma.ldr staat een verwijzing naar poke &H676, in plaats van &HF676. Kan aan mij liggen.
Verder wat algemene tips: "programma.ldr" wordt uiteraard "programm.ald" op disk, aangezien MSX (of FAT12 in het algemeen) een 8.3 conventie heeft voor bestandsnamen. Ook werkt BASIC alleen met de eerste twee letters van een identifier. Dus BEGINADR wordt BE en EINDADR wordt EI. Hier geen probleem, maar stel dat je nog een variabele BEGINWAARDE introduceert, dan heb je een probleem omdat je BEGINADR (eigenlijk BE) overschrijft.

Laatste opmerking, hierover ben ik niet zeker: in regel 1080 bereken je het startadres met PEEK(&HF676)+PEEK(&HF677)*256-1. Volgens mij moet dit zijn PEEK(&HF676)+PEEK(&HF677)*256, dus ZONDER de -1 op het eind. Anders zou je wel eens een variabele kunnen overschrijven als je dit zo zou doen. Nogmaals, ben ik niet zeker van. In ieder geval zou je eens kunnen kijken naar die adressen die ik noemde. Veel succes in ieder geval!

Hmmm, die F ben ik inderdaad vergeten Die ga ik gelijk aanpassen.

Ik heb de naam 'programma.ext' gebruikt omdat ik dit deel van de programma's die ik maak overal gebruik, het is een fictief woord, maar inderdaad wel scherp van je dat je ziet dat het een 9.3 naam is - had ik nog niet gezien.

Dat van die twee letters zal ik in mijn achterhoofd houden, daar ik er niet op heb gelet. En die laatste berekening had ik 1:1 uit een msx boek gehaald.

Voorlopig heb ik weer een hele berg om uit te zoeken zie ik. Ik laat het je weten wat er uit komt. Bedankt voor de info

Bdw had ik dat inlezen van het startadres (dat bij de MSX-2 altijd &H8000 is) gedaan om compatible te blijven met oudere machines, maar dan moeten er wel MSX-1 computers zijn met diskdrives (daar gebruik ik namelijk het programma voor).

Ik heb die F's ingevoegd en het adres gecontroleerd (256-1) maar dat is wel de juiste. Het adres telt natuurlijk vanaf 0. (0 is de eerste). Maar: nu gaat de computer ineens resetten als ik 'm run.

Moet ik nog wat bijpoken omdat het BIN bestand ná het loader bestand komt?

Quote:

(dat is wat je volgens mij doet met die peek/poke &HF676/&HF677, om de top van BASIC te bepalen).

Bijna. &HF676/7 bepaalt 't beginadres van BASIC

Verder moet je loader programma er uiteindelijk ongeveer zo uit komen te zien:

 5 ' -- loader.bas
10 IF PEEK(&HF676)=xx AND PEEK(&HF677)=yy THEN 30
20 POKE &HF676,xx: POKE &HF677,yy: RUN"program.ldr"
30 BLOAD"program.bin",r

Regel 10 controleert of de loader al op zn nieuwe plek staat. Zo niet, dan wordt in 20 t BASIC startadress verplaatst en de loader opnieuw (op de niewe plek!) ingeladen. Zonder t opnieuw inladen verzet je wel t begin van BASIC, maarje loader blijft op zn oude plekje staan. Die wordt dan waarschijnlijk door de BLOAD overschreven en dan werkt de boel niet meer.

Dat was het... Ik had het eerder gezien ;-)

Ik heb dat intussen gedaan (ik heb tevens de pokes van de eindadressen weggelaten) en dan volgt gelijk een totale reset van de computer - meteen hetzelfde gedaan met de eindadressen als wat ik met de beginadressen deed, en nu lijkt hij inderdaad verder te komen. Ik kwam ineens in de listing van het binaire programma terecht zonder dat deze is gewist. Is het gebruikelijk dat het programma bij regel 70 in het eerste programma eindigt en dan bij regel 80 in het tweede programma verder wil?

Nee, dat is [in mijn optiek] niet gebruikelijk. Dat zou betekenen dat je het eerste programma volledig in je geheugen hebt staan, terwijl het tweede programma regels 10-70 mist -- oftewel, je hebt programma 1 'over' programma 2 geladen. Zou kunnen, maar het einde van het huidige BASIC programma wordt dat door programma 1 aangegeven. Hij zou dus nooit bij programma 2 mogen komen in zo'n geval.

Ik heb nog wat verder geresearcht (is dit een Nederlands woord?). Zie bijvoorbeeld deze link. Daar probeert iemand een ROM header te maken vanuit BASIC. Geen idee of dat gelukt is, dat kon ik er niet uithalen. Met mijn basiscursus Spaans [hoewel Portugees] heb ik er wel zoiets uit kunnen halen

Uit het BASIC aldaar haal ik het volgende: de ROM header bestaat uit de byte sequence

A B 0 0 0 0 0 0 L H 0 0 0 0 0 0

Waarbij L en H resp. het Low part/High part startadres van BASIC zijn. Ze zetten het BASIC startadres op &H8011 (waar het normaal gesproken &H8001 is). Ook vullen ze &HF6C2-&HF6C7 met driemaal &H8013. Wat dat betekent zou ik niet weten. &HF6C2,&H13-&HF6C3,&H80 betekent in ieder geval dat het eindadres op &H8013 staat. Dit doen ze natuurlijk in direct mode, omdat je anders gelijk je programma weggooit. Met een NEW statement kun je dan beginnen. Nogmaals, ik heb geen idee waarom ze &HF6C4-&HF6C7 vullen met nog tweemaal &H8013. Ik hoop iig dat je hiermee wat kunt.

Een klein programmaatje dat je BASIC workspace monitort in HEX, ASC en decimaal:

10 cls: width80: x=0: y=0: s=peek(&HF676)+256*peek(&HF677): e=peek(&HF6C2)+256*peek(&HF6C3)
20 for i=s to e: a=peek(i): A$=hex$(a): B$=chr$(a): C$=right$(str$(a),3): if a<32 then B$="??"
30 locate x,y: print A$: locate x,y+7: print B$: locate x,y+14: print C$
40 x=x+3: if x>79 then x=0: y=y+1
50 if y>7 then I$=input$(1): y=0: cls
60 next:end

Geen idee of het zo ook direct werkt, ik heb hier geen MSX bij me. Succes iig!

Het programmaatje geeft heel wat gebrabbel op het scherm, het lijkt goed te werken. Ik heb geprobeerd er een foto van te maken, maar de verversingsfrequentie van de tv en het fototoestel liggen ongeveer gelijk 1:2 en daardoor komen er lelijke zwarte strepen op de foto Intussen ben ik gaan expirimenteren met die andere adressen door eerst het originele programma (basic broncode) te laden en met print peek(&hf6c2...f6c7) die waarden op het scherm te zetten en van daaruit het binaire bestand te laden. Het lijkt er op dat de adressen altijd het zelfde zijn als een programma in beeld komt:

&H676   1
&H677 128
&H6C2 114
&H6C3 178
&H6C4 114
&H6C5 178
&H6C6 114
&H6C7 178

Op basis hiervan (ook van die portugese site geven ze aan dat je vanuit je loader verder moet rekenen) heb ik onderstaande loader sm.ldr gemaakt:

10 CLS
20 LE=114
30 RE=178
40 'IF PEEK(&HF676)=1 AND PEEK(&HF677)=128 THEN 120
50 BA=PEEK(&HF6C2)+PEEK(&HF6C3)*256-1
60 TA=LE+(RE)*256-1
70 SA=BA-(PEEK(&HF676)+PEEK(&HF677)*256-1)
80 EA=TA+SA
90 LS=INT(SA/256)
100 RS=SA-(LS*256)
105 PRINT"Initial beg. adress:"PEEK(&HF676)+PEEK(&HF677)*256-1
110 PRINT"Beginning adress:   "BA
120 PRINT"Ending adress:      "EA
130 PRINT"Target adress p1:   "TA
140 PRINT"Left end target:    "LE
150 PRINT"Right end target:   "RE
160 PRINT"Shift program:      "SA
170 PRINT"Left shift:         "LS
180 PRINT"Right shift:        "RS
190 REM
200 POKE&HF6C2, LS+LE
210 POKE&HF6C3, LS+RE
220 POKE&HF6C4, LS+LE
230 POKE&HF6C5, LS+RE
240 POKE&HF6C6, LS+LE
250 POKE&HF6C7, LS+RE
260 POKE&HF676, LS+PEEK(676)
270 POKE&HF677, RS+PEEK(677)
280 BLOAD"a:sm.bin",R

Maar nu begint hij met laden en houdt er na het laden mee op (leeg scherm, geen acties meer). Ik denk dat mijn probleem nu is dat ik die pokes in 260 en 270 moet vervolgen met run"sm.ldr" maar dan worden die andere pokes weer overschreven

Een truuk om je BASIC code wat efficiënter te maken -- kan het niet laten : 90 LS=SA\256
Verder opnieuw het opvallende in je PEEKs in regels 260-270: PEEK(&hF676) en PEEK(&hF677) i.p.v. wat je er nu hebt staan. Verder zal ik eens kijken of ik openMSX geïnstalleerd krijg op mijn net nieuwe Linux installatie, dan zal ik er eens wat beter naar kijken. Naar mijn idee moet dit niet zo moeilijk zijn. Het lastige is de referenties naar de POKE-adressen, die moet je even weten te vinden. Een stapel oude magazines kan een hoop oplossen in zo'n geval.

Overigens heb ik het idee dat je de variabele SA gebruikt om een StartAdres aan te geven (lijkt me logisch). Welnu, je moet dit 16-bits getal opsplitsen in twee stukjes van 8 bits, zoals je doet in regels 90 en 100. Wat in #100 staat werkt op zich wel, echter eenvoudiger is RS = SA AND 255.

Ter verduiidelijking een diagrammetje:

[adres] | [waarde]
&hF677  |   &h80
&hF676	|   &h01
Samen: &h8001.

Makkelijke conversie van dit 16-bits getal naar 2x 8-bits:
&h8001  \  &h100 = &H80
&h8001 AND &hFF  = &H01

Dus: POKE &hF677, SA\256: POKE &hF676, SA AND 255

Hierbij geldt dat het wel makkelijk is als je een beetje vloeiend hexadecimaal/binair kunt rekenen en je raad weet met bits & bytes.

[edit]
Vergelijk decimaal rekenen. Als je van 2345 de twee meest significante cijfers wilt weten, dan doe je 2345\100. Da's 23,45 (maar de \ kapt het af naar beneden), dus 23. Wil je de twee minst significante cijfers weten, dan doe je 2345 MOD 100 (MOD = modulo). Dat levert 45 op. Nu is er een equivalentierelatie tussen (x) MOD 2^(n) <==> (x) AND 2^(n) - 1, waarbij de laatste variant in BASIC sneller werkt. In ASM overigens ook, maar dat terzjide.
[/edit]

[edit2]
Overbodig: (n) en (x) zijn gehele, positieve getallen.
[/edit2]

OK, ik heb een stukje research gedaan... wanneer niet he?

Het blijkt volgens m'n boek dat F676-F677 [TXTTAB] het BASIC startadres bevat. Zover waren we al. Nu voor het eind van BASIC. F6C2-F6C3 [VARTAB] bevat het beginadres van het opslaggebied voor variabelen. Dit adres varieert naarmate het programma in lengte varieert (dus, variabelen komen sequentieel ná het programma, maar dat was ook al bekend). F6C4-F6C5 [ARYTAB] is hetzelfde, maar dan voor arrays. Deze verschuift uiteraard ook als je een nieuwe variabele introduceert. Arrayvariabelen komen na gewone variabelen. F6C6-F6C7 [STREND] bevat vervolgens het eindadres van het BASIC programma, inclusief de ruimte voor alle (array)variabelen. Wil je dus op een gegeven moment een 'snapshot' van je programma maken, dan bewaar je dus vanaf het adres waarnaar verwezen wordt in TXTTAB, tot (NIET tot en met) STREND. Moet je nog wel je strings apart opslaan, aangezien daarvan slechts een verwijzing wordt ogpeslagen in VARTAB, maar dat spreekt voor zich.

Nu over de werking van je programma.
Als ik het goed begrijp wil je een BASIC programma binair laden (waarom is me eigenlijk een raadsel, maar toe maar). Dit is vrij eenvoudig. Maar het programma uitvoeren is totaal andere koek! Goed, de procedure.

1. Schrijf je programma dat je binair wilt bewaren
2. Schrijf de adressen TXTTAB, VARTAB, ARYTAB en STREND op. Voor nu ga ik even uit dat die gevuld zijn met &h8001, &h8023, &h8033 en &h8043.
3. Bewaar het programma van TXTTAB (dus niet TXTTAB-1 ofzo) TOT STREND

4. Schrijf je loader. Die wil je laten beginnen op het adres wat in STREND gespecificeerd staat, en wel als volgt:

1 ' loader.ldr
10 if peek(&hF676) <> &h43 or peek(&hF677) <> &H80 then poke&hF676,&h43: poke&hF677,&h80: run "loader.ldr"
20 bload "binair.bin" ' Zie commentaar 1
25 ' Zie commentaar 2
30 poke&hF6C2,&h23: poke&hF6C3,&h80 'VARTAB
40 poke&hF6C4,&h33: poke&hF6C5,&h80 'ARYTAB
50 poke&hF6C6,&h43: poke&hF6C7,&h80 'STREND
60 poke&hF676,&H01: poke&hF677,&h80 'TXTTAB
70 run ' Zie commentaar 3

Commentaar 1: Nu staat ons binaire BASIC programma dus VOOR de loader in het geheugen. Hier wordt nog niets mee gedaan, het staat er alleen. Dit komt omdat je het startadres van BASIC en de bijbehorende variabeltabelpointers en eindadressen verandert hebt om de loader z'n werk te laten doen.
Commentaar 2: De belangrijke adressen TXTTAB, VARTAB, ARYTAB en STREND goedzetten voor het binaire BASIC programma.
Commentaar 3: Ik heb geen idee of dit werkt.

5. Nu is het zo dat loader.ldr de systeemvariabelen zo zet, dat ze werken voor het binaire programma. Ik kan me voorstellen dat BASIC flink op z'n bek gaat als je STREND verandert in een adres ONDER de pointer naar de huidige instructie. Dat is wezenlijk wat de loader doet in regel 50. Ik zou zeggen, probeer dit uit, en als het niet werkt, verander VARTAB, ARYTAB en STREND als eerste instructie in het binaire programma.

Ik hoop voor je dat dit een werkende oplossing is.

WICKED!

Mijn vorige oplossing werkte [helaas] niet. Ik vergat dat een BASIC programma moet starten met een 1-byte header met de waarde '0' (FE is een binaire header). Als je vóór 'run"loader.ldr"' even een poke STREND-1,0 invoert, dan werkt-ie. Tataaa... Missie geslaagd.

Ten overvloede, ik ben lekker bezig met m'n postcount in deze thread, mijn programma's en manieren enzo:

10 PRINT "Mijn eerste binaire programma!"
20 END

BSAVE "binair.bin",&H8001,&H8030

LOAD"loader.ldr"
# adressen van TXTTAB, VARTAB, ARYTAB en STREND aanpassen

RUN
Mijn eerste binaire programma!
files

Aldus mijn proof-of-concept.

Well done, master Tailz... The MSX Force is strong in you

(Fok, ik wil een <:yoda:> slimey!)