martes, 19 de marzo de 2019

Programa multiplicacion Ej. 2 19/03/2019



 .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   

Creditos: Maestra Yolanda


Programa con loopz 19/03/2019

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

creditos: sauceda carolina


jueves, 7 de marzo de 2019

Practica 07/03/2019 "Programa que dice si el numero es mayor , menor o igual"




include "emu8086.inc"
.model small
.stack
.data
   num1 db 7
   num2 db 7
   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:
 printn "Los numeros son iguales"
 jmp fin
  
mayor2:
 printn "Numero 2 es mayor"
 jmp fin
 
 
mayor1:
 printn "Numero 1 es mayor"
 jmp fin
 
 fin:

Practica 07/03/2019


org    100h

mov    ax, 5          ;poner el hacha a 5.
mov    bx, 2          ;  establece bx en 2.

jmp    calc            ; ir a 'calc'. 

back:  jmp stop      ; ir a 'parar'. 

calc:
add    ax, bx         ; Anadir bx al hacha. 
jmp    back           ; Regresa. 

stop:

ret                   ; Regresa al sistema operativo.

miércoles, 6 de marzo de 2019

Estructuras Condicionales

                Las estructuras condicionales comparan una variable contra otro(s)valor (es), para que en base al resultado de esta comparación, se siga un curso de acción dentro del programa. Cabe mencionar que la comparación se puede hacer contra otra variable o contra una constante, según se necesite. Existen tres tipos básicos, las simples, las dobles y las múltiples. 

Simples: 

Las estructuras condicionales simples se les conoce como “Tomas de decisión”. Estas tomas de decisión tienen la siguiente forma: 

Pseudocódigo:Diagrama de flujo:
Dobles: 

Las estructuras condicionales dobles permiten elegir entre dos opciones o alternativas posibles en función del cumplimiento o no de una determinada condición. Se representa de la siguiente forma: 

Pseudocódigo:Diagrama de flujo:

Donde:
 
Si:Indica el comando de comparación 

Condición : Indica la condición a evaluar 

Entonces : Precede a las acciones a realizar cuando se cumple la condición 

Instrucción(es):Son las acciones a realizar cuando se cumple o no la condición 

si no :Precede a las acciones a realizar cuando no se cumple la condición 
Dependiendo de si la comparación es cierta o falsa, se pueden realizar una o más acciones. 

Múltiples: 

Las estructuras de comparación múltiples, son tomas de decisión especializadas que permiten comparar una variable contra distintos posibles resultados, ejecutando para cada caso una serie de instrucciones especificas. La forma común es la siguiente: 

Pseudocódigo:Diagrama de flujo:
Múltiples (En caso de): 

Las estructuras de comparación múltiples, es una toma de decisión especializada que permiten evaluar una variable con distintos posibles resultados, ejecutando para cada caso una serie de instrucciones especificas. La forma es la siguiente: 

Pseudocódigo:Diagrama de flujo:
Veamos algunos ejemplos donde se aplique todo lo anterior: 

Realizar un algoritmo en donde se pide la edad del usuario; si es mayor de edad debe aparecer un mensaje indicándolo. Expresarlo en Pseudocódigo y Diagrama de flujos. 

Pseudocódigo:Diagrama de flujo:
Se pide leer tres notas del alumno, calcular su definitiva en un rango de 0-5 y enviar un mensaje donde diga si el alumno aprobó o reprobó el curso. Exprese el algoritmo usando Pseudocódigo y diagrama de flujos. 

Unidad 2 "Programacion Basica"

Indice


2.1 Ensamblador (y ligador) a utilizar

2.2 Ciclos numéricos 

2.3 Captura básica de cadenas 

2.4 Comparación y prueba 

2.5 Saltos 

2.6 Ciclos condicionales 

2.7 Incremento y decremento 

2.8 Captura de cadenas con formato 

2.9 Instrucciones aritméticas 

2.10 Manipulación de la pila 

2.11 Obtención de cadena con representación decimal

2.12 Instrucciones lógicas 

2.13 Desplazamiento y rotación 

2.14 Obtención de una cadena con la representación hexadecimal

 2.15 Captura y almacenamiento de datos numéricos

 2.16 Operaciones básicas sobre archivos de disco


Macros

             Las macros son instrucciones complejas formadas de instrucciones más sencillas, sirven cuando se quieren hacer procesos repetitivos.

Los macros sirven para:
-Ahorrar código cuando se quiere hacer un proceso repetitivo.
-Menos errores al momento de realizar código repetitivo.
-Permite hacer uso de variables que son pasados como parámetros.
-Mayor seguridad en el código, se pueden invocar desde un archivo externo al programas ASM.

Las macros se definen al inicio de un programa, antes de .model:

nombreMacro MACRO [parametros] ;Los parámetros son opcionales.
  instrucciones...
ENDM  ;Indica fin del macro.

inicio macro   ;declaramos la macro, le damos el nombre de inicio
  mov ax,@data   ;Cargamos el segmento de datos.
  mov ds,ax
  mov dx,ax
endm

.model small
.stack 64
.data
  msj db 'Este es mi primer macro', 10,13,'$'
.code
  inicio  ;Llamamos al macro, lo único que hace es cargar msj del segmento de datos.
  mov ah,09h
  lea dx,msj ;puede ser mov dx,offset msj
  int 21h
  mov ax,4c00h ;Sale del programa
  int 21h
end

Procedimientos


             Conjunto de instrucciones que realizan una tarea -y preferentemente solo una- que se ha de utilizar en más de una ocasión pero se declara una sola vez en el código fuente.

Un procedimiento puede llamar a otro, y este a su vez a otro y así sucesivamente.

ENDP
Es una directiva que indica donde termina el procedimiento

Nombre ENDP

Nótese que nombre de PROC y de ENDP deben ser el mismo.
Se recomienda que cada procedimiento salve y recupere registros, por lo que debe usar PUSHA al principio y POPA al final.

RET
Permite que el programa principal vuelva al procedimiento que lo llamó (DOS) o bien
Permite que los procedimientos secundarios vuelvan al procedimiento que los llamó (programa principal)

Es una instrucción que recupera la dirección de retorno de la pila para que el programa pueda seguir ejecutándose a partir de la instrucción que sigue a CALL. Se inserta antes de ENDP, su formato es:

RET
Retorno cercano local

PRINT
Imprimir

PRINTN
Imprimir con salto de linea