zahlen über 256 in asm


  • super_castle
  • 1952 Aufrufe 28 Antworten

Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

  • 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
    *** Von ihrem Wesen her hat Wahrheit nichts mit einer demokratischen Prozedur zu tun. ***
    Prof. Julius Gabriel

    Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von Phura ()

  • RE: zahlen über 256 in asm

    Du mußt das verschachteln

    zb.

    lda #04
    sta zp+1
    lda #04
    sta zp2+1
    ldy #$00
    sty zp
    sty zp2
    loop lda daten(zp),y
    sta (zp2),y
    iny
    bne loop
    dec zp+1
    dec zp2+1
    bne loop
    Wem es beim Bit zählen schwindelig wird, der hat zuviel davon.

    Alt werden ist schön, das Altern nicht.
  • gikauf, dein aufbau verstehe ich nicht, kannst du den mal genau erklären, damit ich ihn probieren kann?

    Dieser Beitrag wurde bereits 4 mal editiert, zuletzt von super_castle ()

  • 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

    Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von super_castle ()

  • 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

    Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von super_castle ()

  • 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.

    Dieser Beitrag wurde bereits 4 mal editiert, zuletzt von super_castle ()

  • 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... ;)

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von Roland ()

  • 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

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von super_castle ()

  • zp = zb. f7
    zp+1 = dann f8
    zp2 = f9
    zp2+1 = dann fa

    lda (zp),y = lade von f7 lo adresse f8 hi adresse und addire den Wert von y zu der Adresse.
    Wenn du das Prinziep verstanden hast sollte der Rest kein Problem sein.
    Wem es beim Bit zählen schwindelig wird, der hat zuviel davon.

    Alt werden ist schön, das Altern nicht.
  • 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

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von super_castle ()

  • 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

    Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von super_castle ()