AA_PO-20669-Fotolia-Binagel_Fotolia-Joystick.jpg

© Binagel, Fotolia

Homecomputer mit BASIC

Klassiker aus den 80ern wiederbeleben

09.07.2013
Die Vorgänger der PCs waren die Homecomputer: Mit 8-Bit-Prozessoren und um die 64 KByte Arbeitsspeicher waren sie nicht besonders leistungsfähig – sie hatten aber einen BASIC-Interpreter eingebaut, was viele frühe Computerbesitzer zum Programmieren brachte.

In einigen Kellern stehen sie und verstauben, obwohl bei ihrem Anblick manches Sammlerherz höher schlagen und der Oldtimer-Experte die Schätzchen in eine Vitrine stellen würde: Die Rede ist von Homecomputern aus den 80er Jahren – und damit von den ersten Geräten, welche die privaten Haushalte eroberten und mehr als eine Partie Pong boten. Ernsthaft benutzen wollen heute nur noch wenige Anwender einen solchen Rechner; wer ihn in funktionsfähiger Form besitzt und einschaltet, merkt schnell, dass die Homecomputer mit heutigen PCs wenig gemeinsam haben. Die Bildschirmauflösung ist niedrig (einige Geräte können wegen zu weniger Pixel nur 40 Zeichen pro Zeile darstellen), der Prozessor schnarchend langsam (typisch: 1 MHz), und Arbeitsspeichergrößen zwischen 32 und 128 KByte sowie Kassetten und kleine Disketten als Datenträger machen deutlich, dass man hier nicht viel Leistung erwarten darf.

Praktisch alle Homecomputer starten einen im ROM eingebauten BASIC-Interpreter und sind direkt nach dem Einschalten betriebsbereit: Sie warten dann darauf, dass der Anwender beginnt, ein BASIC-Programm einzutippen (oder von Kassette/Diskette nachzuladen). Für den spielerischen Einstieg in die BASIC-Programmierung reicht das aus, und erste einfache Programme sind schnell erstellt.

Die alten Geräte tauchen immer wieder in Ebay-Auktionen auf, doch auch wer kein solches Technikschätzchen besitzt, kann über einen Emulator in den Genuss der 8-Bit-Welt kommen. Wir stellen in diesem Artikel Emulatoren für zwei Geräte vor, die in den 80er Jahren populär waren, und helfen bei den ersten Schritten mit dem eingebauten BASIC.

Commodore C64

Der erfolgreichste Homecomputer war der Commodore C64 [1] (Abbildung 1): Der Name weist darauf hin, dass dieser Rechner mit 64 KByte Speicher ausgestattet war (es gab auch einen Nachfolger namens C128 mit doppeltem RAM), und die meisten Computerspiele wurden in den 80ern zunächst für den C64 entwickelt und dann eventuell auf andere Homecomputer portiert. Insofern war der C64 "Mainstream", und wer als Schüler in diesen Tagen ein anderes Gerät besaß, war eher Außenseiter.

© Bill BertramAbbildung 1: Der Commodore C64 wurde und wird von seinen Fans liebevoll "Brotkasten" genannt.

Für den C64 gibt es zahlreiche Emulatoren für Windows, Linux, Mac OS und sogar Mobilbetriebssysteme. Von den unter Linux verfügbaren Programmen haben wir uns VICE [2] und Frodo [3] angesehen. VICE betrachten viele Anwender als den besten C64-Emulator, im Test hatten wir allerdings Probleme mit der Tastaturbelegung; es waren nicht alle fürs Programmieren nötigen Buchstaben erreichbar. Außerdem fehlen bei den VICE-Paketen für Linux die ROM-Dateien des C64, ohne die er nicht funktioniert – Sie können diese zwar problemlos nachträglich herunterladen (siehe Kästen zur Installation), aber das macht die Ersteinrichtung umständlicher.

Frodo funktionierte auf Anhieb, lief allerdings etwas langsamer als VICE. Da wir keine Frodo-Pakete für Ubuntu finden konnten, haben wir noch eine weitere Alternative gesucht und diese in CCS64 [6] gefunden: Das ist ein alter C64-Emulator für MS-DOS, den Sie mit Hilfe von dosbox (einem DOS-Emulator für Linux) starten können.

Hinweise zur Installation finden Sie in den Kästen Installation unter OpenSuse und Installation unter Ubuntu für die beiden Linux-Distributionen.

Wenn Sie den emulierten C64 starten, erscheint seine Einschaltmeldung in weißer Schrift auf dem typischen blauen Hintergrund; Blau war bei Homecomputern allgemein sehr beliebt.

Abbildung 2: Geschafft: Der C64 läuft, und der Cursor blinkt.

Installation unter OpenSuse

OpenSuse-Anwender müssen zunächst eine spezielle Paketquelle (ein Repository) einrichten, die nur Emulatoren enthält. Das geht am schnellsten auf der Kommandozeile: Öffnen Sie mit [Alt]+[F2] und Eingabe von konsole ein Terminalfenster und geben Sie darin das folgende Kommando ein, um das Repository zu ergänzen:

sudo zypper ar http://download.opensuse.org/repositories/Emulators/openSUSE_12.3/Emulators.repo

(Anwender von OpenSuse 12.2 oder einer älteren Version passen die Versionsnummer in der Adresse an, also z. B. .../openSUSE_12.2/... statt .../openSUSE_12.3/...)

Für die Installation der Emulatoren verwenden Sie dann eines oder mehrere der folgenden Kommandos:

  • VICE: sudo zypper in vice
  • Frodo: sudo zypper in Frodo
  • CPCemu: sudo zypper in cpcemu

Für VICE benötigen Sie anschließend noch die ROM-Dateien; die Installationsanleitung dazu ist von der Distribution unabhängig – Sie finden sie im Kasten ROMs für VICE.

Nach der Installation starten Sie die Emulatoren, indem Sie mit [Alt]+[F2] ein Schnellstartfenster öffnen und darin x64 (für den C64-Emulator VICE), Frodo (für Frodo) oder cpcemu (für den CPC 6128) eingeben.

Installation unter Kubuntu

Den C64-Emulator VICE finden Sie unter Kubuntu im Multiverse-Repository, das zunächst nicht eingebunden ist. Das ändern Sie wie folgt:

Starten Sie über Anwendungen / System / Paketverwaltung (Muon-Paketverwaltung) die Paketverwaltung und wählen Sie darin den Menüpunkt Einstellungen / Configure Software Sources aus; Sie müssen danach Ihr Passwort eingeben.

Im Fenster Software-Paketquellen (Abbildung 3) prüfen Sie, dass bis auf den Eintrag Quelltext alle Häkchen gesetzt sind, und klicken dann auf Schließen.

Abbildung 3: In Ubuntus Paketverwaltung aktivieren Sie alle Repositories.

Verlassen Sie dann die Paketverwaltung und starten Sie diese erneut. Jetzt können Sie die Suchfunktion über das Eingabefeld rechts oben verwenden: Geben Sie als Suchbegriff C64 ein, wählen Sie unter den Treffern den Eintrag Commodore 64 aus und klicken Sie auf Installieren. Danach müssen Sie noch die ROM-Dateien installieren; die Installationsanleitung dazu ist von der Distribution unabhängig – Sie finden sie im Kasten ROMs für VICE. Sie starten VICE anschließend, indem Sie mit [Alt]+[F2] ein Schnellstartfenster öffnen und darin x64 eingeben.

Frodo ist nicht als Ubuntu-Paket verfügbar; Sie können aber den für DOS entwickelten Emulator CCS64 verwenden. Installieren Sie zunächst über die Paketverwaltung das Paket dosbox und laden Sie dann das CCS64-Paket (CCS64DOS.ZIP) von der Downloadseite [7] herunter. Entpacken Sie das ZIP-Archiv – es enthält eine Datei ccs64.exe. Wechseln Sie im Dateimanager in den Ordner mit der Datei und klicken Sie diese an – im Dialog Öffnen mit, der dann erscheint, geben Sie dosbox ein und drücken [Eingabe]. Dann startet der C64; die ROMs sind hier bereits enthalten.

Für den Schneider CPC gibt es auf der CPCemu-Projektseite [5] ein Archiv cpcemu-linux-x86-1.7.tar.gz, das Sie herunterladen und unter Ubuntu nutzen können. Es ist für 32-Bit-Linux-Versionen gedacht: Wenn Sie eine solche verwenden, können Sie das Paket einfach entpacken, in das neu erstellte Unterverzeichnis cpcemu-1.7 wechseln und die darin enthaltene Programmdatei cpc6128 anklicken.

Arbeiten Sie mit einer 64-Bit-Version von Ubuntu oder Kubuntu, installieren Sie vorher noch über die Paketverwaltung das Paket ia32-libs – es enthält Bibliotheken, die Ubuntu für die Verwendung von 32-Bit-Programmen braucht.

Wenn der Emulator läuft, wählen Sie zunächst die Sprache aus. Es erscheint dann ein Begrüßungsbildschirm, den Sie mit [Eingabe] verlassen, dann startet der CPC.

ROMs für VICE

VICE emuliert nur die Hardware eines C64 – für den Betrieb brauchen Sie aber auch die Software, die beim echten C64 in einem ROM-Baustein steckt. Die benötigten Dateien sind in der Windows-Version von VICE schon enthalten, bei den Linux-Paketen fehlen sie.

Laden Sie das Windows-Programmpaket WinVICE-2.4-x86.zip von der VICE-Projekt-Homepage [2] herunter und entpacken Sie es mit dem Dateimanager. Wechseln Sie dann in den neuen Unterordner WinVICE-2.4-x86.

Öffnen Sie ein zweites Dateimanagerfenster und erzeugen Sie in Ihrem Home-Verzeichnis einen Ordner .vice. Nun kopieren Sie aus dem WinVICE-Ordner alle Verzeichnisse, deren Namen nur Großbuchstaben und Zahlen enthalten (C64, C128, DRIVES usw.) in das neue Verzeichnis .vice.

Danach starten Sie den emulierten C64 über [Alt]+[F2] und Eingabe von x64 (mit "x", nicht mit "c") in das Schnellstartfenster.

Schneider CPC

Vom Schneider CPC (Colour Personal Computer) [4] (Abbildung 4) gibt es drei Varianten: Die CPCs 464 und 664 mit 64 KByte RAM und den CPC 6128 mit 128 KByte RAM. Die erste Zahl (4 oder 6) steht für den fest eingebauten Datenträger: Der älteste CPC hat ein Kassettenlaufwerk für klassische Audiokassetten, während die beiden Modelle mit der "6" am Anfang ein 3-Zoll-Diskettenlaufwerk besitzen. Das ist kein Schreibfehler: Es sind wirklich 3-Zoll- und nicht die bei PCs üblichen 3,5-Zoll-Disketten.

© MOS6502, WikipediaAbbildung 4: Der Schneider CPC 6128 ist das größte Modell der CPC-Familie.

Das BASIC im Schneider CPC ist leistungsfähiger und auch schneller als die Variante im C64, außerdem können die CPCs mit Diskettenlaufwerk ein echtes Betriebssystem booten: CP/M erinnert von der Bedienung stark an MS-DOS, und es waren einige Programme aus der MS-DOS-Welt auch für CP/M verfügbar, z. B. der Pascal-Compiler Turbo Pascal und die Textverarbeitung WordStar.

Auch für den CPC gibt es viele Emulatoren, wir haben für diesen Artikel das Programm CPCemu [5] verwendet (Abbildung 5), für dessen Installation Sie wieder die Anleitungen in den Kästen Installation unter OpenSuse und Installation unter Ubuntu nutzen können.

Abbildung 5: CPCemu kann alle Versionen des Schneider CPC emulieren.

Tasten

Bevor Sie mit dem Programmieren loslegen, sollten Sie sich mit der Tastaturbelegung Ihres emulierten Homecomputers vertraut machen – die Buchstaben und Zahlen erreichen Sie alle wie gewohnt (je nach Emulator sind eventuell Y und Z vertauscht), aber die Sonderzeichen liegen meist auf ungewohnten Positionen. Drücken Sie einfach im laufenden Emulator probeweise alle Tasten und merken Sie sich, welche Zeichen erscheinen – vor allem "=", "+", "-", ";" und ":" werden Sie gelegentlich brauchen.

Original-BASIC

Die klassischen BASIC-Interpreter der Homecomputer kennen keine Funktionen oder Prozeduren – BASIC-Varianten mit solchen Features wurden erst Jahre später entwickelt. Es gibt im ursprünglichen BASIC zwei Möglichkeiten, Sprünge im Programm durchzuführen:

  • Verzweigungen mit GOTO, dabei geben Sie ein Ziel an, an dem der Interpreter die Programmausführung fortsetzt.
  • Unterprogrammaufrufe mit GOSUB, das ist ein Vorläufer von Funktionen oder Prozeduren: Sie können damit in ein Unterprogramm springen und mit RETURN zur aufrufenden Position zurück kehren. Allerdings ist keine Parameterübergabe möglich.

Erschwerend kommt bei den alten BASICs noch hinzu, dass diese keine Labels kennen, mit denen man Sprungzielen einen Namen geben kann – stattdessen erhält jede Programmcodezeile eine Zeilennummer. Der Interpreter springt dann bei der Abarbeitung jeweils von einer Zeile zur Zeile mit der nächst größeren Nummer.

Auch gibt es keinen Quelltext-Editor: Sie erstellen eine Programmzeile, indem Sie zunächst die Zeilennummer und dann den Befehl (oder mehrere Befehle) eingeben. Mit [Eingabe] landet die neue Codezeile im Programm. Um sich einen Überblick über das bestehende Programm zu verschaffen, verwenden Sie das Kommando LIST.

Die folgenden Beispiele funktionieren auf dem C64 und auch auf dem Schneider CPC. Wir starten zunächst mit "Hallo Welt" – in der fortgeschrittenen Variante, welche diesen Text in einer Endlosschleife immer wieder ausgibt:

10 REM HALLO-WELT-PROGRAMM
20 PRINT "HALLO WELT ";
30 GOTO 20

Die erste Programmzeile (Zeile 10) stellt nur einen Kommentar dar. In vielen BASIC-Dialekten (z. B. auf dem Schneider CPC) können Sie statt REM auch einen Apostroph verwenden. Zeile 20 ruft den fest eingebauten Befehl PRINT auf und gibt "HALLO WELT" und ein Leerzeichen aus – das Semikolon am Befehlsende steht dafür, dass kein Zeilenumbruch erfolgt. In Zeile 30 fordert schließlich der Befehl GOTO 20 den Interpreter auf, zu Zeile 20 zurück zu springen und diese erneut auszuführen. Um das Programm zu starten, geben Sie (ohne Zeilennummer) den Befehl RUN ein. Sie brechen es wieder ab, indem Sie einmal (C64) bzw. zweimal (CPC) [Esc] drücken.

Variablen, Ein- und Ausgabe

BASIC-Programme speichern Zahlen und Text in Variablen; die klassischen BASIC-Interpreter verwenden für jede Variable einen einfachen Buchstaben (A, B usw.). Wenn die Variable Text enthalten soll, ist sie eine String-Variable und erhält am Ende ein Dollarzeichen als Kennzeichnung (A$, B$ usw.).

Mit Variablen können Sie rechnen, z. B. gibt das Programm

10 A = 10
20 B = 20
30 C = A + B
40 PRINT "SUMME "; C

die Summe 30 aus. Der PRINT-Befehl akzeptiert mehrere Argumente, die durch ein Semikolon getrennt werden – es erscheint dann alles in einer Zeile. Soll das Programm über die Tastatur eine Eingabe einlesen, benutzen Sie den Befehl INPUT:

10 PRINT "DEIN NAME: "
20 INPUT A$
30 PRINT "DEIN ALTER: "
40 INPUT B
50 PRINT "NAME: "; A$; " - ALTER: "; B

Unterprogramme

Wollen Sie eine Subroutine (ein Unterprogramm) aufrufen, können Sie den Befehl GOSUB verwenden. Das folgende Beispiel zeigt, wie Sie eine einfache Additionsfunktion schreiben können:

100 A=10 : B=20 : GOSUB 200
110 PRINT A; "+"; B; "="; C
120 PRINT "GIB A EIN: "; : INPUT A
130 PRINT "GIB B EIN: "; : INPUT B
140 GOSUB 200
150 PRINT A; "+"; B; "="; C
160 END
200 REM ADDIERER
210 C = A + B
220 RETURN

Der Doppelpunkt, der hier mehrfach auftaucht, ist ein Befehlstrenner: Damit können Sie mehrere Befehle in eine einzelne Zeile packen. Über den Befehl END in Zeile 160 wird das Programm beendet – wenn dieser Befehl fehlt, setzt der Interpreter die Ausführung in der folgenden Zeile fort. Das ist hier aber nicht gewünscht, denn in Zeile 200 beginnt das Unterprogramm, das die Summe berechnet: Es soll nur über GOSUB angesprungen werden.

Eine echte Parameterübergabe (wie in modernen Programmiersprachen) ist nicht möglich, Sie können diese nur simulieren, indem Sie Variablen vor dem Aufruf des Unterprogramms mit passenden Werten füllen und in der Subroutine darauf zugreifen. Für die Rückgabe des berechneten Ergebnisses wählen Sie denselben Weg. Im Beispielprogramm sind A und B die Parameter, und C ist der Rückgabewert. In modernen BASIC-Dialekten würde das Programm stattdessen wie folgt aussehen:

A=10 : B=20 : C = add (A, B)
PRINT A; "+"; B; "="; C
PRINT "GIB A EIN: "; : INPUT A
PRINT "GIB B EIN: "; : INPUT B
C = add (A, B)
PRINT A; "+"; B; "="; C
REM ADDIERER
FUNCTION add (x,y)
  RETURN x+y
END FUNCTION

Fallunterscheidung

Um verschiedene Situationen zu unterscheiden, kennt BASIC die Befehle IF (falls) und THEN (dann); in einigen Varianten der Sprache kommt noch das Schlüsselwort ELSE (anderenfalls) hinzu. Der folgende Programmcode liest z. B. mit INPUT eine Zahl ein und entscheidet dann, ob sie kleiner als 100 ist oder nicht:

10 PRINT "GIB WERT EIN: ";
20 INPUT X
30 IF X < 100 THEN PRINT "KLEINER ALS 100"
40 IF X >= 100 THEN PRINT "GROESSER ODER GLEICH 100"

Variablennamen wie X dürfen übrigens nicht beliebige Längen haben; für maximale Kompatibilität verwenden Sie nur Namen mit Länge 1 (also einzelne Buchstaben). Der C64 akzeptiert längere Namen, unterscheidet aber nur die ersten zwei Buchstaben: X und XY sind dort verschiedene Variablen, aber XY und XYZ sind es nicht. Beim Schneider CPC dürfen die Variablennamen bis zu 40 Zeichen lang sein.

Schleifen

Eine einfache Schleife haben Sie schon gesehen: Mit GOTO können Sie jederzeit zu einer früheren Stelle im Code zurück springen und so immer wieder dieselben Befehle ausführen. Beliebter ist aber die so genannte Zählschleife: Sie verwendet eine Variable, die nacheinander verschiedene Werte annimmt. Das folgende Beispiel gibt alle ungeraden Zahlen zwischen 1 und 9 aus:

10 FOR I = 1 TO 9 STEP 2
20 PRINT I,
30 NEXT I

Die Variable I erhält in Zeile 10 zunächst den Wert 1, dann wird dieser in Zeile 20 ausgegeben, und durch den Befehl NEXT I in Zeile 30 geht es zurück zum Anfang der Schleife. Normal würde eine FOR-Schleife nun den Wert um 1 erhöhen, aber durch das Schlüsselwort STEP addiert der Interpreter stattdessen immer 2 – der Wert von I im nächsten Durchlauf ist also 3, danach 5, 7 und schließlich 9. Wenn der Endwert erreicht ist, bricht die Schleife ab (Abbildung 6).

Abbildung 6: Mit einer FOR-Schleife wiederholen Sie gleichartige Berechnungen mit verschiedenen Werten.

Schleifen können Sie auch schachteln und wie folgt z. B. eine kleine Multiplikationstabelle (das kleine Einmaleins) ausgeben:

10 FOR I = 1 TO 10
20 FOR J = 1 TO 10
30 PRINT I; " x "; J; " = "; I*J
40 NEXT J
50 NEXT I

Beachten Sie, dass hier in Zeile 40 zunächst die "innere Schleife" beendet wird (FOR JNEXT J) und dann in Zeile 50 die "äußere Schleife" (FOR INEXT I).

Bei den meisten BASIC-Dialekten können Sie im NEXT-Befehl auch auf den Namen der Variable verzichten.

Fazit

BASIC hat zwar heute nicht mehr dieselbe Bedeutung wie in den 80er Jahren, eignet sich aber noch immer für kleinere Programmierprojekte – nicht nur auf den hier vorgestellten Emulatoren, sondern auch (mit moderneren BASIC-Versionen) direkt auf dem PC, wie der PureBasic-Artikel ab Seite 54 zeigt. Für weitere Schritte mit den Homecomputer-BASICs können Sie Handbücher im Internet studieren: Die Seite homecomutermuseum.de bietet Einführungen in die BASIC-Befehle diverser Homecomputer [8].

Diesen Artikel als PDF kaufen

Express-Kauf als PDF

Umfang: 4 Heftseiten

Preis € 0,99
(inkl. 19% MwSt.)

LinuxCommunity kaufen

Einzelne Ausgabe
 
Abonnements
 

Related content

Kommentare