WinUAE 5.0.0 disponible

Esta sección te permite ver todos los posts escritos por este usuario. Ten en cuenta que sólo puedes ver los posts escritos en zonas a las que tienes acceso en este momento.
;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
___________________________________________________________________________________;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.
* = $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 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