Tutorial de ensamblador de C64

[Silicebit]

Si no os importa leer en inglés, tengo un par de libros en PDF sobre ensamblador del 6509 que me han ayudado muchísimo. En un par de días fui capaz de pintar un mapeado de tiles en un VIC-20, ahí es nada

¿Qué libros son esos na_th_an? Por cierto, serán del 6502, no del 6509, imagino.  

Puede ser que te confundas con el 6809 de Motorola, otro gran y olvidado microprocesador de 8 bits, mejor aún que el 6502 y el Z80 juntos.  

¡¡Pues yo estaba equivocado!! Sí existe el 6509.

El MOS 6509 es una versión mejorada del 6502 capaz de direccionar hasta 1MB de memoria mediante conmutación de bancos, como haría cualquier otro 8 bits. Sólo que mientras el 6502 o el Z80 necesitan un chip externo para realizar la conmutación de bancos, el MOS 6509 trae la circuitería necesaria para esa conmutación ya incluida dentro.

El MOS 6509 se usó en los Commodore CBM-II.

[na_th_an]

Si no os importa leer en inglés, tengo un par de libros en PDF sobre ensamblador del 6509 que me han ayudado muchísimo. En un par de días fui capaz de pintar un mapeado de tiles en un VIC-20, ahí es nada

¿Qué libros son esos na_th_an? Por cierto, serán del 6502, no del 6509, imagino.  

Puede ser que te confundas con el 6809 de Motorola, otro gran y olvidado microprocesador de 8 bits, mejor aún que el 6502 y el Z80 juntos.  

Oops, un lápsus de números y memoria :lol: El 2, el 2.

Me ayudó, principalmente, "6502 Machine Language for Beginners", que tenéis online en http://www.6502dude.com/6502/mlb/chapter1.htm . Está todo muy bien explicado.

Luego, el programmer reference guide del VIC-20, que tiene mil y una tablas para que no se te pierda nada. Es específico de este ordenador, pero bueno, yo estaba enredando en este ordenador Buscad VIC20PrgRefGuide.txt en Google.

Todas mis pruebas las hice usando el linker y el ensamblador del compilador CC65, que es bastante cómodo para estos manejes (te permite compilar para VIC20 con 8K o 16K de memoria expandida y colocar todo en su sitio: el startup code va el la RAM "normal" y hay una llamada al segmento de memoria expandida donde va todo tu programa. Además, te permite definir un segmento con el juego de caracteres expandido que se coloca en su área correcta de RAM automáticamente. Al final te genera un PRG listo para ejecutar.

Si os interesa el VIC-20 y queréis que os pase todo el "startup code" (que adapté de los fuentes de un juego indie de hace un par de años) no tenéis más que dar un grito

En cuanto le pillas el truco a la página cero es genial, es como tener 256 registros por la patilla

[code]CLEARSCREEN:
        LDX #$00
        LDY #$14
        STX $FB
        STY $FC         ; FC:FB -> $1400 (character memory)
        LDX #$00
        LDY #$94
        STX $FD
        STY $FE         ; FE:FD -> $9400 (color memory)
        ; 512 vueltas
        LDX #$02
        LDY #$00
@fill:  LDA #$0F
        STA ($FD),Y     ; (FE:FD + Y) <- A
        LDA #$7F
        STA ($FB),Y     ; (FC:FB + Y) <- A
        INY             ; Y ++
        BNE @fill       ; Y != 0 THEN @fill
        INC $FC         ; (FC)++
        INC $FE         ; (FE)++
        DEX             ; X --
        BNE @fill       ; X != 0 THEN @fill
        RTS[/quote]

[josepzin]

En cuanto le pillas el truco a la página cero es genial, es como tener 256 registros por la patilla

¿Cómo es eso??

[na_th_an]

La página cero son los primeros 256 bytes de RAM. El acceso a esta página por parte de la CPU es "especial" y se realiza muy rápidamente (más rápido que un acceso a otra parte de la memoria - según tengo entendido). Es ideal para usar como "buffer de intercambio" para almacenar datos temporales y tal, ya que la CPU tiene muy pocos registros propios.

La principal utilidad es que hay modos de direccionamientos de la CPU que emplean directamente la "zero page", como puedes ver en el pochocódigo que he puesto más arriba. Las operaciones LD o ST que se refieran a (nn),X o (nn),Y están apuntando a la dirección de memoria obtenida de consultar el valor almacenado en (nn+1)*256+nn y sumarle X o Y. Esto te permite almacenar punteros en la zero page y usarlos directamente para escribir o leer de memoria en bucle.

Por ejemplo, si quieres copiar 100 bytes desde $2000 a $3000, por ejemplo, haríamos así:

[code]
        ; Almacenamos en FC:FB el origen $2000
       
        LDX #$00
        LDY #$20
        STX $FB
        STY $FC         ; FC:FB -> $2000
       
        ; Almacenamos en FE:FD el destino $3000
       
        LDX #$00
        LDY #$30
        STX $FD
        STY $FE         ; FE:FD -> $3000
       
        ; Ahora vamos a copiar 100 bytes...
       
        LDX #$64        ; 100 en hexadecimal

        ; Y esta es la chicha:
       
@b1:    LDA ($FB),X     ; Nos traemos a A lo que esté en ($FB)+256*($FC)+X, o sea, $2000+X
        STA ($FD),X     ; Escribimos A en ($FD)+256*($FE)+X, o sea, $3000+X
        DEX             ; X = X - 1
        BNE @b1         ; IF X <> 0 THEN @b1[/quote]

Lo que viene MUY bien.

Al principio se hace uno un lío con los direccionamientos, pero una vez que le coges el truco te das cuenta de que todo es muy sencillo y está muy bien diseñado. Un 10 para el 6502.

Sólo hay que tener en cuenta que el C64 usa muchas de las direcciones de la página cero para sus cosas, así que si quieres hacer juegos que funcionen bien con las rutinas del Kernel o como se llame tienes que respetarlo. Si, por el contrario, vas a tomar total control sobre la máquina, puedes pasar de ellos.