Floppy-Kurs:
"Es rappelt in der Kiste..."
(Teil 1)
In Anlehnung an diverse Geräusche die
das Laufwerk unseres Computerlieblings
an und wann von sich gibt, wünsche ich
Sie herzlich willkommen zum ersten Teil
unseres neuen Floppykurses.
In den nächsten Monaten will ich Ihnen
hier die Funktionsweise und effektive
Benutzung des Floppylaufwerks 1541 des
64 ers erklären. Beginnend mit den Grundlagen zur Datenspeichrung auf Diskette
werden wir uns über sequentielle und
relative Dateiverwaltung immer mehr an
die ' Innereien' der Floppy herantasten, und uns auch mit dem Diskettenaufbau und
Direktzugriff beschäftigen. Danach will
ich Ihnen zeigen, wie einfach es ist die
Floppy in Assembler zu programmieren und
Ihnen desweiteren meine gesammelten Tips und Tricks zur Floppy offenbaren. Ich
wünsche Ihnen also viel Spaß bei diesem
Kurs und will gleich zu Sache kommen. . .
GRUNDLAGEN DER DATENEIN-/AUSGABE
Dieser erste Teil des Floppy-Kurses soll
ganz den Grundlagen und der sequentiellen Fileprogrammierung gewidmet sein.
Kommen wir zunächst einmal zu den Grundbegriffen der Dateneinund ausgabe des
64 ers. Wenn Sie sich mit BASIC auskennen, so wissen Sie, daß es prinzipiell 5 BASIC-Befehle gibt, mit denen wir Daten
an externe, oder von externen Geräten
senden und empfangen können. Diese sind:
* OPEN, zum Üffnen eines Datenkanals,
* PRINT#, zum Senden von Daten in einen Datenkanal,
* GET#, zum Lesen von Daten von einem Datenkanal,
* INPUT#, zum einfacheren ( BASICorientierten) Lesen von einem Datenkanal, und
* CLOSE, zum abschließenden Schließen eines Datenkanals.
Dateneinund ausgaben werden nun prinzipiell mit drei verschiedenen Parametern zu den obigen Befehlen gesteuert.
Sie geben an, welchem logischen Kanal
der aktuelle Datenaustausch zugeordnet
wird und geben Informationen über die
Art des Zugriffs ( lesen/ schreiben) und
über das entsprechende Gerät, das angesprochen werden soll. Diese drei Parameter sind die " logische Filenummer", die
" Sekundäradresse" und die " Gerätenummer" .
Die logische Filenummer ist eine Zahl
zwischen 1 und 127, die als Kennung für
eine Ein-/ Ausgabeoperation dient. Durch
den OPEN-Befehl wird ihr eine bestimmte
Fileoperation zugewiesen, die sie ein- deutig definiert. Wird also ein Datenkanal zur Floppy mit der logischen Filenummer 1 und ein Datenkanal zum Drucker
mit der logischen Filenummer 2 geöffnet, so weiß das Betriebssystem des 64 ers
immer, wohin es Daten mit einer der beiden Filenummern senden soll. Ein
" PRINT#1, A$" sendet so die Stringvariable A$ an den momentan offenen Floppykanal ( nachdem die Filenummer 1 so durch
' OPEN' definiert wurde), wohingegen der
Befehl " PRINT#2, A$" dieselbe Stringvariable an den Drucker sendet ( nachdem
ihm die Filenummer 2 zugeordnet wurde) .
Die Gerätenummer spezifiziert nun das
Gerät, mit dem Daten ausgetauscht werden
sollen. Sie kann Werte zwischen 0 und 15 annehmen. Hierzu gibt es eine Liste, die
die verschiedenen Geräte spezifiziert.
Das Betriebssystem des C64 benötigt diese Nummer deshalb, weil die verschiedenen Peripheriegeräte mit unterschiedlichen Betriebssystemroutinen angesprochen werden müssen. Die Verteilung der Gerätenummern an die entsprechenden Geräte
ist wiefolgt festgelegt:
Ger.num. Gerät
0 Bildschirm 1 Datasette 2 RS232-Schnittstelle 4 Drucker 1 5 Drucker 2 8 Floppylaufwerk 1 9 Floppylaufwerk 2 10 Floppylaufwerk 3 11 Floppylaufwerk 4
Die restlichen Nummern sind unbelegt.
Wie Sie sehen ist es also möglich bis zu
4 Floppylaufwerke und 2 Drucker an den
C64 anzuschließen, die alle getrennt
voneinander angesprochen werden können.
Ebenso ist die Kommunikation mit dem
Bildschirm über die Gerätenummer 0 möglich. Hierbei empfangen Sie direkt die Eingaben, die gerade vom Benutzer auf
den Bildschirm geschrieben werden.
Die Sekundäradresse einer Ein-/ Ausgabeoperation gibt nun die Art einer
Datenoperation an. Sie kann Werte zwischen 0 und 15 annehmen, wobei es folgende Bedeutungen gibt:
SAdr. Bedeutung
0 Programm laden 1 Programm speichern 2-14 Daten Lesen oder Schreiben 15 Floppybefehlskanal
In der Regel werden die Sekundäradressen
zwischen 2 und 14 verwendet. Die Adressen 0,1 und 15 sind spezielle Adressen, die eingens für die Verwaltung von Massenspeichern gedacht sind. Normalerweise
muß man nämlich beim Zugriff auf einen
Massenspeicher ( so wie auch das Floppylaufwerk einer ist) grundsätzlich die Art des Zugriffs explizit im Filenamen
angeben. Möchte man aber ein Programmfile ( dazu später mehr) lesen oder schreiben, so kann man sich die Angabe im Filenamen sparen und die Adressen 0 oder 1 benutzen. Die Floppy weiß in dem Fall
direkt, daß sie ein Programmfile lesen, bzw. schreiben soll. Dazu will ich Ihnen
später noch ein paar Beispiele liefern.
Die Sekundäradresse 15 ist ausschließlich für das Floppylaufwerk reserviert.
Mit ihr wird der sogenannte Floppybefehlskanal geöffnet. Dieser ist nicht an
ein spezielles File gebunden und dient
der Öbertragung von Befehlen an die
Floppy selbst. Die 1541 verfügt nämlich, wie der C64 auch, über einen eigenen
Mikroprozessor ( den 6502, ein Artverwandter des 6510, der im 64 er seinen
Dienst verrichtet) und eigene Ein-/ Ausgabechips. Sie stellt im Prinzip
einen autonomen Computer dar, der richtig Programmiert werden kann. Die wichtigsten Funktionen sind in spezeillen Floppybefehlen zusammengefasst und werden über den erwähnten Befehlskanal aufgerufen ( wie z. B. der Befehl, die einliegende Diskette zu formatieren, oder
ein spezielles File von der einliegenden
Diskette zu löschen) . Der Floppybefehlskanal hat später, wenn wir die Direktzugriffbefehle behandeln, und in Zusammenhang mit der relativen Dateiverwaltung
eine große Bedeutung.
Die obig beschriebenen Parameter, die
der OPEN-Befehl benötigt müssen wiefolgt
angewandt werden ( Praxisbeispiele werden
wir im Laufe dieses Kurses noch genügend
kennenlernen, deshalb hier nur eine Syntaxdefinition) :
OPEN ( log. Filenr.),( Ger. nr.),( Sek. adr.)
DER FLOPPYBEFEHLSKANAL
Wir wollen uns nun mit der Benutzung des
Floppybefehlskanals beschäftigen und
einmal die alltäglichen Floppybefehle
durchgehen.
Bevor Sie also einen Befehl an die
Floppy schicken, müssen Sie den Befehlskanal öffnen. Dies geschieht mit dem
Befehl " OPEN 1,8,15" . Wir öffnen hier
einen Kanal mit der logischen Filenummer
1, verbunden mit dem Gerät Nummer 8( der
Floppy nämlich) und mit der Sekundäradresse 15( eben dem Befehlskanal derselbigen) . Nun können Sie der Floppy Befehle senden, die diese dann unabhängig vom
64 er bearbeiten wird. Sie können also
Ihren 64 er währenddessen in seinem aktuellen Programm fortfahren lassen. Er
arbeitet, solange die Floppy selbst arbeitet, unabhängig von ihr. Nur, wenn
während dieser Zeit ein weiterer Diskettenzugriff notwendig wird, wird der 64 er
angehalten ( s. u.)
Ich will Ihnen nun die Standard- Floppybefehle auflisten, die wir einfach
benutzen können. Später beim Direktzugriff und bei der relativen Dateiverwaltung werden wir ebenfalls über den Befehlskanal der Floppy Anweisungen geben, uns die Daten, die wir von ihr verlangen
entprechend vorzubereiten.
Kommen wir jedoch erst einmal zu den
einfachen Befehlen:
* Der NEW-Befehl:
Mit diesem Befehl formatieren wir eine
neue Diskette. Grundsätzlich bestehen
die Floppybefehle aus einem oder mehreren Buchstaben, sowie den zu jedem Befehl variierenden Parametern. Beim NEW-Befehl ist die Befehlskennung ein " N:", nach diesen beiden Zeichen folgt nun der
Name, den die Diskette erhalten soll, sowie eine zwei Zeichen lange Identifikationskennung (" ID") . Floppybefehle
werden nach dem Üffnen des Befehlskanals
immer mit einem " PRINT# lfn"( lfn= logische Filenummer) an die Floppy geschickt. Mit dem folgenden BASIC-Kommando fordern wir die Floppy also
dazu auf, die einliegende Diskette mit
dem Namen " MEINE DISK" und der ID " MD" zu formatieren. Der Befehlskanal wurde
unter der logischen Filenummer 1 geöffnet ( wie in obigem Beispiel), also sen- den wir den Befehl auch an Kanal 1 :
PRINT#1,"N:MEINE DISK,MD"
Die Floppy beginnt nun mit der Formatierung der Diskette. Der 64 er meldet sich
mit einem " READY." zurück, und Sie können während der Formatierung mit ihm
arbeiten. Sie können den Befehlskanal
nun offen halten und weitere Floppybefehle senden, oder aber auch irgend eine
andere Tätigkeit mit dem Rechner tun.
Achten Sie allerdings darauf, daß beim
weiteren Senden eines Befehls, sowie dem
Schließen des Befehlskanals, der Rechner
blockiert wird. Das liegt daran, daß die
Floppy während einer internen Operation
dem 64 er signalisiert, daß sie gerade
" BUSY", also am Arbeiten ist. Soll der
C64 nun mit der Floppy kommunizieren, so
wartet er solange, bis die Floppy wieder
frei wird. Demnach führt jeder weitere
Befehl, der die Floppy anspricht unweigerlich zu einem zwischenzeitlichen Stop des Rechners.
Der NEW-Befehl kennt übrigens zwei Syntaxen. Öbergeben Sie einen Namen UND
eine ID, dann wird die Diskette physisch
formatiert. Das heißt, sie wird Spur um
Spur neu angelegt, wobei die neuen Spuren mit Nullen aufgefüllt werden. Daten, die sich evtl. auf ihr befanden werden
somit komplett gelöscht. Öbergeben Sie
aber nur einen Diskettennamen, und keine
ID, so wird die Diskette " softformatiert" . Es wird lediglich der neue Name
über den alten geschrieben, und alle
Blocks als unbelegt gekennzeichnet. Die
ID bleibt die alte. Die alten Daten sind
jedoch immer noch auf den Spuren enthalten und können evtl. gerettet werden.
Ausserdem ist das softformatieren weitaus schneller als ein " hardformatieren" . Es funktioniert allerdings nur bei
schon einmal hardformatierten Disketten, da diese die grundlegende Diskettenstruktur schon enthalten.
Sie schließen den oben geöffneten Be- fehlskanal übrigens wieder mit " CLOSE
1" . Tun Sie das bitte immer, wenn Sie
ein Datenfile, oder den Befehlskanal
nicht mehr brauchen, da der 64 er intern
immer nur 10 offene Kanäle verwalten
kann.
* Der RENAME-Befehl:
Mit dem Rename-Befehl können Sie den
Namen eines schon bestehenden Files umbenennen. Die Syntax ist eigentlich
recht einfach. Das Kürzel für RENAME ist
" R:" es folgen nun der neue und der alte
Filename getrennt durch ein "="- Zeichen.
Hier ein Beispiel: PRINT#1," R: MAGIC
DISK= GAME ON"
Dieser Befehl benennt das File " GAME ON" in " MAGIC DISK" um. Wieder benutzten wir
die log. Filenummer 1, die oben im
OPEN-Befehl definiert wurde.
* Der VALIDATE-Befehl:
VALIDATE bedeutet " überprüfen", und sel- biges tut der Validate-Befehl der
Floppy. Haben Sie nämlich Grund zu glauben, daß die Diskettenstruktur durcheinandergekommen ist, so zum Beispiel wenn
Sie ein, oder mehrere Files speichern
wollten, für die aber nicht ausreichend
Platz vorhanden war, dann sollten Sie
diesen Befehl verwenden. Er untersucht
die Diskette auf ihre korrekte Struktur
und korrigiert alles, was nicht einer
normalen Diskettenstruktur entspricht.
In dem Beispiel mit einem nur teilweise
gespeicherten Programm sind die schon
geschiebenen Blocks dieses Files als
belegt gekennzeichnet, obwohl das File
im Directoryeintrag mit "0 Blocks" und
einem "*" als unbrauchbar gekennzeichnet
ist. Der Validate-Befehl erkennt nun die
fälschlicherweise belegten Blocks und
gibt sie wieder frei. Desweiteren löscht
er den markierten Eintrag aus dem Directory. Er benötigt keinerlei Parameter
und kann folgendermaßen aufgerufen werden:
PRINT#1," V"
Die Floppy beginnt nun mit der Validierung. Diese kann je nach dem wie voll
und wieviele einzelne Files auf der Diskette enthalten sind, bis zu mehrere
Minuten in Anspruch nehmen.
* Der SCRATCH-Befehl:
Dieser Befehl löscht ein File auf Diskette. Englisch " to scratch" bedeutet
" kratzen" und im Öbertragenen Sinne
" kratzt" die Floppy tatsächlich ein File
von der Diskettenoberfläche.
Der Scratch-Befehl wird mit " S:" eingeleitet, gefolgt von dem oder den Filenamen, die gelöscht werden sollen. Hierbei
dürfen Sie sogar sogenannte Filepatterns
benutzen, die eine Fileangabe abkürzen.
Ein " Pattern" ist eine Maske, die man
der Floppy für einen Filenamen übergibt.
Alle Files, deren Namen dieser Maske
entsprechen sind damit angesprochen,
werden in unserem Fall also durch den
Scratch-Befehl gelöscht. Hier einige
Beispiele:
PRINT#1,"S:FILE1" PRINT#1,"S:TEST1,TEST2,TEST10,TEST11" PRINT#1,"S:TEST?" PRINT#1,"S:TEST*"
Im ersten Beispiel wird das File namens
" FILE1" gelöscht. Das zweite Beispiel
löscht die Files " TEST1"," TEST2"," TEST10", und " TEST11" . Selbiges können
wir aber auch mit Filepatterns verkürzen. So können wir zum Beispiel mit dem
Fragezeichen eine Fileangabe abkürzen.
es steht für ein beliebiges Zeichen. Das
dritte Beispiel löscht also gleichzeitig
die Files " TEST1" und " TEST2" . Im vierten Beispiel benutzen wir den Asterisk
("*") als Abkürzung. Er steht für alles, was hinter den Zeichen " TEST" folgt. Wir
löschen mit diesem Befehl also auf Einmal alle vier Files aus dem zweiten Bei- spiel.
DIE VERSCHIEDENEN DATEITYPEN
Nachdem wir nun Grundsätzliches über die
Kommunikation mit der Floppy gelernt
haben, möchte ich Sie nun in die einzelnen File-Arten selbiger einführen. Das
benötigen wir, um die unterschiedliche
Programmierung der einzelnen File-Typen
zu verstehen. Insgesamt kennt die 1541 fünf verschiedene File-Typen. Diese
sind:* Programm-Dateien ( PRG) :
In diesen Files sind Daten sequentiell, also Byte hinter Byte abgespeichert. Sie
enthalten ausschließlich Programmdaten, also direkt ausführbare BASIC-, oder
Maschinenprogramme.
* Sequentielle Dateien ( SEQ) :
Diese Fileart unterscheidet sich in
nichts mit der vorherigen. Die Daten
liegen hier ebenfalls sequentiell auf
der Diskette vor. Der einzige Grund,
warum man zwei Filearten zur sequentiellen Speicherung gewählt hat, ist der, daß in SEQ-Files immer nur Daten von und
zu Programmen gespeichert werden sollen
und keine Programme selbst. Wenn Sie
also eine Adressverwaltung programmieren, so sollten Sie Ihre Adressen in
einer SEQ-Datei speichern. Dies kennzeichnet Ihre Daten eben als Daten und
nicht als ausführbares Programm ( obwohl
Sie genausogut eine PRG-Datei verwenden
könnten!) . Die Unterscheidung ist besonders wichtig für den LOAD-Befehl, der
SEQ-Dateien gar nicht erst liest, sondern ausschließlich PRG-Dateien in den
Speicher des 64 ers transferiert.
* Relative Dateien ( REL) :
In relativen Dateien liegen die Daten
für uns Anwender nicht hintereinander, sondern relativ zueinander vor. Hierbei
wird beim Anlegen einer REL-Datei eine
Datensatzlänge vorgegeben, die für ein
REL-File immer gleich bleibt. Wenn Sie nun Daten in die Datei scheiben, werden
selbige zu einem Datensatz zusammengefasst und mit einer fortlaufenden Satznummer versehen. Wenn Sie zum Beispiel
die Adressen Ihrer Adressverwaltung in
relativen Datensätzen speichern, und
sich merken, unter welchen Datensatznummern Sie die einzelnen Adressen wiederfinden, so können Sie direkt auf einen
Datensatz zugreifen. Die Vorteile gegenüber sequentieller Speicherung liegen
auf der Hand: durch den Direktzugriff
sind die Daten erstens schneller erreichbar, weil nicht eine komplette Datei eingelesen werden muß, sondern eben
immer nur ein einziger Datensatz, und
sie können zweitens extern gelagert werden, so daß Sie kostbaren Arbeitsspeicher im 64 er sparen. Die Programmierung
von relativen Dateien wird uns im 2 .
Teil dieses Kurses noch näher beschäftigen.
Bitte Teil 2 laden. . .
* User-Dateien ( USR) Diese Dateien sind speziell für die direkte Floppyprogrammierung gedacht. Da
die 1541 ja über einen eigenen Prozessor
verfügt kann dieser auch direkt in Maschinensprache programmiert werden. Legt
man nun ein Assemblerprogramm in einem
USR-File ab, so kann dieses von der
Floppy direkt in ihren eigenen Arbeitsspeicher geladen, und dort von ihr ausgeführt werden.
* Deleted Files ( DEL) Mit der Kennung " DEL" werden Files markiert, die von der Diskette gelöscht
wurden. Die Floppy löscht nun ein File
nicht wirklich, sondern sie versieht den
File-Eintrag im Directory einfach mit
der DEL-Kennung und gibt die vom File
belegten Blocks schlichtweg als ' unbelegt' wieder frei. Das bedeutet, daß ein
File nach seiner Löschung auch immer
wieder restauriert werden kann, solange man keine neuen Daten auf die Diskette
geschrieben hat. Ein mit DEL gekennzeichneter Eintrag ist normalerweise im
Directory nicht sichtbar. Wie das dennoch möglich ist, und wie man ein
gelöschtes File wieder retten kann, soll
und auch in einer der nächsten Ausgaben
dieses Kurses beschäftigen.
DIE PROGRAMMIERUNG SEQUENTIELLER DATEIEN
Speziell die SEQund REL-Dateien sollen
nun in diesem und dem nächsten Teil dieses Kurses zum Zuge kommen. Beginnen wir
mit der Programmierung sequentieller
Files.
Wie oben schon erwähnt, liegen in SEQ
und PRG Dateien die Daten sequentiell, also Byte hinter Byte, vor. In der Reihenfolge, mit der wir Daten in ein solches File hineinschreiben, müssen wir
sie auch wieder auslesen. Die Vorgehens- weise hierbei ist denkabr einfach.
Zunächst wollen wir einmal ein File
schreiben. Hierzu müssen wir lediglich
ein SEQ-File zum Schreiben öffnen und
dann mittels des PRINT#- Befehls Daten
hineinschreiben. Hierzu ein Beispiel:
OPEN 1,8,2,"DATEN,S,W" PRINT#1,ZA PRINT#1,a$ PRINT#1,x% PRINT#1,CHR$(0);CHR$(40);
CLOSE 1
Hier öffnen wir zunächst einmal ein File
mit dem Namen " DATEN" . Innerhalb der
Namensangabe verlangt die Floppy nun
noch eine Spezifizierung des File-Typs
und der Datenoperation ( Lesen oder
Schreiben) die durchgeführt werden soll.
Das " S" steht dabei für eine ( S) equentielle Datei. Andere mögliche Filetypen
wären " R" für relative," P" für Programm-, oder aber auch " U" für Userdateien. Die " P" Angabe nimmt dabei eine
Sonderstellung ein. Da sie der am häufigsten benutzte Filetyp ist, muß sie
nicht explizit angegeben werden. Wenn
keine Typenangabe gemacht ist, nimmt die
Floppy automatisch an, daß es sich um
eine " PRG"- Datei handelt. Dies funktioniert jedoch nur, wenn eine der beiden
Sekundäradressen 0 oder 1 benutzt wurde.
Dazu gleich mehr.
Direkt nach dem Filetyp kommt, ebenfalls
durch ein Komma getrennt, eine Bezeichnung der Datenoperation, die durchgeführt werden soll. Im Beispiel benutzten wir die Operation " W", was für ( W-) rite= schreiben steht. Insgesamt sind
hier aber drei verschiedene Operanden
möglich:
( R) ead - zum Lesen einer Datei
( W) rite - zum Schreiben einer Datei ( A) ppend - zum Anhängen an eine alte
Datei
Die " A"- Option entspricht im Prinzip der
" W"- Option. Daten werden in einem File
gespeichert, jedoch mit dem Unterschied, daß diese Daten an eine schon bestehende
Datei angehängt werden, und nicht etwa
wie bei " W" eine neue Datei auf der Diskette angelegt wird.
Nachdem im obigen Beispiel eine sequentielle Datei zum Scheiben geöffnet wurde, können wir Daten mittels des
PRINT#- Befehls in sie hineinschreiben.
Dies kann in BASIC auf verschiedenste
Arten geschehen, die Betriebssystemroutine des PRINT#- Befehls passt sich automatisch den Variablentypen an ( wie Sie
sehen wurden in obigem Beispiel String-, Floatund Integerveriablen geschrieben) . Möchte man ein " echtes" Zeichen in
ein File schreiben, so benutzt man in der Regel die CHR$- Funktion, die nur
einzelne Bytes schreibt, in obigem Beispiel die Bytes mit den Werten 0 und 40 .
Wichtig ist die Angabe eines Semikolons
nach der CHR$- Ausgabe. Dies bedeutet
nämlich, wie beim normalen PRINT-Befehl
auch, daß nach der " Ausgabe" auf Diskette die nächste Ausgabe direkt folgen
soll. Andernfalls hängt BASIC nämlich
automatisch ein " Carriage Return"( CR, ASCII-Wert 13) an die Ausgabe an. Bei
der Ausgabe von " reinen" Bytes kann dies
hinderlich sein, weshalb man bei CHR$- Ausgaben in der Regel ein " ;" mitangibt.
BASIC-Variablen MÖSSEN ohne Semikolon
ausgegeben werden, da der INPUT#- Befehl, mit dem man die geschriebenen Daten später wieder lesen muß das CR als Endmarkierung eines Wertes heranzieht. Einzelne Bytes liest man mit der GET#- Funktion, die ja sowieso immer nur ein
einzelnes Byte einliest. Hier ein Beispiel, das die obig geschriebene Datei
wieder einliest:
OPEN 1,8,2,"DATEN,S,R" INPUT#1,ZA INPUT#1,A$ INPUT#1,x% GET#1,Z1$: GET#1,Z2$ CLOSE 1
Die zwei einzelnen Zeichen aus obigem
Beispiel sind nun in den String-Variablen Z1$ und Z2$ gespeichert. Möchte man sie wieder in echte Byte-Werte
umwandeln, muß man die ASC-Funktion wiefolgt benutzen:
Z1%=ASC(Z1$) Z2%=ASC(Z2$)
Wie Sie sehen, haben wir diesmal auch
beim OPEN-Befehl die " R"- Angabe gemacht, damit die Floppy weiß, daß wir Daten
lesen wollen.
Was Sie bei der sequentilellen Fileprogrammierung unbedingt anmerken sollten ist, daß die Daten eben " sequentiell", also hintereinander, in einem File liegen. Sie müssen sie demnach haargenau in
der Reihenfolge wieder einlesen, mit der
Sie sie geschrieben haben. Dies ist gar
nicht so selbstverständlich wie es aussehen mag, wie Sie im nächsten Monat bei
der relativen Dateiverwaltung festellen
werden.
Haargenau so, wie wir ein SEQ-File gelesen und geschrieben haben, können Sie
mit PRG-Files hantieren. Sie müssen lediglich das " S" im Filenamen beim OPEN-Befehl in ein " P" abändern. Ansonsten
ändert sich nichts.
Pfiffig bei der Arbeit mit PRG-Files ist
nun die Anwendung der " besonderen" Sekundäradressen 0 und 1 . Wie ich obig
schon beschrieben hatte, können wir damit der Floppy gleich schon mitteilen, daß wir ein PRG-File lesen oder schreiben wollen. Die explizite Angabe ", P, R"
oder ", P, W" entfällt. Die Sekundäradresse 0 steht für " PRG-File lesen", die
Adresse 1 für " PRG-File schreiben" . Hier
einfach einmal zwei Beispiele:
" OPEN 1,8,0," MEINEDATEI"( Üffnet das PRG-File " MEINEDATEI" zum
lesen)
" OPEN 1,8,1," MEINEDATEI"( Üffnet das PRG-File " MEINEDATEI" zum
schreiben)
Nun können Sie ganz normal mit INPUT# und GET# lesen, bzw, mit PRINT# schreiben. Ebenso müssen Sie Ihre Files natürlich wieder wie gewohnt mit CLOSE
schließen.
Die Verkürzung über die Sekundäradressen
wird häufig in Kopierprogrammen benutzt, weil man so nicht noch umständlich den
Filenamen-Appendix anzuhängen hat ( besonders in Assembler eine zwar einfache, aber lästige Arbeit) .
Das war es dann für diesen Monat. Im
nächsten Monat wollen wir und dann an
die relative Dateiverwaltung wagen, die
zwar komplizierter zu Programmieren ist, mit der jedoch auch sehr flexibel und
schnell gearbeitet werden kann. Bis dahin ein allzeit " Gut Hack",
Uli Basters (ub).
Floppy-Kurs: "Es rappelt in der Kiste"
(Teil 2)
Hallo zum zweiten Teil des Floppy-Kurses. In der vorletzten MD hatten einiges über den Floppybefehlskanal und
die Programmierung sequentieller Files
gelernt. In diesem Teil wollen wir uns
nunmehr mit der relativen Dateiverwaltung beschäftigen, die zwar etwas komplizierter zu programmieren, dafür aber
weitaus flexibler als die sequentielle
Dateiverwaltung zu handhaben ist.
DIE RELATIVE DATENVERWALTUNG
Im ersten Teil des Floppy-Kurses hatten
wir bei den von der Floppy unterstützten
Filetypen auch die sogenannten REL-Files
besprochen. Sie bezeichnen Dateien, die
einen RELativen Aufbau haben. Was das bedeutet wollen wir nun klären.
Sicherlich erinnern Sie sich, daß die
sequentiellen Files, wie der Name schon
sagt Daten " sequentiell", also Byte hinter Byte enthalten. Wenn wir Daten in
einem solchen File gespeichert hatten, so mussten wir immer das komplette File
in den Rechner einlesen, um die Daten
weiterverwnden zu können. Bei relativen
Files ist dieser Aufbau nun anders geregelt. Sie arbeiten mit sogenannten " Datensätzen", oder engl." Records" . Im
Prinzip kann man eine relative Datei mit
einem externen Variablenfeld vergleichen. Wir geben der Floppy lediglich an, daß wir z. B. das 24 . Element ( sprich:
Record) ansprechen wollen, und schon
können wir es lesen oder schreiben. Bei
einem sequentiellen File hätten wir die
23 Eintragungen vorher erst überlesen
müssen, bis wir auf das gewollte Element
hätten zugreifen können.
Die Vorteile von REL-Files liegen damit
auf der Hand:
1) Schnellerer Zugriff, da wir nur die
benötigten Daten ansprechen müssen.
2) Speicherersparnis im Rechner selbst, da alle Daten extern gelagert sind
und kein Speicherplatz mit momentan
nicht benötigten Daten belegt wird.
Jedoch hat die relative Dateiverwaltung
auch einen Nachteil: da sie von BASIC
aus nicht unterstützt wird, ist ihre
Programmierung relativ umständlich. Dennoch lässt sich auch das lernen, und wer
es einmal kann der wird merken, daß die
Vorteile überwiegen.
DIE PROGRAMMIERUNG
Bevor wir überhaupt irgendetwas aus oder
in ein relatives File lesen oder schreiben können müssen wir es erst einmal
generieren. Öberhaupt wird ein relatives
File ganz und gar anders behandelt als
ein sequentielles. So wird beim Üffnen nicht mehr zwischen " Lesen" und " Schreiben" unterschieden. Wir öffnen ein solches File ganz einfach um der Floppy
anzuzeigen, daß wir es nun benutzen wollen. Ob wir nun lesen oder schreiben ist
ganz egal. Die Floppy erkennt automatisch, wenn wir etwas schreiben oder
lesen. Das heißt also, daß wir bei der
Benutzung eines relativen Files immer
auch den Floppybefehlskanal öffnen müssen. Öber spezielle Befehle wird die
Floppy dann über die folgende Operation
informiert. Sie stellt dann, je nach
Befehl, beim Lesen auf dem relativen
Filekanal die gewünschten Daten bereit, bzw. erwartet auf diesem die Daten, die
geschrieben werden sollen.
Wollen wir nun also einmal ein relatives
File anlegen, damit wir es benutzen können. Bevor wir das tun, sollten wir uns
überlegen, wie lang ein Datensatz unseres REL-Files werden soll, und wie viele
davon wir vorläufig darin speichern wol- len. Ersteres müssen wir deshalb tun, weil die Datensätze eines relatives Files immer gleich lang sein müssen, um
der Floppy das Auffinden eines Datensatzes zu ermöglichen. Nehmen wir einfach
einmal an, daß wir 300 Datensätze zu je
80 Zeichen anlegen wollen. Wie oben
schon erwähnt, öffnen wir zuerst einmal
den Floppybefehlskanal. Anschließend
folgt der OPEN-Befehl für das relative
File. Wir legen dabei wie gewohnt die
logische Filenummer, die Gerätenummer
und die Sekundäradresse fest, und geben
einen Namen für unsere Datei an. An diesen angehängt folgt die Typenkennung
", L," sowie der Länge des Datensatzes
in diesem File. Hier ein kleiner Hinweis: im ersten Teil dieses Kurses
erwähnte ich, daß die Kennung für eine
relative Datei beim Öffnen ein " R" ist.
Das war leider eine Fehlinformation!" L" ist die richtige Bezeichnung für den
OPEN-Befehl!
Hier nun ein Beispiel, in dem wir das relative File " TEST" mit 80 Zeichen pro
Datensatz eröffnen:
OPEN 1,8,15 OPEN 2,8,3,"TEST,R,"+CHR$(80)
Der Befehlskanal hat nun die logische
Filenummer "1", das relative File die
"2" . Wichtig beim Üffnen desletzeren ist
auch die Wahl der Sekundäradresse, da
diese bei der Befehlsübergabe an den
Befehlskanal verwendet wird. Wählen Sie
bei der Sekundäradresse bitte nicht die
vorreservierten Nummern 0,1 und 15( sh.
Floppy-Kurs, Teil 1), sondern nur Nummern zwischen 2 und 14 . Nachdem wir nun
also alles geöffnet hätten, was wir
benötigen, müssen wir jetzt erst einmal
die gewünschten 300 Datensätze in der
REL-Datei anlegen. Das funktioniert eigentlich ganz einfach: wir sprechen lediglich mit einem speziellen Befehl den
300 . Datensatz an, und schreiben den
Wert 255 hinein. Die Floppy generiert in diesem Fall nämlich automatisch alle
fehlenden Datensätze - in unserem Beispiel also alle 300 . Das Generieren dieser Sätze kann jetzt einige Zeit in Anspruch nehmen, da die Floppy nun den
Speicherplatz, den sie für alle Sätze
braucht, automatisch belegt und mit den
Bytewerten 255 füllt. Stören Sie sich
bitte nicht daran, wenn während dieses
Arbeitsgangs ( wie auch bei allen anderen
Operationen mit relativen Files) die
Floppy-LED zu blinken beginnt, oder
trotz Zugriffs zeitweise erlischt. Das
ist ganz normal bei der Arbeit mit relativen Files.
Wenn die Floppy mit dem Anlegen der relativen Datei fertig ist blinkt sie
übrigens sowieso, da wir durch den Zugriff auf einen noch nicht existierenden
Datensatz einen " Record not present"- Fehler erzeugt haben, der uns jedoch
nicht weiter stören soll. Durch Auslesen
des Befehlskanals stoppen wir das LED-Blinken. Hier nun das Ganze als Programm.
10 OPEN 1,8,15 20 OPEN 2,8,3,"TEST,R,"+CHR$(80) 30 HI=INT(300/256): LO=300-256*HI 40 PRINT#1,"P"+CHR$(3)+CHR$(LO)+CHR$(HI) +CHR$(1) 50 PRINT#2,CHR$(255) 60 INPUT#1,A,B$,C,D: 70 PRINT A,B$,C,D 80 CLOSE1: CLOSE2
Die OPEN-Befehle aus den Zeilen 10 und
20 kennen wir ja schon. In Zeile 30 spalten wir die Zahl 300( die Anzahl der
Datensätze, die wir in unserer Datei
verwenden möchten) in Lowund High-Byte
auf, da mit dem CHR$- Befehl ja immer nur
8- Bit-Werte ( von 0 bis 255) übergeben
werden können, und durchaus mehr Datensätze möglich sein können, müssen wir
einen 16- Bit-Wert in Lo/ Hi-Folge an die
Floppy senden. Dies geschieht in der
folgenden Zeile - mit dem ersten PRINT#- Befehl senden wir den Positionierungsbefehl an die Floppy. Wohlgemerkt
geschieht dies über den Befehlskanal!
Aus dem Beispiel ist die Syntax des Positionierungsbefehls ersichtlich. Beginnend mit dem Zeichen " P"( für " positionieren") werden in Reihenfolge die Sekundäradresse der REL-Datei auf die sich
die Positionierung beziehen soll, die
Datensatznummer in Lo/ Hi-Folge, sowie
die Byteposition innerhalb des entsprechenden Datensatzes mittels CHR$- Codes
an die Floppy übermittelt. In Zeile 50 wird nun über den logischen Kanal des
REL-Files der Wert 255 in den positionierten Datensatz geschrieben. Da er, wie alle anderen vor ihm, noch nicht
existiert, beginnt die Floppy nun damit
alle Datensätze anzulegen, um den
Schreibbefehl in Record 300 ausführen zu
können. Es ist übrigens wichtig, daß Sie
beim Erzeugen einer REL-Datei den Wert
255 schreiben, weil dieser nämlich als
Endmarkierung beim Lesen dient. Hierzu jedoch später mehr.
In den Zeile 60 und 70 lesen wir nun
noch den Fehlerkanal aus und geben die
" Record not present"- Fehlermeldung aus, um die blinkende Floppy-LED zu löschen
und schließen anschließend die beiden
offenen Files - schon haben wir eine
REL-Datei zur Verfügung!
DER SCHREIBZUGRIFF
Möchten wir nun mit unserer selbst erstellten REL-Datei arbeiten, so müssen
wir sie natürlich öffnen. Hierbei ist
darauf zu achten, daß wir dieselbe Datensatzlänge angeben, wie wir sie beim
Erzeugen der Datei verwendet haben. Andernfalls kommt die Floppy nämlich mit
der Verwaltung der Datensätze durcheinander, was verheerende Folgen bei
Schreibzugriffen haben kann. Benutzen
Sie am Besten also den gleichen OPEN-Befehl, den Sie auch beim Erstellen benutzt haben! ! !
Wenn wir jetzt etwas in unsere Datei
schreiben möchten, so verfahren wir im
Prinzip genauso, wie beim Erstellen der
Datei ( denn das war ja nichts anderes
als das Schreiben in eine REL-Datei) .
Wir öffnen also zunächst Befehlskanal
und REL-Datei, positionieren mittels
Befehlskanal auf den gewünschten Datensatz und schreiben über die logische
Filenummer der REL-Datei Daten in diesen
Satz hinein. Hier ein Beispiel:
10 OPEN 1,8,15 20 OPEN 2,8,3,"TEST,R,"+CHR$(80) 30 PRINT#1,"P"+CHR$(3)+CHR$(1)+CHR$(0)+ CHR$(1) 40 PRINT#2,"DIESER TEXT WIRD NUN IN DA TENSATZ NUMMER EINS GESPEICHERT!"; 50 CLOSE1: CLOSE2
Im Positionierbefehl wird wieder die
Sekundäradresse 3 verwendet. Diesmal
positionieren wir jedoch auf Byte 1 des
ersten Datensatzes unserer Datei " TEST"
( Die Werte 1 und 0 entsprechen der
LO/ HI-Darstellung der Zahl 1-->256*0+1=1) . In Zeile 40 wird dann mit einem
ganz normalen PRINT#- Befehl ein Text in
den positionierten Datensatz geschrieben. Da der Datensatz diesmal schon existiert brauchen wir demnach auch keinen
Fehler von der Floppy auszulesen, da
vorraussichtlich keiner auftritt.
Anstelle des Textes könnte natürlich
auch eine Stringvariable stehen. Achten
Sie bitte darauf, daß Sie nie längere
Texte in einen Datensatz schreiben, als
selbiger lang ist, da Sie sonst einen
Teil der Daten im folgenden Datensatz
verlieren könnten.
Wichtig ist auch, ob Sie beim Schreiben
das Semikolon (" ;") verwenden, oder
nicht. Verwenden Sie es nicht, so können
Sie beim Lesen den INPUT#- Befehl verwenden. Dieser erkennt das Ende eines Lesevorgangs immer an einem " Carriage Return
Code"( kurz " CR"= CHR$(13)), der von
einem PRINT# OHNE Semikolon immer auto- matisch gesendet wird. In dem Fall müssen Sie aber auch bedenken, daß ein Text
den Sie schreiben nie länger als die
Datensatzlänge-1 sein darf, da das CR
ebenfalls als ganzes Zeichen in den Datensatz geschrieben wird.
Nun ist, wie wir später sehen werden, das Lesen mittels INPUT# nicht immer von
Vorteil, weshalb Sie einen Text auch MIT
Semikolon schreiben können. In dem Fall
müssen wir später beim Lesen eine GET#- Schleife verwenden, da keine Endmarkierung ( das " CR") für den INPUT#- Befehl
geschrieben wurde.
DER LESEZUGIFF
Auch der Lesezugriff weicht nicht sonderlich von den bisherigen Beispielen
ab. Wie immer öffnen die beiden Floppykanäle und positionieren auf den
gewünschten Datensatz. Nun haben wir
zwei Möglichkeiten unsere Daten wieder auszulesen:
Wurden die Daten OHNE Semikolon geschrieben, so genügt ein einfaches
" INPUT#2, A$" um unseren Text wieder zu
Lesen und in A$ abzulegen.
Wurden Sie MIT Semikolon geschrieben, so
müssen wir den umständlicheren Weg über
eine GET#- Abfrage gehen. Dazu zwei Anmerkungen:
1) Bei der GET#- Abfrage sollten nicht
mehr Zeichen gelesen werden, als maximal in dem Datensatz vorhanden sein
können. Bei einer Länge von 80 Zeichen wird die GET#- Schleife also
nicht mehr als 80 mal durchlaufen.
2) Was tun wir, wenn der Datensatzinhalt
kürzer ist, als die festgelegte Datensatzlänge? Wie ich oben schon einmal erwähnte, dient der Byte-Wert 255 als Endmarkierung innerhalb einer
REL-Datei. Dies stellt sich so dar, daß ein leerer Datensatz alle Bytes
mit dem Wert 255 gefüllt hat. Schreiben wir nun einen Text in diesen Da- tensatz, so werden alle benötigten
Zeichen mit dem Text überschieben.
Das darauf folgende Zeichen enthält
dann aber immer noch den Wert 255 .
Dementsprechend können wir sagen, daß
wenn wir beim Lesen eines Strings
dieses Zeichen erhalten, der String
zu Ende sein muß.
Durch diese beiden Punkte ergibt sich
also folgende Schleife zum Lesen eines
Strings:
90 ... 100 A$="" 110 FOR i=1 TO 80 120 GET#2,B$ 130 IF ASC(B$)=255 THEN 160 140 A$=A$+B$ 150 NEXT 160 ... DATABANKING MIT RELATIVEN FILES
Sie sehen, daß das Arbeiten mit REL-Files trotz aller Gegenteiligen Vorraussagen eigentlich relativ einfach ist.
Wir müssen jeweils nur richtig positionieren und können dann beliebig Lesen
und Schreiben. Nun gibt es jedoch noch
einige Kniffe, die man kennen sollte, wenn man effektiv mit relativen Dateien
arbeiten möchte. Diese will ich nun ansprechen.
DATENFELDER:
Bei jeder Datenverarbeitung werden Sie
meist mehrere Angaben in einem Datensatz
machen. Einfachstes Beispiel ist hier
eine Adressverwaltung. Hier müssen Sie
pro Datensatz einen Namen, Strasse, Wohnort, Telefonnummer, etc. angeben, die Sie nachher auch immer wieder auf
anhieb in Ihrer Adressdatei finden müssen. Diese einzelnen Einträge in einem
Datensatz nennt man Datenfelder. Wie bei relativen Files so üblich, sollte man
sich dann jeweils auf eine maximale Länge eines Datenfeldes beschränken. Sie
könnten nun für jedes Datenfeld eine
eigene REL-Datei anlegen, also beispielsweise eine Datei mit 30 Zeichen
pro Satz für alle Namen, eine mit 40 Zeichen für alle Straßen, eine mit 15 Zeichen für alle Telefonnummern, eine
mit 4 Zeichen für alle Postleitzahlen
usw. Diese Lösung birgt jedoch ein größeres Problem in sich: der C64 verwaltet
nämlich immer nur EINE offene REL-Datei.
Das bedeutet in der Praxis, daß Sie jedesmal, wenn Sie eine komplette Adresse
ausgeben wollen, alle Ihre REL-Files
nacheinander öffnen, lesen und schließen
müssen. Was das an Programmierund
Zeitaufwand beim Zugriff bedeutet ist
verheerend. Deshalb geht man in der Regel einen anderen Weg. Halen wir doch
einfach einmal an dem Beispiel der
Adressverwaltung fest. Zunächst wollen
wir uns einmal überlegen, welche und wieviele Felder wir verwenden wollen, und wie lang sie im einzelnen sein sollen. Für unsere kleine Adressverwaltung
wollen wir 6 Felder pro Datensatz definieren:
1) "Name" (20 Zeichen) 2) "Vorname" (15 Zeichen) 3) "Straße" (30 Zeichen) 4) "Postleitzahl" ( 4 Zeichen) 5) "Ort" (30 Zeichen) 6) "Telefon" (15 Zeichen)
Kommen wir nun zu dem Lösungsweg, denn
man hier in der Regel geht. Anstelle von
6 einzelnen Dateien legen wir nun eine
einzige Datei an, in der in einem Datensatz jeweils alle 6 Felder abgelegt werden. Dadurch ergibt sich eine Datensatzlänge von 114 Zeichen (20+15+30+4+30+15=114) . Wir können nun wiederum zwei
Wege gehen, mit denen wir die sechs Felder in einem Datensatz speichern. Ich
gehe dabei davon aus, daß die Einträge vom Programm schon abgefragt wurden und
in Stringvariablen stehen:
Die einfachere, dafür jedoch unflexiblere, Methode sieht folgendermaßen aus:
Wir schreiben mit mehreren PRINT#- Befehlen OHNE Semikolon alle Stringvariablen hintereinander in ein Datenfeld
hinein. Später können wir sie genauso
wieder mittels INPUT# einlesen. Hierbei
ist es egal, wie lang ein Feldeintrag
ist, solange er die vorgegebene Länge
nicht überschreitet ( wäre das bei allen
Feldern nämlich der Fall, so würden wir
mehr Zeichen in einen Datensatz schreiben, wie dieser lang ist, was man tunlichst unterlassen sollte) . Je nach dem, wie flexibel unser Adressverwaltungsprogramm sein soll entstehen nun jedoch
diverse Schwierigkeiten. So müssen wir
zum Beispiel immer alle Felder eines
Datensatzes einlesen, wenn wir eine Datei z. B. nach einem einzelnen Feld sortieren möchten. Für gerade diese Aufgabe werden dann immer 5 Felder zuviel gelesen, was sich wiederum auf die Verarbeitungszeit ReLativ auswirkt. Das zweite
Problem ist die Endmarkierung nach jedem
Feldeintrag. Wie oben ja schon dargestellt müssen wir bei dieser Methode
OHNE Semikolon arbeiten, und in dem Fall
hängt PRINT# immer ein ' CR' an einen
String an. Dadurch müssen wir von den
obigen Feldlängen jeweils ein Zeichen
abziehen ( der Name z. B. darf nicht mehr
20, sondern nur noch 19 Zeichen lang
sein) .
Sie sehen also, daß diese Methode zwar
einfacher zu programmieren, aber sicherlich unflexibler ist.
( bitte Teil 2 Laden. . . .)
Kommen wir zu der flexibleren Methode.
Hierbei halten wir wie oben an den
Feldlängen fest. Da wir nun ja wissen, wie lang ein Feldeintrag maximal sein
kann, können wir im Prinzip vorausberechnen, an welcher Stelle im Datensatz
welches Feld zu finden, bzw. abzulegen
ist, ohne daß sich zwei Felder überschneiden. Hierbei müssen wir darauf
achten, daß entweder ein Feld immer so
lang ist, wie es maximal sein darf ( bei
kürzeren Einträgen wird der Rest einfach
mit SPACE-Zeichen aufgefüllt), oder aber
wir verwenden den Trick mit der GET#- Abfrage beim Lesen. Letzeres ist wohl
die eleganteste Lösung, da sie weniger
Programmieraufwand erfordert und gleichzeitig die Leseund Schreibzugriffe
beschleunigt, da immer nur so viele Zeichen gelesen werden, wie auch wirklich
benötigt werden ( und nicht immer die
maximale Feldlänge) . Wollen wir nun einmal ausrechnen, an welchen Bytepositionen die einzelnen Felder abgelgt werden:
Feldename Beginn Länge
Name 1.Byte 20 Bytes Vorname 21.Byte 15 Bytes Straße 36.Byte 30 Bytes PLZ 66.Byte 4 Bytes Ort 70.Byte 30 Bytes Telefon 100.Byte 15 Bytes
Anhand der Länge eines Feldes können wir
immer die erste Position des folgendenden Feldes berechnen, indem wir die Anfangsposition im Datensatz mit der
Feldlänge addieren.
Nun wissen Sie ja, daß man beim Positionierbefehl nicht nur die Datensatznummer, sondern auch die Byteposition innerhalb des gewählten Datensatzes angeben kann. Und über diese Methode können wir nun ganz bequem jede der 6 Feldpositionen einstellen und den Feldeintrag hineinschreiben. Beim Lesen können
wir, da wir für jedes Feld ja die An- fangsposition innerhalb eines Datensatzes kennen, dieses ebenfalls direkt
anwählen und Lesen. Das ist vor allem
beim Sortieren einer REL-Datei von Vorteil, da wir nun nach allen sechs Feldern eine Datei beliebig sortieren können, ohne die übrigen fünf Felder noch
extra einlesen zu müssen. Das erhöht die
Arbeitsgeschwindigkeit ungemein. Ein
anderer Geschwindigkeitsvorteil ergibt
sich beim Ändern von Datensätzen. Wollen
wir zum Beispiel in einer Adressdatei
nur die Straße verändern, weil die betreffende Person umgezogen ist, so genügt es auf das Feld " Straße"( Byte 36 im entsprechenden Datensatz) zu positionieren und den neuen Eintrag hineinzuschreiben. Hierbei müssen Sie jedoch
auch beachten, daß der neue Straßenname
unter Umständen kürzer ist, als der alte. Wir müssen dann nämlich noch ein
CHR$(255) nachschicken, damit unsere
GET#- Schleife auch ihre Endmarkierung
findet. Andernfalls würde Sie die rest- lichen Zeichen des alten Straßennamens
mitlesen. Ein Beispiel:
Alte Straße --> "Bahnhofstrasse 76" Neue Straße --> "Am Brunnen 2" Ergebnis beim Lesen OHNE eine neue Endmar- kierung --> "Am Brunnen 2se 76"
Schreiben Sie aber aich bitte nur dann
ein CHR$(255) danach, wenn der neue
Straßenname kleiner als die maximale
Feldlänge ist. Andernfalls würden Sie
wieder über die Feldgrenze hinausschreiben und so das erste Zeichen des darauffolgenden Feldes überschreiben!
SORTIEREN ODER INDIZIEREN:
Oben habe ich schon einmal die Möglichkeit der Sortierung einer Datenbank angesprochen. Die augenscheinlich einfachste Art der Sortierung wäre wohl das alphabetische Ordnen der Einträge eines
Feldes ( z. B. des Namensfeldes), und das
anschließende Umkopieren der Datensätze, so daß im ersten Datensatz auch wirklich
der alphabetisch erste und im letzten
Datensatz der alphabetisch letzte Name
steht. Diese Lösung verwendet aber wohl
keiner, da man sich vorstellen kann, daß
die Sortierung durch das Umkopieren der
Datensätze einen extremen Zeitaufwand
bedeutet ( gerade bei einfachen Sortieralgorithmen ist die Anzahl der Austausche zwischen zwei Einträgen ungemein
hoch) . Zusätzlich erfordert diese Methode nach jedem Neueintrag das Umkopieren
der kompletten REL-Datei, da ein neuer
Datensatz ja ebenfalls irgendwo einsortiert werden muß, und damit alle folgenden Datensätze einen Datensatz weiter
nach hinten rücken. Lassen Sie uns also
diese Methode in dem Mülleinmer werfen
und die schnelle, komfortable und flexible Methode herauskramen:" Indizierung" heißt das Zauberwort!
Im Prinzip bedeutet dieses Wort nicht
mehr als " Sortieren", jedoch ist die
Handhabung etwas anders. Hier möchte ich
noch einmal auf das Beispiel der Adressverwaltung zurückgreifen. Gehen wir also
davon aus, daß wir unsere Adressen nach
den Namen der eingetragenen Personen
ordnen wollen. Zu diesem Zweck lassen
wir unseren Sortieralgorithmus nach und
nach alle Namen aus der REL-Datei auslesen und alphabetisch in eine Liste einordnen. Dabei wollen wir uns zu jedem
Namen auch seine Datensatznummer merken.
Letztere können wir dann als Referenz
auf den alphabetisch richtigen Datensatz
verwenden. Ich möchte Ihnen dies anhand
eines Beispiels verdeutlichen. Nehmen wir
einmal eine Adressdatei, die die folgenden vier Namenseinträge, in der Reihenfolge in der sie eingegeben wurden, enthält:
Satznummer Eintrag (Name)
1 Müller
2 Becker
3 Schmidt
4 Meier
Nun sortieren wir unsere Datei nach Namen und erhalten folgende Reihenfolge:
2 Becker
4 Meier
1 Müller
3 Schmidt
Die aphabetisch richtige Reihenfolge
legen wir nun z. B. in einem Variablenfeld ab. Dieses Variablenfeld nennt man
Index. Wenn wir nun den alphabetisch
ersten Eintrag lesen wollen, so schauen
wir uns einfach den ersten Eintrag in
der Indexliste an, und lesen den Daten- satz ein, der dort steht - im Beispiel
also den zweiten.
Damit wir nicht jedes mal neu sortieren
müssen ist es ratsam die Indexliste in
einem sequentiellen File auf Diskette
abzuspeichern. Wenn wir nun jedesmal, wenn die Adressverwaltung gestartet wird
das Indexfeld einlesen, so können wir
ganz einfach und schnell alphabetisch
geordnete Datensätze finden und bearbeiten. Ebenso sollten wir darauf achten, daß neue Datensätze in die Indexliste
richtig einsortiert werden und der Index
wieder neu auf Diskette gespeichert
wird.
Die Indizierung bietet jedoch noch weitere Vorteile. So können wir auch ganz
beliebig nach verschiedenen Feldern sortieren und gleichzeitig beide sortierten
Dateien weiterverwenden. Wenn Sie Ihre
Adressen manchmal besser über den Vornamen finden können, so ist es sinnvoll
auch nach dem Vornamen zu indizieren und
diesen Index als Alternative Verwenden zu können. Beim Umschalten zwischen zwei
Indizes müssen Sie dann jeweils die neue
Indexdatei einlesen. Dies ist sogar bequem möglich, da wir zu der einen offenen REL-Datei auch noch eine SEQ-Datei
öffnen dürfen, ohne daß der 64 er
verrückt spielt. Wir können so als deh eit den Index wechseln, ohne dabei
noch umständlicherweise die REL-Datei
schließen und anschließend wieder öffnen
zu müssen.
EIN WORT ZU NUMERISCHEN EINTRÄGEN:
Vielleicht wollen Sie irgenwann einmal
auch numerische Einträge in einer REL-Datei speichern. Das wäre bei unserer
Adressverwaltung zum Beispiel bei dem
Postleitzahlenfeld sehr gut denkbar. In
manchen Fällen kann uns das auch einen
Speicherplatzvorteil im Gegensatz zu der
Speicherung als String geben. Hierbei
müssen wir jedoch immer gewisse Regeln beachten, sonst werden Sie ganz schön
Probleme mit den Datensatzlängen bekommen. Schreiben Sie nämlich eine numerische Variable ( wie z. B." A" als Float-, oder " A%" als Integervariable) mittels
" PRINT#2, A"( oder " PRINT#2, A%") in eine
Datei, so wandelt die PRINT#- Routine
Ihre Variable immer in eine Zeichenkette, also eine String, um. Wenn diese
numerische Variable nun verschieden viele Stellen besitzen kann, so werden Sie
ganz schöne Schwierigkeiten bekommen.
Logischerweise hat die Zahl "100" eine
Stelle weniger als die Zahl "1000" . Hinzu kommt, daß auch noch ein "-" als Vorzeichen davor stehen kann und daß der
PRINT#- Befehl immer noch ein SPACE-Zeichen ("") vor einer Zahl ausgibt, oder daß ganz kleine oder ganz große
Zahlen in der wissenschaftlichen
Schreibweise ( also z. B."3 .456+ E10") ausgegeben werden.
Wie lang sollen wir dann unser Feld nun
machen? Eine Antwort darauf ist schwierig, da das dann immer auch ganz von dem
Verwendungszweck abhängt. Entweder müssen Sie dem Benutzer schon bei der Eingabe der Zahlen gewisse Einschränkungen
auferlegen, oder aber durch eigene Umkonvertierung einer Zahl eine bestimmte
Bytelänge festlegen können.
Letzteres möchte ich hier als Beispiel
aufzeigen. Wir wollen uns auf positive
Integerzahlen beschränken, also ganze
Zahlen ( ohne Nachkommastellen), die von
0 bis 65535 gehen. In diesem Fall genügt
es eine solche Zahl in Lowund Highbyte
aufzuspalten und die beiden CHR$- Codes
zu speichern. In der Praxis sieht das
ähnlich wie in der Syntax des Positionierbefehls für REL-Dateien aus:
ZA=1992 HI=INT(ZA/256): LO=ZA-256*LO PRINT#2,CHR$(LO);CHR$(HI);
Damit können S) e nun alle oben genannten
Zahlen schreiben. Aber eben nur diese.
Möchten Sie z. B. Float-Zahlen schreiben, so sollten Sie sich überlegen, wie groß
oder klein diese maximal sein können.
Dann können Sie sie sich einmal mit dem
normalen PRINT-Befehl auf dem Bildschirm
ausgeben lassen und die Stellen, die sie
einnehmen abzählen. Wenn Sie sicher sein
können, daß dies die maximale Länge einer Ihrer Zahlen ist, so können Sie sie
als Feldlänge definieren. Beachten Sie
aber auch immer, daß der PRINT#- Befehl
vor einer Zahl immer ein Leerzeichen
druckt und daß zusätzlich immer noch ein
Minus-Zeichen vor einer Zahl stehen
kann. Außerdem können Sie solche Zahlen
auch nur mittels des INPUT#- Befehls wieder einlesen, weshalb Sie noch ein Zeichen mehr für das CR mitrechnen sollten.
Ein anderer Weg um Float-Zahlen zu speichern wäre das direkte übernehmen der
5- Byte-Mantissen- Darstellung, wie das
Betriebssystem des 64 ers sie benutzt,
jedoch ist diese Möglichkeit relativ
kompliziert, da sie den intensiven Gebrauch von Betriebssystemsroutinen erfordert, wovon wir momentan die Finger
lassen wollen ( in einer der späteren
Folge: dieses Kurses werde ich aber noch
einmal auf dieses Thema zurückkommen) .
So. Das wäre es dann wieder einmal für
diesen Monat. In der nächsten Ausgabe
der " Magic Disk" wollen wir uns mit den
Direktzugriffsbefehlen der Floppy befassen, die es uns ermöglichen, auf die
Diskettenblocks direkt zuzugreifen.
(ub)
Floppy-Kurs:
"Es rappelt in der Kiste..."
(Teil 3)
Hallo und herzlich Willkommen zum dritten Teil dieses Kurses. Nachdem wir uns
in den ersten beiden Teilen um die sequentielle und die relative Dateiverwaltung gekümmert hatten, wollen wir nun in
die tieferen Ebenen der Floppy-Programmierung einsteigen. Diesen Monat
soll es um die Direktzugriffsbefehle
gehen, mit denen wir Daten auf einer
Diskette direkt manipulieren können.
Dabei haben wir die Möglichkeit auf die
einzelnen Datenblöcke selbiger zuzugreifen und sie unseren Wünschen entsprechend zu verändern. Bevor wir beginnen, sollten erst einmal ein paar Grundlagen
geklärt werden.
DIE DISKETTENSTRUKTUR
Zunächst wollen wir uns einmal die
Grundstruktur einer Diskette anschauen.
Nachdem sie mit dem Format-Befehl der
Floppy formatiert wurde, enthält Sie 35 konzentrisch angeordnete Spuren ( engl.
" Tracks") und pro Spur 17-21 Sektoren.
Diese Anordung ist typisch für das
1541- Format. Die unterschiedliche Anzahl
von Sektoren pro Spur ergibt sich aus
der physikalischen Anordnug der Spuren.
Dadurch, daß die Spuren von außen nach
innen immer kleiner werdenden Kreisen
entsprechen, wird demnach auch der
Kreisumfang, oder die " Länge" einer Spur
immer kleiner. Je kleiner nun die
Spurlänge ist, desto weniger Sektoren
haben auf ihr Platz. Die folgene Grafik
über den Aufbau einer Diskette soll Ihnen das verdeutlichen. . .
( Anm. d. Red. : Bitte wählen Sie jetzt
den 2 . Teil des Floppykurses aus dem
Textmenu!)
Daraus ergibt sich nun die folgende Sektorenverteilung:
Spuren Sektoren-pro-Spur
1-17 21 18-24 19 25-30 18 30-35 17
Wichtig ist, daß Sie wissen, wieviele
Sektoren ein bestimmter Track hat, da
wir diese Information bei den Direktzugriffsbefehlen benötigen, um einen speziellen Block anzusprechen. Versuchen
Sie nun aber Sektor 19 von Spur 35 zu
lesen, so erhalten Sie natürlich eine
Fehlermeldung von der Floppy zurück ( obwohl es einen Sektor 19 bei den Tracks
1-24 gibt!) .
DIE FLOPPY - EIN EIGENSTÄNDIGER COMPUTER
Wie ich vielleicht schon einmal erwähnte
stellt die 1541 einen vollblütigen, unabhängen Computer dar. Sie verfügt
über einen eigenen 8- Bit-Prozessor ( den
6502, der Vorgänger des 6510 aus dem
64 er, der auch im VC20 Verwendung fand), zwei I/ O Bausteine, die man auch VIA
nennt ( Typ 6522, das Vorläufermodell des
6526- CIA-Chips, wie er auch zweimal im
C64 vorhanden ist, und ebenfalls im VC20 eingesetzt war), einem 16- KB-ROM mit dem
Betriebssystem ( DOS) und 2 KB RAM als
Arbeitsspeicher für letzeres und Zwischenspeicher für Diskettenblocks. Die
VIA-Bausteine übernehmen dabei den Datentransfer mit dem 64 er, sowie die Bedienung der Floppymechanik. Natürlich
können Sie dem Floppyprozessor auch ein
Programm geben, das er abarbeiten soll.
Dieses muß in Maschinensprache geschrieben sein, wobei der Befehlssatz des 6502
identisch mit dem des 6510( aus dem
64 er) ist. Die Speicheraufteilung der
Floppy sieht folgendermaßen aus:
Adresse Belegung
$0000-$08002 KB RAM ab $1800 VIA1( serieller Bus) ab $1 C00 VIA2( Laufwerkssteuerung)$ C000-$ FFFF Betriebssystem-ROM (16 KB)
Alle übrigen Bereiche sind unbelegt. Wie
beim C64 auch, können Sie mit einem Programm, daß sich im Floppy-RAM befindet
die Betriebssystemroutinen der Floppy
aufrufen ( so funktionieren z. B. einige
Software-Floppyspeeder) .
Kommen wir nun zum RAM der Floppy, denn
das soll uns eigentlich interessieren.
Ein Datenblock auf einer Diskette ist, wie Sie wissen 256 Bytes lang. Diese
Datenlänge wird auch als Einheit für das
Floppy-RAM benutzt:256 Byte entsprechen
einer sogenannten " Page"( engl." Seite"
- den Assemblerprogrammierern unter Ihnen sicherlich ein geläufiger Begriff) .
Das Floppy-RAM wird nun in acht Pages
unterteilt, die von 0 bis 7 durchnummeriert sind. Die Pages 0,1 und 2 sollten
wir dabei außer Acht lassen, da sie für
die Zeropage, den Stack und den Befehls- puffer der Floppy vorreserviert
sind. Die Pages 3-7 sind Datenpuffer für
Diskettenblöcke. Wir werden sie von nun
an " Puffer" nennen.
DIE DIREKTZUGRIFFSBEFEHLE
Kommen wir nun endlich zu den Blockbefehlen selbst. Eigentlich gibt es drei
Gruppen, von Befehlen, mit denen wir
Abläufe innerhalb des " Floppy-Computers" steuern können: die Blockbefehle zum
lesen, schreiben, belegen und freigeben
von Blocks, die Memorybefehle, mit denen
wir den Floppy-Speicher manipulieren
können und die User-Befehle, die eine Verkürzung von Blockund Memorybefehlen
darstellen.
Bevor wir nun einen dieser Befehle benutzen können, müssen wir natürlich den
Floppybefehlskanal öffnen. Da wir aber
immer auch einen Arbeitspuffer im
Floppy-RAM benötigen, um die Direktzugriffsbefehle ( einige Blockbefehle und
zwei Userbefehle) anwenden zu können, müssen wir gleichzeitig auch einen Puffer für uns vorreservieren. Entweder
überlassen wir dabei die Wahl des Puffers der Floppy, oder aber wir bestimmen
die Puffernummer selbst. Letztes wird
wohl nur in ganz besonderen Fällen
vonnöten sein, weshalb wir uns auf die
erste Methode festlegen wollen. Das Üffnen des Befehlskanals mit der Zuweisung
eines Arbeitspuffers geschieht über das
Üffnen eines eigenen Datenkanals, der
für den Datentransfer mit dem Puffer
herangezogen wird. Dies geschieht folgendermaßen:
OPEN 1,8,15 :REM Befehlskanal öffnen OPEN 2,8,2,"#" :REM Pufferkanal öffnen
Hier öffnen wir also wie gewohnt den
Befehlskanal, dem wir die logische Filenummer 1 zuordnen. Der zweite OPEN-Befehl öffnet einen Kanal zur Floppy, den wir zum Auslesen und Schreiben unseres Datenpuffers verwenden werden. Das
Doppelkreuz ("#") zeigt der Floppy an, daß wir mit einem Datenpuffer arbeiten
möchten. Welche Nummer dieser hat, sei
der Floppy überlassen. Sie sucht nun
einfach einen freien Puffer aus, und
ordnet ihm unserem Kanal zu. Möchten wir
wissen, welcher Puffer ausgewählt wurde, so können wir seine Nummer direkt nach
dem Üffnen durch Lesen des Pufferkanals
erfahren:
GET#2,PN$ PRINT ASC(PN$)
Hierbei ist es wichtig, daß Sie den GET-Befehl innerhalb eines Programms
benutzen, da er vom Direktmodus aus
nicht verwendbar ist.
Wenn wir gleich einen bestimmten Puffer
für uns reservieren möchten, so müssen
wir beim OPEN-Befehl einfach die Puffernummer mit übergeben. Folgender Befehl
reserviert den Puffer Nummer 3( Floppy-Adressbereich $0300-$03 FF) für uns:
OPEN 2,8,2,"#3"
Wichtig ist, daß wir uns die Sekundäradresse merken, mit der wir den Pufferkanal geöffnet hatten. Sie wird später
dazu verwendet, um der Floppy mitzuteilen auf welchem Datenkanal Sie Daten für
uns bereitzustellen hat, bzw. von uns
empfangen wird ( ähnlich den Befehlen für
die RELative Dateiverwaltung) . Wie
üblich wählen wir bei der Sekundäradresse eine der freien Nummern von 2-14 .
DIE BLOCKBEFEHLE Nachdem wir nun einen Datenpuffer reserviert haben und einen Filekanal für diesen Puffer offen halten, können wir uns
jetzt mit den Befehlen beschäftigen, die
wir der Floppy geben können. Die erste
Gruppe dieser Befehle sind die Blockbefehle. Mit ihnen können wir die einzelnen Blocks einer Diskette " hardwaremäßig" ansprechen. Aufgrund eines Blockbefehls wird physisch auf den Block zugegriffen und in den Puffer eingelesen, bzw. aus ihm heraus geschrieben. Für die
Beispiele innerhalb der Befehlsbeschreibungen gelten die obig definierten logischen Filenummern ( Befehlskanal=1, Pufferkanal=2), sowie die Sekundärdresse 2 für den Pufferkanal.
1) BLOCK-READ (" B-R") Mit diesem Blockbefehl lesen wir einen
Diskettenblock in unseren Datenpuffer
ein. Hierbei müssen wir die Sekundäradresse unseres Pufferkanals, die Drive- nummer ( immer 0), den Track und den Sektor als Parameter übergeben. Hier die
allgemeine Syntax:
PRINT#BFN,"B-R";SA;DN;TR;SE
Hierbei gilt:
BFN = logische Filenummer des Befehlska-
nals
SA = Sekundäradresse des Pufferkanals
DN = Drivenummer (immer 0)
TR = Tacknummer
SE = Sektornummer
( Diese Variablennamen und Abkürzungen
werde ich auch im Folgenden weiterverwenden.)
Mit der folgenden Anweisung wird also
Sektor 1 von Track 18 in unseren Puffer
eingelesen. Von dort aus können Sie Ihn
nun mittels einer GET-Schleife auslesen:
... 100 PRINT#1,"B-R 2 0 18 1" 110 FOR I=0 TO255 120 GET#2,a$: PRINT ASC(a$) 130 NEXT
. . .
2) BLOCK-WRITE (" B-W") Mit diesem Blockbefehl schreiben wir
einen Block aus unserem Datenpuffer auf
die Diskette. Seine Syntax ist analog
der von " B-R", nur daß diesmal der Block
geschrieben wird:
PRINT#BFN,"B-W";SA;DN;TR;SE
3) BUFFER-POINTER (" B-P") Für jeden Datenpuffer der Floppy existiert ein Zeiger, der auf das aktuelle
Byte im Puffer zeigt. Möchte man nun ein
ganz spezielles Byte aus dem Puffer auslesen, so muß nicht unbedingt der ganze
Puffer gelesen werden, um das gewünschte
Byte zu erhalten. Sie können mit dem
" B-P"- Befehl den Pointer auf selbiges positionieren und anschließend auslesen.
Als Parameter benutzen Sie ganz einfach die Sekundäradresse des Pufferkanals und
die Nummer des gewünschten Bytes minus
1 . Möchten Sie z. B. das 200 . Byte auslesen, so gehen Sie bitte wiefolgt vor:
PRINT#1,"B-P 2 199" GET#2,A$: A=ASC(A$)
Die zweite, oben angeführte Zeile liest
nun das 200 . Byte in eine Stringvariable
und speichert es als Zahl in der Variablen " A" .
4) BLOCK-ALLOCATE (" B-A") Mit diesem Floppybefehl können Sie gezielt einzelne Disketten-Blocks als " belegt" kennzeichnen. Das ist dann notwendig, wenn Sie Daten mittels " B-W" auf
einer Diskette speichern, zusätzlich
aber noch normale DOS-Files darauf ablegen wollen. Wird ein Block nämlich nicht
als belegt gekennzeichnet, so wird er
beim Speichern eines DOS-Files unter
Umständen überschrieben. Die belegten Blocks sind in der " Block-Allocation- Map"( BAM) einer Diskette gespeichert, die sich in Block 18,0 befindet. Mit dem
Block-Allocate- Befehl wird hier dann der
entsprechende Block als belegt eingetragen. Mehr zum Aufbau der BAM werden wir
im nächsten Teil des Floppy-Kurses lernen. Die allgemeine Syntax des " B-A"- Befehls lautet:
PRINT#BFN,"B-A"; DN; TR; SE
Möchten Sie also z. B. den Block 5 von
Spur 34 als belegt kennzeichnen, so müssen Sie folgenden Befehl benutzen:
PRINT#1,"B-A 0 34 5"
5) BLOCK-FREE (" B-F") Dieser Befehl ist das Gegenstück zu
Block-Allocate. Mit ihm geben Sie einen
belegten Block wieder zur Benutzung
frei. Die Syntax ist dabei identisch zu
" B-A" :
PRINT#BFN,"B-F"; DN; TR; SE
Um den obig belegten Block wieder freizugeben senden Sie den folgenden Befehl
an die Floppy:
PRINT#1,"B-F 0 34 5"
6) BLOCK-EXECUTE ( B-E) Dieser Befehl ist identisch mit Block-Read. Er beinhaltet jedoch zusätzlich, daß der Diskettenblock, der in den Puffer geladen werden soll, ein ausführbares Floppy-Programm ist, das nach dem
Laden direkt angesprungen wird.
DIE MEMORYBEFEHLE
Diese Floppybefehle beziehen sich auf
die Floppy selbst und haben mit dem Direktzugriff nur indirekt zu tun. Trotzdem sind sie nützlich zum Auswerten von
Daten, weshalb sie hier aufgeführt sind:
1) MEMORY-READ (" M-R") Dieser Befehl enstspricht dem PEEK- Befehl von BASIC. Mit ihm können Sie
gezielt einzelne, oder mehrere Speicheradressen der Floppy auslesen. Die allgemeine Syntax lautet dabei wiefolgt:
PRINT# BFN," M-R" ; CHR$( LO) ; CHR$( HI) ;
CHR$( N)
Hierbei stehen " LO" und " HI" für Lowund Highbyte der Adresse die gelesen
werden soll und " N" für die Anzahl Bytes
(0-255), die ab dort übertragen werden
sollen. Das Lowund Highbyte einer
Adresse ermitteln Sie mit folgenden Formeln:
HI= INT( Adresse/256) LO= Adresse-256* HI
Alle Parameter müssen als CHR$- Codes, also dirket, übertragen werden, und dürfen nicht als ASCII-Codes ( wie in den
bisherigen Befehlen) erscheinen. Die zu
lesenden Bytes werden ebenfalls als absoluter CHR$- Code auf dem BEFEHLSKANAL
( !) bereitgestellt ( nicht etwa auf dem Pufferkanal, da der interne Floppyspeicher nichts mit Datenblocks zu tun hat) .
Als Beispiel für die Verwendung von
" M-R" sei folgendes Programm aufgeführt.
Es liest den ASCII-Code der ID der zuletzt initialisierten Diskette aus dem
Floppyspeicher aus. Dieser wird vom
Floppy-Betriebssystem automatisch in den
Speicherstellen 18 und 19 gespeichert
( LO=18 ; HI=0 ; N=2) :
10 OPEN 1,8,15 20 PRINT#1,"M-R"; CHR$(18); CHR$(0); CHR$(2) 30 GET#1,I1$: GET#1,I2$ 40 CLOSE 1 50 PRINT "ID DER ZULETZT BENUTZTEN DIS KETTE: ";I1$;I2$
2) MEMORY-WRITE Mit diesem Befehl schreiben Sie Daten in
den Floppy-Speicher. Er entpricht dem
POKE-Befehl von BASIC. Auch hier über- tragen Sie zunächst die Adresse in Lowund Highbytedarstellung, sowie die Anzahl der zu schreibenden Bytes. Letztere
hieraufhin gesandt. Hier die allgemeine
Syntax:
PRINT# BFN," M-W" ; CHR$( LO) ; CHR$( HI) ;
CHR$( N) ; CHR$( W1) ; CHR$( W2) ; . . . ;
CHR$( Wn-1) ; CHR$( Wn)
3) MEMORY-EXECUTE Dieser Befehl dient dem Ausführen eines
Assembler-Programms innerhalb der
Floppy. Damit hat auch er einen Verwandten in BASIC: den SYS-Befehl. Als Parameter übergeben Sie hier einfach nur die
Startadresse des aufzurufenden Assembler- Programms:
PRINT#BFN,"M-E"; CHR$(LO); CHR$(HI) DIE USERBEFEHLE
Die dritte Gruppe der Floppy-Direkt- Befehle sind die Userbefehle. Sie stel- len eine Abkürzung von einigen Befehlen
aus den anderen beiden Gruppen dar. Die
Userbefehle beginnen alle mit einem " U", gefolgt von einer Zahl zwischen 1 und 9 .
Die ersten beiden Userbefehle sind wohl
die wichtigsten:
1)" U1" Der U1- Befehl ersetzt den Block-Read- Befehl. In der Praxis wird er öfter verwendet, da er gegenüber " B-R" einen Vorteil bietet. Wird mit " B-R" ein Block
eingelesen und anschließend der Inhalt
des Puffers vom 64 er aus ausgelesen, so
wird das erste Byte nicht mitgesandt.
Möchten wir dieses nun aber auch lesen, so müssen wir den " U1"- Befehl benutzen.
Er sendet es zusätzlich mit - im Prinzip
ist der U1- Befehl also besser als " B-R" .
Die Syntax ist identisch mit der von
" B-R" :
PRINT# BFN," U1" ; SA; DN; TR; SE Ansonsten verhält sich alles so, wie
auch bei " B-R" .
2)" U2" Der zweite Userbefehl ist der U2- Befehl
( Ähnlichkeiten mit dem Namen einer bekannten Rock-Band sind rein zufällig) .
Er ersetzt den " B-W" Befehl. Auch hier
ist der Vorteil des ersten Bytes gegeben. Sie benutzen den U2- Befehl, wie den
" B-W"- Befehl:
PRINT#LFB,"U2"; SA; DN; TR; SE
3)" U3- U8" Diese sechs Userbefehle ersetzen ganz
bestimmte " M-E"- Kommandos. Wird einer
dieser Befehle gesandt, so springt die
Floppy in eine Sprungtabelle ab Adresse
$0500 und führt das dort stehende Programm aus. In der Regel besteht selbiges
aus einer Reihe von " JMP $ XXXX"- Anweisungen, mit denen Sie nun auf einfache Weise, vom 64 er aus, selbstdefinierte Programme in der Floppy aktivieren können. Die Userbefehle 3-8 benötigen keine Parameter. Bei Benutzung der Befehle werden folgende Adressen jeweils
angesprungen:
Befehl Springt an Adresse
U3 $0500 U4 $0503 U5 $0506 U6 $0509 U7 $050C U8 $050F
Damit ersetzen diese Userbefehle also
" M-E"- Befehle wie z. B. :
PRINT#BFN,"M-E";CHR$(9);CHR$(5);
Wenn Sie den obigen Befehl abkürzen wollen, so genügt auch ein einfaches:
PRINT# BFN," U6"
4)" U9" Der " U9"- Befehl wurde eingebaut, um die
Kompatibilität der 1541 zum VC20, dem
Vorgänger des C64, zu wahren. Mit ihm können Sie die Floppy in den Modus des
entsprechenden Rechners schalten. Dies
geschieht über folgende Kombinationen
des " U9"- Befehls:
PRINT#BFN,"U9+"; schaltet in C64-Modus PRINT#BFN,"U9-"; schaltet in VC20-Modus
5)" U:" Mit diesem Userbefehl lösen Sie einen
RESET in der Floppy aus. Das Floppysystem wird dann wieder in den Einschaltzustand zurückversetzt. Der " U:"- Befehl
entspricht einem " SYS 64738" beim C64 .
Auch er benötigt keine Parameter.
Das war es dann wieder für diese Ausgabe. In der nächsten Magic-Disk werden
wir uns dann mit dem Aufbau von Files, der BAM und des Directorys beschäftigen.
In diesem Zusammenhang werden wir dann
die hier erlernten Floppy-Befehle in
praktische Beispiele umsetzen.
(ub)
----------------------------------------
FLOPPY-KURS
"Es rappelt in der Kiste..."
(Teil 4)
----------------------------------------
Hallo und herzlich willkommen zum vierten Teil unseres Floppy-Kurses. Nachdem
wir das letzte Mal die Direktzugriffsbefehle kennengelernt haben, wollen wir
uns dieses Mal mit der Struktur auf der
Diskette beschäftigen. Dabei werden wir
lernen, wie wir einzelne Diskettenblocks
so manipulieren, daß zum Beispiel der
Typ eines Files geändert ist, ein File
nicht mehr gelöscht werden kann, etc.
WAS STEHT WO?
Sicherlich erinnern Sie sich noch daran, daß die 1541 eine Diskette in 35 Spuren
zu je 17-21 Sektoren aufteilt. Wir wollen uns nun anschauen, wie das DOS ( so
nennt man das Betriebssystem der Floppy) nun Daten auf diesen Blocks ablegt.
Dabei müssen wir gleich einmal unterscheiden zwischen DOSinternen Verwaltungsblöcken und den reinen Datenblökken. In ersteren stehen Informationen
wie z. B. der Name der Diskette, ihre ID, welche Blocks belegt sind, und welche
nicht, die Directoryeinträge, etc. Den
Verwaltungsblöcken ist ausschließlich
der gesamte 18 . Track vorreserviert.
Datenblöcke weden nie dort abgelegt, dazu dienen jedoch dann alle anderen
Tracks (1-17 und 19-35) .
DIE DATENBLÜCKE
Zunächst wollen wir uns mit der Struktur eines Datenblocks beschäftigen. Diese
ist die einfachere, und demnach schneller erklärt. Dazu will ich Ihnen nun
zunächst einmal beschreiben, was in der
Floppy vorgeht, wenn ein File auf der
Diskette gespeichert wird.
Zu aller erst erhält die Floppy vom C64 die Meldung, daß nun ein Schreibzugriff
erfolgen soll. Gleichzeitig mit dieser
Information wird der Filename des zu
schreibenden Files, sowie sein Filetyp
übertragen. Die Floppy schaut nun in den
Blocks, die für die Directoryeinträge
definiert sind nach, wo ein Eintrag noch
frei ist, oder ob ein neuer hinzugefügt
werden soll. Warum das so ist, wollen
wir später bei den Verwaltungsblocks
klären. Nehmen wir also einfach einmal
an, daß Platz für einen Eintrag gefunden
wurde, und daß der angegebene Filename
noch nicht auf der Diskette existiert
( dies wird nämlich ebenfalls festgestellt und bei Zutreffen wird mit der
Fehlermeldung " File Exists" abgebro- chen) . Das DOS trägt nun im freien Eintrag den Namen und Typ des zu speichernden Files ein. Anschließend macht es
sich auf die Suche nach einem freien
Block in den Tracks 1-17, bzw.19-35, in
dem Sie die ersten Daten des Files ablegen kann. Wurde einer gefunden, so wird
seine Track und Sektornummer ebenfalls
im Directoryeintrag gespeichert. Im andern Fall wird mit der Meldung " Disk
Full" abgebrochen. Nun wird damit begonnen, die zu schreibenden Daten vom Rechner zu empfangen und zu speichern. Da
ein Diskettenblock nur 256 Bytes lang
ist, und zu speichernde Daten in der
Regel ein größeres Volumen haben, sucht
sich die Floppy jedesmal wieder einen
neuen freien Block, wenn der letzte
vollgeschrieben ist. Diese Blocks werden
anschließend als ' belegt' gekennzeichnet
und auf der Diskette vermerkt.
Nun fragen Sie sich bestimmt schon, wie
das DOS später wieder erkennt, welche
Blocks zu welchem File gehören und in welcher Reihenfolge diese geladen werden
sollen. Das ist nun ganz einfach gelöst.
Wie ich oben schon erwähnte kann ein
Datenblock 256 Bytes fassen. Als reine
Datenbytes werden davon jedoch nur 254 genutzt. Die ersten zwei Bytes sind nämlich für die Folgeblocknummer reserviert. Im ersten Byte steht der Track, im zweiten der Sektor des nächsten
Blocks, der zu diesem File gehört. In
diesem ist dann wiederum der nächste
Block vermerkt und so weiter. Um festzustellen, wann ein File aufhört, enthält
der letzte Block als Tracknummer den
Wert 0 . Im Byte für die Sektornummer ist
nun ein Wert enthalten, der die Anzahl
der in diesem Block benutzten Bytes
kennzeichnet, da am Ende, je nach Länge
der gespeicherten Daten, mit hoher Wahrscheinlichkeit nicht alle Datenbytes des
Blocks für das File benötigt werden.
Dieser Aufbau gilt übrigens für alle
Filetypen. Ausnahmen bestätigen jedoch die Regel, und so ist es auch in diesem
Fall. Relative Datenfiles benutzen eine
andere Datenstruktur, was in Ihrer besonderen Funktion begründet ist. Sie
benutzen sogenannte " Side-Sector- Blocks" um ihren relativen Aufbau verwalten zu
können. Da die Manipulation an relativen
Files jedoch wenig ratsam ist, und nur
selten einen Sinn macht, wollen wir den
Aufbau von Side-Sektor- Blöcken wegfallen
lassen.
DIE DIRECTORY-BLOCKS
Nun wissen wir also, auf welche Weise
Datenblocks miteinander verkettet sind.
Was uns nun interessieren soll, ist die
Art und Weise, mit der das DOS nun eine
Diskette verwaltet. Im Prinzip haben wir
das in obigem Beispiel auch schon angesprochen, nur wie funktioniert z. B. das
Heraussuchen eines freien Directoryeintrags, oder freien Blocks?
Nun, wie schon erwähnt, ist der Track 18 ausschließlich dem DOS vorbehalten. Im
Prinzip ist er komplett für das Directory zuständig, wobei hier natürlich
auch Informationen enthalten sind, die
wir nicht beim üblichen LOAD"$",8 angezeigt bekommen. Außerdem ist in einem
ganz speziellen Block die sogenannte
" BAM" abgelegt, was für " Block Availabillity Map" steht. Öbersetzt bedeutet
das nichts anderes als " Block Verfügbarkeits Karte", bzw. Liste. Hier steht
eingetragen, welche Blocks der Diskette
schon belegt sind, und welche nicht.
DER DISK-HEADER-BLOCK
Den Block, in dem die BAM enthalten ist, nennt man " Disk-Header- Block" . Er ist
der wichtigste Block auf der ganzen Diskette, da nur an ihm das DOS eine Diskette überhaupt erkennt und bearbeiten kann. Er liegt im Sektor 0 des 18 .
Tracks. Außer der BAM sind hier noch
viele andere Informationen gespeichert, wie z. B. Diskettenname und - ID. Wollen
wir uns nun eine Liste anschauen, aus
der Sie ersehen können, welche Bytes des
Disk-Header- Blocks welche Informationen
enthalten:
Byte Aufgabe
000 Hier ist die Tracknummer des
ersten Directoryblocks enthal-
ten (normalerweise 18).
001 Hier steht die Sektornummer des
ersten Diretoryblocks (norma-
lerweise 1)
002 Hier steht das 1541-
Formatkenn-zeichen. Selbiges
entspricht dem ASCII-Zeichen
"A" (Code: 65 = $41).
003 Dieses Byte kennzeichnet, ob
die eingelegte Diskette doppel-
seitig formatiert ist (dann
steht hier der Wert 1) . Das ist
wichtig für die Benutzer einer
1571- Floppy, die in der Lage
ist, Disketten beidseitig zu
beschreiben. Die 1541 beachtet
dieses Byte nicht.
004-007 In diesen 4 Bytes ist die
Blockbelegung des ersten Tracks
vermerkt.
008-139 Blockbelegungsbytes für die
Tracks 2-34 .
140-143 Hier steht die Blockbelegung
des letzten,35 . Tracks.
144-159 Hier steht der Diskettenname, der bei der Formatierung angegeben wurde, und zwar im AS-CII- Code. Ist ein Name kürzer
als 16 Zeichen, so werden die
restlichen Bytes mit dem Wert
160 aufgefüllt.
160-161 Hier steht zweimal der Wert
160, was übrigens dem ASCII-Zeichen ' SHIFT-SPACE' entspricht.
162-163 Hier ist die zweistellige ID
der Diskette vermerkt.
164 Wert 160 .
165-166 Formatangabe der Diskette. Diese ist bei 1541- Disketten immer
"2 A" . Sie sehen sie im normalen
Directory, daß Sie mit
LOAD"$",8 geladen haben, immer
am Ende der ersten Zeile, in
der auch Diskname und - ID zu
finden sind.
167-170 Gefüllt mit ' SHIFT-SPACE'( Wert
160) .
171-255 Unbenutzer Bereich. Gefüllt mit
Nullen.
Wie Sie sehen kann hier schon eine Fülle
an Informationen abgelesen werden.
Zunächst einmal sehen wir hier, bei welchem Block das Directory beginnt. Das
ist in der Regel Sektor 1 von Track 18 .
Dieser Wert könnte jedoch mit Hilfe eines Diskmonitors, oder eines kleinen Block-Lese- und-Schreibprogramms beliebig
geändert werden.
Das Formatkennzeichen ist bei der Floppy
1541 das " A" . Es zeigt dem DOS an, daß
dies eine von einer 1541( oder einem
kompatiblen Laufwerk, z. B.1570,1571) formatierte Diskette ist. Dieses Formatkennzeichen wurde deshalb eingeführt, weil Commodore für ältere Bürorechner
ebenfalls eigene Laufwerke gebaut hat, die wiederum eine andere Diskettenstruktur aufweisen ( z. B. mehr Tracks und Sektoren) . Disketten von solchen Laufwerken
können von der 1541 zwar teilweise gelesen, nicht aber beschrieben werden. Deshalb verweigert die Floppy auch den
Schreibzugriff auf Disketten mit anderem
Formatkenneichen. Dies kann man sich
aber auch zunutze machen: ändert man
nämlich den Wert des 3 . Bytes, so kann
man eine Diskette softwaremäßig
schreibschützen. Ein Speichern, Löschen, oder Softformatieren ist nun nicht mehr
möglich. Wohl aber kann von der Diskette geladen werden.
Das 4 . Byte ist für die 1541 nutzlos.
Hier steht in der Regel eine 0( nur
sinnvoll in Verwendung von Laufwerken
mit 2 Schreib/ Leseköpfen) .
Wie Sie weiterhin aus obiger Liste erkennen können, sind nun jeweils vier
Bytes für die Blockbelegung eines jeden
der 35 Tracks reserviert. Die Bytes 4 bis 143 enthalten die oben schon angesprochene BAM. Auf sie werden wir gleich
zurückkommen.
Es folgen zum Schluß noch zwei Informationen über die Diskette. Zum einen der
16 Zeichen lange Diskettenname, zum anderen die ID, gefolgt von einem ' SHIFT-SPACE' und der DOS-Versionsnummer ( normalerweise "2 A") . Auch diese beiden Bereiche können verändert werden. Zusätzlich sollten Sie wissen, daß Sie nicht
nur die ID, sondern auch das SHIFT-SPACE- Zeichen, sowie das "2 A" verändern
können. Dadurch hat man die Möglichkeit
eine 5- stellige " ID" herzustellen( natürlich zählen für das DOS immer nur
noch die ersten beiden Zeichen) . Auf
diese Art und Weise ist es z. B. Möglich, daß die Diskettenseiten der Magic-Disk
die IDs " SIDE1" und " SIDE2" haben ( haben
Sie einmal darauf geachtet?) .
DIE BAM
Die BAM verwaltet, wie schon erwähnt, die freien und belegten Blocks einer
Diskette.140 Bytes sind für sie im
Disk-Header- Block reserviert. Wir haben
ebenso gelernt, daß jeweils vier Bytes
die Blockbelegungen eines Tracks kodieren. Wollen wir uns dies einmal anhand
des ersten Tracks betrachten. Dieser
verfügt ja über 21 Sektoren. Seine
" BAM-Bytes" sind in den Bytes 4 bis 7 des Disk-Header- Blocks (18/0) zu finden.
Im ersten Byte dieser vier Bytes ist nun
die Anzahl der freien Blöcke auf Track 1 vermerkt. In den folgenden drei Bytes sind nun die Zustände der Blocks 0-20 bitweise kodiert. Ist ein Bit in einem
der drei Bytes gesetzt, so entspricht
das der Information, daß der zugehörige
Block frei ist. Ist es gelöscht, so ist
der Block belegt. Die Verteilung der
Sektoren auf die drei Bytes sieht nun
folgendermaßen aus. Die Bits 7-0( in
dieser Reihenfolge!) des ersten Bytes
geben die Belegung der Sektoren 0-7 an.
Die Bits 7-0 des zweiten Bytes zeigen
den Status für die Blocks 8-15 . Die Bits
7-3 des dritten Bytes stehen für die
Blocks 16-20 . Bits 2-0 sind hier unbelegt. Zur besseren Öbersicht hier nochmal eine Tabelle (" DHB"= Disk-Header- Block) :
Byte 1 (für Track 1, Byte 5 des DHB)
Bit 7 6 5 4 3 2 1 0 Sektor 00 01 02 03 04 05 06 07 --------------------------------------
Byte 2 (für Track 1, Byte 6 des DHB)
Bit 7 6 5 4 3 2 1 0 Sektor 08 09 10 11 12 13 14 15 --------------------------------------
Byte 3 (für Track 1, Byte 7 des DHB)
Bit 7 6 5 4 3 2 1 0 Sektor 16 17 18 19 20 -- -- -- --------------------------------------
Alle gesetzten Bits (= freier Block) dieser drei Bytes werden nun gezählt und in
das 0 . Byte der entsprechenden Track-BAM
( für Track 1, Byte 4 des DHB), eingetragen. So baut sich nun die gesamte BAM
auf, wobei sich in Byte 3 die Belegung
natürlich ändert, da es ja auch Tracks
gibt, die nur 19,18 oder 17 Sektoren
haben. In letztem Fall sind dann nur
noch das 7 . und 6 . Bit von Byte 3 be- nutzt.
DIE DIRECTORY-BLOCKS
Kommen wir nun zu den Directoryblocks.
In ihnen sind die auf der Diskette enthaltenen Filenamen und deren Typ gespeichert. In einen Directoryblock passen 8 Fileeinträge. Sind alle Einträge voll, so wird ein neuer Directoryblock angelegt. Track und Sektor des erste Directoryblocks können aus dem Disk-Header- Block entnommen werden. Normalerweise
ist das Block 18/1 . Kommen wir nun zum
Aufbau eines Directoryblocks.
Zunächst einmal sind diese Blocks ebenso
wie normale Datenblocks über die Angabe
des jeweils nächsten Blocks miteinander
verkettet. Deshalb stehen in den ersten
beiden Bytes jeweils Track und Sektor des nächsten Directoryblocks. Der Letzte
ist mit dem Wert 0 als Trackund dem
Wert 255 als Sektornummer markiert. Hier nun eine Öbersicht mit der genauen Belegung eines Directoryblocks:
ByteNr. Aufgabe
000 Track des Folgeblocks 001 Sektor des Folgeblocks 002-033 Fileeintrag Nr. 1 034-065 Fileeintrag Nr. 2 066-097 Fileeintrag Nr. 3 098-129 Fileeintrag Nr. 4 130-161 Fileeintrag Nr. 5 162-193 Fileeintrag Nr. 6 194-225 Fileeintrag Nr. 7 226-255 Fileeintrag Nr. 8
Jeder einzelne Eintrag belegt also 32 Bytes im Directoryblock. Ich muß dies
allerdings korrigieren. Im Prinzip werden immer nur die ersten 30 Bytes benutzt. Die letzten beiden Bytes eines
Eintrags sind immer unbenutzt. Daher ist
Eintrag Nr.8 auch nur 30 Bytes lang.
Die 2 unbenutzten Bytes fehlen hier ein- fach, was auch keinen Unterschied macht.
Nun wollen wir uns einmal anschauen, welche Informationen in den 30 Bytes
eines File-Eintrags zu finden sind. Auch
hier will ich Ihnen eine Tabelle geben, damit die Öbersichtlichkeit gewahrt
bleibt:
000 Byte für den Filetyp.
001-002 Track und Sektor des ersten
Datenblocks dieses Files.
003-01816 Bytes für den Filenamen.
019-020 Bei relativen Files stehen hier
Track und Sektor des ersten
Side-Sektor- Blocks ( sonst unbenutzt) .
021 Bei relativen Files seht hier
die Länge eines Datensatzes
( sonst unbenutzt) .
022-025 unbenutzt 026-027 Zwischenspeicher des Tracks und
Sektors beim Öberschreiben mit
dem Klammeraffen (" ") vor dem
Filenamen. Dies ist nur ein
temporärer Speicher. Normaler-
weise werden diese Bytes nicht
beschrieben.
028-029 Hier steht die Länge des Files
in Blocks als 16-Bit-Lo/Hi-
Zahl.
In Byte 0 ist der Filetyp kodiert. Desweiteren finden sich hier auch Informationen darüber, ob das entsprechende
File ordnungsgemäß geschlossen wurde und
ob es schreibgeschützt ist. In ersterem
Fall ist das File im normalen Directory
mit einem "*" markiert. Das zeigt an, daß das File ungültig ist. Ein File ist
z. B. ungültig, wenn Sie versuchen etwas
auf eine volle Diskette zu speichern.
Die Floppy erkennt nun während des
Schreibens, das kein Platz mehr vorhanden ist, und bricht ab. Zuletzt wird das fehlerhafte File noch als ungültig
erklärt, damit man es nicht mehr laden
kann. Mit einem Validate-Befehl an die
Floppy wird ein solches File dann aus
dem Directory entfernt.
Ein schreibgeschütztes File kann nicht
mehr überschrieben oder gelöscht werden, solange es geschützt ist. Dadurch können
Sie das ungewollte Löschen von Daten
verhindern. Ein so geschütztes File ist
im Directory mit einer spitzen Klammer
nach links ("<") markiert. Wenn Sie sich
einmal das Inhaltsverzeichnis der Magic- Disk anschauen, so werden Sie dort
mehrere Trennstrich-Files finden, die
schreibgeschützt sind.
Im Filetyp-Byte werden die einzelnen
Informationen nun folgendermaßen codiert: Ist Bit 7 gesetzt, so ist ein
File gültig, es wurde ordnungsgemäß geschlossen und kann geladen werden. Wenn
Bit 6 gesetzt ist, so ist das File
schreibgeschützt ( normalerweise ist es
gelöscht, also ungeschützt) . Die Bits 0
bis 2 enthalten die möglichen Filecodierungen. Werte von 0 bis 4 sind sinnvoll.
Bitte Teil 2 des Floppy-Kurses laden! ! !
Deren Bedeutung ist folgendermaßen aufgeteilt:
Bits2-0 Wert Filetyp
000 0 DEL (deleted) 001 1 SEQ (sequentielle Datei) 010 2 PRG (Programmdatei) 011 3 USR (Userdatei) 100 4 REL (relative Datei)
Wie Sie sehen, können aber noch andere
Werte eingetragen werden, die zwar keinen Filetyp spezifizieren, aber dennoch
möglich sind. Dies hat zur Folge, daß
die Files ganz merkwürdige Bezeichnungen
erhalten. Wird zum Beispiel der Wert 15( Bit 3 auch noch mitbenutzt) eingetragen, so hat ein File die Bezeichnung
" ?" .
Alle anderen Bits des Filetyp-Bytes eines Directoryeintrags sind unbenutzt.
Ebenfalls interessant sind das 28 . und
das 29 . Byte eines Fileeintrags. Damit
können Sie nämlich ebenfalls einen kleinen Effekt für den Directoryeintrag erzielen. Da hier die Länge des Files in
Blocks angegeben ist, kann diese auch
verändert werden. Dies hat keinerlei
Einfluß auf das Laden oder Speichern
eines Files, da die Blockangabe vom DOS
nur dazu verwendet wird, um beim Ausgeben eines Directorys die Filelänge direkt greifbar zu haben. Wenn Sie nun
jemanden verblüffen wollen, so kann hier
z. B. der Wert 0 eingetragen werden. Laut
Directory befindet sich in dem File dann
nichts. Trotzdem kann sich dahinter ein
Wahnsinns-Programm verstecken.
Einen änhlichen Effekt können Sie auch
durch Manipulation der BAM erzielen.
Schreiben Sie hier nämlich andere Werte
in die jeweils 0 . Bytes der Trackbelegungen, so erhalten Sie eine andere Anzahl an freien Blocks. Das DOS addiert nämlich diese 35 Bytes auf, um die verbleibende Speicherkapazität (" Free
Blocks") einer Diskette zu ermitteln und
im Directory anzeigen zu können. Achten
Sie danach jedoch bitte darauf, daß Sie
nichts mehr auf eine solche Diskette
speichern, da nun nämlich vermeintliche
freie Blöcke beschrieben werden könnten, was zu erheblichem Datenverlust führen
kann. Am Besten ist es dann, einen
Schreibzugriff durch Ändern des Formatkennzeichens zu verhindern. Öbrigens
sollte ich erwähnen, daß Änderungen an
der BAM jederzeit durch den Validate-Befehl der Floppy wieder rückgängig gemacht werden können. Dieses Floppykommando geht nämlich nach und nach alle
Files der Diskette durch und merkt sich
die jeweils belegten Blocks. Hiernach
kann die ursrüngliche BAM wieder rekonstruiert werden.
Und noch etwas ist zu den Directoryeinträgen zu sagen. Wenn Sie ein File löschen, so wird es keineswegs komplett
von der Diskette entfernt. Das einzige, was der Scratch-Befehl bewirkt, ist das
Freigeben der belegten Diskettenblocks.
Desweiteren wird als Filetyp der Wert 0 eingetragen, was dem Filetyp " DEL" entspricht. Gleichzeitig ist das File als
' ungültig' markiert und nicht schreibgeschützt ( wieso auch) . Ein solcher Fileeintrag kann jederzeit wiederhergestellt werden, indem man einen definerten, gültigen, Filetyp einträgt und anschließend die Diskette validiert. Nun
ist das File wieder so vorhanden, wie
vor dem Löschen ( inklusive des Vermeks, welche Blocks belegt sind) .
Wird jedoch zwischenzeitlich etwas auf
der Diskette gespeichert, so sucht sich
das DOS zunächst immer einen solchen
' leeren' Fileeintrag heraus, bevor es
einen neuen Eintrag im letzten Directoryblock anlegt. Dadurch erklärt sich
auch, warum neu geschriebene Files
manchmal mitten im Directory zu finden sind und nicht am Ende. Hier wurde vorher an dieser Stelle ein altes File
gelöscht.
Dies soll es dann wieder einmal gewesen
sein für diesen Monat. Wenn Sie Ihre neu
hinzugewonnenen Kenntnisse einmal ausprobieren möchten, so nehmen Sie sich
einfach einen Diskmonitor zur Hand und
versuchen Sie einmal einige Directoryeinträge oder den Disk-Header- Block zu
verändern. Weiterhin kann mit dem Programm " Disk-Manager" auf dieser MD das
Directory noch weitaus komfortabler manipuliert werden. Nun wissen Sie ja
wahrscheinlich auch, was dabei geschieht.
Im nächsten Teil des Floppykurses wollen
wir uns mit der Floppybedienung in Assembler beschäftigen. Dabei werden wir
dann auch einige Programme erstellen, die sich die hier kennengelerntern In- formationen zunutze machen.
(ub)
----------------------------------------
Floppy-Kurs
"Es rappelt in der Kiste..."
(Teil 5)
----------------------------------------
Herzlich Willkommen zum 5 . Teil unseres
Floppykurses. In diesem Monat wollen wir
die Kenntnisse, die wir bisher über die
Floppy erfahren haben in die Praxis umsetzen. Das heißt, daß wir in diesem
Kursteil einige nützliche Anwendungen
zum bisher Erlernten programmieren werden. Diese werden zunächst in BASIC behandelt. Im nächsten Kursteil wollen wir
dann auf die Programmierung in Assembler
eingehen.
1) DISKETTE SCHREIBSCHÖTZEN
Kommen wir zu unserem ersten Programm- beispiel. Wie ich im dritten Teil dieses
Kurses schon erwähnte ist es ganz einfach möglich, eine Diskette softwaremäßig schreibzuschützen. Sie können anschließend weder etwas auf die Diskette
schreiben, noch etwas von ihr löschen.
Das Laden von Programmen funktiert jedoch nach wie vor. Einzige Möglichkeit
die Diskette wieder beschreibbar zu machen ist dann das Formatieren ( oder
nochmaliges Behandeln mit unserem Programm) .
Wie realisieren wir nun einen solchen
Schreibschutz? Nun, wie wir mittlerweile
ja wissen, legt die Floppy beim Formatieren einer Diskette im Diskheaderblock
einige wichtige Informationen über die
Diskette ab. Hier steht unter anderem
auch das Formatkennzeichen, das bei der
1541 den Buchstaben " A" darstellt. Andere Commodorelaufwerke ( z. B. das eines
alten CBM4040) haben dort ein anderes
Zeichen stehen. Da Commodore bei den
alten Laufwerkstypen ähnliche Aufzeich- nugsformate benutzte, sind die Disketten
von Commodorelaufwerken bis zu gewissen
Grenzen untereinander kompatibel. Meist
unterscheiden sie sich nur in der Aufzeichnungsdichte ( mehr Tracks auf einer
Diskette) . Um nun zu vermeiden, das
Laufwerke von verschiedenen Rechnern die
Daten einer Diskette eines anderen Laufwerks zerstören, wurde eine Sicherung in
die 1541 eingebaut. Sie beschreibt ausschließlich nur Disketten, die ein " A" als Formatkennzeichen tragen. Andere
werden nicht verändert, wohl aber kann
von Ihnen gelesen werden. Es genügt nun
also, das Formatkennzeichen in ein anderes Zeichen umzuwandeln, und die 1541 wird keine Daten mehr darauf schreiben.
Dies geschieht im Prinzip ganz einfach.
Wir müssen lediglich den Diskheaderblock
einlesen, das 3 . Byte ( hier steht nämlich das Formatkennzeichen) in ein anderes Zeichen als " A" abwandeln und den
Block wieder auf die Diskette zurückschreiben. Abschließend muß die Diskette noch initialisiert werden, damit das
Betriebssystem der Floppy, das DOS, die
neue Formatkennung auch in den Floppyspeicher übernimmt.
Ein Programm, das eine Diskette mit
Schreibschutz versieht und ihn wieder
entfernt finden Sie auf dieser MD unter
dem Namen " FK. SCHREIBSCHUTZ" . Die Unterroutine, mit der eine Diskette geschützt
wird, steht in den Zeilen 400 bis 470 dieses Programms. Hier sind sie nochmals
aufgelistet:
Unterroutine " Diskette sichern" :
400 OPEN 1,8,15,"I": OPEN 2,8,2,"#" 410 PRINT#1,"U1 2 0 18 0" 430 PRINT#1,"B-P 2 2" 440 PRINT#2,"B"; 450 PRINT#1,"U2 2 0 18 0" 460 PRINT#1,"I" 470 CLOSE1:CLOSE2:RETURN
Zunächst einmal öffnen wir hier den Befehlskanal und übergeben gleichzeitig einen Initialisierungsbefehl an ihn. Mit
letzterem werden alle Grunddaten der
eingelegten Diskette ( z. B. ID, Formatkennung, etc.) in den Speicher der
Floppy übertragen. Man sollte vor einer
direkten Manipulation des Diskheaderblocks diesen Befehl aufrufen. Desweiteren öffnen wir einen Pufferkanal mit der
Kanalnummer 2( also Sekundäradresse 2) um Blockoperationen durchführen zu können. In Zeile 410 wird nun Spur 0 von
Track 18 in den Puffer, dem Kanal 2 zugeordnet ist, eingelesen. Dies tun wir
mit dem " U1"- Befehl, der besser ist als
" Block-Read"(" B-R") . Hiernach folgt die
Positionierung des Pufferzeigers auf das
2 . Byte ( mit dem 0 . Byte eigentlich das
dritte Byte) des Puffers. In Zeile 440 wird nun der Buchstabe " B" an diese Position geschrieben. Wichtig ist hierbei
das Semikolon (" ;") nach dem PRINT-Befehl, da letzterer ohne Semikolon noch
ein CHR$(13) nachsenden würde, womit wir
einen Teil der BAM überschreiben würden!
Nun muß der geänderte Block nur noch mit
Hilfe des " U2"- Befehls auf die Diskette
zurückgeschrieben werden. Damit unsere
Änderung auch in den Floppyspeicher
übernommen wird muß abschließend die
Diskette wieder initialisiert werden. In
Zeile 470 werden die beiden Filekanäle
wieder geschlossen und zum Hauptprogramm
zurückgekehrt.
Nun soll unser Programm den Diskettenschutz ja auch wieder rückgängig machen
können. Dies geschieht im Prinzip wieder
genauso. Wir müssen lediglich die fremde
Formatkennung wieder in ein " A" umwandeln. Jedoch ergibt sich hierbei ein
kleineres Problem. Dadurch, daß die Diskette ja schreibgeschützt ist, können
wir den modifizierten Disk-Header ja
nicht mehr auf die Diskette zurückschreiben! Hier behilft man sich mit
einem kleinen Trick. In der Speicherstelle $0101( dez.257) des Floppy-RAMs
" merkt" sich das DOS das Formatkennzei- chen der eingelegten Diskette. Es wird
bei jedem Initialisierungsbefehl wieder
aktualisiert. Ändern wir nun diese Speicherstelle so um, daß in ihr der Wert
" A" steht, so können wir dem DOS vorgaukeln, es hätte eine Diskette mit korrekter Formatkennung vor sich. Erst jetzt
ist es wieder möglich auf die Diskette
zu schreiben. Auch hier möchte ich Ihnen
die Unterroutine, die entsprechendes tut
auflisten. Sie steht im oben erwähnten
Programm in den Zeilen 300-370 :
Unterroutine " Diskette entsichern" :
300 OPEN 1,8,15,"I": OPEN 2,8,2,"#"
310 PRINT#1,"U1 2 0 18 0"
320 PRINT#1,"M-W";CHR$(1);CHR$(1);
CHR$(1);CHR$(65);
330 PRINT#1,"B-P 2 2"
340 PRINT#2,"A";
350 PRINT#1,"U2 2 0 18 0"
360 PRINT#1,"I"
370 CLOSE1:CLOSE2:RETURN
In den Zeilen 300 und 310 öffnen wir, wie gewohnt, unsere beiden Filekanäle
und lesen den Diskheaderblock in den
Puffer ein. Anschließend jedoch benutzen
wir den Memory-Write- befehl der Floppy
um den Inhalt von $0101 zu in " A" abzuändern. Die Adresse $0101 wird durch
das Low-Byte 1 und das High-Byte 1 dargestellt. Desweiteren wollen wir nur ein
Byte übertragen. Selbiges hat den AS-CII- Code 65, was dem Buchstaben " A" entspricht. In dieser Reihenfolge werden
die Parameter nun an den String " M-W" angehängt. Nach dieser Operation können
wir nun den Buffer-Pointer auf das Formatkennzeichen positionieren und über
den Pufferkanal den Buchstaben " A" heinschreiben. Da die Floppy seit dem " M-W"- Befehl glaubt, es läge eine Diskette
mit korrekter Formatkennung vor, können
wir in Zeile 350 auch erfolgreich den
Diskheaderblock zurückschreiben. Eine
Abschließende Initialisierung macht die
Diskette ab nun wieder beschreibbar.
Nun soll unser Programm aber auch in der
Lage sein, zu erkennen, ob eine Diskette
schreibgeschützt ist, oder nicht. Auch
dies ist sehr einfach zu realisieren.
Wir gehen dabei wieder den Weg über die
Speicherstelle $0101 des Floppy-RAMs.
Hier die Unterroutine die in den Zeilen
200 bis 260 zu finden ist:
Unterroutine "Formatkennung prüfen:"
200 OPEN 1,8,15,"I"
210 PRINT#1,"M-R";CHR$(1);CHR$(1);
CHR$(1)
220 GET#1,A$
230 PRINT "DISKETTE IST ";
240 IF A$="A" THEN PRINT "NICHT";
250 PRINT "GESCHUETZT!"
260 CLOSE1:RETURN
Hier wird zunächst nur der Befehlskanal
geöffnet. Einen Puffer benötigen wir
nicht. Gleichzeitig wird die Diskette
initialisiert und somit ihr Formatkenn- zeichen in die Speicherstelle $0101 übertragen. In Zeile 210 greifen wir
diesmal mit Hilfe des Memory-Read- Befehls (" M-R") auf selbige zu. Wieder
werden Lowund High-Byte 1, sowie die
Länge 1 als CHR$- Codes übergeben. Anschließend können wir das Zeichen aus
dem Befehlskanal auslesen. Es folgt nun
eine Prüfung, ob es dem Buchstaben " A" entspricht. Wenn ja, so wird zuerst der
Text " nicht" ausgegeben und anschließend
der Text " geschuetzt!" . Andernfalls gibt
das Programm nur " geschuetzt" aus. Zum
Schluß schließen wir den Befehlskanal
wieder und kehren zum Hauptprogramm
zurück.
2) ÄNDERN DES DISKETTENNAMENS UND DER ID
Sicherlich haben Sie schon einmal ein
Programm benutzt, das den Namen und die
ID einer Diskette nachträglich verändert, ohne Daten zu zerstören. Wollen wir nun einmal selbst so etwas schreiben.
Zunächst möchten wir den Diskettennamen
verändern. Wie Sie aus dem letzten Kurs
bestimmt noch wissen, steht der Name
einer Diskette in den Bytes 144-159 des
Dir-Header- Blocks. Um ihn zu ändern
brauchen wir lediglich diesen Block in
einen Pufferspeicher einzulesen und den
neuen Namen an dieser Position hineinzuschreiben. Dabei müssen wir noch auf
zwei Dinge achten: Ist der neue Name
kürzer als 16 Zeichen, so müssen die
restlichen Zeichen mit dem ASCII-Code
160 aufgefüllt werden. Das ist der Code
für ' SHIFT-SPACE' der von der Floppy
automatisch an kürzere Namen angefügt
wird. Desweiteren darf der neue Name
natürlich nicht länger als 16 Zeichen
sein, da wir sonst ja weitere Daten im
Diskheaderblock überschreiben würden.
Das Programm mit dem Sie Disknamen und
- ID ändern können, finden Sie auf dieser
MD unter dem Namen " FK. NAMECHANGE" . Hier nun ein Auszug mit der Namensänderungsroutine bei Zeile 200 :
Unterroutine " Diskname ändern" :
200 OPEN 1,8,15,"I": OPEN 2,8,2,"#"
210 PRINT#1,"U1 2 0 18 0"
220 PRINT#1,"B-P 2 144"
230 NA$=""
240 FOR I=1 TO 16
250 GET#1,A$: NA$=NA$+A$
260 NEXT
270 PRINT "AKTUELLER NAME: ";NA$
280 INPUT " NEUER NAME";NA$
285 IF LEN(NA$)>16 THEN NA$=
LEFT$(NA$,16)
290 IF LEN(NA$)<16 THEN NA$=NA$+
CHR$(160): GOTO290
300 PRINT#1,"B-P 2 144"
310 PRINT#2,NA$;
320 PRINT#1,"U2 2 0 18 0"
330 PRINT#1,"I"
340 CLOSE1:CLOSE2:RETURN
In den Zeilen 200 und 210 öffnen wir,
wie gewohnt, unsere Kanäle und lesen den
Diskheaderblock in den Floppypuffer.
Anschließend wird der Pufferzeiger auf
das 144 . Byte des Puffers positioniert.
In den Zeilen 230-260 werden nun die 16 Bytes des Diskettennamens mit Hilfe einer Schleife ausgelesen und in der Variablen NA$ abgelegt. Diese wird anschließend ausgegeben um den aktuellen
Diskettennamen anzuzeigen. Es wird daraufhin nach dem neuen Namen gefragt, der nun seinerseits in die Variable NA$ kommt. In der Zeile 285 wird zunächst
geprüft, ob der neue Name zu lang ist.
Wenn ja, so wird er auf die ersten 16 Zeichen gekürzt. In Zeile 290 wird abgefragt, ob der eingegebene Name nicht zu
kurz ist. Wäre das der Fall, so würde
beim Schreibvorgang der alte Name nicht
ganz überschrieben werden und wäre dann
noch sichtbar. In diesem Fall füllt die
Schleife in Zeile 290 den Rest des
Strings NA$ mit ' SHIFT-SPACES' auf. Erst
jetzt kann wieder auf das erste Byte des Namens ( Byte 144 des Diskheaderblocks) positioniert werden und der String NA$ dorthin geschrieben werden. Abschließend
wird die Änderung mittels " U2" auf der
Diskette aktualisiert, letztere nochmmals initialisiert und alle Kanäle werden geschlossen.
Wollen wir die ID einer Diskette verändern, so müssen wir ähnlich arbeiten.
Hierbei wollen wir berücksichtigen, daß
wir für die Directoryanzeige sogar fünf
Zeichen ( anstelle von 2) zur Verfügung
haben. Sie sicherlich ist Ihnen aufgefallen, daß in den letzten drei Zeichen
der ID im Directory ( rechts oben) immer
der Text "2 A" steht, was eine Formatkennung darstellt. Diese Formatkennung
hat jedoch keinerlei Einfluß auf die, die im dritten Byte des Diskheaderblocks
zu finden ist. Sie wird lediglich zur
Anzeige beim Laden des Diretorys benötigt und kann im Prinzip beliebig geändert werden. Die drei Formatkennzei- chenbytes liegen glücklicherweise auch
direkt hinter den beiden Bytes für die
Disketten-ID, nämlich in den Bytes 162-166 des Diskheaderblocks. Hier nun der
Programmteil, der die ID einer Diskette
ändert:
Unterroutine "ID ändern" 400 OPEN 1,8,15,"I": OPEN 2,8,2,"#" 410 PRINT#1,"U1 2 0 18 0" 420 PRINT#1,"B-P 2 162" 430 ID$="" 440 FOR I=1 TO 5 450 GET#1,A$: ID$=ID$+A$ 460 NEXT 470 PRINT "AKTUELLE ID: ";ID$ 480 INPUT " NEUE ID";ID$ 490 IF LEN(ID$)>5 THEN ID$=LEFT$(ID$,5) 500 PRINT#1,"B-P 2 162" 510 PRINT#2,ID$; 520 PRINT#1,"U2 2 0 18 0" 530 PRINT#1,"I" 540 CLOSE1: CLOSE2: RETURN
Im Prinzip arbeitet diese Unterroutine
genauso wie die, die den Namen ändert.
Nur daß diesmal nicht 16, sondern nur 5 Zeichen für die ID eingelesen werden
müssen. Desweiteren kann eine ID auch
kürzer sein, als 5 Zeichen, nämlich
dann, wenn Sie wirklich nur die beiden
ID-Zeichen ändern wollen, das Formatkennzeichen aber gleich bleiben soll.
Deshalb wird in Zeile 490 der String ID$ nur auf 5 Zeichen gekürzt, falls er länger sein sollte. Ein kürzerer Text wird
als solcher übernommen und an die Entsprechende Position ( nämlich 162) geschrieben. Auch hier wird die Änderung
dann mittels " U2" gespeichert und die
Diskette initialisiert.
Das soll es dann wieder einmal gewesen
sein für diesen Monat. Ich hoffe ich
habe Sie zum " Spielen" mit den Blockbefehlen animiert. Nächsten Monat wollen
wir uns mit einer weiteren Anwendung der Blockbefehle beschäftigen und dann die
Programmierung der Floppy in Maschinensprache angehen.
(ub)
Floppy-Kurs:
"Es rappelt in der Kiste..."
(Teil 6)
Hallo und herzlich Willkommen zum sechsten Teil unseres Floppykurses. Wir wollen unsere Kenntnisse auch hier wieder
vertiefen und zwei weitere Beispielprogramme kennenlerenen. Eines, um das Directory auf dem Bildschirm anzuzeigen
und eines um gelöschte Files wieder zu
retten.
BEISPIEL 1: DIRECTORY ANZEIGEN
Unser erstes Programmbeispiel soll eine
Routine sein, mit der Sie das Directory
der eingelegten Diskette ohne Speicherverlust einlesen können. Dies ist ein
Hinweis auf eine besondere Eigenheit der Floppy. Wenn wir uns nämlich das Inhaltsverzeichnis einer Diskette einfach
nur anzeigen lassen wollen, so können
wir durch Angabe des Filenamens "$" die
Floppy dazu bewegen, uns sehr viel Arbeit abzunehmen. Sie beginnt dann nämlich damit, alle Directoryblöcke von
selbst einzulesen und sie für uns aufzubereiten. Ein direktes " herumpfuschen" auf der Diskette mittels der Block-Befehle entfällt.
Wollen wir uns nun verdeutlichen, was
passiert, wenn wir wie gewohnt das Directory mit LOAD"$",8 in den Speicher
des Computers laden. Wie schon erwähnt, ist das Dollarzeichen für die Floppy das
Kennzeichen für eine spezielle Aufbereitung des isketteninhalts. Sie sendet an
den C64 nun Daten, die dieser, wie bei
auch beim Laden eines normalen Programms
in seinen Basic-Speicher schreibt. Der
Computer behandelt das Directory im
Prinzip also wie ein Basic-Programm.
Dies wird dadurch bestätigt, daß das eingelesene Directory auch wie ein Basic- Programm, mit dem Befehl LIST auf
dem Bildschirm angezeigt wird. Sie können es sogar mit NEW wieder löschen, oder mit RUN starten, was jedoch nur
einen Syntax-Error bewirkt, da das Directory ja keine echten Basic-Befehle
enthält. Sinnigerweise übermittelt die
Floppy in der Directoryliste als erstes
auch immer die Blockanzahl eines Files, was für das Basic des C64 einer Zeilennummer entspricht. Diese Zeilennummern
sind zwar nicht immer in einer numerischen Reihenfolge, jedoch macht das Basic unseres Computers da keinen Unterschied. Der interne Aufbau eines Basic-Programms erlaubt es tatsächlich, Zeilennummern wahllos zu vergeben. Wenn wir
ein Programm direkt eingeben ist das
natürlich nicht möglich, da die Eingaberoutine des Betriebssystems die Zeile
anhand der Zeilennummer automatisch an
der logisch richtigen Position des Programms einfügt.
Der langen Rede kurzer Sinn ist, daß wir
beim Öbermitteln des Directorys von der
Floppy darauf achten müssen, daß diese
es uns in einer Form schickt, die eigentlich nur der Basic-Programm- Speicher
versteht, so daß die LIST-Routine das
' Directory-Programm' listen kann. Deshalb gibt e) einige Bytes, die für uns
wertlos sind und überlesen werden müssen. Hierzu erkläre ich Ihnen einfach
einmal den Aufbau des Files, das uns die
Floppy bei Angabe des Filenamens "$" übermittelt. Zuerst erhalten wir von
ihr, wie bei jedem File, daß normalerweise mittels LOAD in den Speicher des
Computers gelangt, eine Adresse, an die
das " Programm" geladen werden soll. Dies
ist die Basic-Startadresse $0801( dez.
2049) im Low/ High-Byteformat. Wir benötigen diese natürlich nicht, und können
sie deshalb überlesen. Von nun an ist
der Aufbau einer jeden Directoryzeile
gleich. Zuerst werden dabei zwei Linkbytes übertragen, die der Basic-Interpre-
ter benötigt, um die einzelnen Zeilen zu
verketten. Beide können wir getrost
überlesen. Als nächstes erhalten wir
dann die Blockanzahl in Low/ High-Byte- Darstellung, was für den Basic-Inter- preter einer Zeilennummer entpräche.
Diese Nummer müssen wir nun erst einmal
umrechnen, bevor wir sie ausgeben können. Hieran anschließend folgen nun ein
oder mehrere Spacezeichen, sowie der
Filename und die Filekennung im Klartext. Alle diese letzten Zeichen werden
im ASCII-Code übertragen, so daß wir sie
lediglich mit PRINT ausgeben müssen. Am
Ende bekommen wir dann noch eine Null
übermittelt, die das Ende der ( Basic-) Zeile kennzeichnet. An ihrer Stelle
müssen wir lediglich einen Zeilenvorschub ausgeben ( ein PRINT ohne Parameter) . Das Ende des Files ist natürlich
dann erreicht, wenn die Statusvariable
ST gleich 64 ist. Im Prinzip ist alles
also ganz einfach. Hier ist das entsprechende Basic-Programm, Sie finden es
auf dieser MD unter dem Namen " FK. DIR" :
10 gosub200
20 end
30 :
31 :
90 rem *****************
91 rem * zeichen lesen *
92 rem *****************
93 :
100 get#1,a$
110 ifa$=""thena=0:return
120 a=asc(a$):return
130 :
131 :
190 rem **********************
191 rem * directory anzeigen *
192 rem **********************
193 :
200 print"{clr}";:open1,8,0,"$"
210 fori=1to4:get#1,a$:next
215 :
220 gosub100:bl=a
230 gosub100:bl=bl+256*a
240 print bl;
250 get#1,a$:printa$;
260 ifa$<>""then250
270 print
280 fori=1to2:get#1,a$:next
290 ifst=0then220
300 close1
310 return
In den Zeilen 100-120 sehen Sie eine
Routine, die uns ein Byte mittels GET# einliest und es als numerischen Wert in
der Variablen " a" abspeichert. Diese
Routine ist deshalb notwendig, da eine
Umwandlung des Strings " a$" bei dem Bytewert 0 einen " illegal quantity error" verursacht. Das liegt daran, daß ein
String, der nur den Bytewert 0 als Zeichen enthält, einem Leerstring entspricht. Deshalb muß mit der IF-THEN- Abfrage überprüft werden, ob " a$" ein
Leerstring ist, oder nicht.
Ab Zeile 200 sehen wir nun das Programm, das das Directory einliest und auf dem Bildschirm ausgibt. In Zeile 200 wird
zunächst einmal der Bildschirm gelöscht
und der Filekanal, der uns das Directory
sendet, geöffnet. Ich habe hier ganz
bewußt die Sekundäradresse 0 benutzt, da
sie der Floppy ja automatisch mitteilt, daß wir ein Lesefile öffnen ( sh. voherige Teile dieses Kurses) . In Zeile 210 werden nun die Startadresse und die beiden Linkbytes der ersten Zeile überlesen.
Danach beginnt die Hauptschleife des
Unterprogramms. In den Zeilen 220 und
230 lesen wir hier zunächst mit Hilfe
unserer " Zeichen lesen"- Unterroutine, Lowund High-Byte der Blockanzahl aus, verrechnen diese beiden Werte zu der
reellen Blockanzahl und speichern sie in
der Variablen " bl"( Wert= Lowbyte+256*- Highbyte) . Die Blockanzahl wird jetzt in
Zeile 240 auf dem Bildschirm ausgegeben.
Wir hängen an den PRINT-Befehl ganz bewußt ein Semikolon an, damit der folgende Text direkt hinter der Blockanzahl ausgegeben wird. Dies geschieht in den
Zeilen 250 und 260 . Dort lesen wir jeweils ein Zeichen mittels GET# ein, und
geben es anschließend auf dem Bildschirm
aus. War das eingelesene Zeichen ein
Leerstring, entspricht es dem Bytewert 0 und die Zeile ist zu Ende. Jetzt wird in
Zeile 270 eine Leerzeile ausgegeben, daß
der Cursor am Anfang der nächsten Zeile
steht. In Zeile 280 werden die beiden
Linkbytes der folgenden Directory-Zeile
überlesen. In der IF-THEN- Abfrage in
Zeile 290 wird überprüft, ob das Ende
des Files schon überlesen wurde. Wenn
nicht, wird an den Anfang der Hauptschleife verzeigt und alles beginnt von
vorne. Wenn doch, so wird der Filekanal
geschlossen und zum aufrufenden Programm
zurückverzweigt.
BEISPIEL 2: GELOESCHTE FILES RETTEN
Um Sie in die Benutzung der Blockbefehle weiter einzuführen, wollen wir uns jetzt
einem weiteren Programmbeispiel in BASIC
zuwenden. Wir wollen ein einfaches " UN-DELETE"- Programm schreiben. Mit ihm soll
es möglich sein, versehentlich mit dem
Floppybefehl " SCRATCH"(" S:") gelöschte
Dateien wiederherzustellen. Hierzu wollen wir zunächst einmal klären, was die
Floppy eigentlich macht, wenn sie ein
File löschen soll. Als erstes bekommt
Sie einen Befehl übermittelt, der sie
dazu auffordert ein ( oder auch mehrere) Files zu löschen. Als Beispiel wollen
wir einmal ein File mit Namen " TEST" heranziehen. Der entsprechende Floppybefehl an den Befehlskanal muß also lauten
" S: TEST" . Hieraufhin beginnt die Floppy
nun, das Inhaltsverzeichnis der eingelegten Diskette nach einer Datei zu
durchsuchen, die den Namen " TEST" trägt.
Wird sie gefunden, so trägt die Lösch-Routine des Floppy-Betriebssystems lediglich den Wert 0 als Filetyp für dieses
File ein, und sucht nun alle Blocks he- raus, die von dem File belegt werden.
Jetzt holt sich die Floppy die BAM der
Diskette in den Speicher, kennzeichnet
alle vom File belegten Datenblocks als
' unbelegt' und schreibt die BAM wieder
zurück auf die Diskette. Der Filetyp 0 entspricht dem Filetyp " DEL", der normalerweise im Directory nicht mehr angezeigt wird. An dieser Leerstelle wird
das File einfach übersprungen. Im Prinzip sind aber noch alle seine Informationen auf der Diskette enthalten. Zumindest einmal solange, bis Sie wieder
ein neues File auf die Diskette schreiben. Dann nämlich sucht sich die Floppy
den ersten freien Directoryeintrag heraus, der in unserem Fall, der des Files
" TEST" ist, und trägt dort das neue File
ein. Desweiteren kann es dann auch passieren, daß die Datenblocks, die von
" TEST" belegt wurden möglicherweise von
denen des neuen Files überschrieben werden. Ein UNDELETE-Programm hat deshalb
nur dann einen Sinn, wenn noch nichts neues auf die Diskette geschrieben wurde
( obwohl es auch andere Programme gibt, die selbst dann noch das eine oder andere retten können - hierauf kommen wir
später zurück) . Es muß lediglich alle
Einträge im Directory nach Filetyp-0- Einträgen durchsuchen und diese Anzeigen. Hieraufhin muß vom Benutzer entschieden werden, welchen Filetyp das
alte File hatte ( dies ist die einzige
Information, die über selbiges verloren
ging) . Ist dieser angegeben, so braucht
unser Programm nur noch den Entsprechenden Code in den Fileeintrag zu schreiben
und alle Blocks des Files zu verfolgen, die von ihm belegt wurden und sie abermals als ' belegt' zu kennzeichnen. Dies
kann man über die umständliche Metode
tun, indem man aus den Bytes 1 und 2 des
Fileeintrags Track und Sektor ersten
Datenblocks ermittelt, und nun alle verketteten Blöcke ( nächster Block steht
immer in den ersten beiden Bytes eines
Datenblocks) heraussucht uns diese mit- tels Block-Allocate- Befehl (" B-A") als
belegt kennzeichnet. Die zweite Methode
ist einfach den Validate-Befehl der
Floppy zu benutzen. Dieser sucht nämlich
automatisch alle Blocks von gültigen
Fileeinträgen im Directory heraus und
kennzeichnet sie als ' belegt' . Beide
Methoden haben ihre Vorund Nachteile.
Benutzen wir die erste Methode, so haben
wir bei höherem Programmieraufwand eine
weitaus höhere Arbeitsgeschwindigkeit
( da nur die Blocks eines Files herausgesucht werden müssen und nicht aller Files der Diskette, was sich vor allem
dann bemerkbar macht, wenn Sie besonders
viele Files auf der Diskette haben) .
Andererseits ist es bei dieser Methode
nicht so einfach, die Blocks eines REL-Files wiederzubelegen, da diese mit
zusätzlichen Side-Sektor- Blöcken arbeiten, die ebenfalls gesucht werden müssen. Das aber wiederum macht der Validate- Befehl für uns. Ausserdem arbeitet er
bei Disketten mit wenigen Files weitaus schneller als unsere Routine, da er ja
ein Floppyprogramm ist und ein zeitraubender Datenaustausch zwischen Floppy
und C64 entfällt. Da wir unser Programm
in BASIC schreiben wollen, ist er bestimmt immer noch etwas schneller. Ich
werde mich in meinem Beispiel nun jedoch
auf die " von Hand"- Methode beschränken.
Wenn Sie möchten, können Sie das Programm ja so erweitern, daß z. B. bei weniger als fünf Files automatisch der
Validate-Befehl benutzt wird und im anderen Fall die " von Hand"- Routine.
Zunächst will ich Ihnen nun eine Unterroutine vorstellen, die uns das Inhaltsverzeichnis einliest und alle Informationen darüber in Variablenfeldern
ablegt. Sie steht in dem Beispielprogramm " FK. UNDEL" auf dieser MD in den
Zeilen 200-510 . Wir benötigen sie, um
die einzelnen Fileeinträge zu isolieren
und feststellen zu können, welcher Eintrag einem DEL-File entspricht. Ich habe die Routine jedoch so ausgelegt, daß Sie
sie auch für andere Zwecke benutzen können, da sie so ziemlich alle Informationen des Directorys ausliest.
Vorher sind jedoch noch einige Anmerkungen zu der Routine zu machen. Vorab sei
gesagt, daß in den Zeilen 600-620 dieselbe Routine steht, wie wir sie auch
schon im Dir-Programm benutzten. Sie
liest ein Zeichen ein, und wandelt es in
einen Bytewert um, der nach Aufruf in
der Variablen " a" steht. Desweiteren
benötigen wir noch einige Variablenfelder, die im Hauptprogramm mit Hilfe der
DIM-Anweisung dimensioniert werden müssen. Hier eine Liste der Felder:
Name Elemente Inhalt
TY$ 144 Filetyp FT 144 Starttrack des Files FS 144 Startsektor des Files BL 144 Blockanzahl des Files NA$ 144 Name des Files
DT 18 Tracknummern des Dirs DS 18 Sektorennummern des Dirs
Die ersten fünf Felder aus dieser Liste
dienen ausschließlich der Speicherung
von Informationen über ein File. Da das
Directory maximal 144 Einträge beinhalten kann, werden alle diese Felder auf
maximal 144 Elemente dimensioniert. Die
Felder DT und DS werden benutzt um Track
und Sektor der Folgeblocks des Directorys zu speichern. Rein theoretisch ist
das zwar nicht unbedingt notwenig, da
die Folge der Directoryblöcke immer
gleich ist ( Block 1 in 18/1, Block 2 in
18/4, etc.), jedoch ist so einfacher mit
den Blocks zu handhaben. Im Prinzip
könnten wir auch das Feld DT wegfallen
lassen, da das Directory IMMER in Track
18 steht, jedoch kann es sich ja auch um
eine manipulierte Diskette handeln, die
das Directory woanders stehen hat ( hierauf wollen wir in einem der nächsten
Teile des Floppykurses zurückkommen) .
Nun möchte ich Ihnen die Routine, mit
denen wir die Diretcoryinformationen
einlesen nicht länger vorenthalten. Hier
der erste Teil von Zeile 200 bis 295 :
200 print"Gelesene Files:" 210 open1,8,15,"i":open2,8,2,"#" 220 print#1,"u1 2 0 18 0" 230 gosub600:tr=a 240 gosub600:se=a 245 : 250 dn$="":id$="" 260 print#1,"b-p 2 143" 270 fori=0to15:get#2,a$:dn$=dn$+a$:next 280 print#1,"b-p 2 162" 290 fori=1to5:get#2,a$:id$=id$+a$:next 295 :
In diesem Teil unserer Unterroutine werden die Vorbereitungen zum Einlesen des
Directorys getroffen, sowie der Diskettenname und die ID in die Variablen
" dn$" und " id$" eingelesen. Diese Variablen können Sie im Hauptprogramm eben- falls weiterverwenden.
Nachdem also in Zeile 200 ein Informationstext ausgegeben wurde, öffnen wir
in Zeile 210 den Befehlskanal und einen
Pufferkanal. Ersterer erhält die Filenummer 1, letzterer die Filenummer 2 .
Beim Öffnen des Befehlskanals initialisieren wir die Diskette auch gleichzeitig. In Zeile 220 senden wir nun den
ersten Befehl an die Floppy. Der U1- Befehl in dieser Zeile liest uns den
Dir-Header- Block ( Track 18, Sektor 0) in
den Puffer. In Zeile 230 und 240 lesen
wir nun die ersten beiden Bytes dieses
Blocks ein, und ordnen sie den Variablen
TR und SE zu, die als Variablen für den
aktuellen Track/ Sektor benutzt werden.
Sie enthalten nun Track und Sektor des
ersten Directoryblocks. Bevor wir uns
jedoch daran machen dieses auszulesen, nehmen wir uns aus dem Dir-Header- Block
noch den Diskettennamen und ID heraus.
In Zeile 250 werden diese beiden
Variablen zunächst einmal gelöscht. Als nächstes positionieren wir den Pufferzeiger auf die Position 144 des Dir-Header- Blocks. Die 16 dort folgenden
Bytes enthalten den Namen der Diskette, der mit Hilfe der Schleife in Zeile 270 in dn$ eingelesen wird. Ebenso wird mit
der ID verfahren. Sie steht in den 5 Bytes ab Position 163 . In Zeile 280 wird
darauf positioniert und der String id$ wird in Zeile 290 eingelesen. Kommen wir
nun zum zweiten Teil der Routine, in dem
die Directoryeinträge eingelesen werden:
299 q=0 300 print#1,"u1 2 0";tr;se 305 a=int(q/8):dt(a)=tr:ds(a)=se 310 gosub600:tr=a 320 gosub600:se=a 330 forj=1to8 335 printq 340 gosub600:ty(q)=a 350 gosub600:ft(q)=a 360 gosub600:fs(q)=a 370 x$="" 380 fori=1to16:get#2,a$:x$=x$+a$:next 390 na$(q)=x$ 400 fori=1to9:get#2,a$:next 410 gosub600:bl(q)=a 420 gosub600:bl(q)=bl(q)+a*256 425 get#2,a$:get#2,a$ 430 q=q+1 440 next j 450 iftr<>0then300 460 : 470 close1:close2 480 q=q-1 500 ifna$(q)=""thenq=q-1:goto500 510 return
In Zeile 299 wird nun zunächst die Laufvariable " q" initialisiert. Sie gibt
später an, wieviele Einträge in diesem
Directory gefunden wurden. Der U1- Befehl
in Zeile 300 liest nun den ersten Directoryblock ein, dessen Track und Sektor
ja noch in TR und SE stehen. Anschliessend werden beide Variablen im 0 .
Element von " dt" und " ds" abgelegt.
Hierbei wird die Hilfsvaiable " a" als
Indexvariable verwendet. Ihr wird der
Wert ( q dividiert durch 8) zugeordnet, da in einem Block ja immer 8 Fileeinträge stehen. In den Zeilen 310 und 320 werden nun schon einmal Trackund
Sektornummer des Folgeblocks in TR und
SE eingelesen.
Bitte Teil 2 des Floppy-Kurses laden !
Teil 2 Floppy-Kurs 6
Nun wird eine Schleife durchlaufen, die
die acht Fileeinträge dieses Directoryblocks in den entsprechenden Feldern
ablegt. Zur Information geben ich Ihnen
hier nocheinmal den Aufbau eines Directoryeintrags an ( sh. Floppy-Kurs, Teil
4) :
ByteNr. Aufgabe
000 Byte für den Filetyp.
001-002 Track und Sektor des ersten Datenblocks dieses Files.
003-01816 Bytes für den Filenamen.
019-020 Bei relativen Files stehen hier
Track und Sektor des ersten Si-Sektor- Blocks ( sonst unbenutzt)021 Bei relativen Files seht hier die Länge eines Datensatzes ( sonst unbenutzt) .
022-025 unbenutzt 026-027 Zwischenspeicher des Tracks und Sektors beim Öberschreiben mit
dem Klammeraffen ("") vor dem
Filenamen.
028-029 Hier steht die Länge des Files
in Blocks als 16- Bit-Lo/ Hi-Zahl
030-031 unbenutzt
In den Zeilen 340-360 werden nun, obiger
Liste entsprechend, der Reihe nach das
Filetypenbyte, sowie Starttrack und
- sektor des Files in die entsprechenden
Felder eingelesen. Die anschließenden 16 Zeichen stellen den Filenamen dar und
werden als Text, mit Hilfe einer
Schleife in das Feld " na$" eingelesen.
In Zeile 400 überlesen wir nun 9 Zeichen
des Fileeintrags, die für uns nicht von
Nutzen sind. In den Zeilen 410 und 420 werden nun noch Lowund High-Byte der
Blockanzahl eingelesen und umgerechnet
im Feld " bl" abgelegt. Hiernach werden
noch die beiden letzten unbenutzten
Bytes überlesen, um den Pufferzeiger auf den Anfang des nächsten Eintrags zu
positionieren. Nun wird die Laufvariable
q um eins erhöht und an den Schleifenanfang zurück verzweigt. Ist die
Schleife 8 Mal durchlaufen worden, so
haben wir alle Einträge dieses
Directoryblocks eingelesen und können
den nächsten Block laden. Da der letzte
Directoryblock immer Track 0 als Folgetrack beinhaltet können wir mit der IF-THEN- Abfrage in Zeile 450 prüfen, ob der
letzte benutzte Directoryblock schon
eingelesen wurde, oder nicht. Ist " tr" ungleich null, so muß die Schleife nochmals wiederholt werden und es wird zu
Zeile 300 zurückverzweigt. Im anderen
Fall sind wir beim letzten Directoryblock angelangt und können die Filekanäle schließen. In Zeile 480 wird nun
die Laufvariable " q" um 1 erniedrigt, da
dieser Feldindex beim letzten Durchlauf
ja noch keine neue Zuweisung erhielt.
Zeile 500 dient nun dazu, den effektiv
letzten Eintrag in diesem Directoryblock herauszusuchen, da ja nicht unbedingt
alle 8 Einträge in diesem Block benutzt
sein müssen. Dies geschieht einfach
darin, daß wir " q" solange herunerzählen
bis in der Variablen na$( q) ein Text
steht. Da Leereinträge nur Nullen enthalten, ist der Filename bei solchen
Einträgen 16 Mal der Wert CHR $(0), was
einem Leerstring ("") entspricht.
Abschließend wird in das aufrufende Programm zurückverzweigt. In unseren Feldvariablen befinden sich nun alle Informationen des Directorys, sowie der
Diskettenname in " dn$" und die ID in
" id$" . In der Laufvariablen " q" steht
die Anzahl der vorhandenen Einträge
minus 1( beachten Sie bitte, daß im
Indexfeld 0 ebenfalls ein Eintrag enthalten ist." q" bezeichnet lediglich die
Nummer des letzten Eintrags) . Nun wissen
wir also schon, wie wir die Directoryinformationen in den Computer bekommen.
Die Hauptroutine unseres UN-DEL- Progamms
muß jetzt also nur noch die Unterroutine bei Zeile 200 aufrufen um sie zu
erhalten. Um jetzt alle DEL-Einträge
herauszusuchen, müssen wir lediglich
alle Einträge heraussuchen, die in den
unteren 3 Bits des Filetypenbytes den
Wert 0 stehen haben. Wir müssen uns deshalb auf die unteren 3 Bits beschränken, da in den Bits 7 und 6 ja auch noch Informationen über das File gespeichert
sind. In den Zeilen 1100-1120 des Hauptprogramms werden diese Einträge nun herausgesucht und deren Feldindizes im
Feld " li" abgelegt. Das Hauptprogramm
von UNDEL beginnt übrigens bei Zeile
1000 . Aus Platzgründen will ich Ihnen ab
jetzt nur noch die Zeilen auflisten, die
für uns interessant sind. Der Rest dient
hauptsächlich der Bildschirmformatierung
und soll uns hier deshalb nicht interessieren. Das ganze Programm können Sie
sich ja einmal auf dieser MD anschauen.
Hier nun die Zeilen 1100-1120 :
1100 z=0
1105 fori=0 toq 1110 if( ty( i) and7)=0 thenli( z)= i: z= z+11120 next
Wie Sie sehen, benutzen wir hier die
Laufvariable " z" als Indexvariable für
das Feld " li" . Mit dem Ausdruck " ty( i) and 7" isolieren wir die unteren drei
Bits des Typenbytes und löschen die
evtl. gesetzten Bits 7 und 6 für den
IF-THEN- Vergleich. Wenn " z" nun größer
Null ist, so wurden DEL-Files gefunden.
Selbige werden in den Zeilen 1190-1230 auf dem Bildschirm ausgegeben und es
wird gefragt, welches davon gerettet
werden soll. In den Zeilen 1240 bis 1350 wird nun nach dem Typ des Files gefragt
und ob es evtl. auch vor erneutem
Löschen geschützt werden soll. Hier
wieder ein Programmauszug:
1240 gosub100:print"Zu retten: ";na$(li(
1250 print"0 - DEL"
1260 print"1 - SEQ"
1270 print"2 - PRG"
1280 print"3 - USR"
1290 print"4 - REL"
1300 input"Welchen Filetyp soll ich
zuordne ";t1
1310 if(n<0)or(n>4)then1300
1320 print"File auch schuetzen (J/N) ?"
1330 geta$:ifa$=""then1330
1340 ifa$="j"thent1=t1+64
1350 t1=t1+128:ty(li(n))=t1
Wie Sie sehen, wird in die Variable " t1" eine Zahl zwischen 0 und 4 eingelesen.
Die Zahlen, die die einzelnen Typen
zuordnen, entsprechen den Codes, die
auch die Floppy zur Erkennung des Filetyps benutzt. In den Zeilen 1320-1340 wird nun gefragt, ob das File auch vor
dem Löschen geschützt werden soll. Dies
regelt Bit 6 im Filetyp-Byte. Soll das
File geschützt werden, so wird zu der
Variablen " t1" der Wert 64 hinzuaddiert, was dem Setzen des 6 . Bits entspricht.
Zusätzlich müssen wir noch Bit 7 setzen, das anzeigt, daß das File ein gültiges File ist. Dies geschieht durch addieren des Wertes 128 . Nun müssen wir nur
noch den neuen Wert für den Filetyp in
die Feldvariable " ty" übernehmen. Als
nächstes muß der neue Filetyp im Directory eingetragen und die Datenblocks
des Files als ' belegt' gekennzeichnet
werden. Dies geschieht in den Zeilen
1370-1550 . Hier wieder ein Auszug:
1370 gosub100:print"Schreibe neuen
Eintrag"
1380 bl=int(li(n)/8):ei=li(n)-bl*8
1390 tr=dt(bl):se=ds(bl)
1400 open1,8,15,"i":open2,8,2,"#"
1410 print#1,"u1 2 0";tr;se
1420 po=2+ei*32
1430 print#1,"b-p 2";po
1440 print#2,chr$(t1);
1450 print#1,"u2 2 0";tr;se
1460 :
In den Zeilen 1380-1390 wird nun zunächst den Variablen TR und SE die Werte für den Directoryblock, in dem der
Eintrag steht zugewiesen. Als nächstes
öffnen wir einen Befehlsund einen
Pufferkanal mit den logischen Filenummern 1 und 2( wie auch schon in der
Dir-Lese- Routine) . In Zeile 1410 wird
der Block des Eintrags eingelesen.
Nun muß der Pufferzeiger auf den Anfang
des Eintrags positioniert werden. Da
jeder Fileeintrag 32 Bytes lang ist, errechnet sich seine Anfangsposition aus
seiner Position im Block ( steht in der
Variablen " ei", die in Zeile 1380 definiert wurde) multipliziert mit 32 .
Zusätzlich müssen wir noch zwei Bytes
aufaddieren, in denen Trackund
Sektornummer des Folgeblocks stehen
( ganz am Anfang des Directoryblocks) . In
Zeile 1430 wird nun auf die errechnete
Position positioniert. Nun müssen wir an
dieser Stelle nur noch das neue Typenbyte eintragen ( geschieht in Zeile 1440) und den Directoryblock mittels " U2" wieder auf die Diskette zurückschreiben.
Schon ist der Fileeintrag geändert!
Zum Schluß müssen wir noch alle vom File
belegten Blocks heraussuchen und wieder
neu belegen. Den ersten davon finden wir
in den Feldern " ft" und " fs" . Hier
wieder ein Programmauszug:
1465 z=0 1470 print"Belege Blocks neu... " 1480 tr=ft(li(n)):se=fs(li(n)) 1490 print#1,"b-a 0";tr;se 1500 print#1,"u1 2 0";tr;se 1505 z=z+1 1510 gosub600:tr=a 1520 gosub600:se=a 1530 iftr<>0then1490 1540 close1:close2 1550 printz;"Blocks gefunden."
Hier wird die Variable " z" dazu benutzt, die gefundenen Blocks zu zählen. In Zeile 1480 werden nun die Feldeinträge in " ft" und " fs" in TR und SE Übertra- gen. Zeile 1490 benutzt nun den Block-Allocate- Befehl um diesen Block als
' belegt' zu kennzeichnen. In Zeile 1500 wird er dann in den Puffer gelesen, da
seine ersten beiden Bytes ja auf den
nächsten Block des Files zeigen. Dessen
Trackund Sektornummer wird nun in den
Zeilen 1510 und 1520 in TR und SE eingelesen und für den nächsten Durchlauf
der Schleife verwendet. Sollte TR jedoch
den Wert 0 aufweisen, so sind wir beim
letzten Block angelangt und können die
Blockbelegung beenden. Dies regelt die IF-THEN- Anweisung in Zeile 1530 .
Somit wären alle wichtigen Teile des UN-DEL- Programms besprochen. Um einen
Gesamtüberblick zu erhalten, rate ich
Ihnen, sich das Programm auf dieser MD
einmal auszudrucken und anzuschauen.
Öbrigens beinhaltet das Programm noch
einen kleinen Schönheitsfehler: Wenn Sie
nämlich z. B.9 Files auf einer Diskette
haben, und das letzte davon löschen, so findet es die Directory-Lese- Routine
nicht mehr. Das liegt daran, daß nach
dem Löschen des Eintrags der zweite
Directoryblock ja nicht mehr benötigt
wird und deshalb als Folgeblock Track 0, Sektor 255 im ersten Directoryblock
eingetragen wird. Um diesen Fehler zu
beheben, können Sie ja eine Routine
schreiben, die alle Directoryblocks der
Reihe nach einliest. Das ist zwar sehr
zeitaufwendig, könnte jedoch den Fehler
beheben. Sie können dabei davon ausgehen, daß die Folgetracks und - sektoren
beim Directory immer gleich sind. Bei
einem vollen Directory (144 Einträge), können Sie so diese Einträge mit Hilfe
eines Diskettenmonitors einfach
herausfinden.
Ich verabschiede mich hiermit von Ihnen
bis zur nächsten Ausgabe, wo wir uns an
die Floppyprogrammierung in Assembler
heranwagen möchten.
(ub)
----------------------------------------
Floppy-Kurs:
"Es rappelt in der Kiste..."
(Teil 7)
----------------------------------------
Hallo und herzlich Willkommen zum siebten Teil des Floppy-Kurses. In diesem
Monat möchten wir uns an die Floppy-Programmierung in Assembler heranwagen.
Hierbei werden wir alle notwendigen Routinen zum I/ O-Handling von Maschinenspache aus kennenlernen. Allerdings sollten
Sie schon einige Assembler-Vorerfahrung
mitbringen und zumindest Kenntnis vom
Befehlssatz des 6510- Prozessors haben.
DER EINSTIEG IN ASSEMBLER
Wie Sie bemerkt haben, waren alle bishe- rigen Programmbeispiele und Befehlserläuterungen in BASIC programmiert. Dies
diente hauptsächlich der Einfachheit
halber. Wenn Sie nun ein angehender
Assemblerprogrammierer sind, so werden
Sie sich desöfteren schon einmal gefragt
haben, wie Sie die Floppy in Maschinensprache ansprechen können. Dies unterscheidet sich von BASIC zwar schon in
einigen Punkten, da es etwas aufwendiger
ist, jedoch können wir hier komplett auf
schon im Betriebssystem des 64 ers vorhandene Routinen zurückgreifen, die lediglich mit den richtigen Parametern
gefüttert werden müssen. Diese Routinen
sind dieselben, die auch vom BASIC des
C64 benutzt werden, weshalb die Parameterübergabe der von BASIC sehr ähnlich
ist. Kommen wir zunächst einmal zu einigen grundlegenden Dingen:
ÜFFNEN UND SCHLIESSEN VON FILES Jedesmal, wenn wir einen Zugriff auf die Floppy ausführen wollten, mussten wir
zuvor immer einen Filekanal öffnen.
Hierzu wurden mit Hilfe des OPEN-Befehls
einige Parameter an die Floppy übergeben, die zur eindeutigen Definition des
Kanals notwendig waren. Diese Parameter
waren die Filenummer, die Devicenummer
und die Sekundäradresse. Oft folgte der
ganzen Anweisung dann auch noch ein Filename, dessen Appendix ebenso die verlangte Operation spezifizierte. Man kann
also sagen, daß diese Werte alles Grundwerte sind, die zum Datenaustausch mit
der Floppy benötigt werden. Aus diesem
Grund müssen sie auch bei jeder Fileoperation angegeben werden. Möchten wir nun
eine Operation von Assembler aus durchführen, so müssen wir diese Parameter
zunächst dem Betriebssystem mitteilen.
Dies geschieht über die beiden ROM-Routinen " SETPAR" und " SETNAM" . SETPAR
hat die Einsprungadresse $ FFBA. An sie
werden die Filenummer, sowie Geräteund
Sekundäradresse übergeben. SETNAM legt den Filenamen ( inklusive Appendix) fest.
Sie steht bei $ FFBD. Beide Routinen tun
nichts anderes, als die gegebenen Werte
in Betriebssystem-Zwischenspeichern der
Zeropage abzulegen.
Nachdem die Werte festgelegt sind, können wir die Betriebssystemroutine " OPEN" aufrufen, die uns den Kanal mit der
Floppy öffnet. Ihre Einsprungadresse ist
bei $ FFC0 . Zum Schließen benutzen wir
die Routine " CLOSE" bei $ FFC3 .
Wenn wir ein File öffnen, so müssen wir
zunächst einmal seinen Namen festlegen.
Diesen legen wir irgendwo im Speicher, an einer bekannten Adresse, ab. Die Länge des Namens benötigen wir ebenso. Als
nächstes können wir SETNAM und SETPAR
aufrufen. SETNAM wird die Adresse des
Filenamens und seine Länge, SETPAR die
logische Filenummer, die Geräteund die
Sekundäradesse übergeben. Hier eine
Öbersicht der Registerbelegungen:
SETPAR: Akku = Filenummer
X-Reg. = Geräteadresse
Y-Reg. = Sekundäradresse
SETNAM: Akku = Länge des Filenamens
X-Reg. = Low-Byte der Speicher-
adresse des Namens
Y-Reg. = High-Byte der Speicher-
adresse des Namens
Ich möchte Ihnen hierzu ein Beispiel
liefern. Angenommen, Sie wollten das
sequentielle File " TEST" zum Lesen öffnen. Als Filenummer wollen wir die 1 wählen, als Sekundäradresse 2 . Die Geräteadresse ist in Bezug auf die Floppy
natürlich 8( oder 9,10,11 wenn Sie eine
zweite, dritte oder vierte Floppy besitzen) . All diese Parameter entsprechen
also dem BASIC-Befehl:
OPEN 1,8,2,"TEST,S,R"
Möchten wir diesen Befehl nun in Maschinensprache umsetzen, so schreiben wir folgendes Assembler-Programm. Hierbei
gehe ich davon aus, daß wir den Filenamen " TEST, S, R" als ASCII-Code bei Adresse $0334( dem Kasettenpuffer) abgelegt
haben:
LDA #$01 ;Filenummer 1 LDX #$08 ;Geräteadresse 8 LDY #$02 ;Sekundäradresse 2 JSR $FFBA ;SETPAR aufrufen LDA #$08 ;Filename ist 8 Zeichen lang LDX #$34 ; und liegt bei Adresse LDY #$03 ; $0334 JSR $FFBD ;SETNAM aufrufen
Die Parameter für das File " TEST" wären
damit festgelegt. Da das ", S, R" im Filenamen enthalten ist, weiß die Floppy
auch gleich schon, daß wir ein sequentielles File lesen möchten.
Als Nächstes müssen wir das zuvor spezifizierte File öffnen. Dies geschieht
über die oben schon erwähnte Betriebssystemroutine " OPEN" . Sie benötigt keine Parameter und wird direkt aufgerufen:
JSR $ FFC0 ; File mit zuvor gesetzem Namen und Parametern öffnen
Nun ist das File " TEST" geöffnet. Da
aber auch jeder Datenfluß einmal ein
Ende hat, muß unser File irgendwann einmal wieder geschlossen werden. Dies geschieht, wer hätte das gedacht, mit der
ROM-Routine " CLOSE", die bei Adresse
$ FFC3 angesprungen wird. Da auch mehrere
Files gleichzeitig offen sein können, muß ihr die Filenummer des zu schließenden Files im Akku übergeben werden:
LDA #$01 ; File mit Filenummer 1 JSR $ FFC3 ; schließen
DER DATENAUSTAUSCH Wie man ein File öffnet, sollte Ihnen
nun klar sein. Wenn Sie jedoch auch noch
mit ihm komunizieren wollen ( was sie bestimmt tun möchten, da es anders sinnlos wäre ein File zu öffnen), so müssen
Sie weiterhin fünf Betriebssystem-Routinen kennen, die Ihnen dies ermöglichen. Zunächst wären da " CHKIN" und
" CHKOUT" . Sie dienen der Umleitung der
Standard-Ein/ Ausgabe auf den entsprechenden Filekanal. Wenn Sie aus einem
File lesen wollen, so sollten Sie nach
dem Üffnen desselben die Routine CHKIN
aufrufen. Mit ihr teilen Sie dem Betriebssystem mit, daß Sie, wenn Sie
jetzt etwas einlesen, die Daten aus diesem Filekanal haben möchten. Möchten Sie
in ein File schreiben, so müssen Sie
CHKOUT aufrufen um in das geöffnete File
schreiben zu können. Beide Routinen
benötigen die Filenummer des entsprechenden Files im X-Register. Die Einsprungadresse von CHKIN ist $ FFC6, die
von CHKOUT $ FFC9 .
Wenn Sie die Standard-Ein/ Ausgabe mit
Hilfe unserer beiden Routinen umgeleitet
haben, so können Sie die Ihnen viel- leicht schon bekannten Routinen BASIN
($ FFCF) und BASOUT ($ FFD2) zum Lesen und
Schreiben von Daten vom, bzw. an, das
Ein/ Ausgabe-Gerät benutzen. Rufen Sie
diese Routinen bei unveränderter Standard- Ein-/ Ausgabe auf, so erscheint bei
BASIN ein Cursor auf dem Bildschirm, der
dem Assemblerprogramm eine Eingabe von
der Tastatur übermittelt, bei BASOUT
wird ein Zeichen an die aktuelle Cursorposition gedruckt und der Cursor um eine
Stelle weiterbewegt ( wie Sie bemerken
ist das Standard-Eingabegerät die Tastatur, das Standard-Ausgabegerät der Bildschirm) .
Bei umgeleiteter Eingabe erhalten Sie
nun beim Aufruf von BASIN das aktuelle
Byte des geöffneten Files im Akku
zurück. Bei umgeleiteter Ausgabe wird
jedes Byte, daß Sie in den Akku laden
und anschließend an BASOUT übergeben in
das geöffnete File hineingeschrieben.
Haben Sie nun Ihre Fileoperationen beendet, so ist es notwendig, die fünfte Routine zu benutzen, von der ich oben
sprach. Sie heißt " CLRCH" und wird verwendet, um die Standard-Ein/ Ausgabe wieder zurückzusetzen auf ' Tastatur' und
' Bildschirm' . Ihre Einsprungadresse ist
$ FFCC. Sie wird VOR dem Aufruf von CLOSE
benutzt und benötigt keine Parameter.
FEHLERERKENNUNG UND BEHANDLUNG Bevor wir uns der Praxis zuwenden, zunächst noch ein Wort zur Fehlererkennung. Hierüber können wir nämlich beim
Lesen eines Files auch erkennen, wann
wir sein letztes Byte gelesen haben.
Prinzipiell gilt: tritt während der Arbeit einer der Floppy-Betriebssystem- Routinen ein Fehler auf, so wird das an
das aufrufende Programm durch ein gesetztes Carry-Bit zurückgemeldet. So
können Sie also nach jeder der Routinen
durch eine einfache " BCS"- Verzweigung
(" Branch on Carry Set") auf eine Fehlerbehandlungsroutine verzweigen. Hierbei steht dann im Akku ein Fehlercode, mit
dessen Hilfe Sie die Art des Fehlers
feststellen können. Hier eine Liste mit
den möglichen Fehlermeldungen und den
Ursachen für einen aufgetretenen Fehler.
In eckigen Klammern stehen jeweils die
Betriebssystem-Routinen, die den entsprechenden Fehler auslösen können.
Steht nichts dahinter, so handelt es
sich um einen allgemeinen Fehler:
0 :" Break Error"- Die RUN/ STOP-Taste
wurde gedrückt.
1 :" too many files"- Der 64 er verwaltet
intern maximal 10 offene Files. Sie
versuchten ein elftes File zu öffnen.
Oder aber sie haben schon zu viele
Files zur Floppy hin offen ( Sie erinnern sich: man darf maximal 3 sequentielle, oder 1 relatives und 1 sequentielles File gleichzeitig offen
halten) .{ OPEN}2 :" file open"- Sie versuchten, ein
schon offenes File nochmal zu öffnen.
{ OPEN}3 :" file not open"- Sie versuchten, ein
ungeöffnetes File anzusprechen.{ CH-KIN, CHKOUT, CLOSE}4 :" file not found"- Das File, das Sie
zum Lesen öffnen wollten existiert
gar nicht.{ OPEN}5 :" device not present"- Die Floppy
( oder das gewählte Gerät) ist nicht
eingeschaltet.{ OPEN}6 :" not an input file"- Sie versuchten
aus einem zum Schreiben geöffneten
File zu lesen.{ CHKIN}7 :" not an output file"- Sie versuchten
in ein zum Lesen geöffneten File zu
schreiben.{ CHKOUT}8 :" missing filename"- Sie gaben keinen
Filenamen an.{ OPEN}9 :" illegal device number"- Sie gaben
eine ungültige Devicenummer an.
{ OPEN}
Beachten Sie bitte, daß nicht unbedingt
alle Fehler aus obiger Liste auftreten müssen, da man die oben genannten Routinen auch zum Anprechen von anderen Geräten verwenden kann ( z. B. Drucker, Datasette, etc.) . Üffnen Sie z. B. einen Kanal zum Drucker, so brauchen Sie keinen
Filenamen - der Fehler 8 wird in dem
Fall also nie auftreten.
Als weitere Fehlererkennungshilfe stellt
uns das Betriebssystem auch eine Statusspeicherstelle zur Verfügung. Sie ist
absolut identisch mit der Variablen " ST" von BASIC. Fragt ein BASIC-Programm diese Variable ab, so greift der BASIC-Interpreter auf eben diese Speicherstelle zurück. Die Assemblerprogrammierer
finden den I/ O-Status in der Zeropage, nämlich in Speicherstelle $90( dez.
144) . Um feststellen zu können, ob während der Arbeit mit der Floppy ein Fehler aufgetreten ist, müssen wir sie lediglich einlesen und analysieren. Ein
Fehler wird hierbei durch das gesetzt
sein eines oder mehrerer Bits dieser Speicherstelle gemeldet. Hier eine Belegung der Bits ( nur für die Arbeit mit
der Floppy gültig, bei Kasettenbetrieb
gilt eine andere Belegung) :
Bit Bedeutung
0 Fehler beim Schreiben
1 Fehler beim Lesen
6 Datei-Ende wurde erreicht (Lesen)
7 Gerät nicht vorhanden oder abge-
schaltet ("device not present")
Sie sehen, daß Sie hier, wie auch in
BASIC, das Ende eines Files durch gesetzt sein des 6 . Bits von ST feststellen können. Dann nämlich hat ST den Wert
64, den wir bei BASIC-Abfragen auch immer verwendeten. Sie sehen übrigens
auch, warum bei erneutem Lesen trotz
beendetem File die Fehlernummer 66 zurückgeliefert wird. Das File ist dann
nämlich zu Ende und es trat ein Fehler
beim Lesen auf, weil es ja gar nichts mehr zu lesen gibt. Damit sind die Bits
1 und 6 gesetzt (2+64) was dem Wert 66 entspricht.
Wenn ST den Wert 0 enthält, so ist alles
gut gegangen. Auf diese Weise können wir
in Assembler sehr einfach den Fehler
abfragen: Wir lesen die Speicherstelle
$90 einfach ein und verzweigen mittels
BNE auf eine Fehlerbehandlungsroutine.
ZUSAMMENFASSUNG Abschließend zu diesen Routinen möchte
ich Ihnen nun zwei Universal-Lese/ Schreib-Routinen vorstellen, die
Sie zum Lesen, bzw. Schreiben eines Files verwenden können. Sie finden diese
Routinen auch auf dieser MD unter dem
Namen " FK. I/ O. S" . Sie sind im Hypra-Ass- Format gespeichert. Um sie sich anzuschauen können Sie sie wie ein BASIC-Programm laden und listen.
Zunächst einmal möchte ich Ihnen die
" ReadFile"- Routine vorstellen. Sie liest
ein File an eine beliebige Adresse ein.
Hierbei übergeben Sie Lowund High-Byte
in Xund Y-Register, sowie die Länge
des Filenamens im Akku. Der Filename
selbst soll immer bei $0334( dez.820) stehen:
ReadFile:
stx $fb ;Startadresse in
sty $fc ; Zeiger schreiben
ldx #$34 ;Namensadresse=$0334
ldy #$03 ;in X/Y (Len in Ak.)
jsr $ffbd ;Und Name setzen
lda #01 ;Filenummer=1
ldx #08 ;Geräteadresse=1
ldy #00 ;Sek.=0 (=PRG lesen)
jsr $ffba ;Parameter setzen
jsr open ;File öffnen
ldx #01 ;Ausgabe auf FNr. 1
jsr chkin ; umleiten
ldy #00 ;Index auf 0 setzen
loop1: jsr basin ;Byte lesen
sta ($fb),y ;und auf Zeiger-
adresse speichern
inc $fb ;Den Zeiger in
bne l1 ; $FB/$FC um 1
inc $fc ; erhöhen
l1 : lda $90 ; File-Ende erreicht?
beq loop1 ; Nein, dann weiter!
jsr $ffcc ;Ja, also Standard-
Ein-/Ausgabe
zurücksetzen.
lda #01 ;Und File mit File-
jmp $ffc3 ; nummer 1 schließen
Als nächstes stelle ich Ihnen die " WriteFile"- Routine vor. Sie speichert Daten
in einem beliebigen Speicherbereich auf Diskette und wird mit denselben Vorraussetzungen aufgerufen wie " ReadFile" :
Name bei $0334, Namenslänge im Akku und
Startadresse des zu speichernden Bereichs in X-/ Y-Register. Zusätzlich müssen Sie die Endadresse dieses Bereichs
( in Lo/ Hi-Darstellung) vorher in den
Speicherstellen $ FD/$ FE abgelegt haben:
WriteFile:
stx $fb ;Startadresse in
sty $fc ; Zeiger schreiben
ldx #$34 ;Namensadresse=$0334
ldy #$03 ;in X/Y (Len in Ak.)
jsr $ffbd ;Und Name setzen
lda #01 ;Filenummer=1
ldx #08 ;Geräteadresse=1
ldy #01 ;Sek.=1 (=PRG
schreiben)
jsr $ffba ;Parameter setzen
jsr $ ffc0 ; File öffnen ldx #01 ; Eingabe auf FNr.1 jsr $ ffc9 ; umleiten ldy #00 ; Index auf 0 setzen loop2 : lda ($ fb), y ; Byte aus Sp. holen jsr $ ffd2 ; und an Floppy senden
inc $fb ;Den Zeiger in
bne l2 ; $FB/$FC um 1
inc $fc ; erhöhen
l2: lda $fe ;Quellzeiger $FB/$FC
cmp $fc ; mit Zielzeiger
bne loop2 ; $FD/$FE
lda $fd ; vergleichen. Wenn
cmp $fb ; ungleich, dann
bne loop2 ; weitermachen.
jsr $ffcc ;Wenn gleich, dann
Standard-I/O
zurücksetzen.
lda #01 ;und File mit File-
jmp $ffc3 ;nummer 1 schließen
Wie Sie sehen, habe ich hier den Trick
mit den Sekundäradressen verwendet. Da
bei der Sekundäradresse die Werte 0 und
1 für " Programm lesen" bzw." Programm
schreiben" stehen, erübrigt sich ein
umständliches anhängen von ", P, R" bzw.
", P, W" an den Filenamen. Dafür jedoch
können mit den Routinen nur PRG-Files
gelesen und geschrieben werden.
Bitte Teil 2 des Floppy-Kurses laden !
----------------------------------------
Floppy-Kurs:
"Es rappelt in der Kiste..."
(Teil 7.2)
----------------------------------------
Sie können diese Routinen nun universell
verwenden, um Programmdaten ( z. B. die
High-Score- Tabelle in einem Spiel) auf
Diskette zu schreiben und wieder von ihr
zu lesen. Aber Achtung: die Routinen
sind nur zum reinen Lesen und Schreiben
gedacht! Files, die normalerweise mit
LOAD in den Rechner geladen werden, oder
mit SAVE abgespeichert wurden, können
nicht ganz so behandelt werden! Hierbei
müssen Sie beachten, daß die SAVE-Routine des Betriebssystems immer die
Anfangsadresse des Files in den ersten
beiden Bytes ( in Lo/ Hi-Byte- Darstellung) mitspeichert. Lesen Sie ein solches File
mit " BASIN" ein, so erhalten Sie in den
ersten beiden Bytes immer zuerst diese Adresse. Beachten Sie also, daß diese
beiden Bytes nicht zu den eigntlichen
Daten des Files gehören! Ebenso können
Sie kein mit " WriteFile" geschriebenes
File mit dem LOAD-Befehl laden, weil
hierbei nämlich die ersten beiden Bytes
als Startadresse gewertet werden und das
File anschließend irgendwohin in den
Speicher geladen wird! Zum Kopieren von
Files sind diese Routinen wiederum optimal geeignet, da sie die Ladeadresse ja
mitladen und mitspeichern.
Sie können sie aber auch so modifizieren, daß diese Adresse mitberücksichtigt
wird. Hierzu müssen Sie " ReadFile" lediglich so umprogrammieren, daß sie die
ersten beiden Bytes liest und als Anfangsadresse nimmt, bzw. daß " WriteFile" die gegebene Anfangsadresse, die in Xund Y-Register übergeben wird, vorher an
das zu speichernde File sendet. Noch
einfacher geht das aber mit den Betriebssystemroutinen für LOAD und SAVE.
Sie nehmen uns diese Arbeit nämlich kom- plett ab und sind zudem noch relativ
flexibel zu handhaben.
LOAD UND SAVE Wie schon erwähnt stellt uns das Betriebssystem ebenso zwei Routinen zur
Verfügung, mit denen wir komplette Files
nachladen, bzw. speichern können. Der
Aufruf ist hierbei sehr einfach. Zunächst einmal müssen wir unsere Files
wieder mittels SETNAM und SETPAR spezifizieren. Danach werden die Prozessorregister einfach nur noch mit den entprechenden Parametern gefüttert und die
benötigte Routine wird aufgerufen.
Kommen wir zuerst zur LOAD-Routine. Sie
liegt bei $ FFD5 und hat folgende Aufrufparameter:
Akku : Operationsflag ($00 oder $01) X-Reg. : Low-Byte der Ladeadresse Y-Reg. : High-Byte der Ladeadresse
Das Operationsflag, das in den Akku
kommt, hat folgende Bewandnis: die LOAD-Routine kann nämlich auch zum Verifizieren eines Files verwendet werden ( BA-SIC- Befehl " VERIFY") . Hierbei wird haargenau so verfahren wie beim Laden, jedoch mit dem Unterschied, daß das File
nicht in den Speicher geschrieben, sondern nur gelesen wird. Möchte man nun
laden, so muß der Wert 0 im Akku stehen.
Möchte man verifizieren, so gehört der
Wert 1 in ihn hinein. Desweiteren kann
in Xund Y-Register die Startadresse
des File übergeben werden, an die es
geladen werden soll. Die LOAD-Routine
überliest dann ganz einfach die ersten
beiden Bytes, die diese Adresse ja angeben, und liest das File anschließend an
die gegebene Adresse. Möchten Sie das
File jedoch an seine vorgegebene Adresse
laden, so müssen Sie Xund Y-Register
lediglich mit 0 füllen.
Zum besseren Verständins einmal eine
kleine Routine, die ein File mittels LOAD-Routine an seine im File vorgegebene Adresse lädt. Sie verlangt als Aufrufparameter die Filenamenlänge im Akku
und den Filenamen bei Adresse $0334 :
LDX #$34 ;Name bei $0334 (Länge ist LDY #$03 ; noch vom Aufruf im Akku) JSR $FFBD ;Namen setzen (SETNAM) LDA #01 ;Filenummer=1 LDX #08 ;Gerät Nr. 8 LDY #00 ;Sek.=0 für "PRG laden" JSR $FFBA ;Parameter setzen (SETPAR) LDA #00 ;Load-Flag in Akku TAX ;X/Y löschen (Startadresse TAY ;aus dem File holen) JMP $FFD5 ;und laden
Wie Sie sehen, werden SETNAM und SETPAR
genauso benutzt wie in der " ReadFile"- Routine. Im Prinzip können Sie die Angabe einer Filenummer weglassen, da Sie
sie selbst ja nicht brauchen. Es wird in
dem Fall gerade die Nummer gewählt, die
im Akku steht. Nur hat das den Nachteil,
daß der Ladevorgang nicht immer funktioniert, wenn Sie noch weitere Files offen
halten.
Das File steht am Ende der Routine an
der Stelle im Speicher, die von seinen
ersten beiden Bytes spezifiziert wurde.
Möchten Sie es allerdings an eine bestimmte Adresse laden, z. B.$1234, so
müssen Sie die beiden Befehle " TAX" und
" TAY" durch die folgenden beiden Zeilen
ersetzen:
LDX #$34 LDY #$12
Kommen wir nun zur SAVE-Routine des Betriebssystems. Sie wird ähnlich aufgerufen. Zunächst müssen wieder mittels SET-NAM und SETPAR der Name und die Parameter des Files gesetzt werden. Anschließend kann die SAVE-Rotine aufgerufen
werden. Sie benötigt jedoch ein paar
mehr Parameter, nämlich Startund End- adresse. Da hierfür die drei Prozessorregister nicht ausreichen, wurde folgender Weg gegangen: Zunächst legen Sie die
Staradresse des zu speichernden Bereichs
in Lo' Hi Darstellung in zwei aufeinanderfolgenden Adressen der Zeropage ab.
Hierzu bieten sich $ FB und $ FC an, da
sie vom Betriebssystem nicht benutzt
werden. Nun laden Sie einen " Zeropage-Zeiger" in den Akku. Dieser ist nichts
anderes als die Nummer der Speicherstelle in der Sie das Low-Bytes der Startadresse abgelegt haben. In unserem Beispiel also $ FB. Die Endadresse des zu
speichernden Bereichs legen Sie in Xund Y-Register ab und rufen anschließend
die SAVE-Routine auf. Ihe Einsprungadresse liegt bei $ FFD( . Hier wieder
eine Beispielroutine. Sie verlangt
wieder den Filenamen bei $0334 und
dessen Länge im Akku. Desweiteren müssen
Sie die Startadresse in $ FB/$ FC abgelegt
haben und die Endadresse in Xund Y-Register übergeben:
STX $FD ;Endadresse in $FD/$FE STY $FE ; sichern LDX #$34 ;Filenamen bei $0334 LDY #$03 ; setzen JSR $FFBD ; (SETNAM) LDA #01 ;Filenr. 1 LDX #08 ;Geräte Nr. 8 LDY #01 ;Sek.=1 für "PRG speichern" JSR $FFBA ;Parameter setzen (SETPAR) LDA #$FB ;Zeiger auf Startadr. laden LDX $FD ;Endadresse wieder in LDY $FE ; X- und Y-Reg. holen JMP $FFD8 ;Und speichern!
Wie Sie sehen, wird die Endadresse hierbei in $ FD/$ FE zwischengespeichert, um
den Aufruf korrekt durchführen zu können. Diese beiden Speicherstellen sind
übrigens ebenfalls vom Betriebssystem
unbenutzt.
Die beiden Programmbeispiele zum Laden
und Speichern mittels LOAD und SAVE finden Sie übrigens ebenfalls in dem File
" FK. I/ O. S" auf dieser MD. Ich verabschiede mich nun wieder einmal von Ihnen, und wünsche Frohe Weihnachten und
ein schönes neues Jahr, in dem wir dann
tiefer in die Assemblerprogrammierung
der Floppy einsteigen und einige Programmbeispiele des täglichen Gebrauchs
kennenlernen werden.
(ub)
----------------------------------------
Floppy-Kurs:
"Es rappelt in der Kiste..."
(Teil 8)
----------------------------------------
Herzlich Willkommen zum achten Teil des
Floppy-Kurses. In diesem Monat wollen
wir noch etwas weiter in die Floppyprogrammierung in Assembler einsteigen. Im
letzten Monat hatten wir ja schon angesprochen, wie man ein File öffnet und
mit ihm kommuniziert, sowie man Files
lädt und speichert. Diesmal will ich
Ihnen eine andere, effektiviere Methode
zeigen, mit der man die Floppy ansprechen kann.
DIE ALTE METHODE
In der letzten Ausgabe des Floppy-Kurses
hatten wir gelernt, wie man ein File
öffnet, es zur Datenübertragung bereitmacht, Daten an es sendet und von ihm
empfängt, und es anschließend wieder
schließt. Die dort behandelte Arbeitsweise war die einfachste, die man zum
reinen Lesen oder Schreiben eines Files
anwendet. Es gibt jedoch eine weitere
Methode Files anzusprechen. Diese ist
zwar ein wenig umständlicher, dafür aber
schneller und weitaus flexibler.
Rekapitulieren wir: Nach der ersten Methode gingen wir immer folgendermaßen
vor:
1)" SETNAM" mit den Parametern für den
Filenamen aufrufen.
2)" SETPAR" mit den Datenkanalparametern aufrufen.
3) Mit " OPEN" das File öffnen 4 a) War das File eine Ausgabedatei, so
mussten wir " CKOUT" aufrufen.
4 b) War das File eine Eingabedatei, so mussten wir " CHKIN" aufrufen.
5 a) War das File eine Ausgabedatei, so
wurden die Daten mit Hilfe von " B-SOUT" geschrieben.
5 b) War das File eine Eingabedatei, so
wurden die Daten mit Hilfe von " BA-SIN" gelesen.
6) Abschließend wurde mittels " CLRCH" die Standardausgabe wieder zurückgestellt.
7) Das File wurde mit " CLOSE" geschlossen.
Wie gesagt, ist diese Methode die einfachste, wenn Sie ein einziges File lediglich Lesen oder Schreiben wollen.
Wenn Sie nun aber mehrere Files offenhalten und ansprechen wollen, oder aber
auf einem Kanal Lesen und Schreiben wollen ( so wie das beim Befehlskanal unter
Mitbenutzung von Pufferkanälen oft der
Fall ist), so versagt diese Methode. Das
liegt daran, daß Sie mit der einfachen
Methode eigentlich nicht wirklich mit den Dateien kommunizieren. Dies geschieht dann nämlich mit einem Umweg
über das Betriebssystem. Das Aufrufen
von " CKOUT" entspricht zum Beispiel dem
Basic-Befehl " CMD" . Sie leiten damit die
Daten, die normalerweise auf dem Bildschirm ausgegeben werden, auf den
Floppykanal um. Nun ist es aber wiederum
nicht so einfach, einen zum Ausgabekanal
erklärten Filekanal, als Eingabekanal zu
benutzen. Ein folgendes " CHKIN" zeigt
nämlich keine Wirkung. Auch wenn Sie
zwei Files offenhalten, so funktioniert
das Umschalten zwischen diesen beiden
Files nicht immer. Der Grund dafür liegt
in der Art und Weise wie die Standard-Ein/ Ausgabefiles im C64 verwaltet werden.
DIE NEUE METHODE
Um nun effizienter mit der Floppy zu
kommunizieren, müssen wir auf spezielle Betriebssystemroutinen zurückgreifen, die eigens für die Datenkommunikation
mit der Floppy ( bzw. dem IEC-Bus, an dem
Floppy und Drucker angeschlossen sind), dienen. Diese Routinen werden im Prinzip
auch bei Verwendung der ersten Methode
vom Betriebssystem benutzt, jedoch muß
ein Standard-Kanal eben auch andere, virtuelle, Geräte ( wie Bildschirm, Tastatur, etc.) ansprechen können, weshalb
die Restriktionen dort etwas umständlicher sind. Deshalb ist eine Ausgabe über
BASOUT, oder die Eingabe über BASIN, auch immer langsamer, als wenn Sie die
entsprechenden I/ O-Routinen für den
IEC-Bus benutzen, da bei den beiden ersten Routinen erst einmal entschieden
werden muß, welche effektiven Ein-/ Ausgaberoutinen nun wirklich benutzt werden
müssen ( in unserem Fall nämlich die
IEC-Busroutinen) .
Kommen wir nun jedoch endlich zu den
neuen Routinen und deren Funktionsprin- zip. Hierzu müssen wir uns zunächst noch
einmal verdeutlichen, daß die Floppy im
Prinzip ein eigenständiger Computer ist, der nichts anderes tut, als darauf zu
warten, daß Befehle über den IEC-Bus
kommen, um sie auszuführen. Hierbei meine ich nicht die Floppy-Befehle, wie wir
sie bisher kennengelernt haben. Diese
stellen wiederum eine höhere Ebene von
Befehlen dar. Da der IEC-Bus als Kommunikationsschnittstelle zwischen C64 und
Floppy dient, werden auf Ihm Daten entweder vom Rechner zur Floppy oder umgekehrt hinund herbewegt. Die Verarbeitung dieser Daten ist dann dem jeweiligen Gegengerät überlassen, daß die Daten
empfangen hat. Noch dazu kann es vorkommen, daß sich bis zu 7 Geräte ( der C64, max.2 Drucker und max. vier Floppys) über ein und denselben Bus miteinander
unterhalten müssen. In dem Fall muß vor
einer Datenübertragung natürlich festgelegt werden welches der Geräte nun mit
welchem ( im Normalfall dem 64 er) kommu- nizieren soll. Hierzu dienen nun insgesamt sechs Betriebssystemroutinen.
Als erstes müssen wir wieder einmal ein
File auf die gewohnte Art und Weise öffnen. Zunächst übergeben wir die Filenamenparameter mit Hilfe von " SETNAM"( Akku= Länge des Namens, X/ Y= Zeiger auf Namensstring) . Anschließend muß " SETPAR" aufgerufen werden. Hierbei kommen Filenummer und Geräteadresse, wie gewohnt, in Akku und X-Register. Im Y-Register
wird die Sekundäradresse abgelegt. Jedoch müssen wir hier, anders als sonst, die gewünschte Sekundäradresse plus $60(= dez.96) übergeben. Dies hat Floppyinterne Gründe. Möchten wir also den Befehlskanal ansprechen, so muß die Sekundäradresse $6 F ( dez.111) übergeben
werden. Möchten wir ein PRG-File lesen, so müssten wir den Wert $60 übergeben, etc. Zuletzt wird wieder wie üblich das
File mittels " OPEN" geöffnet.
Soweit also nichts Neues. Nun müssen wir uns, wie vorher auch, verdeutlichen, ob
die Floppy senden, oder empfangen soll.
Anstelle von " CHKIN" oder " CKOUT" müssen
diesmal jedoch andere Routinen benutzt
werden. Möchten wir Daten empfangen, so
soll die Floppy mit uns " reden" . Deshalb
heißt die entsprechende Routine, die sie
dazu auffordert uns Daten zuzusenden
" TALK"( engl." reden") . Wollen wir Daten
senden soll die Floppy uns " zuhören" .
Die hierfür gedachte Unterroutine heißt
" LISTEN"( engl." hören") . Da es, wie
oben schon einmal beschrieben, bis zu 6 Geräte geben kann, die uns zuhören oder
mit uns reden sollen, muß mit " TALK" oder " LISTEN" auch mitgeteilt werden, welches der Geräte nun für uns bereit
sein soll. Hierzu müssen Sie vor Aufruf
der Routinen die Geräteadresse des gewünschten Gerätes im Akku ablegen.
Als nächstes muß dem Gerät an der anderen Seite mitgeteilt werden, welcher
seiner offenen Kanäle senden oder empfangen soll. Hierzu muß die Sekundär- adresse an das Gerät übermittelt werden.
Dies geschieht über die Routinen
" SECTLK" und " SECLST" . Beide verlangen
die gewünschte Sekundäradresse ( wieder
plus $60) als Parameter im Akku.
" SECTLK" müssen Sie nach einem " TALK" aufrufen," SECLST" nach einem " LISTEN" .
Nun ist alles vorbereitet, um Daten zu
lesen oder zu schreiben. Dies erledigen
Sie nun am besten mit den beiden speziellen IEC-Ein-/ Ausgaberoutinen, die
ich oben schon ansprach. Sie können sie
genauso wie " BASIN" und " BASOUT" benutzen. Zum Lesen von Daten benutzen Sie
die Routine " IECIN", die das gelesene
Byte im Akku zurückgibt. Zum Schreiben
benutzen Sie " IECOUT", der das zu
schreibende Byte im Akku übergeben werdeb muß.
Haben Sie die Einoder Ausgabe beendet, so müssen Sie das entsprechende Empfangs-, bzw. Sendegerät wieder in den
Wartezustand zurückbringen. Dies geschieht über die Routinen " UNTALK" und" UNLIST" . Die erstere müssen Sie nach
dem Empfang, die letztere nach dem Senden von Daten benutzen. Dies müssen Sie
auch immer dann tun, wenn Sie anschließend auf dem selben Kanal eine andere
Operation ausführen wollen ( z. B. Befehl
an Befehlskanal senden und anschließend
Floppystatus auslesen) .
Wenn Sie mit Ihrer Operation nun fertig
sind, so können Sie den zuvor geöffneten
Filekanal wieder schließen.
Wie Sie sehen ist diese Methode etwas
aufwendiger. Dafür aber können Sie nun
problemlos den Befehlskanal öffnen und
z. B. den " Memory-Read"- Befehl (" M-R") benutzen. Hierbei öffnen Sie einen Filekanal und teilen der Floppy mit, daß sie
Daten empfangen soll (" LISTEN" und
" SECLST" aufrufen) . Nun senden Sie mittels " IECOUT" den Befehlsstring. Anschließend setzen Sie die Floppy wieder
in der Normalstatus zurück, indem Sie
" UNLIST" aufrufen. Hiernach können Sie nun die zuvor verlangten Daten vom Befehlskanal abholen. Senden Sie einfach
ein " TALK" und " SECTLK" und lesen Sie
die Daten mit " IECIN" ein. Abschließend
muß die Floppy wieder mit " UNTALK" in
den Wartezustand geschickt werden und
wir können das File schließen.
Desweiteren ist das Bedienen von zwei
offenen Files nun weitaus besser möglich. Bevor Sie eines dieser Files ansprechen, müssen Sie einfach den entsprechenden Öbertragungsmodus festlegen und
seine Sekundäradresse an die Floppy
schicken. Denken Sie immer daran, daß
Sie nach jeder Leseoder Schreiboperation ein " UNTALK" oder " UNLIST" senden
müssen, damit die Floppy auf weitere
Befehle reagiert.
Hier nun noch die Einsprung-Adressen der
neuen I/ O-Routinen:
LISTEN: $FFB1 TALK: $FFB4 SECLST: $FF93 SECTLK: $FF96 UNLIST: $FFAE UNTALK: $FFAB IECOUT: $FFA8 IECIN: $FFA5 PROGRAMM-BEISPIELE
Kommen wir nun noch zu einigen Programmbeispielen, die Ihnen die Benutzung der
neuen I/ O-Routinen erläutern sollen.
Die Routinen aus Beispiel 1 und 2 finden
Sie, als Hypra-Ass Quellcode, auf dieser
MD unter dem Namen " FK. IO2 . S" . Der
Quellcode für Beispiel 3 steht im File
" FK. SHOWBAM. S" . Da es sich dabei um ein
eigenständiges Programm handelt, existiert hierzu auch noch ein, durch
' RUN' startbares, File namens " FK. SHOW-BAM" .
1) LESEN UND SCHREIBEN EINES FILES Zunächst einmal möchte ich Ihnen zeigen, wie die beiden Routinen " READFILE" und
" WRITEFILE" aus dem letzten Kursteil in
der neuen Methode aussehen. Hierbei müssen wir lediglich den Aufruf von " CH-KIN/ CKOUT" mit dem von " TALK/ SECTALK" oder " LISTEN/ SECLIST" ersetzen. Der Aufruf von " CLRCH" am Ende der Öbertragung
muß mit einem " UNTALK" bzw." UNLIST" ersetzt werden. Desweiteren muß den Sekundäradressen beim Üffnen der Wert $60 hinzuaddiert werden ('$60' bei ReadFile,'$61' bei WriteFile) .
Der Rest des Programms sollte sich von
selbst erklären. Damit man die alte und
neue Version der Routinen nicht miteinander verwechselt, heißen die neuen
Versionen " IECREAD" und " IECWRITE" . Die
Parameter, die beim Aufruf übergeben
werden müssen, sind dieselben wie bei
den alten Versionen:
IECREAD stx $ fb ; Startadresse in sty $ fc ; Zeiger ablegen.
ldx #$34 ;Zeiger auf
ldy #$03 ; Filenamen
jsr setnam ; setzen.
lda #01 ;Fileparameter
ldx #08 ; setzen
ldy #$60 ; ($60=PRG Lesen)
jsr setpar
jsr open ;File öffnen
lda #08 ;"Gerät Nr. 8:
jsr talk ; rede bitte!"
lda #$60 ;"Und zwar auf Se-
jsr sectlk ; kundäradr. $60)!"
ldy #00 ;Offset=0
loop1 jsr iecin ;Zeichen lesen
sta ($fb),y; und ablegen
inc $fb ;Zeiger
bne l1 ; um 1
inc $fc ; erhöhen
l1 lda $90 ;Ende erreicht?
beq loop1 ;Nein, dann weiter!
lda #08 ; Sonst:" Gerät jsr untalk ; Nr.8 : Ruhe bitte!" lda #01 ; File jmp close ; schließen ;*************************************** IECWRITE stx $ fb ; Startadresse in sty $ fc ; Zeiger ablegen
ldx #$34 ;Filenamen
ldy #$03 ; setzen
jsr setnam
lda #01 ;Fileparameter
ldx #08 ; setzen
ldy #$61 ; ($61=PRG schr.)
jsr setpar
jsr open ;File öffnen
lda #08 ;"Gerät Nr8: Hör'
jsr listen ; mir bitte zu!'
lda #$61 ;"Und zwar auf Sek.
jsr seclst ; Adr.$61 !")
ldy #00 ;Offset=0
loop2 lda ($fb),y;Zeichen holen
jsr iecout ; und abschicken
inc $fb ;Zeiger
bne l2 ; um 1
inc $fc ; erhöhen
l2 lda $fe ;Und mit
cmp $fc ; Endadresse
bne loop2 ; vergleichen
lda $fd ;Wenn ungleich
cmp $fb ; dann weiter
bne loop2
lda #08 ;"Gerät Nr.8:
jsr unlist ; Bin fertig!"
lda #01 ;File
jmp close ; schließen
2) FLOPPYSTATUS ANZEIGEN
Ein weiterer Vorteil, der sich aus der
Benutzung der direkten IEC-Routinen ergibt, ist, daß Sie nun problemlos, während des Arbeitens mit einem File, Statusmeldungen auf dem Bildschirm ausgeben
können. Da die Standard Ein-/ Ausgabe ja
nicht verändert wurde, erscheinen Texte, die mit BSOUT ausgegeben werden sollen, auch weiterhin auf dem Bildschirm. Umgekehrt wird bei BASIN von der Tastatur, und nicht etwa aus dem offenen File gelesen.
Als Beispiel für eine solche Anwendung
möchte Ich Ihnen das Auslesen des Fehlerkanals der Floppy zeigen. Hierzu muß
lediglich der Befehlskanal geöffnet, und
die Fehlermeldung, die im ASCII-Code von
der Floppy generiert und übermittelt
wird, Zeichen für Zeichen ausgelesen und
auf dem Bildschirm ausgegeben werden.
Ich denke, die Routine erklärt sich von
selbst:
ERRCHN lda #00 ;Länge Filename=0
jsr setnam ; für "Kein Name"
lda #01 ;Fileparameter
ldx #08 ; setzen
ldy #$6f ; (=Befehlskanal)
jsr setpar
jsr open ;Filekanal öffnen
lda #08 ;Floppy Nr.8 zum
jsr talk ; Senden auffordern
lda #$6f ;Und zwar auf Kanal
jsr sectlk ; mit Sek.Adr. $6F
ecloop1 jsr iecin ;Zeichen lesen
jsr bsout ;Und auf dem Bild-
schirm ausgeben
lda $90 ;Fileende erreicht?
beq ecloop1; Nein, also weiter
lda #08 ;Floppy Nr.8
jsr untalk ; zurücksetzen
lda #01 ;Und Befehlskanal
jmp close ; schließen
3) BAM ANZEIGEN Als Nächstes wollen wir ein Programm
schreiben, daß uns anzeigt, welche
Blocks einer Diskette belegt sind, und
welche nicht. Hierzu müssen wir die BAM
(" Block Availability Map"), die im
Disk-Header- Block ( Track 18 Sektor 0) zu
finden ist, auslesen und zu einer grafikschen Anzeige dekodieren. Dies ist
ein hervorragendes Beispiel um die Benutzung der neuen I/ O-Routinen zu demonstrieren und gleichzeitig zu zeigen, wie man mit der BAM umgeht. Sie erinnern
sich vielleicht noch an deren Aufbau.
Ich hatte ihn in Teil 5 dieses Kurses
besprochen:
Im Disk-Header- Block sind die Bytes 4 bis einschließlich 143 für die BAM reserviert. Hierbei zeigen jeweils 4 Bytes
in Folge die Blockbelegung für einen
Track an. Im ersten Byte steht dabei die
Gesamtanzahl der freien Blocks dieses
Tracks. Die Bits des zweiten Bytes ko- dieren die Belegung der Sektoren 0-7, die Bits des dritten Bytes die Belegung
der Sektoren 8-15 und die Bits des vierten Bytes die Belegung der Sektoren 16-23 . Hat ein Track weniger Sektoren, als
im vierten Byte angezeigt werden, so
sind die restlichen Bits dieses Bytes
unbenutzt ( so z. B. immer die letzten
zwei Bits, da es ja nie mehr als 21 Tracks gibt) . Ein gesetztes Bit bedeutet, daß der entsprechende Sektor frei
ist, ein gelöschtes Bit, daß er belegt
ist.
Wollen wir einmal klären, welche Dinge
zur Lösung des obigen Problems notwendig
sind. Zunächst müssen wir den Befehlskanal und anschließend einen Pufferkanal
öffnen. Nun muß der Befehl zur Floppy
gesandt werden, der den Block 18/0 in
den geöffneten Puffer liest. Ist dies
geschehen, müssen wir nur noch auf das
vierte Byte des Puffers positionieren
( dort beginnt ja die BAM) und die vier Belegungs-Bytes für jeden Track einlesen
und darstellen.
Bitte Teil 2 des Kurses laden!
Teil 2 Floppy Kurs 8
Kommen wir also zu unserem Programm:
main lda #00 ;Bildschirm-
sta 53280 ; farben
lda #11 ; ein-
sta 53281 ; stellen
lda #<(text1) ;Text für Anzeige
ldy #>(text1) ; auf Bildschirm
jsr strout ; ausgeben
mloop5 lda #00 ;Filename setzen
jsr setnam ; (0='Kein Name')
lda #01 ;Parameter: LFN 1
ldx #08 ; Ger.Adr 8
ldy #$6f ; Sek.Adr 15
jsr setpar ; setzen
jsr open ;Bef.kan. öffnen
lda #01 ;Filename "#"
ldx #<(bufnam); (für 'Puffer
ldy #>(bufnam); reservieren')
jsr setnam ; setzen
lda #02 ;Fileparameter
ldx #08 ; setzen
ldy #$62 ; (Sek.Adr=2)
jsr setpar
jsr open ;Puff.kan. öffnen
Bis hier sollte wohl alles klar sein.
Wir haben in den obigen Zeilen den Befehlskanal und einen Pufferkanal mit der
Sekundäradresse 2 geöffnet ( bitte denken
Sie daran, daß beim Üffnen und beim Benutzen der Routinen SECTLK und SECLST
diese Adresse plus $60 übergeben werden
muß) .
Als nächstes können wir die beiden
Floppybefehle zum Lesen des Blocks 18/0 und zum Positionieren auf Byte 4 senden:
lda #<(com1) ;Befehl 'Block
ldy #>(com1) ; 18/0 lesen'
jsr sendcom ; senden.
lda #<(com2) ;Befehl 'Puffer-
ldy #>(com2) ; zeiger auf
jsr sendcom ; Byte 4' senden.
Wie Sie sehen, benutze ich hier eine
eigene Routine, um die Befehle zu senden. Sie heisst " SENDCOM" und benötigt
einen Zeiger auf den Befehlstext in Akku
und Y-Register. Zur Beschreibung der
Routine kommen wir später. Hier noch die
Syntax beiden Befehle, die oben gesandt
werden. Sie finden Sie ganz am Ende des
Quelltextes:
com1 .tx "u1 2 0 18 0"
.by 13,0
com2 .tx "b-p 2 4"
.by 13,0
Wie Sie sehen benutzen wir die Befehle
" U1"( die bessere Version von " B-R") und
" B-P" . Die einzelnen Parameter werden
dabei als ASCII-Werte übertragen. Wie
Sie auch bemerken, so wird bei den Be- fehlen die tatsächliche Sekundäradresse, nämlich 2 und nicht etwa $62, benutzt.
Der Wert 13 am Ende jedes Befehls wird
benötigt, um der Floppy das Ende des
Befehlsstrigs zu signalisieren. Die 0 wird nicht mitgesandt. Sie dient als
Endmarkierung für die SENDCOM-Routine.
Machen wir nun jedoch weiter im Quelltext des Hauptprogramms. Die nun folgenden Zeilen versetzen die Floppy in den
Sendestatus und bereiten die Bildschirmausgabe der Tracks vor. Hierbei
wird ein Zeiger auf den Bildschirmspeicher in $ FB/$ FC abgelegt, der nach der
Ausgabe eines Sektors um 40 erhöht wird.
So erreichen wir eine vertikale Ausgabe
des Tracks. Für den nächsten Schleifendurchlauf wird der Zeiger wieder auf den
Startwert+1( nächste Spalte) zurückgesetzt:
lda #08 ;Floppy Nr. 8 zum
jsr talk ;Senden auffordern
lda #$62 ;Und zwar auf
jsr sectlk ; Sek. Adr 2
lda #34 ;Trackzähler
sta $03 ; initialisieren
lda #163 ;Grundwert Zeiger
sta mloop3+1 ; einstellen
mloop3 ldx #163 ;Bildschirmpo-
ldy #04 ; sitionszeiger
stx $fb ; initialisieren
sty $fc
inc mloop3+1 ;Spalte für näch-
sten Track um 1
erhöhen
Nun erfolgt das eigentliche Lesen und
Ausgeben der BAM-Bytes. Hierbei müssen
wir immer das jeweils erste Byte überlesen, da es ja keine Blockbelegung ansich, sondern nur die Anzahl der freien
Blocks enthält. Die folgenden zwei Bytes
können normal ausgegeben werden. Da das
letzte Byte immer eine unterschiedliche
Anzahl an unbelegten Bits enthält, müs- sen wir hier aufpassen, daß nur soviele
Bits ausgegeben werden, wie tatsächlich
benutzt werden. Dies geschieht über die
Tabelle " SECTAB", die die Anzahl der
benutzen Blocks des letzten Bytes eines
jeden Tracks beinhaltet. Hier jedoch
erst einmal wieder das Listing:
jsr iecin ;1. Byte überlesen
jsr iecin ;2. Byte lesen
jsr byteout1 ; und ausgeben
jsr iecin ;3. Byte lesen
jsr byteout1 ; und ausgeben
jsr iecin ;4. Byte lesen
ldy $03 ;Tracknr. als Zei-
ger holen
ldx sectab,y ;Anzahl benutzte
Bits des Tracks
holen.
jsr byteout2 ;Und Byte ausgeben
dec $03 ;Trackzähler-1
bpl mloop3 ;Nochmal, wenn >0
Wie Sie sehen, benutze ich eine eigene
Routine zur Ausgabe eines BAM-Bytes. Sie
heisst " BYTEOUT1" und gibt die Bits 0-7 des BAM-Bytes vertikal auf dem Bildschirm aus. Hierbei wird ein " o" geschrieben, wenn der Block belegt ist, und ein " .", wenn er unbelegt ist. Die
Routine " BYTEOUT2" ist im Prinzip dieselbe, wie BYTEOUT1 . Der einzige Unterschied ist, daß die zweite Version die
Anzahl der auszugebenden Bits im X-Register verlangt. Diese wird nun über
die SECTAB-Tabelle eingelesen. Achten
Sie darauf, daß die Liste rückwärts gelesen wird, und somit der Reihe nach die
Blockanzahlen der Tracks 35-1( jeweils
nur für das letzte Byte und minus 1) in
der Liste verzeichnet sind. Sie finden
die Liste ebenfalls am Ende des Quellcodes.
Fahren wir nun weiter im Hauptprogramm.
Nachdem alle BAM-Bytes gelesen und ausgegeben wurden, können wir Befehlsund
Pufferkanal wieder schließen. Vorher muß die Floppy allerdings wieder in den Wartezustand zurückversetzt werden. Hierauf
folgt noch eine Tastenabfrage, die das
Programm bei Tastendruck wiederholt und
bei der Taste '<' den Bildschirm löscht
und zurückspringt:
lda #08 ;Floppy wieder
jsr untalk ; zurücksetzen.
lda #02 ;Pufferkanal
jsr close ; schließen
lda #01 ;Befehlskanal
jsr close ; schließen
mloop4 jsr inkey ;Taste holen
beq mloop4 ; Keine --> weiter
cmp #95 ;= '<' ?
beq end ;Ja, also ENDE.
jmp mloop5 ;Nein,also nochmal
end jmp $e544
Wollen wir uns nun die Routine SENDCOM
anschauen. Im Prinzip ist sie nichts
anderes als eine STROUT-Routine, nur daß die Ausgabe nicht auf dem Bildschirm, sondern an die Floppy erfolgt. Sie finden sie in den Zeilen 990-1070 des
Quelltextes:
sendcom sta $ fb ; Zeiger auf String
sty $ fc ; ablegen
lda #08 ;Floppy Nr.8 zum
jsr listen ; Empfang auffor-
dern
lda #$6f ;Und zwar von Sek.
jsr seclst ; Adr. 15
ldy #00 ;Offset=0
scloop1 lda ($fb),y ;Zeichen lesen
beq s1 ;Wenn 0 --> fertig
jsr iecout ;Zeichen senden
iny ;Zeiger um 1
bne scloop1 ; erhöhen und
inc $fc ; Schleife wieder-
jmp scloop1 ; holen
s1 lda #08 ;Ende. Floppy Nr.
jmp unlist ;8 zurücksetzen
Das soll es dann wieder einmal für diesen Monat gewesen sein. Sie sind nun
komplett in die Bedienung der Floppy
1541 eingeführt und sollten eigentlich
auch schon eigene Programme schreiben
können. Trotzdem wird es nächsten Monat
noch einen Teil dieses Floppy-Kurses
geben, in dem wir ein ganz besonderes
Beispielprogramm besprechen werden wollen.
(ub)
----------------------------------------
Floppy-Kurs
"Es rappelt in der Kiste..."
(Teil 9)
----------------------------------------
Herzlich Willkommen zum neunten und
letzten Teil des Floppy-Kurses. In den
vorangehenden Folgen haben wir einiges
über den Aufbau von Disketten und das
Ansprechen der Floppy gelernt. Ich möchte diesen Kurs nun mit einem anspruchsvollen Programmbeispiel abschließen, das
wir uns im Laufe der heutigen Folge
erarbeiten wollen. Es dient als Beispiel
für die Programmierung der Floppy in
Assembler und gleichzeitig auch als Beispiel für das was möglich ist, wenn eine
Diskette richtig manipuliert wird.
DIE AUFGABE
Sicherlich kennen Sie das Problem: Sie
sind gerade dabei Ihre Diskettensammlung
aufzuräumen und Ihre Programme so umzukopieren, daß jede Diskette optimale
Platzausnutzung aufweisen soll. Am Besten so, daß restlos jeder Block dieser
Diskette beschrieben ist. Beim Zusammenstellen bleiben dann aber noch noch
17 Blocks übrig - Mist, kein Platz mehr
für das letzte,30 Blocks lange Programm!
Was tun? Im Prinzip bleiben Ihnen nur
die folgenden Möglichkeiten:
1) Sie fangen nochmal von vorne an ( Gähn
- Kopieren dauert lange) .
2) Sie belassen alles, wie es ist ( Ärgerlich -17 Blocks verschenkt) .
3) Sie packen das letzte Programm ( Wieder Gähn - dauert auch lange und ausserdem hat das File hinterher bestimmt genau 18 Blocks, so daß es
doch nicht passt) .
4) Sie benutzen das Programm " USEDIR", das wir uns in diesem Kursteil erarbeiten wollen.
Nun werden Sie fragen:" Na schön, und
wie will dieses Programm nun 13 weitere
Blocks freibekommen, wenn die Diskette
voll ist?" . Ganz einfach: aus dem Directory." USEDIR" nimmt sich die Tatsache
zunutze, daß der Track 18, in dem das
Directory einer Diskette steht, nicht
für normale Files zur Verfügung steht.
Er ist lediglich für die Fileeinträge
reserviert. In jedem der 18 Fileeintragsblocks ( Sektoren 1-18,0 ist für
DiskHeader und BAM reserviert) können
nun 8 Einträge stehen, was einer maximal
mögliche Anzahl von 144 Einträgen entspricht. Da eine normale Diskette aber
so gut wie nie so viele Files beherbergt, liegen eine Menge dieser Directoryblocks brach. Gerade bei einer randvollen Diskette werden sie bis in alle
Ewigkeit unbenutzt bleiben, da ja keine neuen Files mehr hinzukommen können. Im
günstigsten Fall, nämlich dann, wenn Sie
weniger als 9 Files auf der Diskette
haben, sind das 17 Blocks, die noch
zusätzlich frei sind!
Diese Blocks soll UseDir nun einfach als
Datenblocks verwenden. Es muß lediglich
einen Fileeintrag kreieren, in dem der
Zeiger für den ersten Track und Sektor
auf einen der unbenutzten DirBlocks
zeigt. Wird dieses File dann geladen, so
greift das DOS der Floppy schön brav auf
diese sonst ungenutzten Blocks zu, so
als gäbe es keinen Unterschied. Tatsächlich hat die Diskette dann jedoch 683 Blocks ( maximal) anstelle von nur 664 !
DIE THEORIE
Was muß unser Programm nun tun, um ein
File auf die oben beschriebene Weise
umzukopieren. Zunächst einmal wollen wir
hier eine Einschränkung vereinbaren, die uns die Arbeit erleichtern soll: ein
File, das auf diese Weise installiert
werden soll, muß länger sein, als es
freie Directoryblöcke gibt. Daraus ergibt sich natürlich, daß die Diskette
mindestens noch einen ' normalen', freien
Datenblock hat. Das zu installierende
File muß desweiteren natürlich kleiner, oder gleich lang der insgesamt verfügbaren Blöcke sein und sollte vom Typ " PRG" sein. Daraus ergeben sich folgende Aufgaben für unser Programm:
1) Das zu installierende File einlesen
und benötigte Anzahl von Blöcken ermitteln.
2) Anzahl der freien Blöcke der Zieldiskette ermitteln.
3) Anzahl der freien Directoryblöcke der
Zieldiskette ermitteln.
4) Vergleichen, ob das File den obig
gegebenen Restriktionen entspricht
und ob noch genügend Platz auf der
Zieldiskette ist.
5) Wenn ja, dann weiter, sonst abbrechen.
6) Nun muß berechnet werden, wieviele
Bytes in den Directoryblocks Platz
haben. Alles restliche wird anschließend, als normales File, mit Hilfe
der WriteFile-Routine aus dem vorletzten Kursteil auf die Diskette
geschrieben.
7) Jetzt suchen wir den Fileeintrag des
soeben gespeicherten Files aus den
Directoryblocks heraus und Lesen die
Informaton für den ersten Track und
Sektor aus dem Eintrag aus.
8) Diese Information wird sogleich in
die Trackund Sektornummer des ersten freien Directoryblocks abgeändert.
9) Jetzt müssen wir nur noch die fehlenden Directoryblocks schreiben und den
letzten Directoryblock auf den ersten
Track/ Sektor des geschriebenen Files
zeigen lassen - Fertig ist die Installation!
DIE BENÜTIGTEN PROGRAMMTEILE
Kommen wir nun also zu unserem Programm.
Dabei möchte ich Ihnen zunächst einmal
eine Liste der darin enthaltenen Routinen geben. Hierbei habe ich in zwei Arten unterschieden: in Steuerund IO-Routinen. Diese beiden Namen treffen
Ihre Bedeutung zwar nicht voll und ganz, jedoch musste irgendwo eine Grenze gezogen werden.
Die erste Art, die Steuerroutinen also, sind alles Funktionen, die entweder
nichts direkt mit der Floppy zu tun haben, und somit für uns uninteressant
sind, oder aber Funktionen, die wir in
vorangegangenen Kursteilen schon besprochen hatten, und somit nicht noch einer
zweiten Dokumentation bedürfen. All diese Routinen werden nur mit ihrem Namen, ihrer Funktion und ihren Parametern aufgeführt, damit Sie wissen, wozu sie da sind, und wie man sie benutzt.
Die zweite Art von Routinen sind größtenteils Floppy-Routinen, die eine Beschreibung benötigen und im Laufe dieses
Kursteils alle nocheinmal genauer dokumentiert sind.
Desweiteren werden diverse Speicherzellen als Zwischenspeicher für verschiedentliche Werte benutzt. Diese haben, der besseren Öbersichlichkeit wegen, richtige Namen, und können im Prinzip
überall im Speicher stehen. Dennoch will
ich die von mir benutzten Speicherzellen
hier einmal aufführen. Sie liegen, bis
auf einige Außnahmen, im Speicherbereich
von $0332-$03 FF, dem Kasettenpuffer also, der bei Floppybenutzung ja unbenutzt, und deshalb verwendbar ist. Hier
nun also die besprochenen Beschreibungen:
1) BENUTZTE SPEICHERZELLEN: * MEM0-MEM4 Die fünf Zeropageadressen von $02 bis $06. Sie werden für die Zwischenspei- cherung verschiedenster Ergebnisse herangezogen. * FILEMEM ($0F00) Dies ist die Anfangsadresse des Spei- chers, in den das zu installierende Programm geladen wird. * NUMBUFF ($0332) Hier wird der ASCII-String einer Kon- vertierten Zahl abgelegt (maximal 5 Zeichen). * NEED ($0337) Zwischenspeicher für die Länge des gelesenen Files in Blocks. * DSKFREE ($0338/$0339) Speicher für die Anzahl der freien Blocks der Zieldiskette. * ALLFREE ($033A/$033B) Anzahl der insgesamt (inkl. freie Dir- blocks) auf der Zieldiskette verfügba- ren Blocks. * DIRFREE ($033C) Anzahl der freien Directoryblocks * DIRSTRT ($033D) Sektornummer des ersten freien Direc- toryblocks. * FTRACK ($033E) Tracknummer des ersten, vom normal geschriebenen File benutzten, Daten- blocks. * FSECTOR ($033F) Sektornummer des ersten, vom normal geschriebenen File benutzten, Daten- blocks. * DSINDEX ($0340) Indexzeiger auf den aktuellen Eintrag der Dirblockliste. * COMBUFF ($0341-) Zwischenspeicher für Befehle, die an die Floppy gesandt werden sollen. * NAME Dieses Label beszeichnet die Starta- dresse, des 17 Zeichen langen Zwi- schenspeichers für Filenamen. Dieser befindet sich direkt im Sourcecode. 2) STEUERROUTINEN
* GETIN: Diese Funktion verlangt keine
Parameter. Sie liest mit Hilfe der
BASIN-Routine des Betriebssystems einen maximal 16 Zeichen langen String
von der Tastatur ein und wird zum Eingeben des Filenamens benutzt. Dieser
String liegt nach dem Rücksprung ab
der Adresse NAME. Die Länge des Filenamens steht in der Speicherzelle
MEM0 . Am Ende des Namensstring wird
ein Nullbyte als Endmarkierung angefügt.
* STROUT: Diese Routine gibt einen AS-CII- Text auf dem Bildschirm aus. Lo/- Hi-Byte der Textadresse müssen in Akku
und Y-Register übergeben werden. Der
Text muß mit einem Nullbyte enden.
* OPENCOM: Diese Routine öffnet den Befehlskanal mit der logischen Filenummer 1 . Beim Üffnen wird die Diskette
automatisch initialisiert ( Floppybefehl " I")
* OPENIO: Hier wird der Befehlskanal mit
der Filenummer 1( wie OPENCOM) und ein Pufferkanal mit der Filenummer 2( und
Sekundäradresse 2) geöffet.
* RFILE: Dies ist die " ReadFile"- Routine
aus dem letzten Kursteil. Sie liest
das File, dessen Namen bei NAME steht
und dessen Namenslänge in MEM0 abgelegt ist, an die Adresse FILEMEM. Sie
benutzt die Zeropageadressen $ F9/$ FA
als Lesezeiger. Hier steht nach dem
Rücksprung gleichzeitig auch die Endadresse des gelesenen Files.
* WFILE: Schreibt das File in NAME und
MEM0 auf Diskette. Die Startadresse
des zu speichernden Bereichs muß dabei
in den beiden Zeropageadressen $ FD/$ FE, die Endadresse in $ F9/$ FA
stehen.
* STATOUT: Gibt die ermittelten Werte
für " Anzahl benötigte Blocks"," Freie
DirBlocks", und " Freie Diskblocks" auf
dem Bildschirm aus.
3) IO-ROUTINEN: * STRIEC: Wie "STROUT", nur daß diesmal
ein String auf den IEC-Bus ( also an
die Floppy) ausgegeben wird.
* SENDCOM: Da wir zur Erfüllung unserer
Aufgabe immer nur Floppybefehle benötigen, die aus einem festen String und
einer angehängten, variablen Zahl bestehen, wird diese Routine benutzt, um
einen Befehl, dessen String an der
Adresse in Xund Y-Register steht und
dessen abschließende Nummer im Akku
übergeben wurde, an die Floppy zu senden.
* WDUMMY: Diese Routinelegt auf der
Zieldiskette ein File mit dem Namen in
NAME und MEM0 an und löscht es direkt
wieder. Wozu dies notwendig ist, werden wir später sehen.
* GETDSKF: Ermittelt die Anzahl der
freien Blocks der Zieldiskette und
legt sie in DSKFREE ab.
* GETDIRF: Ermittelt die Anzahl der
freien Directoryblocks der Zieldiskette und legt sie in DIRFREE ab. Desweiteren wird die Summe von DSKFREE und DIRFREE berechnet und in ALLFREE abgelegt.
* GETNEED: Berechnet die benötigte Anzahl Blöcke des zuvor eingelesenen
Files und legt Sie bei " NEED" ab.
* CHGENT: Diese Routine sucht den Filenamen in NAME aus dem Directory heraus, liest die Nummern des ersten
Tracks und Sektors dieses Files ein, und überschreibt diese beiden Informationen mit den Werten für den ersten
freien Directoryblock.
* WBLOCKS: Diese Routine schreibt alle
fehlenden Blocks des Files in die
freien Directoryblocks und gibt im
letzten dieser Blocks Trackund Sektornummer des ersten Datenblocks des
' normal' gespeicherten Files an.
DIE PRAXIS
Nach all der trockenen Theorie wollen
wir nun endlich zur Praxis schreiten.
Beginnen möchte ich mit der Steuerroutine ' MAIN' unseres Programms, in der das
oben aufgeführte Aufgabenschema in Programmcode umgesetzt ist. Anschließend
wollen wir uns mit den benutzten Unterroutinen beschäftigen.
1) MAIN Diese Routine steuert das gesamte Programm. Zunächst einmal wollen wir die
Bildschirmfarben setzen, den Titeltext
ausgeben und den Namen des zu installierenden Files ermitteln. Ist dieser Name
gleich dem String X", so soll das Programm mit einem RESET verlassen werden:
main lda #11 ;Bildschirm-
sta 53280 ;farben
sta 53281 ;setzen.
lda #<(text1) ;Titeltext
ldy #>(text1) ;auf Bildschirm
jsr strout ;ausgeben.
jsr getin ;Und Filename
einlesen.
cpy #1 ;Vergleichen, ob
bne m3 ;der Name="X"
lda #"x" ;ist.
cmp name ;Wenn nein, dann
bne m3 ;weitermachen.
jmp 64738 ;Sonst: RESET.
Als Nächstes müssen wir das File lesen
und seine Blocklänge berechnen. Hieraufhin wird der Benutzer dazu aufgefordert, die Zieldiskette einzulegen, von der wir
dann die Anzahl der freien Dirund
Diskblocks ermitteln. Gleichzeitig wird
dann auch noch das Dummyfile erzeugt. Am
Ende werden alle ermittelten Werte mittels der Routine STATOUT auf dem Bildschirm ausgegeben:
m3 jsr rfile ;File einlesen
jsr getneed ;Anzahl der benö-
tigten Blocks
berechnen
lda #<(text2) ;"Zieldisk ein-
ldy #>(text2) ;legen"
jsr strout ;ausgeben und
mloop1 jsr inkey ;auf Tastendruck
beq mloop1 ;warten.
lda #<(text3) ;"Untersuche
ldy #>(text3) ;Zieldisk"
jsr strout ;ausgeben.
jsr wdummy ;Dummy-File anle-
gen und löschen.
jsr openio ;Kanäle öffnen
jsr getdskf ;Freie Diskblocks
ermitteln
jsr getdirf ;Freie Dirblocks
ermitteln.
jsr closeio ;Kanäle schließen
jsr statout ;Werte ausgeben.
Nachdem nun all diese Dinge getan sind, müssen wir nun erst einmal prüfen, ob
das gelesene File und die Daten der
Zieldiskette es uns ermöglichen, das
File auf die Diskette zu schreiben.
Hierbei wird abgebrochen, wenn keine
Dirblocks mehr frei sind, das File kürzer als die noch verfügbaren Dirblocks, oder länger als die gesamt verfügbaren
Blocks ist:
lda dirfree ;DirFree lesen
bne m1 ;wenn<>0, weiter.
lda #<(errtxt1) ;Sonst "Kein Dir-
ldy #>(errtxt1) ;blk mehr frei"
jmp errout ;ausg. u. Ende.
m1 cmp need ;DirFree mit NEED
bcc m2 ;vergleichen.
lda #<(errtxt2) ;Wenn >, dann
ldy #>(errtxt2) ;"File zu kurz"
jmp errout ;ausg. u. Ende.
m2 ldy allfree+1 ;Hi-Byte ALLFREE
lesen.
bne ok ;Wenn <>0, dann
genug Platz.
lda allfree+0 ;Sonst Lo-Byte
lesen
cmp need ;u. m. NEED vgl.
bcs ok ;Wenn >, Ok.
lda #<(errtxt3) ;Sonst "File zu
ldy #>(errtxt3) ;lang" aus-
jmp errout ;geben
Wurden all diese Vergleiche erfolgreich
bestanden, so kann das File installiert
werden. Hierzu müssen zunächst einige
Vorbereitungen getroffen werden: Als
erstes sollten wir die Sektornummer des
ersten freien Directoryblocks ermitteln.
Dies ginge natürlich dadurch, indem wir
die BAM einlesen würden, und uns einen
unbelegten Block als Startblock heraussuchen würden. Es geht aber noch viel
einfacher: das DOS der Floppy beschreibt
die Sektoren einer Diskette nämlich meistens in einer ganz bestimmten Reihenfolge. Das ist bei den normalen Datenblocks nicht unbedingt gesichert, da bei
einer nahezu vollen Diskette diese Reihenfolge nicht mehr eingehalten werden
kann. Beim Directorytrack 18 können wir uns jedoch mit 100%- iger Sicherheit darauf verlassen, daß sie immer eingehalten wird. So gibt es nämlich eine ganz
bestimmte Reihenfolge, in der die Directorytracks geschrieben werden. Wir müssen lediglich wissen, wieviele Blocks
benutzt sind, und uns die Sektornummer
des nächsten Blocks aus einer Tabelle zu
holen. Dies ist dann automatisch der
erste leere Dirblock. Die angesprochene
Tabelle ist bei dem Label " BLKTAB" abgelegt, und beinhaltet die folgenden Werte
für Sektornummern:
BLKTAB .byte 0,1,4,7,10,13,16
.byte 2,5,8,11,14,17
.byte 3,6,9,12,15,18,$ff
Bitte nun Teil 2 des Floppy-Kurses laden In dieser Reihenfolge werden die Blocks
des Track 18 IMMER belegt. Der Wert $ FF
am Ende der Liste steht hier als Endmarkierung der Liste, die später beim Beschreiben der Dirblocks von Bedeutung
ist. Nun müssen wir erst einmal die Sektornummer des ersten freien Dirblocks
ermitteln:
ok lda #19 ;Von der Gesamt-
sektorzahl (19)
für Track 18
sec ;die Anzahl der
sbc dirfree ;freien Dirblocks
subtrahieren
(=Anzahl belegte
Blocks) und als
tay ;Index in Y-Reg.
lda blktab,y ;Sektornr. lesen
sta dirstrt ;und speichern.
sty dsindex ;Index speichern
Nun wollen wir das File auf der Zieldiskette anlegen. Hierzu schreiben wir es zunächst ganz normal mittels der WFILE-Routine. Hierbei sollen jedoch nur die
Bytes geschrieben werden, die nicht mehr
in die Dirblocks passen. Wir müssen nun
also die Anfangsadresse des zu schreibenden Files berechnen. Da die ersten
beiden Bytes eines Datenblocks immer als
Zeiger auf den nächsten Datenblock dienen, müssen wir also den Wert DIR-FREE*254 zur FILEMEM-Adresse hinzuaddieren, um unsere Anfangsadresse zu erhalten:
ldx dirfree ;DIRFREE in X
laden (=HiByte
Startadr.).
txa ;u. in Akku holen
dex ;HiByte-1
asl ;Akku*2
eor #$ff ;und invertieren
clc ;mit
adc #1 ;Öbertrag.
adc #<(filemem) ;LoByte von
bcc m5 ;FILEMEM
inx ;addieren.
m5 sta $fd ;unde ablegen
txa ;HiByte holen
clc ;und mit HiByte
adc #>(filemem) ;FILEMEM add.
sta $fe ;u. ablegen
jsr wfile ;File schreiben
Nachdem die Anfangsadresse berechnet und
in $ FD/$ FE abgelegt wurde, wird die WFI-LE- Routine aufgerufen. Die Endadresse
muß in $ F9/$ FA stehen, wo sie noch von
der RFILE-Routine enthalten ist ( wird
von ihr als Lesezeiger verwedet) .
Ist das File nun geschrieben, so müssen
wir nur noch seinen Fileeintrag aus dem
Directory heraussuchen, Track und Sektor
des ersten freien Dirblocks eintragen
und die fehlenden DIRFREE*254 anfänglichen Bytes in den Dirblocks unterzubringen:
jsr openio ;Kanäle öffnen
jsr chgent ;Eintrag suchen
und ändern.
jsr wblocks ;DirBlocks
schreiben.
jsr closeio ;Kanäle schließen
lda #<( text4) ;" File installldy #>( text4) ; liert"
errout jsr strout ;ausgeben.
eo1 jsr inkey ;Auf Tastendruck
beq eo1 ;warten.
jmp main ;Und neu starten
Soviel also zu unserer Steuerroutine.
Kommen wir nun zu den Unterfunktionen:
2) STRIEC Diese Routine gibt einen Zeichenstring, dessen Adresse in Akku und Y-Register
steht, an den Befehlskanal aus. Der
String muß mit einem Nullbyte beendet
sein:
striec sta $ fb ; Adresse in Zeisty $ fc ; ger ablegen.
lda #8 ;Floppy auf
jsr listen ;Befehlskanal
lda #$6f ;empfangsbereit
jsr seclst ;machen.
ldy #0 ;String lesen
siloop1 lda ($fb),y ;und senden.
bne si1
lda #8 ;Floppy zurück-
jmp unlist ;setzen u. Ende.
si1 jsr iecout ;Zeichen senden
iny ;und Zeiger+1
bne siloop1
inc $fc
jmp siloop1
3) SENDCOM Diese Routine wird dazu verwandt, einen
Floppybefehl zu senden. Hierbei unterscheidet sie sich jedoch von der Routine STRIEC. Es wird nämlich nicht nur der
Zeiger des Befehls übergeben ( in X und
Y-Register), sondern auch ein Wert im
Akku, der vor dem Senden in ASCII umgewandelt und an den Befehlsstring in X/ Y
angehängt wird. Der gesamte Befehl wird
dabei bei COMBUFF abgelegt und dann mittels STRIEC an die Floppy gesandt:
sendcom pha ; Akku retten stx scloop1+1 ; Stringzeiger sty scloop1+2 ; setzen
ldy #0 ;Und String
scloop1 lda $c000,y ;nach COMBUFF
beq sc1 ;umkopieren.
sta combuff,y
iny
jmp scloop1
sc1 sty mem0 ;Zeiger retten,
pla ;Akku holen,
jsr i2a ;konvertieren.
ldy mem0 ;Zeiger zurückh.
ldx #0 ;und in ASCII
scloop2 lda numbuff,x ;konvertierte
beq sc2 ;Zahl an COMBUFF
sta combuff,y ;anhängen.
inx
iny
jmp scloop2
sc2 lda #13 ;CR anhängen
sta combuff,y
iny
lda #0 ;Endmarkierung
sta combuff,y ;anhängen
lda #<( combuff) ; und Inhalt von ldy #>( combuff) ; COMBUFF an jmp striec ; Floppy senden.
4) WDUMMY Kommen wir nun zur Routine " WDUMMY" . Wir
sollten zunächst einmal klären, wozu sie
benötigt wird. Wie Sie oben sahen, wird
sie aufgerufen, noch BEVOR irgendendet- was anderes getan wird. Hierbei tut sie
eigentlich nichts anderes, als ein File
mit dem Namen in NAME und MEM0 auf der
Zieldiskette anzulegen und gleich darauf
wieder zu löschen. Das deshalb notwendig, um sicherzustellen, daß auch die
richtige Anzahl an Dirblocks als ' belegt' gekennzeichnet ist. Sollten nämlich genau 8( oder 16,24, etc.) Files auf
der Zieldiskette vorhanden sein, so kann
es zu Problemen kommen. Beim Schreiben
eines neuen Files muß das DOS dann nämlich einen neuen Dirblock hinzufügen, der ab dann nicht mehr zur Datenspeicherung benutzt werden kann. Damit es dabei
keine Konfrontationen gibt, wird das
File also sporadisch schon einmal angelegt und direkt danach wieder gelöscht.
Der neue DirBlock wird dann nicht wieder
freigegeben. Der Eintrag bleibt nämlich
erhalten, es wird lediglich der Filetyp
' DEL' an das Programm vergeben. Hier nun
also die Routine:
wdummy lda mem0 ;Filename
ldx #<(name) ;in NAME
ldy #>(name) ;und MEM0
jsr setnam ;setzen.
lda #1 ;Fileparameter
ldx #8 ;"1,8,1" für
ldy #1 ;("PRG saven")
jsr setpar ;setzen.
jsr open ;File öffnen.
ldx #1 ;Kanal 1 als
jsr ckout ;Ausgabefile
jsr bsout ;Byte ausgeben.
jsr clrch ;Standardkanäle
zurücksetzen.
lda #1 ;File wieder
jsr close ;schließen.
jsr opencom ;Befehlskanal
öffnen
lda #<(name-2);Name-2 als
ldy #>(name-2);Adresszeiger
jsr striec ;senden.
lda #1 ;Befehlskanal
jmp close ;schließen.
Nun kann ich Ihnen auch den Grund zeigen, warum der Filename im Sourcecode
abgelegt wird. Hier ist nämlich vor dem
eigentlichen Namen auch noch der Text
" S:" abgelegt. Wenn wir nun NAME-2 an
STRIEC übergeben, so enspricht das einem
Scratchbefehl für den Filenamen (" S: NA-ME") . Da STRIEC ein Nullbyte als Endmarkierung verlangt, wurde die GETIN-Routine so ausgelegt, daß sie nach dem
letzten eingelesenen Zeichen ein solches
Byte in den NAME-Puffer schreibt. Hier
nun die Source-Definition des Filenamenspuffers. Für den Namen werden 17 Bytes reserviert, da ja maximal 16 Zeichen plus die Endmarkierung 0 vonnöten
sind:
. text " s:" name . byte 0,0,0,0,0,0,0,0 . byte 0,0,0,0,0,0,0,0,0
5) GETNEED Diese Routine wird benutzt, um die An-
zahl der vom Quellfile benötigten Blocks
zu ermitteln. Hierbei wird zunächst die
Startadresse des Filespeichers subtrahiert, um die effektive Länge in Bytes
zu ermitteln. Hiernach wird das High-Byte mit zwei multipliziert. Dies ist
nämlich die Anzahl Bytes, die Aufgrund
des Wegfalls der ersten beiden Bytes
eines Datenblocks zu der Anzahl Lo-Bytes
addiert werden muß. Ist dieser Wert größer als 256, so wird ein Block mehr gebraucht. Jetzt wird noch die Anzahl der
Low-Bytes hinzuaddiert. Gibt es auch
hier einen Öberlauf, so muß wieder ein
Block hinzuaddiert werden. Letztendlich
muß wieder ein Block hinzugefügt werden, da die letzten Bytes, selbst wenn
es weniger als 254 sind, dennoch einen
ganzen Block belegen:
getneed ldx #0 ;NEED
stx need ;löschen.
lda $f9 ;Endadr. d.
Quellfiles (von
ldx $fa ;RFILE noch da)
lesen.
sec ;und Startadresse
sbc #<(filemem);subtrahieren.
bcs rf1 ;Ergebnis wird in
dex ;MEM1 (LoByte)
rf1 sta mem1 ;und
txa ;MEM2 (HiByte)
sec ;abgelegt.
sbc #>(filemem)
sta mem2
rol ;HiByte*2
bcc cn1 ;Wenn<256, weiter
inc need ;Sonst Blocks+1
cn1 clc ;LoByte addieren
adc mem1
beq cn2
bcc cn2
inc need ;Bei Öberlauf
Blocks+1
cn2 inc need ;Und nochmal
Blocks+1
lda mem2 ;Und Hi-Byte
clc ;addieren.
adc need ;und in NEED
cn3 sta need ;ablegen.
rts
6) GETDISKF Kommen wir nun zur Routine zum Feststellen der freien Blocks der Diskette. Dieser Wert ist normalerweise nicht direkt
aus dem DiskHeaderBlock zu erfahren. Die
einzige Möglichkeit wäre, die Blockbelegungen der einzelnen Tracks aus der BAM
zu lesen und aufzusummieren. Aber auch
hier wollen wir uns eines kleinen Tricks
bedienen. Wird eine Diskette nämlich
initialisiert ( was wir beim Üffnen des
Befehlskanals schon tun), so liest die
Floppy die BAM der Diskette automatisch
ein und berechnet die Anzahl der freien
Blocks von selbst. Diese Anzahl wird
dann in den Bytes $02 FA ( Lo) und $02 FC
( Hi) des Floppyspeichers abgelegt. Was liegt also näher, als diesen Wert direkt, über den Memory-Read- Befehl der
Floppy auszulesen. Und nichts anderes
tut GETDISKF:
getdskf lda #<(com5) ;Memory-Read
ldy #>(com5) ;Befehl
jsr striec ;senden.
lda #8 ;Floppy sende-
jsr talk ;bereit auf
lda #$6f ;Befehlskanal
jsr sectlk ;machen.
jsr iecin ;Lo-Byte lesen
sta dskfree+0 ;und sichern.
jsr iecin ;Byte überlesen.
jsr iecin ;Hi-Byte lesen
sta dskfree+1 ;und sichern.
lda #8 ;Floppy zurück-
jmp untalk ;setzen.
Zusätzlich hierzu muß noch das entspre- chende Memory-Read- Kommando im Sourcetext abgelegt werden (3 Zeichen ab
Adresse $02 FA lesen) :
com5 .text "m-r"
.byte 250,2,3,13,0
7) GETDIRF Nun kommen wir zur Routine zum Ermitteln
der freien Directoryblocks. Hier können
wir keinen Umweg gehen, sondern müssen
die BAM direkt auslesen. Da das Directory ausschließlich in Block 18 steht, genügt es, das erste Byte des BAM-Eintrags für Track 18 auszulesen. Dieses
Byte steht an Position 72 des DiskHeaderBlocks. Wir müssen also den Block
18/0 in den Puffer lesen, und den Pufferzeiger auf 72 setzen um an die
gewünschte Information zu kommen.
Gleichzeitig berechnet diese Routine die
Anzahl der insgesamt verfügbaren Blocks
auf Diskette. Hierzu müssen wir lediglich den Inhalt von DSKFREE und DIRFREE addieren und in ALLFREE ablegen.
getdirf lda #<(com6) ;"Block 18/0
ldy #>(com6) ;lesen"
jsr striec ;senden.
lda #<(com7) ;"Pufferzeiger
ldy #>(com7) ;auf Byte 72"
jsr striec ;senden.
lda #8 ;Floppy sende-
jsr talk ;bereit auf
lda #$62 ;Pufferkanal
jsr sectlk ;machen
jsr iecin ;Wert lesen
sta dirfree ;und sichern.
ldx dskfree+1 ;Hi-Byte lesen
clc ;Lo-Byte zu
adc dskfree+0 ;DIRFREE
bcc gf1 ;addieren.
inx
gf1 sta allfree+0 ;und in ALLFREE
stx allfree+1 ; ablegen.
lda #8 ;und Floppy
jmp untalk ;zurücksetzen.
Auch hier benötigen wir zwei Sourcecodetexte für die Diskkommandos:
com6 .text "u1 2 0 18 0" ;Sekt. 18/0
.byte 13,0 ;lesen
com7 .text "b-p 2 72" ;Pufferzgr.
.byte 13,0 ;auf 72.
8) CHGENT Kommen wir nun zu einer der wichtigsten
Routinen unseres Programms. Sie durchsucht die Directoryblocks nach unserem
Fileeintrag, liest aus ihm den
Track/ Sektor des ersten ' normalen' Datenblocks aus und legt ihn in den Adressen FTRACK und FSEKTOR ab. Desweiteren
wird hier dann Track und Sektor des ersten, freien Directoryblocks eingetragen
und der Block wieder auf die Diskette zurückgeschrieben. Auch diese Routine
benutzt die Sektorentabelle BLKTAB, um
die Reihenfolge der Directroyblocks zu
ermitteln. Desweiteren benötigt sie noch
eine weitere Tabelle, in der die Anfangspositionen der einzelnen Fileeinträge eines Directoryblocks abgelegt sind. Diese Tabelle heißt ENTTAB
und sieht folgendermaßen aus:
enttab .byte 2,34,66,98,130,162
.byte 194,226
Kommen wir nun jedoch zur eigentlichen
Routine. Sie besteht im Prinzip aus zwei
ineinander verschachtelten Schleifen, die nacheinander die einzelnen Dirblocks
einlesen und jeden einzelnen Eintrag mit
dem Namen in NAME vergleichen. Wird der
Name gefunden, so werden die Schleifen
verlassen. Dann wird nochmals auf diesen
Eintrag positioniert, und zwar so, daß
der Bufferpointer direkt auf die zwei
Bytes für Starttrack und - sektor zeigt und dort die Werte für den ersten freien
Dirblock eingertragen ( Track 18, Sektor
in DIRSTRT) . Abschließend wird dieser
Directoryblock inklusive der Änderung
wieder auf die Diskette zurückgeschrieben:
chgent lda #<(text6) ;"Suche
ldy #>(text6) ;Eintrag"
jsr strout ;ausgeben
lda #1 ;Blockzähler
sta mem1 ;initialisieren
celoop1 lda #8 ;Floppy zurück-
jsr untalk ;setzen.
ldy mem1 ;Blkzähler holen
lda blktab,y ;Sekt.nr. lesen,
sta mem3 ;ablegen,
ldx #<(com1) ;und Sektor lesen
ldy #>(com1)
jsr sendcom
inc mem1 ;Blkzähler+1
lda #0 ;Eintragszähler
sta mem2 ;initialisieren
celoop2 ldy mem2 ;Eintr.z. holen
cpy #8 ;Mit 8 vgl.
beq celoop1 ;Ja, also näch-
sten Block lesen
lda enttab,y ;Nein, also Pos.
lesen,
sta mem4 ;ablegen,
ldx #<(com2) ;und Pufferzeiger
ldy #>(com2) ;positionieren.
jsr sendcom
inc mem2 ;Eintr.z+1
lda #8 ;Floppy zum
jsr talk ;Senden auf
lda #$62 ;Pufferkanal
jsr sectlk ;bewegen.
jsr iecin ;Filetyp holen.
cmp #$82 ;u.m. "PRG" vgl.
bne celoop2 ;Wenn <>, dann
direkt weiter.
jsr iecin ;Sonst Track
sta ftrack ;und Sektor
jsr iecin ;holen und ab-
sta fsector ;legen.
Bitte nun Teil 3 des Floppy-Kurses laden
ldy #$ff ;Jetzt Filenamen
celoop3 iny ;mit NAME
jsr iecin ;vergleichen
cmp name,y
beq celoop3
cpy #16 ;Wenn 16 Stellen
beq ce1 ;dann OK.
cmp #160 ;letztes Byte 160
(Endmarkierung)
bne celoop2 ;Nein, also wei-
tersuchen.
lda name,y ;Letztes Namens-
bne celoop2 ;byte=0? Nein,
weitersuchen.
ce1 lda #8 ;Floppy
jsr untalk ;zurücksetzen.
lda mem4 ;Letzte Eintrags-
clc ;position holen,
adc #1 ;1 Addieren
ldx #<(com2) ;und setzen
ldy #>(com2)
jsr sendcom
lda #8 ;Floppy zum
jsr listen ;Empfang auf
lda #$62 ;Pufferkanal
jsr seclst ;bereit machen.
lda #18 ;Tracknr.
jsr iecout ;ausgeben.
lda dirstrt ;SektorNr.
jsr iecout ;ausgeben.
lda #8 ;Floppy
jsr unlist ;Zurücksetzen
lda mem3 ;letzten Dir-
ldx #<(com3) ;block holen,
ldy #>(com3) ;und zurück-
jmp sendcom ;schreiben.
Auch hier werden zwei Floppykommandos
benötigt. Diesmal jedoch welche mit fehlendem letzten Parameter, der von SEND-COM hinzugefügt wird:
com1 .text "u1 2 0 18";Einen DirBlk
.byte 0 ;lesen.
com2 .text "b-p 2" ;Auf best.
.byte 0 ;Byte posit.
9) WBLOCKS Dies ist die zweite, wichtige Routine
unseres Programms. Sie füllt die freien Directoryblocks mit den Bytes vom Fileanfang, bis zu dem Punkt, an dem das
' normale' File beginnt. Gleichzeitig
werden diese Dirblocks mit Hilfe des
Block-Allocate- Befehls als ' belegt' gekennzeichnet:
wblocks lda #<(text7) ;"Schreibe Dir-
ldy #>(text7) ;blocks"
jsr strout ;ausgeben.
ldx #<(filemem);Zeiger auf
ldy #>(filemem);Filemem
stx $fd ;setzen
sty $fe
wbloop1 lda #<(com4) ;Pufferzeiger
ldy #>(com4) ;auf 0 posi-
jsr striec ;tionieren.
lda #8 ;Floppy auf
jsr listen ;Pufferkanal
lda #$62 ;Empfangsbereit
jsr seclst ;machen.
ldy dsindex ;Indexzgr. holen
wb4 iny ;und erhöhen.
lda blktab,y ;Sektornr. lesen
bpl wb1 ;Wenn>0, dann
nicht letzter
Block
lda ftrack ;Wenn letzter
jsr iecout ;Block, dann
lda fsector ;Starttrack u.
jsr iecout ;-sektor d. norm.
jmp wb2 ;Files eintr.
wb1 pha ;Sonst Sekt. ret-
ten,
lda #18 ;Track 18
jsr iecout ;senden,
pla ;Sektor holen
jsr iecout ;und senden.
wb2 ldy #0 ;Anschließend
wbloop2 lda ($fd),y ;254 Datenbytes
jsr iecout ;senden.
iny
cpy #$fe
bne wbloop2
lda #8 ;Floppy zurück-
jsr unlist ;setzen.
lda $fd ;Zeiger neu
clc ;positionieren
adc #$fe ;(+254).
bcc wb3
inc $fe
wb3 sta $fd
ldy dsindex ; Sektornummer lda blktab, y ; holen,
pha ;retten,
ldx #<(com3) ;und Sektor
ldy #>(com3) ;schreiben.
jsr sendcom
pla ;Sektornummer
ldx #<(com8) ;zurückholen u.
ldy #>(com8) ;Block als 'be-
jsr sendcom ;'legt' kenn-
zeichnen.
inc dsindex ;Index+1
dec dirfree ;freie Dir-
blocks-1 (dient
als Schlei-
fenzähler)
bne wbloop1 ;und wiederholen.
rts
Auch hier eine Auflistung der benötigten
Floppybefehle. COM3 und COM8 dienen
hierbei als Halbbfehele, die von SENDCOM
ergänzt werden:
com3 . text " u22018" ; Block auf
.byte 0 ;T18 schr.
com4 .text "b-p 2 0" ;Bufferptr.
.byte 13,0 ;auf 0 setzen
com8 .text "b-a 0 18" ;Block be-
.byte 13,0 ;legen.
Hiermit ist der Floppykurs nun beendet.
Für diejenigen unter Ihnen, die Geschmack an der Programmierung der Floppy
gefunden haben, halten wir für die nächste Ausgabe einen ganz besonderen Lekkerbissen parat: ab dann gibt es nämlich
einen aufbauenden Floppy-Kurs für Profis, in dem die Floppy direkt programmiert wird.
Öbrigens: Sie sollten es nicht auf sich
sitzen lassen, daß unser Beispielprogramm mit Einschränkungen arbeitet. Öben
Sie sich doch einmal selbst in der
Floppyprogrammierung und versuchen Sie
das Programm so zu modifizieren, daß
auch Files, die kürzer als die vorhande- nen freien Dirblocks sind, installiert
werden können. Viel Spaß dabei und bei
der Programmierung der Floppy ansich
wünscht Ihnen,
Uli Basters (ub).