Magic Disk 64

home to index to text: MD9301-KURSE-FLOPPY-KURS_8.2.txt

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)

Valid HTML 4.0 Transitional Valid CSS!