Calcula el promedio de tres materias

name "calcula el promedio de tres materias"
include "emu8086.inc"
org 100h

.data
pro db 4 dup (?) 

.code
promedio proc
    printn "" 
    print "introduce una calificacion: "
    call scan_num 
    mov pro[0],cl
    printn ""
    print "introduce la 2da calificacion: "
    call scan_num
    mov pro[1],cl
    printn ""
    print "introduce la 3ra calificacion: "
    call scan_num
    mov pro[2],cl
    printn ""
    print "numero de materias: "
    call scan_num
    mov pro[3],cl
    xor ax,ax
    add al,pro[0]
    add al,pro[1]
    add al,pro[2]
    div pro[3]
    printn ""
    print "promedio es= "
    call print_num
     
promedio endp

exit:
    printn ""
    printn ""
    print "presione para salir..."
    mov ah,0
    int 16h
    ret
define_print_string
define_print_num
define_print_num_uns
define_scan_num

end

Resta de dos numeros libreria emu8086.inc

 ;creado por Yulissa Muraira Primero
name 'resta dos numeros'
include 'emu8086.inc'
org 100h

.data
resta db 2 dup (?)

.code
restas proc
    print " " ;usa macro de la lib, un espacio en blanco
    print "Introduce el primer numero: "  ;usa macro print
    call scan_num;uso del procedimiento scan_num de lib
    mov resta[0],cl;guarda el valor en el arreglo
    printn " ";usa macro print
    printn " ";usa macro print
    print " Introduce el segundo numero: ";
    call scan_num ;usop del procedimiento scan_num
    sub resta[1],cl
    xor ax,ax      ;limpia el reg az
    add al,resta[0]
    add al, resta[1]
    printn " "
    printn " "
    print " La resta es==> "
    call print_num
restas endp

exit:
    print " "
    printn " "
    printn " "
    print " Presiona cualquier letra o enter para salir..."
    mov ah,0
    int 16h
    ret
    define_print_string
    define_print_num
    define_print_num_uns
    define_scan_num    ;usa el procedimiento scan_num
end



ret

name "suma de dos numeros"
include "emu8086.inc"
org 100h

.data
suma db 2 dup (?);declaramos un arreglo de tamaño dos
.code
sumas proc Far
    print " Introduce el primer numero: " ;uso de la macro p´rint de la libreria
    call scan_num  ;uso del procedimiento Scan_num
    mov suma[0],cl
    printn " ";macro que imprime un string y su retorno de carro
    print " Introduce el segundo numero: " ;macro print
    call scan_num ;procedimiento scan_num
    mov suma[1],cl
    xor ax,ax ;limpiar el registro ax
    add al,suma[0]
    add al,suma[1]
    printn " "
    print " La suma es: "
    call print_num ;usa un procedimiento de la macro para imprimir un numero en ax
sumas endp
exit:
    print " "
    printn " "
    print "Presiona enter para salir..."
    mov ah,0  ;servicio de pulsación de teclado
    int 16h   ;invoca a servicios de taclado
    ret
;define_print_string
define_print_num ;viene del uso del procedimeinto print_num
define_print_num_uns      ; por usa un num dec
define_scan_num  ;uso del proc_scan_num
end

Registro de banderas

De los 16 bits del registro de banderas, nueve son comunes a toda la familia de procesadores 8086, y sirven para indicar el estado actual de la maquina y el resultado del procesamiento. Muchas instrucciones que piden comparaciones y aritmética cambian el estado de las banderas, algunas cuyas instrucciones pueden realizar pruebas para determinar la acción subsecuente. En resumen, los bits de las banderas comunes son como sigue:

OF (Overflow, desbordamiento). Indica desbordamiento de un bit de orden alto (mas a la izquierda) después de una operación aritmética.

DF (dirección). Designa la dirección hacia la izquierda o hacia la derecha para mover o comparar cadenas de caracteres.

IF (interrupción). Indica que una interrupción externa, como la entrada desde el teclado, sea procesada o ignorada.

TF (trampa). Permite la operación del procesador en modo de un paso. Los programas depuradores, como el DEBUG, activan esta bandera de manera que usted pueda avanzar en la ejecución de una sola instrucción a un tiempo, para examinar el efecto de esa instrucción sobre los registros de memoria.

SF (signo). Contiene el signo resultante de una operación aritmética (0 = positivo y 1 = negativo).

ZF (cero). Indica el resultado de una operación aritmética o de comparación (0 = resultado diferente de cero y 1 = resultado igual a cero).

AF (acarreo auxiliar). Contiene un acarreo externo del bit 3 en un dato de 8 bits para aritmética especializada.

PF (paridad). Indica paridad par o impar de una operación en datos de 8 bits de bajo orden (mas a la derecha).

CF (acarreo). Contiene el acarreo de orden mas alto (mas a la izquierda) después de una operación aritmética; también lleva el contenido del ultimo bit en una operación de corrimiento o de rotación.



Ejemplos:

https://www.youtube.com/watch?v=4puXc5S2WOg

Bandera CF(acarreo)

.model small
.stack
.data
 
.code
    mov al,255
    mov bl,1
    add al,bl
     
     
.exit
end

Bandera ZF

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

Bandera SF

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

Bandera OF

 
.model small
.stack
.data
 
.code
    mov al,100
    mov bl,50
    add al,bl
     
     
.exit
end

Mas ejemplos con la libreria emu8086.inc

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

include emu8086.inc ORG 100h PRINT 'Hola mundo!' GOTOXY 10, 5 PUTC 65 ; 65 - es un código ASCII para 'A' PUTC 'B' RET ; Regreso al sistema operativo. END ; Directiva para detener el compilador.

--------------------------------------------------------------------

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

; demonstrate get_string and print_string ;---------------------------------------- include 'emu8086.inc' ORG 100h LEA SI, msg1 ; set up pointer (SI) to msg ; to ask for the number CALL print_string ; print message that SI points to LEA DI, buffer ; set up pointer (DI) to input buffer MOV DX, bufSize ; set size of buffer CALL get_string ; get name & put in buffer LEA SI, newln ; point at CR/LF / Hello message CALL print_string ; print message that SI points to RET ; return to operating system. ; data msg1 DB "Enter your name: ", 0 newln DB 13, 10 DB "Hello, " buffer DB 20 DUP (0) ; input buffer for get_string bufSize = $-buffer ; calculates size of buffer DEFINE_GET_STRING DEFINE_PRINT_STRING END ; directive to stop the compiler.

---------------------------------------------------------------------------------

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

; demonstrate scan_num, print_num, pthis ;---------------------------------------- include 'emu8086.inc' ORG 100h LEA SI, msg1 ; ask for the number CALL print_string ; CALL scan_num ; get number in CX. MOV AX, CX ; copy the number to AX. ; print the following string: CALL pthis DB 13, 10, 'You have entered: ', 0 CALL print_num ; print number in AX. RET ; return to operating system. ; data msg1 DB 'Enter the number: ', 0 ; macros to define procs DEFINE_SCAN_NUM DEFINE_PRINT_STRING DEFINE_PRINT_NUM DEFINE_PRINT_NUM_UNS ; required for print_num. DEFINE_PTHIS END ; directive to stop the compiler.

http://jbwyatt.com/253/emu/asm_tutorial_05.html

lib include emu8086

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77

name "Hola mundo" include 'emu8086.inc' org 100h .code gotoxy 6,10 print " " print "Hola mundo" gotoxy 6,12 print " " printn "Hola mundo2" gotoxy 6,14 print " " print "letrero fin" gotoxy 6,16 putc "A" gotoxy 6,18 print " " print "dame un numero" call print_string DEFINE_PRINT_STRING call scan_num define_scan_num END ret

Ejemplos con la libreria emu8086

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

name "Hola mundo" include 'emu8086.inc' org 100h .code ;gotoxy 6,10 ;usando la macro de la librería printn " " ;macro que imprime una tarea print "Hola mundo" ret

Examen unidad 1 Lenguajes de Interfaz

Humberto Pérez Cruz
ISC
#Control: 16260648



1.1 Importancia de la programación en lenguaje ensamblador.

El lenguaje ensamblador es un tipo de lenguaje de bajo nivel utilizado para escribir programas informáticos, y constituye la representación más directa del código máquina específico para cada arquitectura de microprocesador.

La importancia del lenguaje ensamblador es principalmente que se trabaja directamente con el microprocesador; por lo cual se debe de conocer el funcionamiento interno de este, tiene la ventaja de que en el se puede realizar cualquier tipo de programas que en los lenguajes de alto nivel no lo pueden realizar. Otro punto sería que los programas en ensamblador ocupan menos espacio en memoria.

• El único lenguaje que entienden los microcontroladores es el código máquina formado por ceros y unos del sistema binario.

• El lenguaje ensamblador expresa las instrucciones de una forma más natural al hombre a la vez que muy cercana al microcontrolador, ya que cada una de esas instrucciones se corresponde con otra en código máquina.

• El lenguaje ensamblador trabaja con nemónicos, que son grupos de caracteres alfanuméricos que simbolizan las órdenes o tareas a realizar.

•La traducción de los nemónicos a código máquina entendible por el microcontrolador la lleva a cabo un programa ensamblador.

• El programa escrito en lenguaje ensamblador se denomina código fuente (*.asm). El programa ensamblador proporciona a partir de este fichero el correspondiente código máquina, que suele tener la extensión *.hex.

 

Ventajas y desventajas del Lenguaje Ensamblador

Ventajas

1.     .- Como trabaja directamente con el microprocesador al ejecutar un programa, pues como este lenguaje es el mas cercano a la máquina la computadora lo procesa mas rápido.

2.     Eficiencia de tamaño .- Un programa en ensamblador no ocupa mucho espacio en memoria porque no tiene que cargan librerías y demás como son los lenguajes de alto nivel

3.     Flexibilidad .- Es flexible porque todo lo que puede hacerse con una máquina, puede hacerse en el lenguaje ensamblador de esta máquina; los lenguajes de alto nivel tienen en una u otra forma limitantes para explotar al máximo los recursos de la máquina. O sea que en lenguaje ensamblador se pueden hacer tareas especificas que en un lenguaje de alto nivel no se pueden llevar acabo porque tienen ciertas limitantes que no se lo permite 

Desventajas

Tiempo de programación .

- Como es un lenguaje de bajo nivel requiere más instrucciones para realizar el mismo proceso, en comparación con un lenguaje de alto nivel. Por otro lado, requiere de más cuidado por parte del programador, pues es propenso a que los errores de lógica se reflejen más fuertemente en la ejecución.

Programas fuente grandes .

- Por las mismas razones que aumenta el tiempo, crecen los programas fuentes; simplemente requerimos más instrucciones primitivas para describir procesos equivalentes. Esto es una desventaja porque dificulta el mantenimiento de los programas, y nuevamente reduce la productividad de los programadores.

Peligro de afectar recursos inesperadamente .

- Que todo error que podamos cometer, o todo riesgo que podamos tener, podemos afectar los recursos de la maquina, programar en este lenguaje lo más común que pueda pasar es que la máquina se bloquee o se reinicialize. Porque con este lenguaje es perfectamente posible (y sencillo) realizar secuencias de instrucciones inválidas, que normalmente no aparecen al usar un lenguaje de alto nivel.

Falta de portabilidad.

- Porque para cada máquina existe un lenguaje ensamblador; por ello, evidentemente no es una selección apropiada de lenguaje cuando deseamos codificar en una máquina y luego llevar los programas a otros sistemas operativos o modelos de computadoras.

(1) 1.2 Procesador y sus registros internos

La Unidad Central de Proceso (CPU, por sus siglas en inglés) tiene 14 registros in-
ternos cada uno de 16 bits. Los primeros cuatro, AX, BX, CX y DX, son de uso general

y se pueden usar también como registros de 8 bits. Es decir, AX se puede dividir en AH
y AL (AH es el byte alto, high, y AL es el byte bajo, low) Lo mismo es aplicable a los
otros tres (BX en BH y BL, CX en CH y CL y DX en DH y DL)
Estos son los únicos registros que pueden usarse de modo dual (en 8 o 16 bits)
Los registros de la CPU son conocidos por sus nombres propios, que son:

AX (acumulador)
BX (registro base)
CX (registro contador)
DX (registro de datos)



(2) 1.3 definición de la memoria ram
La memoria RAM es la memoria principal de un dispositivo donde se almacena programas y datos informativos. Las siglas RAM significan “Random Access Memory” traducido al español es “Memoria de Acceso Aleatorio”.
La memoria RAM es conocida como memoria volátil lo cual quiere decir que los datos no se guardan de manera permanente, es por ello, que cuando deja de existir una fuente de energía en el dispositivo la información se pierde. Asimismo, la memoria RAM puede ser reescrita y leída constantemente.

1.4 El concepto de interrupciones definición y un poco de código

INTERRUPCIÓN

Una interrupción consiste en un mecanismo que provoca la alteración del orden lógico de ejecución de instrucciones como respuesta a un evento externo, generado por el hardware de entrada/salida en forma asincrónica al programa que está siendo ejecutado.

Procesamiento de una interrupción

• Terminar la ejecución de la instrucción máquina en curso.
• Salvar el estado del procesador (valores de registros y flags) y el valor del contador de programa, IP, en la pila, de manera que en la CPU, al terminar el proceso de interrupción, pueda seguir ejecutando el programa a partir de la última instrucción.
• La CPU salta a la dirección donde está almacenada la rutina de servicio de interrupción (Interrupt Service Routine, o abreviado ISR) y ejecuta esa rutina que tiene como objetivo atender al dispositivo que generó la interrupción.
• Una vez que la rutina de la interrupción termina, el procesador restaura el estado que había guardado en la pila en el paso 2 y retorna al programa que se estaba usando anteriormente.

Tipos de interrupciones

1. Interrupciones de hardware. Estas son asíncronas a la ejecución del procesador, es decir, se pueden producir en cualquier momento independientemente de lo que esté haciendo el CPU en ese momento
2. Excepciones. Son aquellas que se producen de forma síncrona a la ejecución del procesador. Normalmente son causadas al realizarse operaciones no permitidas tales como la división entre 0, el desbordamiento, el acceso a una posición de memoria no permitida, etc.
3. Interrupciones por software. Son aquellas generadas por un programa en ejecución. Para generarlas, existen distintas instrucciones en el código máquina que permiten al programador producir una interrupción

Sistemas de prioridad

El sistema operativo necesita un mecanismo para priorizar las interrupciones y tratar primero las más urgentes. Para ello, existen varias alternativas:

• Interrupciones simultáneas: No tienen por qué ocurrir de manera simultánea sino que se refiere a que en un momento dado pueden haber varias interrupciones activas.
• Interrupciones anidadas: Mientras se está procesando una determinada rutina de servicio de interrupción sucede otra señal de interrupción.
• Inhibición de interrupciones: Se deshabilitan las demás interrupciones mientras se está tratando una.

Determinación de la fuente que genera la interrupción

Hay distintas formas de identificar la fuente de una determinada interrupción.

• Polling: el microprocesador comprueba de manera sistemática todos los dispositivos de manera que «busca» cuál de ellos fue el que solicitó la interrupción.
• Interrupciones vectorizadas: Como ventajas podemos destacar que suele ser rápido pero implica un alto costo en el hardware.
• Hardware paralelo: se utiliza un registro de interrupción cuyos bits se controlan de forma independiente por las señales de petición de interrupción de cada periférico. Según la posición de cada bit en el registro, se establece la prioridad.

listado de interrupciones de cada interrupción y codigo

una interrupción es detener el programa para hacer una tarea especifica

1.5 llamadas a servicios del sistema

Una llamada al sistema es un método o función que puede invocar un proceso para solicitar un cierto servicio al sistema operativo. Dado que el acceso a ciertos recursos del sistema requieren la ejecución de código en modo privilegiado, el sistema operativo ofrece un conjunto de métodos o funciones que el programa puede emplear para acceder a dichos recursos. En otras palabras, el sistema operativo actúa como intermediario, ofreciendo una interfaz de programación (API) que el programa puede usar en cualquier momento para solicitar recursos gestionados por el sistema operativo.

Algunos ejemplos de llamadas al sistema son las siguientes:

• Time: que permite obtener la fecha y hora del sistema.
• 
  
• Write: que se emplea para escribir un dato en un cierto dispositivo de salida, tales como una pantalla o un disco magnético.
• 
  
• Read: que es usada para leer de un dispositivo de entrada, tales como un teclado o un disco magnético.
• 
  
• Open: que es usada para obtener un descriptor de un fichero del sistema, ese fichero suele pasarse a write.

Cuando una llamada al sistema es invocada, la ejecución del programa que invoca es interrumpida y sus datos son guardados, normalmente en su PCB (Bloque de Control de Proceso del inglés Process Control Block), para poder continuar ejecutándose luego. El procesador entonces comienza a ejecutar las instrucciones de código de alto nivel de privilegio, para realizar la tarea requerida. Cuando esta finaliza, se retorna al proceso original, y continúa su ejecución. El retorno al proceso demandante no obligatoriamente es inmediato, depende del tiempo de ejecución de la llamada al sistema y del algoritmo de planificación de CPU.

1.6 Modos de direccionamiento

Se les llama modos de direccionamiento a las distintas formas de combinar los operandos según el acceso que se hace a memoria.

Dicho de otra manera, un modo de direccionamiento será una forma de parámetro para las instrucciones.
Una instrucción que lleve un parámetro, por lo tanto, usará un modo de direccionamiento, que dependerá de cómo direccionará (accesará) al parámetro; una instrucción de dos parámetros, combinará dos modos de direccionamiento.

Direccionamiento implícito
Depende solamente de la instrucción, es decir, la instrucción no lleva parámetros.
Particularmente en instrucciones que no accesan memoria, o bien que tienen una forma específica de accesarla.

Ejemplos: PUSHF, POPF, NOP

Modo registro

Usa solamente registros como operandos

Es el más rápido, pues minimiza los recursos necesarios (toda la información fluye dentro del EU del CPU)

Ejemplo:

MOV AX, BX

Modo inmediato

Tiene dos operandos: un registro y una constante que se usa por su valor.

El valor constante no se tiene que buscar en memoria, pues ya se obtuvo al hacer el “fetch” de la instrucción.

Ejemplo:

MOV AH, 9

Modo directo

Uno de los operandos involucra una localidad específica de memoria

El valor constante se tiene que buscar en memoria, en la localidad especificada.

Es más lento que los anteriores, pero es el más rápido para ir a memoria, pues ya “sabe” la localidad, la toma de la instrucción y no la tiene que calcular.

Ejemplo:

MOV AH, [0000]

MOV AH, Variable

Estas dos instrucciones serían equivalentes, si Variable está, por ejemplo, en la localidad 0 de memoria. En la forma primitiva del lenguaje de máquina, como el primer ejemplo, se tiene que indicar “mover a AH el contenido (indicado por los corchetes), de la localidad 0 de los datos (lo de los datos es implícito). El lenguaje Ensamblador, sin embargo, nos permite la abstracción del uso de variables, pero como una variable tiene una localidad determinada en memoria, para el procesador funciona igual. La única diferencia consiste en que el programador no tiene que preocuparse por la dirección, ese manejo lo hace automáticamente el Ensamblador.

Modo indirecto

Se usan los registros SI, DI como apuntadores

El operando indica una localidad de memoria, cuya dirección (sólo la parte desplazamiento) está en SI o DI.

Es más lento que los anteriores, pues tiene que “calcular” la localidad

Ejemplos:

MOV AL, [SI]

MOV BL, ES:[SI] ; Aquí se dice que se usa un “segment override”, donde se indica que en vez de usar el segmento de datos por defecto, se use en su lugar como referencia el segmento extra.

Modo indexado de base

Formato:

[

BX o BP

+ SI o DI (opcionales)

+ constante (opcional)

]

BX o BP indica una localidad base de la memoria

A partir de BX o BP, se puede tener un desplazamiento variable y uno constante

La diferencia es el segmento sobre el que trabajan por defecto:

BX por defecto en el segmento de datos

BP por defecto en el segmento de pila.

Ejemplos:

MOV AX, [BX]

MOV DX, [BX+2]

MOV CX, [BX+DI]

MOV DL, [BX+SI+3]

(3) 1.7 proceso de ensamblado ligado

EDICION 

Los archivos fuente de código ensamblador deben estar en formato ASCII standard. Para esto puede usarse cualquier editor que permita crear archivos sin formato, e.g. Edlin, Edit, Write, 

El editor del Turbo Pascal, Works, Word, WordStar, etcétera. Las declaraciones pueden ser introducidas en mayúsculas y/o minúsculas. Una buena práctica de programación es poner todas las palabras reservadas (directivas e instrucciones) en mayúsculas y todo lo del usuario en minúsculas para fines de facilidad de lectura del código. Las sentencias pueden comenzar en cualquier columna, no pueden tener más de 128 caracteres, no se permiten lineas múltiples ni códigos de control, y cada línea debe ser terminada con una combinación de line-feed y carriage-return. Los comentarios se declaran con; y terminan al final de la línea. 

ENSAMBLADO 

El ensamblado se lleva a cabo invocando al MASM. Este puese ser invocado, usando una línea de comando, de la siguiente manera: MASM archivo [,[objeto][,[listado][,[cross]]]]][opciones][;] Dónde: Objeto.- Es el nombre para el archivo objeto. Listado.- Nombre del archivo de listado de ensamblado. cross. Es un archivo de referencias cruzadas. LINK De la misma forma que el ensamblado, la fase de liga se lleva a cabo con el LINK. Este puede ser invocado de la misma forma que el MASM. Los parámetros que este requiere son: LINK objeto [,[ejecutable][,[mapa][,[librería]]]]][opciones][;] dónde: 

Objeto.- Es el nombre para el archivo .OBJ Ejecutable.- Nombre del archivo .EXE Mapa.- Nombre del archivo mapa Librería.- Nombre del archivo biblioteca de rutinas 

EJECUCION 

Para la ejecución del programa simplemente basta teclear su nombre en el prompt de MS-DOS y teclear ENTER. Con esto el programa será cargado en memoria y el sistema procederá a ejecutarlo. El proceso completo para poder crear un programa ejecutable con el Microsoft Macro Assembler se muestra abajo. 

Caracteristicas del Proceso de Ensamblado y ligado.

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 fuete 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.

(4) 1.8 desplegado de mensajes en el monitor

Desplegado de mensajes en el monitor

MENSAJES EN EL MONITOR

• 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.

En este momento podemos comenzar a escribir las verdaderas instrucciones que le indicarán a la computadora que mensaje y como lo va a desplegar. Sugiero que comenzemos por borrar la pantalla. Esto se puede realizar de muy diversas formas, aquí lo haremos usando el BIOS, el cual es un microchip que se encuentra dentro de toda PC y controla las funciones básicas de entrada y salida (Basic Input Output System). 

Lo que haremos es decirle al chip "¡Hey! dime en que modo está trabajando la tarjeta de video", cuando obtengamos la respuesta le diremos: 

"Dile a la tarjeta de video que deje de trabajar en ese modo y que comienze a trabajar en el modo de video que me diste".

 Una instrucción rara, pues lo que le estamos ordenando es que deje de trabajar en el modo en el que está trabajando !y que comienze a trabajar en ese mismo modo! Así se lo decimos en su propio lenguaje: principio: mov ah, 0fh int 10h mov ah, 0 int 10h .

Lo primero que vemos es una "etiqueta", con ella le damos nombre a un punto dentro del código, si más tarde dentro del programa deseamos repetir esta parte del código solo tenemos que decir "salta a 'principio'" y ya está. 

El primer grupo de instrucciones después de la etiqueta le dicen al BIOS que obtenga la modalidad en la que está trabajando el video. Aquí vemos por primera vez una interrupción (int 10h). Las interrupciones son funciones ya incorporadas dentro del BIOS y del sistema operativo MS-DOS que realizan tareas comunes como leer del disco, mostrar un mensaje en el monitor, o ¡borrar la pantalla!. Enseguida, mediante una función de la interrupción 10h, le decimos que cambie a la misma modalidad de video. Bueno, ahora que la pantalla está limpia, podemos mostrar nuestro mensaje en el monitor. Aquí está el código: lea dx, mensaje_a_mostrar mov ah, 9h int 21h Con la primera instrucción le decimos al procesador "Carga en el registro DX, la dirección de memoria de la variable llamada 'mensaje_a_mostrar'".

 Enseguida le decimos que la despliegue en pantalla con la función 9h de la interrupción 21h. Nuestra tarea está terminada, así que digamosle a la computadora que no hay más instrucciones que procesar. int 20h Las instrucciones están terminadas, pero todavía tenemos que decirle a la computadora que valor va a tener la variable 'mensaje_a_mostrar'. mensaje_a_mostrar db "¡Hola Mundo!$",0 El signo de pesos al final de la cadena, es necesario para que el sistema operativo sepa en donde se acaba la cadena (una cadena es un grupo de caracteres) que va a desplegar. 

Una vez que terminamos con las instrucciones y valores para la máquina, hay que marcar el archivo para que el compilador sepa que ya terminamos de darle instrucciones a la maquina. CODE ENDS end principio ¡Al fin! ¡Llegamos al final! Aquí está el código fuente completo: 

CODE SEGMENT

 ASSUME CS:CODE, DS:CODE, SS:CODE, ES:CODE
ORG 100h 

principio: 

mov ah, 0Fh 

rar db 

"¡Hola Mundo!$",0

 CODE ENDS 

end principio

Suma de dos numeros con libreria emu8086.inc

name 'suma de dos numeros'
include 'emu8086.inc'
org 100h

.data
suma db 2 dup (?)

.code
Sumas proc
    printn " "
    print "Introduce el primer numero==>"
    call scan_num
    mov suma[0],cl
    printn " "
    print "Introduce el segundo numero==>"
    call scan_num
    mov suma[1],cl
    printn
    xor ax,ax
    add al,suma[0]
    add al,suma[1]
    printn " "
    print "La suma es: "
    call print_num
   
Sumas endp

exit:
    printn " "
    printn " "
    print "Presiona enter para salir..."
    mov ah,0
    int 16h
    ret
   
define_print_string
define_print_num
define_print_num_uns
define_scan_num
end

division

uso de reg

1 2 3 4 5 6 7 8 9 10

ORG 100h mov ax,80 ; AX=80 mov bx,450 ;BS=450 inc bx;BX++ bx=451 add ax, 80 ;AX=AX+80 160 mov cx,200 ;CX=200 sub cx,ax ;CX=CX-aX 200-160 ret

suma de un solo digito

1 2 3 4 5 6 7 8 9 10 11 12 13

org 100 ;suma numero de un solo digito mov ax, 8 mov bx, 4 add ax,bx mov bx, 5 sub ax,bx mov bx,3 inc bx mov ax,6

Suma de dos números e imprime la suma

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57

.model small .stack 64 .data n1 db 0 n2 db 0 suma db 0 msg1 db "dame el primer valor",'$' msg2 db "dame el segundo valor",'$' msg3 db 10,13,"suma",'$' .code begin proc far ;direccionamos al segmento de datos mov ax,@data mov ds,ax ;solicitamos primer digito mov ah,09 lea dx,msg1 int 21h ;se lee el primer valor mov ah, 01 int 21h sub 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 add al,n2 add al,30h;convierte el caracter mov suma,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,suma int 21h mov ah,4ch int 21h begin endp end