Buenas.
Como veo interes en aprender ensamblador (yo el que mas) , ire colgando por aquí las rutinas
que en su dia aprendí o me enseñaron. "Trasteocódigos" los llamaba (era un crio).
Me encantaria crear una colección con los aportes de todos para tener un lugar de consulta rápida ante esos momentos "¿y ahora como demonios hago esto?" .
Aqui van mis primeros aportes. Utilizo la ROM del basic para las operaciones. Ya se que no es lo mas rápido, pero la facilidad de uso ayudará (o eso espero) a los noveles como yo.
___________________________________________________________________________________
Este permite hacer calculos de 16bit. y los muestra en pantalla. Suma, resta, divide y multiplica enteros.Muy útil para manejarse en la memoria de pantalla usando coordenadas por ejemplo.
;Creado en CBM prg Studio
; 10 SYS (4096)
*=$801
BYTE $0E, $08, $0A, $00, $9E, $20, $28, $34, $30, $39, $36, $29, $00, $00, $00
*=$1000 ;inicio programa
facarg=$bc0c
intfac=$b391
sum=$b86a
res=$b853
mul=$ba2b
div=$bb12
facind=$bc9b
intasc=$bdcd
lda #$01 ;hibyte 1ª cifra a calcular
ldy #$18 ;lobyte 1ª cifra a calcular
jsr intfac ;
jsr facarg ;
lda #$04 ;hibyte 2ª cifra a calcular
ldy #$00 ;lobyte 2ª cifra a calcular
jsr intfac ;
jsr sum ;OPERACION ELEGIDA
jsr facind ;
ldx $65 ;Resultado lobyte leido de $65
lda $64 ;Resultado hibyte leido de $64
jsr intasc ;Imprimir resultado en pantalla (X=lobyte/Acu=Hibyte)
rts
___________________________________________________________________________________
Aqui lo mismo pero usando la pagina cero (zeropage) para pokear el puntito dentro de las coordenadas que pongais en cordx y cordy.Primero calculo la coordenada Y*40 para saltar a la columna a la que apunte y después le sumo 1024 al resultado.
La coordenada X, simplemente usando STA indirecto indizado por Y que contiene el valor de cordx...
;Creado en CBM prg Studio
;----------------------------------------------------------------------------------------
;Este bloque separado genera una linea basic para arrancar el programa
; 10 SYS (4096)
*=$801
BYTE $0E, $08, $0A, $00, $9E, $20, $28, $34, $30, $39, $36, $29, $00, $00, $00
;-----------------------------------------------------------------------------------------
*=$1000 ;inicio programa SYS4096
;Direcciones de las rutinas del basic necesarias.
facarg=$bc0c
intfac=$b391
sum=$b86a
res=$b853
mul=$ba2b
div=$bb12
facind=$bc9b
;Aqui están las coordenadas X e Y para que juguéis con ellas y poner el punto
;donde os apetezca.
cordx=#05 ;Coordenada X de pantalla. De 0 a 39
cordy=#24 ;Coordenada Y de pantalla. De 0 a 24
;Aqui el programa en cuestión.
lda #00 ;hybyte
ldy #cordy ;lobyte la coordenada Y no pasa de 24
jsr intfac ;
jsr facarg ;
lda #00 ;hibyte
ldy #40 ;lobyte #40-$28. En la memoria de pantalla para bajar una linea se suma 40 ;)
jsr intfac ;
jsr mul ;Multiplica cordy * #40
jsr facind ;
lda $64 ;Carga el hibyte resultado del calculo en el ACU
ldy $65 ;Carga el lobyte resultado del calculo en Y
jsr intfac ;
jsr facarg ;
lda #$04 ;La memoria de pantalla va de 0400 hasta 07E7
ldy #$00 ;hibyte en ACU y lobyte en Y
jsr intfac ;
jsr sum ;Suma 0400 al resultado de (cordy*40)
jsr facind ;
lda $64 ;Carga ACU con el hibyte resultado.
ldx $65 ;Carga X con el lobyte resultado.
sta $FC ;Guarda hibyte en la zeropage.
stx $FB ;Guarda lobyte en la zeropage.
ldy #cordx ;Carga Y con el valor de cordx.
lda #81 ;Carga ACU con el valor 81 (puntito).
sta ($FB),y ;Lo muestra en pantalla
rts ;Volver al BASIC
;Puede que no sea una forma muy rápida para hacer los calculos, pero si es más comprensible
;para usuarios noveles. Siempre estaré agradecido a JAVIER CANTERO por las ayudas que me
;brindo a la hora de programar en CM.
;Se puede usar para mover multitud de objetos en la memoria de pantalla. Espero la ayuda de todos con correcciones , mejoras y vuestros trasteocódigos con los que aprendisteís o aprendeis.
___________________________________________________________________________________
Mostrar texto en pantalla en las coordenadas que se deseénAportado por R.Internacional en este hilo
http://retroinvaders.com/commodoremania/foro/index.php/topic,1080.msg17747.html#msg17747* = $1000 ; SYS 4096.
LDX #$01 ; Carga X con #$01, que corresponde a la línea 1.
LDY #$0A ; Carga el Y #$0A, que corresponde a la columna 10.
JSR $E50C ; Salta a la subrutina en ROM $E50C, que sitúa el cursor en las coordenadas dadas en los valores de X e Y.
LDA #<CADENA ; Carga A con el byte bajo de la posición donde empieza el texto.
LDY #>CADENA ; Carga Y con el byte alto de la posición donde empieza el texto.
JSR $AB1E ; Salta a la subrutina en ROM $AB1E, que imprime una cadena de caracteres.
RTS ; Retorna al BASIC.
CADENA .TEXT "HOLA A TODOS!!!" ; Texto.
.BYTE $00
___________________________________________________________________________________
Rutina multiplicación rápidaAportado por Lobogris en el hilo:
http://retroinvaders.com/commodoremania/foro/index.php/topic,637.msg9662.html#msg9662/*
*************************************************************************************
RUTINA DE MULTIPLICACION RAPIDA * 320
ENTRADAS:
$fa = numero multiplicador (1 byte, rango efectivo = 0 < 204)
SALIDAS:
$fb-$fc = resultado del multiplicador * 320 (precisión 16 bits)
DETALLES:
Num. de ciclos = 51 (+12 contando ciclos del JSR/RTS)
Tamaño en memoria = 29 bytes
Max resultado teorico = 255 * 320 = 81600 ($013EC0)
(no cabe en 16 bits, habria que adaptar resultado a 3 bytes)
Max. resultado efectivo = 204 * 320 = 65280 ($FF00)
Si se quiere optimizar para menor tamaño, se pueden incluir las rotaciones
como una parte iterada dos veces por un bucle. Pero perdemos ciclos asi...
FECHA CREACION: 05-03-13 , ULT. REV.: 05-03-13 (LOBOGRIS)
***************************************************************************************
*/
fastMUL320:
// Descomponiendo, resultado de n * 320 = (256 * n) + (64 * n)
// ahora vamos a calcular 64*numero
// esto se consigue poniendo numero en la parte alta del resultado para obtener numero*256
// y desplazaremos (todos los 16 bits) de resultado a la derecha 2 veces para
// conseguir numero*64...
lda numero
clc // Primera rotacion lógica a la derecha (16 bits)
lsr
sta resultado+1 // Num. en parte alta resultado = multiplicar Num. * 256)
lda resultado
ror
sta resultado // Tras 1a rotación, resultado = 128 * numero
clc // 2a rotacion a la derecha (16 bits)
lda resultado+1
lsr
sta resultado+1
lda resultado
ror
sta resultado // aqui resultado = 64 * numero
// Ahora haremos resultado = (numero * 256) + (numero * 64)
lda numero // Recupera numero. Al ponerlo parte alta = numero * 256
adc resultado+1 // se añade a resultado*64 (parte alta es la única afectada)
sta resultado+1 // ¡Ahora resultado = 320 * numero!
rts
