13. Cambiar el color de la pantalla

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: Hola mundo'
            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,01011110b ;color que se modifico
            MOV CX,000H
            MOV DX,484FH
            INT BIOS_10H
            RET
            LIMPIA_PANTALLA ENDP
            
            POSICIONA_CURSOR PROC NEAR
            MOV AH,02 ;Posicion del cursor
            MOV BH,00 ;Pagina en 0,es decir que usara esa pantalla y no otra
            MOV DH,RENGLON ; coordenadas de la pagina por renglon
            MOV DL,COLUMNA ;coordenadas de la pagina por columna
            INT BIOS_10H
            RET
            POSICIONA_CURSOR ENDP
            
        CODIGO ENDS

        END CLSP

12. Impresion de valores numericos (decimales y hexadecimales)

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 XD"

    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

11. Mensaje con Colores

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

10. Conversión de ASCII a Binario (Capturado)

import base64
try:


EQU 13
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 DB 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,0064H,03E8H,2710H,"$"
DATOS ENDS
PILA SEGMENT STACK 'STACK'
    DW 128 DUP('P')
PILA ENDS
CODIGO SEGMENT
    CAPT PROC NEAR
    ASSUME CS:CODIGO,SS:PILA,DS:DATOS
    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

9. Conversión de ASCII a Binario

import base64
try:


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,10,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 CX,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

8. Programa de impresión en hexadecimal

import base64

try:

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,10,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 'STACK'

    DB 64 DUP('0')

PILA ENDS

CODIGO SEGMENT

    CEXA PROC NEAR

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

    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

7. Letras en ASCII a Binario

import base64
try:


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,SS:PILA,DS:DATOS
    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

6. Impresión de un valor binario dado.

import base64
try:

       
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

5. Mensaje en posicion X,Y.

import base64
try:

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: Hola mundo',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

4. Uso de funciones.

import base64
try:



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

3. Programa de calificaciones con emu8086

El siguiente programa analiza la calificación ingresada y muestra si es aprobatoria o reprobatoria.

org 100h

.model small
.stack 64

.data ;seccion de variables
  msg1 db "Dame una calificacion (seguida de un enter):$"
  aprobado db 13,10, "Aprobado$" ;13 es salto de linea y 10 es salto de carro
  reprobado db 13,10, "Reprobado$"
  var1 dw ?,"$" ;variable data write
  var2 dw ?,"$"
  var3 dw ?,"$"
  
.code ;inicia el segmento de codigo

resultado proc far ;declaracion de funcion
    mov ax, @data ;como inicio
    mov ds, ax
;------------desplegar primer mensaje 

    mov ah,09 ;inicio de mensaje
    lea dx,msg1
    int 21h
    
;------------pedir un caracter
    mov ah,01
    int 21h ;parpadea el cursor      
    mov var1,ax 
    
;------------pedir segundo caracter
    mov ah,01
    int 21h ;parpadea el cursor      
    mov var2,ax
    
;------------pedir un caracter
    mov ah,01
    int 21h ;parpadea el cursor      
    mov var3,ax        
    
;------------momento de evaluar
    cmp al,13 ;compara con el enter
    je continue ;salto si se cumple la condicion igual a 13
    jmp mayor 
    
;inicia funcion
continue:
    mov ax, var1 ;valor de var1 se va a reg ax
    cmp al,037h
    jge mayor ;salta si es mayor o igual
    jmp menor ;si no se cumplio se va a funcion menor
    
mayor:
    mov ah,09
    lea dx, aprobado
    int 21h
    jmp salir
    
menor:
    mov ah,09
    lea dx, reprobado
    int 21h
    jmp salir
    
salir:
    mov ax, 4ch
    int 21h
    
resultado endp
end

2. Programa multiplicador 5 y 10 sin libreria emu8086

.data ;segmento Data   

msg db 13,10,"Ingrese el primer numero $"  
msg2 db 13,10,"Ingrese el segundo numero $"    
msg1 db 13,10,"El resultado mult por 10 es :$" 
diez db 10 ;una variable con valor de 10
cinco db 5 ;una variable con valor de 5 
num1 db 0
    
.code ;segmento de codigo del programa  
MOV AX,@DATA
    MOV DS,AX
    ;Para desplegar el mensaje 1: 
    
    MOV AH,09
    lea DX,msg
    int 21h
                  
                 

MOV AH,01
    int 21h  
    mul diez
    aam
    mov ah,02
    int 21h 
    ;MOV num1,AX 
    
MOV AX,@DATA
    MOV DS,AX
    ;Para desplegar el mensaje 2:
    MOV AH,09
    lea DX,msg2
    int 21h
    

MOV AH,01
    int 21h 
    mul cinco
    aam
    mov ah,02
    int 21h    

    end

1. Programa multiplicador 5 y 10 con libreria emu8086

org 100h

include 'emu8086.inc'

.data

numeros db 2 dup (?) ;creacion de un arreglo

cad2 dw ?

msg dw "Multiplicacion por 10: $"

msg2 dw "Multiplicacion por 5: $"

.code

print 'Ingresa el primer numero:'

call scan_num

mov numeros[0],cl

printn ""

print 'Ingresa el segundo numero:'

call scan_num

mov numeros[1],cl

//multi:

xor ax,ax

mov al,numeros[0]

mov bl,10

mul bl

printn ""

mov bx, ax

mov ah,09

lea dx,msg

int 21h

mov ax, bx

printn ""

call PRINT_NUM

xor ax,ax

mov al,numeros[1]

mov bl,5

mul bl

printn ""

mov bx, ax

mov ah,09

lea dx,msg2

int 21h

mov ax, bx

printn ""

call PRINT_NUM

ret

define_print_num

define_scan_num

define_print_num_uns

define_print_string

define_get_string

end

Lenguaje Ensamblador Del Microprocesador (Resumen)

La CPU x86 tiene 14 registros internos y básicos. Algunos son realmente de 32 bits pero por ahora se utilizará el modo real que es compatible con el procesador 8086 (igualmente accesibles a la parte alta de éstos registros, inclusive en el modo real). Los registros son los siguientes (estos registros son de 16 bits nombrados de la siguiente manera, a excepción del registro de banderas).

Registros de uso general:

• AX: Acumulador (AL:AH)
• BX: Registro base (BL:BH)
• CX: Registro contador (CL:CH)
• DX: Registro de datos (DL:DH)

Un registro es un espacio de almacenamiento disponible para el CPU. Una de las principales características de estos, es que pueden ser accedidos más rápido que cualquier otro dispositivo de almacenamiento de una computadora. Los procesadores x86 cuentan con una serie de registros disponibles para utilizar como almacenamiento temporal para variables, valores y demás información que utilizan durante la ejecución de instrucciones como así también punteros a secciones de memoria como la pila. Podemos mencionar 4 categorías diferentes:

• Registros generales
• Segmentos de registros
• Flags (banderas de estado)
• Instruction Pointer (IP), puntero a la próxima instrucción a ejecutar

Registros Generales

Normalmente, los registros generales almacenan datos o direcciones de memoria y son utilizados de manera intercambiable para lograr que se ejecuten las instrucciones del programa.  Algunos de estos registros generales son utilizados para funciones específicas. Por ejemplo, para realizar multiplicaciones o divisiones se utilizan los registros EAX y EBX.


Flags

El registro que nombramos como EFLAG es un registro de estado. En esta arquitectura, tiene una longitud de 32 bits y cada uno de sus bits es una bandera. Según el valor de 0 o 1 de cada bit serán utilizados para controlar las operaciones de la CPU luego de la ejecución de una instrucción. Entre los registros más importantes para remarcar en relación al análisis de malware podemos enumerar:

• ZF (Zero Flag): Cero. Esta bandera se activa cuando el resultado de la operación es cero.
• CF (Carry Flag): cuando ha ocurrido un “llevar” o “pedir préstamo” del resultado (8 o16 bits)
• SF (Sign Flag): Según si el resultado de una operación es un valor positivo o negativo. Si el valor es positivos se queda en cero y es uno en caso contrario.
• PF (Paridad): Cuando esta bandera está activa, el resultado de la operación tiene un número par de unos.

Las instrucciones se pueden clasificar en los siguientes grupos:

• Transferencia de datos (MOV, IN, OUT, PUSH, POP)
• Control de Bucles (sin fin, conteo, hasta, mientras)
• Prueba, Comparación y Saltos (JMP)
• Llamado y Retorno de Subrutinas
• Aritmeticas (ADD, SUB, MUL, DIV)
• Logicas (NOT, AND, OR)
• Desplazamiento y Rotación (ROL,SHL)
• Pila (PUSH, POP)
• Control del Microprocesador (NOP, HLT)
• Interrupción (STI, CLI, INT)
• Otras instrucciones

Con los saltos condicionales y no condicionales se pueden crear estructuras de iteración bastante complejas, aunque existen instrucciones específicas para ello tal como loop.
Los 2 registros usados para la dirección de la instrucción son el IP y el CS. Se combinan en una forma especial para generar la dirección de 20 bits.


Programacion en el Lenguaje Ensamblador


Los archivos deben terminar con la extensión “ASM”. Las letras minúsculas trabajan igual que las mayúsculas, pero durante el presente trabajo se utilizarán mayúsculas para evitar confusión entre el número 1 y la minúscula l, el 0 (cero) y la letra O.

El ensamblador puede usar archivos fuente que contengan caracteres ASCII estándar. Considere que no todos los procesadores de texto escriben archivos en disco usando solamente los caracteres ASCII estándar. Antes de ensamblar un programa verifique que esté en código ASCII.