2. Instrucción LOOPZ (Vídeo)

Programa con Loopz


Código:

org 100h
.stack 64
.data
.code
inicio:
mov cx,10 ;cantidad de veces que repetira
mov al,'>' ;caracter inicial

Lee_car:
    mov ah,0eh ;Funcion para imprimir caracter
    int 10h   ;llama a la bios
    
    mov ah,00 ;funcion de espera de un caracter del teclado
    int 16h ;llama al bios
    cmp al,'S' ;compara el caracter con 'S'
    loope Lee_car  ;si es igual salta a otro
    
    mov ah,0eh ;funcion para imprimir caracter
    int 10h ;llamada al bios
    
    ;colocar el fin de la linea para que baje una linea y lo imprima 
    mov ah,0eh ;funcion del bios para imprimir caracter
    mov al,10
    int 10h ;servicio de video
    
    ;colocar el retorno de carro para ir al inicio
    mov al,13
    int 10h ;servicio de video
    ;prepara la salida del programa
    mov ax,4c00h
    int 21h
end inicio

Resultado:

2. Arreglos

Instrucción CMP, JE, JNE, LOOP

En esta ocasión introducimos un programa que incluye saltos, ciclos, este programa permite comparar una dos palabras y si estas coinciden.


Código:

org 100h          ;directiva

include 'emu8086.inc' 

mov si, 0    ;ponemos si en 0(asigna),el registro 'si' para poder utilizar cmp

comienzo:

mov al, msg2[0]   ;copiar la primera letra de la palabra A al, del
cmp msg[si],"$"   ;si es el fin de la cadena mandar a final,compara msg con msg2
 je final      ; brinca si es igual 
                  ;continuar
cmp msg[si], al   ;comparar si encuentra la primera letra de la cadena en msg2
 jne seguir    ;brinca si es diferente

mov di, 1         ;poner en 1 = di 

comprobar:

 mov al, msg[di]       ;compara en la [?] posicion (di, inc di)msg
 mov bx, di             ;  bx = di
 cmp msg2[si+bx], al     ;posicion de la letra coincidente di(si+bx),comparar con(al) la cadena msg
 jne seguir             ;si no coincide mandar a seguir 
 
 inc di                 ;incrementar di para seguir recorriendo cadena
 cmp msg[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: 
      mov di, 1
 inc si       ;para seguir recorriendo la palabra
loop comienzo   ;bucle principal para recorrer palabra

resultado:

    printn 'multi Coincide con multiplicacion'             
  jmp fin

final:

  print 'No coindice '
fin:

 mov ax, 4c00h 
 ret

msg db "mult$"      ;subcadena a comparar
msg2 db "multiplicacion$" ;cadena
msg5 db "fin$"

Resultado:

2. Instrucción LOOP, LOOPNE, JCXZ

Ejemplo con LOOP


Programa 1:


Código: 

org 100h 

include 'emu8086.inc'
mov cx,50 ;cx controla el numero de iteraciones

comienzo:
    printn 'letrero'
    inc cx      ;
LOOP comienzo ;   

ret

Resultado:

Programa 2:

Código: 

org 100h 

include 'emu8086.inc'

.data

msj1 db 10,13, 'letrero $' 
.code 
    mov cx,50 

    comienzo:

    lea dx, msj1
    mov ah, 09
    int 21h
   
    LOOP comienzo ;   

ret

Resultado:

Programa 3:

Código:  

.model tiny
name "bucle"
.data 
msj1 db 10,13,'Letrero $' 
.CODE

 inicio:
 mov cx,50
 comienzo: 
  MOV dx, OFFSET msj1
  MOV ah,09
  int 21h   
     
LOOP comienzo
ret

Resultado:

Programa 4:

Código: 

.model tiny
name "bucle"
.data 
msj1 db 10,13,'Letrero $' 
.CODE

 inicio:
 mov cx,50
 comienzo: 
 
  lea dx, msj1
  MOV ah,09   ;para imprimir
  int 21h   
     
LOOP comienzo
ret

Resultado:

Ejemplo con LOOPNE


Programa 5:

Código: 

.model tiny
name "bucle"
.data 
msj1 db 10,13,'Letrero $' 
.CODE

 inicio:
 mov cx,9
 comienzo: 
 
  lea dx, msj1
  MOV ah,09   ;para imprimir
  int 21h   
     
LOOPNE comienzo
ret ;retorna      
END

Resultado:

Ejemplo con JCXZ

La instrucción JCXZ es un tipo de salto condicional, este solo se hará si en nuestro registro cx tenemos un cero. Solo imprimirá una vez.

Programa 6:

Código: 

.model tiny
name "bucle"
.data 
msj1 db 10,13,'Letrero $' 

.CODE

 inicio:
 mov cx,4 ;0
 comienzo: 
 
  lea dx, msj1
  MOV ah,09   ;para imprimir
  int 21h   
     
JCXZ comienzo
ret ;retorna      
END

Resultado:

2. Saltos condicionales en Ensamblador (CMP JC JZ JNZ)

Saltos condicionales en Ensamblador (CMP JC JZ JNZ)

Comparar números

Código:

include 'emu8086.inc'
.model small
.stack
.data
    num1 db 8 ;numero a comparar - cambia e intenta
    num2 db 8 ;numero a comparar - cambia e intenta 
    msg1 db 'Numeros iguales','$'
    msg2 db 'Numero 1 mayor','$'
    msg3 db 'Numero 2 mayor','$'
     
.code
    main:
    mov ax, @data
    mov ds,ax
     
    mov al,num1
    cmp al,num2
     
    jc Mayor2   ;Brinca si es mayor el numero 2
    jz igual    ;Salta si es igual
    jnz Mayor1  ;Brinca si es mayor el numero 1
     
.exit
 
igual:
    mov ah,09h
    lea dx ,msg1
    int 21h  
    ;printn 'Los numeros son iguales'
.exit 
 
Mayor1:
    mov ah,09h
    lea dx, msg2
    int 21h
    ;printn 'El numero 1 es mayor'
.exit
 
Mayor2:
    mov ah,09h
    lea dx, msg3
    int 21h
    ;print 'El numero 2 es mayor'
.exit
end

Resultado:

Referencia:
https://www.youtube.com/watch?v=Ng4YEb2Jtcg

2. Saltos Incondicionales (JMP) y Saltos Condicionales

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

Salto incondicional (JMP):
La instrucción básica que transfiere el control a otro punto del programa. La sintaxis básica es :

JMP etiqueta

JMP et1 ;Indica a donde saltara et1
.
.
.
et1: ;realiza lo que se encuentra en ella et1
MOV AX, 1 

Programa 1: Salto incondicional

Código:

org    100h

mov    ax, 5          ; se asigna 5 en ax. 
mov    bx, 2          ; se asigna 2 en bx. 

jmp    calc            ; va a 'calc'. 

back:  jmp stop      ; va a 'stop'. 

calc:
add    ax, bx         ; suma bx y ax. 
jmp    back           ; va a la etiqueta 'back'. 

stop:

ret                   ; return to operating system. 

Resultado:

Salto condicional (CMP):

Hay instrucciones que realizan saltos condicionales (salta solo cuando alguna condiciones están en acción)


Programa 2: Salto condicional, Compara un número

Código: 

include "emu8086.inc"

org    100h

mov    al, 25     ; establece al a 25. modificar a 10 para probar el igual
mov    bl, 10     ; establece bl a 10. 

cmp    al, bl     ; compara al - bl. 
je     equal      ; salta si al = bl (zf = 1). 

putc   'n'        ; si llega aqui, entonces al <> bl,

print  'No es igual'  

jmp    stop       ;  imprime 'n', y salta a stop. 

equal:            ; si llega aqui, 
putc   'y'        ; entonces al = bl, imprime 'y'. 
print  'Es igual'   
stop:

ret               ; llega aqui no importa que. 

Resultado:

Se asigna valores a los registros, compara  "al" y "bl".

Al ser diferente imprime n "No es igual".

En caso de comparar valores iguales imprime lo siguiente:

Instrucción LOOP:

Programa 3: LOOP Imprime 5 veces 1233333233333233333233333233333, se usa push para decrementar

Código:

org 100h

mov bx, 0  ; contador de pasos total. 

mov cx, 5
k1: 
   ;add bx, 1
    mov al,' ' ;guardamos un espacio en al 
    mov ah, 0eh

    int 10h 

    mov al, '1' ; al=1
    mov ah, 0eh ;invoca el servicio de impresion video
    int 10h     ;imprimimos
    push cx     ;resta 1 a cx: cx=cx-1 para loop1
    mov cx, 5   ;cx a 5 para loop 2
      k2: 
      ;add bx, 1
      mov al, '2'  ;al=2
      mov ah, 0eh  ;impresion de video    
      int 10h      ;imprime
      push cx        ;decrementa -1 loop2
         mov cx, 5    ;cx=5 loop3
         k3: add bx, 1  ;
         mov al, '3'    ;al=3
         mov ah, 0eh    ;impresion video
         int 10h        ;imprimimos
         loop k3    ; internal in internal loop. 
      pop  cx       ;resta 1 a cx loop3
      loop  k2      ; internal loop. bucle interno
    pop cx          ;resta 1 a cx loop2
loop k1             ; external loop. bucle externo

ret   ;retornamos control al ordenador

Resultado:

Instrucciones de salto que prueban una sola bandera.

Saltar instrucciones para números firmados.

 Saltar instrucciones para números sin firmar.

Bucle

Referencia:

https://www.youtube.com/watch?v=Ng4YEb2Jtcg
http://jbwyatt.com/253/emu/asm_tutorial_07.html
https://www.youtube.com/watch?v=llCG44dzPQM

2. Comparaciones, saltos, ciclos condicionales, incrementos y decrementos

Sentencias condicionales 

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:

• Bucles sin fin
• Bucles por conteo
• Bucles hasta
• Bucles mientras

Las instrucciones de control de bucles son las siguientes:

La instrucción LOOP va acompañada de el registro CX como contador, que es para la iteración.

Instrucciones de prueba, Comparación y Saltos.

CMP y TEST son como el if compara y verifica.



Referencia:
http://moisesrbb.tripod.com/unidad5.htm#u511
https://drive.google.com/file/d/1GEXHus3zVUPLlDw4ASeUjRXcp53D_c31/view
http://jbwyatt.com/253/emu/asm_tutorial_07.html

1.8 DESPLEGADO DE MENSAJES EN EL MONITOR

Int 21H

Esta interrupción tiene varias funciones, para acceder a cada una de ellas es necesario que el el registro AH se encuentre el número de función que se requiera al momento de llamar a la interrupción.

Funciones para desplegar información

02H Exhibe salida

Uso: Despliega un carácter a la pantalla.

Registros de llamada:

AH = 02H

DL = Valor del caracter a desplegar.

09H Impresión de cadena

Uso: Despliega una cadena de caracteres en la pantalla.

Registros de llamada:

AH = 09H

DS:DX = Dirección de inicio de una cadena de caracteres

Esto se puede hacer de 2 maneras, utilizando offset o con el nemónico lea.

offset va a conseguir cada dirección de memoria de cada carácter y lo devolverá a la 
instrucción solicitada.

Con lea esta solicitud de direcciones por cada carácter se hace de forma automática.

Libreria emu8086.inc