Archiv der Kategorie: CBM

Schneller, höher, weiter, lautet die Maxime im Sport. Schneller, bunter, klangvoller, könnte man das auf Computer übertragen. Für die Multiplattform-Programmierung kann sich das allerdings als (kleines) Problem erweisen, z.B. wenn man mit einfachen FOR-NEXT-Warteschleifen arbeitet. Der heutige Beitrag in dieser Reihe widmet sich dem „schneller“, wobei man sich in einem Irrtum befindet, wenn man meint, dass neuere 8-Bit-Rechner schneller als ältere gewesen sein müssen, und dem „Schleifenproblem“ (was uns wieder mit den spezifischen Eigenheiten der Rechner konfrontieren wird).

Die CPU: mal schnell, mal langsam

Grundsätzlich wird die Rechengeschwindigkeit durch den Takt des Prozessors (der CPU) bestimmt. Der ist je nach Rechnertyp mal schneller, mal langsamer. Vom C64 weiß man, dass schon zwischen einem NTSC- und einem PAL-Gerät merkliche Unterschiede bestehen. Ein Plus/4 taktet (scheinbar) schneller, ein C128 (ohne VIC-Bildschirmanzeige) ebenfalls. Doch der CPU-Takt ist nur die halbe Wahrheit und manchmal führt er uns auch an der Nase herum.

Tabelle 1: Vergleich der CPU-Taktraten der Commodore-Rechner:

Anmerkungen:
PET/CBM: der Takt ist unabhängig vom Videochip und daher gibt es kein PAL oder NTSC.
VC 20: Kein Fehler! Die PAL-Version ist schneller.
P 500: Die verfügbaren Quellen sprechen alle nur von 1 MHz; da jedoch ein VIC II verbaut wurde, ist zu vermuten, dass die gleichen Werte wie für den C64 gelten.
Plus/4: Die hohe Taktrate (hier gibt es aus unterschiedlichen Quellen leicht variierende Angaben) führt in die Irre. Im sichtbaren Bereich des Bildschirms wird auf halbe Taktrate zurückgeschaltet, da TED und CPU sich den Systemtakt teilen müssen. Die effektive mittlere Taktrate liegt wohl irgendwo bei 1 MHz. Wegen unterschiedlicher Anzahl von Bildern/Sekunde zeigt die mittlere Taktrate eine weitere Abhängigkeit von der jeweiligen Videonorm (PAL/NTSC).

BASIC: weniger ist manchmal mehr

Bei Multiplattform-Programmen ist die Geschwindigkeit des BASICs entscheidend. Diese ist von zusätzlichen Faktoren abhängig, die sich durchaus stärker als die Variatonen in der Taktrate auswirken können. Zum einen spielt die Komplexität des Interpreters eine gewichtige Rolle. Ein mächtigeres BASIC (wie beim C128 BASIC 7.0) verlangsamt die Ausführung, spezielle Implementierungen von Grundfunktionen wie die verbesserte Garbage Collection ab BASIC 4.0 beschleunigt Programme mit vielen Stringoperationen. Zum anderen spielt die Komplexität der Hardware eine Rolle. Beim C64 braucht sich der Interpreter nicht groß mit Bankswitching herumzuschlagen, beim C128 hat das jedoch durchaus einen spürbareren Einfluss. Auch beim P500 wirkt sich das komplizierte Bankswitching geschwindigkeitshemmend aus.

Für einen Praxistest verwenden wir folgendes Programm:

10 t1=ti:fori=1to10000:next:t2=ti
20 print (t2-t1)/60"sekunden"

Zur Erinnerung: Die reservierte Variable TI gibt die Zeit in sechzigstel Sekunden (1/60) an. Der Zähler für TI wird initialisiert (auf Null gesetzt), wenn der Rechner startet und auch jedesmal wenn man die Anweisung TI$="000000" ausführt. TI$ gibt die seit dem letzten Initialisieren vergangene Zeit in Stunden, Minuten und Sekunden an („hhmmss“).

Mir ist klar, dass eine einfache Schleife nicht die ganze Wahrheit über die Leistungsfähigkeit eines Rechners offenbart. Es handelt sich mit Absicht um einen simplen Vergleich. Ich tröste mich damit, dass er auf jeden Fall besser ist als ein Vergleich mit PRINT-Operationen, da dabei die zusätzlichen Berechnungen für das Setzen des Farbrams die Ergebnisse einseitig beeinflussen würden.

In Ermangelung der erforderlichen Hardwarevielfalt wurden alle Messungen mit dem Emulator VICE unter Win98 durchgeführt. Daher sind die Angaben mit Vorsicht zu genießen. Zudem zeigten sich in Einzelfällen Probleme mit dem Emulator, die einen eigenen Artikel wert sind.

Tabelle 2 und 3: Zeitverbrauch der FOR-NEXT-Schleife mit 10.000 Durchläufen:

Anmerkung: Die Messungen für PET 2001 und CBM 3032 mussten mit VICE 2.2 statt der aktuellen Version 2.4 durchgeführt werden, da VICE 2.4 bei diesen Rechnern eine Bildwiederholrate von 56 fps statt 50 fps anzeigt und folglich andere Berechnungszeiten als VICE 2.2 liefert.

Anmerkung: Für den P 500 sind derzeit keine Angaben zu NTSC möglich, da die Umstellung auf NTSC unter VICE 2.4 dazu führt, dass der Emulator nur noch mit 87%iger Geschwindigkeit läuft, dies beeinträchtigt die Messung. Unter VICE 2.2 ist im Menü keine Auswahl zwischen PAL und NTSC vorhanden. Beim Plus/4 ist deutlich der Effekt der Videonorm zu erkennen. Durch die höhere Bildfrequenz (60 Hz) unter NTSC wirkt sich der Bremseffekt des TED stärker aus als unter PAL (50 Hz). Beim C128 ist zum Vergleich zusätzlich der Wert für den 2 MHz-Modus in Klammern angegeben.

Für Experten sei noch angemerkt, dass der C128 auch im 40-Zeichen-Modus mit ein paar Tricks auf ca. 1,3 MHz beschleunigt werden kann. Die Schleife braucht dann ca. 11,74 s (PAL). Man kann auch noch den BASIC-IRQ deaktivieren und weitere Millisekunden gewinnen, Aber das alles bringt den C128 nur in die Nähe der Geschwindigkeit eines C64.

Kurze Zwischenbilanz: Komplexität und verrotztes Design (Plus/4) lassen die neueren Rechner gegenüber den alten CBMs alt aussehen. Hier gilt: weniger ist mehr. Die Unterschiede in der Effektivgeschwindigkeit sind erheblich. Blinkeffekte oder Anzeigezeiten für Info-Texte sollte man daher nicht mit einer einfachen FOR-NEXT-Schleife lösen!

Der Turbo: schlimmer geht immer

Wer jetzt noch meint, man könne diese „leichten“ Variationen in der Geschwindigkeit ignorieren, der sollte bedenken, dass es noch andere Gründe gibt, es nicht zu tun. Die passenden Stichworte sind SuperCPU, Chameleon im Turbo-Mode und BASIC-Compiler!

Die Zeit: ein steter Fluss

Die Lösung des Warteschleifenproblems ist simpel (oder auch nicht, wie wir später sehen werden) und nicht neu! BASIC 2.0 liefert uns seit seinen Anfängen das Werkzeug, das wir dazu brauchen: TI

Beispiel 1: Eine simple Warteschleife, wie sie vielleicht für einen Blinkeffekt genutzt werden könnte:
for i=1 to 1000 : next i

Auf einem C64 erhalten wir eine Verzögerung von ca. einer Sekunde. Der C128 benötigt für die gleiche Schleife allerdings gute 1,5 Sekunden. Derartige Abweichungen sind, vorsichig ausgedrückt: „unschön“.

Immer exakt eine Sekunde liefert hingegen dieses Programmschnipsel:
10000 t=ti+59:fori=0to1:i=-(ti>t):next:return

Man kann das auch so schreiben:
10000 t=ti+60:fori=0to1:i=-(ti=>t):next:return

So geht’s noch eleganter:
10000 t=ti+60:fori=-1to0:i=ti<t:next:return

Für einen relativen Vergleich der Rechnergeschwindigkeiten kann man ermitteln, wie häufig eine Schleife durchlaufen wird. Dazu baut man einen Zähler ein. Integriert man weitere Elemente in die Schleife kann man so auch die verbleibenden Ressourcen abschätzen. Zur Demonstration mag sich die simple Schleife selbst genügen. Die nachstehende Tabelle basiert auf folgendem Programm:

10 x=0:t1=ti:t=ti+60:fori=-1to0:i=ti<t:x=x+1:next:t2=ti
20 print (t2-t1)/60"sekunden", x"loops"

Anmerkung: Die Zahlen gelten bei den farbfähigen Computern für die PAL-Geräte. Zum Vergleich ist beim Plus/4 zusätzlich der Wert für NTSC, beim C128 der für den 2 MHz-Modus, in Klammern angegeben.

Beispiel 2: Eine Warteschleife mit Abbruchoption, wie sie vielleicht für die Anzeige von Infotexten genutzt werden könnte. Das folgende Unterprogramm kombiniert elegant Zeitschleife und Tastaturabfrage:

10000 rem 10 sekunden textanzeige (weiter mit <taste>)
10010 t=ti+600:fori=-1to0:getg$:i=(ti<t)and(g$=""):next:return

Über TI läßt sich auch bei Spielen der zeitliche Verlauf steuern, indem (z.B.) Unterprogramme (nur) alle halbe Sekunde angesprungen werden und nicht, abhängig von anderen Operationen und dem jeweiligen Rechnertyp, häufiger. Der Schwierigkeitsgrad des Programms ist dann plattformunabhängig gleich. Wobei man zugeben muss: gleich schwach, denn der schwächste Rechner bestimmt dann das zulässige Tempo. Was nerven kann, wenn es sich um interpretiertes BASIC handelt.

Beabsichtigt man hingegen, die Programme zu compilieren (danach ist das jeweils compilierte Programm natürlich wieder systemspezifisch, aber man braucht es nur in einer Version zu pflegen), dann ist ein TI-gesteuertes Programm oft die einzige Möglichkeit es überhaupt noch spielen zu können.

Der Frust: Commodore ist eben Commodore!

Commodore wäre nicht Commodere, wenn sie nicht wieder die simpelsten Grundregeln mißachtet und Blödsinn fabriziert hätten. Zum Thema TI/TI$ muss es daher heißen: Achtung Falle! Man mag es sich nicht vorstellen, was in den Knallköpfen damals vorgegangen sein muss, als man sich entschloß die CBM II-Reihe mit einem BASIC auszustatten, dass die Systemvariable TI (TIME) nicht mehr kennt.

Zwar zeigt der P 500 ein BASIC 4.0 an (es ist allerdings Version 4.7), das zu BASIC 2.0 abwärtskompatibel sein soll, doch hilft das wenig. TI ist nicht verwendbar und TI$ (TIME$) erhielt (wohl als schwachen Ersatz) einen veränderten Wertebereich. Was die Sache noch schlimmer macht. In BASIC 2.0 ist TI$ sechsstellig (ti$=“000000″) im Format „hhmmss“ (Stunden, Minuten, Sekunden). Bei BASIC 4.7 kommt eine siebte Stelle hinzu. Diese steht für Zehntel Sekunden. Kürzere Zeiteinheiten sind in BASIC nicht mehr erfassbar.

Bei der im Abschnitt „BASIC: weniger ist manchmal mehr“ in Tabelle 3 angegebenen Rechenzeit habe ich daher gemogelt. Statt des oben angegebenen Programms habe ich das folgende verwenden müssen (und folgerichtig habe ich keine zweite Nachkommastelle angegeben, denn es gab hier nichts zu Runden):

10 ti$="0000000":fori=1to10000:next:t$=ti$
20 print val(right$(t$,3))/10+val(mid$(t$,3,2))*60"sekunden"

Doch was bedeutet das für die Multiplattform-Programmierung? Man muss entweder auf den hübschen TI-Trick verzichten, für den P 500 eine alternative „Schleife“ auf Basis von TI$ entwickeln oder den P 500 aus dem Kreis der unterstützten Rechner ausschließen (da waren’s nur noch vier: PET/CBM, C64, Plus/4, C128). Beim Verbreitungsgrad des P 500 fällt da im Zweifel die Entscheidung leicht. Doch ein Gutes hat die Sache: Spötter können die CBM II-Reihe jetzt als zweifelsfrei „zeitlos“ titulieren – und in Anbetracht des Designs, wäre in diesem Spruch sogar noch eine zweite Wahrheit verborgen.

Nachdem sich, sozusagen als Nebenprodukt dieses Beitrags, die erste der bereits angekündigten bösen Überraschungen offenbart hat, mag man erahnen, dass im nächten Teil weiteres Ungemach droht, wenn wir uns intensiver mit der Kompatibilität bezüglich BASIC 2.0 beschäftigen werden.

Nachdem im letzten Teil dieser Serie über Multiplattform-Programmierung die über die gemeinsame Basis BASIC 2.0 hinausgehenden, vergleichbaren Eigenschaften der Commodore-Rechner im Mittelpunkt standen und Wege gesucht wurden, diese auf den unterschiedlichen Geräten einheitlich anzusprechen, geht es diesmal um Beispiele für die Nutzung spezifischer, individueller Eigenschaften. Diese zu kennen und zu berücksichtigen, ist oft hilfreich und in manchen Fäller sogar erforderlich. Auch der CBM-Checker macht Gebrauch davon.

Einige dieser Besonderheiten beziehen sich auf Befehle aus höheren BASIC-Versionen (BASIC 4.0, 4.7, 3.5 und 7.0). In diesen Fällen ist es erforderlich, dass die betroffenen Programmzeilen nur vom passenden Rechnertyp abgearbeitet werden. Erschwerend kommt hinzu, dass die Token, also die Verschlüsselung der zusätzlichen Befehle, für die BASIC-Versionen 4.x und 3.5/7.0 unterschiedlich und daher inkompatibel sind. In einer späteren Folge werden wir uns mit einem solchen Fall noch beschäftigen müssen. Hier aber sollen nur das Befehlspaar FAST und SLOW und das Kommando GRAPHIC 0 des C128 betrachtet werden.

Commodore 128: Die Kombination SLOW:GRAPHIC 0 findet sich auch im Programm CBM-Checker. Sie soll sicherstellen, dass das Programm, wenn es im 80-Zeichen-Modus gestartet wurde, in den 40-Zeichen-­Modus wechselt und dort angezeigt wird. Es kann auch durchaus mal sinnvoll sein, für den Fall längerer Berechnungen, auf einem C128 die Möglichkeit zu nutzen, den Rechner kurzzeitig mit FAST in den 2 Mhz-Modus zu versetzten. Es gibt kein Gesetz, das das verbietet.

Andere Besonderheiten beziehen sich auf spezielle Zeropage bzw. I/O-Adressen. Einige davon sind uns schon im Programm CBM-Checker begegnet. Hier sollen nun die und eine weitere näher betrachtet werden.

CBM 4001/8001 Series: Mittels PEEK(224) unterschiedet man zwischen einem CBM-Rechner mit 40-Zeichen (PEEK(224)<>0) und mit 80-Zeichen (PEEK(224)=0) Bildschirmbreite. Diese Information kann genutzt werden, um ein spezielles Programm (CBM4032 ANY HZ) nachzuladen, das die erforderlichen Einstellungen vornimmt, um den Bildschirm in den 40-Zeichen-Betrieb umzustellen und diese Änderung in das Betriebssystem einzubinden. Durch diesen Trick können viele Spiele für einen CBM 40xx auch auf einem CBM 80xx laufen.

PET 2001 / CBM 3001 Series: Ein bekanntes Beispiel für systemspezifische Eigenschaften ist der Killer-Poke, auch Fastprint-Poke genannt. Diesen sollte man aus bekannten Gründen nie auf CBM-Rechner mit dem neuen Universalboard (board#3) und CRTC-Chip anwenden. Andererseits laufen ältere CBM-Rechner mit altem Board (board#2) ohne ein gesetztes Bit 5 an Adresse 59458 ($E842; VIA) wie eine Schnecke. Das fragliche Bit wird mittels POKE59458,PEEK(59458)OR32 gesetzt.

Killer poke! (PET 2001): Ein ziemlich sinnfreies Video, aber ein schöner Totenkopf

PET 2001: Ein paar hübsche Blinkeffekte aber auch ein sauberes „Umschalten“ von Bildschirminhalten erhält man mit dem Blank-Poke (Adresse 59409, Bit 3; $E811; PIA 1) . Um den Bildschirm auszuschalten verwendet man POKE59409,52 mit POKE59409,60 läßt sich der Bildschirm wieder einschalten. Dieser POKE-Befehl funktioniert nur bei einem PET 2001 (board#1) und schaltet den Bildschirm komplett ab. Das Programm Distichon nutzt diesen Effekt, um unbemerkt die Darstellung des Einleitungstexts korrigieren zu können. Bekanntlich sind beim PET 2001 im Zeichensatz Groß- und Kleinschriftzeichen vertauscht. Dies wird in besagtem Programm unsichtbar durch eine kleine Assemblerroutine korrigiert.

PET/CBM: Während man bei den farbfähigen Commodore-Rechnern zwischen den zwei implementierten Zeichensätzen bequem über Steuerzeichen umschalten kann [Groß-/Kleinschrift: PRINT CHR$(14); Grafikzeichen: PRINT CHR$(142)], muss dies bei PET/CBM mittels POKE-Befehl bewerkstelligt werden. POKE59468,14 aktiviert Groß-/Kleinschrift und POKE59468,12 den Grafikzeichensatz.

Plus/4, C16, C116: Bedingt durch die Speicherkonfiguration überlagern sich RAM-Bank und ROM-Bank. Da anders als beim C128 kein BANK-Befehl verfügbar ist, wird über Adresse 1177 ($0499) gesteuert, auf welche Speicherbank ein PEEK-Befehl zugreift. Nach einem POKE1177,62 liest PEEK aus dem ROM, nach POKE1177,63 (Grundeinstellung) aus dem RAM. CBM-Checker benutzt diesen Trick, um an den für die Systemerkennung benötigten IRQ-Vektor zu kommen.

Mit den gesammelten Informationen sollte es jetzt eigentlich möglich sein, ein Multiplattform-Programm zu erzeugen. Dass da aber trotzdem noch ein paar interessante Kniffe und (böse) Überraschungen warten, wird sich in den folgenden Teilen dieser Serie zeigen.

Nachtrag (22.12.2012) : Zusammenfassung

Unlängst habe ich über Möglichkeiten zur Unterscheidung verschiedener Commodore-Rechner geschrieben. Heute geht es darum, diese Informationen zu nutzen, um Programme entwickeln zu können, die sich unterschiedlicher Hardwarebasis anpassen können. Für die weiteren Beschreibungen beschränke ich mich auf die 8-Bit-Rechner mit 40-Zeichen-Darstellung (PET, CBM, P500, C64, Plus4, C128), da ansonsten der Aufwand für die Anpassung der Bildschirmdarstellung zu groß wäre bzw. die Darstellungsmöglichkeiten zu stark einschränken würden.

Unabhängig von später zu behandelnden Sonderfällen, die durch individuelle Eigenheiten oder spezifische Inkompatibilitäten einzelner Rechnertypen ausgelöst werden, gibt es einige Unterscheidungsmerkmale, die alle (oder zumindest mehrere) Rechner betreffen und die im Programm am Besten über das Vorbelegen einer Variable mit einem jeweils systemspezifischen Wert gelöst werden müssen. Ich nenne das jetzt hier einfach mal eine Systemvariable. Was sich hier kompliziert anhört, wirkt in einem Beispiel ganz simpel und verständlich: Anstatt mit POKE 1024,0 im linken oberen Bildschirmeck eines C64 einen Klammeraffen erscheinen zu lassen, verwendet man eine Variable: P=1024 und einen flexiblen POKE-Befehl: POKE P,0. Durch Anpassen des Werts der Variable P für verschiedene Systeme kann der POKE-Befehl auf allen Rechnern im linken oberen Eck den gewünschten Klammeraffen erzeugen.

Neben dem Basiswert des Bildschirmspeichers könnten auch Werte für I/O-Register als Systemvariable interessant sein, um zum Beispiel die Hintergrund- und Rahmenfarbe festlegen zu können:

Eine weitere Spielwiese ist die Belegung der „Zeropage“. Bei Commodore-Rechnern ist die Besonderheit zu beachten, dass mit dem Begriff Zeropage oft die „erweiterte Zeropage“, also der Bereich bis $03ff (beim C128 sogar bis $12ff), angesprochen wird und nicht nur die Zeropage, wie sie die CPU sieht. Und so soll der Begriff auch hier verstanden werden. Wobei klar sein muss, dass der Begriff „erweiterte Zeropage“ technisch gesehen Unsinn ist. Möglicherweise hat Commodore (oder eigentlich Microsoft) diesen Begriff dadurch provoziert, dass beim ROM-Update vom PET 2001 zu den Rechnern der CBM 3001 Series diverse Kernel- und BASIC-ROM-Variable und -Zeiger aus der Zeropage in den Bereich ab $0200 bis $033a verlegt wurden und umgekehrt. In jedem Fall war ein Begriff für den Gesamtbereich des von Kernel und BASIC benötigten RAM-Speichers erforderlich.

In der (erweiterten) Zeropage finden sich Daten zur zuletzt genutzten Peripherie (Gerätenummer für Nachladeoperationen), zu Tastatureingaben (Tastaturpuffer und Zeiger in den selben), Sprungektoren, z.B. für den IRQ, und vieles mehr. Die nachfolgende Tabelle listet einige dieser Daten in einer synoptischen Darstellung für die hier betrachteten Geräte auf:

FA: Aktuelle Gerätenummer – Diese Adresse ist relevant für alle Programme, die andere Programmteile nachladen. So können Kassetten- und Diskversionen unterschieden werden und das Nachladen erfolgt immer vom richtigen Laufwerk.

NDX: Anzahl der Zeichen im Tastaturpuffer (Warteschlange) – Durch Beschreiben mit dem Wert Null (0) wird der Tastaturpuffer „gelöscht“.

KEYD: Tastaturpuffer – In der Regel umfasst der Tastaturpuffer 10 Zeichen.

STKEY: Flag für STOP-Taste – Bei einigen Rechnern kann hier auch die RVS-Taste abgefragt werden. Prinzipiell stehen die 8 Bits für 8 Tasten. Welche das sind, ist jedoch systemspezifisch (abhängig von der Verdrahtung der Tastaturmatrix); nur die STOP-Taste ist immer dabei.

SFDX: Nummer der augenblicklich gedrückten Taste – In der Regel systemspezifische Indexnummer in die Tastaturdekodiertabelle. Bei CBM-Rechnern mit neuen ROMs, neuem Board und CRTC-Chip (40xx/80xx) ist es allerdings der dekodierte PETSCII-Code. Wer es in VICE testen will, kann dazu den 4032 (neue ROMs) mit dem 4032B (alte ROMs) vergeichen.

LSTX: Nummer der zuletzt gedrückten Taste – Analog zu SFDX.

SHFLAG: Flag für SHIFT-Taste – Neben der SHIFT-Taste werden hier (sofern vorhanden) auch die Tasten CONTROL und COMMODORE durch ein Bit repräsentiert. Beim P 500 beeinflussen auch andere Tasten den Inhalt dieser Speicherzelle.

RPTFLG: Ermöglicht Tastenwiederholung – Dieses Flag bestimmt die Art der Repeatfunktion: $80 = aktiv für alle Tasten, $40 = keine Tasten, $00 nur für Cursorsteuerung. Bei den CBM-Rechnern hat nur der CBM 80xx eine Repeatfunktion. Beim P 500 konnte ich das Flag nicht zweifelsfrei identifizieren.

PNT: Zeiger auf aktuelle Zeile (Text) – Pointer auf den Zeilenanfang.

PNTR: Aktuelle Cursor-Spalte

TBLX: Aktuelle Cursor-Zeile

IIRQ: IRQ-RAM-Vektor – Über diesen Vektor werden eigene Interruptgesteuerte Routinen eingebunden.

TBUFFR: Kassettenpuffer – Immer wieder beliebt für kleine, unterstützende Assemblerroutinen.

Üblicherweise werden nur wenige der hier aufgeführten Systemvariablen in die Systemerkennungsroutine integriert werden. Dafür kommen noch ein paar systemspezifische Systemadressen hinzu, die jeweils nur für ein Rechnersystem relevant sind, um dort Sonderfunktionen auslösen bzw. steuern zu können. Darüber wird allerdings erst im nächsten Teil berichtet.

Der Erste Schritt bei der Multiplattform-Programmierung besteht im Erkennen des Computersystems. Denn bei aller Ähnlichkeit zwischen den Commodore 8-Bit-Rechnern, gibt es doch genügend Unterschiede, die es zu beachten gilt. Zur Unterscheidung sind spezifische und unverwechselbare Kriterien heranzuziehen. Ein Beispiel für eine automatische Rechnererkennung ist die Routine die sauhund im Forum64 gepostet hat.

Wenn man auf Details, wie den RAM-Ausbau beim VC20 oder die Unterscheidung zwischen C16 und Plus4 verzichten kann, geht es aber auch einfacher. Statt diverse Adressen zu prüfen, genügt es, sich auf eine zu beschränken, die bei allen Rechnern unterschiedlich ausfällt aber bei allen ROM-Varianten identisch ist. Eine vertiefende Analyse läßt sich dann in den erforderlichen Fällen noch nachträglich durchführen.

Am Ende des ROMs finden sich gleich zwei geeignete Kandidaten für einen Rechnercheck. Nach meinen bisherigen Recherchen sind IRQ- (Puls) und RESET-Vektor bei jedem Commodore-Rechner unterschiedlich jedoch für verschiedene ROM-Versionen eines Rechners immer identisch. Zur Identifizierung genügt es, das Low-Byte des Vektors zu prüfen. Ich persönlich bevorzuge dabei den IRQ-Vektor, für irgendetwas muss man sich ja mal entscheiden.

Tabelle der Systemvektoren IRQ und RESET für alle Commodore-8-Bit-Rechner

Der IRQ-Vektor liegt bei $FFFE/FFFF, der RESET-Vektor bei $FFFC/FFFD im ROM; wie bei der CPU 6502 üblich im Format LSB/MSB (Low-Byte/High-Byte bzw. LB/HB). Mittels PEEK lässt sich der gewünschte Wert auslesen. PEEK(65534) liefert das Low-Byte des IRQ-Vektors, PEEK(65532) den des RESET-Vektors. Beim Commodore Plus 4 (und C16 / C116) muss zuvor allerdings noch das ROM eingeblendet werden, was einen kleinen schmutzigen Trick erfordert. Man kann ihn in Zeile 130 des nachfolgenden Listings finden:

Variante A der Systemerkennung. Rechnerspezifische Details werden über ON / GOSUB definiert

Variante B der Systemerkennung. Rechnerspezifische Details werden über DATA-Statements definiert

Wer den Quellcode genau studiert, wird feststellen, dass für die Rechner der CBM 8000er Reihe, die den gleichen IRQ-Vektor haben wie die 4000er, eine zusätzliche Detailprüfung implementiert wurde. Über die Speicherstelle $E0 (224) in der Zeropage kann man leicht erkennen, welchen Rechner (8001 Series: 0 / 4001 Series: 128) man vor sich hat.

Beide Varianten der Rechnererkennung haben ihre Vor- und Nachteile und stehen hier nur beispielhaft für zwei Möglichkeiten das Problem anzugehen [die Programme können als Text- und PRG-Dateien (gezippt) für Testzwecke heruntergeladen werden]. Da sich meine Multiplattform-Programme in der Regel auf die Rechner mit 40-Zeichen-Darstellung beschränken, lasse ich in der Praxis die Erkennung von CBM 600/700 und VC 20 „unter den Tisch fallen“ und erkläre sie zu „nicht unterstützten Systemen“. Und natürlich muss der Identifizierung auch eine ausgefeilte Differenzierung folgen (hier angedeutet durch den „Killer-POKE“ und die BASIC 7-Befehle GRAPHIC und SLOW). Doch dazu berichte ich später mehr.

Als der C64 im Jahr 1982 auf den Markt kam, hatte er ein Problem nicht: fehlende Software. Zwei ganz wesentliche Eigenschaften waren dafür verantwortlich: zum einen das Commodore BASIC 2.0, das die sprachbarrierenfreie Übernahme der bereits für ältere Commodore-Rechner (PET 2001, CBM und VC20) geschriebene Programme ermöglichte und zum anderen der über POKE-Befehle direkt beschreibbare Bildschirm mit 25 Zeilen zu 40 Zeichen (dem Format von PET 2001 und CBM 3001/4001 Series). Nahm man von beidem die Schnittmenge, so ergab sich, dass alles was als BASIC-Programm auf einem CBM-Rechner mit 40-Zeichen-Bildschirm lief, mit wenig Aufwand auf einen C64 übertragbar war.

Zwar bot der C64 mit Farbe, Grafik und Sound viele zusätzliche Möglichkeiten und natürlich lagen der Bildschirmspeicher und auch die für BASIC wichtigen Zeropage-Adressen an anderen Stellen im RAM, aber insgesamt war die Umstellung vom CBM auf den C64 nicht problematischer als die vom PET 2001 auf CBM 3001 Series. [Die stellte für Commodore sicher auch keine große Herausvorderung dar, aber ich erinnere mich noch mit Grausen an meine Probleme, denn mir fehlte damals jede Dokumentation.]

Eines der bekanntesten Beipiele für ein umgestelltes Programm ist sicher „FROSCH“ (Original Titel: „Back to Nature„) von der deutschen 1541-Demodiskette [Inhalt und Download]. Wie man an der Spielanleitung noch erkennt, wurde das Spiel ursprünglich für einen CBM-Rechner mit 40-Zeichen-Bildschirm und separatem Ziffernblock geschrieben (Autor: Bob Carr; veröffentlicht im CURSOR Magazine). Außer ein bißchen Farbe hat die C64-Version auch noch ein paar Geräusche bekommen. Doch allein durch einfaches Ändern der in Zeile 0 definierten Bildschirmadresse kann man, mit einigen Abstrichen, das Programm jederzeit auf einem CBM-Rechner ausführen.

Die Portierung von CBM-Programmen auf die Nachfolgegeräte (C64 /C128) hat also eine lange Tradition. Auch von mir gibt es dazu einige vor langer Zeit programmierte Beipiele (Wumpus, Wator). Im Zuge einer 4k BASIC Compo im Forum64 hatte ich mich (im Jahr 2009) des Themas mal wieder angenommen, besaß ich doch noch ein paar simple auf einem CBM 4008 programmierte BASIC-Spielchen auf Diskette, die außer mir noch kein Mensch gespielt hatte. Was lag da also näher, als sich an fertigen Programmen zu bedienen, anstatt sich neue Ideen abzuquälen.

Ich entschied mich damals für die Portierung von „Distichon„. Da noch genügend Bytes verfügbar waren, konnte ich allerdings gleich Nägel mit Köpfen machen und baute das Programm als Multiplattform-Game auf. Neben dem C64 wurden so auch CBM-Rechner (2001, 3001/4001 Series), der CBM 510 (aka P 500) aus der CBM2-Serie und der Plus 4 (C16/C116) bedient. Die bei der Compo noch bestehenden Limitierungen wurden jetzt mit einer Aktualisierung behoben (so dass nun auch die CBM 8001 Serie unterstützt wird).

Ein weiteres BASIC-Spiel (Isola) mit vergleichbarem „Migrationshintergrund“, habe ich für die letztjährigen C128 4kGame Coding Compo erstellt. Vermutlich mangels Teilnehmer ist es aber irgendwie nie zu einer Veröffentlichung der eingereichten Beiträge gekommen. Auch „Isola“ wird zu einem Multiplattform-Game weiterentwickelt. Ähnliches ist auch für das Spiel Canyon-Bomber geplant, das ich für die Compo auf der Bunkerparty 2012 vom CBM 4008 auf C64 portiert hatte (wobei hier zusätzlich einige Assemblerroutinen umzustellen waren).

Langer Rede kurzer Sinn: Im Laufe der Zeit hat sich so einiges an Informationen angesammelt, die es verdienen, hier dokumentiert zu werden. Es soll beleuchtet werden, wie man die einzelnen Rechner identifiziert und welche Besonderheiten zu berücksichtigen sind, wie kompatibel BASIC 2.0 mit sich selber ist, wie zickig sich 40-Zeichen-Bildschirme verhalten können und welche Gemeinheiten sonst noch so lauern. Wenn man all das beachtet, ist es jedoch keine große Kunst mehr ein Programm so aufzusetzen, dass es auf allen 40-Zeichen-Rechnern lauffähig ist.

Teil 1: Identifizieren Sie sich! – Auf welchem Computer läuft mein Programm?
Teil 2: Zeropage, oh, Zeropage – Synopse wichtiger Adressen im RAM
Teil 3: Jedem seine Extrawurst – Das Individuum fordert sein Recht
Teil 4: Immer im Takt – Die CPU (und BASIC): mal schnell, mal langsam
Teil 5: Abwärtskompatibel (zu BASIC 2.0) – Es ist gleich, doch nicht dasselbe
Teil 6: Das vierzigste Zeichen – Wie Fortschritt zum Problem wird

PS: Tokra hat mich darauf aufmerksam gemacht, dass es für den VC 20 einen PET-Simulator mit einer 40-Zeichen-Anzeige gibt. Und natürlich kann auch der VDC im C128 in einen 40-Zeichen-Modus geschaltet werden. Trotzdem werden beide Modi von meinen Multiplatformprogrammen nicht unterstützt. Diese Sonderfälle zu erfassen, würde sicher ein oder zwei Kilobyte zusätzlichen Programmcode erfordern. Da ich die Programme aber so klein halten will, dass sie auch auf einem CBM-Rechner mit nur 8K RAM lauffähig sind, ist das nicht umsetzbar. Was nicht heißen soll, dass es im Einzelfall nicht doch eine Spezialversion für den VDC im C128 geben wird.