Hallo Besucher, der Thread wurde 4,5k mal aufgerufen und enthält 28 Antworten

letzter Beitrag von hoogo am

zahlen über 256 in asm

    hallo, ich muss jetz 1024 byte in den speicher bringen, kann aber nur bis 255 mit dem register zählen. welche möglichkeit gibt es? wie kann man die zahl die hinter 0400 und dem daten0400 addiert wird mit inc hochzählen und wieder als addition setzen. oder was muss ich jetz machen?
    mfg



    ldx #$00
    loop lda daten0400,x
    sta $0400,x
    inx
    bne loop

    ldx #$00
    loop1 lda daten0400+256,x
    sta $0400+256,x
    inx
    bne loop1

    ldx #$00
    loop2 lda daten0400+512,x
    sta $0400+512,x
    inx
    bne loop2

    ldx #$00
    loop3 lda daten0400+768,x
    sta $0400+768,x
    inx
    bne loop3


    ....
    ......
    daten0400:
    !bin "video0400.prg",,2

    Handhabe das Hibyte der 16-Bit-Adresse jetzt nicht länger als Konstante (0x04) sondern auch als Variable oder im y-Register.
    Dann setzt um deine Schleife eine zweite, äußere Schleife, die nach dem Kopieren von 256 Byte das y-Register um 1 erhöht, diesen Wert mit 8 vergleicht und solange er noch kleiner ist wieder einen neuen Kopierzyklus der inneren Schleife startet mit der Startadresse YReg*256.
    vielleicht so:
    QuelladresseHi = ;hier lege zwei Speicherzellen für das Merken der Startadresse der Quelle fest
    QuelladresseLo =
    ZieladresseHi = ;hier lege zwei Speicherzellen für das Merken der Startadresse des Zieles fest
    ZielladresseLo =


    lda "Hibyte der Startadresse deines Quellbereiches -1)"
    sta QuelladresseHi
    lda =x00
    sta QuelladresseLo
    sta ZielladresseLo


    ldy 0x04
    lda =x00


    loop1
    sty ZieladresseHi
    clc
    lda QuelladresseHi
    adc #01
    sta QuelladresseHi
    ldx #$00
    loop2 lda (Quelladresse,x)
    sta (Zieladresse,x)
    inx
    bne loop2
    iny
    cpy #0x08
    bne loop1

    hallo pura hier ist meine umsetzung :


    !to "basicstart.prg",cbm


    *= $0800
    !byte $00,$0c,$08,$d6,$07,$9e,$32,$30,$36,$34,$00,$00,$00,$00
    * =$0810


    quellhi =$f7
    quelllo =$f8
    zielhi = $f9
    ziello = $fa


    lda #<daten
    sta quellhi

    lda #$00
    sta quelllo
    sta ziello

    ldy $04
    lda #$00

    loop1
    sty zielhi
    clc
    lda quellhi
    adc #$01
    sta quellhi
    ldx #$00
    loop2
    lda (quelllo,x)
    sta (ziello,x)
    inx
    bne loop2
    iny
    cpy #$08
    bne loop1


    rts


    daten:
    !bin "testdaten"



    da meckert der compiler : sta (Zieladresse,x) , er nimmt hier nur daten aus der zeropage, ist "Zieladresse" richtig?
    ich habe lo genommen und hi , die buchstaben kommen trotzdem nicht in den screen..
    kannst du es noch mal durchschauen?


    in den testdaten befinden sich 1024 "A" als test.


    mfg

    ACHTUNG!!!!
    GEFÄHRLICH!!!!


    mit den zeropage indirekt indiziert geht so mit zähler NUR mit ,Y und ausserhalb der klammer.
    wenn du das mit ,X innerhalb der klammer machst, dann wird der X wert zu der zeropageaddresse addiert, und nicht zu dem inhalt der zeropage addressen.


    LDX #10
    LDA ($3B,X)


    liesst dann den inhalt der speicherstellen die in $4B, $4C sind, und nicht
    inhalt von $3B,$3C + #10....


    drum....


    y als laufregister (#00 - #FF)....


    also


    LDA ($3B),Y ... oder eben LDA ($F7),Y

    roland, kannst du das programm von mir mal umstellen welches ich schon halbwegs auf phura-ebene gebracht habe, das die daten in den screen ab 0400 eingetragen werden? ich steige jetzt mit den x und y register nicht mehr durch.


    mfg

    ich könnte es ja auch über das disklaufwerk laden , ich müsste jetz nur wissen wo der programname für diese routine : " jsr FRMEVL" hingepackt werden muss, den rest hole ich mir aus diesem diskbeispiel.


    ; Diese Programm ladet ein weiteres Programm an die gewünschte Adresse
    ; Programmstart mit SYS 49152 "NAME",Startadresse
    ; z.B: SYS 49152 "NAME",8192 (Programm NAME ab Adresse $2000 laden)


    *=$c000 ; Startadresse des Programmes


    CHKKOM = $AEFD
    FRMEVL = $e257
    FRMNUM = $AD8A
    GETADR = $b7f7


    start jsr FRMEVL ; Dateinamen holen und setzen

    ldx #$08 ; Gerätenummer
    stx $ba

    jsr CHKKOM ; auf "," prüfen


    jsr FRMNUM ; Ausdruck holen und auf numerisch prüfen
    jsr GETADR
    sty $c3 ; Startadresse in $c3/$c4 speichern
    sta $c4

    ldy #$00
    sty $b9 ; Sekundäradresse = 0
    lda #$00
    jmp $f4a5 ; Load-Routine



    :baby2: es macht immer wieder spass mit dem asm, obwohl man dabei viel auf die nase fällt, es ist faszinierend , wenn das progamm wächst.

    Vorweg: ich kenne mich mit den notationen in diesen assemblerprogrammen nicht so aus...wird aber wohl irgendwie klappen :)


    WICHTIG ist, dass bei den zeropageaddressen ZUERST das LOWBYTE und DANN das HIGHBYTE kommt. Darum low auf $f7 (und f9) und high auf f8 (und fa)




    !to "basicstart.prg",cbm


    *= $0800
    !byte $00,$0c,$08,$d6,$07,$9e,$32,$30,$36,$34,$00,$00,$00,$00
    * =$0810


    quelllo =$f7
    quellhi =$f8
    ziello = $f9
    zielhi = $fa


    lda #<daten // kommt so das highbyte von den daten zustande?
    sta quellhi


    lda #>daten // kann man nicht dann auch das lowbyte von der datenadress irgendwie so einbinden???
    sta quelllo


    lda #$00
    sta ziello


    ldx #$04
    ldy #$00


    loop1
    stx zielhi


    loop2
    lda (quelllo),y
    sta (ziello),y
    iny
    bne loop2


    inc quellhi


    inx
    cpx #$08
    bne loop1


    rts




    ...so, das sollte doch tun... ;)

    hallo, es funktioniert, vielen dank. das ist lo " lda #<daten". habe es umgedreht.


    das mit dem x und y ist für mich garnicht so einfach, man kann es leicht verwechseln mit den funktionsaufgaben.


    werde weiter üben, jetzt ist das disklaufwerk dran mit asm, weil ich doch nicht soviele daten in den 64 reinpacken kann, also häppchenweise laden.


    dann kommt die reu dran mit proggen.


    natürlich progge ich nur mit dem vice hier. originalen c64 habe ich nicht mehr.


    vielen dank.


    vielleicht habe ich bald das nächste problem mit asm, aber es macht spass.


    mfg

    jetzt ist ein teil fertig:
    mit ganged erzeuge ich ein multibild und speichere das bild ab ,adresse $2000 mit 8000byte, dann den farbram adresse $d800 und den farbram $0400 mit je 1024 byte. diese 3 dateien lade ich mit der unteren routine ein.
    dank eurer hilfe bin ich sehr weit gekommen.


    nun kommen die sprites dran, die dann über ein schönes hintergundbild hin und her wandern....usw....



    !to "multibild.prg",cbm
    * =$c000 ;startadresse


    screenmem = $fb
    blockbasic = $04
    getin = $ffe4


    datenlo =$f7
    datenhi =$f8
    speicherlo =$f9
    speicherhi =$fa


    start


    jsr scrloesche

    ;waehlt den speicher ab $2000 als bitmap
    lda $d018
    ora #%00001000
    sta $d018


    ; schaltet den grafikmodus ein (hi-res, also 320*200*2)
    lda $d011
    ora #%00100000
    sta $d011

    ;schaltet auf Multicolor (160*200*16)
    lda $d016
    ora #%00010000
    sta $d016

    lda #>bild
    sta datenhi
    lda #<bild
    sta datenlo

    lda bildlo
    sta speicherlo
    lda bildhi
    sta speicherhi

    jsr diskette

    lda #>video
    sta datenhi
    lda #<video
    sta datenlo

    lda videolo
    sta speicherlo
    lda videohi
    sta speicherhi

    jsr diskette

    lda #>multi
    sta datenhi
    lda #<multi
    sta datenlo

    lda multilo
    sta speicherlo
    lda multihi
    sta speicherhi

    jsr diskette

    beenden
    jsr getin
    beq beenden

    lda $d011 ; hires-modus aus
    and #%11011111
    sta $d011

    lda $d016 ;Multicolor (160*200*16) aus
    and #%11101111
    sta $d016

    lda $d018 ;speicher ab $2000 als bitmap aus
    and #%11110111
    sta $d018

    jsr scrloesche

    rts

    ;ende

    diskette
    LDA #$00
    JSR $FF90 ; enable/disable KERNAL messages
    LDA fnnumb
    LDX drive
    LDY fn_sec
    JSR $FFBA ; Kernal : Set Logical File Parameters
    LDA fnchars
    LDX datenlo
    LDY datenhi
    JSR $FFBD ; Kernal : Set Filename
    LDA #$00 ; 0 = load
    LDX speicherlo
    LDY speicherhi
    JSR $FFD5 ; Load (to address)
    rts

    scrloesche
    lda #$00
    sta screenmem
    lda #$04
    sta screenmem+1
    ldx #blockbasic
    ldy #$00
    lda #32
    schleife
    sta (screenmem), y
    iny
    bne schleife
    inc screenmem+1
    dex
    bne schleife
    rts

    drive !byte $0a
    fnchars !byte $08
    fnnumb !byte $0F
    fn_sec !byte $00


    bild !tx "bild.prg"
    bildlo !byte $00
    bildhi !byte $20


    video !tx "vide.prg"
    videolo !byte $00
    videohi !byte $04


    multi !tx "colo.prg"
    multilo !byte $00
    multihi !byte $d8

    Hallo!


    Nochmal zu der Move-Routine. Du hast sicher viel gelernt mit der ZP-(indirekt),Y-Adressierung und ZP-(indirekt,X)-Adressierung (ja, das muss man sich ganz langsam reinziehen), aber mir hat Dein erster, eigener, Ansatz viel besser gefallen. Das indirekt Gedingse ist ganz toll, aber auch ganz toll langsam (da die Adressenbytes ja auch noch aus dem RAM gelesen werden müssen).


    Wenn Du Deinenen ersten Ansatz etwas weiterdenkst, kommst Du auf das hier (einfacher, kürzer, und schneller als die Lösung mit cpx#8):


    ldx #$00
    loop lda daten0400,x
    sta $0400,x
    lda daten0400+256,x
    sta $0400+256,x
    lda daten0400+512,x
    sta $0400+512,x
    lda daten0400+768,x
    sta $0400+768,x
    inx
    bne loop


    Tadaaa! Think Simple!


    Gruß WTE

    hallo deine idee ist gegenüber meinem code die schnellere.
    ich habe auch schon daran gedacht, das man bei 1024 byte diese adressenschaufelei usw nicht braucht. man muss halt immer ein komprormiss schliessen, speicherbedarf und v0.


    was mir noch zu schaffen macht, ist das bitsetzen um den bitmapbereich zu setzen/verlagern und den charbereich verlegen und umzukopieren.


    dafür bräuchte ich noch einmal eine intensive erklärung.


    danke


    mfg

    das ist jetzt keine Antwort die Du hoeren willst, aber das lohnt es sich wirklich sich selbst anzulesen und dann vor allem viel zu probieren!
    Gibt viel zu viele die ein 'setting' per copy&paste uebernehmen und dann ganz wilde dinger damit verbrechen :)
    SO wild ist es nicht, aber man muss es eben einmal verstehen.

    ich habe zwar schon bücher über den c64 hier gefunden, rom-beschreibungen usw, aber es ist wie im wirklichen leben, du findest keine klare beschreibung darüber, alle schreiben drum herum mit 2 bis 3 sätzen , aber des pudels kern wird nie getroffen. wenn du mir mal eine beschreibung empfehlen könntest die man irgendwo hier runterladen kann, ich habe nichts gefunden, was nachvollziehbar war mit experiementen über dieses thema.


    mfg