Programa que imprime valores numericos con macros (Carolina Sauceda)

Codigo:


Mostrar Macro Mensaje
LEA DX,Mensaje ;mandamos el mensaje a leer
MOV AH,9 ;usamos el servicio para mostrar en pantalla
INT 21H
endM

Terminar Macro
MOV AX,4C00H
INT 21H
endM

DATOS SEGMENT
ENCABEZADO DB 13,10,13,09h,09h,"==============================="
DB 13,10,13,09h,09h,"PROGRAMA QUE IMPRIME VALORES NUMERICOS DEC Y HEXA "
DB 13,10,13,09h,09h,"================================",13,10,"$"
ALINEAR DB 13,10,13,09h,09h
VALOR_1 DW 41D,"$"
VALOR_2 DW 42D,"$"
VALOR_3 DW 43D,"$"
VALOR_4 DW 44D,"$"
VALOR_5 DW 45D,"$"
VALOR_6 DW 46,"$"
VALOR_7 DW 47,"$"
VALOR_8 DW 48,"$"
VALOR_9 DW 49,"$"
VALOR_10 DW 50,"$"
DATOS ENDS


valores Macro
Mostrar ALINEAR
Mostrar VALOR_1
Mostrar VALOR_2
Mostrar VALOR_3
Mostrar VALOR_4
Mostrar VALOR_5
Mostrar VALOR_6
Mostrar VALOR_7
Mostrar VALOR_8
Mostrar VALOR_9
Mostrar VALOR_10
endM

Titulo Macro
Mostrar ENCABEZADO
endm

CODIGO SEGMENT
ASSUME CS: CODIGO,DS:DATOS,SS:PILA
Main PROC

MOV AX,DATOS
MOV DS,AX

Titulo
valores


Main ENDP
Terminar
CODIGO ENDS
END Main

Mejora programa # 9: Letras de colores (Ivan Gutierrez)

Código:

include 'emu8086.inc'

CUADRO MACRO XI,YI,XF,YF,COLOR

MOV AX, 0600H ;

MOV BH, COLOR ; COLOR DE FONDO Y LETRA

MOV BL, 00H

MOV CH, YI ; Y INICIAL

MOV CL, XI ; X INICIAL

MOV DH, YF ; Y FINAL

MOV DL, XF ; X FINAL

INT 10h

endM

POSICION MACRO X,Y

; **** POSICIONA EL CURSOR ********

MOV DH, Y ; POSICI[ON EN Y

MOV DL, X ; POSICI[ON EN X

MOV AH, 02

MOV BH, 00

INT 10H

ENDM

DESPLEGAR MACRO MENSAJE

MOV AH,09 ;****** MUESTRA MENSAJE *******

MOV DX,OFFSET MENSAJE

INT 21h

ENDM

DATOS SEGMENT ;SEGMENTO DE DATOS

M1 DB "I",'$'

M2 DB "V",'$'

M3 DB "A",'$'

M4 DB "N",'$'

datos ends

cincocuadros macro

cuadro 1,1,20,5,71

posicion 10,3

desplegar M1

cuadro 21,1,40,5,22

posicion 30,3

desplegar M2

cuadro 41,1,60,5,33

posicion 50,3

desplegar M3

cuadro 61,1,78,5,54

posicion 70,3

desplegar M4

endM

CODIGO SEGMENT

ASSUME CS: CODIGO,DS:DATOS,SS:PILA

PRINCIPAL PROC

MOV AX,DATOS

MOV DS,AX

cincocuadros

PRINCIPAL ENDP ;FIN DEL PROCEDIMIENTO

CODIGO ENDS ;FIN DEL SEGMENTO

END PRINCIPAL

15 programas en TASM

1. Hola mundo

CR EQU 13
LF EQU 0Ah

DATOS SEGMENT
    MENSAJE DB CR,LF,'HOLA MUNDO',CR,LF,'$'
DATOS ENDS

PILA SEGMENT STACK
    DB 64 DUP('PILA')
PILA ENDS

CODIGO SEGMENT
    HM PROC FAR
    ASSUME CS: CODIGO,DS:DATOS,SS:PILA
    
    MOV AX,DATOS
    MOV DS,AX
    LEA DX,MENSAJE
    
    MOV AH,9
    INT 21H
    
    MOV AX, 4C00H
    INT 21H
    
    HM ENDP
  
CODIGO ENDS
END HM

2. Uso de constantes

CR EQU 13  
LF EQU 10
IMPRIMIR EQU 9
FIN EQU 4C00H
DOS EQU 21H

DATOS SEGMENT
    TEXTO DB 'EJEMPLO DEL USO DE CONSTANTES',CR,LF,'$'
   
DATOS ENDS

PILA SEGMENT STACK
    DB 64 DUP ('PILA')
PILA ENDS

CODIGO SEGMENT
    ASSUME CS:CODIGO,DS:DATOS,SS:PILA
    INICIO: MOV AX,DATOS
           MOV DS,AX
           MOV DX,OFFSET TEXTO
           MOV AH,IMPRIMIR
           INT DOS 
           MOV AX,FIN
           INT DOS
           
      CODIGO ENDS
      END INICIO



3. Hola mundo con funcion

CR EQU 13  
LF EQU 10

DATOS SEGMENT
    MENSAJE DB CR,LF,'HOLA MUNDO',CR,LF,'$'
    
DATOS ENDS

PILA SEGMENT STACK
    DB 64 DUP ('PILA')
PILA ENDS

CODIGO SEGMENT
    HMF PROC FAR
    ASSUME CS:CODIGO,DS:DATOS,SS:PILA
    MOV AX,DATOS
    MOV DS,AX
    LEA DX,MENSAJE
    
    CALL ESCRIBE
    MOV AX,4C00H
    INT 21H
    
    HMF ENDP
    
    ESCRIBE PROC 
            MOV AH,9
            INT 21H
            RET
            ESCRIBE ENDP
        CODIGO ENDS
        END HMF



4. Lineas en pantalla con procesdimiento

CR EQU 13  
LF EQU 10

DATOS SEGMENT 
    LINEA1 DB CR,LF,'MANUEL RAMIREZ BONILLA',CR,LF,'$'
    LINEA2 DB 'TECNOLOGICO DE MATAMOROS',CR,LF,'$'
    LINEA3 DB 'INGENIERIA EN SISTEMAS COMPUTACIONALES',CR,LF,'$'
    LINEA4 DB 'SOLTERO :(',CR,LF,'$'
    
DATOS ENDS

PILA SEGMENT STACK
    DB 64 DUP ('PILA')
PILA ENDS

CODIGO SEGMENT
    
    LN PROC FAR
    
    ASSUME CS:CODIGO,DS:DATOS,SS:PILA
    MOV AX,DATOS
    MOV DS,AX
    LEA DX,LINEA1
    CALL ESCRIBE
    LEA DX,LINEA2
    CALL ESCRIBE
    LEA DX,LINEA3
    CALL ESCRIBE
    LEA DX,LINEA4
    CALL ESCRIBE
    MOV AX,4C00H
    INT 21H
    
    LN ENDP
    
    ESCRIBE PROC
    MOV AH,9
    INT 21H
    RET
    ESCRIBE ENDP
    
CODIGO ENDS
END LN



5. Programa que limpia pantalla

FIN_4C00H EQU 4C00H
DOS_21H EQU 21H
BIOS_10H EQU 10H

PILA SEGMENT STACK
    DW 100 DUP('0')
PILA ENDS

CODIGO SEGMENT
    CLS PROC FAR
    ASSUME CS:CODIGO,SS:PILA
    CALL LIMPIA_PANTALLA
    MOV AX,FIN_4C00H
    INT DOS_21H
    CLS ENDP
    
    LIMPIA_PANTALLA PROC NEAR
        MOV AX,0600H
        MOV BH,0AH
        MOV CX,000H
        INT BIOS_10H
        RET
        LIMPIA_PANTALLA ENDP
        
    CODIGO ENDS
    END CLS



6. Programa que controla la posicion del cursor

CR EQU 13
LF EQU 10
TECLADO_8 EQU 8
IMPRIMIR_9 EQU 9
FIN_4C00H EQU 4C00H
DOS_21H EQU 21H
BIOS_10H EQU 10H
TAB EQU 09H
BELL EQU 07H

DATOS SEGMENT
    RENGLON DB 0
    COLUMNA DB 0
    MENSAJE DB CR,LF,'POSICION (X,Y), DEL MENSAJE: MANUEL RAMIREZ',CR,LF,'$'
DATOS ENDS

PILA SEGMENT STACK
    DW 100 DUP('0')
PILA ENDS

CODIGO SEGMENT
    PC PROC FAR
    ASSUME CS:CODIGO,DS:DATOS,SS:PILA
    MOV AX,DATOS
    MOV DS,AX
    LEA DX,MENSAJE
    CALL POSICIONA_CURSOR
    MOV AH,IMPRIMIR_9
    INT DOS_21H
    MOV AX,FIN_4C00H
    INT DOS_21H
    
    PC ENDP
    POSICIONA_CURSOR PROC NEAR
    MOV AH,02
    MOV BH,00
    MOV DH,RENGLON
    MOV DL,COLUMNA
    INT BIOS_10H
    RET
    POSICIONA_CURSOR ENDP
CODIGO ENDS
END PC



7. Programa que borra pantalla y posicion del cursor

CR Equ 13
LF EQU 10
TECLADO_8 EQU 8
IMPRIMIR_9 EQU 9
FIN_4C00H EQU 4C00H
DOS_21H EQU 21H
BIOS_10H EQU 10H
TAB EQU 09H
BELL EQU 07H

DATOS SEGMENT
    RENGLON DB 0
    COLUMNA DB 0
    MENSAJE DB CR,LF,"POSICION (X,Y), DEL MENSAJE: Manuel Ramirez"
            DB "DESPUES DE BORRAR PANTALLA",CR,LF,"$"
            
        DATOS ENDS
        
        PILA SEGMENT STACK
            DW 100 DUP("0")
        PILA ENDS
        
        CODIGO SEGMENT
            CLSP PROC FAR
            ASSUME CS:CODIGO, DS:DATOS, SS:PILA
            MOV AX,DATOS
            MOV DS,AX
            LEA DX,MENSAJE
            CALL LIMPIA_PANTALLA
            CALL POSICIONA_CURSOR
            MOV AH,IMPRIMIR_9
            INT DOS_21H
            MOV AX,FIN_4C00H
            INT DOS_21H
            
            CLSP ENDP
            
            LIMPIA_PANTALLA PROC NEAR
            MOV AX,0600H
            MOV BH,0AH
            MOV CX,000H
            MOV DX,484FH
            INT BIOS_10H
            RET
            LIMPIA_PANTALLA ENDP
            
            POSICIONA_CURSOR PROC NEAR
            MOV AH,01
            MOV BH,00
            MOV DH,RENGLON
            MOV DL,COLUMNA
            INT BIOS_10H
            RET
            POSICIONA_CURSOR ENDP
            
        CODIGO ENDS
        END CLSP



8. Programa que pide 3 cadenas y las muestra en pantalla

TECLADO EQU 8
IMPRIMIR EQU 9
FIN EQU 4C00H
DOS EQU 21H
BIOS EQU 10H
TAB EQU 09H
BELL EQU 07H
CR EQU 13
LF EQU 10

DATOS SEGMENT
    NOMBRE DB 30 DUP(32),"$"
    DIR DB 30 DUP(32),"$"
    TLF DB 15 DUP(32),"$"
    MENS1 DB "NOMBRE: $"
    MENS2 DB "DIRECCION: $"
    MENS3 DB "TELEFONO: $"
    ENTERR DB CR,LF,"$"
DATOS ENDS

PILA SEGMENT STACK
    DB 64 DUP("PILA")
PILA ENDS

CODIGO SEGMENT
    ASSUME CS:CODIGO, DS:DATOS, SS:PILA
    INICIO:
    MOV AX,DATOS
    MOV DS,AX
    CALL MODO_DE_VIDEO
    
    MOV DX,OFFSET MENS1
    CALL ESCRIBE
    MOV SI,OFFSET NOMBRE
    MOV CX,8
    CALL PEDIR
    CALL SALTO_DE_LINEA
    
    MOV DX,OFFSET MENS2
    CALL ESCRIBE
    MOV SI,OFFSET DIR
    MOV CX,8
    CALL PEDIR
    CALL SALTO_DE_LINEA
    
    MOV DX,OFFSET MENS3
    CALL ESCRIBE
    MOV SI,OFFSET TLF
    MOV CX,10
    CALL PEDIR
    CALL SALTO_DE_LINEA
    
    CALL ESCRIBE
    CALL ESCRIBE
    CALL ESCRIBE
    MOV DX,OFFSET NOMBRE
    CALL ESCRIBE
    CALL SALTO_DE_LINEA
    MOV DX,OFFSET DIR
    CALL ESCRIBE
    CALL SALTO_DE_LINEA
    
    MOV DX,OFFSET TLF
    CALL ESCRIBE
    CALL SALTO_DE_LINEA
    CALL SALIR
    
    PEDIR PROC NEAR
    BUCLE:
    MOV AH,TECLADO
    INT DOS
    MOV[SI],AL
    MOV AH,2
    MOV DL,AL
    INT DOS
    
    INC SI
    LOOPNZ BUCLE
    
    RET 
    PEDIR ENDP
    
    ESCRIBE PROC NEAR
    MOV AH,IMPRIMIR
    INT DOS
    RET
    ESCRIBE ENDP
    
    SALTO_DE_LINEA PROC NEAR
    MOV DX,OFFSET ENTERR
    CALL ESCRIBE
    RET 
    SALTO_DE_LINEA ENDP
    
    MODO_DE_VIDEO PROC NEAR
    MOV AX,3
    INT BIOS
    RET
    MODO_DE_VIDEO ENDP
    
    SALIR PROC NEAR
    MOV AX,FIN
    INT DOS
    RET
    SALIR ENDP
CODIGO ENDS
END INICIO



9. Programa que cambia los colores del texto y fondo

CR EQU 13
LF EQU 10
BIOS EQU 10H
DOS EQU 21H
TEXTO EQU 3
FIN EQU 4C00H

DATOS SEGMENT 
    TITULO DB "JUENITO_XD"
    COLORES DB 01001110B
    DB 11101111B
    DB 10110001B
    DB 01011100B
    DB 00110001B
    DB 01011111B
    DB 01101011B
    DB 01011100B
    DB 01101111B
    DB 01001110B
    DB 00110001B
DATOS ENDS

PILA SEGMENT STACK
    DB 64 DUP("PILA")
PILA ENDS

CODIGO SEGMENT
    COLO PROC FAR
    ASSUME CS:CODIGO, DS:DATOS, SS:PILA
    MOV AX,DATOS
    MOV DS,AX
    MOV AX,TEXTO
    INT BIOS
    MOV CX,11
    XOR SI,SI
    BUCLE:
    PUSH CX
    MOV DX,SI
    ADD DX,35
    MOV DH,12
    CALL COLOCA
    MOV AL,[SI+OFFSET TITULO]
    MOV BL,[SI+OFFSET COLORES]
    CALL COLOR
    POP CX
    INC SI
    
    LOOPNZ BUCLE
    MOV AH,8
    INT DOS
    XOR DX,DX
    CALL COLOCA
    MOV AX,FIN
    INT DOS
    COLO ENDP
    
    COLOR PROC
    MOV AH,9
    XOR BH,BH
    INT BIOS
    RET
    COLOR ENDP
    
    COLOCA PROC
    MOV AH,2
    XOR BX,BX
    INT BIOS
    RET
    COLOCA ENDP
CODIGO ENDS
END COLO



10. Muestra un valor binario

CR EQU 13
LF EQU 10
IMPRIMIR EQU 9
FIN EQU 4C00H
DOS EQU 21H
TAB EQU 09H
BELL EQU 07H

DATOS SEGMENT
    ENCABEZADO DB 13,10,13,TAB,TAB,"==============================="
    DB 13,10,13,TAB,TAB,"   PROGRAMA QUE IMPRIME UN VALOR BINARIO"
    DB 13,10,13,TAB,TAB,"==================================",13,10,"$"
    VALOR_ASCII DB "0101010110","$"
DATOS ENDS

PILA SEGMENT STACK
    DB 64 DUP("0")
PILA ENDS

CODIGO SEGMENT
    ASCI PROC NEAR
    ASSUME CS:CODIGO, DS:DATOS, SS:PILA
    MOV AX,DATOS
    MOV DS,AX
    LEA DX,ENCABEZADO
    CALL ESCRIBE
    
    LEA DX, VALOR_ASCII
    CALL ESCRIBE
    CALL SALIR
    
    ASCI ENDP
    
    ESCRIBE PROC
    MOV AH,9
    INT 21H
    RET
    ESCRIBE ENDP
    
    SALIR PROC NEAR
    MOV AX,FIN
    INT DOS
    RET
SALIR ENDS
CODIGO ENDS
END ASCI





11. Muestra valores numericos en decimal y hexadecimal 


CR EQU 13
LF EQU 10
IMPRIMIR EQU 9
FIN EQU 4C00H
DOS EQU 21H
TAB EQU 09H
BELL EQU 07H

DATOS SEGMENT
    ENCABEZADO DB 13,10,13,TAB,TAB,"==============================="
    DB 13,10,13,TAB,TAB,"   PROGRAMA QUE IMPRIME VALORES NUMERICOS DEC Y EXA 91.3 ;)"
    DB 13,10,13,TAB,TAB,"==================================",13,10,"$"
    VALOR_1 DW 41D,"$"
    VALOR_2 DW 42D,"$"
    VALOR_3 DW 43D,"$"
    VALOR_4 DW 44D,"$"
    VALOR_5 DW 45D,"$"
    VALOR_6 DW 46,"$"
    VALOR_7 DW 47,"$"
    VALOR_8 DW 48,"$"
    VALOR_9 DW 49,"$"
    VALOR_10 DW 50,"$"
    VALOR_11 DW 31H,"$"
    VALOR_12 DW 32H,"$"
    VALOR_13 DW 33H,"$"
    VALOR_14 DW 34H,"$"
    VALOR_15 DW 35H,"$"
    VALOR_16 DW 36H,"$"
    VALOR_17 DW 37H,"$"
    VALOR_18 DW 38H,"$"
    VALOR_19 DW 39H,"$"
    VALOR_20 DW 40H,"$"
    
DATOS ENDS

PILA SEGMENT STACK
    DB 64 DUP('0')
PILA ENDS
CODIGO SEGMENT
    EXA PROC NEAR
    ASSUME CS:CODIGO,DS:DATOS,SS:PILA
    MOV AX,DATOS
    MOV DS,AX
    LEA DX,ENCABEZADO
    CALL ESCRIBE
    LEA DX, VALOR_1
    CALL ESCRIBE
    
LEA DX, VALOR_2
CALL ESCRIBE
LEA DX, VALOR_3
CALL ESCRIBE
LEA DX, VALOR_4
CALL ESCRIBE
LEA DX, VALOR_5
CALL ESCRIBE
LEA DX, VALOR_6
CALL ESCRIBE
LEA DX, VALOR_7
CALL ESCRIBE
LEA DX, VALOR_8
CALL ESCRIBE
LEA DX, VALOR_9
CALL ESCRIBE
LEA DX, VALOR_10
CALL ESCRIBE
LEA DX, VALOR_11
CALL ESCRIBE
LEA DX, VALOR_12
CALL ESCRIBE
LEA DX, VALOR_13
CALL ESCRIBE
LEA DX, VALOR_14
CALL ESCRIBE
LEA DX, VALOR_15
CALL ESCRIBE
LEA DX, VALOR_16
CALL ESCRIBE
LEA DX, VALOR_17
CALL ESCRIBE
LEA DX, VALOR_18
CALL ESCRIBE
LEA DX, VALOR_19
CALL ESCRIBE
LEA DX, VALOR_20
CALL ESCRIBE
CALL SALIR
EXA ENDP
ESCRIBE PROC
MOV AH,9
INT 21H
RET
ESCRIBE ENDP
SALIR PROC NEAR
MOV AX,FIN
INT DOS
RET
SALIR ENDP
CODIGO ENDS
END EXA 



12. Conversion de letras a binario

CR EQU 13
LF EQU 10
IMPRIMIR EQU 9
FIN EQU 4C00H
DOS EQU 21H
TAB EQU 09H

DATOS SEGMENT
    ASCII DB 'A','B','C','D','E','F','G','H'
    ESPACIO DB CR,LF,'$'
    BINARIO DB 64 DUP (?),'$'
    MENSAJE1 DB CR,LF,TAB,"ANTES DE LA CONVERSION: ",'$'
    MENSAJE2 DB CR,LF,TAB,"DESPUES DE LA CONVERSION: ",'$'
DATOS ENDS

PILA SEGMENT STACK 'STACK'
    DW 128 DUP('P')
PILA ENDS
CODIGO SEGMENT
    CONV PROC FAR
    
  ASSUME CS:CODIGO, DS:DATOS, SS:PILA
  MOV AX,DATOS
  MOV DS,AX
  LEA DX,MENSAJE1
  CALL ESCRIBE
  LEA DX, ESPACIO
CALL ESCRIBE
LEA DX, ASCII
CALL ESCRIBE
LEA DX, ESPACIO
CALL ESCRIBE
LEA DX, BINARIO
CALL ESCRIBE
LEA DX, ESPACIO
CALL ESCRIBE
LEA SI, ASCII
LEA DI, BINARIO
CALL ASCII2BIN
LEA DX, MENSAJE2
CALL ESCRIBE
LEA DX, ESPACIO
CALL ESCRIBE
LEA DX, ASCII
CALL ESCRIBE
LEA DX, ESPACIO
CALL ESCRIBE
LEA DX, BINARIO
CALL ESCRIBE
LEA DX, ESPACIO
CALL ESCRIBE
CALL SALIR
CONV ENDP
ASCII2BIN PROC NEAR
XOR AX, AX
MOV CX, 8
ASCII1:
MOV AL, [SI]
PUSH CX
MOV CX,8
LOOP_SHIFT:
SHL AL, 1
JC BIN_UNO
MOV [DI], BYTE PTR '0'
JMP CICLO_SHIFT
BIN_UNO:
MOV [DI], BYTE PTR '1'
CICLO_SHIFT:
INC DI
LOOP LOOP_SHIFT
POP CX
INC SI
LOOP ASCII1
RET
ASCII2BIN ENDP
ESCRIBE PROC
MOV AH,IMPRIMIR
INT DOS
RET
ESCRIBE ENDP
SALIR PROC NEAR
MOV AX, FIN
INT DOS
SALIR ENDP
CODIGO ENDS
END CONV



13. Numeros a hexadecimal

CR EQU 13
LF EQU 10
IMPRIMIR EQU 9
FIN EQU 4C00H
DOS EQU 21H
TAB EQU 09H
DATOS SEGMENT
ENCABEZADO DB 13,10,13,TAB,TAB,"==============================="
DB 13,10,13,TAB,TAB,"   PROGRAMA QUE IMPRIME NUMEROS EN HEXADECIMAL"
DB 13,10,13,TAB,TAB,"==================================",13,10,13,10,"$"
DATOS ENDS
PILA SEGMENT STACK
DB 64 DUP('0')
PILA ENDS
CODIGO SEGMENT   
    CEXA PROC NEAR
ASSUME CS:CODIGO,DS:DATOS,SS:PILA
ORG 100H
MOV AX,DATOS
MOV DS,AX
LEA DX,ENCABEZADO
CALL ESCRIBE
MOV CX, 200H
XOR DX, DX
CICLO:
CALL ESCRIBE_HEX
CALL ESCRIBE_CRLF
INC DX
LOOP CICLO
CALL SALIR
CEXA ENDP
ESCRIBE_HEX PROC NEAR
PUSH AX
PUSH CX
PUSH DX
OTRO_DIGITO:
PUSH CX 
MOV CL,4
ROL DX,CL
CALL ESCRIBE_DIGITO_HEX
POP CX
LOOP OTRO_DIGITO
POP DX
POP CX
POP AX
RET
ESCRIBE_HEX ENDP
ESCRIBE_DIGITO_HEX PROC NEAR
PUSH AX
PUSH DX
AND DX,0FH
CMP DL,10
JAE ES_MAYOR_A_10
ADD DL,48
JMP IMPRIME_DIGITO
ES_MAYOR_A_10:
ADD DL,55
IMPRIME_DIGITO:
MOV AH,2
INT 21H
POP DX
POP AX
RET
ESCRIBE_DIGITO_HEX ENDP
ESCRIBE_CRLF PROC NEAR
PUSH AX
PUSH DX
MOV AH,2
MOV DL,13
INT 21H
MOV DL,10
INT 21H
POP DX
POP AX
RET
ESCRIBE_CRLF ENDP
ESCRIBE PROC
MOV AH,9
INT 21H
RET
ESCRIBE ENDP
SALIR PROC NEAR
MOV AX,FIN
INT DOS
RET
SALIR ENDP
CODIGO ENDS
END CEXA



14. Convierte numeros ASCII a binario

CR EQU 13
LF EQU 10
IMPRIMIR EQU 9
FIN EQU 4C00H
DOS EQU 21H
TAB EQU 09H
BELL EQU 07H
DATOS SEGMENT
ENCABEZADO DB 13,10,13,TAB,TAB,"======================================================"
DB 13,10,13,TAB,TAB,"   PROGRAMA QUE CONVIERTE UN NUMERO ASCII A BINARIO"
DB 13,10,13,TAB,TAB,"======================================================",13,10,"$"
VALOR_ASCII DB '33',"$"
VALOR_BINARIO DW 0,"$"
LONGITUD_ASCII DW 2,"$"
POTENCIA_10 DW 00000001B,"$"
DATOS ENDS
PILA SEGMENT STACK
DB 64 DUP('0')
PILA ENDS
CODIGO SEGMENT   
    POTE PROC NEAR
ASSUME CS:CODIGO,DS:DATOS,SS:PILA
MOV AX,DATOS
MOV DS,AX
LEA DX, VALOR_ASCII
CALL ESCRIBE
MOV BX, 00001010B
MOV BX, LONGITUD_ASCII
LEA SI, VALOR_ASCII+1
ETIQUETA_1:
MOV AL, [SI]
AND AX, 000FH
MUL POTENCIA_10
ADD VALOR_BINARIO, AX
MOV AX, POTENCIA_10
MUL BX
MOV POTENCIA_10, AX
DEC SI
LOOP ETIQUETA_1
LEA DX, ENCABEZADO
CALL ESCRIBE
LEA DX, VALOR_BINARIO
CALL ESCRIBE
CALL SALIR
POTE ENDP
ESCRIBE PROC
MOV AH,9
INT 21H
RET
ESCRIBE ENDP
SALIR PROC NEAR
MOV AX, FIN
INT DOS
RET
SALIR ENDP
CODIGO ENDS
END POTE



15.Convierte numero ASCII a binario (ingresando el numero)

LF EQU 10
IMPRIMIR EQU 9
FIN EQU 4C00H
DOS EQU 21H
TAB EQU 09H
BELL EQU 07H
TECLADO EQU 8
DATOS SEGMENT
NUMERO_BINARIO DW 0,"$"
NUMERO_ASCII DW 6,0,6 DUP (?),"$"
M_ENCABEZADO DB 13,10,13,10,TAB,"================================================================="
DB 13,10,13,TAB,"   PROGRAMA QUE CONVIERTE UN NUMERO ASCII (CAPTURADO) A BINARIO"
DB 13,10,13,TAB,"===============================================================",13,10,"$"
M_ESPACIO DB 13,10,13,10,13,10,13,10,13,10,13,10,"$"
M_ASCII_ASCII DB 13,10,13,10,"NUMERO ASCII IMPRESO NORMALMENTE COMO LO HACE UNA PC (EN ASCII)",13,10,"$"
M_BINARIO_ASCII DB 13,10,13,10,"NUMERO BINARIO (YA CONVERTIDO),",13,10,"IMPRESO NORMALMENTE COMO LO HACE UNA PC (EN ASCII): ","$"
POTENCIA DW 001H, 000AH, 0064, 03E8H, 2710H,"$"
DATOS ENDS
PILA SEGMENT STACK
DB 64 DUP('0')
PILA ENDS
CODIGO SEGMENT   
    CAPT PROC NEAR
ASSUME CS:CODIGO,DS:DATOS,SS:PILA
MOV AX,DATOS
MOV DS, AX
MOV AH,0AH
MOV DX, OFFSET NUMERO_ASCII
INT 21H
MOV DI, OFFSET NUMERO_ASCII + 1
MOV CX,[DI]
MOV SI, OFFSET NUMERO_ASCII + 2
XOR CH, CH
MOV DI, OFFSET POTENCIA
DEC SI
ADD SI,CX
XOR BX,BX
STD
CICLO:
LODSB
SUB AL, 30H
CBW
MOV DX, [DI]
MUL DX
ADD DI,2
ADD BX,AX
LOOP CICLO
MOV NUMERO_BINARIO,BX
LEA DX,M_ENCABEZADO
CALL ESCRIBE
LEA DX,M_ASCII_ASCII
CALL ESCRIBE
LEA DX,NUMERO_ASCII - 1
CALL ESCRIBE
LEA DX,M_BINARIO_ASCII
CALL ESCRIBE
LEA DX,NUMERO_BINARIO
CALL ESCRIBE
LEA DX,M_ESPACIO
CALL ESCRIBE
CALL SALIR
CAPT ENDP
ESCRIBE PROC
MOV AH,IMPRIMIR
INT DOS
RET
ESCRIBE ENDP
SALIR PROC NEAR
MOV AX,FIN
INT DOS
SALIR ENDP
CODIGO ENDS
END CAPT

Programa utilizando LOOPE

Este es un programa que utiliza ciclos condicionales, en este caso LOOPE.

Codigo:

org 100h
.stack 64
.data
.code
inicio:
mov cx,10 ;cantidad de veces que repetira
mov al,'>' ;caracter inicial

Lee_car:
mov ah,0eh ;Funcion para imprimir caracter
int 10h ;llama a la bios

mov ah,00 ;funcion de espera de un caracter del teclado
int 16h ;llama al bios
cmp al,'S' ;compara el caracter con 'S'
loope Lee_car ;si es igual salta a otro

mov ah,0eh ;funcion para imprimir caracter
int 10h ;llamada al bios

;colocar el fin de la linea para que baje una linea y lo imprima
mov ah,0eh ;funcion del bios para imprimir caracter
mov al,10
int 10h ;para servicio de video

;colocar el retorno de carro para ir al inicio
mov al,13
int 10h
;prepara la salida del programa
mov ax,4c00h
int 21h
end inicio

Resultado:

Programa multiplicador de 2 cifras en ensamblador

Este programa lo que hace es multiplicar 2 cifras en ensamblador.

.model small ;Modelo de memoria m?s utilizado
.stack

.data        ;definición de datos(variables), donde se almacenara información
.code
   chr1  db ? ;primer digito
   chr2  db ? ;segundo digito
   chr3  db ? ;multiplo
   chr4  db ?
   r1    db ? ;resultado 1
   r2    db ? ;resultado 2
   r3    db ?
   r4    db ?
   ac    db 0 ;acarreo
   ac1   db 0
.startup
   ;cls
   mov ah,00h     ;Function(Set video mode)
   mov al,03      ;Mode 80x25 8x8 16
   int 10h        ;Interruption Video

   mov ah,01h     ;Function(character read) Guarda en AL
   int 21h        ;Interruption DOS functions
   sub al,30h     ;ajustamos valores
   mov chr1,al    ;[chr1].chr2 * chr3 = ac.r1.r2

   mov ah,01h     ;Function(character read) Guarda en AL
   int 21h        ;Interruption DOS functions
   sub al,30h     ;Ajustamos valores
   mov chr2,al    ;chr1.[chr2] * chr3 = ac.r1.r2

   mov ah,02h     ;Function(character to send to standard output)
   mov dl,'*'     ;Character to show
   int 21h

   mov ah,01h     ;Function(Read character) Guarda en AL
   int 21h        ;Interruption DOS Functions
   sub al,30h     ;Transform(0dec = 30hex)
   mov chr3,al    ;chr1.chr2 * [chr3] = ac.r1.r2
  
   mov ah,01h     ;Function(Read character) Guarda en AL
   int 21h        ;Interruption DOS Functions
   sub al,30h     ;Transform(0dec = 30hex)
   mov chr4,al    ;chr1.chr2 * [chr3] = ac.r1.r2

   mov ah,02h     ;Character to send to standar output
   mov dl,'='     ;
   int 21h        ;Interruption DOS functions

   ;Realizamos operaci?n   
  
   mov al,chr4  ;al=5       ;unidad del segundo numero
   mov bl,chr2  ;bl=5       ;unidad del primer numero
   mul bl       ;bl=25      ;multiplicar
   mov ah,0     ;ah=0       ;limpiamos ah0
   aam          ;ax=02  05  ;separamos de hex a dec
   mov ac1,ah   ;ac1=02     ;decenas del primera multiplicacion
   mov r4,al    ;r4=05      ;unidades del primera multiplicacion
            
   mov al,chr4  ;bl=4       ;unidades del segundo numero
   mov bl,chr1  ;al=5       ;decentas del primer numero
   mul bl       ;al=14h     ;multiplicar
   mov r3,al    ;r3=14h     ;movemos el resultado de la operacion a r3
   mov bl,ac1   ;bl=02      ;movemos el acarreo a bl
   add r3,bl    ;r3=16h     ;sumamos resultado mas acarreo
   mov ah,00h   ;ah=00      ;limpiamos ah por residuos
   mov al,r3    ;al=16h     ;movemos el resultado de la suma a al
   aam          ;ax=02  02  ;separamos  de hex a dec
   mov r3,al    ;r3=02      ;guardamos unidades en r3
   mov ac1,ah   ;ac1=0      ;guardamos decenas en ac1
  
      

   mov al,chr3    ;al=2     ;al = chr3
   mov bl,chr2    ;bl=5     ;bl = chr2
   mul bl         ;al=10    ;AL = chr3*chr2 (BL*AL)
   mov Ah,0h      ;ah=0     
   AAM            ;ax=01 00 ;ASCII Adjusment
   mov ac,AH      ;ac=01    ;ac = AH (Acarreo)
   mov r2,AL      ;r2=0     ;r2 = AL       (Unidad del resultado)

   mov al,chr3    ;al=2     ;AL = chr3
   mov bl,chr1    ;bl=4     ;BL = chr1
   mul bl         ;al=8     ;AL = chr1*chr3 (BL*AL)
   mov r1,al      ;r1=8     ;r1 = AL       (Decena del resultado)
   mov bl,ac      ;bl=01    ;BL = Acarreo anterior
   add r1,bl      ;r1=9;    ;r1 = r1+ac (r1 + Acarreo)
   mov ah,00h     ;ah=00
   mov al,r1      ;al=9     ;AL = r1 (Asignaci?n para el ajust)
   AAM            ;ax=00 09 ;ASCII Adjustment
   mov r1,al      ;r1=09    ;r1 = AL
   mov ac,ah      ;ac=0     ;ac = AH (Acarreo para la Centena del resultado)
  
  
   ;suma final
   ;R4 resulta ser las unidades de mul y no se toma en cuenta ya que se pasa entero
  
  
   mov ax,0000h   ;limpiamos ax
  
   mov al,r3      ;al=02        ;movemos el segundo resultado de la primera mult a al
   mov bl,r2      ;bl=0         ;movemos primer resultado de la segunda mult a bl
   add al,bl      ;al=2         ;sumamos
   mov ah,00h     ;ah=00        ;limpiamos ah
   aam            ;ax=00  02    ;separamos hex a dec
   mov r3,al      ;r3=02        ;r3 guarda las decenas del resultado final
   mov r2,ah      ;r2=0         ;r2 se utiliza como nuevo acarreo
  
   mov ax,0000h   ;''''
  
   mov al,ac1     ;al=02        ;movemos el acarreo de la primera mult a al
   mov bl,r1      ;bl=9         ;movemos segundo resultado de la segunda mult a bl
   add al,r2      ;al=2         ;sumamos el nuevo  acarreo de la suma anterior  a al
   add al,bl      ;al=Bh        ;sumamos al a bl
   mov ah,00h     ;ah=00        ;limpiamos el registro ah
   aam            ;ax=01 01     ;separamos de hex a dec
   mov r1,al      ;r1=01        ;r1 guarda las centenas
   mov r2,ah      ;R2=01        ;ah se sigue utilizando como acarreo
  
   mov al,r2      ;al=01        ;movemos el acarreo a al
   mov bl,ac      ;bl=00        movemos ac a bl
   add al,bl      ;al=01        ;sumamos al a bl
   ;aam            ;separamos hex a dec
   mov ac,al      ;ac=01        mov al a ac como nuestro acarreo final
  
 
  
   ;Mostramos resultado
   mov ah,02h 
   mov dl,ac
   add dl,30h
   int 21h        ;Mostramos ac (millar) ac=1

   mov ah,02H
   mov dl,r1
   add dl,30h
   int 21h        ;Mostramos r1 (centena) r1=1

                 
  
   mov ah,02H
   mov dl,r3                                  
   add dl,30h
   int 21h        ;Mostramos r3 (decena)  r3=2
  
   mov ah,02H
   mov dl,r4
   add dl,30h
   int 21h        ;unidad r4=5
  
.exit
end   

Resultado:

Programa detector de subcadenas

En esta entrada veremos el código de lo que es un detector de subcadenas en Ensamblador.

org 100h
include 'emu8086.inc'
mov si, 0 ;ponemos si en 0

comienzo:
mov al, msg2[0] ;copiar la primera letra de la palabra A al
cmp msg[si],"$" ;si es el fin de la cadena mandar a final
jz noacepta ; brinca si en efecto es el final de la cadena
;si no continuo con las siguientes lineas
cmp msg[si], al ;comparar si encuentra la primera letra de la cadena en msg2
jne seguir ;brica si es diferente
;si no continuo con la ejecucion

mov di, 1 ;poner en 1 di

comprobar:
mov al, msg2[di] ;extraigo el siguiente caracter de msg2
mov bx, di ;igualo bx=di
cmp msg[si+bx], al ;consiguo el caracter ubicado en la posicion si+bx y lo comparo con al (al contiene el caracter de msg2)
jne seguir ;si no coincide mandar a seguir
;si no continuo con las siguientes lineas

inc di ;incrementar di para seguir recorriendo cadena

cmp msg2[di],"$" ;si es el fin de la cadena y el programa llego
jz resultado ;aca quiere decir que la cadena es parte de la palabra


loop comprobar ;bucle para recorrer cadena


seguir:

inc si ;para seguir recorriendo la palabra

loop comienzo ;bucle principal para recorrer palabra

resultado:
print "Si lo contiene"
jmp final ;brinco al final

noacepta:
print "No la contiene"
jmp final ;brinco al final



final:
ret

msg db "tecnologico$"
msg2 db "logi$"

Resultado:

Programas con la instruccion de LOOP

En este apartado veremos las diferentes formas de utilizar la instruccion LOOP

Codigo 1:

.model tiny
name "Bucle"

.data
dato db 10,13 ,'Letrero $'

.code
Inicio:
mov cx,50
comienzo:
mov dx,OFFSET dato
mov ah,09
int 21h
;inc cx
loop comienzo
ret

Codigo 2: LOOP con libreria emu8086

org 100h
include 'emu8086.inc'

mov cx,10 ;Vueltas que va a dar el programa

comienzo:
printn 'letrero'

loop comienzo


ret

Unidad 2: Ciclos condicionales

Etiquetas de instrucciones

Las instrucciones JMP,Jnnn y LOOP requieren de un operador que se refiere a la etiqueta de una instrucciones.

Salto incondicional (JMP)

Una instrucción usada mas comúnmente para la transferencia de control es la instrucción de JMP. Un salto es incondicional, ya que la operación transfiere el control bajo cualquier circunstancia.

Una operación JMP dentro del mismo segmento puede ser corta o cercana. En su primer paso por un programa fuente, el ensamblador genera la longitud de cada una de las instrucciones. Sin embargo, una instrucción JMP puede ser de dos o tres bytes de longitud. Este tipo de operaciones al ir a una etiqueta dentro de -128 a +127 bytes , se considera un salto corto.

Instrucción LOOP 

Esta instrucción requiere de un valor inicial en el registro CX. En cada iteracion, LOOP de forma automática disminuye 1 de CX. Si el valor en el registro CX es cero, el control pasa a la instrucción siguiente; sino es así y CX no es igual a cero, el control pasa a la dirección del operando. La distancia debe ser un salto corto, desde -128 hasta +127 bytes. Para una operación que exceda este limite, el ensamblador envía un mensaje como "salto relativo fuera de rango".

Tabla de las instrucciones LOOP

Instrucciones de salto condicional

El ensamblador permite usar una variedad de instrucciones de salto condicional que transfiere el control dependiendo de las configuraciones en el registro de banderas. Por ejemplo, puede comparar dos campos y después saltar de acuerdo con los valores de las banderas que la comparación establece.

Finalmente, agregare un sitio de consulta en donde viene un gran catalogo de todas las instrucciones condicionales que podemos encontrar en ensamblador y una breve explicación de cada una de ellas y como se utilizan.

Ejemplo de algunas instrucciones condicionales:

• JE. Salto si es equivalente a lo que se compara
• JG. Salto si es mas grande a su comparación
• JGE. Salto si es mas grande o igual a su compacidad.
• JL. Salgo si es menor a lo que se compara.

Salto condicional con banderas

Tabla de saltos condicionales con parámetros dentro de la sintaxis

Uso de Banderas en ensamblador

Las banderas son aquellas que registran el estado del procesador, normalmente asociado a una comparación o a una instrucción aritmética. Las banderas del procesador 8086 son:

CF: Bandera de acareo.
OF: Bandera de desbordamiento (aritmético).
ZF: Bandera de resultado 0 o comparación igual.
SF: Bandera de resultado o comparación negativa.
PF: Bandera de paridad (número par de bits).
AF: Bandera auxiliar. Indica si hay necesidad de ajuste en las operaciones aritméticas con números
BCD.

Banderas de control:
DF: Bandera de dirección. Controla la dirección de las operaciones con cadenas de caracteres
incrementando o decrementando automáticamente los registros índices (SI y DI)
IF: Bandera de interrupciones. Indica si están permitidas o no las interrupciones de los dispositivos
externos.
TF: Bandera de atrape. Controla la operación de modo paso a paso (usada por el programa DEBUG).

Veamos algunos ejemplos:

Para activar la bandera CF haremos una suma, una suma entre 2 numeros, en este caso 255 + 1, de manera que supere el limite del registro inferior.


Codigo:


.model small

.stack

.data

.code

mov al,255

mov bl,1

add al,bl


.exit




end




La bandera ZF sirve para indicar que el valor del resultado es cero:


Codigo:


.model small

.stack

.data

.code

mov al,2

mov bl,2

sub al,bl


.exit

end







En el caso de SF esta se encedera al obtener un resultado negativo en los registros:


Codigo:


.model small .stack .data .code mov al,1 mov bl,2 sub al,bl .exit end

Programas con librerias

Compara la edad de una persona y regresa si eres mayor de edad o no

Codigo:

.model small

.stack

.data                        

include "emu8086.inc"            

num1 db 0; variable para la edad

.code

inicio proc far

    

    ;poner el primer letrero

    print " Ingrese su edad: "

    

    ;lectura del valor

    call scan_num

    mov num1,cl

    

    ;lectura segundo valor

    

    xor ax,ax

    mov al,num1

    cmp al,18d ;Si lo que se encuentra en al>18 

    JGE mayor ;salta a mayor

    JMP menor ;sino ve a menor  

    

    mayor:

        printn " "

        print "Eres mayor de edad"

        jmp final

    menor:

        printn " "

        print "Eres menor de edad"

               

        jmp final

           

           

    final:  

         print " "

         printn " "

         print "Presiona enter para salir..."

         mov ah,0 ;servicios de lectura de una pulsación de teclado

         int 16h  ;Invoca a servicios de teclado

         mov ah,4ch

         int 21h

         ret

define_print_string

define_print_num

define_print_num_uns

define_scan_num

endp inicio

end

Compara la calificacion de un alumno y le dice si esta reprobado o aprovado

Codigo:

.MODEL SMALL

.STACK 64

.DATA  

    include "emu8086.inc"

    

    nota db 0

    

.CODE   

OPERACIONES PROC FAR ;DECLARACION DE PROCEDIMIENTO    

 

    ;MUESTRO EL MENSAJE         

    print " "

    print "Ingrese la calificacion: "

    

    call scan_num    ;Leo el numero

    mov nota,cl      ;lo guardo en nota

    

    xor ax,ax        ;borro el contenido de ax

    mov al,nota      ;muevo nota a al

    

    CMP AL,70d       ;comparo al con 70

    JGE MAYOR        ;si es mayor o igual pasa a mayor

    JMP MENOR        ;si no a menor

        

   MAYOR:

    printn " "    

    print "Aprobado"

    JMP SALIR 

        

   MENOR:   

    printn " "    

    print "Reprobado"

    JMP SALIR

    

   SALIR:

         print " "

         printn " "

         gotoxy 10,10  ;coloco el cursor en las coordenadas 10x,10y

         print "Presiona enter para salir..." ;imprimo despues este mensaje

         mov ah,0  ;servicio de lectura de pulsacion de tecla

         int 16h   ;invoca servicios de teclado

         mov ah,4ch

         int 21h

         ret

       

OPERACIONES ENDP   

define_print_string

define_print_num

define_print_num_uns

define_scan_num    

    

END

Desplegado de mensajes en el monitor

Para poder desplegar los mensajes en lenguaje ensamblador es preciso conocer primero la estructura del lenguaje ensamblador, la cual es:


◘ Palabras reservadas:

• PAGE: designa el número máximo de líneas para listar en una página y el número máximo de caracteres en una línea.
• TITLE: para hacer que un título en un programa se imprima en la línea 2 de cada página en el listado del programa.
• SEGMENTS Y ENDS
• ASSUME

◘ Identificadores: nombre que se le da a algunos elementos del programa.
◘ Operación.
◘ Operando.

Todos los gráficos y el texto que se muestran en el monitor se escriben en la RAM de visualización de video, para después enviarlos al monitor mediante el controlador de video. El controlador de video es en sí un microprocesador de propósito especial, que libera a la CPU principal del trabajo de controlar el hardware de video.

Un monitor de pantalla de cristal líquido (LCD) digital directo recibe un flujo de bits digitales directamente desde el controlador de video, y no requiere del barrido de trama.

Proceso de ensamblado y ligado

Pasos para llevar a cabo el proceso:

1. El programa utiliza un editor de texto para crear un archivo de texto ASCII, conocido como archivo de código fuente.

2. El ensamblador lee el archivo de código fuente y produce un archivo de código objeto, una traducción del programa a lenguaje máquina. De manera opcional, produce un archivo de listado. Si ocurre un error, el programador debe regresar al paso 1 y corregir el programa.

3. El enlazador lee el archivo de código objeto y verifica si el programa contiene alguna llamada a los procedimientos en una biblioteca de enlace. El enlazador copia cualquier procedimiento requerido de la biblioteca de enlace, lo combina con el archivo de código objeto y produce el archivo ejecutable. De manera opcional, el enlazador puede producir un archivo de mapa.

4. La herramienta cargador (loader) del sistema operativo lee el archivo ejecutable y lo carga en memoria, y bifurca la CPU hacia la dirección inicial del programa, para que éste empiece a ejecutarse.

Modos de direccionamiento

Los modos de direccionamiento son las diferentes maneras de especificar un operando dentro de una instrucción en lenguaje ensamblador. Un modo de direccionamiento especifica la forma de calcular la dirección de memoria efectiva de un operando mediante el uso de la información contenida en registros y/o constantes, contenida dentro de una instrucción de la máquina o en otra parte.

Diferentes arquitecturas de computadores varían mucho en cuanto al número de modos de direccionamiento que ofrecen desde el hardware. Eliminar los modos de direccionamiento más complejos podría presentar una serie de beneficios, aunque podría requerir de instrucciones adicionales, e incluso de otro registro. Se ha comprobado que el diseño de CPUs segmentadas es mucho más fácil si los únicos modos de direccionamiento que proporcionan son simples.

La mayoría de las máquinas RISC disponen de apenas cinco modos de direccionamiento simple, mientras que otras máquinas CISC tales como el DEC VAX tienen más de una docena de modos de direccionamiento, algunos de ellos demasiado complejos. El mainframe IBM System/360 disponía únicamente de tres modos de direccionamiento; algunos más fueron añadidos posteriormente para el System/390.

Cuando existen solo unos cuantos modos, estos van codificados directamente dentro de la propia instrucción (Un ejemplo lo podemos encontrar en el IBM/390, y en la mayoría de los RISC). Sin embargo, cuando hay demasiados modos, a menudo suele reservarse un campo específico en la propia instrucción, para especificar dicho modo de direccionamiento. El DEC VAX permitía múltiples operandos en memoria en la mayoría de sus instrucciones, y reservaba los primeros bits de cada operando para indicar el modo de direccionamiento de ese operando en particular.

Tipos de direccionamiento

◘ Implícito: En este modo de direccionamiento no es necesario poner ninguna dirección de forma explícita, ya que en el propio código de operación se conoce la dirección de el/los operando/s al (a los) que se desea acceder o con el/los que se quiere operar.

Supongamos una arquitectura de pila, las operaciones aritméticas no requieren direccionamiento explícito por lo que se ponen como: - add - sub ...Porque cuando se opera con dos datos en esta arquitectura se sabe que son los dos elementos del tope de la pila. Ejemplo de una pila

1 2 3 4 5 6 <- pila top() es 1 ntop() es 2
Donde top() representa el tope de la pila y ntop() el siguiente al tope de la pila y son estos argumentos con los que se opera al llamar a una orden en concreto.

◘ Inmediato: En la instrucción está incluido directamente el operando.

En este modo el operando es especificado en la instrucción misma. En otras palabras, una instrucción de modo inmediato tiene un campo de operando en vez de un campo de dirección. El campo del operando contiene el operando actual que se debe utilizar en conjunto con la operación especificada en la instrucción. Las instrucciones de modo inmediato son útiles para inicializar los registros en un valor constante.

Cuando el campo de dirección especifica un registro del procesador, la instrucción se dice que está en el modo de registro. Su valor es fijo, por lo que se suele utilizar en operaciones aritméticas o para definir constantes y variables. Como ventaja, no se requiere acceso adicional a memoria para obtener el dato, pero el tamaño del operando está limitado por el tamaño del campo de direccionamiento.

Las desventajas principales son que el valor del dato es constante y el rango de valores que se pueden representar está limitado por el tamaño de este operando.

◘ Directo: El campo de operando en la instrucción contiene la dirección en memoria donde se encuentra el operando.
En este modo la dirección efectiva es igual a la parte de dirección de la instrucción. El operando reside en la memoria y su dirección es dada directamente por el campo de dirección de la instrucción. En una instrucción de tipo ramificación el campo de dirección especifica la dirección de la rama actual.

Indirecto: El campo de operando contiene una dirección de memoria, en la que se encuentra la dirección efectiva del operando.
Si hace referencia a un registro de la máquina, la dirección de memoria (dirección efectiva) que contiene el dato estará en este registro y hablaremos de direccionamiento indirecto a registro; si hace referencia a una posición de memoria, la dirección de memoria (dirección efectiva) que contiene el dato estará almacenada en esta posición de memoria y hablaremos de direccionamiento indirecto a memoria.

La desventaja principal de este modo de direccionamiento es que necesita un acceso más a memoria que el directo. Es decir, un acceso a memoria para el direccionamiento indirecto a registro y dos accesos a memoria para el direccionamiento indirecto a memoria; por este motivo este segundo modo de direccionamiento no se implementa en la mayoría de las máquinas

◘ Absoluto: El campo de operando contiene una dirección en memoria, en la que se encuentra la instrucción. Y no se cancela.

◘ De registro: Sirve para especificar operandos que están en registros. En este modo, los operandos están en registros que residen dentro de la CPU.

◘ Indirecto mediante registros:El campo de operando de la instrucción contiene un identificador de registro en el que se encuentra la dirección efectiva del operando.

En este modo el campo de la dirección de la instrucción da la dirección en donde la dirección efectiva se almacena en la memoria. El control localiza la instrucción de la memoria y utiliza su parte de dirección para acceder a la memoria de nuevo para leer una dirección efectiva. Unos pocos modos de direccionamiento requieren que el campo de dirección de la instrucción sea sumado al control de un registro especificado en el procesador. La dirección efectiva en este modo se obtiene del siguiente cálculo:

         Dir. efectiva = Dir. de la parte de la instrucción + Contenido del registro del procesador.

◘ De desplazamiento:Combina el modo directo e indirecto mediante registros.

◘ De pila:Se utiliza cuando el operando está en memoria y en la cabecera de la pila.
Este direccionamiento se basa en las estructuras denominadas Pila (tipo LIFO), las cuales están marcados por el fondo de la pila y el puntero de pila (*SP). El puntero de pila apunta a la última posición ocupada. Así, como puntero de direccionamiento usaremos el SP.

El desplazamiento más el valor del SP nos dará la dirección del objeto al que queramos hacer referencia. En ocasiones, si no existe C. de desplazamiento solo se trabajara con la cima de la pila. Como es un modo de direccionamiento implícito, solo se utiliza en instrucciones determinadas, las más habituales de las cuales son PUSH (poner un elemento en la pila) y POP (sacar un elemento de la pila).

Este tipo de direccionamiento nos aporta flexibilidad pero por el contrario, es mucho más complejo que otros tipos estudiados más arriba.

◘ Relativo a un registro base:Consiste, al igual que el indirecto a través de registro, en calcular la dirección efectiva (EA, effective address) como la suma del contenido del registro base y un cierto desplazamiento (offset) que siempre será positivo. Esta técnica permite códigos reentrantes y acceder de forma fácil y rápida a posiciones cercanas de memoria.

Este modo de direccionamiento es muy usado por los ensambladores cuando se llaman a las funciones (para acceder a los parámetros almacenados en la pila).

◘ Relativo a un registro índice:Es similar al direccionamiento relativo a un registro base, excepto que es el contenido del registro índice el que indica el desplazamiento que se produce a partir de una dirección de memoria que se pasa también como argumento a la orden que utiliza este modo de direccionamiento. Aunque en esencia son dos modos equivalentes. La EA se calcula como la suma del contenido del registro índice y una dirección de memoria.

◘ Indexado respecto a una base:Se trata de una combinación de los dos anteriores y consiste en calcular la dirección efectiva como:

• Relativo al contador de programa:Consiste en dirección una posición de memoria usando como registro base al contador de programa (PC), el funcionamiento es análogo al direccionamiento respecto a registro base con la salvedad de que, en este caso, el offset puede ser también negativo.

• Indexado con autoincremento/autodecremento:Es un modo de direccionamiento análogo al indexado, explicado anteriormente.

La única diferencia es que permite un incremento o decremento de la dirección final o el registro índice según los siguientes casos:

• Indexado con autopreincremento:Incrementa el registro índice primero (se incrementa un valor, según el tamaño del objeto direccionado) y luego calcula la EA al igual que el direccionamiento indexado.
• Indexado con autoposincremento: Calcula la dirección efectiva y después incrementa esta.
• Indexado con autopredecremento: Decrementa el registro índice y después calcula la dirección efectiva.
• Indexado con autoposdecremento: Calcula la dirección efectiva y después decrementa esta.

◘ Instrucción de salto con direccionamiento absoluto: Consiste en cargar en el PC el valor que se especifica, por ¿ejemplo: jmp 0xAB ----> Carga 0xAB en PC.

◘ Instrucción de salto con direccionamiento relativo:Es parecida a la especificada anteriormente la diferencia es que el salto es relativo al PC

Ejemplo:supongamos que PC vale = 0x0A, si nosotros interpretamos la instrucción jr +03, saltaremos tres posiciones posteriores a PC (también podría ser -03 y serían posiciones anteriores). Pero, ¡cuidado! si esa instrucción estaba en la posición 0x0A la dirección de PC a incrementar será la inmediatamente posterior (ya que PC se incrementa automáticamente después de leer la instrucción), por lo que quedaría:
       PC = 0x0B ---> nuevo PC = 0x0B+0x03 = 0x0E, con lo que el PC quedaría como 0x0E.

◘ Direccionamiento paginado: En el paginado la memoria se encuentra actualmente dividida en páginas (bloques de igual longitud). Para obtener las direcciones se necesita:

• Indicador de página (IP):en un registro específico o de propósito general de la máquina.
• Dirección de la palabra (DP):
  en el campo CD de la instrucción.
  
  Así, concatenando ambas partes se obtiene la dirección completa.

El problema viene cuando queremos referenciar un dato al que no podemos acceder de forma relativa (p.e. porque los registros base no puedan alcanzar dicha posición aun con el direccionamiento absoluto. Sin embargo, sólo una pequeña parte de la memoria se puede acceder (64 kilobytes, si el desplazamiento es de 16 bits).

El desplazamiento de 16 bits puede parecer muy pequeño en relación con el tamaño de la memoria de los equipos actuales (esta es la razón por la 80386 se expandió a 32 bits). Podría ser peor ya que: los sevidores IBM System/360 sólo tienen un signo de 12 bits de desplazamiento. Sin embargo, el principio de localización se aplica en un corto espacio de tiempo, la mayoría de los elementos de datos que un programa quiere acceder están bastante cerca uno del otro.

Este modo de direccionamiento está estrechamente relacionado con el modo de direccionamiento absoluto.

Ejemplo 1: Dentro de una subrutina, un programador estará principalmente interesados en los parámetros y las variables en los atributos del objeto actual.