calificacion

.MODEL SMALL
.STACK 64
.DATA 
    include "emu8086.inc"
   
    nota db 0

   
.CODE 
OPERACIONES PROC FAR ;DECLARACION DE PROCEDIMIENTO   

    ;MUESTRO EL MENSAJE       
    print " "  ;macro 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   la d es para tomarlo como decimal
    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  ;macro para poner los letreros en una posicion 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 

Programa que dice si eres mayor de edad o no con emu8086

.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  ;llama al
    mov num1,cl
 
    ;lectura segundo valor
 

    xor ax,ax ; xor limpiar el reg 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    ;para recidir numeros decimales
define_scan_num   ;del procedimiento  de scam_num
endp inicio

suma de numeros

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

.data
suma db 2 dup (?)   ;declara un areglo de dos variables
.code
sumas proc
    print " Introduce el primer numero: "  ;macro de lib
    call scan_num ;llamada a un proceminiento  para pedir un numero
    mov suma[0],cl
    printn " "
    print " Introduce el segundo numero: "
    call scan_num ;llamada a un proceminiento  para pedir un numero
    mov suma[1],cl
    xor ax,ax   ;nominacion que limpia registros
    add al,suma[0] ;valor de la suma  pos 0
    add al,suma[1]  ;valor de la suma  pos 1
    printn " "
    print " La suma es: "
    call print_num
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  ;ws  del prim_num
define_print_num_uns  ;conversion a decimal del scam_num
define_scan_num ;es del scam num del proc
end

Ejercicio del 26 de febrero

include 'emu8086.inc'

 

org 100h

 

.code   

Cursoroff      ;apaga el cursor

call scan_num  ;pide un numero

 

define_scan_num  ;define la funcion

 

gotoxy 2,5

putc 'A'   ;imprime un solo caracter

 

gotoxy 5,7    ;define en donde se ira a la pantalla

print 'dame un numero'

call scan_num  

mov ax,cx

gotoxy 8,7

call print_num                  

    

define_print_num

define_print_num_uns

end

ret

ensamblador: suma de dos numeros

name "suma dos numeros"
include 'emu8086.inc';le ponemos nombre al programa e importamos la libreria
org 100h
;creamos un arreglo llamado suma de 2 espacios de tipo byte
.data
suma db 2 dup (?)

.code ;pedimos 2 numeros
Sumas proc
    printn " " 
    print "Introduce el primer numero ==>"
    call scan_num
    mov suma[0], cl ;movemos los valores que recibe scan_num en cl y mandamos las posiciones del arreglo
    printn " "
    print "Introduce el segundo numero ==>"
    call scan_num
    mov suma[1],cl
    printn " "
    xor ax,ax  ;limpiamos el registro ax y mandamos la suma al registro al para poder imprimir con print_num
   
    add al,suma [0]
    add al,suma [1]
    print " "
    print "la suma es:" 
    call print_num
Sumas endp

exit: ;creamos etiquetas salir con las intrucciones para terminar nuestro programa
    printn " "
    printn " "
    print "presiona enter para salir..."
    mov ah,0
    int 16h
    ret   
;definimos los comandos de emu8086.inc
define_print_string
define_print_num
define_print_num_uns
define_scan_num
end

divicion

org 100h

mov ax,100
mov bx,5
div bx
ret

org 100h

call inicializar

call multaxbx

inicializar:

mov ax,8

mov bx,9

multaxbx:

mul ax

ret

calificacion

.model small
.stack 64

.data ;seccion de variables
    msg1 db "dame una calificacion(seguida de un enter)$"
    aprobado db 13,10, "Aprobado $"
    reprobado db 13,10, "Reprobado$"
    var1 dw ?,"$"
    var2 dw ?,"$" 
    var3 dw ?,"$"
   
 .code ;segmento de codigo
 Resultado proc far
    mov ax ,@DATA ;como 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
 ;------------pedir un segundo caracter
    mov ah,01
    int 21h
    mov var2, ax
 ;------------pedir un segundo caracter
    mov ah,01
    int 21h
    mov var3, ax   
   
 ;momento de evaluar la calif

    cmp al,13
    je  CONTINUE  ;salta si es igual a 13
    jmp mayor
 ;inicia funcion

 CONTINUE:
    MOV AX,var1
    cmp al,037h ;7 es 37 en ASCII
    jge mayor  ;salta su el mayor 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

 resultado endp
 end resultado
   

resta

.model small

.stack 64
.data
;declarando variables globales
numero1 db 0
numero2 db 0
resta db 0
msjn1 db 10,13, "INGRESE EL PRIMER NUMERO A RESTAR=  ",'$';ingrese n1
msjn2 db 10,13, "INGRESE EL SEGUNDO NUMERO A RESTAR=  ",'$';ingrese n2
;mensaje para mostrar los resultados
msjnR db 10,13, "LA RESTA DE LA OPERACION DADA ES=  ",'$'

.code
begin proc far 
   
   
    ;direccionamiento del procedimiento
    mov ax, @data
    mov ds,ax 
     
    ;solicitar del teclado numero 1
   
    mov ah, 09
    lea dx, msjn1
    int 21h
    mov ah, 01
    int 21h
    sub al, 30h
    mov numero1,al 
     
    ;solicitar del teclado numero 2
   
    mov ah, 09
    lea dx, msjn2
    int 21h
    mov ah, 01
    int 21h
    sub al, 30h
    mov numero2,al
   
    ;operaciones aritmeticas
                   
    ;RESTA
    mov al,numero1
    sub al,numero2
    mov resta,al
   
    ;mostrando la resta
    mov ah,09
    lea dx,msjnR
    int 21h
    mov dl,resta
    add dl,30h
    mov ah,02
    int 21h
   
    ;cierre del programa
    mov ah,4ch
    int 21h
   
    begin endp
end

suma

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

ciclo

.model small

.stack 64

.data

mensaje db "ingrese el numero de veces que se repetira el mensaje$"

repetir db 13,10, "repitiendo el ciclo$"

.code

inicio proc far

    

        mov ax, @data

        mov ds,ax

        

        mov ah , 09

        lea dx , mensaje

        int 21h

        

        mov ah ,01

        int 21h

        

        ;comvertir a valor lo que se tecleo

        sub al , 30h

        

        mov cl, al 

        ciclo:

            mov ah, 09

            lea dx, repetir

            int 21h

        loop ciclo

        

        mov ax,4c00h

        int 21h

inicio endp

end

Programa: 3 Hola mundo con Espera

 Espera que se  presione cualquier tecla para que despliega el Hola mundo

CODE SEGMENT
    ASSUME CS:CODE, DS:CODE, SS:CODE, ES:CODE
    ORG 100h
    
    
    PRINCIPIO:
    INT 16H
    CODE ENDS
    MOV AH, 0FH
    MOV AH, 0
    INT 10H    
    LEA DX, MENSAJE_E_MOSTRAR
    MOV AH, 9H
    INT 21H
    INT 20H
    MENSAJE_E_MOSTRAR DB "HOLA MUNDO!$", 0
    MOV AH,0

END PRINCIPIO

Programa 2: Hola mundo 2 veces en emu8086

Hola mundo 2 veces en emu8086

.MODEL SMALL

.STACK

.DATA

CADENA1 DB 'HOLA MUNDO.$'

CADENA2 DB 'HOLA MUNDO2.$'

.CODE

PROGRAMA:

    MOV AX,@DATA

    MOV DS,AX

    MOV DX,OFFSET CADENA1

    MOV AH,9

    INT 21H

    MOV AX,@DATA

    MOV DS,AX

    MOV DX,OFFSET CADENA2

    MOV AH,9

    INT 21H

END PROGRAMA

Programa 1: Hola mundo en lenguaje ensamblador

Hola mundo en emu8086

.MODEL SMALL
.STACK
.DATA
CADENA1 DB 'HOLA MUNDO.$'
.CODE
PROGRAMA:
    MOV AX,@DATA
    MOV DS,AX
    MOV DX,OFFSET CADENA1
    MOV AH,9
    INT 21H
END PROGRAMA

Lenguaje ensamblador

El lenguaje ensamblador, o assembler (en inglés assembly language y la abreviación asm), es un lenguaje de programación de bajo nivel. Consiste en un conjunto de mnemónicos que representan instrucciones básicas para los computadores, microprocesadores, microcontroladores y otros circuitos integrados programables. Implementa una representación simbólica de los códigos de máquina binarios y otras constantes necesarias para programar una arquitectura de procesador y constituye la representación más directa del código máquina específico para cada arquitectura legible por un programador. Cada arquitectura de procesador tiene su propio lenguaje ensamblador que usualmente es definida por el fabricante de hardware, y está basada en los mnemónicos que simbolizan los pasos de procesamiento (las instrucciones), los registros del procesador, las posiciones de memoria y otras características del lenguaje. Un lenguaje ensamblador es por lo tanto específico de cierta arquitectura de computador física (o virtual). Esto está en contraste con la mayoría de los lenguajes de programación de alto nivel, que idealmente son portables

Características

El código escrito en lenguaje ensamblador posee una cierta dificultad de ser entendido directamente por un ser humano ya que su estructura se acerca más bien al lenguaje máquina, es decir, lenguaje de bajo nivel.
El lenguaje ensamblador es difícilmente portable, es decir, un código escrito para un Microprocesador, suele necesitar ser modificado, muchas veces en su totalidad para poder ser usado en otra máquina distinta, aun con el mismo Microprocesador, solo pueden ser reutilizados secciones especiales del código programado.
Los programas hechos en lenguaje ensamblador, al ser programado directamente sobre Hardware, son generalmente más rápidos y consumen menos recursos del sistema (memoria RAM y ROM). Al programar cuidadosamente en lenguaje ensamblador se pueden crear programas que se ejecutan más rápidamente y ocupan menos espacio que con lenguajes de alto nivel. 
Con el lenguaje ensamblador se tiene un control muy preciso de las tareas realizadas por un Microprocesador por lo que se pueden crear segmentos de código difíciles de programar en un lenguaje de alto nivel.
También se puede controlar el tiempo en que tarda una Rutina en ejecutarse, e impedir que se interrumpa durante su ejecución.
El lenguaje ensamblador es un código estructurado y gravitatorio desarrollado sobre un archivo de programación (.ASM), en el cual pueden existir varios programas, macros o rutinas que pueden ser llamados entre si.

Generalmente, un programa ensamblador (assembler en inglés) moderno crea código objeto traduciendo instrucciones mnemónicas de lenguaje ensamblador en opcodes, y resolviendo los nombres simbólicos para las localizaciones de memoria y otras entidades.1​ El uso de referencias simbólicas es una característica clave del lenguaje ensamblador, evitando tediosos cálculos y actualizaciones manuales de las direcciones después de cada modificación del programa. La mayoría de los ensambladores también incluyen facilidades de macros para realizar sustitución textual - ej. generar cortas secuencias de instrucciones como expansión en línea en vez de llamar a subrutinas.

Programa ensamblador

Los ensambladores son generalmente más simples de escribir que los compiladores para los lenguajes de alto nivel, y han estado disponibles desde los años 1950. Los ensambladores modernos, especialmente para las arquitecturas basadas en RISC, tales como MIPS, Sun SPARC, y HP PA-RISC, así como también para el x86 (-64), optimizan la planificación de instrucciones para explotar la segmentación del CPU eficientemente.

En los compiladores para lenguajes de alto nivel, son el último paso antes de generar el código ejecutable.

Número de paso Hay dos tipos de ensambladores basados en cuántos pasos a través de la fuente son necesarios para producir el programa ejecutable.

Los ensambladores de un solo paso pasan a través del código fuente una vez y asumen que todos los símbolos serán definidos antes de cualquier instrucción que los refiera.
Los ensambladores de dos pasos crean una tabla con todos los símbolos y sus valores en el primer paso, después usan la tabla en un segundo paso para generar código. El ensamblador debe por lo menos poder determinar la longitud de cada instrucción en el primer paso para que puedan ser calculadas las direcciones de los símbolos.
La ventaja de un ensamblador de un solo paso es la velocidad, que no es tan importante como lo fue en un momento dados los avances en velocidad y capacidades del computador. La ventaja del ensamblador de dos pasos es que los símbolos pueden ser definidos dondequiera en el código fuente del programa. Esto permite a los programas ser definidos de maneras más lógicas y más significativas, haciendo los programas de ensamblador de dos pasos más fáciles de leer y mantener.​