C 128
Tips & Tricks

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
Listing 1. »DATAGEN 128« – erzeugt ein Basic-Ladeprogramm. Bitte verwenden Sie zur Eingabe den Checksummer 128.
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
Listing 2. So könnte ein mit DATAGEN 128 erzeugtes Listing aussehen

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"
Listing 3. Ein Programm zum Austauschen des Punktes mit einem Komma auf der Zehnertastatur

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 ************************************
Listing 4. Nun blinkt der Cursor auch bei GET. Bitte beachten Sie den Checksummer 128.

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
Listing 5. Mehrere Bildschirme austauschen
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
Listing 6. Ein Demo-Programm, das Ihnen die Fähigkeiten des Bildschirm-Vertauschens aufzeigt

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
Listing 7. »Merge« – Verbinden mehrerer Basic-Programme

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
Tabelle 1. Die wichtigsten Kernel-Routinen und ihre Funktion

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
Listing 8. »Kernel 128« – Bitte mit dem MSE im C 64-Modus eingeben
10 open8,8,8,"@0:kernal,p,w"
20 sys9*4096:.opt p,o8:*= $c00
30 ; **********************************
40 ; *                                *
50 ; *           k e r n a l          *
60 ; *                                *
70 ; *        von frank probst        *
80 ; *                                *
90 ; *         im februar '86         *
100 ;*                                *
110 ;**********************************
120 conf   = $ff00                    ;konfigurationsregister
130 flag   = 996                      ;nr. der kernalroutine
140 jsrfar = $2cd                     ;jsrfar routine
150 jmpfar = $2e3                     ;jmpfar routine
160 ramcr  = $d506                    ;ramkonfigurationsreg.
170 usrvek = $1219                    ;vektor des usrbefehls
180 peek   = $ff50                    ;begin der peek/poke-routinen
190 ;
200 ;        ** kernal **
210 ; nummer der kernalroutine in 996
220 ;     aufruf durch jsr $c00
230 ;      von beliebiger bank
240 ;
250            sta 6                  ;register
260            stx 7                  ;in die
270            sty 8                  ;zeropage
280            lda #15                ;bank 15
290            sta 2                  ;in zp
300            lda #$44               ;lo-byte von sprungtabelle
310            sta 4                  ;in zp
320            lda #$ff               ;hi-byte von sprungtabelle
330            sta 3                  ;in zp
340            lda flag               ;flag lesen
350            cmp #20                ;kleiner als
360            bcc kleiner            ;20 dann bei kleiner weiter
370            inc 4                  ;lo-byte von sprungtabelle hochzaehlen
380 kleiner    asl                    ;akku=akku*2
390            adc flag               ;akku=akku+flag
400            adc 4                  ;akku=akku+lo-byte
410            sta 4                  ;akku in 4
420 ;
430 ;     ** jsrfar routine **
440 ;    parameteruebergabe wie        
450 ;    normale jsrfar-routine
460 ;   jedoch von jeder bank aus
470 ;    einfach durch jsr $c23
480 ;
490 jrfar      lda conf               ;akku=configuration
500            pha                    ;sichern
510            lda #0                 ;bank 15
520            sta conf               ;in conf
530            jsr jsrfar             ;jsrfar anspringen
540            pla                    ;conf holen
550            sta conf               ;wieder herstellen
560            lda 5                  ;akku=status
570            pha                    ;auf stack
580            lda 6                  ;register
590            ldx 7                  ;wieder
600            ldy 8                  ;herstellen
610            plp                    ;status-reg. herstellen
620            rts                    ;ruecksprung
630 ;
640 ;     ** initialisierung **
650 ;   vergroessert die common-area
660 ;auf 4k byte. passt basic zeiger an
670 ; und verschiebt peek/poke-routine
680 ;
690 init       lda #0                 ;bank 15
700            sta conf               ;in conf
710            lda ramcr              ;ram-configurations-reg.
720            ora #%00000101         ;4k ram gemeinsam
730            sta ramcr              ;von $0000 - $0fff
740            lda #0                 ;basic-
750            sta 47                 ;zeiger
760            sta 49                 ;an
770            lda #$10               ;neue
780            sta 48                 ;situation
790            sta 50                 ;anpassen
800 ;
810 ;  ** initialisiert usr-vektor **
820 ;bei usr erfolgt sprung nach $0f000
830 ;
840            lda #<start            ;lo-byte in
850            sta usrvek             ;usrvektor
860            lda #>start            ;hi-byte in
870            sta usrvek+1           ;usrvektor
880 ;
890 ; **verschiebt peek/poke-routinen**
900 ;
910            lda #$7f               ;bank 1
920            sta conf               ;in conf
930            ldy #end-peekr         ;schleifenzaehler
940 loop       lda peekr,y            ;verschieben der
950            sta peek,y             ;peek/poke-routinen
960            dey                    ;y=y-1
970            bpl loop               ;noch nicht fertig dann loop
980            rts                    ;ruecksprung
990 ;
1000 ;     ** nach usr springen **
1010 ;
1020 start      lda #$3f              ;bank 0
1030            sta conf              ;in conf
1040            jmp $f000             ;sprung nach $0f000
1050 ;
1060 ;      ** peek aus bank 1 **
1070 ;       holt byte aus nicht
1080 ;        erreichbarem  ram
1090 ; eingabeparameter :
1100 ; x-reg =  lo-byte der peekadresse
1110 ; y-reg =  hi-byte der peekadresse
1120 ;
1130 ; ausgabeparameter :
1140 ; akku  =  gelesenes byte
1150 ;
1160           sta lob+1              ;zpadresse fuer lo-byte ablegen
1170           sta hib+1              ;zpadresse fuer hi-byte ablegen
1180           inc hib+1              ;hi-byte=hi-byte+1
1190           lda conf               ;akku=configuration
1200           pha                    ;sichern
1210           lda #$7e               ;bank 1+i/o
1220           sta conf               ;in conf
1230 lob       lda 0                  ;lo-byte der zpadresse
1240           sta pevek-peekr+peek+1 ;lo-byte der adresse
1250 hib       lda 0                  ;hi-byte der zpadresse
1260           sta pevek-peekr+peek+2 ;hi-byte der adresse
1270           jsr peek               ;sprung nach peekroutine
1280           sta flag               ;zwischenspeichern
1290           pla                    ;configuration holen
1300           sta conf               ;und herstellen
1310           lda flag               ;ergebnis nach akku
1320           rts                    ;ruecksprung
1330 ;
1340 ;      ** poke in bank 1 **
1350 ;     schreibt byte in nicht
1360 ;        erreichbares ram
1370 ; eingabeparameter :
1380 ; x-reg =  lo-byte der pokeadresse
1390 ; y-reg =  hi-byte der pokeadresse
1400 ; akku  =  der zu speichernde wert
1410 ;
1420 ; ausgabeparameter = keine
1430 ;
1440           sta flag               ;zwischenspeichern
1450 pozpa     lda #$ff               ;poke zpadresse
1460           sta lobp+1             ;zpadresse lo-byte ablegen
1470           sta hibp+1             ;zpadresse hi-byte ablegen
1480           inc hibp+1             ;hi-byte=hi-byte+1
1490           lda conf               ;akku=configuration
1500           pha                    ;sichern
1510           lda #$7e               ;bank 1+i/o
1520           sta conf               ;herstellen
1530 lobp      lda 0                  ;lo-byte lesen
1540           sta povek-peekr+peek+1 ;lo-byte der adresse
1550 hibp      lda 0                  ;hi-byte lesen
1560           sta povek-peekr+peek+2 ;hi-byte der adresse
1570           lda flag               ;gesicherten wert holen
1580           jsr poker-peekr+peek   ;poke anspringen
1590           pla                    ;gesicherte configuration holen
1600           sta conf               ;herstellen
1610           rts                    ;ruecksprung
1620 ;
1630 ;     ** jmpfar routine **
1640 ;    parameteruebergabe wie
1650 ;    normale jmpfar-routine
1660 ;   jedoch von jeder bank aus
1670 ;    einfach durch jsr $cd0
1680 ;
1690           lda #0                 ;bank15
1700           sta conf               ;herstellen
1710           jmp jmpfar             ;sprung nach jmpfar
1720 ;       peekroutine
1730 peekr     sei                    ;interrupts aus
1740           lda ramcr              ;akku=ram-configurations-register
1750           and #%11110011         ;keine common-area
1760           sta ramcr              ;herstellen
1770 pevek     lda $ffff,y            ;byte holen
1780           sta $fff0              ;zwischenspeichern
1790           lda ramcr              ;akku=ramcr
1800           ora #%00000100         ;common-area an
1810           sta ramcr              ;und herstellen
1820           lda $fff0              ;akku=ergebnis
1830           cli                    ;irq an
1840           rts                    ;ruecksprung
1850 ;    poke
1860 poker     sta $fff0              ;sichern
1870           sei                    ;irq aus
1880           lda ramcr              ;akku=ramcr
1890           and #%11110011         ;common-area aus
1900           sta ramcr              ;herstellen
1910           lda $fff0              ;byte holen
1920 povek     sta $ffff,y            ;schreiben
1930           lda ramcr              ;akku=ramcr
1940           ora #%00000100         ;common-area an
1950           sta ramcr              ;herstellen
1960           cli                    ;irq an
1970 end       rts                    ;ruecksprung
1980          .end
1990 close8
2000 save"@:kernal.s",8
2010 verify"kernal.s",8

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
Listing 9. Ein Boot-Sektor mit 17 Möglichkeiten

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
Listing 10. »DumpV 128« – Ausgabe nichtindizierter Variablen
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
Listing 11. »DumpA 128« – Ausgabe indizierter Variablen

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]
Bild 1. Die Tastenbelegung der geSHIFTeten Tasten des Zehnerblocks

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,","
Listing 12. Neubelegung der geSHIFTeten Tasten des Zehnerblocks
************** 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
Listing 13. Der kommentierte Quellcode zum 10’er-Blocker

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.
Listing 14. Ein Versuchs-Programm, um Fehlermeldungen zu erklären (siehe Text)

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
Listing 15. Mit diesem kleinen Programm können Sie bezaubernde Lissajous-Figuren erzeugen. Bitte benutzen Sie zur Eingabe den Checksummer 128.

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
(Michael Bartels/Helmut Schottmüller/dm)

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
(Karl-Heinz Montag/dm)

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
PDF Diesen Artikel als PDF herunterladen
Mastodon Diesen Artikel auf Mastodon teilen
← Vorheriger ArtikelNächster Artikel →