miércoles, 27 de marzo de 2019

ejercicio del dia 27 de marzo del 2019-multiplicacion de dos numeros con emu8086.inc

programa que se ejecuta con la libreria emu8086.inc.
La cual nos deja hacer uso de la palabra reservada PRINT para mostrar mas facilmente textos en pantalla.

el codigo:


; You may customize this and other start-up templates; 
; The location of this template is c:\emu8086\inc\0_com_template.txt
include "emu8086.inc"

org 100h

    
   .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  
   
    print 'hola este es un mensaje'
   printn ''
   printn 'introduzca el primer valor de dos digitos'
   printn ''

   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
   printn ''
   printn 'introduzca el segundo valor de dos digitos'
   printn ''
   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  ;unidad del segundo numero
   mov bl,chr2  ;unidad del primer numero
   mul bl       ;multiplicar
   mov ah,0     ;limpiamos ah0
   aam          ;separamos de hex a dec
   mov ac1,ah   ;decenas del primera multiplicacion
   mov r4,al    ;unidades del primera multiplicacion
            
   mov al,chr4  ;unidades del segundo numero
   mov bl,chr1  ;decentas del primer numero
   mul bl       ;multiplicar
   mov r3,al    ;movemos el resultado de la operacion a r3
   mov bl,ac1   ;movemos el acarreo a bl
   add r3,bl    ;sumamos resultado mas acarreo
   mov ah,00h   ;limpiamos ah por residuos
   mov al,r3    ;movemos el resultado de la suma a al
   aam          ;separamos  de hex a dec
   mov r3,al    ;guardamos unidades en r3
   mov ac1,ah   ;guardamos decenas en ac1
  
      

   mov al,chr3    ;al = chr3
   mov bl,chr2    ;bl = chr2
   mul bl         ;AL = chr3*chr2 (BL*AL)
   mov Ah,0h      ;
   AAM            ;ASCII Adjusment
   mov ac,AH      ;ac = AH (Acarreo)
   mov r2,AL      ;r2 = AL       (Unidad del resultado)

   mov al,chr3    ;AL = chr3
   mov bl,chr1    ;BL = chr1
   mul bl         ;AL = chr1*chr3 (BL*AL)
   mov r1,al      ;r1 = AL       (Decena del resultado)
   mov bl,ac      ;BL = Acarreo anterior
   add r1,bl      ;r1 = r1+ac (r1 + Acarreo)
   mov ah,00h     ;
   mov al,r1      ;AL = r1 (Asignaci?n para el ajust)
   AAM            ;ASCII Adjustment
   mov r1,al      ;r1 = AL
   mov ac,ah      ;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
   printn ''
   printn 'introduzca el valor de la mulltiplicacion es:'
   printn ''
  
   mov ax,0000h   ;limpiamos ax
  
   mov al,r3      ;movemos el segundo resultado de la primera mult a al
   mov bl,r2      ;movemos primer resultado de la segunda mult a bl
   add al,bl      ;sumamos
   mov ah,00h     ;limpiamos ah
   aam            ;separamos hex a dec
   mov r3,al      ;r3 guarda las decenas del resultado final
   mov r2,ah      ;r2 se utiliza como nuevo acarreo
  
   mov ax,0000h   ;''''
  
   mov al,ac1     ;movemos el acarreo de la primera mult a al
   mov bl,r1      ;movemos segundo resultado de la segunda mult a bl
   add al,r2      ;sumamos el nuevo  acarreo de la suma anterior  a al
   add al,bl      ;sumamos al a bl
   mov ah,00h     ;limpiamos el registro ah
   aam            ;separamos de hex a dec
   mov r1,al      ;r1 guarda las centenas
   mov r2,ah      ;ah se sigue utilizando como acarreo
  
   mov al,r2      ;movemos el acarreo a al
   mov bl,ac      ;movemos ac a bl
   add al,bl      ;sumamos al a bl
   ;aam            ;separamos hex a dec
   mov ac,al      ;mov al a ac como nuestro acarreo final
  

  
   ;Mostramos resultado
   mov ah,02h 
   mov dl,ac
   add dl,30h
   int 21h        ;Mostramos ac (millar)

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

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


ret


martes, 19 de marzo de 2019

Unidad 2-Cadenas con formato

Unidad 2-Documentacion de 2.7 incremento y decremento

Unidad 2-ejercicios del dia 19 de marzo del 2019 -multiplicacion de dos numero

#programa creado en emu8086 que permita hacer la multiplicacion de dos dos valores cada uno con 2 numeros.


; You may customize this and other start-up templates;
; The location of this template is c:\emu8086\inc\0_com_template.txt

org 100h

   
   .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  ;unidad del segundo numero
   mov bl,chr2  ;unidad del primer numero
   mul bl       ;multiplicar
   mov ah,0     ;limpiamos ah0
   aam          ;separamos de hex a dec
   mov ac1,ah   ;decenas del primera multiplicacion
   mov r4,al    ;unidades del primera multiplicacion
           
   mov al,chr4  ;unidades del segundo numero
   mov bl,chr1  ;decentas del primer numero
   mul bl       ;multiplicar
   mov r3,al    ;movemos el resultado de la operacion a r3
   mov bl,ac1   ;movemos el acarreo a bl
   add r3,bl    ;sumamos resultado mas acarreo
   mov ah,00h   ;limpiamos ah por residuos
   mov al,r3    ;movemos el resultado de la suma a al
   aam          ;separamos  de hex a dec
   mov r3,al    ;guardamos unidades en r3
   mov ac1,ah   ;guardamos decenas en ac1
 
     

   mov al,chr3    ;al = chr3
   mov bl,chr2    ;bl = chr2
   mul bl         ;AL = chr3*chr2 (BL*AL)
   mov Ah,0h      ;
   AAM            ;ASCII Adjusment
   mov ac,AH      ;ac = AH (Acarreo)
   mov r2,AL      ;r2 = AL       (Unidad del resultado)

   mov al,chr3    ;AL = chr3
   mov bl,chr1    ;BL = chr1
   mul bl         ;AL = chr1*chr3 (BL*AL)
   mov r1,al      ;r1 = AL       (Decena del resultado)
   mov bl,ac      ;BL = Acarreo anterior
   add r1,bl      ;r1 = r1+ac (r1 + Acarreo)
   mov ah,00h     ;
   mov al,r1      ;AL = r1 (Asignaci?n para el ajust)
   AAM            ;ASCII Adjustment
   mov r1,al      ;r1 = AL
   mov ac,ah      ;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      ;movemos el segundo resultado de la primera mult a al
   mov bl,r2      ;movemos primer resultado de la segunda mult a bl
   add al,bl      ;sumamos
   mov ah,00h     ;limpiamos ah
   aam            ;separamos hex a dec
   mov r3,al      ;r3 guarda las decenas del resultado final
   mov r2,ah      ;r2 se utiliza como nuevo acarreo
 
   mov ax,0000h   ;''''
 
   mov al,ac1     ;movemos el acarreo de la primera mult a al
   mov bl,r1      ;movemos segundo resultado de la segunda mult a bl
   add al,r2      ;sumamos el nuevo  acarreo de la suma anterior  a al
   add al,bl      ;sumamos al a bl
   mov ah,00h     ;limpiamos el registro ah
   aam            ;separamos de hex a dec
   mov r1,al      ;r1 guarda las centenas
   mov r2,ah      ;ah se sigue utilizando como acarreo
 
   mov al,r2      ;movemos el acarreo a al
   mov bl,ac      ;movemos ac a bl
   add al,bl      ;sumamos al a bl
   ;aam            ;separamos hex a dec
   mov ac,al      ;mov al a ac como nuestro acarreo final
 

 
   ;Mostramos resultado
   mov ah,02h
   mov dl,ac
   add dl,30h
   int 21h        ;Mostramos ac (millar)

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

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


ret

capturas de ejecucion del programa:


Unidad 2-LOOP Z

#Ejercicio que permite al hallar un valor al que se compara dar seguimiento con el loop.
En este caso se utiliza la letra mayuscula S

org 100h

mov ah,09
;invoca a la interrupcion para desplegar el mensaje
int 21h

;leera hasta 10 veces la letra s
mov cx,10 ;veces a repetir
mov al, '>';caracter inicial

LEE_CAR:
    mov ah,0eh ;funcion para imprimir los caracteres
    int 10h    ;llamada a la bios  
    
    mov ah,00 ;funcion esperar un caracter desde el teclado
    int 16h   ;llamar a al bios
    cmp al,'S' ;compara el caracter presionado con 's'
    loope LEE_CAR ;si es igual ,salta a OTRO_C  
    
    MOV ah,0Eh
    int 10h ;PARA SERVICIOS DE VIDEO
    
    ;coloca el fin de linea para que baje una linea y lo imprime
    mov ah,0Eh ;funcion de la bios para imprimir un caracter
    mov al,10
    int 10h
    
    ;coloca el retorno de carro parea que vaya al inicio
    mov al,13
    int 10h
    
    ;prepara salida del programa
    mov ax,4c00h
    int 21h


    
end inicio



miércoles, 13 de marzo de 2019

UNIDAD 2-EJERCICIO DEL DIA 13 DE MARZO DEL 2019-BUCLES Y SALTOS

Ejercicios de bucle #1

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 final      ; brinca si es igual

cmp msg[si], al   ;comparar si encuentra la primera letra de la cadena
 jne seguir    ;brica si es diferente


mov di,1       ;poner en 1 di 

comprobar:

 mov al, msg2[di]
 mov bx, di
 cmp msg[si+bx], al     ;posicion de la letra coincidente + di, comparar con la cadena
 jne seguir             ;si no coincide mandar a seguir 


 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:

  mov dx, offset msg3    ;copiar msg3 a dx
  mov ah, 9              ;preparar ah con 9 para la interrupcion 21h
  int 21h
  jmp fin                ;mostrar contenido en dx 
 
final:
  mov dx, offset msg4    ;copiar msg3 a dx
  mov ah, 9              ;preparar ah con 9 para la interrupcion 21h
  int 21h 
 
fin:



ret 

msg db "tecnologico$"
msg2 db "tecy$"

msg3 db "Si se encuentra$"
msg4 db "no se encuentra$"

en este no se encontrara el mensaje 2 en el mensaje 3

ejecucion:

martes, 12 de marzo de 2019

UNIDAD 2-Ejercicios del día 12 de marzo del 2019(BUCLES O LAZOS)

Bucles o Lazos:


los bucles loop van acompañados de registros ax es un contador y en el es el numero de vueltas que dara nuestro ciclo
si yo digo que ax=10 
se usa inc para incrementar
y se usa dec para decremenntar

Control de Bucles (instrucciones simples) 

Éstas posibilitan el grupo de control más elemental de nuestros programas. Un bucle es un bloque de código que se ejecuta varias veces. Hay 4 tipos de bucles básicos: 

o Bucles sin fin o Bucles por conteo o Bucles hasta o Bucles mientras 

Las instrucciones de control de bucles son las siguientes: 

• • INC   incrementar
• • DEC   decrementar 
• • LOOP   realizar un bucle
 • •LOOPZ,LOOPE realizar un bucle si es cero 
• • LOOPNZ,LOOPNE realizar un bucle si no es cero 
• • JCXZ   salta si CX es cero 


ejemplos

#1 ejemplo de bucle 1:

 org 100h


include 'emu8086.inc';libreria para las letras

mov cx,10;darle el valor de 10 a cx

comienzo:          ;inicio de la funcion

   printn 'letrero' ;letrero
   inc cx ;incrementar cx 
   

LOOP comienzo             ;inicio del bucle
ret


Capturas de ejecucion del programa

#2 CREACION DE UN BUCLe:

.MODEL tiny

NAME "BUCLE"

.DATA
    dato db 10,13,"letrero $" ,13,10




.code   
INICIO:
mov cx,2
comienzo:
    mov dx,OFFSET dato:
    mov ah,09
    int 21h
   loop comienzo
   
ret  

end
    

captura de ejecucion(no salio del todo bien):


#3 ejemplo de bucle 3 (cambio la salida en pantalla)

.MODEL tiny

NAME "BUCLE"

.DATA
    dato db 10,13,"letrero $" ,13,10




.code   
INICIO:
mov cx,2
comienzo:
    lea dx,dato
    mov ah,09
    int 21h
   loop comienzo
   
ret  

end

    
captura del programa en ejecucion:


#4 ejemplo con loopne
este ejemplo hace la utilizacion de las banderas.\


.MODEL tiny

NAME "BUCLE"

.DATA
    dato db 10,13,"letrero $" ,13,10

.code   
INICIO:
mov cx,10
comienzo:
    lea dx,dato
    mov ah,09
    int 21h
   loopne comienzo      ;esto es lo que cambia en ejemplo al anterior
   
ret  

end
    

captura de la ejecucion:




#5 ejemplo de la ejecucion con jcxz:

.MODEL tiny

NAME "BUCLE"

.DATA
    dato db 10,13,"letrero $" ,13,10
 
.code   
INICIO:
mov cx,0
comienzo:
    lea dx,dato
    mov ah,09
    int 21h
   jcxz comienzo      ;esto es lo que cambia en ejemplo al anterior
   
ret  

end

captura de la ejecucion:



jueves, 7 de marzo de 2019

Unidad 2-ejercicio del dia 7 de marzo -Saltos y condicionales.

Tutorial del ensamblador 8086 para principiantes (parte 7)

Programa de control de flujo

Controlar el flujo del programa es algo muy importante, aquí es donde su programa puede tomar decisiones de acuerdo con ciertas condiciones. 


  • Saltos incondicionales

    La instrucción básica que transfiere el control a otro punto del programa es JMP . 

    La sintaxis básica de la instrucción JMP :
    Etiqueta JMP
    Para declarar una etiqueta en su programa, simplemente escriba su nombre y agregue " : " al final, la etiqueta puede ser cualquier combinación de caracteres pero no puede comenzar con un número, por ejemplo, aquí hay 3 definiciones de etiquetas legales:
    label1: 
    label2: 
    a:
    La etiqueta se puede declarar en una línea separada o antes de cualquier otra instrucción, por ejemplo:
    x1: 
    MOV AX, 1 

    x2: MOV AX, 2
tablas que son utilles:





#1 programa de ejemplo del uso de jmp\
\

org    100h

mov    ax, 5          ; set ax to 5. 
mov    bx, 2          ; set bx to 2. 

jmp    calc            ; go to 'calc'. 

back:  jmp stop      ; go to 'stop'. 

calc:
add    ax, bx         ; add bx to ax. 
jmp    back           ; go 'back'. 

stop:

ret                   ; return to operating system. 







#2 programa que usa incondicionales

include "emu8086.inc"

org    100h

mov    al, 25     ; set al to 25.
mov    bl, 10     ; set bl to 10.

cmp    al, bl     ; compare al - bl.

je     equal      ; jump if al = bl (zf = 1).

putc   'n'        ; if it gets here, then al <> bl,
jmp    stop       ; so print 'n', and jump to stop.

equal:            ; if gets here,
putc   'y'        ; then al = bl, so print 'y'.

stop:

ret               ; gets here no matter what.





y este es su ejecucion en pantalla:


#3 ejemplo de comparacion de dos valores y haciendo una condicion para si es mayor o iguales los valores:


include 'emu8086.inc'
.model small
.stack
.data
    num1 db 8  
    num2 db 4
    msg1 db 'numeros iguales $'
    msg2 db 'numero 1 es mayor $'
    msg3 db 'numero 2 es mayor $'
    
.code
    main:
    mov ax,@data
    mov ds,ax
    
    mov al,num1
    
    cmp al,num2
    
    jc mayor2
    jz igual
    jnz mayor1
    
.exit

igual:
    print 'son iguales'
    mov ah,09h
    lea dx,msg1
    int 21h
.exit

mayor1:
    print 'es mayor el numero 1'
    .exit
    
    
mayor2:
    print 'es mayor el numero 2'
    .exit


capturas de la ejecucion:
si el numero 1 es mayor:
si el numero 2 es mayor:
\si ambos números son iguales:



Unidad 3-ejemplo con macros

Programa que que imprime valores numericos en hexadecimales pero haciendo la utilizacion de macros. include 'emu8086.inc' Mostra...