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. 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. Programa que compara si es mayor de edad

Condicionales

Programa 1: 

Compara al ingresar la edad si es mayor o menor de edad.

Código:

org 100h

.model small

.stack ; segmento de pila


.data 

diez db 10; variable para poder imprimir dos caracteres(se multiplica por el 1 valor) 
num1 db 0 ; variable para edad
mens db 'Ingrese la edad: $'
mens1 db 10, 13, 'Eres mayor de Edad $'
mens2 db 10, 13, 'Eres menor de Edad $'

.code
    inicio proc Far
        mov ax, @data ; direccionamiento del seg
        mov ds, ax ;los datos se mueven al registro de ax
       
        ; poner el primer letrero  


        mov ah, 09 ;impresion
        lea dx, mens
        int 21h

        
        mov ah, 01
        int 21h  
        sub al, 30h ;convierte el valor 
        mul diez ;se multiplica el numero ingresado para las decenas
        mov num1, al

        ;pedir segundo valor
        
        mov ah, 01
        int 21h
        sub al, 30h ;resta lo que se guardo en al con 30h
        add num1, al ; se suma a las decenas obtenidas 
        mov al, num1 ;
        
        cmp al, 18 ; compara si en el registro al es 18    

        ;en caso de que sea mayor jge mayor o igual
        jge mayor ;en caso de que sea mayor va a la etiqueta
        jmp menor ;va a la etiqueta menor, si es menor el num 18
        
        mayor:
            mov ah, 09
            lea dx, mens1
            int 21h      
            jmp fin 

        menor:  
            mov ah, 09
            lea dx, mens2
            int 21h      
            jmp fin  ;va a la etiqueta fin
          
        fin: ; fin de programa
            mov ax, 4c00h   
      
 inicio endp

    end inicio

ret

Resultado:

1. Programa que al ingresar una calificación, muestra si has aprobado o reprobado

Programa: Calificación 

Al ingresar una calificación, muestra si has aprobado o reprobado

Al ingresar un calificación al sistema, se mostrara un mensaje aprobado o reprobado, al introducir uno y dos dígitos.

Código:

org 100h

.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 ;inicia el segmento de codigo 

Resultado PROC FAR ;procedimiento
    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 segundo caracter
    mov ah, 01
    int 21h
    mov VAR2,ax
;----------------tercer caracter
    mov ah, 01
    int 21h
    mov VAR3,ax
;-----momento de evaluar la calificacion
    CMP al, 13  ; para comparar  
    JE CONTINUE ;salta si es iguala 13
    JMP MAYOR   ;salta 
;----INICIA FUNCION

CONTINUE:  ;
    mov ax, VAR1 ;valor tomado para comparar
    CMP AL, 037h ;7 es 37 en ASCII
    JGE MAYOR   ; salta si es mayor o igual a 7 va a 'mayor'
    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 ; o 4ch
    int 21h    

RESULTADO endp

end RESULTADO 

    ret

En el código, estamos guardando tres valores en nuestras variables. Al ingresar la calificación (80), guardamos el 8 en código ascii en una variable (var1), el 0 en otra variable(tambien en ascii, var2) y finalmente el enter en la ultima variable(var3), en cambio si ingresamos solo un dígito nos funciona el programa, ya que se compara lo que se encuentra en var1.

Ejecución 1:

Ejecución 2: