Mostrando entradas con la etiqueta Unidad 2. Mostrar todas las entradas
Mostrando entradas con la etiqueta Unidad 2. Mostrar todas las entradas

martes, 2 de abril de 2019

Ejemplo Loopz

Ejemplo

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



    ;colocar el retorno de carro para ir al inicio

    mov al,13

    int 10h

    ;prepara la salida del programa

    mov ax,4c00h

    int 21h

end inicio

Multiplicación con 2 cifras

Ejemplo

.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

Se encuentra palabra

Ejemplo

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                ;mostrar contenido en dx  
  
final: 



ret   

msg db "tecnologico$"
msg2 db "tec$"

msg3 db "Si se encuentra$"

Despliegue de letreros ( Lea, Macro y Offset )

Despliegue con letrero con lea


org 100h 

.model tiny

.data
    dato db 10,13, 'letrero $'

.code

INICIO:
mov cx,4

comienzo:

mov ah,09h
    lea dx,dato
    int 21h

loop comienzo

ret

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

Despliegue de letrero con macro



ORG 100H

INCLUDE 'EMU8086.INC'


MOV CX,4

COMIENZO:

PRINTN 'LETRERO'

LOOP COMIENZO

RET




----------

Despliegue con letrero con offset

org 100h 

.model tiny

.data
    dato db 10,13, 'letrero $'

.code

INICIO:
mov cx,4

comienzo:



mov ah,09h
    ;lea dx,dato
    mov dx,OFFSET DATO
    int 21h

loop comienzo

ret

jueves, 7 de marzo de 2019

JMP

Ejemplo




saltos condicionales

.model small

.stack

.data

include 'emu8086.inc'


num1 db 8

num2 db 9

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

jz igual

jnz mayor1

.exit

igual:

;printn 'numeros iguales'

jmp fin


mov ah,09h

lea dx,msg1

int 21h

jmp fin


mayor1:


;printn 'el numero 1 es mayor'

jmp fin


mov ah,09h

lea dx,msg2

int 21h

jmp fin


mayor2:

;printn 'el numero dos es mayor'

jmp fin


mov ah,09h

lea dx,msg3

int 21h

jmp fin


fin:

ret

miércoles, 6 de marzo de 2019

Ciclos Condicionales

LOOP etiqueta

La instrucción loop decrementa CX en 1, y transfiere el flujo del programa a la
etiqueta dada como operando si CX es diferente a 1.

Instrucción LOOPE

Propósito: Generar un ciclo en el programa considerando el estado de ZF

Sintaxis:

LOOPE etiqueta

Esta instrucción decrementa CX en 1. Si CX es diferente a cero y ZF es igual a 1,
entonces el flujo del programa se transfiere a la etiqueta indicada como operando.

Instrucción LOOPNE

Propósito: Generar un ciclo en el programa, considerando el estado de ZF

Sintaxis:

LOOPNE etiqueta

Esta instrucción decrementa en uno a CX y transfiere el flujo del programa solo si
ZF es diferente a 0.