> Página 4

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

> | 16 - 17a - 17b - 18 - 19 - 20 | translate this page

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

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

> Nº 16.- Introducir una cadena
> Por Blackspawn en Lemon 64

> * = $1000 |  | ; SYS 4096.
> | LDY #$00 | ; Carga el Y con el valor #$0A, que corresponde a la columna 10.
> BUCLE | JSR $FFCF | ; Salta a la subrutina en ROM $FFCF, que permite introducir una cadena de caracteres.
> | CMP #$0D | ; ¿Se ha presionado la tecla RETURN?.
> | BEQ FIN | ; Si es así vamos a FIN.
> | STA BUFFER,Y | ; Guarda el texto introducido en FUFEER y siguientes.
> | INY | ; Incrementa el valor de Y.
> | BNE BUCLE | ; Salta a BUCLE hasta que se pulse la tecla RETURN.
> FIN | RTS | ; Retorna al BASIC.
> BUFFER | .BYTE 0 | ; A partir de aquí serán introducidos los códigos de los caracteres del texto.

> Para entender más: Con este programa podemos simular el comando INPUT del BASIC.
> Para aprender más: Utiliza eta rutina para introducir una cadena. Una vez introducida prueba a imprimirla en pantalla.

> Nº 17a.- Scroll sencillo
> Por Ferris, fermhg y sys64738, canal #c64 del irc-hispano

> * = $1000 |  | ; SYS 4096.
> INICIO | LDY #$00 | ; Carga Y con #$00, que es el valor inicial de un bucle.
> RETARDO | LDA #$1E | ; Carga A con #$1E, que corresponde con la velocidad del scroll.
> | STA $F9 | ; Guarda el valor de A en la posición $F9.
> | LDX #$00 | ; Carga X con #$00, que es el valor inicial de un bucle.
> | LDA #$FE | ; Carga A con #$FE, que en decimal es #254.
> RASTER | CMP $D012 | ; Compara el valor de la dirección $D012 con #$FE.
> | BNE RASTER | ; Salta a RASTER hasta que éste coincida con #$FE.
> | DEC $F9 | ; Decrementa el valor de la dirección $F9.
> | BNE RASTER | ; Salta a RASTER hasta que el valor de la dirección $F9 coincida con #$00.
> BUCLE | LDA $0401,X | ; Carga A con el valor de $0401 y siguientes.
> | STA $0400,X | ; Guarda el valor de A en la posición $0400 y siguientes, lo que permite un "scroll" de caracteres hacia la izquierda.
> | INX | ; Incrementa el valor de X.
> | CPX #$27 | ; Compara el valor de X con #$27, final de la línea.
> | BNE BUCLE | ; Salta a BUCLE hasta que el valor de X coincida con #$27.
> | LDA TEXTO,Y | ; Carga A con el valor de TEXTO y siguientes.
> | CMP #$00 | ; Compara el valor de A con #$00, final del texto.
> | BEQ INICIO | ; Si es así salta a INICIO, si no, continúa.
> | STA $0427 | ; Guarda el valor de A en la posición $0427, final de línea.
> | INY | ; Incrementa el valor de Y.
> | JMP RETARDO | ; Salta a RETARDO para seguir leyendo el texto.
> TEXTO | .BYTE $03,$15,$01,$04,$05,$12 | ; Texto.
> | .BYTE $0E,$0F,$20,$04,$05,$20 |
> | .BYTE $10,$12,$0F,$07,$12,$01 |
> | .BYTE $0D,$01,$03,$09,$0F,$0E |
> | .BYTE $20,$04,$05,$0C,$20,$03 |
> | .BYTE $0F,$0D,$0D,$0F,$04,$0F |
> | .BYTE $12,$05,$20,$36,$34,$20 |
> | .BYTE $20,$20,$20,$20,$20,$00 |

> Para entender más: Aquí tenemos un scroll sencillo de derecha a izquierda.
> Para aprender más: Puedes introducir tu propio texto. Puedes utilizar otra línea para realizar tu scroll. ¿Sabrías realizar un scroll de izquierda a derecha utilizando como modelo este programa?

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

> Nº 17b.- Scroll sencillo
> Po r fermhg, canal #c64 del irc-hispano

> * = $1000 |  | ; SYS 4096.
> INICIO | LDY #$00 | ; Carga Y con #$00, que es el valor inicial de un bucle.
> RETARDO | LDA #$1E | ; Carga A con #$1E, que corresponde con la velocidad del scroll.
> | STA $F9 | ; Guarda el valor de A en la posición $F9.
> | LDA #$FE | ; Carga A con #$FE, que en decimal es #254.
> RASTER | CMP $D012 | ; Compara el valor de la dirección $D012 con #$FE.
> | BNE RASTER | ; Salta a RASTER hasta que éste coincida con #$FE.
> | DEC $F9 | ; Decrementa el valor de $F9.
> | BNE RASTER | ; Salta a RASTER hasta que el valor de $F9 coincida con #$00.
> | LDA TEXTO,Y | ; Carga A con el valor de TEXTO y siguientes.
> | CMP #$00 | ; Compara el valor de A con #$00, final del texto.
> | BEQ INICIO | ; Si es así salta a INICIO, si no, continúa.
> | STA $07E7 | ; Guarda el valor de A en la posición $07E7, final de línea.
> | TYA | ; Transfiere el contenido de Y a A.
> | PHA | ; Guarda en la pila el contenido de A.
> | JSR $E8EA | ; Salta a la subrutina en ROM $E8EA, que realiza un scroll de pantalla hacia arriba.
> | PLA | ; Extrae el contenido antes guardado y lo deja en A.
> | TAY | ; Transfiere el contenido de A al registro Y.
> | INY | ; Incrementa el valor de Y.
> | JMP RETARDO | ; Salta a RETARDO para seguir leyendo el texto..
> TEXTO | .BYTE $03,$15,$01,$04,$05,$12 | ; Texto.
> | .BYTE $0E,$0F,$20,$04,$05,$20 |
> | .BYTE $10,$12,$0F,$07,$12,$01 |
> | .BYTE $0D,$01,$03,$09,$0F,$0E |
> | .BYTE $20,$04,$05,$0C,$20,$03 |
> | .BYTE $0F,$0D,$0D,$0F,$04,$0F |
> | .BYTE $12,$05,$20,$36,$34,$20 |
> | .BYTE $20,$20,$20,$20,$20,$00 |

> Para entender más: Aquí tenemos un scroll sencillo de abajo a arriba utilizando, en este caso la subrutina en ROM $E8EA.
> Para aprender más: Puedes introducir tu propio texto. Puedes utilizar otra columna para realizar tu scroll.

> Nº 18.- Increíble efecto sonoro
> Por John Iannetta en comp.sys.cbm

> * = $1000 |  | ; SYS 4096.
> | SEI | ; Prohíbe las interrupciones IRQ, necesario para evitar que la CPU se centre en "otras cosas".
> | LDA #$00 | ; Carga A con #$00.
> | STA $D011 | ; Guarda el valor de A en la dirección $D011, lo que deshabilita todos los bits, dejando la pantalla en blanco.
> BUCLE | LDA #$00 | ; Carga A con #$00.
> | STA $D418 | ; Guarda el valor de A en la posición $D418, lo que activa el SID pero con el volumen al mínimo.
> | LDA #$0F | ; Carga A con #$0F.
> | STA $D418 | ; Guarda el valor de A en la posición $D418, dando el máximo volumen al SID.
> | JMP BUCLE | ; Salta a BUCLE.

> Para entender más: SID
> Para aprender más: Puedes probar introduciendo otros valores en la dirección $D418.

> Nº 19.- Copiar bloques de memoria
> Por David Holz en comp.sys.cbm, fermhg, canal #c64 del irc-hispano

> *= $1000 |  | ; SYS 4096.
> | LDA #<$6000 | ; Carga A con el byte bajo de la dirección $6000, que es la dirección donde está el código que queremos copiar.
> | STA $FB | ; Guarda el valor de A en la dirección $FB.
> | LDA #>$6000 | ; Carga A con el byte alto de la dirección $6000.
> | STA $FC | ; Guarda el valor de A en la dirección $FC.
> | LDA #<$2000 | ; Carga A con el byte bajo de la dirección $2000, que es la dirección donde destinaremos ese código.
> | STA $FD | ; Guarda el valor de A en la dirección $FD.
> | LDA #>$2000 | ; Carga A con el byte alto de la dirección $2000.
> | STA $FE | ; Guarda el valor de A en la dirección $FE.
> | LDY #$00 | ; Carga Y con #$00, que es el valor inicial de un bucle.
> BUCLE | LDA ($FB),Y | ; Carga A con el valor de la dirección $FB y siguientes, realizando un direccionamiento indirecto indexado de la dirección $6000 y siguientes.
> | STA ($FD),Y | ; Guarda el valor de A en la dirección $$FD y siguientes, ealizando un direccionamiento indirecto indexado de la dirección $2000 y siguientes.
> | INY | ; Incrementa el valor de Y.
> | BNE BUCLE | ; Salta a BUCLE hasta que el valor de Y=#$00.
> | LDA $FC | ; Carga A con el valor de la dirección $FC.
> | CMP #$90 | ; Compara A con #$90, que correspondería a la dirección $9000, que es un poco más de donde termina el código que queremos copiar.
> | BEQ FIN | ; Si es así salta a FIN, si no, continúa.
> | INC $FC | ; Incrementa el valor de $FC.
> | INC $FE | ; Incrementa el valor de $FE.
> | JMP BUCLE | ; Salta a BUCLE, donde volvemos a iniciar la copia de otro bloque, recordemos que ya Y=#$00.
> FIN | RTS | ; Retorna al BASIC.

> Para entender más: Direccionamiento Indirecto Indexado
> Para aprender más: Si te das cuenta, hemos copiado el código que está entre $6000-$9000 en las direcciones $2000-$5000. Como ves ésta es otra forma de copiar los archivos KOALA en la dirección $2000 y siguientes, pudiendo ya ser leídos con los programas Nº 4a y Nº 4b.