miércoles, 27 de febrero de 2019

LIBRERIA EMU8086

USO DE LA LIBERIA emu8086


emu8086.inc define las siguientes macros :

PRINT string - macro con 1 parámetro, imprime una cadena.PRINTN string - macro con 1 parámetro, imprime una cadena. Lo mismo que PRINT pero agrega automáticamente "retorno de carro" al final de la cadena.PUTC char - macro con 1 parámetro, imprime un carácter ASCII en la posición actual del cursor.GOTOXY col, fila - macro con 2 parámetros, establece la posición del cursor.CURSOROFF - apaga el cursor de texto.CURSORON - enciende el cursor de texto.

emu8086.inc también define los siguientes procedimientos :


PRINT_NUM : procedimiento que imprime un número firmado en el registro AX . Para usarlo declare: DEFINE_PRINT_NUM y DEFINE_PRINT_NUM_UNS antes de la directiva END .
PRINT_NUM_UNS : procedimiento que imprime un número sin firma en el registro AX . Para usarlo declare: DEFINE_PRINT_NUM_UNS antes de la directiva END.
GET_STRING : procedimiento para obtener una cadena terminada en nulo de un usuario, la cadena recibida se escribe en el búfer en DS: DI , el tamaño del búfer debe estar en DX . El procedimiento detiene la entrada cuando se presiona 'Enter'. Para usarlo declare: DEFINE_GET_STRING antes de la directiva END .

PRINT_STRING : procedimiento para imprimir una cadena terminada en nulo en la posición actual del cursor, recibe la dirección de la cadena en el registro DS: SI . Para usarlo declare: DEFINE_PRINT_STRING antes de la directiva END .
SCAN_NUM : procedimiento que obtiene el número FIRMADO de varios dígitos del teclado y almacena el resultado en el registro CX . Para usarlo declare: DEFINE_SCAN_NUM antes de la directiva END .

Codigo que muestra un hola mundo

include emu8086.inc
org 100h
PRINT  'HOLA MUNDO'
GOTOXY 10,5
PUTC 65 ; 65 es un codigo ascii para 'A'
PUTC 'B'
RET ;REGRESO AL SISTEMA OP
END ;DIRECTIVA PARA DETENER EL COMPI

Salida del programa


Codigo que pide tu nombre y muestra un mensaje de saludo

;get string y print_string
include 'emu8086.inc' 
org 100h 

lea SI, msg1  ;configurar puntero (SI) a msg
              ;pedir el numero

call print_string ;imprime el mensaje que apunta SI

lea  DI, buffer ;configura el puntero (DI) para el buffer de entrada
mov  DX, bufSize ;esteble el tamano del buffer
call get_string  ;obtener el nombre y ponerlo en el buffer

lea  SI , newIn ;punto a CR/LF hola mundo
call print_string ;mensaje impreso que apunta SI
ret  ;retorno del sistema    

;data
msg1   db "Ingresa tu nombre " , 0
newIn  db 13,10
       db "Hola "
buffer db 20 dup (0)   ; buffer de entrada para get_string
bufSize = $-buffer ;calcul el tamano del buffer

define_get_string
define_print_string
end     ;directivo para detener el compilador

Salida del programa

Codigo que pide un numero y muestra un mensaje 

include 'emu8086.inc'
org 100h
lea SI, msg1 ;pide el numero
call print_string
call scan_num ;obtener el numero en cx

mov ax, cx   ;copia el numero a ax

call pthis  ;imprime la sig cadena
DB 13,10, 'Has introducido  el numero: ' , 0
call print_num   ;numero de impresionen ax
ret

msg1 DB 'Ingresa un numero: ', 0

;macros para definir procs 
define_scan_num
define_print_string
define_print_num
define_print_num_uns
define_pthis

end

Salida del programa



APORTES DE NUESTROS COMPAÑEROS:

PROGRAMA "MAYOR O MENOR DE EDAD"
.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  ;llamada al procedimiento de la lib para pedirla
 
    mov num1,cl
   
    ;lectura segundo valor
   

    xor ax,ax  ;xor para limpiar el registro
    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

SALIDA DEL PROGRAMA


PROGRAMA DE SUMA DE DOS NUMEROS
name "suma de dos numeros"
include "emu8086.inc"
org 100h

.data
suma db 2 dup (?) ;,manera de declarar un arreglo de 2 lugrares
.code
sumas proc
    print " Introduce el primer numero: " ;macro de la lib
    call scan_num  ;llamada a un prodecimiento para pedir un numero
    mov suma[0],cl
    printn " "
    print " Introduce el segundo numero: "
    call scan_num  
    mov suma[1],cl
    xor ax,ax      ;xor nemonico que limpia registros
    add al,suma[0] ;valor de suma posicion 0
    add al,suma[1] ;valor de suma posicion 1
    printn " " ;macro de la libreria pone un espacio y retorno
    print " La suma es: " ; macro que imprime un letrero
    call print_num  ;llamada a un procedimiento para imprimir un num del
sumas endp
exit:
    print " "
    printn " "
    print "Presiona enter para salir..."
    mov ah,0  ;servicio de pulsacion de teclado
    int 16h   ;invoca a servicios de taclado
    ret
define_print_string  ;no se uso 
define_print_num ;es del print_num
define_print_num_uns ;conversion decimal a scan_num
define_scan_num ;del scan_num prodedimiento
end  

SALIDA DEL PROGRAMA

PROGRAMA "APROBADO O REPROBADO"
MODEL SMALL
.STACK 64
.DATA 
    include "emu8086.inc"
     
    nota db 0

     
.CODE  
OPERACIONES PROC FAR ;DECLARACION DE PROCEDIMIENTO   
  
    ;MUESTRO EL MENSAJE        
    print " "  ;usa macro print para un espacio
    print "Ingrese la calificacion: "
     
    call scan_num    ;Leo el numero  proc scan_num de la libreria
    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 

SALIDA DEL PROGRAMA



PROGRAMA QUE PIDE UN NUMERO

SALIDA


martes, 26 de febrero de 2019

Programas en EMU8086

Primer hola mundo


Salida del programa

Programa hola mundo

.STACK n sirve para fijar un tamaño n del segmento de pila, por defecto 1K.
.DATA abre el segmento de datos.
.CODE abre el segmento de código, al final código debe aparecer END.

Una vez inicializado los segmento se permite usar los símbolos @CODE y @DATA en lugar del
nombre de los segmentos de código y datos respectivamente.
Justo después de la directiva .CODE hay que inicializar el segmento de datos (ya que la directiva
no genera código):
MOV AX, @DATA
MOV DS, AX


Salida del programa:


Suma de un numero

Los numero se declaran dentro del programa y estos serán 5 y 3 después de la suma se hará un incremento en esa suma entonces: 5+3=8 a 8 se le incrementa 1 (inc bx) y despues se le suma el numero 6  entonces sera ahora: 9+6=15
Salida del programa

Incremento de un numero

Salida del programa

Programa que imprime las letra del abecedario



Salida del programa

Programa que imprime un mensaje 

Salida del programa

Suma de dos dígitos ingresados por el usuario


Salida del programa


Resta de dos números ingresados por el usuario

.model small
.stack 64
.data

 n1 db 0
 n2 db 0
 resta db 0
 msg1 db "Dame el primer valor " , '$'
 msg2 db 10,13,"Dame el segundo valor ",'$'
 msg3 db 10,13,"Resta= ",'$'
 .code
 begin proc far       
    ;direccionamos al segmentos de datos
    mov ax,@data
    mov ds,ax
   
    ; primer digito
    mov ah,09
    lea dx, msg1
    int 21h 
 
  ;Se lee el primer valor
    mov ah,01
    int 21h
    add al, 30h ;convierte el caracter en numero
    mov n1,al         
   
    ;Solicitamos el segundo digito
    mov ah,09
    lea dx, msg2
    int 21h
    mov ah,01
    int 21h
    sub al, 30h ; Convierte el caracter en numero
    mov n2,al
   
    ;Operacion
    mov al,n1
    sub al,n2
    sub al,30h ; Convierte a caracter 
    mov resta, al
    mov ah,09
    lea dx,msg3
    int 21h
   
    ;Se imprime el caracter con el servicio 02 de la int 21h
    mov ah,02
    mov dl,resta
    int 21h         
    begin endp
  end

Salida del programa


Division de un numero 100/5

Salida del programa

Programa que compara una calificación y muestra un mensaje de aprobado o reprobado


.model small
.stack 64
.data ;seccion de variables

   msg1 db "Dame una calificacion (seguida de un entero):$"
   aprobado db 13,10, "Aprobado$"
   reprobado db 13,10, "Reprobado$"
   VAR1 dw ?, "$"
   VAR2 dw ?, "$"
   VAR3 dw ?, "$" 

.CODE 
; inicia el segmento de codigo

resultado proc far
    mov ax, @data ; inicio 
    mov ds, ax
    
    ;desplegar primer mensaje
    mov ah, 09
    lea dx, msg1
    int 21h      
    
    ;pedir un caracter
    
    mov ah, 01
    int 21h
    mov VAR1, ax
    
    ;segundo caracter
    mov ah, 01
    int 21h
    mov VAR2, ax 
    
    ;tercer caracter
    mov ah, 01
    int 21h
    mov VAR3, ax
    
    ;evaluar la calficacion
    
    cmp al,13
    JE  CONTINUE  ;SALTA SI ES IGUAL A 13
    ;JGE CONTINUE
    JMP MAYOR
    
    ;INICIA FUNCION
    
CONTINUE: 
    MOV AX, VAR1
    CMP AL,037H  ;7 ES 37 EN ASCII
    JGE MAYOR   ;SALTA SI ES MAYOR A O IGUAL 
    JMP 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, 4C00H
   INT 21H 
   
RESULTADO ENDP
END RESULTADO
       
Salida del programa

Programa que te dice si eres mayor o menor de edad


.model small
.stack 64 

.data
diez db 10 ;variable que se muliplica para obtener decimales
num1 db 0
msg db "Ingrese la edad: $"
msg1 db " Eres mayor de edad $ "
msg2 db " Eres menor de edad $ "

.code   

 inicio proc far
    mov ax, @data ;direccionamos el segmento de datos
    mov ds, ax ;los datos se mueven a ax
    
    ;primer letrero
    mov ah, 09
    lea dx, msg 
    int 21h
    
    mov ah, 01
    int 21h
    sub al, 30h
    mul diez ; se multiplica el numero ingresado para
    ;las decenas
    mov num1, al
    
    mov ah,01
    int 21h
    sub al,30h
    add num1, al
    mov al, num1
    
    cmp al,  18
    jge mayor
    jmp menor
    
             
mayor: 
mov ah, 09  
lea dx, msg1
int 21h
jmp fin
            
menor:
mov ah, 09
lea dx, msg2
int 21h
jmp fin
            
fin:
     MOV AX, 4C00H  
     int 21h
    
inicio endp

ret
    
 Salida  del programa




lunes, 25 de febrero de 2019

ENSAMBLADOR 8086

El lenguaje ensamblador como cualquier lenguaje de programación es un conjunto de palabras
que le indican al ordenador lo que tiene que hacer. Sin embargo la diferencia fundamental es que
cada instrucción escrita en lenguaje ensamblador tiene una correspondencia exacta con una
operación en el procesador. Por lo que son operaciones muy sencillas tales como: “Cargar 32 en
el registro BX” o “Transferir el contenido del registro CL al CH”. Así pues, las palabras del lenguaje
ensamblador son nemotécnicos que representan el código máquina, lenguaje que entiende el
procesador.

Almacenamiento de datos

El 8086/88 usa el formato de almacenamiento denominado “little endian”, esto quiere decir que el
byte menos significativa (LSB) del dato es guardada en la parte baja de la memoria. Por ejemplo
el dato 0x1122 será almacenado en memoria:

Registros de datos

Los registros de datos son de 16 bits, aunque están divididos. lo que permite su acceso en 8 bits.
Estos registros son de propósito general aunque todos tiene alguna función por defecto.
AX (acumulador) se usa para almacenar el resultado de las operaciones, es al único registro con
el que se puede hacer divisiones y multiplicaciones. Puede ser accedido en 8 bits como AH para
la parte alta (HIGH) y AL (LOW) para la parte baja.
BX (registro base) almacena la dirección base para los accesos a memoria. También puede
accederse como BH y BL, parte alta y baja respectivamente.
CX (contador) actúa como contador en los bucles de repetición. CL (parte baja del registro)
almacena el desplazamiento en las operaciones de desplazamiento y rotación de múltiples bits.
DX (datos) es usado para almacenar los datos de las operaciones.

Registros de segmento

Los registros de segmento son de 16 bits (como ya se dicho antes) y contienen el valor de
segmento.
CS (segmento de código) contiene el valor de segmento donde se encuentra el código. Actúa en
conjunción con el registro IP para obtener la dirección de memoria
que contiene la próxima instrucción. Este registro es modificado por las instrucciones de saltos
lejanos.
DS (segmento de datos) contiene el segmento donde están los datos.
ES (segmento extra de datos) es usado para acceder a otro segmento que contiene más datos.
SS (segmento de pila) contiene el valor del segmento donde está la pila. Se usa conjuntamente
con el registro SP para obtener la dirección donde se encuentra el último valor almacenado en la
pila por el procesador.

Registros de índice

Estos registros son usados como índices por algunas instrucciones. También pueden ser usados
como operandos (excepto el registro IP).
IP (índice de programa) almacena el desplazamiento dentro del segmento de código. Este registro
junto al registro CS apunta a la dirección de la próxima instrucción. No puede ser usado como
operando en operaciones aritmético/lógicas.
SI (índice de origen) almacena el desplazamiento del operando de origen en memoria en algunos
tipos de operaciones (operaciones con operandos en memoria).
DI (índice de destino) almacena el desplazamiento del operando de destino en memoria en
algunos tipos de operaciones (operaciones con operandos en memoria).
SP (índice de pila) almacena el desplazamiento dentro del segmento de pila, y apunta al último
elemento introducido en la pila. Se usa conjuntamente con el registro SS.
BP (índice de base) se usa para almacenar desplazamiento en los distintos segmentos. Por
defecto es el segmento de la pila.

Registro de estados

El registro de estado contiene una serie de banderas que indican distintas situaciones en las que
se encuentra el procesador.
OF (desbordamiento) es el principal indicador de error producido durante las operaciones con
signo. Vale 1 cuando:
* La suma de dos números con igual signo o la resta de dos números con signo opuesto
producen un resultado que no se puede guardar (más de 16 bits).
* El bit más significativo (el signo) del operando ha cambiado durante una operación de
desplazamiento aritmético.
* El resultado de una de una operación de división produce un cociente que no cabe en el registro de resultado
DF (dirección en operaciones con cadenas) si es 1 el sentido de recorrido de la cadena es de
izquierda a derecha, si es 0 irá en sentido contrario.
IF (indicador de interrupción) cuando vale 1 permite al procesador reconocer interrupciones. Si se
pone a 0 el procesador ignorará las solicitudes de interrupción.
TF (modo traza) indica al procesador que la ejecución es paso a paso. Se usa en la fase de
depuración.
SF (indicador de signo) solo tiene sentido en las operaciones con signo. Vale 1 cuando en una de
estas operaciones el signo del resultado es negativo.
ZF (indicador de cero) vale 1 cuando el resultado de una operación es cero.
AF (acarreo auxiliar) vale 1 cuando se produce acarreo o acarreo negativo en el bit 3.
PF (paridad) vale 1 si el resultado de la operación tiene como resultado un número con un número
par de bits a 1. Se usa principalmente en transmisión de datos.
CF (bit de acarreo) vale 1 si se produce acarreo en una operación de suma, o acarreo negativo en
una operación de resta. Contiene el bit que ha sido desplazado o rotado fuera de un registro o
posición de memoria. Refleja el resultado de una comparación.

Instrucciones de tranferencias de datos

Las instrucciones de transferencia de datos copian datos de un sitio a otro y son: MOV, XCHG,
XLAT, LEA, LDS, LES, LAHF, SAHF, PUSH, PUSHF, POP, POPF.

MOV realiza la transferencia de datos del operando de origen al destino. MOV admite todos los tipos de direccionamiento.
Ambos operandos deben ser del mismo tamaño y no pueden estar ambos en memoria.

XCHG realiza el intercambio entre los valores de los operandos. Puede tener operando en

registros y en memoria:
XLAT carga en AL el contenido de la dirección apuntada por [BX+AL].

Ejemplo:
LEA carga en un registro especificado la dirección efectiva especificada como en el operando
origen:
LEA reg, mem

Ejemplos:
para este tipo de acceso (el del segundo ejemplo) la instrucción LEA es mas eficiente, que con la
instrucción MOV e instrucciones de multiplicación.

PUSH y POP realizan las operaciones de apilado y desapilado en la pila del procesador
respectivamente, admiten todos los tipos de direccionamiento (excepto inmediato). Los operandos
deben ser siempre de 16 bits.
PUSH reg
PUSH mem
PUSH seg-reg
POP reg
POP mem

POP seg-reg


PUSHF y POPF apila y desapila el registro de estado, respectivamente.
LAHF carga la parte baja del registro de estado en AH.
SAHF carga AH en el la parte baja del registro de estado.

Saltos condicionales

Estas instrucciones realizan el salto a la dirección especificada en función
de si se cumple o no una condición. Para evaluar la condición se considera el registro de estado,

esto quiere decir que la condición depende directamente de la instrucción anterior.

Bucles

Las instrucciones de bucle se usan para realizar estructuras repetitivas, y utilizan el registro CX
como contador.
LOOP esta instrucción hace que el programa salte a la dirección especificada (salto dentro del
segmento), mientras que CX sea distinto de 0 y decrementa CX en 1 cada vez.
LOOP salto

Directivas

Las directivas más comunes son:
Las directivas simplificadas se utilizan para la definición de segmentos.
.MODEL para usar las directivas simplificadas es necesario incluir esta directiva que define el
modelo de memoria que debe usarse. Algunos de los argumentos que puede tomar son:
TINY: para programa con un solo segmento para datos y código (tipo .COM)
SMALL: para programas con un solo segmento de datos (64K, incluida la pila) y otro de
código (64K).
LARGE: varios segmentos de datos y código (1Mb para cada uno).
MEDIUM: Varios segmentos de código y 1 de datos.

COMPACT: 1 segmento de código y varios de datos.

.STACK n sirve para fijar un tamaño n del segmento de pila, por defecto 1K.
.DATA abre el segmento de datos.

.CODE abre el segmento de código, al final código debe aparecer END.

Una vez inicializado los segmento se permite usar los símbolos @CODE y @DATA en lugar del nombre de los segmentos de código y datos respectivamente.

Justo después de la directiva .CODE hay que inicializar el segmento de datos (ya que la directiva
no genera código):
MOV AX, @DATA

MOV DS, AX



Unidad 3 -Unidad 4

Unidad 3 Modularizacion Programación modular Los avances en la programación de computadoras han permitido crear hermosas y grandes aplic...