Pág. 1. Avocet 8051 Assembler V2.45, #01809 Chip=8051 3/12/101 15:23:52 Page 1

Transcripción

1 Avocet 8051 Assembler V2.45, #01809 Chip=8051 3/12/101 15:23:52 Page 1 1 $PG PW=136 PL=60 2 ; 3 ;VERSION SIMPLIFICADA DE LA LIBRERÍA ARITMÉTICA EN PUNTO FIJO 4 ; 5 ;MICRO 80C31 6 ;***************************************************************************** 7 ;^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 8 ;MACROS UTILES 9 ; 10 ; BRANCHS CON COMPARACION INCLUIDA 11 ; REG : A, MAG : directo o # SALTO : CQ LABEL (sin limitacion) 12 ; REG : Rn MAG : # " " " 13 ; 14 ;BHI BRANCH IF HIGHER (SIN SIGNO) 15 ;BHI %MACRO REG,MAG,SALTO 16 ; %LOCAL BNEQ,SIGA 17 ; CJNE REG,MAG,BNEQ 18 ; LJMP SIGA 19 ;BNEQ JC SIGA 20 ; LJMP SALTO 21 ;SIGA 22 ; %ENDM 23 ; 24 ;BLO BRANCH IF LOWER (SIN SIGNO) 25 ;BLO %MACRO REG,MAG,SALTO 26 ; %LOCAL BNEQ,SIGA 27 ; CJNE REG,MAG,BNEQ 28 ; LJMP SIGA 29 ;BNEQ JNC SIGA 30 ; LJMP SALTO Pág. 1

2 31 ;SIGA 32 ; %ENDM 33 ; 34 ;BHE BRANCH IF HIGHER OR EQUAL (SIN SIGNO) 35 ;BHE %MACRO REG,MAG,SALTO 36 ; %LOCAL BNEQ,SIGA 37 ; CJNE REG,MAG,BNEQ 38 ; LJMP SALTO 39 ;BNEQ JC SIGA 40 ; LJMP SALTO 41 ;SIGA 42 ; %ENDM 43 ; 44 ;BLE BRANCH IF LOWER OR EQUAL (SIN SIGNO) 45 ;BLE %MACRO REG,MAG,SALTO 46 ; %LOCAL BNEQ,SIGA 47 ; CJNE REG,MAG,BNEQ 48 ; LJMP SALTO 49 ;BNEQ JNC SIGA 50 ; LJMP SALTO 51 ;SIGA 52 ; %ENDM 53 ; 54 ;BEQ COMPARE Y SALTE SI ES IGUAL 55 ;BEQ %MACRO REG,MAG,SALTO 56 ; %LOCAL SIGA 57 ; CJNE REG,MAG,SIGA 58 ; LJMP SALTO 59 ;SIGA 60 ; %ENDM 61 ; 62 ;BNE COMPARA Y SALTA SI NO ES IGUAL 63 ;BNE %MACRO REG,MAG,SALTO 64 ; %LOCAL SALTE,SIGA 65 ; CJNE REG,MAG,SALTE 66 ; LJMP SIGA 67 ;SALTE LJMP SALTO Pág. 2

3 68 ;SIGA 69 ; %ENDM ;SHIFTEO HACE RLC O RRC EN LA RAM INTERNA SEGUN UNA MASCARA 73 ; se hace para escribir menos ;SHIFTEO %MACRO DESDE,COMO 76 ; MOV R0,#DESDE 77 ; MOV mascara,como 78 ; LCALL ROLEO 79 ; %ENDM ;^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 83 ;******************************************************************************************* 84 ; ******************************************************************************************* 85 ; ******************************************************************************************* ; O R G A N I Z A C I O N D E L A R A M I N T E R N A ; ******************************************************************************************* 91 ; ******************************************************************************************* DEFSEG DATOS, START=$20, ABSOLUTE, CLASS=DATA 94 SEG DATOS 95 ; 96 ; SEGMENTO DE BITS 0020 (0001) 97 mascara DS 1 =0007# 98 DIRECCION_RAM BIT mascara.7 =0006# 99 DIRECCION_SHIFT BIT mascara.6 =00D5# 100 FLAG_ROLEO EQU PSW ; 103 ; SEGMENTO DE AUXILIARES 0021 (0001) 104 contador DS 1 ;21 contador general Pág. 3

4 0022 (0001) 105 aux0 DS 1 ; (0001) 106 dvdnd_l DS 1 ; (0001) 107 dvdnd_ml DS 1 ; (0001) 108 dvdnd_mh DS 1 ; (0001) 109 dvdnd_h DS 1 ;26 parte alta del dvdnd 0027 (0001) 110 aux1 DS 1 ; (0001) 111 divisor_h DS 1 ;28 parte alta del divisor 0029 (0001) 112 aux1_2 DS 1 ;29 002A (0001) 113 aux1_3 DS 1 ;2A 002B (0001) 114 rsltd_l DS 1 ;2B 002C (0001) 115 rsltd_ml DS 1 ;2C 002D (0001) 116 rsltd_mh DS 1 ;2D 002E (0001) 117 rsltd_h DS 1 ;2E parte alta del rsltd 002F (0001) 118 rsltd_hh DS 1 ;2F parte agregada al rsltd para producto 119 ;tienen que ser tantos bytes como tenga 120 ;el multiplicador 0030 (0001) 121 resto DS 1 ;30 Aca queda el resto de la division (0001) 123 mltplcndo_l DS 1 ; (0001) 124 mltplcndo_ml DS 1 ; (0001) 125 mltplcndo_mh DS 1 ; (0001) 126 mltplcndo_h DS 1 ;34 parte alta del multiplicando 0035 (0001) 127 mltplcndo_hh DS 1 ;35 parte agregada al multiplicando 128 ;tienen que ser tantos bytes como tenga 129 ;el multiplicador 0036 (0001) 130 mltplcdor_h DS 1 ;36 parte alta del multiplicador (0001) 132 hexal DS 1 ; (0001) 133 hexah DS 1 ;38 numero hexa a convertir en BCD 0039 (0003) 134 displ DS 3 ;39lugar a donde va a parar el BCD 003C (0001) 135 finaux DS 1 ;comienzo del stack 136 ; 137 ;***************************************************************************** 138 ; CONSTANTES 139 = BYTES_DVDND EQU Pág. 4

5 = BYTES_DVSR EQU 2 ;a pesar de que tiene 1 le asignamos ;para poder shiftearlo sin perder nada 144 = BYTES_DIVISION EQU (BYTES_DVDND) 146 = BYTES_MLTPLCDR EQU = BYTES_MLTPLCND EQU 4 + BYTES_MLTPLCDR 150 ;en realidad son 4 pero agregamos 151 ;tanto como tenga el multiplicador 152 ;para permitir el shifteo = BYTES_PRODUCTO EQU (BYTES_MLTPLCND) 156 = BYTES_BCD EQU = A_RAM_ALTA EQU b = A_RAM_BAJA EQU b = SHIFT_IZQUIERDA EQU b = SHIFT_DERECHA EQU b 163 =000A 164 BASE_DECIMAL EQU 10 = NIBBLE EQU 4 = LOW_RIGHT_DVDND EQU (A_RAM_BAJA + SHIFT_DERECHA + BYTES_DVDND) = LOW_RIGHT_DIVISION EQU (A_RAM_BAJA + SHIFT_DERECHA + BYTES_DIVISION) =00C4 168 HIGH_LEFT_DIVISION EQU (A_RAM_ALTA + SHIFT_IZQUIERDA + BYTES_DIVISION) =00C4 169 HIGH_LEFT_DVDND EQU (A_RAM_ALTA + SHIFT_IZQUIERDA + BYTES_DVDND) = LOW_RIGH_MLTPLCDR EQU (A_RAM_BAJA + SHIFT_DERECHA + BYTES_MLTPLCDR) =00C5 171 HIGH_LEFT_MLTPLCND EQU (A_RAM_ALTA + SHIFT_IZQUIERDA + BYTES_MLTPLCND) =00C3 172 HIGH_LEFT_BCD EQU (A_RAM_ALTA + SHIFT_IZQUIERDA + BYTES_BCD) ; ******************************************************************************************* 175 ; 176 ; 177 DEFSEG MYCODE, START=$0, ABSOLUTE, CLASS=CODE 178 ; Pág. 5

6 179 SEG MYCODE ;VECTORES 182 = ORG 00H ' 184 LJMP MAIN ;por si uso IRQ 185 ; ;PROGRAMA PRINCIPAL 188 ; 189 ;******************************************************************************************* 190 ; P R O G R A M A P R I N C I P A L 191 ;******************************************************************************************** 192 ;******************************************************************************************* 193 = ORG 30H " 3B" 195 MAIN MOV SP,#(finaux-1) ;ubico el stack Pointer A5' 196 LCALL CARGUE_UN_NUMERO_CQ ' 197 LCALL DIV4 198 ;cambiando las CONSTANTES 199 ;BYTES_DVDND y BYTES_DVSR 200 ;se ajusta a cualquier caso 201 ;para hacerlo on de fly, ponerlas 202 ;en variables A5' 204 LCALL CARGUE_UN_NUMERO_CQ 003C C' 205 LCALL MULT4 003F ' 206 LCALL HEXA_BCD NOP ;para poner el breakpoint Pág. 6

7 208 ;***************************************************************************** 209 ; 210 ;RUTINAS 211 ;******************************************************************************************* 212 ; DIV4 213 ; divide directamente dvdnd_h/l (4 bytes) por divisor_h (1 byte) 214 ; 215 ; los rsltds quedan en rsltd_h/l, El resto en resto (obviamente) 216 ; usa B,A,R0,R2 (si se usan en la rutina invocante se deben pushear) 217 ; Es muy facil generalizar la rutina para usar signo y la cantidad de bytes que se quiera. 218 ; DIV C2 D5 220 CLR FLAG_ROLEO " MOV aux1,# A MOV R2,#BYTES_DIVISION 004A 12 00EC' 223 LCALL CLEAR_rsltd 004D 75 21" MOV contador,#(8*(bytes_dvdnd-bytes_dvsr+1)+1) 225 ;para justificar el divisor = 25 en este caso E MOV A,divisor_h ' 228 JNZ JUSTIFICAR RET ;DIVISION POR CERO HABRIA QUE PONER UN FLAG 230 ; o cargar con $FFFFFFFF el resultado JUSTIFICAR 0055 E MOV A,divisor_h E7# 0D' 233 JNB ACC.7,JUSTIENDO ;para corregir el clasico error 234 ;del algoritmo de Booth en el que 235 ;si divisor.7 == 1 y dvdnd.7 ==1 236 ;con MSB dvdnd < divisor 237 ;se shiftea el dvdnd y se pierde 238 ;el bit 7 dando error 005A D2 D5 239 SETB FLAG_ROLEO 005C C3 240 CLR C Pág. 7

8 005D RRC A 005E F MOV divisor_h,a 0060 E MOV A,aux RRC A 0063 F MOV aux1,a DEC contador JUSTIENDO 0067 E MOV A,dvdnd_h " F0" 249 MOV B,divisor_h ; ojo el Assembler pone los Macros como comentario porque no los ; expande, pero esto no significa que SEAN comentarios 250 ;BLO A,B,LOOPDIV ;la primera vez se bate el dvdnd 251 ;para que primero sea menor y luego 252 ;mayor que el divisor (se podrian dividir 253 ;y comparar el resto con el divisor, para 254 ;ajustar) 255 ;BHI A,B,JUSTIDOS 0082 E MOV A,dvdnd_mh " F0" 257 MOV B,aux1 258 ;BLE A,B,LOOPDIV JUSTIDOS 0092 C3 260 CLR C ;shifteo el dvdnd a la derecha empezando 261 ;con el MSB 262 ;SHIFTEO dvdnd_h,#low_right_dvdnd 263 ;shifteo el rsltd a la derecha empezando 264 ;con el MSB ;SHIFTEO rsltd_h,#low_right_division A INC contador 00A ' 269 LJMP JUSTIENDO A8 271 LOOPDIV 00A " 2A" 272 MOV aux1_3,dvdnd_h 00AB 85 25" 29" 273 MOV aux1_2,dvdnd_mh Pág. 8

9 00AE C3 274 CLR C 00AF E MOV A,aux1_2 00B SUBB A,aux1 00B3 F MOV aux1_2,a 00B5 E5 2A 278 MOV A,aux1_3 00B SUBB A,divisor_h 00B9 F5 2A 280 MOV aux1_3,a 00BB 10 D7# 07' 281 JBC PSW.7,MOVER ;el carry en directo 00BE 85 2A" 26" 282 MOV dvdnd_h,aux1_3 00C " 25" 283 MOV dvdnd_mh,aux1_ C4 D3 285 SETB C C5 288 MOVER 289 ;shifteo el rsltd a la izquierda 290 ;empezando por el LSB ;SHIFTEO rsltd_l,#high_left_division CD D5 21" 03' 294 DJNZ contador,shift_div 00D DD' 295 JMP PONRESTO D3 297 SHIFT_DIV ;shifteo el dvdnd a la izquierda 298 ;empezando por el LSB 299 ;SHIFTEO dvdnd_l,#high_left_dvdnd DB 80 CB' 301 JMP LOOPDIV DD 306 PONRESTO 00DD 30 D5# 08' 307 JNB FLAG_ROLEO,DIVISOR_DIRECTO ;SHIFTEO dvdnd_l,#high_left_dvdnd 310 Pág. 9

10 00E8 311 DIVISOR_DIRECTO 00E " 30" 312 MOV resto,dvdnd_h EB 314 FINDIVISION 00EB RET 316 ; ******************************************************************************************* 317 ;Rutina para limpiar los auxiliares de resultado 00EC 317 CLEAR_rsltd 318 ;usa R0, R2 00EC 78 2E 319 MOV R0,#rsltd_h 00EE 320 LOOP_CLEAR 00EE F DEC R0 00F1 DA FB' 323 DJNZ R2,LOOP_CLEAR 00F RET 325 ;********************************************************************* 00F4 326 CLEAR_dvdnd F4 7A MOV R2,#(BYTES_DIVISION + 1) 00F MOV R0,#dvdnd_h 00F8 80 F4' 330 SJMP LOOP_CLEAR FA 332 ;********************************************************************* 333 CLEAR_DISP FA 7A MOV R2,#(BYTES_BCD) 00FC 78 3C 336 MOV R0,#(displ+3) 00FE 80 EE' 337 SJMP LOOP_CLEAR ;********************************************************************* SUMA 342 ;suma en multiple presicion lo que viene apuntado por R0 (LSB) con 343 ;la cantidad de bytes que trae R2 y lo apuntado por R1 (LSB) (idem cant. De bytes) 344 ;el rsltd queda en lo apuntado por R1, que debe tener disponible 1 byte mas 345 ;que lo apuntado por R0 346 ;usa A,R0,R1,R2 Pág. 10

11 C3 348 CLR C LOOP_SUMA 0101 E6 350 MOV A,@R ADDC A,@R F INC R INC R DA F9' 355 DJNZ R2,LOOP_SUMA ' 356 JNC FIN_SUMA 010A B 358 FIN_SUMA 010B RET 360 ;********************************************************************* C 362 MULT ;multiplica 4 bytes en mltplcndo_h/l por un byte en mltplcdor_h 365 ;el rsltd queda en rsltd_h/ll 366 ;puede facilmente generalizarse para cualquier cantidad de bytes C 75 35" MOV mltplcndo_hh,# F 7A MOV R2,#BYTES_PRODUCTO EC' 371 LCALL CLEAR_rsltd LOOP_PROD 373 ;SHIFTEO mltplcdor_h,#low_righ_mltplcdr C 50 09' 375 JNC NO_SUME E MOV R0,#mltplcndo_l B 378 MOV R1,#rsltd_l A MOV R2,#BYTES_MLTPLCND ' 380 LCALL SUMA NO_SUME 0127 C3 382 CLR C 383 ;SHIFTEO mltplcndo_l,#high_left_mltplcnd Pág. 11

12 E MOV A,mltplcdor_h E0' 386 JNZ LOOP_PROD RET 388 ;********************************************************************* HEXA_BCD ;convierte dos bytes hexa en tres byte en BCD (empaquetados como diría Marisa) F4' 390 LCALL CLEAR_dvdnd FA' 391 LCALL CLEAR_DISP 013B 85 37" 23" 392 MOV dvdnd_l,hexal 013E 85 38" 24" 393 MOV dvdnd_ml,hexah " MOV dvdnd_mh,# " MOV dvdnd_h,# LOOP_HEXA " 0A 397 MOV divisor_h,#base_decimal 014A ' 398 LCALL DIV4 014D E MOV A,resto ;el resto 014F 12 00F4' 400 LCALL CLEAR_dvdnd B" 23" 401 MOV dvdnd_l,rsltd_l C" 24" 402 MOV dvdnd_ml,rsltd_ml ORL displ,a 015A 7C MOV R4,#NIBBLE 015C 405 LOOP_BCD 406 ;SHIFTEO displ,#high_left_bcd 0164 DC F6' 407 DJNZ R4,LOOP_BCD 0166 E MOV A,dvdnd_ml DD' 409 JNZ LOOP_HEXA 016A E MOV A, divisor_h 411 ;BLE A,dvdnd_l,LOOP_HEXA E MOV A,dvdnd_l ORL displ,a 017B MOV R0,#displ Pág. 12

13 017D E MOV A,displ ;para dejarlo mas bonito 017F C4 417 SWAP A 0180 F MOV displ,a 0182 E5 3A 419 MOV A,displ C4 420 SWAP A 0185 F5 3A 421 MOV displ+1,a 0187 E5 3B 422 MOV A,displ C4 423 SWAP A 018A F5 3B 424 MOV displ+2,a C RET 427 ;********************************************************************* 018D 428 ROLEO 429 ;Subrutina para shiftear a derecha o izquierda a travez del carry 430 ;y hacia arriba o abajo de la RAM segun lo que traiga en 431 ;los bits 6 y 7 del auxiliar mascara, la cantidad de bytes 432 ;que tenga mascara en el nibble bajo 433 ;R0 apunta al primer byte a shiftear ;usa R0,R1,R2,A (si se usan en la rutina invocante se deben pushear ) D MOV R1,#mascara 018F E4 438 CLR A 0190 D7 439 XCHD A,@R FA 440 MOV R2,A ;en R2 la cantidad de bytes LOOP_SHIFT 0192 E6 443 MOV A,@R # 03' 445 JB DIRECCION_SHIFT,A_IZQUIERDA RRC A ' 447 SJMP SEGUIR A_IZQUIERDA RLC A 019A F6 450 SEGUIR1 Pág. 13

14 B 20 07# 03' 452 JB DIRECCION_RAM,ARRIBA 019E DEC R0 019F 80 01' 454 SJMP SEGUIR2 01A ARRIBA INC R A2 DA EE' 457 SEGUIR2 DJNZ R2,LOOP_SHIFT 01A RET ;bastante elegante!!!! ;************************************************************************** 01A5 461 CARGUE_UN_NUMERO_CQ A " FF 463 MOV dvdnd_h, #$FF ;cargo cualquier numero como 01A " 9F 464 MOV dvdnd_mh, #$9F ;demostracion 01AB 75 24" MOV dvdnd_ml, #$00 01AE 75 23" MOV dvdnd_l, #$00 01B " MOV divisor_h, #$ B " 9F 469 MOV mltplcndo_l,#$9f 01B " FF 470 MOV mltplcndo_ml,#$ff 01BA 75 33" AA 471 MOV mltplcndo_mh,#$aa 01BD 75 34" MOV mltplcndo_h,#$00 01C " 7F 473 MOV mltplcdor_h,#$7f C " FF 475 MOV hexah,#$ff 01C " 9F 476 MOV hexal,#$9f C RET Pág. 14

15 01C1 481 ;************************************************************************** 482 ; Rutina rápida para elevar al cuadrado. 483 ; se podría usar la de multiplicación, pero esta es m s rápida. 484 ; se puede usar con leves variaciones para hacer una rutina de producto 485 ; rápida de dos bytes por dos bytes CUADRADO ; Recibe el dato en mltplcndo_ml y _l y devuelve el rsltd en 490 ; rsltd_h/l 491 ; usa R0,R1,B,A C MOV R0,#mltplcndo_l 01C MOV R1,#mltplcndo_l 01C F5' 495 LCALL PRODUCTO 01C8 F5 2B 496 MOV rsltd_l,a 01CA 85 F0" 2C" 497 MOV rsltd_ml,b 01CD INC R0 01CE 12 01F5' 499 LCALL PRODUCTO 01D RLC A 01D2 C5 F0 501 XCH A,B 01D RLC A 01D5 C5 F0 503 XCH A,B 01D ' 504 JNC CUAD0 01D9 05 2E 505 INC rsltd_h 01DB 506 CUAD0 01DB 25 2C 507 ADD A,rsltd_ml 01DD F5 2C 508 MOV rsltd_ml,a 01DF 50 02' 509 JNC CUAD1 01E1 05 F0 510 INC B ;No teman NO puede haber C 01E3 85 F0" 2D" 511 CUAD1 MOV rsltd_mh,b 01E INC R1 01E F5' 513 LCALL PRODUCTO 01EA 25 2D 514 ADD A,rsltd_mh 01EC F5 2D 515 MOV rsltd_mh,a 01EE C5 F0 516 XCH A,B 01F0 35 2E 517 ADDC A,rsltd_h Pág. 15

16 01F2 F5 2E 518 MOV rsltd_h,a ; y se terminó!!!!!!!!!!! 01F RET 520 ;************************************************************************** 521 ;Realiza el producto de dos variable de un byte apuntadas por R0 y R1 01F5 522 PRODUCTO F5 E6 524 MOV A,@R0 01F6 87 F0 525 MOV B,@R1 01F8 A4 526 MUL AB 01F RET ;************************************************************************** 530 END No lines contained errors. No lines contained warnings. Breve explicación de la rutina de división Div4. Esta rutina está extractada de una mucho más general (cualquier cantidad de bytes dividos por otra cantidad cualquiera de bytes y con signo) que hice para un desarrollo mio. No la debugee, pero supongo que estará bien ( Acá se dividen cuatro bytes dvdnd_h a dvdnd_l y (se reserva un aux0 para shift de este dividendo) por un byte divisor_h (y se reserva un byte aux1 para el shift del divisor). 1.Se justifica (virtualmente) el divisor con el byte MSB del dividendo. A ese efecto se pone un contador en 25 (las veces que lo corrí virtualmente hacia la parte significativa más uno, ya que cuando contador == 0 se termina la división). 2.Se verifica que el divisor no tenga un 1 en el bit MSB (7) ya que eso podría traer un desborde del dividendo cuando lo justifique para ser mayor que el divisor (ejemplo divisor = dividendo = , en este caso al justificar a la derecha el dividendo perdería un uno) Pág. 16

17 En caso que así sea lo shifteo (al divisor) a la derecha hacia el aux0 y decremento el contador. Se memoriza que esto ocurra con un Flag (Flag_roleo), a fin de calcular luego correctamente el resto de la división. 3.Se corre a la derecha (hacia la parte baja) al dividendo hasta que sea menor que el divisor y luego nuevamente hacia la parte alta hasta que sea mayor. Se ajusta el contador. Ahora se pueden restar. 4.Se resta el dividendo menos el divisor en dos auxiliares, si el resultado es mayor que cero, se traslada el resultado al dividendo y se shiftea este (hacia el MSB) y se hace lo mismo con el resultado, ingresado un uno en el bit menos significativo. En caso que la resta de negativa, se shiftea el dividendo y el resultado pero introduciendo un cero en el bit menos significativo de este. Se disminuye el contador. 5. Se itera el paso anterior hasta que el contador dé cero. 6.Se calcula el resto, tomando en cuenta si hubo roleo (Flag_roleo) inicial del divisor, caso en que se shiftea el dividendo, ya que las restas se hicieron en dos bytes. Obvio!!!. Pág. 17