fragen zu source code (char-rom kopieren & eigene zeichen erstellen)

e2020 · 10. Mai 2011

hallo,

habe hier code gefunden, der das char-set aus dem rom ins ram kopiert:
der einfacheit halber kopiere ich den code von tecMO nochmal hier hin:

Code

lda #$30 ; [1.frage]
sta $01
ldx #0
copy lda $d000,x
sta $2000,x
lda $d100,x
sta $2100,x
lda $d200,x
sta $2200,x
lda $d300,x
sta $2300,x
lda $d400,x
sta $2400,x
lda $d500,x
sta $2500,x
lda $d600,x
sta $2600,x
lda $d700,x
sta $2700,x
txa
sta $0400,x
dex
bne
copy lda #25
sta $d016 [2. frage]
jmp *

Alles anzeigen

dazu habe ich 2 fragen (ich glaub ich brauch n bit-refresh
1. (1.zeile:) warum #$30 in $01?
2. (vorletzte zeile) wozu #25 (und wie wäre der wert *ohne* multicolor? ich komme nämlich manchmal in vice in den multicolor-mode...)

nach ausführung steht auf dem screen: " abcdefghijkl"... - also ein leerzeichen und dann auflistung kleinbuchstaben und tastaturzeichen etc - und ich gehe mal davon aus dass der zeichensatz jetzt ab $2000 liegt, aber:
3. wie verändere ich denn jetzt mal die matrix des buchstabens "A" (oder "a" - eigentlich egal) so dass ich mal etwas sehen kann, also

Code

76543210 ...**... 0 ..****.. 1 .**..**. 2 .******. 3 .**..**. 4 .**..**. 5 .**..**. 6 ........ 7

ich dachte da an:

Code

lda #$ff sta 2000 sta 2001 sta 2002 sta 2003 sta 2004 sta 2005 sta 2006 sta 2007 sta 2008

aber irgendwie bemerke ich keine unterschiede, weder auf dem screen noch wenn ich die buchstaben tippe...

4. und wie sage denn dem VIC jetzt, dass er das char-set jetzt (aus dem rAm ab $2000) übernehmen soll und nicht mehr aus dem char-rom?
sta $d018 umstellen? auf welchen wert?

danke für eure hilfe!
e2020

TheRyk · 10. Mai 2011

Zitat von e2020

3. wie verändere ich denn jetzt mal die matrix des buchstabens "A" (oder "a" - eigentlich egal) ...

Die meisten Menschen nehmen für so etwas einen CharSet-Editor (Software). Dort kreiert man sich den Zeichensatz, den man braucht, speichert das Produkt und bindet es später als Binary in den Assembler-Code ein, in Deinem Fall z.B. als

Code

*= $2000
!bin "charset.prg",,2

Du kannst das natürlich auch "zu Fuß" machen, schau Dir dazu mal das hier an:
http://www.c64-wiki.de/index.p…atz#Zeichenprogrammierung
Ist zwar Basic, aber nur POKE, also im Prinzip in Assembler nicht anders.

Zitat von e2020

wie sage denn dem VIC jetzt, dass er das char-set jetzt (aus dem rAm ab $2000) übernehmen soll und nicht mehr aus dem char-rom?
sta $d018 umstellen? auf welchen wert?

Das macht man mittels Poken der richtigen Werte in $D018. Eine $D018-Tabelle, der man entnehmen kann, was zu poken ist, findest Du auf Codebase:
http://codebase64.org/doku.php…vicii_memory_organizing&s[]=d018
Da gibt es auch Infos zu Bank-Switching, falls Du mal andere VIC-Bänke verwenden willst für Textscreens.

Zu $d016 steht da auch einiges auf Codebase erklärt (Frage 2).

Gold Beaver · 10. Mai 2011

zu 2.: das scheint mir ein Tippfehler zu sein, vermutlich war

lda #25
sta $d018

gemeint.

Endurion · 11. Mai 2011

Und du mußt die 2000 natürlich hex angeben, also

sta $2000

Lysosom · 11. Mai 2011

Zu 1)

Um das Charrom auslesbar zu machen. Aber sollte da nicht vorher besser der Interrupt gestoppt werden? Ausserdem vermisse ich am Ende des Programms das Wiedereinschalten des Kernals per LDA #$37 STA $01

e2020 · 11. Mai 2011

danke Lysosom, danke Endurion, danke Colt Seavers und danke TheRyk - ich habe eure berichtigungen & tipps be- und die links verfolgt und so sieht mein code mittlerweile aus:

Code

;1) EIGENES`ZEICHEN`erstellen
;
*= $4000 ; SYS 16384
;1.1 SPEICHER`SCHUETZEN ab $2000
; (basic pointer veraendern)
; Bottom of String Storage
lda $1a ; msb
sta $33 ; FRETOP
lda $00 ; lsb
sta $34 ; FRETOP
;Highest Address Used by BASIC
lda #$20 ; msb
sta $37 ; MEMSIZ
lda #$00 ; lsb
sta $38 ; MEMSIZ
;1.2 BANKSWITCHING (CHAR-ROM an)
lda #30 ; 2 kernal OUT
;+4 char ON
;+8 cassette line
;+16 cassette sw ON
sta $01 ; Bankswitching
;0/LORAM (0=Switch BASIC ROM Out)
;1/HIRAM (0=Switch Kernal ROM Out)
;2/CHAREN(0=Swith Char. ROM In)
;3 Cassette Data Output Line
;4 Cassette Switch: 1 = Switch Closed
;5 Cassette Motor: O = ON, 1 = OFF
;6-7 undefined
;1.2.1 INTERUPTS`AUS`(kopieren schutzn)`
lda #1 ;
sta $dc0e ; CIA Control Reg A
lda #1 ;
sta $01 ; R6510 IO register
;1.3 KOPIEREN`(aus ROM ins RAM)
ldx $00 ; zaehler
copy lda $d000,x ; aus CharROM
sta $2000,x ; ins RAM
lda $d100,x
sta $2100,x
lda $d200,x
sta $2200,x
lda $d300,x
sta $2300,x
lda $d400,x
sta $2400,x
lda $d500,x
sta $2500,x
lda $d600,x
sta $2600,x
lda $d700,x
sta $2700,x
txa ; copy X in Akku
sta $0400,x
dex ; runterzaehlen
bne copy
; BAENKE`UMSCHALTEN
lda #25
sta $d018 ; VIC
; c64 codebase/wiki/VIC banks
;bitmap
;$D018 = %xxxx1xxx -> bitmap is at $2000
;character memory
;$D018 = %xxxx100x ->charmem is at $2000
;screen memory
;$D018 = %0001xxxx ->screenmem is $0400
; CPU`MEM`MODULE
lda #$37 ; kernal AN
sta $01 ;
; interrupts wieder anschalten [frage 1]
lda #1 ; stimmt dieser wert?
sta $dc0e ; CIA Control Reg A
;1.4 ZEICHEN AENDERN
; (zeichensatz ist ab $2000)
; 1. ZEICHEN
lda $ff
sta $2000
lda $00
sta $2001
lda $ff
sta $2002
lda $00
sta $2003
lda $ff
sta $2004
lda $00
sta $2005
lda $ff
sta $2006
lda $00
sta $2007
; 2. ZEICHEN
lda $66
sta $2008
lda $66
sta $2009
lda $66
sta $2010
lda $66
sta $2011
lda $66
sta $2012
lda $66
sta $2013
lda $66
sta $2014
lda $66
sta $2015
; die neuen zeichen auf dem screen anzeigen (zum vergleich etwas weiter unter der ersten bereits bestehenden reihe)
lda #$00
sta $0600 ;1.zeichen
lda #$01
sta $0601 ;2.zeichen
rts

Alles anzeigen

[frage 1] habe befürchtung dass mein versuch die interrupts wieder anzuschalten so nicht richtig ist - kann das sein?

[frage 2] und wieso haben sich immer noch keine zeichen verändert?

danke für eure hilfe!
e2020

Gold Beaver · 11. Mai 2011

zu 1) wenn du die Interrupts nur mal für ne Weile abstellen willst, ist es oft einfacher das Befehlspaar SEI/CLI zuverwenden als an den I/O Registern rumzufummeln:

Code

SEI ;SEt Interrupt disable bit (CPU ignoriert IRQ-Eingang)
.... irgendwelche Aktionen, z.B. Charrom kopieren :)
CLI ; CLear Interrupt disable bit (CPU reagiert wieder auf IRQ-Eingang)

zu 2) Das hat mit dem Banking zu tun: Du hast den Bereich mit sämtlichen I/O-Chips vorher mit LDA #$irgendwas /STA $01 ausgeblendet, um an das darunter liegende Characterrom zu kommen. Das Register $d018 befindet sich aber im Grafikchip, und kann daher nicht beschrieben werden, solange der I/O-Bereich ausgeblendet ist, also bewirkt das nichts, wenn du nicht erst wieder mit z.B. LDA #$37/STA $01 den I/O-Bereich wieder einblendest.

Rapid Eraser · 11. Mai 2011

Der Wert #$30 für Adresse $01 dürfte übrigens auch nicht richtig sein. So aus dem Kopf - $31, $32 oder $33 müssten es tun.

e2020 · 11. Mai 2011

danke Colt Seavers, mit SEI und CLI hatte ich das gestern kurz versucht, aber ich dachte register-fummeln wäre irgendwie richtiger...

Zitat von Colt Seavers

LDA #$irgendwas /STA $01 ausgeblendet

du meinst zeile #19 - 23?
du hast bestimmt recht, aber ich kann dir gerade nicht folgen:
was hat das denn mit dem I/O bereich zu tun?

danke für deine hilfe!
e2020

Gold Beaver · 11. Mai 2011

Also, der 6510 kann ja nur 65536 verschiedene Adressen auf einen Rutsch ansteuern, braucht aber für 64K Ram, diverse Roms etc. deutlich mehr davon. Daher sind bestimmte Adressbereiche doppelt und z.T. auch dreifach belegt, siehe z.B. hier.

In Zeile 19 ff. schaltest du über $01 zwischen den Mehrfachbelegungen so um so um, dass die CPU im Bereich ab $d000 das Zeichen Rom "sehen" (und kopieren) kann, dafür kann sie dann den I/O Bereich nicht mehr sehen. Da liegt aber jenes ominöse $d018, mit dessen Hilfe du in Zeile 63/64 den Grafikchip so einstellen willst, dass er den Zeichensatz bei $2000 ff. benutzt.

Wenn du den Code aus Zeile 63/64 ganz an den Anfang oder ans Ende des Programms verschiebst, wo $01 wieder/noch so eingstellt ist, dass die CPU ab $d000 die Register des Grafikchips sehen kann, sollte es funktionieren.

Und Rapid Eraser hat übrigens auch Recht.

Ingo · 12. Mai 2011

Zum Thema Speicherzelle $01 hab ich mal die Konfigurationen angehängt.

Fratzengeballer · 12. Mai 2011

Zitat

lda $ff
sta $2000
lda $00
sta $2001
lda $ff
sta $2002
lda $00

Alles anzeigen

Du liesst hier die Zeropageadressen aus und speicherst deren Werte in deinen Charset. Je nachdem welche Werte in den Adressen stehen, ändert sich das Muster deines Charsets.

ich schätze mal, du wolltest den Wert #$ff nach $2000 speichern und nicht den Wert aus der Speicherstelle $ff, gleiches gilt dann auch für die anderen Werte dort, also überall noch ein # davor

spider-j · 12. Mai 2011

Nur mal so als Tipp zwischendurch:
1.) mit ACME kannst Du auch ganz "bequem" Binärzahlen nutzen (gerade bei Chars ungeheuer praktisch), also sowas wie:

Code

lda #% 01010101

Und 2.) auch wenn man Copy&Paste hat, ist diese ewige Laderei der gleichen Werte in den Akku ziemliche Speicherverschwendung; z.B. lässt sich einiges kürzen durch:

Code

; 1. ZEICHEN
lda #$ff
sta $2000
sta $2002
sta $2004
sta $2006
lda #$00
sta $2001
sta $2003
sta $2005
sta $2007

Alles anzeigen

e2020 · 18. Mai 2011

Code

;1) EIGENES`ZEICHEN`erstellen
;
*= $4000 ; SYS 16384
;1.2 INTERRUPT`*AUS* VOR`$0001 EDIT
sei ; SEt Interrupt flag
;1.3 BANKSWITCHING (CHAR-ROM an, etc)
lda #50 ;=$31 (errechnet:
;128 undef :aus
;64 undef :aus
;32 cassette:AN
;16 cassette:AN
;8 cassette:aus
;4 4=io/0=chars :CHAR
;2 2=kernal/0=ram:KERNL
;1 1=basic/0=ram :RAM
sta $01 ;R6510 register
;1.4 KOPIEREN`(aus ROM ins RAM)
ldx $00 ; zaehler
copy lda $d000,x ; aus CharROM
sta $2000,x ; ins RAM
lda $d100,x
sta $2100,x
lda $d200,x
sta $2200,x
lda $d300,x
sta $2300,x
lda $d400,x
sta $2400,x
lda $d500,x
sta $2500,x
lda $d600,x
sta $2600,x
lda $d700,x
sta $2700,x
txa ; copy X in Akku
sta $0400,x ; [auf dem screen anzeigen]
dex ; runterzaehlen
bne copy
; BANKSWITCHING (IO wieder an)
; (= VIC + SID`erreichbar)
lda #54 ; IO:AN / char:aus
; KERNAL:AN
sta $01 ; bankswitching
; VIC: banks umschalten
; = um zeichensatz aus ram
; von $2000 nutzen zu k:nnen
; und nicht mehr aus char/rom
lda #21 ; war #25
sta $d018 ; VIC
; c64 codebase/wiki/VIC banks
; clear interrupt flag
; interrupts wieder an
cli ; interrupt an
;1.5 ZEICHEN AENDERN
; (zeichensatz ist ab $2000)
; 1. ZEICHEN
lda #$ff
sta $2000
lda #$00
sta $2001
lda #$ff
sta $2002
lda #$00
sta $2003
lda #$ff
sta $2004
lda #$00
sta $2005
lda #$ff
sta $2006
.da #$00
sta $2007
; 2. ZEICHEN
lda #$66
sta $2008
sta $2009
sta $2010
sta $2011
sta $2012
sta $2013
sta $2014
sta $2015
; AUF`SCREEN`ZEIGEN
lda #$00
sta $0600 ;1.zeichen
lda #$01
sta $0601 ;2.zeichen
rts

Alles anzeigen

so, danke! colt seavers, ingo, rapid eraser, fratzengeballer & spider-j - ich habe eure hilfe & tipps so gut wie ich weiss umgesetzt (siehe oben) - aber es geht immer noch nicht...
es wird zwar etwas nach $2000 kopiert (ist wohl der zeichensatz), aber auf dem screen erscheinen auch zeichen, aber in einen unbekannten/defekten zeichensatz - anscheinend nimmt der vic irgendeinen, aber *nicht* den zeichensatz von $2000 ...

Roland · 18. Mai 2011

zeile 9: #50 ist nicht $31 sondern $32. aber #50 (also $32) passt schon wenn du zunächst das original char rom nach 2000 kopieren willst

zeile: 45: das solltest du nicht #54 nehmen ($36) sondern #55 ($37), denn sonst ist das basic-rom am ende nicht mehr eingeschaltet,
und dein code stürzt ab wenn er ins basic zurückkehren will.

zeile 54: wenn du den char auf $2000 aktivieren willst must du #24 ($18 ) nehmen (oder #25 bzw. $19. aber das 1er bit spielt keine rolle).

und ab zeile 87: das müsste wohl eher $200a, $200b, 200c.... sein

The Joker · 18. Mai 2011

und in Zeile 21 wurde das # Zeichen vergessen --> ldx #$00

enthusi · 18. Mai 2011

ldx $00 ; zaehler

das soll sicher auch ldx #$00
oder ldx #0 heissen.

Schau Dir evtl. genau nochmal an, wann #, $, #$ benutzt wird.
Bei der Gelegenheit auch % denn dann kannst Du bits wie ueber $01 sehr viel direkter Schalten statt dezimal die Zweierpotenzen zu addieren.

e2020 · 18. Mai 2011

danke! enthusi, the joker & roland, ihr seid wirklich eine grosse hilfe:

Zitat von Roland

zeile: 45: das solltest du nicht #54 nehmen ($36) sondern #55 ($37), denn sonst ist das basic-rom am ende nicht mehr eingeschaltet,
und dein code stürzt ab wenn er ins basic zurückkehren will.

meinst su damit den "syntax error" den ich manchmal hier noch bekomme?
passiert nach ablauf des programmes, könnte glatt der rts ins basic sein...

Zitat

zeile 54: wenn du den char auf $2000 aktivieren willst must du #24 ($18 ) nehmen (oder #25 bzw. $19. aber das 1er bit spielt keine rolle).

das hatte ich mittlerweile auch (durch herumprobieren) herausbekommen ...
wie hätte man sich das richtig errechnen können, wenn der char auf $3000 oder $4000 gewesen wäre?

Zitat

und ab zeile 87: das müsste wohl eher $200a, $200b, 200c.... sein

ja, danke! du bist echt der held meines tages denn du hast mir gerade die antwort auf die frage gegeben die ich jetzt hier stellen wollte ich hatte nämlich pixel fehler im bild (siehe anhang)- und die kamen natürlich weil ich im eifer des gefechts das hexadezimale zählen mit ABCDEF übersehen hatte ...

wow, das war mein 1. assembler programm - danke nochmal allen die geholfen haben!

The Joker · 19. Mai 2011

Zitat von e2020

wie hätte man sich das richtig errechnen können, wenn der char auf $3000 oder $4000 gewesen wäre?

wie bereits weiter oben von anderen angemerkt, ist hier eine bitweise Schreibweise sinnvoll, da man das Bitmuster einfach zusammensetzen kann.

Code

; Bildschirmspeicher Startadresse in aktueller VIC-Bank
; $0000 ----> $D018 = #%0000xxxx
; $0400 ----> $D018 = #%0001xxxx
; $0800 ----> $D018 = #%0010xxxx
; $0c00 ----> $D018 = #%0011xxxx
; $1000 ----> $D018 = #%0100xxxx
; $1400 ----> $D018 = #%0101xxxx
; $1800 ----> $D018 = #%0110xxxx
; $1c00 ----> $D018 = #%0111xxxx
; $2000 ----> $D018 = #%1000xxxx
; $2400 ----> $D018 = #%1001xxxx
; $2800 ----> $D018 = #%1010xxxx
; $2c00 ----> $D018 = #%1011xxxx
; $3000 ----> $D018 = #%1100xxxx
; $3400 ----> $D018 = #%1101xxxx
; $3800 ----> $D018 = #%1110xxxx
; $3c00 ----> $D018 = #%1111xxxx
; Zeichensatz Startadresse in aktueller VIC-Bank
; $0000 ----> $D018 = #%xxxx000x
; $0800 ----> $D018 = #%xxxx001x
; $1000 ----> $D018 = #%xxxx010x
; $1800 ----> $D018 = #%xxxx011x
; $2000 ----> $D018 = #%xxxx100x
; $2800 ----> $D018 = #%xxxx101x
; $3000 ----> $D018 = #%xxxx110x
; $3800 ----> $D018 = #%xxxx111x

Alles anzeigen

Code

; Beispiel1: Bildschirmspeicher $0400, Zeichensatz $2000
lda #%00011000
sta $D018

Code

; Beispiel2: Bildschirmspeicher $0400, Zeichensatz $3000
lda #%00011100
sta $D018

Code

; Beispiel3: Bildschirmspeicher $4800 ($4000+$0800), Zeichensatz $4000 ($4000+$0000)
lda #%00100000
sta $D018
; Hier muss zusätzlich die Startadresse der VIC-Bank von $0000 auf $4000 umschaltet werden.
lda $DD00
and #%11111100 ; Bit 0 und 1 löschen, Bit2-7 unverändert lassen
ora #%00000010 ; Bit 1 setzen, restliche Bits unverändert lassen
sta $DD00 ; VIC-Bank $4000-$7FFF
; VIC-Bank einstellen
; VIC-Bank $C000-$FFFF ----> $DD00 = %xxxxxx00
; VIC-Bank $8000-$BFFF ----> $DD00 = %xxxxxx01
; VIC-Bank $4000-$7FFF ----> $DD00 = %xxxxxx10
; VIC-Bank $0000-$3FFF ----> $DD00 = %xxxxxx11

Alles anzeigen

Vernunftmensch · 14. September 2012

Code

i=0;
__asm__ ("sei");
__asm__ ("lda $01");
__asm__ ("sta %v",zw_wert);
__asm__ ("lda #$30");
__asm__ ("sta $01");
while (i<8)
{
MouseSprite [i*3]=*((char*) 0xd000+7*8+i);
i++;
};
__asm__ ("lda %v",zw_wert);
__asm__ ("sta $01");
__asm__ ("cli");

Alles anzeigen

Statt oben rechts im Sprite das Zeichen 8 zu sehen, nur Müll.
Aber wo ist der Fehler?