Assign commands to F-Keys on C64

dg5kr · 4. August 2019

Code

In order to stay in practice I started to program the probably 50th Basic Extender for the c64. It was important for me to program this again in 6502 assembler (that's a long time ago) and train the gray cells. As the saying goes, no pain, no gain. Now I am looking for an example routine to assign the F-Key with commands. Similar to the KEY command from BASIC 3.5. Who can help me? I am also happy to be contacted in German. It is not a duty.
Kind regards,
Robert

dg5kr · 5. August 2019

Sprache dieses Forms: DEUTSCH. (Sorry, habs übersehen )

Hallo 6502 Fans. Ich dachte wenn ich es in Englisch versuche spreche ich ein breiteres Publikum an. Hab aber völlig vergessen das es sich hier um ein rein nationales Forum handelt. Sorry. Kommt nicht wieder vor.

Meine Frage wie man in Assembler die F-Tasten mit Text belegt und abruft hat sich erledigt. Bin hier im Forum bei einem uralten Beitrag fündig geworden

Danke an alle die sich die Mühe gemacht haben dies hier zu lesen.

Unnd nun nochmal:

Ich schreibe gerade den wo möglich 50. BASIC Extender. Warum das denn werden einige fragen. Es gibt doch so viele. Nun, als 8Bit und 6502 Fan ist so ein Projekt eine gute Fingerübung und gibt einen schnell sichtbare erfolgserlebnisse und es ist wunderbar geeignet um sich mit 6502 Assembler und dem C64 ROM aus einander zu setzen.

Die besten Grüße aus Herzogenrath

Robert (DG5KR, JO30AU)

KiWi · 5. August 2019

Hier ggf. das ganze noch mal als Souce-Code für Kernal-Erweiterungen -> Welchen Assembler für das Patchen von Kernals/Binärdateien

dg5kr · 8. August 2019

Für alle die es interessiert. Nach ein paar gefundenen Ideen habe ich mir diese Routine programmiert. Hier der Codesnipsel:

Code

; Verbiegt Vector für Tastaturabfrage auf neuen Vector um FKEY zu nutzen
FKEYON lda #<FKEYABFR ;neuen vektor
sta $28F ;setzen
lda #>FKEYABFR
sta $290
rts
;--------------|--------|--------------|---------------------------------------
;--------------|--------|--------------|---------------------------------------
DO_KEY php
;- BEGIN CODE --------------------------
jsr CHRGET
cmp #$00 ; Keine weiteren Param
beq SHOWFKEY ;=0, dann zeige FKEY Belegung
jsr BYTEGET ;Tastennummer holen (Ergebnis liegt in X)
txa ;Lege Nr in A
GETKEYNR clc
cpx #9 ;KEYn > 8?
sta FKEYNUM ;Sichere FKey- Nr
bcs _Tab_Err10 ;'illegal quantity' anzeigen
jmp _DEFK2
_Tab_Err10 jmp $B248 ;'illegal quantity' anzeigen
_DEFK2 nop ;Prüfe auf Komma
jsr $AEFD ;auf komma testen (Wenn kein Komma -> ausgabe Syntax Erro, Ende)
_DEFK3 jsr STRPARMGET ;Hole Sting
clc
cpy #21 ;String > 20 Zeichen?
bcs _Tab_Err11 ;'string too long' anzeigen
jmp _DEFK4
_Tab_Err11 jmp $A571 ;'string too long' anzeigen
; Nun muss ich anhand der FKEy Nr den Anfangsbereich des Puffers finden. Jeder FKey hat 20Bytes.
; Beginnend bei der Startadresse FKEYBUFFER.
_DEFK4 dec FKEYNUM ;da FKey 1 = intern 0 sein soll eins abziehen
lda #>FKEYBUFFER
sta ZP5
lda #<FKEYBUFFER
sta ZP4
ldx #$00
ldx #$00
_DEFK5 ldy FKEYNUM ;Key 1 liegt am Begin vom Puffer
cpy #$00 ; und deshalb darf keine 21byte dazu addiert werden
beq _DEFK71 ;Erst ab KEY 2 wird ein Offset berechnet
clc
adc #21 ;Eine F-Taste soll max 16Zeichen sein +1 = NULL
bcs _DEFK6 ;Übertrag? Erhöhe HIGH BYTE
jmp _DEFK7
_DEFK6 inc ZP5
_DEFK7 sta ZP4 ;Sichere LOW Byte der Startadresse vom Buffer
inx
cpx FKEYNUM
bne _DEFK5
_DEFK71 lda #<TEXTBUFFER
sta ZP2
lda #>TEXTBUFFER
sta ZP3
ldy #$00
_DEFK8 lda (ZP2),y ;Lade TEXTPUFFER
sta (ZP4),y ;Speichere in FKEYPUFFER
iny
cpy TEXTBUFFERLEN
beq _DEFK9
jmp _DEFK8
_DEFK9 lda #$00 ;Setze NULL an FKEY Text Ende
sta (ZP4),y
jsr CLR_KEYBUF
jmp _KEY_END
;-------------------------------------------------------------------------------
SHOWFKEY jsr $AAD7 ;cr ausgeben
lda #<FKEYBUFFER ;zeiger auf textspeicher
sta ZP0
lda #>FKEYBUFFER
sta ZP1
ldx #1 ;tastennummer
stx ZP5 ;zwischenspeichern
_FKL1 lda #"K" ;'K' ausgeben
jsr CHROUT
lda #"E" ;'E' ausgeben
jsr CHROUT
lda #"Y" ;'Y' ausgeben
jsr CHROUT
lda #0 ;tastennr. (high)
ldx ZP5 ;(low)
jsr $BDCD ;ausgeben
lda #"," ;',' ausgeben
jsr CHROUT
lda #$22 ;'"' ausgeben
jsr CHROUT
ldy #0
lda (ZP1),Y ;kein text vorhanden?
beq _FKL2 ;ja, dann ausgabe ueberspringen
lda ZP0 ;zeiger auf textspeicher (low)
ldy #$00
_FKL2_CHR lda (ZP0),y
cmp #$00
beq _FKL2
cmp #$0D ; Überspringe $0D (CR)
beq _FKL2_INY
jsr CHROUT
_FKL2_INY iny
jmp _FKL2_CHR
_FKL2 lda #$22 ;'"" ausgeben
jsr CHROUT
jsr $AAD7 ;cr ausgeben
ldx ZP5 ;tastennummer
inx ;um 1 erhoehen
cpx #9 ;>8?
bcc _FKL3 ;nein, dann weiter
jmp _KEY_END ;sonst fertig!
_FKL3 stx ZP5 ;tastennummer zwischenspeichern
clc ;zeiger um 11 erhoehen
lda ZP0
adc #21 ;Sind 20+1 Zeichen erreic
sta ZP0
lda ZP1
adc #0
sta ZP1
jmp _FKL1 ;naechsten text ausgeben
;------------------------------------------------------------------------------
;--------------|--------|--------------|---------------------------------------
FKEYABFR lda $9D
cmp #$80 ;Direktmodus?
beq _FKEX1 ;Ja, weiter
jmp _jmp_key_org ;Nein, zur original-routine
_FKEX1 sei ;Interrupts sperren (IRQ-Routine abschalten, um Überschneidungen mit alter Tastaturabfrage zu vermeiden)
lda $028D ;0=unshift, 1=shift
sta FZP0
lda $CB ;F1/F2=04, F3/F4=05, F5/F6=06, F7/F8=03
sta FZP1
;--------------|--------|--------------|---------------------------------------
_FK_Pressed lda FZP1
cmp #$04
beq _FKEY_F1_F2
cmp #$05
beq _FKEY_F3_F4
cmp #$06
beq _FKEY_F5_F6
cmp #$03
beq _FKEY_F7_F8
jmp _jmp_key_org
_FKEY_F1_F2 lda FZP0
cmp #$00
beq _FKEY_F1
jmp _FKEY_F2
_FKEY_F1 lda #$01
sta FKEYNUM
jmp _jmp_SND_FTXT
_FKEY_F2 lda #$02
sta FKEYNUM
jmp _jmp_SND_FTXT
_FKEY_F3_F4 lda FZP0
cmp #$00
beq _FKEY_F3
jmp _FKEY_F4
_FKEY_F3 lda #$03
sta FKEYNUM
jmp _jmp_SND_FTXT
_FKEY_F4 lda #$04
sta FKEYNUM
jmp _jmp_SND_FTXT
_FKEY_F5_F6 lda FZP0
cmp #$00
beq _FKEY_F5
jmp _FKEY_F6
_FKEY_F5 lda #$05
sta FKEYNUM
jmp _jmp_SND_FTXT
_FKEY_F6 lda #$06
sta FKEYNUM
jmp _jmp_SND_FTXT
_FKEY_F7_F8 lda FZP0
cmp #$00
beq _FKEY_F7
jmp _FKEY_F8
_FKEY_F7 lda #$07
sta FKEYNUM
jmp _jmp_SND_FTXT
_FKEY_F8 lda #$08
sta FKEYNUM
jmp _jmp_SND_FTXT
;--------------|--------|--------------|---------------------------------------
;Lese jeweils 10 Zeichen aus FKEYBUFFER aus und sende es an $0277,y. Dann speicher Länge (meist 10) in $C6. Puffer wird ausgeführt
;Das mache solange bis Zeichen aus FKEYBUFFER=0 ist.
_jmp_SND_FTXT nop
ldx #$3f
ldy #$ff
_VZ1 dey
bne _VZ1
ldy #$ff
dex
bne _VZ1
_TXFK4 dec FKEYNUM ;da FKey 1 = intern 0 sein soll eins abziehen
lda #>FKEYBUFFER
sta ZP5
lda #<FKEYBUFFER
sta ZP4
ldx #$00
_TXF5 ldy FKEYNUM ;Key 1 liegt am Begin vom Puffer
cpy #$00 ; und deshalb darf keine 21byte dazu addiert werden
beq _TXF71 ;Erst ab KEY 2 wird ein Offset berechnet
clc
adc #21 ;Eine F-Taste soll max 16Zeichen sein +1 = NULL
bcs _TXF6 ;Übertrag? Erhöhe HIGH BYTE
jmp _TXF7
_TXF6 inc ZP5
_TXF7 sta ZP4 ;Sichere LOW Byte der Startadresse vom Buffer
inx
cpx FKEYNUM
bne _TXF5
_TXF71 nop
ldy #$00
ldx #$00
_TXF72 lda (ZP4),y ;Lade FKEYPUFFER + Offset
cmp #$00 ;Text Ende?
beq _TXF8
cmp #$5E
bne _TXF73
lda #13
_TXF73 sta $0277,y ;Speichere ins Tastaturpuffer
iny
cpy #$10
bne _TXF72 ;<10 Zeichen, dann nächstes Zeichen holen und speichern
_TXF74 sty $C6 ;10 Zeichen voll, führe aus
ldy #$00
inx ;Nächsten Block aus 10 Zeichen (oder weniger)
cpx #$03
bne _TXF72
_TXF8 jsr CLR_KEYBUF
sty $C6 ;Anzahl Bytes in Puffer und ausführen
;--------------|--------|--------------|---------------------------------------
;Verzögerung wegen "Tastenprellen" (suboptimal)
;Das mache ich, bis ich heraus gefunden wie ich auf "Keine" Taste prüfen kann
ldx #$3f
ldy #$ff
_VZ2 dey
bne _VZ2
ldy #$ff
dex
bne _VZ2
_jmp_key_org nop
ldx #$FF ;flag 'tastaturcode ungueltig'
jmp $EB48 ;Fertig, zur original-routine
FZP0 !BYTE $00 ;Exclusiver Zwischenspeicher
FZP1 !BYTE $00 ;Exclusiver Zwischenspeicher
;- END CODE ----------------------------
_KEY_END nop
;---jmp CLR_KEYBUF ;--> KEYBUF darf nicht geleert werden!
PLP ;Stelle Prozessor Status wieder her
rts ;Einfache CMD ohne Parm braucht ein RTS
;------------------------------------------------------------------------------

Alles anzeigen

GoDot · 8. August 2019

Ich würde noch ne Abkürzung für CHR$(13) (Returntaste) einbauen, z.B. den Linkspfeil. Dann muss die Eingabe natürlich geparst werden.

Arndt

dg5kr · 9. August 2019

Ja, danke für die Anmerkung. Habs schon umgesetzt.

JeeK · 12. August 2019

Vielleicht bisschen zum Programmierstil selbst und etwas Feinschliff:

Code

jsr CHRGET
cmp #$00 ; Keine weiteren Param
beq SHOWFKEY ;=0, dann zeige FKEY Belegung

kann man ersetzen durch

Code

jsr CHRGET
beq SHOWFKEY ;=0, dann zeige FKEY Belegung

CHRGET setzt das Zero-Flag, wenn es auf eine "0" oder ":" (also Anweisungsende) stößt. Explizit auf 0 abfragen ist eigentlich falsch und berücksichtigt einen folgenden Doppelpunkt nicht. CMP #0 prüft nicht das Zero-Flag (das ja schon entsprechend gesetzt ist), sondern "nur" den Akku auf Wert = 0

Siehe C64-Wiki: CHRGET

Auch dieser Teil (kommt ja öfter in der Art vor)

Code

jsr BYTEGET ;Tastennummer holen (Ergebnis liegt in X)
txa ;Lege Nr in A
GETKEYNR clc
cpx #9 ;KEYn > 8?
sta FKEYNUM ;Sichere FKey- Nr
bcs _Tab_Err10 ;'illegal quantity' anzeigen
jmp _DEFK2
_Tab_Err10 jmp $B248 ;'illegal quantity' anzeigen

lässt sich so schreiben:

Code

jsr BYTEGET ;Tastennummer holen (Ergebnis liegt in X)
GETKEYNR
cpx #9 ;KEYn > 8?
stx FKEYNUM ;Sichere FKey- Nr
bcc _DEFK2
_Tab_Err10 jmp $B248 ;'illegal quantity' anzeigen
_DEFK2

cpx/cmp/cpy setzen implizit das Carry-Flag - das muss man nicht vorbereiten. Außerdem bleibt der Wert in Register ja erhalten, daher kann man sich das Transferieren (Retten?) von X nach A eigentlich sparen und gleich den Wert in X in FKEYNUM speichern.

Die Verzweigungsbedingung wurde umgedreht, um im "Gutfall" über die Fehlermeldung zu springen (statt in die Fehlermeldung beim "Schlechtfall").

D.h. mit bcc ( entspr. < 9) weiter machen (und bei >=9 läuft man in den Error-Handler).

Ähnlich dann auch bei der String-Parameterabfrage ...

Soweit mal zur 6502-typischen Programmierung und Bug-Behebung (ohne jetzt noch weiteres durchgearbeitet zu haben) als Anregung.

dg5kr · 15. August 2019

Perfekt. Recht vielen Dank. Habs bereits umgesetzt.

dg5kr · 16. August 2019

Habe das Thema auf Erledigt gesetzt.