> Página 2

> Página 1 - Página 2 - Página 3 - Página 4 - Página 5 - Página 6

> | 6a - 6b - 7a - 7b - 7c - 7d - 8 - 9a - 9b - 9c - 9d - 9e - 10 | translate this page

> Página Cero | Basic ROM | Kernal ROM
> VIC II | SID | CIA

> A = Acumulador | X = Registro X | Y = Registro Y

> Nº 6a.- Cambiar colores en una línea de la pantalla
> Por Wanja Gayk en GO64! Magazine

> * = $1000 |  | ; SYS 4096.
> | LDX #$00 | ; Carga X con #$00, que será utilizado como código de color y como valor inicial de un bucle.
> | STX $D020 | ; Guarda el valor #$00 en la dirección $D020, que corresponde al borde de la pantalla.
> | STX $D021 | ; Guarda el valor #$00 en la dirección $D021, que corresponde al fondo de la pantalla.
> DATS | LDA CLRS,X | ; Carga A con el valor de la posición CLRS y siguientes #40.
> | STA $D800,X | ; Guarda los valores de A en la dirección $D800 y siguientes #40 posiciones, que corresponde a los primeros #40 caracteres del mapa de colores de la pantalla.
> | INX | ; Incrementa el valor de X.
> | CPX #$28 | ; Compara el valor de X con #$28, que es el final de la línea.
> | BNE DATS | ; Salta a DATS hasta que el valor de X=#$28.
> | RTS | ; Retorna al BASIC.
> CLRS | .BYTE $06,$04,$0E,$0A,$03,$0F,$0D,$07 | ; Colores.
> | .BYTE $01,$01,$07,$0D,$0F,$03,$0A,$0E |
> | .BYTE $04,$06,$0B,$0C,$0F,$01,$0F,$0C |
> | .BYTE $0B,$09,$02,$08,$0A,$0F,$07,$01 |
> | .BYTE $01,$0D,$03.$05,$0C,$0B,$0C,$0F |

> Para entender más: Código de colores, escribir un texto cualquiera en la primera línea de la pantalla y pulsar SHIFT + RETURN, luego, más abajo, hacer el SYS 4096.
> Para aprender más: Cambia los colores. Realiza este mismo programa en otras líneas de la pantalla (recuerda que cada línea tiene #40 caracteres).

> Una segunda aplicación del anterior programa consiste en:

> Nº 6b.- Cambiar colores en una línea de Pantalla con efecto
> Por Wanja Gayk en GO64! Magazine

> * = $1000 |  | ; SYS 4096.
> PRG | JSR COM | ; Salta a la subrutina COM, que cambia los colores de las letras de la primera fila de la pantalla.
> | JSR EFECT | ; Salta a la subrutina EFECT, que cambia el color rodándose de derecha a izquierda.
> | JMP PRG | ; Salta a PRG, lo que realiza un bucle cerrado.
> COM | LDX #$00 | ; Carga X con #$00, que será utilizado como código de color y como valor inicial de un bucle.
> | STX $D020 | ; Guarda el valor #$00 en la dirección $D020, que corresponde al borde de la pantalla.
> | STX $D021 | ; Guarda el valor #$00 en la dirección $D021, que corresponde al fondo de la pantalla.
> DATS | LDA CLRS,X | ; Carga A con el valor de la posición CLRS y siguientes #40.
> | STA $D800,X | ; Guarda los valores de A en la dirección $D800 y siguientes #40 posiciones, que corresponde a los primeros #40 caracteres del mapa de colores de la pantalla.
> | INX | ; Incrementa el valor de X.
> | CPX #$28 | ; Compara el valor de X con #$28, que es el final de la línea.
> | BNE DATS | ; Salta a DATS hasta que el valor de X=#$28.
> | RTS | ; Retorno de subrutina.
> CLRS | .BYTE $06,$04,$0E,$0A,$03,$0F,$0D,$07 | ; Colores
> | .BYTE $01,$01,$07,$0D,$0F,$03,$0A,$0E |
> | .BYTE $04,$06,$0B,$0C,$0F,$01,$0F,$0C |
> | .BYTE $0B,$09,$02,$08,$0A,$0F,$07,$01 |
> | .BYTE $01,$0D,$03,$05,$0C,$0B,$0C,$0F |
> EFECT | LDA CLRS | ; Carga A con el valor de la posición CLRS.
> | PHA | ; Guarda en la pila el contenido de A.
> | LDX #$00 | ; Carga X con #$00, que es el valor inicial de un bucle.
> CAMB | LDA CLRS+1,X | ; Carga A con el valor de la posición CLRS+1 y siguientes.
> | STA CLRS,X | ; Guarda el código de dicho valor en la posición CLRS y siguientes. Esto va cambiando los colores de derecha a izquierda.
> | INX | ; Incrementa el valor de X.
> | CPX #$27 | ; Compara el valor de X con #$27, que es el final de la línea.
> | BNE CAMB | ; Salta a CAMB hasta que el valor de X=#$27.
> | PLA | ; Extrae el valor guardado antes en la pila y lo vuelve a dejar en A. Recordemos que este valor era el que correspondía a CLRS.
> | STA CLRS + 39 | ; Guarda el código de dicho valor en MAS-1, es decir, al final de la lista de colores.
> | RTS | ; Retorno de subrutina.

> Para entender más: Código de colores, escribir un texto cualquiera en la primera línea de la pantalla y pulsar SHIFT + RETURN, luego, más abajo, hacer el SYS 4096.
> Para aprender más: Cambia los colores. Realiza este mismo programa en otras líneas de la pantalla (recuerda que cada línea tiene #40 caracteres).

> Nº 7a.- Pulsar teclas de función
> Po r fermhg y _PaCo_, canal #c64 del irc-hispano

> * = $1000 |  | ; SYS 4096.
> TECLA | JSR $FFE4 | ; Salta a la subrutina en ROM $FFE4, que carga A con el valor de una tecla al ser pulsada.
> | BEQ TECLA | ; Si es igual a #$00, es decir, si aún no se ha pulsado ninguna tecla, salta a TECLA.
> | LDX #$00 | ; Carga X con #$00, que es el valor inicial de un bucle.
> BUCLE | CMP COMPI,X | ; Compara el valor de la tecla pulsada con el valor situado en la posición COMPI y siguientes.
> | BEQ COLOR | ; Si coincide con alguna de las teclas de función, salta a COLOR.
> | INX | ; Incrementa el valor de X.
> | CPX #$08 | ; Compara el valor de X con #$08, que lee el dato referido a F8, última de las teclas de función.
> | BNE BUCLE | ; Salta a BUCLE hasta que X sea igual a alguno de los códigos de las teclas de función.
> | JMP TECLA | ; Salta a TECLA, al detectar que la tecla pulsada no corresponde a las teclas de función. ; Si la tecla pulsada es una de las teclas de función entonces, la pantalla tomará el color equivalente al valor de X.
> COLOR | STX $D020 | ; Guarda el valor de X en la posición $D020, que corresponde al borde de la pantalla.
> | STX $D021 | ; Guarda el valor de X en la posición $D021, que corresponde al fondo de la pantalla.
> | JMP TECLA | ; Salta a TECLA, pero esta vez para volver a tocar otra tecla de función.
> COMPI | .BYTE 133,137,134,138 | ; Código de las teclas de función.
> | .BYTE 135,139,136,140 |

> Para entender más: Código de Caracteres ASCII
> Para aprender más: Al igual que las teclas de función, puedes utilizar el código ascii de otros caracteres.

> Una segunda aplicación del anterior programa consiste en:

> Nº 7b.- Cambiar colores al pulsar una tecla
> Por Blackspawn en Lemon 64

> * = $1000 |  | ; SYS 4096.
> | SEI | ; Prohibe las interrupciones IRQ, necesario para evitar que la CPU se centre en "otras cosas".
> | LDA #<IRQ | ; Carga A con el byte bajo de la posición de la rutina IRQ.
> | STA $0314 | ; Guarda el valor de A en la dirección $0314.
> | LDA #>IRQ | ; Carga A con el byte alto de la posición de la rutina IRQ.
> | STA $0315 | ; Guarda el valor de A en la dirección $0315.
> | CLI | ; Permite las interrupciones IRQ.
> | RTS | ; Retorna al BASIC.
> IRQ | LDA $CB | ; Carga A con el código del carácter situado en la dirección $CB.
> | CMP #$40 | ; Compara el valor de A con #$40.
> | BEQ FIN | ; Si es así va a FIN.
> | INC $D020 | ; Incrementa el valor de la dirección $D020, que corresponde al borde de la pantalla. Este incremento, junto con un bucle, produce un efecto de colores.
> FIN | JMP $EA31 | ; Salta a la subrutina en ROM $EA31, que se encarga de realizar las interrupciones.

> Para entender más: Gracias a las interrupciones IRQ podemos asignar acciones al teclado que en BASIC no son posibles.
> Para aprender más: ¿Serías capaz de conseguir, gracias a las interrupciones IRQ que, en vez de cambiar el color del borde, produjeras un sonido al pulsar una tecla? Para ello consulta el programa Nº 5 de esta sección.

> Una tercera aplicación del anterior programa consiste en:

> Nº 7c.- Cambiar colores del borde al pulsar las teclas F1 y F3
> Po r fermhg, canal #c64 del irc-hispano

> * = $1000 |  | ; SYS 4096.
> INICIO | LDA $C5 | ; Carga A con el valor situado en la dirección $C5, que es la encargada de recoger el código de la tecla pulsada.
> | CMP #$04 | ; Compara el valor de A con #$04, que es la tecla F1.
> | BEQ NEGRO | ; Si es F1 salta a NEGRO.
> | CMP #$05 | ; Compara el valor de A con #$05, que es la tecla F3.
> | BEQ BLANCO | ; Si es F3 salta a BLANCO.
> | JMP INICIO | ; Si no se ha pulsado ni F1 ni F3, salta a INICIO, esperando a que sean pulsadas una de esas dos teclas.
> NEGRO | LDA #$00 | ; Carga A con #$00, que es el código del color negro.
> | STA $D020 | ; Guarda el valor #$00 en la dirección $D020, que corresponde al borde de la pantalla.
> | JMP INICIO | ; Salta a INICIO, esperando a que nuevamente sean pulsadas una de esas dos teclas.
> BLANCO | LDA #$01 | ; Carga A con #$01, que es el código del color blanco.
> | INC $D020 | ; Guarda el valor #$01 en la dirección $D020.
> | JMP INICIO | ; Salta a INICIO, esperando a que nuevamente sean pulsadas una de esas dos teclas.

> Para entender más: Código del Teclado, la dirección $C5 controla la pulsación de la tecla y no controla el carácter de la tecla. La tecla F1 contiene los caracteres de F1 y F2; la tecla 1 contiene los caracteres 1 y !. Pero lo que realmente genera $C5 es el código de la tecla, no de los caracteres.
> Para aprender más: Puedes hacer que este programa lea otras teclas. Además puedes asignar un sonido distindo a cada tecla pulsada.

> Una cuarta aplicación consiste en:

> Nº 7d.- Cambiar colores con el joystick (puerto 1)
> Po r Andreas Boose en comp.sys.cbm

> * = $1000 |  | ; SYS 4096.
> | SEI | ; Prohibe las interrupciones IRQ, necesario para evitar que la CPU se centre en "otras cosas".
> | LDY #$7F | ; Carga Y con #$7F, que en binario es %01111111.
> BUCLE2 | STY $DC00 | ; Guarda el valor de Y en la dirección $DC00, lo que habilita el joystick en el puerto 1.
> | LDA $DC01 | ; Carga A con el valor de la dirección $DC01.
> | CMP #$EF | ; Compara el valor de A con #$EF.
> | BNE BUCLE1 | ; Salta a BUCLE1 hasta que el valor de A sea #$EF.
> | INC $DC00 | ; Incrementa el valor de la direccion de memoria $DC00.
> | LDA $DC01 | ; Carga A con el valor de $DC01.
> | AND #$10 | ; Efectúa un AND lógico entre A y #$10.
> | LSR | ; Desplaza una vez los bits de A hacia la derecha.
> | LSR | ; Desplaza una vez los bits de A hacia la derecha.
> BUCLE1 | STA $D020 | ; Guarda el valor de A en la dirección $D020, que corresponde al borde de la pantalla.
> | JMP BUCLE2 | ; Salta a BUCLE2.

> Para entender más: $DC00 - $DC01. Debemos mirar una vez más los programas Nº 1b y Nº 1c para recordar un poco el uso de la CIA 1.
> Para aprender más: Puedes hacer que cada posición del joystick imprima un caracter diferente, o que produzca un sonido diferente. Más adelante veremos el uso de los Sprites, una vez visto puedes asignar la dirección del Sprite utilizando el joystick.

> Nº 8.- Degradado de color fijo en pantalla (controlando el raster)
> Por _PaCo_, canal #c64 del irc-hispano

> * = $1000 |  | ; SYS 4096.
> INI | SEI | ; Prohibe las interrupciones IRQ, necesario para evitar que la CPU se centre en "otras cosas".
> BUCLE | LDA $D012 | ; Carga A con el valor de la dirección $D012, leyendo la posición del raster (0-255). Cuando dicha posición está en 255 significa que ha hecho un barrido completo de pantalla.
> | STA $D020 | ; Guarda el valor de A en la dirección $D020, que corresponde al borde de la pantalla.
> | NOP | ; Sincronismo
> | NOP | ; NOP significa no operación, es decir, nada.
> | NOP | ; Es necesario para ajustar el sincronismo del raster.
> | NOP |
> | NOP |
> | JMP BUCLE | ; Salta a BUCLE, realizando un bucle sin fin.

> Para entender más: La manera que tiene el monitor (televisor) de generar los efectos luminosos que dan origen a los caracteres en la pantalla se llama raster (espectro luminoso de arriba a abajo). Éste puede ser controlado desde el Commodore 64 para realizar divisiones, flashes, etc. en la pantalla. La dirección que controla el raster es $D012 más un bit (bit 8) que está el el bit 7 de la dirección $D011.
> Para aprender más: Si añades o quitas NOP te darás cuenta de cómo el Commodore 64 necesita retardar el ensamblado con el fin de conseguir efectos como éste.

> Nº 9a.- Interrupciones IRQ
> Por Wanja Gayk en GO64! Magazine

> * = $1000 |  | ; SYS 4096.
> | SEI | ; Prohibe las interrupciones IRQ, necesario para evitar que la CPU se centre en "otras cosas".
> | LDA #<PRG | ; Carga A con el byte bajo de la posición donde empieza el texto.
> | STA $0314 | ; Guarda el valor de A en la dirección $0314.
> | LDA #>PRG | ; Carga A con el byte alto de la posición donde empieza el texto.
> | STA $0315 | ; Guarda el valor de A en la dirección $0315.
> | CLI | ; Permite las interrupciones IRQ.
> | RTS | ; Retorna al BASIC.
> PRG | LDA #$08 | ; Carga A con #$08, que corresponde al carácter “H”.
> | STA $0400 | ; Guarda el valor #$08 en la posición $0400 del mapa de memoria de pantalla.
> | LDA #$0F | ; Carga A con #$0F, que corresponde al carácter “O”.
> | STA $0401 | ; Guarda el valor #$0F en la posición $0401.
> | LDA #$0C | ; Carga A con #$0C, que corresponde al carácter “L”.
> | STA $0402 | ; Guarda el valor #$0C en la posición $0402.
> | LDA #$01 | ; Carga A con #$01, que corresponde al carácter “A”.
> | STA $0403 | ; Guarda el valor #$01en la posición $0403.
> | LDA #$21 | ; Carga A con #$21, que corresponde al carácter “!”.
> | STA $0404 | ; Guarda el valor #$21 en la posición $0404.
> | JMP $EA31 | ; Salta a la subrutina en ROM $EA31, que se encarga de realizar las interrupciones.

> Para entender más: Para comprender exactamente lo que realiza este pequeño programa podemos ir a la esquina superior izquierda, donde aparece "HOLA!". Si intentamos eliminar o escribir encima de estas palabras veremos que no podemos.
> Para aprender más: Si añades o quitas NOP te darás cuenta de cómo el Commodore 64 necesita retardar el ensamblado con el fin de conseguir efectos como éste.

> Una segunda aplicación del anterior programa consiste en:

> Nº 9b.- Interrupciones IRQ (2)
> Por Wanja Gayk en GO64! Magazine

> * = $1000 |  | ; SYS 4096.
> | SEI | ; Prohibe las interrupciones IRQ, necesario para evitar que la CPU se centre en "otras cosas".
> | LDA #<INTROU | ; Carga A con el byte bajo de INTROU.
> | STA $0314 | ; Guarda el valor de A en la dirección $0314.
> | LDA #>INTROU | ; Carga A con el byte alto de INTROU.
> | STA $0315 | ; Guarda el valor de A en la dirección $0315.
> | LDA #$60 | ; Carga A con #$60, que es el valor de la posición de la pantalla.
> | STA $D012 | ; Guarda el valor de A en la dirección $D012, que comienza la interrupción en la línea #$60 de la pantalla.
> | LDA #$1B | ; Carga A con #$1B.
> | STA $D011 | ; Guarda el valor de A en la dirección $D011, que activa el texto en pantalla y deja el bit 7 en 0.
> | LDA #$F1 | ; Carga A con #$F1.
> | STA $D01A | ; Guarda el valor de A en la dirección $D01A, que comienza la interrupción del raster.
> | CLI | ; Permite las interrupciones IRQ.
> | RTS | ; Retorna al BASIC.
> INTROU | JSR SUBR1 | ; Salta a la subrutina SUBR1, que es la que realiza la rutina de interrupción.
> | JSR SUBR2 | ; Salta a la subrutina SUBR2, que copia la tabla COLTAB en el mapa de colores de pantalla.
> | LDA #$01 | ; Carga A con #$01.
> | STA $D019 | ; Guarda el valor de A en la dirección $D019, que limpia el registro de interrupciones. Las interrupciones finalizan.
> | JMP $EA31 | ; Salta a la subrutina en ROM $EA31, que se encarga de realizar las interrupciones.
> SUBR1 | LDX #$00 | ; Carga X con #$00, que es el valor inicial de un bucle.
> COPY | LDA COLTAB,X | ; Carga A con el valor de COLTAB y siguientes.
> | STA $D800,X | ; Guarda el valor de A en la dirección $D800 y sieguientes, que colorean las distintas posiciones de memoria utilizando también los valores de X.
> | INX | ; Incrementa el valor de X.
> | CPX #$28 | ; Compara el valor de X con #$28, que es el final de la línea.
> | BNE COPY | ; Salta a COPY hasta que el valor de X=#$28.
> | RTS | ; Retorno de subrutina.
> SUBR2 | LDA COLTAB | ; Carga A con el valor de COLTAB.
> | PHA | ; Guarda en la pila el contenido de A.
> | LDX #$00 | ; Carga X con #$00, que es el valor inicial de un bucle.
> VALUE | LDA COLTAB+1,X | ; Carga A con el valor de COLTAB+1 y siguientes.
> | STA COLTAB,X | ; Guarda el código de dicho valor en COLTAB y siguientes. Siempre de derecha a izquierda va cambiando los valores que corresponden a los colores.
> | INX | ; Incrementa el valor de X.
> | CPX #$27 | ; Compara el valor de X con #$27, que es el final de la línea.
> | BNE VALUE | ; Salta a VALUE hasta que el valor de X=#$27.
> | PLA | ; Extrae el valor guardado antes en la pila y lo vuelve a dejar en A. Recordemos que este valor era el que correspondía a COLTAB.
> | STA COLTAB + 39 | ; Guarda el código de dicho valor en COLTAB + 39, es decir, coloca el valor que estaba antes en COLTAB al final de la lista de colores.
> | RTS | ; Retorno de subrutina.
> COLTAB | .BYTE $06,$04,$0E,$0A,$03,$0F,$0D,$07 | ; Colores.
> | .BYTE $01,$01,$07,$0D,$0F,$03,$0A,$0E |
> | .BYTE $04,$06,$0B,$0C,$0F,$01,$0F,$0C |
> | .BYTE $0B,$09,$02,$08,$0A,$0F,$07,$01 |
> | .BYTE $01,$0D,$03,$05,$0C,$0B,$0C,$0F |

> Para entender más: Este programa produce el mismo efecto que el Nº 6b pero esta vez utiliza una interrupción IRQ.
> Para aprender más: Cambia los colores. Realiza este mismo programa en otras líneas de la pantalla (recuerda que cada línea tiene #40 caracteres).

> Una tercera aplicación de los anteriores programas consiste en:

> Nº 9c.- Raster
> Por NorthWest Urers Group

> * = $1000 |  | ; SYS 4096.
> | SEI | ; Prohibe las interrupciones IRQ, necesario para evitar que la CPU se centre en "otras cosas".
> | LDA #<INTROU | ; Carga A con el byte bajo de INTROU.
> | STA $0314 | ; Guarda el valor de A en la dirección $0314.
> | LDA #>INTROU | ; Carga A con el byte alto de INTROU.
> | STA $0315 | ; Guarda el valor de A en la dirección $0315.
> | CLI | ; Permite las interrupciones IRQ.
> | RTS | ; Retorna al BASIC.
> INTROU | LDX #$00 | ; Carga X con el valor #$00.
> | LDA #$3B | ; Carga A con #$3B.
> SUBR | CMP $D012 | ; Compara el valor de A con el valor de la dirección $D012.
> | NOP | ; Sincronismo.
> | NOP | ; NOP significa no operación, es decir, nada.
> | NOP |
> | NOP |
> | NOP |
> | NOP |
> BUCLE | LDY TIMER,X | ; Carga Y con el valor de la posición TIMER y siguientes.
> | LDA COLOR,X | ; Carga A con el valor de la posición COLOR y siguientes.
> | STA $D020 | ; Guarda el valor de A en la dirección $D020, que corresponde al borde de la pantalla.
> | STA $D021 | ; Guarda el valor de A en la dirección $D021, que corresponde al fondo de la pantalla.
> DELAY | DEY | ; Decrementa el valor de Y.
> | BNE DELAY | ; Salta a DELAY hasta que Y=#$00.
> | INX | ; Incrementa el valor de X.
> | CPX #$18 | ; Compara el valor de X con #$18.
> | BNE BUCLE | ; Salta a BUCLE hasta que X=#$18, que es el número de códigos que hay en TIMER y en COLOR.
> | JMP $EA31 | ; Salta a la subrutina en ROM $EA31, que se encarga de realizar las interrupciones.
> TIMER | .BYTE $08,$08,$08,$08,$08,$08 | ; Contador del tiempo.
> | .BYTE $08,$01 |
> | .BYTE $08,$08,$08,$08,$08,$08 |
> | .BYTE $08,$01 |
> | .BYTE $08,$08,$08,$08,$08,$08 |
> | .BYTE $08,$01 |
> | .BYTE $08,$08,$08,$08,$08,$08 |
> | .BYTE $08,$01 |
> COLOR | .BYTE $01,$00,$01,$00,$01,$00 | ; Colores.
> | .BYTE $01,$00 |
> | .BYTE $01,$00,$01,$00,$01,$00 |
> | .BYTE $01,$00 |
> | .BYTE $01,$00,$01,$00,$01,$00
> | .BYTE $01,$00 |
> | .BYTE $01,$00,$01,$00,$01,$00
> | .BYTE $01,$00 |

> Para entender más: Vemos nuevamente otro ejemplo de control del raster.
> Para aprender más: Cambia los valores del raster en $D012. Cambia los colores y el contador de tiempo.

> Una cuarta aplicación de los anteriores programas consiste en:

> Nº 9d.- Rutina para generar una interrupción de tiempo
> Por John P. Gibbons

> * = $1000 |  | ; SYS 4096.
> | LDA #<IRQ | ; Carga A con el byte bajo de IRQ.
> | LDY #>IRQ | ; Carga Y con el byte alto de IRQ.
> | STA $0314 | ; Guarda el valor de A en la dirección $0314.
> | STY $0315 | ; Guarda el valor de Y en la dirección $0315. ; Determina la frecuencia de las interrupciones ($411A = 60 interrupciones por segundo).
> | LDA #$1A | ; Carga A con el byte bajo de #$411A.
> | LDY #$41 | ; Carga Y con el byte alto de #$411A.
> | STA $DC04 | ; Guarda el valor de A en la dirección $DC04.
> | STY $DC05 | ; Guarda el valor de Y en la dirección $DC05. ; Permite las interrupciones del temporizador A.
> | LDA #$81 | ; Carga A con #$81.
> | STA $DC0D | ; Guarda el valor de A en la dirección $DC0D. ; Activa el modo continuo del temporizador.
> | LDA #$91 | ; Carga A con #$91.
> | STA $DC0E | ; Guarda el valor de A en la dirección $DC0E.
> | CLI | ; Permite las interrupciones IRQ.
> | RTS | ; Retorna al BASIC. ; Rutina de Interrupción: Incrementa el color de la pantalla sesenta veces por segundo.
> IRQ | INC $D021 | ; Incrementa el valor de la dirección $D021, que corresponde al fondo de la pantalla. Este incremento, junto con un bucle, produce un efecto de colores. ; Salida de la rutina de interrupciones: Es necesario leer $DC0D para que pueda volverse a producir la interrupción. Finalmente se restuaran los registros y se vuelve al programa interrumpido con RTI.
> | LDA $DC0D | ; Carga A con el valor de la dirección $DC0D.
> | PLA | ; Extrae el valor de la pila y lo deja en A.
> | TAY | ; Transfiere el contenido de A a Y.
> | PLA | ; Extrae el valor de la pila y lo deja en A.
> | TAX | ; Transfiere el contenido de A a X.
> | PLA | ; Extrae el valor de la pila y lo deja en A.
> | RTI | ; Retorno de la rutina de interrupción. Esto asegura que todo queda igual a como estaba cuando ocurrió la interrupción, asegurando que puede continuar el procesamiento como si nada hubiera ocurrido.

> Para entender más: CIA 1 y CIA 2.
> Para aprender más: Cambia los valores del tiempo para comprobar la velocidad del INC $D021.

> Una quinta aplicación de los anteriores programas consiste en:

> Nº 9e.- Dividir la pantalla en 3 partes
> Por Rob & Bjoern en 8 bit core y sys64738, canal #c64 del irc-hispano

> *= $2000 |  | ; SYS 8192.
> | SEI | ; Prohibe las interrupciones IRQ, necesario para evitar que la CPU se centre en "otras cosas".
> | LDA #147 | ; Carga A con #143, que equilvadría a las teclas SHIFT-CLR/HOME, es decir, limpiaría la pantalla.
> | JSR $FFD2 | ; Salta a la subrutina en ROM $FFD2 que saca a pantalla el carácter ASCII cuyo código está en A.
> | LDA #$7F | ; Carga A con #$7F, que en binario es %01111111, lo que desactiva el bit 7.
> | STA $DC0D | ; Pone a cero las interrupciones de la CIA.
> | LDA #$00 | ; Carga A con #$00.
> | STA $D012 | ; Guarda el valor de A en la dirección $D012, que comienza la interrupción en la línea #$00 de la pantalla.
> | STA IRCONT | ; Guarda el valor de A en la posición IRCONT.
> | LDA #>IRQ | ; Carga A con el byte alto de IRQ.
> | STA $0315 | ; Guarda el valor de A en la dirección $0315.
> | LDA #<IRQ | ; Carga A con el byte bajo de IRQ.
> | STA $0314 | ; Guarda el valor de A en la dirección $0314.
> | LDA $D01A | ; Carga A con el valor situado en la dirección $D01A.
> | ORA #$01 | ; Ejecuta un OR lógico entre A y #$01, lo que activa el bit 0.
> | STA $D01A | ; Guarda el valor de A en la dirección $D01A, lo que habilita las interrupciones del raster.
> | CLI | ; Permite las interrupciones IRQ.
> | RTS | ;Retorna al BASIC.
> IRQ | LDA #$01 | ; Carga A con #$01, lo que activa el bit 0.
> | STA $D019 | ; Guarda el valor de A en la dirección $D019, lo que realiza las interrupciones del raster.
> | LDA $D011 | ; Carga A con el valor situado en la dirección $D011.
> | AND #$7F | ; Efectúa un AND lógico entre A y #$7F.
> | STA $D011 | ; Guarda el valor de A en la dirección $D011, lo que pone a 0 el bit 8.
> | LDA IRCONT | ; Carga A con el valor situado en la posición IRCONT.
> | BEQ INT1 | ; Si el valor de IRCONT es 0 va a INT1.
> | CMP #$01 | ; Compara el valor de A con #$01.
> | BEQ INT2 | ; Si el valor de IRCONT es 1 va a INT2.
> | JMP RESET | ; Si el valor de IRCONT no es ni 0 ni 1 salta a RESET.
> INT1 | LDA #100 | ; Carga A con #100.
> | STA $D012 | ; Guarda el valor de A en la dirección $D012, que comienza la interrupción en la línea #100 de la pantalla.
> | INC IRCONT | ; Incrementa el valor de la posición IRCONT.
> | LDA #$02 | ; Carga A con el valor #$02, que corresponde al color rojo.
> | STA $D020 | ; Guarda el valor de A en la dirección $D020, que corresponde al borde de la pantalla.
> | STA $D021 | ; Guarda el valor de A en la dirección $D021, que corresponde al fondo de la pantalla.
> | JMP $EA31 | ; Salta a la subrutina en ROM $EA31, que se encarga de realizar las interrupciones.
> INT2 | LDA #200 | ; Carga A con #200.
> | STA $D012 | ; Guarda el valor de A en la dirección $D012, que comienza la interrupción en la línea #200 de la pantalla.
> | INC IRCONT | ; Incrementa el valor de la posición IRCONT.
> | LDA #$03 | ; Carga A con el valor #$03, que corresponde al color cyan.
> | STA $D020 | ; Guarda el valor de A en la dirección $D020, que corresponde al borde de la pantalla.
> | STA $D021 | ; Guarda el valor de A en la dirección $D021, que corresponde al fondo de la pantalla.
> | JMP $FEBC | ; Salta a la subrutina en ROM $FEBC, que se encarga de salir de las interrupciones.
> RESET | LDA #$00 | ; compensamos con 1 el contador en byte alto.
> | STA IRCONT | ; Guarda el valor de A en la posición IRCONT.
> | STA $D012 | ; Guarda el valor de A en la dirección $D012, que comienza la interrupción en la línea #$00 de la pantalla.
> | LDA #$05 | ; Carga A con el valor #$05, que corresponde al color verde.
> | STA $D020 | ; Guarda el valor de A en la dirección $D020, que corresponde al borde de la pantalla.
> | STA $D021 | ; Guarda el valor de A en la dirección $D021, que corresponde al fondo de la pantalla.
> | JMP $FEBC | ; Salta a la subrutina en ROM $FEBC, que se encarga de salir de las interrupciones.
> IRCONT | .BYTE 0 | ; Si es 0, salta a SAMOS.

> Para entender más: Vemos nuevamente otro ejemplo de control del raster.
> Para aprender más: ¿Te atreves a hacer la bandera de España? Puedes también dividir la pantalla en muchos más trozos.

> Nº 10.- Palabras nuevas
> Por Curtis White en _Bonkers_

> * = $1000 |  | ; SYS 4096.
> | LDA $0400 | ; Carga A con el código del caracter situado en la posición $0400, que corresponde al primer caracter, en la esquina superior izquierda.
> | LDX $0401 | ; Carga X con el código del caracter situado en la posición $0401.
> | LDY $0402 | ; Carga Y con el código del caracter situado en la posición $0402.
> | STA $0402 | ; Guarda el código del caracter de A en la posición $0402.
> | STX $0401 | ; Guarda el código del caracter de X en la dirección $0401. En este caso no se produce ningún cambio.
> | STY $0400 | ; Guarda el código del caracter de Y en la dirección $0400.
> | RTS | ; Retorna al BASIC.

> Para entender más: Para comprender exactamente lo que realiza este pequeño programa podemos ir a la esquina superior izquierda, donde deberemos escribir por ejemplo "RAC". El programa hará lo siguiente: cambiará las letras de orden haciendo escribir la parabra "CAR".
> Para aprender más: Podemos hacer lo mismo con cualquier palabra que nos imaginemos.