Tips, Tricks, PEEKs und POKEs zum C 128
Eine wahre Fundgrube für jeden C 128-Anwender. Hier finden Sie interessante Listings und Informationen, die Ihnen helfen werden, Ihren C 128 besser auszunutzen und kennenzulernen.
Eine wahre Fundgrube für jeden C 128-Anwender und -Programmierer haben wir für Sie zusammengestellt. Tips & Tricks-Listings, PEEKs, POKEs und jede Menge Hintergrundinformationen, um Ihnen das Arbeiten mit Ihrem Computersystem zu erleichtern.
Datagenerator C 128
Da der Monitor des C 128 im Vergleich mit dem SMON keine Möglichkeit besitzt, Maschinenprogramme in DATA-Zeilen zu verwandeln, mußte der gequälte C 128-Besitzer immer zwischen C 64- und C 128-Modus wechseln, nur um eine kleine Routine in Basic-Zeilen abgelegt zu bekommen.
Mit diesem Datagenerator (Listing 1, bitte mit dem neuen Checksummer 128 eingeben) können bequem alle Maschinensprache-Routinen in Basic-Zeilen übernommen werden.
Das Programm verlangt von Ihnen die Eingabe der Start- und Endadresse des zu wandelnden Bereiches. Diese kann sowohl dezimal oder auch, mit vorangestelltem »$«-Zeichen, hexadezimal erfolgen. Zu beachten ist nur, daß die Hex-Zahl vierstellig sein muß.
Haben Sie die beiden Adressen eingegeben, müssen Sie dem Computer noch die Startzeilennummer der DATA-Zeilen und deren Schrittweite mitteilen. Danach wird der Bildschirm gelöscht und die Einleseschleife übernommen. Wiederum löscht sich der Bildschirm und aus dem angegebenen Bereich werden die Werte in DATA-Zeilen abgelegt, und zwar in hexadezimaler Form. Dadurch sind die erzeugten Zeilen nicht nur schön untereinander formatiert, sondern ersparen den späteren Benutzern auch noch ein Drittel Tipparbeit. Letztendlich löscht sich der Datagenerator per DELETE -40 noch selbst, so daß nun beim LISTen ein speicherfertiges Programm auf dem Bildschirm steht.
Das Programm »Tasten-Piep« (Listing 2) zeigt, wie ein durch »Datagen 128« bearbeitetes Programm aussieht. Die ersten vier Zeilen zeigen die vom Programm erzeugte Einleseschleife, danach folgen die formatierten DATA-Zeilen. Übrigens können Sie dieses kleine Programm ruhig abtippen, denn einen Piepston auf Tastendruck kann man immer gebrauchen, vor allem dann, wenn man mehr oder weniger blind DATA-Zeilen eintippt.
Wichtiger Hinweis:
Sollten Sie das Programm RENUMBERn, müssen Sie auch in den Zeilen 22, 36 und 40 die Werte entsprechend ändern, da der RENUMBER-Befehl GOTO und DELETE innerhalb einer PRINT-Zeile nicht ändert.
(Torsten Fahle/dm)8 scnclr
10 input"startadr.";sa$:if mid$(sa$,1,1)="$"then sa=dec(right$(sa$,4)):else sa=val(sa$)
12 input"endadr.";ea$:if mid$(ea$,1,1)="$"then ea=dec(right$(ea$,4)):else ea=val(ea$)
14 input"1.zeilennr.";zn:input"schrittweite";sw:ifzn<38 then 14
16 printchr$(147);zn;"fori="sa"to"ea"
18 zn=zn+sw:printzn;"read a$:poke i,dec(a$)":zn=zn+sw:printzn;"next i"
20 zn=zn+sw:printzn;":"
22 print"goto 26"
24 poke 842,19:for i=1to5:poke 842+i,13:next:poke208,6:end
26 zn=zn+sw:scnclr:printzn;"data";
28 for i=satosa+14
30 : printright$(hex$(peek(i)),2)+",";
32 next i:printchr$(20)
34 print"sa="sa":ea="ea":sw="sw":zn="zn
36 print"{down}{down}goto38":poke 842,19:fort=1to3:poke842+t,13:next:poke 208,5:end
38 sa=sa+15:ifsa<ea then 26
40 scnclr:print"delete-40":poke842,19:poke 843,13:poke208,2:end
1000 fori= 4864 to 4919 1010 read a$:poke i,dec(a$) 1020 next i 1030 : 1040 data78,a9,0e,8d,14,03,a9,13,8d,15,03,58,60,78,a5 1050 datad5,f0,25,c5,fc,f0,21,85,fc,a9,15,8d,18,d4,a0 1060 data09,a2,00,8c,05,d4,8e,06,d4,a9,30,8d,01,d4,a9 1070 data20,8d,04,d4,a9,21,8d,04,d4,58,4c,65,fa,a4,fb
Punkt-Komma-Tausch
Mit diesem kurzen Programm (Listing 3, bitte mit dem neuen Checksummer 128 eingeben) läßt sich der Dezimalpunkt auf der Zehnertastatur durch ein Komma ersetzen. Dies ist sehr hilfreich, falls lange DATA-Kolonnen mittels der Zehnertastatur eingetippt werden müssen.
Der Dezimalpunkt wird nur im ASCII-Modus mit dem Komma belegt. Es ist aber trotzdem möglich, den deutschen Zeichensatz zu nutzen, wenn man wie folgt vorgeht:
Den C 128 ausschalten, auf DIN umstellen, das Programm laden und starten. Nach kurzer Zeit wird man aufgefordert, die Taste F8 zu betätigen.
Nun kann damit begonnen werden, Listings einzugeben. Will man nun den Dezimalpunkt als Komma benutzen, was ja meist in DATA-Zeilen der Fall ist (da hier ja sowieso keine deutschen Umlaute benötigt werden), schaltet man auf ASCII-Zeichensatz um und hat nun das Komma zur Verfügung. Soll wieder Text eingegeben werden, wählt man wieder den DIN-Zeichensatz. Der Dezimalpunkt auf der Zehnertastatur ist nun wieder Dezimalpunkt, kann aber durch erneutes Umschalten auf ASCII wieder als Komma genutzt werden.
Soll nur im ASCII-Modus gearbeitet werden, ist das ganze wesentlich weniger kompliziert. Einfach Programm laden und starten!
Vor dem Speichern eines so eingegebenen Programmes sollte erst einmal <RUN/STOP-RESTORE> betätigt werden, um den Ursprungszustand wieder herzustellen.
Programmbeschreibung
In Zeile 85 bis 105 werden die für das Programm notwendigen Adressen definiert. Die nun folgende FOR..NEXT-Schleife erstellt im RAM ab Adresse $1B00 die später benötigte Normaltabelle des ASCII-Codes, da sie dort einfach zu manipulieren ist. Diese Tabelle ist im Commodore-Handbuch des C 128 in Anhang J sehr gut versteckt.
In Zeile 125 wird bei Adresse $0AC5 das siebte Bit gesetzt. Dies bewirkt, daß das High-Byte bei Adresse $033F immer mit dem gesetzten Modus (ASCII oder DIN) übereinstimmt, da die Adresse $033F andernfalls neu gesetzt würde.
Die Zeilen 130 bis 135 setzen nun noch die Adreßzeiger, und zwar $033E auf 0 und $033F auf 27.
Zeile 140 ist eigentlich der komplizierteste Teil. Hier findet der eigentliche Tausch der Tastaturbelegung statt. Sie erhalten nun die Methode gezeigt, mit der sich Tasten nahezu beliebig umbelegen lassen. Es folgt nun eine genaue Erklärung des S. Kohlitz-Tasttausch-Systems:
Man hat durch die FOR..NEXT-Schleife einen ASCII-Zeichensatz im RAM, der bei Adresse 6912 ($1B00) beginnt. Will man nun eine Taste umbelegen, so addiert man zu dem Wert 6912 zuerst den Platz-Code aus der Tastaturtabelle des zu ändernden Zeichens minus 1 (im Falle des Dezimalpunktes also 83-1). Warum denn minus 1? Ganz einfach: Die Platzcodes sind von 1 bis 89 fortlaufend durchnumeriert. Um aber sinnvoll damit arbeiten zu können, sollten sie von 0 bis 88 numeriert sein. Man sagt ja auch acht Bit, die aber von 0 bis 7 durchnumeriert sind.
Wir haben nun den Wert 6912+82 errechnet, also 6994. In diese Speicherstelle POKEt man nun nur noch den Code (nicht den Platzcode) des Zeichens, mit der die Taste belegt werden soll (im Falle des Kommas also eine 44). POKE 6994,44 und der Tausch ist perfekt.
Wollen Sie jetzt noch weitere Tasten umbelegen (wie wäre es mit SHIFT anstatt der Minus- oder Plus-Taste, um die Funktionstasten von der Zehnertastatur leichter zu erreichen?), so dürften der Ausführung keine Probleme mehr im Wege stehen.
(Stephan Kohlitz/dm)5 rem" ********************************
10 rem"*** commodore 128 pc ***
15 rem"*** ***
20 rem"*** vertauscht den dezimal- ***
25 rem"*** punkt auf der 10er tasta-***
30 rem"*** tur mit einem komma ! ***
35 rem"********************************
40 rem"*** (c) stephan kohlitz ***
45 rem"*** ***
50 rem"*** 1985 // bandelhohe 7a ***
55 rem"*** ***
60 rem"*** 4930 detmold ***
65 rem"*** ***
70 rem"*** tel. 05231/22558 ***
75 rem"********************************
80 restore
85 z1=dec("0058"):z2=dec("1b00")
90 z3=dec("0ac5"):z4=dec("0080")
95 z5=dec("033e"):z6=dec("033f")
100 z7=dec("001b"):z8=dec("1b52")
105 z9=dec("002c")
110 for dc=0toz1 :read da
115 poke z2+dc, da
120 next dc
125 poke z3,peek(z3) or z4
130 poke z5,0
135 poke z6,z7
140 poke z8,z9
145 data 20,13,29,136,133,134,135,17
150 :
155 data 51,87,65,52,90,83,69,1
160 :
165 data 53,82,68,54,67,70,84,88
170 :
175 data 55,89,71,56,66,72,85,86
180 :
185 data 57,73,74,48,77,75,79,78
190 :
195 data 43,80,76,45,46,58,64,44
200 :
205 data 92,42,59,19,1,61,94,47
210 :
215 data 49,95,4,50,32,2,81,3
220 :
225 data 132,56,53,9,50,52,55,49
230 :
235 data 27,43,45,10,13,54,57,51
240 :
245 data 8,48,46,145,17,157,29,255
250 :
255 data 255
260 key8,"delete-300"+chr$(13)
270 printchr$(147);"punkt-->komma tausch
280 print:print"(c) stephan kohlitz 1985"
290 print:print"vor weiteren eingaben 'f8' drucken"
Get mit Cursor
Bei allen Commodore-Computern konnte man mit drei kleinen POKEs den Cursor beim GET-Befehl ein- und ausschalten. Beim C 128 geht es im Prinzip auch, nur nicht im 80-Zeichen-Modus. Doch nichts ist unmöglich.
Im 80-Zeichen-Modus kann man dem VDC (Videocontroller) ein Zeichen mit einem »Blink-Attribut« versehen übergeben. Wie man anhand des Programms (Listing 4, bitte mit dem neuen Checksummer 128 eingeben) ausprobieren kann, blinkt der Cursor jetzt bei der GET-Routine, egal, ob im 40- oder 80-Zeichen-Modus.
Das Programmsegment für den 80-Zeichen-Modus dürfte durch die reichlichen Kommentare verständlich sein. Beim 40-Zeichen-Modus sind folgende zwei angesprochenen Speicherstellen von Interesse:
2599 $0A27 BLNSW Schalter für den Cursor (204 beim C 64); 0 = Ein/1 = Aus
2600 $0A28 BLNCT Zähler für Cursorblinken (205 beim C 64)
Den Cursorblinkzähler sollte man nach dem Holen eines Zeichens auf 1 stellen, da sonst hin und wieder ein inverser Block irgendwo auf dem Bildschirm stehenbleibt.
(Michael Bauer/dm)100 rem ************************************ 110 rem * * 120 rem * get mit blinkendem cursor * 130 rem * fuer c128 mit 40 oder 80 * 140 rem * zeichen-schirm * 150 rem * * 160 rem ************************************ 170 : 180 rem ***************** testprogramm 190 : 200 print"eingabe ? "; 210 gosub310:ifx$<>"j"andx$<>"n"then210 220 printx$ 230 end 240 : 250 rem ***************** subroutine get 260 rem ***************** mit blinkendem 270 rem ***************** cursor 280 : 290 rem pruefe ob 40 oder 80 zeichen-schirm 300 : 310 if peek(215)=128 then begin: rem 80 zeichen 320 : 330 : rem chr$(15) = zeichenblink an 340 : rem chr$(18) = rvs on 350 : rem chr$(146) = rvs off 360 : rem chr$(157) = cursor links 370 : rem chr$(143) = zeichenblink aus 380 : 390 : printchr$(15)chr$(18);" ";chr$(146)chr$(157)chr$(143); 400 : 410 : getkey x$: rem warte auf tastendruck 420 : 430 bend: else begin: rem 40 zeichen 440 : 450 : poke2599,0: rem schalte blinken ein 460 : 470 : getkey x$: rem warte auf tastendruck 480 : 490 : poke2599,1: rem schalte blinken aus 500 : 510 : poke2600,1: rem schalte blinkzaehler aus 520 : 530 bend 540 : 550 return 560 : 570 rem ************************************
Bildschirme verwalten
Dieses Programm macht es möglich, bis zu drei Bildschirme gleichzeitig im 80-Zeichen-Modus zu verwalten. Die einzelnen Bildschirme können nach dem Starten des Basic-Laders mit SYS 2883, Sichtbar, Bildschirmnummer, Attribut aufgerufen werden. Dabei haben die Parameter folgende Bedeutung:
— Sichtbar: Sichtbar kann zwei verschiedene Werte annehmen.
Wert 0: Der vorherige Bildschirm wird angezeigt. Die Befehle PRINT und CHAR schreiben aber schon auf den neuen Bildschirm. Dadurch kann ein Bildschirm aufgebaut werden, während ein anderer angezeigt wird.
Wert 1: Der angewählte Bildschirm wird auch tatsächlich angezeigt.
— Bildschirm: Es stehen die Bildschirme 1 bis 5 zur Verfügung. Bitte lassen Sie sich nicht verwirren, die Bildschirme 1 und 3 sind die gleichen.
— Attribut: Auch für das Attribut gibt es zwei Werte:
Wert 0: Attribut wird ausgeschaltet. Das heißt, auf dem Bildschirm sind keine Farben, blinkende und unterstrichene Zeichen mehr sichtbar. Außerdem werden alle Zeichen im Grafikmodus angezeigt. Das alles gilt auch, wenn Sie den Bildschirm nicht sichtbar einschalten. Beim Beschreiben des Bildschirms wird aber auch das abgeschaltete Attribut-RAM beschrieben. Diese Funktion (Attribut aus) ist für die Bildschirme 3, 4 und 5 gedacht, für die nur ein Attribut-RAM zur Verfügung steht.
Wert 1: Attribut wird eingeschaltet.
Insgesamt können fünf Bildschirme erzeugt werden. Die verschiedenen Bildschirme werden durch Verschiebung des Video-RAMs (in ihm stehen die Bildschirmcodes der Zeichen, die auf dem Bildschirm sichtbar sind), und durch Verschieben beziehungsweise Abschalten des Attribut-RAMs (in ihm werden die Farben und alternativen Darstellungen eines Zeichens eingetragen) des VDC-RAM (der VDC besitzt ein eigenes, 16 KByte großes RAM) realisiert.
Dabei stehen folgende Bildschirme zur Verfügung:
| Bildschirm 1 | Video-RAM von $0000 bis $0800, Attribut-RAM von $0800 bis $1600 |
| Bildschirm 2 | Video-RAM von $1600 bis $2400, Attribut-RAM von $2400 bis $3200 |
| Bildschirm 3 | Video-RAM von $0000 bis $0800, Attribut-RAM von $0800 bis $1600 |
| Bildschirm 4 | Video-RAM von $1600 bis $2400, Attribut-RAM von $0800 bis $1600 |
| Bildschirm 5 | Video-RAM von $2400 bis $3200, Attribut-RAM von $0800 bis $1600 |
Daraus ergibt sich die folgende Aufteilung: Bildschirm 1 und 2 oder Bildschirm 3, 4 und 5 können zusammen benutzt werden, ohne daß Verluste des Bildschirminhalts auftreten. Bei den Bildschirmen 3, 4 und 5 wird dasselbe Attribut-RAM benutzt. Für eben diese Schirme steht dann jedoch nur ein Attribut-RAM zur Verfügung.
Eingabehinweise
Das Programm (Listing 5) geben Sie bitte mit dem neuen Checksummer 128 ein und speichern es. Das Programm starten Sie durch RUN. Das zweite Programm (Listing 6) ist ein Demo-Programm, das nicht unbedingt abgetippt werden muß.
Der Befehl SYS DEC ("C07B") im Basic-Lader ist nötig, um den Bildschirm zu initialisieren. Wird dieser Befehl nicht ausgeführt, so kann es geschehen, daß sich der Computer nach dem Wechsel eines Bildschirms nicht mehr meldet. Dann müssen Sie das Programm mit RUN/STOP-RESTORE unterbrechen.
(Christoph Franzen/dm)10 :rem bildschirme
20 :
30 :rem maschinensprachedaten einlesen
40 :bank0: fast
50 :for i = dec("b00") to dec ("b91")
60 : read da$: poke i, dec(da$)
70 : su = su + dec(da$)
80 :next i
90 :if su <> 11931 then print"{CTRL-O}Fehler in Datazeilen":end: else begin
100 : print"{CTRL-O}Datazeilen sind richtig.": sleep3 :bend
110 :rem die steuerzeichen in zeile70/80 sind < control o >
120 bank 15:sysdec("c07b"): rem bildschirm initialisieren
130 :
140 :rem assemblerdaten
150 data 8e,00,d6,2c,00,d6,10,fb,8d,01,d6,60,8e,00,d6,2c
160 data 00,d6,10,fb,ad,01,d6,60,a9,00,e0,01,d0,07,a2,0c
170 data 20,00,0b,a2,01,8d,2e,0a,60,a9,08,e0,01,d0,05,a2
180 data 14,20,00,0b,8d,2f,0a,60,20,0c,0b,09,40,20,00,0b
190 data 4c,53,0b,48,8a,48,a2,19,98,d0,ed,20,0c,0b,29,bf
200 data 20,00,0b,68,c9,01,f0,04,c9,03,d0,08,68,aa,20,18
210 data 0b,4c,29,0b,c9,02,d0,0c,68,aa,a9,10,20,1a,0b,a9
220 data 18,4c,2b,0b,c9,04,d0,0a,68,aa,a9,10,20,1a,0b,4c
230 data 29,0b,c9,05,d0,0a,68,aa,a9,18,20,1a,0b,4c,29,0b
240 data 68,60
250 :
260 :rem mit sys2883,sichtbar,bildschirm,attribut werden die bildschirme
270 :rem eingeschaltet. sichtbar kann die werte 0 (nicht sichtbar) und 1 (sicht-
280 :rem bar) annehmen. Îicht sichtbar heisst, dass fuer die befehle print und
290 :rem char auf den neuen bildsch. zugegriffen wird, aber gleichzeit. der alte
300 :rem bildsch. angezeigt wird. bildschirm kann die werte von 1-5 annehmen.
310 :rem attribut kann die werte 0 (aus) und 1 (ein) annehmen.
320 :rem der befehl in zeile 120 zum initialisieren des bildschirms ist notwen-
330 :rem dig um das prg. bildschirme fehlerfrei ablaufen zu lassen. er muss ein-
340 :rem mal nach dem poken der maschinensprachedaten ausgefuehrt werden.
350 :
360 :rem christoph franzen bonifatiusstrasse 70 4130 moers asberg
10 fast: ein=1:aus=0
11 :
20 bs=2:sys 2883,ein,bs,ein: print"{clr}": rem bild 2 loeschen u einschalten
30 bs=1:sys 2883,aus,bs,ein: print"{clr}": rem bild 1 loeschen u nicht sichtb. ein
31 :
40 for i=1 to 10
50 print"{CTRL-B}Christoph Franzen Bonifatiusstrasse 70 4130 Moers Asberg Bildschirm 1
60 next
61 :
70 bs=1:sys 2883,ein,bs,ein: rem bild 1 einschalten
80 input "Bitte gebe Deinen Namen ein"; na$
81 print"{clr} Hallo "na$"{down}{down}
82 print"Ich hoffe es geht Dir heute sehr gut. Jedenfalls wird jetzt gerade waehrend
83 print"Du diesen Text liesst Dein Name auf Bildschirm 2 blinkend geschrieben.
84 print"Wenn Du gleich die Aufforderung bekommst eine Taste zu druecken, dann ist
85 print"der Aufbau des Bildschirms 2 fertig und Du kannst ihn Dir ansehen, indem Du
86 print"der Aufforderung nachkommst und eine beliebige Taste Deines Computers
87 print"drueckst.
89 :
90 bs=2: sys 2883,aus,bs,ein : rem bild 2 nicht sichtb. ein
100 print"{clr}{CTRL-B}Christoph Franzen Bonifatiusstrasse 70 4130 Moers Asberg Bildsch.2
110 fori=0to100: print" {CTRL-O}" na$ " "; :next
111 :
120 bs=1: sys2883,ein,bs,ein: rem bild 1 wieder einschalten
130 char1,20,20, "Bitte eine Taste druecken"
140 getkey a$
141 :
150 bs=2: sys 2883,ein,bs,ein: rem bild 2 zum sehen einschalten
Programme verbinden (MERGE)
Mit diesem Programm (Listing 7, bitte mit dem neuen Checksummer 128 eingeben) lassen sich mehrere Programme zu einem einzigen verbinden.
Das Programm »Merge« ist so geschrieben, daß es an einen freien Speicherplatz gesetzt und aufgerufen werden kann. Um das Programm an eine andere Adresse zu verschieben, muß im Basic-Lader in Zeile 30 die Variable »AN« geändert werden.
Die Bedienung der Routine:
1) Reset-Taster am Computer betätigen beziehungsweise Computer aus- und einschalten. Das ist wichtig, um sicherzugehen, daß der Basic-Start wirklich bei $1C00 beginnt.
2) Programm MERGE laden und starten. Bitte schreiben Sie sich die Adressen der SYS-Befehle auf.
3) Laden Sie Ihr Programm, das Sie mit einem anderen verbinden wollen, und bringen Sie das Programm eventuell durch RENUMBER in einen vernünftigen Zeilennummernbereich. Schreiben Sie sich bitte die höchste Zeilennummer des ersten Programmes auf.
4) Verschieben Sie den Basic-Start (SYS 2816).
5) Laden Sie das nächste Programm und bringen auch dieses durch RENUMBER in einen vernünftigen Zeilennummernbereich (die Zeilennummern des zweiten Programms müssen höher als die des ersten sein).
6) Verbinden Sie die Programme (SYS 2838).
7) Nun können Sie das neue Programm speichern.
Nach dem Verschieben des Basic-Starts sind alle Befehle erlaubt. Das heißt, Sie können die geladenen Programme mittels DELETE, RENUMBER oder sonstigen Befehlen verändern.
(Christoph Franzen/dm)10 rem merge 20 : 30 an = 2816 : bank0 40 : 50 rem maschinensprachedaten einlesen 60 for i = an to an + 30 70 read da$: poke i, dec(da$) 80 su = su + dec(da$) 90 next 100 if su <> 2733 then print"Fehler in Datazeilen":end:else begin 110 print"Programmstart an Programmende setzen mit SYS" an 120 print"Programme zu einem Programm zusammensetzen mit SYS" an+22 130 : 140 rem maschinensprachedaten 150 data ad,10,12,38,e9,02,85,2d,ad,11,12,e9,00,85,2e,a0 160 data 02,a9,00,91,2d,60,a9,01,85,2d,a9,1c,85,2e,60 170 : 180 rem ende
Bankswitching in Assembler
Durch das Bankswitching wird die Assemblerprogrammierung oft sehr aufwendig und mühselig. Wer schon einmal versucht hat, aus BANK 1 in eine Kernel-Routine in BANK 15 zu springen, wunderte sich sicher, denn danach befand sich der Computer in einem (sehr) undefinierten Zustand.
Um diesem Problem zu begegnen, müßte ein Programm her, das vor Aufruf die gewünschte Konfiguration einschaltet und bei der Rückkehr die alte Speicherbelegung wiederherstellt.
Das Programm müßte zusätzlich in der Common-Area (jenem Speicherbereich, der für alle BANKs gleich ist) funktionieren. Es bietet sich der RS 232-Eingabepuffer von $C00 bis $D00 an.
Das Programm »Kernel« (Listing 8), das in diesem Bereich liegt, funktioniert so:
1) Die Nummer der Kernel-Routine wird in 996 gespeichert (die Nummern entnehmen Sie bitte Tabelle 1)
2) Akku, X- und Y-Register so mit ihren Werten laden, als würde direkt in die gewünschte Kernel-Routine verzweigt
3) JSR $C00
| Name | Nummer | Adresse | Funktion |
|---|---|---|---|
| FSTMODE | 01 | $ff47 | Fastimpuls an Bus |
| EAINIT | 02 | $ff4a | Standard E/A-Geräte setzen |
| C64MODE | 03 | $ff4d | Aktivierung des 64’er-Modus |
| DMA-CALL | 04 | $ff50 | Externe RAM-Bausteine initialisieren |
| BOOT-CALL | 05 | $ff53 | Booten der Diskette |
| PHOENIX | 06 | $ff56 | Kaltstart |
| LKUPLA | 07 | $ff59 | Suche nach logischer Filenummer |
| LKUPSA | 08 | $ff5c | Suche nach Sekundäradresse |
| SWAPPER | 09 | $ff5f | Umschalter zwischen 40 und 80 Zeichen |
| DLCHR | 10 | $ff62 | Kopiert Zeichensatz ins VDC-RAM |
| PFKEY | 11 | $ff65 | F-Tastenbelegung |
| SETBANK | 12 | $ff68 | Speicherbank für LOAD/SAVE definieren |
| GETCONF | 13 | $ff6b | Holt Konfigurationsbyte |
| JSRFAR | 14 | $ff6e | JSR in beliebige Bank |
| JMPFAR | 15 | $ff71 | JMP in beliebige Bank |
| FETCH | 16 | $ff74 | LDA ( ),Y aus beliebiger Bank |
| STASH | 17 | $ff77 | STA ( ),Y in beliebiger Bank |
| COMPARE | 18 | $ff7a | CMP ( ),Y in beliebiger Bank |
| PRIMM | 19 | $ff7d | Textausgabe |
| CINT | 20 | $ff81 | Editor-Initialisierung |
| IOINIT | 21 | $ff84 | Ein-/Ausgabe-Initialiesierung |
| RAMTAS | 22 | $ff87 | Warmstart |
| RESTOR | 23 | $ff8a | Systemvektoren initialisieren |
| VECTOR | 24 | $ff8d | Systemvektoren kopieren |
| SETMSG | 25 | $ff90 | Systemmeldungen ermöglichen/verhindern |
| SECND | 26 | $ff93 | Sekundäradresse nach LISTn |
| TKSA | 27 | $ff96 | Sekundäradresse nach TALK |
| MEMTOP | 28 | $ff99 | Lesen/setzen der Speicherobergrenze |
| MEMBOT | 29 | $ff9c | Lesen/setzen der Speicheruntergrenze |
| KEY | 30 | $ff9f | Tastaturabfrage |
| SETTMO | 31 | $ffa2 | Setzen des Timeoutflags für IEEE |
| ACPTR | 32 | $ffa5 | Holt Byte vom Bus |
| CIOUT | 33 | $ffa8 | Legt Byte auf Bus |
| UNTLK | 34 | $ffab | Untalk an Bus senden |
| UNLSN | 35 | $ffae | Unlisten an Bus senden |
| LISTN | 36 | $ffb1 | Listen an Bus senden |
| TALK | 37 | $ffb4 | Talk an Bus senden |
| READST | 38 | $ffb7 | Statusbyte lesen |
| SETLFS | 39 | $ffba | Setzen der Fileparameter |
| SETNAM | 40 | $ffbd | Setzen des Filenamens |
| OPEN | 41 | $ffc0 | Datei öffnen |
| CLOSE | 42 | $ffc3 | Datei schließen |
| CHKIN | 43 | $ffc6 | Datei ist Eingabedatei |
| CKOUT | 44 | $ffc9 | Datei ist Ausgabedatei |
| CLRCH | 45 | $ffcc | Ein-/Ausgabekanäle schließen |
| BASIN | 46 | $ffcf | Zeicheneingabe |
| BSOUT | 47 | $ffd2 | Zeichenausgabe |
| LOAD | 48 | $ffd5 | Laden einer Datei |
| SAVE | 49 | $ffd8 | Speichern einer Datei |
| SETTIM | 50 | $ffdb | Setzen der internen Uhr |
| RDTIM | 51 | $ffde | Lesen der internen Uhr |
| STOP | 52 | $ffe1 | Stop-Tasten-Abfrage |
| GETIN | 53 | $ffe4 | Holt Zeichen aus Tastaturpuffer |
| CLALL | 54 | $ffe7 | Schließen aller Dateien |
| UDTIM | 55 | $ffea | Interne Uhr hochzählen |
| SCRORG | 56 | $ffed | Fenstergröße feststellen |
| PLOT | 57 | $fff0 | Cursorposition holen/setzen |
| IOBASE | 58 | $fff3 | Holt die Basisadresse des I/O-Bereiches |
Manchmal kommt es auch vor, daß ein Unterprogramm im Basic-ROM von $F4000 bis $FAFFF oder im Monitor von $FB000 bis FBFFF aufgerufen werden soll. Solch ein Problem ist mit JSRFAR zu lösen:
1) Die anzuspringende BANK ist in $02 abzulegen
2) Die anzuspringende Adresse ist im High-/Low-Format in $03/$04 bereitzustellen
3) Akku in $06, X-Register in $07 und Y-Register in $08
4) JSR $C23
Soll kein Unterprogrammaufruf, sondern ein normaler Sprung stattfinden, so ist Punkt 4 durch JMP $CD0 zu ersetzen.
Diese seltsame Art der Parameterübergabe entspricht den original JMP- und JSRFAR-Routinen. Es dürfte also keine großen Probleme bei der Umrüstung bereits bestehender Programme geben.
»Kernel 128« muß vor dem Start noch initialisiert werden. Dies erfolgt durch JSR $C3E. Findet der Interpreter während der Ausführung eines Basic-Programms eine USR(X)-Anweisung, so wird nach $0F000 gesprungen.
(Frank Probst/dm)PROGRAMM : KERNEL 128 0C00 0D10 ----------------------------------- 0C00 : 85 06 86 07 84 08 A9 0F 58 0C08 : 85 02 A9 44 85 04 A9 FF A0 0C10 : 85 03 AD E4 03 C9 14 90 0F 0C18 : 02 E6 04 0A 6D E4 03 65 A5 0C20 : 04 85 04 AD 00 FF 48 A9 12 0C28 : 00 8D 00 FF 20 CD 02 68 38 0C30 : 8D 00 FF A5 05 48 A5 06 A7 0C38 : A6 07 A4 08 28 60 A9 00 B8 0C40 : 8D 00 FF AD 06 D5 09 05 C0 0C48 : 8D 06 D5 A9 00 85 2F 85 77 0C50 : 31 A9 10 85 30 85 32 A9 56 0C58 : 72 8D 19 12 A9 0C 8D 1A 7F 0C60 : 12 A9 7F 8D 00 FF A0 37 C9 0C68 : B9 D8 0C 99 50 FF 88 10 0B 0C70 : F7 60 A9 3F 8D 00 FF 4C 5B 0C78 : 00 F0 8D 8D 0C 8D 92 0C 95 0C80 : EE 92 0C AD 00 FF 48 A9 E5 0C88 : 7E 8D 00 FF A5 00 8D 5A 12 0C90 : FF A5 00 8D 5B FF 20 50 EA 0C98 : FF 8D E4 03 68 8D 00 FF EA 0CA0 : AD E4 03 60 8D E4 03 A9 EC 0CA8 : FF 8D BC 0C 8D C1 0C EE 13 0CB0 : C1 0C AD 00 FF 48 A9 7E C9 0CB8 : 8D 00 FF A5 00 8D 7C FF 58 0CC0 : A5 00 8D 7D FF AD E4 03 7F 0CC8 : 20 6C FF 68 8D 00 FF 60 C5 0CD0 : A9 00 8D 00 FF 4C E3 02 D3 0CD8 : 78 AD 06 D5 29 F3 8D 06 D8 0CE0 : D5 B9 FF FF 8D F0 FF AD 4D 0CE8 : 06 D5 09 04 8D 06 D5 AD 57 0CF0 : F0 FF 58 60 8D F0 FF 78 53 0CF8 : AD 06 D5 29 F3 8D 06 D5 B2 0D00 : AD F0 FF 99 FF FF AD 06 1B 0D08 : D5 09 04 8D 06 D5 58 60 46
Boot-Sektoren selbst erstellen
Die Wirkung eines Boot-Sektors kennt wohl jeder Besitzer eines C 128. Doch eine Diskette mit diesem Boot-Sektor (Listing 9) versehen, ist dagegen ganz etwas anderes.
Selbst mit dem »Auto-Boot-Creater« von der Test-Demo-Diskette kann leider nur ein Boot-Sektor mit Autostart für ein Maschinen- oder ein Basic-Programm erzeugt werden.
Oder man studiert die entsprechenden Kapitel in den entsprechenden Fachbüchern, und schreibt den Boot-Sektor mit Floppy-Befehlen oder einem Disketten-Monitor (Wer hat den schon für den C 128?) auf die Diskette. Aber versuchen Sie dann einmal, das so geladene Basic-Programm im Speicher zu verändern! Oder lieber nicht, denn absolut geladene Basic-Programme lassen sich nicht mehr editieren. Doch das steht ja schon im »Commodore-128-Handbuch« von Markt & Technik.
Doch Gott sei Dank gibt es noch vernünftige Boot-Maker wie den hier vorgestellten.
Hiermit lassen sich leicht und locker 17 (in Worten: siebzehn) verschiedene Boot-Kombinationen erstellen!
Zunächst einmal kann man frei wählbaren Text während des Ladens auf den Bildschirm geben. Hierbei sind sogar Steuerzeichen möglich. Oder man gibt schlicht den Namen des Programms ein, das gerade geladen wird.
Das zu ladende Programm kann mit oder ohne Autostart sein. Natürlich kann man auch nur einen Begrüßungstext auf den Bildschirm ausgeben. Oder nur ein Maschinen- oder Basic-Programm laden.
Aus den drei Grundeinstellungen
| 1) Text | nein / | ja |
| 2) Masch.Prg. | nein / | ja, mit Autostart ja, ohne Autostart |
| 3) Basic-Prg. | nein / | ja, mit Autostart ja, ohne Autostart |
ergeben sich die oben genannten 17 Boot-Versionen.
»Boot-Sektor« wurde auf einem 80-Zeichen-Montior erstellt, aber auch auf einem 40-Zeichen-Monitor bleibt die Übersichtlichkeit erhalten. Hierfür wird vom Programm automatisch festgestellt, welcher der Bildschirme gerade eingeschaltet ist.
Selbstverständlich läuft das Programm nicht nur mit den Floppy-Laufwerken 1570/1571, sondern auch mit der guten, alten 1541.
Zum Ausprobieren nimmt man am besten eine frisch formatierte Diskette mit je einem Testprogramm in Basic und Maschinensprache. Daß die Floppy 1571 beidseitig formatierte Disketten schneller liest, hat sich sicher schon herumgesprochen; es entfallen dann nämlich einige vergebliche Leseversuche. Aber das nur nebenbei.
Doch nun zur eigentlichen Beschreibung des Programms (Listing 9), das Sie übrigens mit dem neuen Checksummer 128 eingeben müssen:
Zeile 100 löscht den Bildschirm und aktiviert die Fehlerfalle. Hiermit soll vor allem ein Programmabbruch durch versehentliches Drücken der <STOP>-Taste oder falsche HEX-Eingabe (in Zeile 530) vermieden werden.
Es folgen in den Zeilen 120 bis 150 Initialisierung und Test auf Schreibschutz.
Mit Zeile 160 bis 200 wird der Sektor 0 in Spur 1 anhand der ersten 3 Byte geprüft. Je nach Ergebnis kann nach einer Information laut Zeile 210 oder Zeile 250 das Programm in Zeile 290/320 abgebrochen oder fortgesetzt werden. Hier kommen übrigens die sehr praktischen, für C 64-Aufsteiger neuen Basic-Anweisungen GETKEY und IF..THEN..ELSE zur Anwendung.
Haben die ersten 3 Byte den Wert 00, ist der Block frei und es wird von Zeile 190 direkt nach Zeile 340 gesprungen.
Auf die Frage »Text hinter 'Booting'?« kann ein beliebiger Text eingegeben werden (Text = TX$). Wird der Name des zu ladenden Programms eingetippt, erscheint während des Ladens:
"BOOTING (Programmname)..."
Aber dank des bereits durch Zeile 360 in den Tastaturpuffer vorgegebenen Anführungszeichens können auch die bereits oben erwähnten Steuerzeichen eingegeben werden.
Wenn kein Text erwünscht ist: <RETURN> drücken!
Für die richtige Positionierung der Punkte (...) wurde in Zeile 380 für die TAB-Funktion aus Speicherstelle 215 ($D7) der Wert für 40- oder 80-Zeichen-Darstellung abgefragt. Dort steht entweder $00 oder $80 für 40 beziehungsweise 80 Zeichen. Denn: 0:3,2 ergibt TAB(0) und 128:3,2 ergibt TAB(40)!
Zeile 400: Soll ein Maschinen-Programm geladen werden, kann jetzt der Name des Programms eingegeben werden. Kein Maschinen-Programm? <RETURN> drücken!
Wurde ein Name eingegeben (MP$), muß nun die Frage »Autostart?« mit J(a) oder N(ein) beantwortet werden (Zeilen 420 bis 480).
Zeile 470: Die Variable RU ist für die Einsprungadresse zum eventuellen Laden eines Maschinen-Programms wichtig, und ergibt sich aus der Länge des Textes (TX$), der Länge des Maschinenprogramm-Namens (MP$) und dem Wert von JN=19 plus 3 für einen JSR-Befehl, falls Autostart gewählt wurde.
In Zeile 490/500 wird wieder für die PRINT-Anweisung der aktuelle Bildschirm abgefragt. Falls das Maschinen-Programm nicht automatisch gestartet werden soll, geht es von Zeile 490 direkt nach 650 zur Frage nach einem Basic-Programm. Ansonsten muß nun erst noch die Startadresse genannt werden (Zeilen 530 bis 630). Wer die Adresse nicht in HEX-Werten weiß, kann selbstverständlich auch die SYS-Adresse in dezimal angeben; man braucht dann nur N(ein) mit <RETURN> zu bestätigen. Wer unmögliche Werte eingibt, TRAPt in die Fehlerfalle und darf die Eingabe wiederholen.
Die Zeilen 620/630 zerlegen die Adresse in Low- (JL) und High-(JH)Byte.
Nun wird (Zeile 650) nach einem Basic-Programm gefragt. Soll kein Basic-Programm geladen werden, nur <RETURN> drücken. Andernfalls muß der Programmname eingegeben werden (BP$).
Entsprechend der Entscheidung: Autostart – ja oder nein wird der Variablen BS$ der Wert RUN für Laden und Starten oder DLOAD für Laden ohne Starten übergeben (Zeilen 670 bis 710).
Sollte weder ein Text noch ein Programmname eingegeben worden sein, wäre ein Boot-Sektor überflüssig und das Programm wird beendet.
Im Abschnitt der Zeilen 770 bis 830 wird mit GETKEY OK$ angehalten und die Eingaben können in aller Ruhe überprüft werden. Durch X bricht das Programm ab, mit N können laut Zeile 340 nach Löschung aller Variablen (CLR) alle Eingaben erneuert werden.
Ist alles in Ordnung, muß nur noch J gedrückt werden. Nachdem den Variablen CB$ und NB$ die Werte CBM und 00 zugewiesen wurden, läuft der eigentliche Schreibvorgang des Boot-Sektors in den Zeilen 880 bis 1010 ab. In Zeile 1010 wird mit TRAP die Fehlerfalle desaktiviert. Zeile 1020 schafft mit ESCAPE <Klammeraffe> Platz für die Floppy-Meldung DS$.
Fehlermeldungen von der Floppy werden in den Zeilen 1040 bis 1060 und Basic-Fehler in den Zeilen 1080 bis 1120 verarbeitet.
(Hans-Georg Schmidt/dm)10 rem:::::::::::::::::::::::::::::::::
20 rem programm zur einrichtung eines
30 rem boot-sektors fuer den
40 rem commodore 128 pc
50 rem
60 rem (c)1986 hans-georg schmidt
70 rem koenigsberger strasse 39
80 rem 2870 delmenhorst
90 rem:::::::::::::::::::::::::::::::::
100 print"{clr}":trap 1080
110 print" boot-sektor fuer den commodore 128 (c) 1986 hans-georg schmidt"
120 open15,8,15
130 print#15,"io":print#15,"b-f 0 1 0"
140 if val(ds$)<>0 then 1040
150 print#15,"b-a 0 1 0":open5,8,5,"#"
160 print#15,"u1 5 0 1 0"
170 print#15,"b-p 5 0"
180 get#5,a$,b$,c$:dclose
190 if a$+b$=""then 340
200 if a$+b$+c$="cbm"then250
210 print"{down}{down}{down} achtung!"
220 print"{down}{down} der bootsektor (sektor 0 in spur 1) ist nicht frei !"
230 print"{down}{down} wichtige daten zum retten ?"
240 print"{down} oder weitermachen?":goto 290
250 print"{down}{down}{down} achtung!"
260 print"{down} auf der diskette befindet sich bereits ein boot-sektor!"
270 print"{down} ueberschreiben ? ?"
280 print"{down} oder programm abbrechen ?"
290 print"{down}{down} x =abbrechen w = weiter"
300 getkey wx$
310 if wx$="w"then 340
320 if wx$="x"then 1120:else300
330 :
340 clr:print"{home}{home}{down}{down}{down}";chr$(27);"@{down}{down}"
350 print" kein text = nur {rvon}return{rvof} !{up}{up}{up}"
360 poke 842,34:poke 208,1
370 input" text hinter 'booting' ";tx$
380 if tx$=""then print tab(int(peek(215)/3.2))"{up}...."
390 :
400 input"{down} name des zu ladenen masch-programms ";mp$
410 if mp$=""then ru=len(tx$)+19:print"{up}{up}{up}":goto 650
420 print"{down} soll das maschinen-programm"
430 print" automatisch gestartet werden ? j/n"
440 getkey am$
450 if am$="j"or am$="n" then 460:else 440
460 if am$="j" then jn=22:else jn=19
470 ru=len(tx$)+len(mp$)+jn
480 if am$="j" then 500
490 printtab(peek(215)/3.2+17)"{up}{up}{up}{up}= kein autostart";chr$(27)chr$(64):goto 650
500 printtab(peek(215)/3.2+17)"{up}{up}{up}{up}= mit autostart"chr$(27)chr$(64)
510 print"{down}":trap1080
520 :
530 input"{up} adresse in hex n{left}{left}{left}";he$
540 if he$="n" then 580
550 sy=dec(he$)
560 printtab(26)"{up}= sys";sy
570 goto 620
580 input"{up} adresse in dezimal (sys)";sy
590 if sy=0 then print"{up}"chr$(27)"d":goto 530
600 if sy>65535 then print tab(28)"{up}=zu gross!":else620
610 sleep 2:print"{up}"chr$(27)"d":goto580
620 jh=int(sy/256)
630 jl=sy-jh*256
640 :
650 input"{down} name des zu ladenen basic-programms ";bp$
660 if bp$=""then print"{up}";chr$(27)"d":goto 750
670 print"{down} soll das basic-programm"
680 print" automatisch gestartet werden ? j/n"
690 getkey ab$
700 if ab$="j"or ab$="n" then 710:else 690
710 if ab$="j" then bs$="run":else bs$="dload"
720 if ab$="j" then 740
730 printtab(peek(215)/3.2+17)"{up}{up}{up}{up}= kein autostart";chr$(27)chr$(64):goto 750
740 printtab(peek(215)/3.2+17)"{up}{up}{up}{up}= mit autostart"chr$(27)chr$(64)
750 if tx$=""and mp$=""and bp$=""then 1120
760 :
770 print"{down}{down}{down} alles ok ?";chr$(27)"q"
780 print"{down} die richtige diskette im laufwerk ? ?"
790 print"{down} j = weiter n = neubeginn x = abbruch"
800 getkey ok$
810 if ok$="j"or ok$="n"or ok$="x" then 820:else 800
820 if ok$="n" then 340
830 if ok$="x" then 1120
840 :
850 cb$="cbm"
860 nb$=chr$(0)
870 :
880 open 15,8,15:open 5,8,5,"#"
890 print#15,"u1 5 0 1 0":print#15,"b-p 5 0"
900 print#5,cb$;nb$;nb$;nb$;nb$;
910 print#5,tx$;nb$;mp$;nb$;
920 if am$="n" or mp$="" then 940
930 print#5,chr$(32);chr$(jl);chr$(jh);
940 if bp$="" then bp$=chr$(96):goto 990
950 print#5,chr$(169);chr$(ru);chr$(133);chr$(61);
960 print#5,chr$(169);chr$(11);chr$(133);chr$(62);
970 print#5,chr$(76);chr$(209);chr$(77);
980 print#5,bs$;chr$(34);
990 print#5,bp$;chr$(0)
1000 print#15,"u2 5 0 1 0"
1010 close 5:close 15:trap
1020 print "{up}{up}{up}{up}{up} "chr$(27)"@"ds$
1030 :
1040 if val(ds$)=26 then print"{down}{down} bitte schreibschutz entfernen":else 1060
1050 print"{down} und neu starten !":end
1060 if val(ds$)<>0 then print"{down}{down} bitte fehlermeldung beachten: ",,ds$
1070 end
1080 if er=14 then 1100
1090 if er=30 then resume:else print"{down}{rght}"err$(er):resume1070
1100 print tab(21)err$(er):sleep 2:print"{up}";chr$(27)"d"
1110 print"{up}{up}":resume 530
1120 trap:print"{home}{down}{down}{down}{down}"chr$(27)"@ neuer start mit 'run' !{down}{down}":end
Variablen- und Array-Inhalte anzeigen
1): DUMPV 128
Dieses Programm (Listing 10, bitte mit dem neuen Checksummer 128 eingeben) ermöglicht die Ausgabe der Werte der nichtindizierten Variablen eines Basic-Programms.
Nach Start des Ladeprogramms mit RUN erfolgt der Aufruf mit SYS DEC ("0B00"). Es werden für jede Variable deren Name (maximal die ersten beiden Buchstaben), deren Typ (SPACE für Real, % für Integer und $ für String) sowie deren Werte ausgegeben.
2): DUMPA 128
Dieses Programm (Listing 11, bitt ebenfalls mit dem neuen Checksummer 128 eingeben) funktioniert ähnlich wie DUMPV 128, nur daß die Werte der indizierten Variablen (Arrays) eines Basic-Programms ausgegeben werden. Nach Start des Ladeprogramms mit RUN kann es mit SYS DEC ("0C1E") aufgerufen werden. Die Ausgabe der Namen und Felder erfolgt analog zur Ausgabe der Variablennamen bei DUMPV 128. Die Werte eines Arrays werden, getrennt durch Kommata, in der Reihenfolge, in der sie im Speicher stehen, ausgegeben.
Da beide Programme verschiedene RAM-Bereiche belegen, können sie gleichzeitig im Speicher stehen und unabhängig voneinander verwendet werden. Die Werte aller Variablen (also einfache und indizierte Variable) können mit SYS DEC ("0DE6") ausgegeben werden, wenn vorher folgendes Programm gestartet wird:
10 FOR I=DEC("0DE6") TO DEC("0DEC"): READ X
20 POKE I,X: NEXT I
30 DATA 32,0,11,32,30,12,96
(Lothar Glässer/dm)
110 rem
120 rem dumpv 128
130 rem
140 rem programm zur automatischen ausgabe der nichtindizierten variablen
150 rem eines basic 7.0 programmes fuer den commodore 128
160 rem
170 rem l.glaesser
180 rem am brunnen 27
190 rem 8011 kirchheim
200 rem
210 rem ************************************************************************
220 rem
230 rem
240 rem
250 screenmode=peek(dec("00d7"))
260 if screenmode=0 then sp=0: sx=15: sy=10: else sp=5: sx=35: sy=10
270 scnclr sp
280 color 0,1: color 6,1: color 4,1: color 5,2
290 char 1,sx,sy,"dumpv 128",1
300 rem data-zeilen lesen
310 s=0: for i=dec("0b00") to dec("0c1d"): read x: s=s+x: poke i,x: next i
320 data169,0,141,0,255,165,47,133,252,165,48,133,253,197,50,208,12,165,252
330 data197,49,208,6,169,63,141,0,255,96,160,0,32,230,11,16,6,32,78,11,76
340 data57,11,200,32,230,11,16,6,32,147,11,76,57,11,32,115,11,169,13,32,45
350 data199,24,165,252,105,7,133,252,165,253,105,0,133,253,76,13,11,32,200
360 data11,169,37,32,45,199,169,32,32,45,199,32,230,11,133,100,200,32,230
370 data11,133,101,162,144,56,32,112,140,32,66,142,32,226,85,96,32,200,11
380 data169,32,32,45,199,169,32,32,45,199,166,252,164,253,232,208,1,200,232
390 data208,1,200,138,32,246,11,76,108,11,32,200,11,169,36,32,45,199,169
400 data32,32,45,199,169,32,32,45,199,32,230,11,133,254,240,27,200,32,230
410 data11,72,200,32,230,11,133,251,104,133,250,160,0,32,238,11,32,45,199
420 data200,198,254,208,245,96,169,32,32,45,199,160,0,32,230,11,41,127,32
430 data45,199,200,32,230,11,41,127,208,2,169,32,32,45,199,200,96,165,252
440 data133,250,165,253,133,251,169,250,162,1,32,116,255,96,133,250,132,251
450 data160,4,32,238,11,133,103,136,32,238,11,133,102,136,32,238,11,133,101
460 data136,32,238,11,133,104,9,128,133,100,136,32,238,11,133,99,96
470 scnclr sp
480 if s=32209 then 510
490 char 1,sx,sy,"fehler in datazeilen !!!"
500 char 1,sx,sy+2,"differenz = "+str$(32209-s)
510 end
110 rem
120 rem dumpa 128
130 rem
140 rem programm zur automatischen ausgabe der indizierten variablen
150 rem eines basic 7.0 programmes fuer den commodore 128
160 rem
170 rem l.glaesser
180 rem am brunnen 27
190 rem 8011 kirchheim
200 rem
210 rem ************************************************************************
220 rem
230 rem
240 rem
250 screenmode=peek(dec("00d7"))
260 if screenmode=0 then sp=0: sx=15: sy=10: else sp=5: sx=35: sy=10
270 scnclr sp
280 color 0,1: color 6,1: color 4,1: color 5,2
290 char 1,sx,sy,"dumpa 128",1
300 rem data-zeilen lesen
310 s=0: for i=dec("0c1e") to dec("0de5"): read x: s=s+x: poke i,x: next i
320 data169,0,141,0,255,165,49,133,252,165,50,133,253,197,52,208,12,165,252
330 data197,51,208,6,169,63,141,0,255,96,160,0,32,163,13,16,6,32,97,12,76
340 data87,12,200,32,163,13,16,6,32,233,12,76,87,12,32,171,12,169,13,32,45
350 data199,165,253,76,43,12,32,67,13,169,37,32,45,199,169,32,32,45,199,160
360 data0,32,174,13,133,100,200,32,174,13,133,101,162,144,56,32,112,140,32
370 data66,142,32,226,85,24,165,22,105,2,133,22,165,23,105,0,133,23,197,253
380 data240,4,176,16,144,6,165,22,197,252,176,8,169,44,32,45,199,76,110,12
390 data96,32,67,13,169,32,32,45,199,169,32,32,45,199,165,22,164,23,32,190
400 data13,32,66,142,32,226,85,24,165,22,105,5,133,22,165,23,105,0,133,23
410 data197,253,240,4,176,16,144,6,165,22,197,252,176,8,169,44,32,45,199
420 data76,184,12,96,32,67,13,169,36,32,45,199,169,32,32,45,199,169,32,32
430 data45,199,160,0,32,174,13,133,254,240,27,200,32,174,13,72,200,32,174
440 data13,133,251,104,133,250,160,0,32,182,13,32,45,199,200,198,254,208
450 data245,24,165,22,105,3,133,22,165,23,105,0,133,23,197,253,240,4,176
460 data16,144,6,165,22,197,252,176,8,169,44,32,45,199,76,246,12,96,169,32
470 data32,45,199,160,0,32,163,13,41,127,32,45,199,200,32,163,13,41,127,208
480 data2,169,32,32,45,199,160,4,24,165,252,105,5,133,22,165,253,105,0,133
490 data23,32,163,13,24,101,22,133,22,169,0,101,23,133,23,32,163,13,24,101
500 data22,133,22,169,0,101,23,133,23,160,2,32,163,13,24,101,252,8,133,254
510 data200,32,163,13,40,101,253,133,253,165,254,133,252,96,165,252,133,250
520 data165,253,133,251,76,182,13,165,22,133,250,165,23,133,251,169,250,162
530 data1,32,116,255,96,133,250,132,251,160,4,32,182,13,133,103,136,32,182
540 data13,133,102,136,32,182,13,133,101,136,32,182,13,133,104,9,128,133
550 data100,136,32,182,13,133,99,96
560 scnclr sp
570 if s=47090 then 600
580 char 1,sx,sy,"fehler in datazeilen !!!"
590 char 1,sx,sy+2,"differenz = "+str$(47090-s)
600 end
Aus dem Directory laden
Wird ein Programm mit »DSAVE"NAME[SHIFT+SPACE]:"« gespeichert dann findet man im Directory »"Name":« vor. Es kann nun nach <F3> einfach durch Anfahren mit dem Cursor und <F2> + <RETURN> geladen werden. Mit dem RENAME-Befehl lassen sich natürlich schon vorhandene Programme entsprechend umbenennen.
(Gerhard Seebauer/dm)Den Zehnerblock sinnvoll belegen
Das nächste Programm (Listing 12) demonstriert den Gebrauch der Interruptroutine und der Tastaturbelegung des C 128 anhand einer Neubelegung des Zehnerblocks bei gedrückter SHIFT-Taste.
Will man DATA-Werte eingeben, so kommt einem doch der Zehnerblock des C 128 sehr gelegen. Um diesen Vorteil auch bei der Assemblerprogrammierung nutzen zu können, fehlt es jedoch an den Buchstaben A bis F. Weiterhin ist zu bemängeln, daß es beim eingebauten Monitor zu Problemen kommt, wenn man einen Teil disassembliert und anschließend verändern will. Stehen hinter dem neu Eingegebenen noch Zeichen, so akzeptiert der Monitor die Eingabe nicht und gibt statt dessen ein mit der Zeit nervendes Fragezeichen aus. Eine Verbesserung der Belegung der Zehnerblock-Tasten, besonders, wenn man mit dem Monitor arbeitet, bewirkt das Programm »10'ER BLOCKER«. Dabei wird lediglich die SHIFT-Version der 14 Zehnerblock-Tasten neu belegt. Die Belegung ohne SHIFT bleibt gleich (Bild 1 zeigt die neue Belegung des Zehnerblocks, gedrückt mit SHIFT).
Untergebracht sind die Buchstaben A bis F, das Komma sowie die folgenden Zeichen: »$«, »%«, »&«, »/« und »*«. Die Null-Taste ergibt, gedrückt mit SHIFT, zwei Nullen (00). Der RETURN-Taste wird in diesem Fall ein Doppelpunkt vorgeschoben. Befindet man sich im Monitor und verändert ein Assemblerlisting, so werden, falls man SHIFT und RETURN gleichzeitig drückt, die Zeichen hinter dem Cursor nicht beachtet.
![Tastenfeld des Zehnerblocks mit Ziffern und der zusätzlichen SHIFT-Belegung $, %, &, *, D, E, F, /, A, B, C, 00, Komma und :[ENTER]](147-1.jpg)
Die Tastaturbelegung
Zunächst muß man wissen, daß der C 128 mehrere Tastatur-Decodiertabellen besitzt. Diese Tabellen sind für die verschiedenen Tastenkombinationen mit SHIFT-, CONTROL- und COMMODORE-Tasten vorhanden. Außerdem gibt es weitere Tabellen für die DIN-Belegung, die sich von der ASCII-Version unterscheidet.
Die Tabellen, die uns interessieren, sind die, die in Verbindung mit der SHIFT-Taste gelten. Der Vektor, der auf diese Tabelle zeigt, liegt bei $340/$341. Man transferiert also die Tabelle, auf die dieser Vektor zeigt ($FAD9 bis $FB31), ins RAM, verändert die entsprechenden Werte und verbiegt den Vektor auf die neue Tabelle. Dies funktioniert jedoch nur, bis die ASCII/DIN-Taste gedrückt wird, da dann der Vektor wieder ins ROM auf die DIN-Decodiertabelle ($FD82 bis $FDDA) gestellt wird.
Auch eine Belegung der Null- und RETURN-Taste mit zwei Zeichen gleichzeitig ist so nicht zu realisieren. Die einzige vernünftige Lösung scheint über den Interrupt zu laufen.
Der Interrupt
Beim C 128 gibt es, ähnlich wie beim C 64, einen Interrupt-Vektor. Dieser Vektor liegt bei $314/$315 und zeigt auf die Routine bei $FA65. Diese Routine geht bis $FA7C und springt anschließend nach $FF33. Will man eigene Routinen in den System-Interrupt einbauen, so kopiert man zunächst diese ROM-Routine ins RAM (etwa nach $1300) und hängt die eigene Routine hinten an. Am Ende der eigenen Routine springt man nach $FF33, um den Interrupt mit dem Wiederherstellen der Register zu beenden. Aktiviert wird diese neue Routine, indem man den Interrupt-Vektor auf ihren Anfang lenkt.
Das Programm
Der Hauptteil dieses Programms läuft im Interrupt ab. Nachdem der Interrupt-Vektor ($314/$315) durch SYS DEC ("1700") auf die Hauptroutine bei $1700 gestellt wurde, werden dort zunächst die gleichen Unterroutinen aufgerufen, wie es die Interrupt-Routine bei $FA65 auch machen würde. Anschließend wird kontrolliert, ob der Zeiger auf die Tastatur-Decodiertabelle ins ROM zeigt. Ist dies der Fall, wird diese Tabelle nach $17A6 kopiert und die Neuerungen im Zehnerblock-Bereich vorgenommen. Nun muß nur noch der Vektor bei $340/$341 auf die neue Tabelle gestellt werden.
Als nächstes prüft das Programm, ob die SHIFT-Taste gedrückt ist. Dazu existiert in der Zeropage ein Flag. Ist die SHIFT-Taste gedrückt, so ist das 0. Bit von $D3 gesetzt. Trifft dies zu, so wird das letzte Zeichen aus dem Tastaturpuffer gelesen (Anzahl der Zeichen im Tastaturpuffer in $D0, Tastaturpuffer ab $349, maximale Länge des Tastaturpuffers bei $A20). Handelt es sich bei dem Zeichen um eine Null, so wird diese nochmals in den Tastaturpuffer geschoben. Ist dies jedoch die RETURN-Taste, so wird zunächst ein Doppelpunkt und anschließend ein RETURN in den Tastaturpuffer geschrieben.
Der Basic-Lader (Listing 12, bitte mit dem neuen Checksummer 128 eingeben) kann das 255 Byte lange Programm an jede beliebige Stelle speichern. Es empfehlen sich folgende Bereiche für das Maschinenprogramm: $0B00 bis $0DFF (Kassetten- und RS232-Ein- und Ausgabepuffer) sowie das freie RAM von $1300 bis $1F77. Gibt man keine Adresse an, so wird es automatisch in den Bereich von $1700 bis $17FF geschrieben.
Ebenfalls ist es möglich, die geSHIFTeten Zehnerblock-Tasten beliebig zu belegen. Dazu müssen lediglich in den DATA-Zeilen 410 und 420 des Listings 12 die entsprechenden ASCII-Zeichen verändert werden.
Beispiel: Will man die SHIFT-Kombination der Taste »9« im Zehnerblock mit dem Zeichen » # « anstelle des »&« belegen, so braucht man nur in der Zeile 420 das »&«-Zeichen durch das »#« zu ersetzen.
Für Maschinensprache-Experten ist in Listing 13 der kommentierte Quell-Code abgedruckt.
(Olaf Pfeiffer/dm)15 rem * * * 10'er blocker * * * 20 rem 25 rem olaf pfeiffer 1985 30 rem 35 rem 40 rem neubelegung der shift/10'er 50 rem block - tasten ; durch ver- 60 rem aendern der interruptrouti- 70 rem ne und der tastaturbelegung 80 rem 90 rem 100 bank15:poke53280,0:poke53281,0 110 printchr$(147);chr$(30) 120 print"an welche adresse (in hex) soll die":print 130 print"routine? platzbedarf:1 block (256 bytes)":print 140 print:input"adresse ($)";a$:fast 150 a=dec(a$):ifa=0thena=5888:rem $1700 155 rem 1.schleife fuer data-zahlen 160 forn=atoa+139:readz:poken,z:s=s+z:next 170 ifs<>17017thenprint"fehler in data's!!!":stop 175 rem 2.schleife fuer data-zeichen 180 forn=a+140toa+165:readz$:z=val(z$):ifz=0thenz=asc(z$) 190 poken,z:next 200 printchr$(147);"initialisieren mit:":print:print:print 210 print"bank15:sys"a;chr$(145);chr$(145);chr$(145) 215 rem anpassen an die adresse a 220 l=(a+166)and255:h=int((a+166)/256) 230 poke(a+2) ,(a+13)and255 240 poke(a+7) ,int((a+13)/256) 250 poke(a+67),l:poke(a+68),h 260 poke(a+80),(a+148)and255 270 poke(a+81),int((a+148)/256) 280 poke(a+83),(a+231)and255 290 poke(a+84),int((a+231)/256) 300 poke(a+91),l:poke(a+93),h 310 slow:end 320 data 120,169,13,141,20,3,169,23,141,21,3,88,96,216,32,36 330 data 192,144,18,32,248,245,32,208,238,173,13,220,173,4,10,74 340 data 144,3,32,6,64,173,65,3,201,240,144,56,174,0,255,169 350 data 15,141,0,255,172,64,3,132,254,172,65,3,132,255,160,0 360 data 177,254,153,166,23,200,192,89,208,246,142,0,255,160,0,185 370 data 148,23,153,231,23,200,192,18,208,245,162,166,160,23,142,64 380 data 3,140,65,3,165,211,106,144,22,166,208,240,18,189,73,3 390 data 201,48,208,14,236,32,10,176,6,232,157,73,3,134,208,76 400 data 51,255,201,141,208,249,236,32,10,176,244,169,58,157,73,3 410 data 169,13,208,229,"%","e",24,"b","d","$","a",27,"*","/" 420 data 10,141,"f","&","c",8,48,","
************** Interruptvektor veraendern 1700 sei ; Interrupt verbieten 1701 lda #$0d ; Interruptvektor bei $0314/$0315 1703 sta $0314 ; auf $170d stellen 1706 lda #$17 ; (normal: $fa65) 1708 sta $0315 ; 170b cli ; Interrupt wieder erlauben 170c rts ; und zurueck zur Einsprungsadresse ************** Interrupt Einsprung 170d cld ; 170e jsr $c024 ; 1711 bcc $1725 ; 1713 jsr $f5f8 ; Kopie der ROM-Interruptroutine 1716 jsr $eed0 ; von $fa65 bis $fa7c 1719 lda $dc0d ; 171c lda $0a04 ; 171f lsr ; 1720 bcc $1725 ; 1722 jsr $4006 ; ************** Neuer Teil der Interruptroutine 1725 lda $0341 ; Hi-Byte der aktuellen Tast.dec.tabelle 1728 cmp #$f0 ; zeigt in den ROM-Bereich ? ($fa o. $fd) 172a bcc $1764 ; Nein: weiter (ASCII DIN) 172c ldx $ff00 ; aktuelles Konfig.-register speichern 172f lda #$0f ; neue Konfiguration: 1731 sta $ff00 ; Kernal-ROM einschalten 1734 ldy $0340 ; aktuellen Zeiger auf Tastaturdecodier- 1737 sty $fe ; tabelle 2 in die Zeropage 1739 ldy $0341 ; ($0340/$0341) nach ($fe/$ff) 173c sty $ff ; 173e ldy #$00 ; Schleife zum transferieren der 1740 lda ($fe),y ; aktuellen Tastaturdecodiertabelle 2 1742 sta $17a6,y ; (ASCII oder DIN) an das Ende dieser 1745 iny ; Routine ($17a6) 1746 cpy #$59 ; laenge der Tabelle 1748 bne $1740 ; 174a stx $ff00 ; alte Speicherkonfig. wieder herstellen 174d ldy #$00 ; 174f lda $1794,y ; Schleife zum Einbauen der neuen 1752 sta $17e7,y ; Zeichen in die neue Tastaturdecodier- 1755 iny ; tabelle 2 1756 cpy #$12 ; 1758 bne $174f ; 175a ldx #$a6 ; Zeiger ($0340/$0341) auf neue 175c ldy #$17 ; Tastaturdec.tabelle ($17a6) 175e stx $0340 ; 1761 sty $0341 ; ************** Pruefen auf SHIFT/RETURN o. -/"0" 1764 lda $d3 ; Pruefen auf SHIFT-Taste 1766 ror ; (0.Bit gesetzt=SHIFT gedrueckt) 1767 bcc $177f ; nicht gedrueckt: Ende 1769 ldx $d0 ; Anzahl Zeichen im Tastaturpuffer 176b beq $177f ; leer: Ende 176d lda $0349,x ; Zeichen aus Tastaturpuffer holen 1770 cmp #$30 ; gleich ASCII "0" ? 1772 bne $1782 ; nein: Testen auf RETURN 1774 cpx $0a20 ; Tastaturpuffer voll ? 1777 bcs $177f ; ja: Ende 1779 inx ; Anzahl der Zeichen im Puffer um 1 erhoehen 177a sta $0349,x ; Zeichen in Tastaturpuffer schreiben 177d stx $d0 ; Anzahl der Zeichen im Puffer abspeichern 177f jmp $ff33 ; ****** Ende ****** Ruecksprung zum ROM-IRQ 1782 cmp #$8d ; Zeichen = SHIFT/RETURN ? 1784 bne $177f ; Nein: Ende 1786 cpx $0a20 ; Noch Platz im Tastaturpuffer ? 1789 bcs $177f ; Nein: Ende 178b lda #$3a ; ASCII ":" 178d sta $0349,x ; ":" in den Tastaturpuffer 1790 lda #$0d ; ASCII RETURN 1792 bne $1779 ; Unbedingter Sprung 1794 .byte 25 45 18 42 44 24 41 1b ; neue Zeichen der Tastatur- 179c .byte 2a 2f 0a 8d 46 26 43 08 ; decodiertabelle 2 17a4 .byte 30 2c ; 17a6 - 17ff ; Platz fuer neue Tastaturdecodiertabelle
Fehlermeldungen, die nicht im Handbuch stehen
Auch das überraschend dicke Commodore-Handbuch zum C 128 vermag nicht alles zu beantworten. So hat wohl schon so mancher, dem zum Beispiel die Fehlermeldung UNRESOLVED REFERENCE ERROR unterkam, nachgeschlagen, gesucht und doch nicht gefunden...
Insgesamt existieren fünf Fehlermeldungen, die nicht im Handbuch zu finden sind und auch sonst nirgendwo erwähnt werden. Dies sind die Meldungen mit den Nummern 37 bis 41, die Sie auch mit der Funktion ERR$(ER) ansehen können. Hier erfahren Sie nun endlich, was die Meldungen im einzelnen bedeuten:
ER 37: BEND NOT FOUND
Dieser Fehler tritt auf, wenn der Interpreter zu einem BEGIN kein BEND findet. Hat man zum Beispiel eine Befehlssequenz wie
IF (Bedingung) THEN BEGIN
und die Bedingung ist nicht erfüllt, so sucht der Interpreter nach dem BEND. Ist im nachfolgenden Programm vor dem nächsten BEGIN kein BEND mehr vertreten, so erhalten Sie die oben genannte Fehlermeldung mit der Zeilennummer der letzten Basic-Zeile. Drückt man die HELP-Taste, so wird die ganze Zeile als falsch angegeben. Sehr ärgerlich kann der Fehler sein, wenn in einem Programm mehrere BEGIN und BEND existieren. Dann müssen Sie Ihr Programm von Hand durchsuchen. Als Beispiel sehen Sie Listing 14, das die Wurzel einer Zahl berechnen soll. Die Wurzel kann aber nur von einer positiven Zahl gezogen werden. Also muß bei negativen Zahlen auf die Berechnung verzichtet werden. In diesem Fall soll zum END verzweigt werden. Ihnen ist sicher schon aufgefallen, daß in Zeile 50 das BEND fehlt. Lassen Sie das Programm einmal laufen. Geben Sie eine positive Zahl ein, so arbeitet die Routine richtig. Ist Ihre Zahl negativ, so erhalten Sie ein BEND NOT FOUND ERROR IN 540, also der letzten REM-Zeile. Fügen Sie das BEND ein, so arbeitet das Programm ordnungsgemäß.
Geben Sie nun einmal
RENUMBER 10000,10000
ein. Damit sind wir schon beim nächsten Fehler.
ER 38: LINE NUMBER TO LARGE
Auf den ersten Blick könnte man vermuten, daß dieser Fehler auftritt, wenn man eine zu große Zeilennummer eingibt. Dies ist aber nicht der Fall. Der Interpreter würde hier einen SYNTAX ERROR ausgeben. Die oben genannte Fehlermeldung tritt beim RENUMBER-Befehl auf, wenn bei der Umnumerierung Zeilennummern auftreten würden, die zu hoch sind. Die höchste erlaubte Zeilennummer ist 63999. Falls Sie bei Listing 14
RENUMBER 10000,10000
eingeben, so würde in der siebten Programmzeile schon die Zeilennummer 70000 auftreten.
ER 39: UNRESOLVED REFERENCE
Diese Fehlermeldung bezieht sich auch nur auf den RENUMBER-Befehl. Es handelt sich hierbei um das Gegenstück zum UNDEF'D STATEMENT ERROR. Es wird die Nummer der Zeile ausgegeben, in der sich ein Sprungbefehl befindet (GOTO, GOSUB), der sich auf eine Zeile bezieht, die nicht existiert. Fügen Sie beispielsweise
55 GOSUB 1000
in Listing 14 ein. Wollen Sie das Programm jetzt umnumerieren, erhalten Sie einen UNRESOLVED REFERENCE ERROR IN 55.
Allerdings kann man sich diesen Fehler zunutze machen. Haben Sie beispielsweise ein langes Basic-Programm, aus dem Sie jetzt eine Zeile löschen müssen, besteht die Gefahr, daß diese Zeile über GOTO oder GOSUB angesprungen werden könnte. Lassen Sie das Programm laufen, so erhalten Sie einen UNDEF'D STATEMENT ERROR. Angenommen, Listing 14 enthielte ein Unterprogramm ab Zeile 1000, das Sie jetzt gelöscht haben. Sie wissen aber nicht, von wo es angesprungen wurde. Eigentlich hätte man im komfortableren Basic 7.0 einen FIND-Befehl erwarten können. Leider ist das nicht der Fall. Um nun die Zeilen zu finden, die die Zeile 1000 anspringen, fügen Sie an das Listing 14 beispielsweise die Zeile
63000 GOTO 63001
an, wobei die Zeile 63001 nicht existieren darf. Geben Sie jetzt einfach RENUMBER ein. Daraufhin erhalten Sie einen UNRESOLVED REFERENCE ERROR IN 55. Drücken Sie die HELP-Taste, so haben Sie die erste Stelle gefunden, von der aus das Unterprogramm angesprungen wurde. Ändern Sie diese Zeile und geben Sie wieder RENUMBER ein, bis Sie einen UNRESOLVED REFERENCE ERROR IN 63001 erhalten. Dann sind alle Stellen korrigiert. Vielleicht haben Sie sich schon gefragt, was die Zeile 63000 bewirken soll? Nun, solange das Programm nicht einwandfrei ist, beginnt der Interpreter nicht mit der eigentlichen Umnumerierung.
Die Fehlermeldungen 40 und 41 (UNIMPLEMENTED COMMAND ERROR und FILE READ ERROR) konnten noch nicht genau entschlüsselt werden, da die nähere Funktion vom Namen her vielleicht erkennbar ist, aber noch keine stichhaltigen Beweise für Vermutungen vorliegen. Wenn Sie diese Fehlermeldungen schon entlarvt haben, sind wir jederzeit für Tips dankbar.
(Thomas Hansch/dm)10 input" geben sie eine zahl ein ";a 20 if a>=0 then begin 30 w=sqr(a) 40 print" die wurzel von";a;"ist";w 60 end 70 : 80 : 500 rem wenn die zahl groesser oder 510 rem gleich 0 ist, soll die wurzel 520 rem berechnet werden. ist die zahl 530 rem kleiner 0 so soll nichts ge- 540 rem macht werden.
Lissajous-Figuren
Ein kleines Programm, das das Grundgerüst zum Berechnen und Zeichnen von Lissajous-Figuren ermöglicht (Listing 15, bitte mit dem neuen Checksummer 128 eingeben). Durch Verändern verschiedener Werte (siehe REM-Zeilen) können Sie alle möglichen Figuren erzeugen.
(Matthias Jäger/dm)10 graphic 1,1 20 width2 30 x0=160:y0=100:a=150:b=95 40 d=5:n=3:m=4:t0=~/180 50 color0,1:color4,2:color1,2 60 forw=0to180*dstepd 70 t=w*t0 80 x=x0+a*cos(n*t) 90 y=y0+b*sin(m*t) 100 ift<>0thendraw1,x1,y1tox,y 110 x1=x:y1=y 120 nextw 130 color1,3 140 paint1,0,0 150 rem figur 1 - d=5 , n=3 , m=4 160 rem figur 2 - d=77 , n=1 , m=2 170 rem figur 3 - d=77 , n=2 , m=1 180 rem figur 4 - d=77 , n=2 , m=3 190 rem figur 5 - d=77 , n=3 , m=2 200 rem figur 6 - d=94 , n=1 , m=1 210 rem figur 7 - d=94 , n=2 , m=3 220 rem figur 8 - d=94 , n=1 , m=2 230 rem figur 9 - d=94 , n=1 , m=3
Noch ein paar PEEKs und POKEs
| POKE 160,255 | – | Zurückstellen der internen Uhr (TI$ = 000000) |
| PEEK (199) | – | zeigt an, in welcher BANK ein File abgelegt ist |
| POKE 216,0 | – | ersetzt GRAPHIC 0,1 |
| POKE 216,1 | – | ersetzt GRAPHIC 1,1 |
| POKE 216,64 | – | ersetzt GRAPHIC 2,1 |
| POKE 216,128 | – | ersetzt GRAPHIC 3,1 |
| POKE 216,254 | – | ersetzt GRAPHIC 4,1 |
| POKE 241,X | – | Ändern der Schriftfarbe (X = 0 bis 15) |
| POKE 243,1 | – | Einschalten des Revers-Modus |
| POKE 243,0 | – | Ausschalten des Revers-Modus |
| POKE 246,255 | – | Aktivieren des automatischen Einfügemodus (ESC-A) |
| POKE 246,1 | – | Desaktivieren des automatischen Einfügemodus (ESC-C) |
| POKE 247,64 | – | Schaltet NO-SCROLL-Taste ab |
| POKE 247,0 | – | NO-SCROLL-Taste wieder normal |
| POKE 247,255 | – | Unterbinden der Groß-/Kleinschrift-Umschaltung mit COMMODORE/SHIFT |
| POKE 248,254 | – | Der Bildschirm rollt sich beim LISTen auf (ESC-M) |
| POKE 249,255 | – | Schaltet Klingelzeichen (CTRL-G) ab |
| POKE 249,0 | – | Schaltet das Klingelzeichen wieder ein |
| POKE 774,102:POKE 775,224 | – | Listschutz |
| POKE 774,81 :POKE 775,81 | – | Hebt den Listschutz wieder auf |
| POKE 820,189 | – | ESC wird im Quote-Modus sichtbar |
| POKE 820,185 | – | ESC reagiert wieder normal |
| POKE 2594,0 | – | Keine Tasten-Wiederholung bis auf DEL, INST und CRSR |
| POKE 2594,64 | – | Alle Tasten haben Auto-Repeat |
| POKE 2594,128 | – | Normalzustand Tasten-Repeat |
| POKE 2598,64 | – | bringt den Cursor zum Stillstand |
| POKE 2598,0 | – | Cursor blinkt wieder |
| POKE 2603,128 | – | Fester Cursor im 80-Zeichen-Modus |
| POKE 2603,96 | – | Blinkender Cursor im 80-Zeichen-Modus |
| POKE 2603,32 | – | Abgeschalteter Cursor im 80-Zeichen-Modus |
| POKE 2603,64 | – | Schnell blinkender Cursor im 80-Zeichen-Modus |
| SYS 45096 | – | Monitor wird aktiviert |
Laufschrift mit Sprites
Diese auf Spritebasis arbeitende Laufschrift, die jeder Anwender in seine Programme einbauen kann, läßt sich ohne viel Aufwand realisieren. Durch die Interruptsteuerung der Sprites wird der Programmablauf nicht beeinflußt. Dazu ist nur folgendes kleine Programm nötig:
10 input"farbnummer (1-16)";f 20 input"geschwindigkeit (1-6)";g 30 input"text (bis 24 zeichen)";i$:scnclr 40 graphic 1,1:char 1,0,0,i$ 50 sshape a$,0,0,16,20:sprsav a$,1 60 sshape b$,23,0,39,20:sprsav b$,2 70 sshape c$,47,0,63,20:sprsav c$,3 80 sshape d$,71,0,87,20:sprsav d$,4 90 sshape e$,95,0,111,20:sprsav e$,5 100 sshape f$,119,0,135,20:sprsav f$,6 110 sshape g$,143,0,159,20:sprsav g$,7 120 sshape h$,167,0,183,20:sprsav h$,8 130 scnclr:b=0:for a=1to8:sprite a,1,f,1,1,0:b=b+40 140 movspr a,b,51:movspr a,270#g:next
Bildschirmhardcopy 80-Zeichen-Schirm
Der Video-Controller für den 80-Zeichen-Schirm verwaltet einen eigenen 16 KByte großen Speicher, der außerhalb des normalen Adreßbereiches des Prozessors liegt. Das bedeutet, daß der Video-Speicher nur indirekt angesprochen werden kann, hat aber den Vorteil, daß er keinen Arbeitsspeicher belegt (normalerweise liegt der Bildschirmspeicher innerhalb des VDC-RAMs von $0000 bis $07CF).
Diese kleine Routine erlaubt eine Hardcopy des 80-Zeichen-Bildschirms.
Arnulf Bechmann/dm)10 close 4:open 4,4,1
20 a=dec("d600"):d=a+1
30 for j=0 to 1999 step 80
40 for y=0 to 79
50 by=j+y:hb=int(by/256):lb=by-hb*256
60 poke a,18:poke d,hb
70 poke a,19:poke d,lb
80 poke a,31:b=peek(d)
90 if b=>1 and b<=26 then b=b+96
100 print#4,chr$(b);
110 next y,j
120 print#4:close4:end