C64 Programmieren in Maschinensprache
| C64 Programmieren in Maschinensprache | |||
|---|---|---|---|
 |
Sprache | deutsch | |
| Autor(en) | Winfried Kassera, Frank Kassera | ||
| Verlag | Markt&Technik Verlag AG | ||
| Jahr | 1985 | ||
| ISBN | ISBN 3-89090-168-9 | ||
| Neupreis | DM 52,00.- SFR 47,80.- ÖS 405,60.- | ||
| Datenträger | |||
| Seitenzahl | 327 | ||
| letzte Auflage | 1., unveränderte Auflage 1985 | ||
| Genre | Profi / Programmierung | ||
| Information | |||
Vorwort[Bearbeiten | Quelltext bearbeiten]
Dieses Buch ist zunächst entstanden als Sammlung von Programmierschritten in ASSEMBLER, die sich bei der Lösung von Simulationsproblemen, Bildschirmgestaltung, Textverarbeitung usw. auf COMMODORE-Geräten ergeben hatten. Wir haben dann den Themenkreis erweitert und so gut wie alle Punkte erfaßt, die für Maschinenprogramme relevant sind.
Als Schwerpunkt hat sich dabei der Einsatz der betriebsinternen ROM-Routinen herauskristallisiert, der,die Erstellung von ASSEMBLER-Programmen wesentlich vereinfacht. Denn was es schon gibt, braucht man nicht noch einmal erfinden.
Wir sagen Ihnen aber nicht nur, wo die einzelnen Einsprungadressen liegen (das tun viele Veröffentlichungen), sondern erklären auch die Zusammenhänge anhand von sehr einfachen bis sehr anspruchsvollen Beispielen. Unser Prinzip heißt hier: Vom Einfachen zum Schweren. Und damit ergibt sich ein methodisch sinnvoller und für den Leser leicht nachvollziehbarer Aufbau.
Alle vorkommenden Routinen wurden mehrfach von Frank Kassera getestet und verbessert, der zu diesem Buch auch eine Diskette für den C64 mit allen beschriebenen Programmen zusammengestellt hat.
Trotz aller Sorgfalt und Mühe, die wir uns beim Schreiben, Testen und Korrigieren gegeben haben, ist es nicht ganz auszuschließen, daß sich in den Text der eine oder andere Tipp- oder Druckfehler eingeschlichen hat, der uns trotz mehrfacher Durchsicht entgangen ist. Wir versichern Ihnen aber, daß alle vorgestellten Programme einwandfrei laufen: Nicht ein einziges wurde nur so "auf Papier" entwickelt. Sollten Sie daher auf Unstimmigkeiten stoßen, dann könnte eventuell die Unbarmherzigkeit des Druckfehlerteufels dahinterstecken. Für einen entsprechenden Hinweis - vielleicht schon mit einem Verbesserungsvorschlag - wären wir Ihnen dankbar.
Inhaltsverzeichnis (gekürzt)[Bearbeiten | Quelltext bearbeiten]
1 Zur Programmierung in ASSEMBLER ............................ 13 1.1 Warum nicht bei BASIC bleiben? ............................. 15 1.2 Hinweise zum Gebrauch des Buches ........................... 17 1.3 Schreibweisen - Vereinbarungen ............................. 20 2 Bewegte Bildschirmobjekte .................................. 23 2.1 Ein Beispiel: "Wendezeigerpinsel", ein Richtungsanzeiger ... 25 2.2 Variieren des Moduls ....................................... 34 2.3 Abweichungen für die 40/80XX -Geräte ....................... 36 2.4 Erweiterungs- und Übungsaufgaben ........................... 37 3 Erweiterung der Interrupt-Routine - ein Beispiel ........... 39 3.1 Die IR-Routine ............................................. 41 3.2 Erzeugung eines Taktes mit der IR-Routine .................. 42 3.3 Wichtige Adressen des "04-taktmodul " ...................... 42 3.4 Ablauf von "04-taktmodul" .................................. 43 3.5 ASSEMBLER- Programm "04-taktmodul" ......................... 43 3.6 Abstimmung des Taktes ...................................... 44 3.7 Eine kleine Testroutine zur Bestimmung der Taktfrequenz .... 44 3.8 Einstellen des IRQ-Vektors ................................. 45 4 Zahlen, Variablen - Formate ................................ 49 4.1 Rechnen mit Ganzzahlen (Integer-Zahlen) .................... 51 4.2 Arbeiten mit reellen Zahlen ................................ 61 4.3 Zahlenumwandlungen ......................................... 65 5 Arithmetik mit ROM-Routinen ................................ 71 5.1 Durch 10 dividieren mit FDIV10 ............................. 74 5.2 Mit 10 multiplizieren ...................................... 75 5.3 Addieren des Werts 0.5 mit ADD0.5 .......................... 75 5.4 Addieren beliebiger Zahlen mit ADD ......................... 76 5.5 Addieren beliebiger Zahlen mit M-ADD ....................... 76 5.6 Subtrahieren mit M-SUB ..................................... 77 5.7 Vorzeichenwechsel mit FACMIN ............................... 78 5.8 Betrag einer Zahl mit FACABS ............................... 79 5.9 Multiplizieren mit M-MULT .................................. 79 5.10 Division mit M-DIV ......................................... 80 5.11 Kehrwert bilden mit M-DIV .................................. 80 5.12 Quadratwurzel ziehen mit SQRFAC ............................ 81 5.13 Potenzieren und Radizieren mit POTRAD ...................... 81 5.14 Logarithmieren mit LOGNAT .................................. 83 5.15 Exponentialrechnen mit EHOCHF .............................. 83 5.16 Erzeugen einer Zufallszahl mit ZUFALL ...................... 84 5.17 Winkelfunktionen mit SINUS, COSIN, TANG .................... 85 5.18 Umkehrung der Winkelfunktionen mit ARCTAN .................. 87 5.19 Weitere Arcusfunktionen mit ARCTAN ......................... 88 5.20 Polynomauswertung mit POLNOM ............................... 89 5.21 Wertetabellen für Funktionen mit POLNOM .................... 91 5.22 Vergleichsoperationen mit CMPFAC ........................... 94 5.23 Vorzeichenprüfung mit SGNFAC ............................... 96 6 Bildschirmoperationen ...................................... 101 6.1 Ausgabe einer Integer Zahl mit INTOUT ...................... 103 6.2 Ausgabe einer reellen Zahl mit FLPOUT ...................... 103 6.3 Ausgabe eines ASCII-Zeichens mit CHROUT (BSOUT ) ........... 104 6.4 Vorbereitete Zeichenausgaben ............................... 105 6.5 Cursorposition festlegen ................................... 105 6.6 Ausgabe eines Strings mit STROUT ........ ....... .......... 109 6.7 Umwandlung des FAC-Inhalts in einen String mit FACSTR ...... 109 6.8 Anwendung: eine PRINT USING-Routine ........................ 111 6.9 Ausgabe von Hexzahlen ...................................... 123 6.10 Bewegungssimulation - eine Kompaßanzeige ................... 124 7 Eingabe-ROM-Routinen ....................................... 135 7.1 Eingabe eines Zeichens über die Tastatur mit GETIN ......... 137 7.2 Künstlicher Cursor mit GETIN und CHROUT .................... 138 7.3 Zahleneingabe (reell) mit GETIN und STRFAC ................. 141 7.4 Eingabe mit BASIN .......................................... 143 7.5 Eingabe einer Zeile mit INLINE ............................. 145 7.6 Eingabe von Hexzahlen mit HEXINB und HEXINA ................ 148 8 Verwaltung der Variablen ................................... 151 8.1 Überblick über die BASIC-Variablen ......................... 153 8.2 Einrichten einer Variable .................................. 153 9 Variablen-Arten ............................................ 154 9.1 Struktur der Variablen ..................................... 154 9.2 Einrichten einer Variablen ................................. 154 9.3 Vereinfachungen zur Dateibehandlung ........................ 173 9.4 Behandlung von Dateien - Beispiele ......................... 174 9.5 Arbeiten mit SEQ-Dateien ................................... 175 9.6 REL-Dateien - Schreiben/ Lesen mit OUTBUS/ INBUS ........... 181 9.7 Laden eines Programmes mit LOAD und LOADXX ................. 196 9.8 Anwendung: Modul zum Nachladen von Programmen .............. 197 9.9 Modul "84-quickdirector" mit TALK, INBUS, UNTALK ........... 202 9.10 Modul "85-printdirector" ( Floppy-Drucker) ................. 208 9.11 Direktzugriffe auf Floppy: Modul "86-fastdisk " ............ 216 10 Maschinenmodu1e in BASIC-Programmen ....................... 223 10.1 Übernahme von BASIC-Parametern ............................ 225 10.2 Zeichen aus dem BASIC-Text holen mit CHRGET und CHRGOT .... 226 10.3 Byte- Auswertung mit GETBYT und VALBYT .................... 228 10.4 Eine Anwendung: PRINT AT - Routine mit Fehlermeldung ...... 233 10.5 Zu den Fehlermeldungen .................................... 235 10.6 Zur Schreibweise der BASIC-Befehle ........................ 236 10.7 Auswertung mit VAREAL ..................................... 238 10.8 Auswertung mit VALKLA ..................................... 239 10.9 Auswertung von Integerzahlen mit VALINT und INTADR ........ 239 10.10 Auswertung mit VALPAR, VALSTR, PARFLG und TYPFLG .......... 241 10.11 Übernahme einer BASIC-Variablen mit GETVAR ................ 243 10.12 Ein vielseitiges Modul: "98-onstring" ..................... 244 10.13 "99- onstring" für 40/8oXX- Geräte ........................ 250 10.14 Verknüpfen von Modulen - zwei Anwendungen ................. 254 10.15 Modulverknüpfung mit einer Sprung leiste .................. 258 11 Diverse ROM-Hilfen-Anwendungen ............................ 265 11.1 BASIC-Start vom Maschinenprogramm aus mit RUN ............. 267 11.2 Warmstart mit MGOTO ab einer bestimmten Zeilennummer ...... 267 11.3 Startadresse einer BASIC-Zeile suchen mit BLINAD .......... 270 11.4 Umschalten von Text- auf Graphikmodus ..................... 270 11.5 Abfrage der STOP-Taste mit STOPRY und STOPO ............... 272 11.6 Sprung in den READY-Modus mit MREADY ...................... 272 11.7 Verschieben von RAM - Bereichen mit TRABLO ................ 272 11.8 Abspeichern eines Datenbereichs mit MSAVE ................. 274 11.9 Laden eines Programms mit veränderter Startadresse ........ 275 11.10 Speichern eines Datenblocks mit variabler Anfangsadresse .. 279 12 ASSEMBLER-Kurzschule ...................................... 283 12.1 Die Register des 65XX-Prozessors .......................... 285 12.2 Das Prozessor Statusregister P ............................ 285 12.3 Beeinflussung der Flags durch Befehle ..................... 285 12.4 Der Befehlssatz in ASSEMBLER .............................. 286 13 ROM-Routinen - thematisch, mit Kurzbeschreibung .............. 297 14 ROM-Routinen - alphabetisch .................................. 313 15 Wichtige Adressen - alphabetisch ............................. 319 16 Stichwortverzeichnis ......................................... 325 17 Übersicht weiterer Markt&Technik-Bücher ...................... 328
Leseprobe[Bearbeiten | Quelltext bearbeiten]
Seite 83, (5.14 Logarithmieren mit LOGNAT)
Alle Logarithmen beziehen sich hier auf die Basis e. Wir rechnen also mit dem Logarithmus naturalis.
- Vorbedingung
Der Numerus kann erzeugt werden oder im RAM oder ROM stehen.
- Ablauf
01 Erzeugen der Zahl 1000 im FAC1 02 Aufruf von LOGNAT 03 Ablegen von In(1000) ab (16515) ...
- ASSEMBLER-Beispiel "34-log nat" (C64)
01 lda #3 ldy #232 ; Zahl 1000 nach jsr 45969 ; FAC1 mit INTFLP 02 jsr 47594 ; LOGNAT bildet Logarithmus von 1000 03 ldx #131 ldy #64 ; ab (16515) jsr 48087 ; mit FACMEM das Eregebnis ablegen 04 jsr 43708 rts ; Bildschirmausgabe mit FLPOUT : 6.90775528
(Seite 41: Kapitel "3 Erweiterung der Interrupt-Routine - ein Beispiel-"
3.1 Die IR-Routine
Die CBM-Rechner unterbrechen 60 mal in der Sekunde alle Programmläufe, um wichtige ROM-Routinen auszuführen, die einen geregelten Computerbetrieb gewährleisten. So wird z.B. die Tastatur abgefragt, die Uhr nachgestellt usw. Voraussetzung für die Aktivität dieser betriebsinternen Routine ist, daß der sog. IRQ-Vektor auf den Anfang der IR-Routine zeigt.
Dies ist ein Zeiger in der Zeropage, der folgende Adressen (LO/HI) hat:
Label C64 40/80XX
IRQVEC <788/789>=59953 <144/145>=58453
<$0314/0315>=$ea3l <$90/91>=$e455
Zeiger mit Inhalt auf den Standard-Interrupt
IRQVEC LO <788>=49 <144>=85
<$0314>=$31 <$90>=$55
LO des IRQ-Vektors
IRQVEC HI <789>=234 <145>=228
<$0315>=$ea <$91>=$e4
HI des IRQ-Vektors
Erläuterungen dazu:
IRQVEC ist ein Pointer, der auf die Einsprungadresse für den Standard-Interrupt zeigt. Beim C64 z.B. beginnt diese Routine ab (59953). Das ist in LO/HI zerlegt eben 49/234. Der IRQ-Vektor muß also in (788) den Wert 49 und in (789) den Wert 234 enthalten, dann wird automatisch der normale Interrupt durchgeführt.
Verstellt man diesen Zeiger um 3 Adressen nach oben - das wäre beim C64 also (59956) - dann wird die STOP-Tastenabfrage übergangen. Das bedeutet, daß man ein Programm, das mit diesem Interrupt lauft, nicht mehr über die STOP-Taste abbrechen kann.
3.2 Erzeugung eines Taktes mit der IRQ-Abfrage
Zielsetzung:
Wir wollen in einem bestimmten Rhythmus ein Programm durchlaufen.Oder anders ausgedrückt: In einem vorgegebenen Takt sollen bestimmte Abläufe (z.B. Standortbestimmungen, Anzeigen usw.) ausgeführt werden.
Für unser folgendes Beispiel nehmen wir uns vor, daß alle 0,25s ein Flag gesetzt wird, an Hand dessen ein Programm selbst "entscheiden" kann, ob es starten soll oder nicht.
Dadurch lassen sich z.B. Bewegungsabläufe in kleine Schritte zerlegen, so daß man jederzeit die Position o.ä. mitrechnen kann. Es läßt sich somit eine Digitalisierung erzielen, die bei fast allen unregelmäßigen Vorgängen zur Analysierung der Einzelfaktoren erforderlich ist.
Nennen wir das dafür zuständige Programm "04-taktmodul".
3.3 Wichtige Adressen von "04-taktmodul"
- Wir lassen die Interrupt-Erweiterung bei (17000) beginnen.
- Als Flag verwenden wir die Adresse (1010).
Wir vereinbaren, daß wir (1010) mit 1 belegen, wenn eine Zeit von 0,25s verstrichen ist. Läuft auf Grund dieses Flags ein Programm an, muB dieses Programm selbst dafür sorgen, daß (1010) wieder auf O zurückgesetzt ist.
(Voraussetzung für die Einhaltung eines gleichmäßigen Takts ist dann, daß das dadurch gestartete Programm auch bei allen möglichen Verzweigungen nie länger als 0,25s für einen Durchlauf benötigt.)
Die Warteschleife lassen wir wieder über einen Zähler laufen, für den wir die Adressen (1011/1012) als LO/HI bereitstellen. Damit haben wir wieder die Möglichkeit, unsere Taktfrequenz in einem relativ großen Bereich vorzuwählen.
3.4 Ablauf von "04-taktmodul"
Ol: Warteschleife
- Erhöhen des Zählers in (1011/1012).
- Abfrage, ob der gewünschte Wert erreicht ist.
02: Taktflag
- Setzen des Taktflags (1010) auf 1, wenn die vorgegebene Zeit erreicht ist.
03: Abschluß
- Weitersprung zur betriebsinternen IR-Routine.
3.5 ASSSEMBLER-Programm für "04-taktmodul"(C64):
Ol:Warteschleife:
17000 inc 1011 ; Zähler LO erhöhen 17003 bne 17008 ; ungleich 0 ===> weiter 17005 inc 1012 ; sonst Zähler HI erhöhen 17008 1da 1012 ; Zähler HI... 17011 cmp #0 ; ...mit O vergleichen (Beispiel!) 17013 bne 17037 ; ungleich O ===> weiter 17015 Ida 1011 ; Zähler LO... 17018 cmp #15 ; mit 15 vergleichen (Beispiel für 0,25s) 17020 bne 17037 ; nicht erreicht ===> weiter 17022 nop
02: Taktflag:
17023 Ida #1 ; Flag 17025 sta 1010 ; in (1010) auf 1 setzen 17028 lda #0 ; Zähler 17030 sta 1011 ; ...LO 17033 sta 1012 ; ...und HI zurücksetzen
Teil 3:
17036 jmp 59953 ; Sprung zur CBM-IR-Routine
Wir erhalten einen 0,25s-Takt, wenn wir mit dieser Schleife warten, bis der Zähler in (1011/1012) auf 0/15 steht. Das läßt sich durch das angekündigte Testprogramm überprüfen.
Ein genaueres Intervall für exakte Rechenroutinen können wir auch mit Hilfe der Stoppuhr ermitteln. Im Normalfall genügt aber eine Genauigkeit von 1/60 Sekunde.
3.6 Abstimmung des Taktes
Die Warteschleife (sie entspricht der des vorhergehenden Moduls) muß immer individuell abgestimmt werden. Das geschieht mit Hilfe des Zählers in (1011/1012).
Wann eine Zeit von 0,25s erreicht ist, wird durch ein kleines Testprogramm ermittelt.
Für diesen Minitest lassen wir uns immer dann, wenn das Intervall abgeschlossen ist, ein beliebiges Zeichen auf dem Bildschirm ausgeben und setzen danach sofort unseren Zähler und das flag auf 0.
3.7 Eine kleine Testroutine für die Bestimmung der Taktfrequenz
Das folgende Programm (ab 17100) fragt zunächst eine Taste ab, mit deren Hilfe wir den Testlauf abbrechen können. Danach wird zu Beginn eines jeden Taktes der Inhalt der Adresse (165) auf dem Bildschirm ausgegeben. Die Bildschirmadresse wird jeweils durch das (X)-Register indiziert und vor jeder neuen Ausgabe inkrementiert (um eins erhöht), so daß wir also maximal 256 hintereinan der liegende gleiche Zeichen zu sehen bekommen.
Dann fängt alles wieder an derselben Anfangsposition an. Damit sich das vom Vorhergehenden unterscheidet, wechseln wir einfach den Bildschirmcode, indem wir ihn ebenfalls um 1 erhöhen, wenn die Schleife wieder von vorn beginnt. Auf diese Weise läßt sich durch Mit- oder Abzählen der ausgedruckten Zeichen eine durchschnittliche Taktfrequenz mit guter Genauigkeit bestimmen.
Nach jeder Bildschirmausgabe muß das Taktflag zurückgesetzt werden. Danach erfolgt wieder der Sprung an die Warteschleife für das Taktflag.
Das Takt-Testprogramm "test/takt" (C64)
17100 lda 203 17102 cmp #60 ; Stoptaste (Leertaste) gedrückt? 17104 bne 17108 ; nein ===> weiter 17106 rts ; Ja ===> Rücksprung 17107 nop 17108 Ida 1010 17111 beq 17100 ; Flag 0 ===> warten 17113 inx ; Flag gesetzt ---> Zähler erhöhen 17114 bne 17118 ; 255 überschritten? nein ===> weiter 17116 inc 165 ; sonst Zeichencode erhöhen 17118 l1da 165 ; Zeichencode laden 17120 sta 1024,x ; und auf Bildschirm ausgeben 17123 1da #0 17125 sta 1010 ; Flag auf 0 17128 beq 17100 ; und Sprung an den Anfang der Schleife
Wenn sie das Programm "O04-taktmodul!" noch im Speicher haben, sollten Sie es jetzt zusammen mit diesem "test/takt" abspeichern. Nennen wir es einfach "05-takt". Es läßt sich auf diese Weise später bequem - auch von BASIC aus - mit einem einzigen LOAD-Befehl einladen.
Lauffähig ist es allerdings noch nicht, da wir den Taktgeber, der ja im Programm "O4-taktmodul" steckt, noch nicht aktiviert haben. Er muß jetzt erst in die Interrupt-Routine integriert werden. Es bringt also im Moment noch gar nichts, wenn Sie bei (17000) oder (17100) starten. Gleich im nächsten Abschnitt packen wir dieses Problem an.
3.8 Einstellen des IRQ-Vektors Die Interrupt-Routine muB nun unser "04-taktmodul" durchlaufen. Das lMÄäßt sich dadurch erreichen, daß wir den vorhin besprochenen IRQ-Zeiger auf die Anfangsadresse dieses Programms einstellen.
17000 hat zerlegt in LO/HI die Werte 104/66. Setzen wir die nun in die Adressen des IRQ-Zeigers IRQ-LO und IRQ-HI, dann wird die Interrupt-Routine brav bei (17000) beginnen.
Allerdings hat die ganze Sachen noch einen kleinen Haken, der sich aber schnell geradeklopfen läßt:
Der IRQ-Zeiger läßt sich nicht durch einfaches "poken" der Zeropage-Adressen ändern, weil ja während dieser Durchführung auch der Interrupt ausgeführt wird. Er kann deshalb auch zwischen das Einstellen von LO und HI des Zeigers fallen und schon stürzt der Rechner ins Leere, weil er einen Interrupt-Einsprung durchführt, aus dem er in der Regel nicht mehr herauskommt.
Wer den Befehl DOKE besitzt, umgeht diese Schwierigkeit und kann den IRQ-Zeiger z.B. mit DOKE1l44,17000 auf (17000) einstellen. Ansonsten muß vor einer Veränderung des Vektors, die sowohl das LO- als das HI-Byte betrifft, das "Interrupt-Disable-Flag" mit SEI gesetzt werden. Der Interrupt bleibt also aus, der Zeiger kann in Ruhe verändert werden. Anschließend setzt man dieses Flag wieder mit CLI zurück und ermöglicht damit den Einsprung in die Adresse, auf die der Vektor IRQVEC zeigt.
Das folgende kleine Proaramm - der Wichtigkeit halber auch gleich für die "großen" Geräte gelistet - stellt den IRQ-Vektor ein.
ASSEMBLER-Beispiel "06-irqvec17000"
C64 40/80XX
- 24500 sei sei ; I-Flag setzen
- 24501 1da #104 lda #104 ; LO
24503 sta 788 sta 144 ; nach IRQVEC LO
24505 lda #66 lda #66 ; HI
24507 sta 789 sta 145 ; nach IRQVEC HI
- 24509 cli cli ; I-Flag löschen
- 24510 jmp 17100 jmp 17100 ; zu "test-takt"
Jetzt können Sie das Programm gleich mit SYS 24500 starten. Sie müssen aber das Programm "O5-takt" noch im Speicher belassen haben.
Zunächst wird der IRQ-Vektor verstellt und dann zum Programm "test-takt" verzweigt.
Ab sofort wird ca.60 mal pro Sekunde das Programm "04-taktmodul" (17000) angesprungen, und der Zähler wird solange inkrementiert, bis er die eingestellte Zahl erreicht hat.
Unabhängig davon läuft das Testprogramm "test-takt" ab 17100 solange auf der Stelle, bis das Taktflag gesetzt ist. Erst wenn hier eine 1 vorliegt, erfolgt eine Zeichenausgabe auf dem Schirm.
Nun können Sie die Anzahl der gesetzten Zeichen und die dazu benötigte Zeit feststellen und Sie erhalten Ihre Taktfrequenz. Verändern Sie mit POKE 17019,XX einmal Ihren Zähler, dann werden Sie bald merken, daß Sie mit XX=15 recht gut einen 0,25s-Takt er- halten.
Anmerkung:
Daß wir die Taktfrequenz von BASIC aus überprüfen, hat seinen
Grund darin, daß einige Assembler ebenfalls die Adressen des IRQ-
Zeigers verwenden, so daß eine Veränderung nicht ratsam ist.
Zusammenfassung:
Die Interrupt- Erweiterung ist nun so aufgebaut, daß Sie den Zähler beliebig einstellen können zwischen ca. 1/60 Sekunde und ca. 18 Minuten. Jeder weitere Ausbau dieser Routine führt allerdings dazu, daß etwas mehr Zeit zur Ausführung benötigt wird, aber in Maschinensprache haben wir noch einige Reserven.
Die ganze Geschichte mit dem Taktgeber hat auch ihren Bezug zum vorhergehenden Kapitel, wo wir einen Wendezeiger simuliert haben. Wir sind nämlich jetzt (fast) in der Lage, mit Hilfe dieses Geräts die Richtung anzugeben, in die wir uns "bewegen". Wenn wir den Ausschlag des "Pinsels" aus dem Programm "Ol-pinsel" in regelmäßigen kurzen Abständen untersuchen, dann läßt sich daraus eine Richtungsänderung berechnen.
Voraussetzung dazu ist aber, daß wir sehr schnell rechnen können. Und das wiederum erfordert den Einsatz von Maschinenprogrammen. In den nächsten beiden Kapiteln Nr.4 und Nr.5 werden wir uns ausführlich mit der Arithmetik befassen. Sie ist einer der Schwerpunkte in dieser Schrift.
Doch vorher sollten Sie sich zunächst einmal an einer der folgenden Übungen versuchen.
Zwischendurch muß immer wieder betont werden, daß das bloße Durchlesen von bereits fertigen oder schon besprochenen Programmen nicht allzu viel Lerneffekt mit sich bringt.
Mehr als in anderen Bereichen gilt hier das alte Prinzip: Probieren - wobei damit immer systematisches Probieren, nicht aber Herumprobieren gemeint ist - geht über (oder zumindest neben) Studieren.
Aufgaben:
Erweitern Sie die Interrupt-Routine, um die Tastatur abzufragen und z.B. beim Drücken der Taste "0" sofort ein Flag zu setzen, das aber nach 5 Sekunden wieder gelöscht wird.
Erweitern Sie die Interrupt-Routine, um die Eingaben des Joysticks abzufragen und in der richtigen Reihenfolge in einem bestimmten Adressbereich bereitzustellen (Pufferproblem!).
Meinung[Bearbeiten | Quelltext bearbeiten]
Werner: "Die Lesbarkeit der Assembler-Listings leidet enorm unter der dezimale Schreibweise. Diese schwere Kost ist, wenn überhaupt, nur für Profis zu empfehlen."
Bamse: "Die Autoren beginnen das Buch mit einer glatten Fehlentscheidung: Dezimal statt Hexadezimal. Dadurch werden u.a. die Lo/Hi-Byte Übergaben (gerade für Anfänger) unnötig kompliziert / wenig nachvollziehbar. Dazu wirkt das ganze Buch sehr trocken & mathematisch, und dient wohl höchstens dem Profi als Nachschlagewerk für mathematische Formeln (vielmehr steht eh nicht drin). Obwohl das Buch wie ein Schulbuch wirkt schult es leider überhaupt nicht. Fazit: Nicht zu empfehlen - stattdessen den Buchtitel mal googlen und über die Initiative zum ´Zurück-an-den-Autor-senden´ lachen..."
