LENGUAJE EMSAMBLADOR

MODULO I

SIGEDY - 2004

Potosí - Bolivia

S U M A R I O

1.- INTRODUCCION Pag.2

2.- DEFINICION DEL PROBLEMA Pag.3

3.- OBJETIVO Pag.6

4.- ANALISIS Y DISEÑO Pag.7

4.1.- DISEÑO MODULAR Pag.7

4.1.- DISEÑO DETALLADO Pag.18

5.- PASOS DE CORRIDO Pag.20

6.- CONCLUSIONES Pag.24

7.- BIBLIOGRAFIA Pag.25

1.- INTRODUCCION.

El presente documento contiene las especificaciones del primer Modulo de la maquina de calcular a realizar en la asignatura de TALLER DE PROGRAMACION EN BAJO NIVEL cuya docencia se imparte durante el quinto semestre de la carrera de Informática.

El programa realizado en el modulo I tiene la finalidad de la simulación de una maquina de Calcular sencilla que tiene las operaciones más básicas que son:

• Suma

• Resta

• Producto

• División

• Raíz cuadrada

Para este fin se hace uso del las interrupciones int 16h, int 10h, int 21h

En el programa se esta queriendo resolver mediante llamadas a funciones de suma, resta, multiplicación, división y raíz cuadrada, las mismas que trabajan juntamente con la computadora en sistema de numeración hexadecimal, cuyos resultados seran obtenidos en este sistema y convertidos a decimal para su visualización. El cual fue motivo del estudio de la conversión del sistema hexadecimal al sistema decimal.

En el programa se quiere resolver mediante la introducción de datos introducidos por teclado para luego realizar la operación requerida y visualizar la respuesta

2.- DEFINICION DEL PROBLEMA

• SELECCIÓN DEL TEMA

AREA DE INTERES.- se llego a tomar el tema de una simulación de una maquina calculadora para conocer el funcionamiento interno de una maquina de calcular, que operaciones, conversiones realiza y como lo realiza.

NECESIDAD.- Es necesario tener una maquina de calcular, por lo menos una sencilla que nos ayude a realizar operaciones, la cual nos ayude a trabajos en operaciones matemáticas y también otros requieren de maquinas científicas las cuales permitan cumplir sus necesidades de su trabajo, sabiendo que una necesidad actual es la utilización de la PC, es que utilizamos esta maquina para la codificación y construcción de la computadora.

¿Como desarrollar la simulación de una maquina de calcular, haciendo uso de las instrucciones del Lenguaje Ensamblador?

R.- El desarrollo de una maquina de calcular se lo realiza mediante uso de instrucciones de un lenguaje ensamblador, tales la suma, resta, etc, haciendo uso de las diferentes interrupciones, como: INT 10h, INT 16h, INT 21h

- OBJETO DE ESTUDIO

Nos referimos al objeto de estudio de una a maquina de calcular con el hecho de tenerla a mano para realizar diferentes funciones matemáticas.

NOVEDOSO. Lo novedoso para el proyecto sigedy es la forma como realizar operaciones con punto decimal ya que solo aprendimos en materia INF -351 solo funciones enteras.

ANTECEDENTES. Todos conocemos una maquina de calcular ya sea una normal o una científica a la cual la utilizamos para diferentes operaciones y/o necesidades en el trabajo, pero no nos conformamos en utilizar la calculadora ya que tenemos que saber como se realizan las operaciones y funciones internas.

PLANIFICACIÓN DEL TRABAJO DEL PROYECTO

TALLER DE PROGRAMACIÓN I N F - 5 3 5

CARRERA DE INFORMATICA

SIGMAR

EDWIN

Nota el programa se realizo los primeros ocho días por separado el cual se investigo de diferentes formas por cada uno.

1

7 de Abril

Planificación de para el proyecto

2

SIGMAR 8 , 9 , 10 Abril

EDWIN 12 , 13 , 14 Abril

Estudio de libros sobre el tema

3

SIGMAR 11 , 12 , 13 , 14 Abril

EDWIN 9 , 10 , 11 Abril

Investigación en Internet

4

15 de Abril

Inicio de actividades grupal y revisión del material de cada uno con la información recabada de cada persona que obtuvo en todos los días que pasaron.

5

16 de Abril

Implementación de los algoritmos para realizar el programa del proyecto.

6

17 de Abril

Realización del programa

7

Solución a los problemas (en el programa)

8

Corrección de los errores en el programa

3.- OBJETIVO.

El objetivo de este proyecto SIGEDY (Simulación de una maquina de Calcular) es realizar las operaciones básicas de una calculadora en lenguaje de bajo nivel, teniendo como reto la introducción de valores por teclado y la obtención de resultados, con la dura tarea de realizar conversiones en el transcurso del programa de un sistema a otro, ya sea hexadecimal, binario y decimal y viceversa.

4.- ANALISIS Y DISEÑO.

4.1.- DISEÑO MODULAR.

PSP mov ah,06

call borrador mov al,00

CS: call caratula Borrador mov bh,09h

call digito mov cx,00

ret mov dx,184fh

int 10h

ret

call cuadro

mov dx,1400h

call cursor

lea dx,mensaje0

call desplegar

mov dx,1500h

call cursor

lea dx,mensaje1

call desplegar

mov dx,1600h

call cursor

lea dx,mensaje2

call desplegar

mov dx,1700h

call cursor

lea dx,mensaje3

call desplegar

mov dx,1427h

call cursor

lea dx,mensaje4

call desplegar

Carátula mov dx,1527h

call cursor

lea dx,mensaje5

call desplegar

mov dx,1627h

call cursor

lea dx,mensaje6

call desplegar

mov dx,1727h

call cursor

lea dx,mensaje7

call desplegar

mov dx,1815h

call cursor

lea dx,mensaje8

call desplegar

mov dx,1838h

call cursor

lea dx,mensaje9

call desplegar

ret

mov cx,00 . mov dx,esa

mov esa,0117h

mov dx,esa

mov fila,17

mov columna,26

call cursor

mov al,223

mov cl,columna

call escribir

call vertical

call cuadro2

cuadro2 mov al,220

mov cl,columna

call escribir

mov dx,esa

add dl,columna

call cursor

call vertical

ret

mov cx,1

mov dx,esa

call cursor

Cuadro mov al,219

call escribir

add dh,fila

call cursor

mov al,219

call escribir

call esquinas

Esquinas

add dl,columna

call cursor

mov al,219

call escribir

sub dh,fila

call cursor

mov al,219

call escribir

ret

mov cx,00

mov dx,esa

mov esa,0318h

mov dx,esa

mov fila,02

mov columna,24

call cuadro2

call esquinas ret

mov ah,02 mov al,fila

Cursor: mov bh,0 push ax

int 10h add fila,dh

ret mov al,219

mov cx,01

siga1:

call escribir

Vertical: inc dh

call cursor

mov ah,0ah cmp fila,dh

Escribir: mov bh,00 jne siga1

int 10h pop ax

ret mov fila,al

ret

mov ah,09

Desplegar: int 21h

ret

mov dx,041eh mov ah,02

call cursor Cursor: mov bh,0

mov bl,74h int 10h

call teclado ret

otro:

call leer2

cmp al,'S'

jz aqui

cmp al,'E' mov ah,07

Digito: jz aquí Leer2: int 21h

jnz otro ret

aqui:

mov bl,14h

call teclado

call tiempo4

mov bl,74h mas:

call teclado mov bx,50

call tiempo4 otri:

call principal dec bx

ret cmp bx,00

jnz otri

mov bx,50

Tiempo4: otri1:

dec bx

cmp bx,00

jnz otri1

dec ax

cmp ax,00

jnz mas

ret

mov contador,00000011b mov ah,02

mov dx,0f22h mov bh,00

call cursor Cursor: int 10h

lea si,digr ret

call cadena

mov contador,00000011b

mov dx,0927h

call cursor

lea si,dig9

call cadena

mov contador,00000011b

mov dx,0b27h

call cursor

lea si,dig10

call cadena

mov contador,00000011b

mov dx,0d27h

call cursor

lea si,dig11

call cadena

mov contador,00000011b

mov dx,092ch

call cursor

lea si,dig12

call cadena

mov contador,00000011b

mov dx,0b2ch

Teclado: call cursor

lea si,dig13

call cadena

mov contador,00000011b

mov dx,0d2ch

call cursor

lea si,dig14

call cadena

mov contador,0fh

mov dx,021ah

call cursor

lea si,dig15

call cadena zoo1:

mov contador,00000011b call cursor

mov dx,0f27h mov al,[si]

call cursor Call solos

lea si,dig16 Inc dl

call cadena Cadena: inc si

mov contador,00000011b dec contador

mov dx,0f2ch cmp contador,00

call cursor jnz zoo1

lea si,dig17 ret

call cadena

mov contador,00000011b

call cursor

ret

seguir:

mov dx,041eh

mov ah,02

call cursor Cursor: mov bh,00

int 10h lea dx,valor1 ret

mov ah,0ah

call leer Leer: int 21h

cmp long_act1,00 ret

mov cl,long_act1

sub ch,ch

lea si,s_e1

add si,cx

mov contador,0000

mov auxiliar1,cx

siga:

mov al,[si-1]

cmp al,'.'

je fin

add contador,0001

dec si

call condecimal Condecimal: loop siga

mov cx,auxiliar1

cmp auxiliar1,cx

jnz fin

mov contador,00

sub cx,cx

fin:

ret

Principal: mov ax,contador

mov contador1,ax

sub ax,ax

mov dx,041eh

call cursor

mov ah,07h

int 21h

call sin_eco Sin_eco: mov dx,041eh

call cursor

ret

sub ah,ah

push ax

mov dx,041eh

call cursor

lea dx,resultado

call mostrar mov ah,09h

Mostrar: int 21h

ret

pop ax

seguir1:

cmp al,'+'

je sumar

cmp al,'-'

je restar

cmp al,'*'

je producto

cmp al,'/'

je division

cmp al,'r'

je raiz

jmp seguir

ret

call introd2

call adicion

mov cx,auxiliar3

Sumar: mov auxiliar,cx

call con_asc

call visualiza

ret

endp

call introd2

Restar: call resta

ret

call introd2

call multiplicar

mov cx,decimal

Producto: mov auxiliar,cx

call con_asc

call visualiza

ret

call introd2

call dividir

Division: call visualiza

ret

call raizcuadrada

Raiz: call visualiza

ret

mov ax,p_binario1

Adicion: add ax,p_binario2

ret

call sustraer

mov cx,auxiliar3

mov auxiliar,cx

js otro4

call con_asc

jmp otro5

otro4:

Resta: neg ax

call con_asc

dec si

mov al,2dh

mov [si],al

otro5:

call visualiza

ret

mov ax,p_binario1

Sustraer: sub ax,p_binario2

ret

mov ax,p_binario1

Multiplicar: mul p_binario2

ret

mov ax,00

mov bx,p_binario1

ultiop0:

sub bx,p_binario2

js ultiop1

mov auxiliar2,bx

add ax,01

jmp ultiop0

ultiop1:

cmp ax,00

jne ultiop2

lea si,resultado+4

mov byteptr[si],'.'

mov ax,p_binario1

Dividir: inc si

mov cx,c_tres

jmp ultiop3

ultiop2:

lea si,resultado+4

sub dx,dx

call con_ascd

inc si

mov cx,c_tres

mov ax,auxiliar2

ultiop3:

mul camdec1

div p_binario2

or al,30h

mov [si],al

inc si

xchg dx,ax

sub dx,dx

loop ultiop3

ret

mov cx,1

mov dx,1

mov ax,valor1

vuelve:

sub ax,cx

cmp ax,0

Raiz jbe vuelve1

Cuadrada inc dx

add cx,2

jmp vuelve

vuelve1:

mov valbin,dx

call con_asc

ret

mov dx,041eh

call cursor

lea dx,valor2

call leer

mov cl,long_act2

sub ch,ch

lea si,s_e2

Introd2: add si,cx

call condecimal

mov ax,contador

mov contador2,ax

call perfecto

call opera1

call opera2

ret

lea si,resultado+6

mov byte ptr[si],'.'

add si,auxiliar

salt0:

cmp byte ptr[si],'.'

jne salt5

dec si

salt5:

cmp dx,00

jnz salt0

Con_asc: cmp ax,0010

jb s50

sal0:

div camdec

or dl,30h

mov [si],dl

dec si

sub dx,dx

jmp salt0

s50:

or al,30h

mov [si],al

ret

mov cx,01

a3:

cmp dx,00

jnz a1

cmp ax,0010

jb a2

a1:

div camdec

or dl,30h

mov [si],dl

Con_ascd: dec si

add cx,01

sub dx,dx

jmp a3

a2:

or al,30h

mov [si],al

i2:

inc si

loop i2

mov byteptr[si],'.'

ret

mov cx,0ah

lea si,resultado+3

mov ax,valbin

otro2:

cmp ax,0ah

jb fin1

xor dx,dx

Con_asc2: div cx

or dl,30h

mov [si],dl

dec si

jmp otro2

fin1:

or al,30h

mov [si],al

ret

mov bl,long_act1

sub bh,bh

lea si,s_e1

add si,bx

mov dl,long_act2

Perfecto: sub dh,dh

lea di,s_e2

add di,dx

call per

ret

mov ax,contador1

cmp ax,contador2

je final

ja sig1

mov ax,contador2

sub ax,contador1

mov cx,ax

sub ch,ch

add long_act1,cl

sig3:

mov ch,30h

mov [si],ch

sub ch,ch

inc si

loop sig3

mov ax,contador2

mov auxiliar3,ax

sub ah,ah

mul c_dos

mov decimal,ax

ret

sig1:

sub ax,contador2

Per: mov cx,ax

sub ch,ch

add long_act2,cl

sig2:

mov ch,30h

mov [di],ch

sub ch,ch

inc di

loop sig2

mov ax,contador1

mov auxiliar3,ax

sub ah,ah

mul c_dos

mov decimal,ax

ret

final:

mov ax,contador2

mov auxiliar3,ax

sub ah,ah

mul c_dos

mov decimal,ax

ret

mov cl,long_act1

sub ch,ch

lea si,s_e1

add si,cx

Opera1: call asc_bin

mov ax,valor

mov p_binario1,ax

ret

mov cl,long_act2

sub ch,ch

lea si,s_e2

add si,cx

Opera2: call asc_bin

mov ax,valor

mov p_binario2,ax

ret

mov p_mul,0001

mov valor,00

sub bx,bx

asbin2:

mov al,[si-1]

cmp al,'.'

jne asbin1

jmp asbin3

asbin1:

Asc_bin: and ax,000fh

mul p_mul

add valor,ax

mov ax,p_mul

mul camdec

mov p_mul,ax

asbin3:

dec si

loop asbin2

ret

mov dx,0425h

call cursor

Visualiza: call mostrar

mov dx,041eh

call cursor

ret

lea dx,resultado

mov ah,09h

Mostrar: int 21h

ret

mov ah,0ah

Leer: int 21h

ret

mov ah,02

mov bh,0

Cursor: int 10h

ret

mov ah,0ah

mov bh,00

Escribir: int 10h

ret

mov ah,09

Desplegar: int 21h

ret

zoo1:

call cursor

mov al,[si]

call solos

inc dl

Cadena: inc si

dec contador

cmp contador,00

jnz zoo1

ret

mov cx,01h

mov ah,09h

Solos: mov bh,00

int 10h

ret

mov ah,07

leer2: int 21h

ret

mas:

mov bx,50

otri:

dec bx

cmp bx,00

jnz otri

mov bx,50

otri1:

Tiempo4: dec bx

cmp bx,00

jnz otri1

dec ax

cmp ax,00

jnz mas

ret

mov contador,00000011b mov ah,02

mov dx,0f22h mov bh,00

call cursor Cursor: int 10h

lea si,digr ret

call cadena

mov contador,00000011b

mov dx,0927h

call cursor

lea si,dig9

call cadena

mov contador,00000011b

mov dx,0b27h

call cursor

lea si,dig10

call cadena

mov contador,00000011b

mov dx,0d27h

call cursor

lea si,dig11

call cadena

mov contador,00000011b

mov dx,092ch

call cursor

lea si,dig12

call cadena

mov contador,00000011b

mov dx,0b2ch

Teclado: call cursor

lea si,dig13

call cadena

mov contador,00000011b

mov dx,0d2ch

call cursor

lea si,dig14

call cadena

mov contador,0fh

mov dx,021ah

call cursor

lea si,dig15

call cadena zoo1:

mov contador,00000011b call cursor

mov dx,0f27h mov al,[si]

call cursor Call solos

lea si,dig16 Inc dl

call cadena Cadena: inc si

mov contador,00000011b dec contador

mov dx,0f2ch cmp contador,00

call cursor jnz zoo1

lea si,dig17 ret

call cadena

mov contador,00000011b

call cursor

ret

seguir:

mov dx,041eh

mov ah,02

call cursor Cursor: mov bh,00

int 10h lea dx,valor1 ret

mov ah,0ah

call leer Leer: int 21h

cmp long_act1,00 ret

mov cl,long_act1

sub ch,ch

lea si,s_e1

add si,cx

mov contador,0000

mov auxiliar1,cx

siga:

mov al,[si-1]

cmp al,'.'

je fin

add contador,0001

dec si

call condecimal Condecimal: loop siga

mov cx,auxiliar1

cmp auxiliar1,cx

jnz fin

mov contador,00

sub cx,cx

fin:

ret

Principal: mov ax,contador

mov contador1,ax

sub ax,ax

mov dx,041eh

call cursor

mov ah,07h

int 21h

call sin_eco Sin_eco: mov dx,041eh

call cursor

ret

sub ah,ah

push ax

mov dx,041eh

call cursor

lea dx,resultado

call mostrar mov ah,09h

Mostrar: int 21h

ret

pop ax

seguir1:

cmp al,'+'

je sumar

cmp al,'-'

je restar

cmp al,'*'

je producto

cmp al,'/'

je division

cmp al,'r'

je raiz

jmp seguir

ret

call introd2

call adicion

mov cx,auxiliar3

Sumar: mov auxiliar,cx

call con_asc

call visualiza

ret

endp

call introd2

Restar: call resta

ret

call introd2

call multiplicar

mov cx,decimal

Producto: mov auxiliar,cx

call con_asc

call visualiza

ret

call introd2

call dividir

Division: call visualiza

ret

call raizcuadrada

Raiz: call visualiza

ret

mov ax,p_binario1

Adicion: add ax,p_binario2

ret

call sustraer

mov cx,auxiliar3

mov auxiliar,cx

js otro4

call con_asc

jmp otro5

otro4:

Resta: neg ax

call con_asc

dec si

mov al,2dh

mov [si],al

otro5:

call visualiza

ret

mov ax,p_binario1

Sustraer: sub ax,p_binario2

ret

mov ax,p_binario1

Multiplicar: mul p_binario2

ret

mov ax,00

mov bx,p_binario1

ultiop0:

sub bx,p_binario2

js ultiop1

mov auxiliar2,bx

add ax,01

jmp ultiop0

ultiop1:

cmp ax,00

jne ultiop2

lea si,resultado+4

mov byteptr[si],'.'

mov ax,p_binario1

Dividir: inc si

mov cx,c_tres

jmp ultiop3

ultiop2:

lea si,resultado+4

sub dx,dx

call con_ascd

inc si

mov cx,c_tres

mov ax,auxiliar2

ultiop3:

mul camdec1

div p_binario2

or al,30h

mov [si],al

inc si

xchg dx,ax

sub dx,dx

loop ultiop3

ret

mov cx,1

mov dx,1

mov ax,valor1

vuelve:

sub ax,cx

cmp ax,0

Raiz jbe vuelve1

Cuadrada inc dx

add cx,2

jmp vuelve

vuelve1:

mov valbin,dx

call con_asc

ret

mov dx,041eh

call cursor

lea dx,valor2

call leer

mov cl,long_act2

sub ch,ch

lea si,s_e2

Introd2: add si,cx

call condecimal

mov ax,contador

mov contador2,ax

call perfecto

call opera1

call opera2

ret

lea si,resultado+6

mov byte ptr[si],'.'

add si,auxiliar

salt0:

cmp byte ptr[si],'.'

jne salt5

dec si

salt5:

cmp dx,00

jnz salt0

Con_asc: cmp ax,0010

jb s50

sal0:

div camdec

or dl,30h

mov [si],dl

dec si

sub dx,dx

jmp salt0

s50:

or al,30h

mov [si],al

ret

mov cx,01

a3:

cmp dx,00

jnz a1

cmp ax,0010

jb a2

a1:

div camdec

or dl,30h

mov [si],dl

Con_ascd: dec si

add cx,01

sub dx,dx

jmp a3

a2:

or al,30h

mov [si],al

i2:

inc si

loop i2

mov byteptr[si],'.'

ret

mov cx,0ah

lea si,resultado+3

mov ax,valbin

otro2:

cmp ax,0ah

jb fin1

xor dx,dx

Con_asc2: div cx

or dl,30h

mov [si],dl

dec si

jmp otro2

fin1:

or al,30h

mov [si],al

ret

mov bl,long_act1

sub bh,bh

lea si,s_e1

add si,bx

mov dl,long_act2

Perfecto: sub dh,dh

lea di,s_e2

add di,dx

call per

ret

mov ax,contador1

cmp ax,contador2

je final

ja sig1

mov ax,contador2

sub ax,contador1

mov cx,ax

sub ch,ch

add long_act1,cl

sig3:

mov ch,30h

mov [si],ch

sub ch,ch

inc si

loop sig3

mov ax,contador2

mov auxiliar3,ax

sub ah,ah

mul c_dos

mov decimal,ax

ret

sig1:

sub ax,contador2

Per: mov cx,ax

sub ch,ch

add long_act2,cl

sig2:

mov ch,30h

mov [di],ch

sub ch,ch

inc di

loop sig2

mov ax,contador1

mov auxiliar3,ax

sub ah,ah

mul c_dos

mov decimal,ax

ret

final:

mov ax,contador2

mov auxiliar3,ax

sub ah,ah

mul c_dos

mov decimal,ax

ret

mov cl,long_act1

sub ch,ch

lea si,s_e1

add si,cx

Opera1: call asc_bin

mov ax,valor

mov p_binario1,ax

ret

mov cl,long_act2

sub ch,ch

lea si,s_e2

add si,cx

Opera2: call asc_bin

mov ax,valor

mov p_binario2,ax

ret

mov p_mul,0001

mov valor,00

sub bx,bx

asbin2:

mov al,[si-1]

cmp al,'.'

jne asbin1

jmp asbin3

asbin1:

Asc_bin: and ax,000fh

mul p_mul

add valor,ax

mov ax,p_mul

mul camdec

mov p_mul,ax

asbin3:

dec si

loop asbin2

ret

mov dx,0425h

call cursor

Visualiza: call mostrar

mov dx,041eh

call cursor

ret

lea dx,resultado

mov ah,09h

Mostrar: int 21h

ret

mov ah,0ah

Leer: int 21h

ret

mov ah,02

mov bh,0

Cursor: int 10h

ret

mov ah,0ah

mov bh,00

Escribir: int 10h

ret

mov ah,09

Desplegar: int 21h

ret

zoo1:

call cursor

mov al,[si]

call solos

inc dl

Cadena: inc si

dec contador

cmp contador,00

jnz zoo1

ret

mov cx,01h

mov ah,09h

Solos: mov bh,00

int 10h

ret

mov ah,07

leer2: int 21h

ret

mas:

mov bx,50

otri:

dec bx

cmp bx,00

jnz otri

mov bx,50

otri1:

Tiempo4: dec bx

cmp bx,00

jnz otri1

dec ax

cmp ax,00

jnz mas

ret

4.1.- DISEÑO DETALLADO

4.1.1.- MODULO I

SIGEDY.exe

4.1.2.- DATOS DE ENTRADA.

Dos datos de entrada en valor decimal almacenadas en las variables y un operador

valor1 label byte

long_max1 db 6

long_act1 db ?

s_e1 db 10 dup(?),'$'

valor2 label byte

long_max2 db 6

long_act2 db 0

s_e2 db 10 dup(?),'$'

4.1.3.- DATOS DE SALIDA.

Obtención los resultados numéricos de las operaciones realizadas con las variables de entrada, almacenándolas en la variables resultado, para luego ser visualizadas con:

visualiza proc

mov dx,0425h

call cursor

call mostrar

mov dx,041eh

call cursor

ret

visualiza endp

cursor proc

mov ah,02

mov bh,0

int 10h

ret

cursor endp

mostrar proc

lea dx,resultado

mov ah,09h

int 21h

ret

mostrar endp

4.1.4.- ALGORITMO.

Paso 1. Introducir primer dato

Paso 2. Introducir operación a realizar, mientras

no coincida con ninguna operación, hacer

Paso 2, en otro caso

Paso 3. si = `+'

Paso 3.1 Introducir segundo dato

Paso 3.2 Adicionamos los valores

Paso 3.2.1 Convertimos a Ascii y Decimal

Paso 3.3 Visualizamos resultado

Paso 4. si = `-'

Paso 4.1 Introducir segundo dato

Paso 4.2 Restamos los valores

Paso 4.2.1 Convertimos a Ascii y Decimal

Paso 4.3 Visualizamos resultado

Paso 5. si = `*'

Paso 5.1 Introducir segundo dato

Paso 5.2 Multiplicación de valores

Paso 5.2.1 Convertimos a Ascii y Decimal

Paso 5.3 Visualizamos resultado

Paso 6. si = `/'

Paso 6.1 Introducir segundo dato

Paso 6.2 Dividimos los valores

Paso 6.2.1 Convertimos a Ascii y Decimal

Paso 6.3 Visualizamos resultado

Paso 7. si = `r'

Paso 7.1 Hallamos el valor de la raiz

Paso 7.2 Convertimos a Ascii y Decimal

Paso 7.3 Visualizamos resultado

Paso 8. Mientras no cumpla S = `S'hacer

desde Paso 1

Paso 9. Salir

5.- PASOS DE CORRIDO.

A continuación se implementa en detalle un corrido del programa en cada uno de sus pasos en forma grafica

ICONO DE ACCESO DIRECTO AL PROGRAMA EJECUTABLE

SIGEDY.EXE

Esta primera grafica muestra el ingreso al programa de bajo nivel, teniendo un acceso directo en el escritorio del computador

PASOS PARA LA OBTENCION DEL PROGRAMA

SIGEDY.EXE

La presente gráfica nos muestra todos los pasos, que se siguen para la obtención de un programa ejecutable en lenguaje ensamblador, a través de los pasos de ensamblado, enlace

VISUALIZACION DEL PROGRAMA

SIGEDY.EXE

Esta es la visualización obtenida, a través de la simulación de una maquina de calcular, editada, ensamblado, enlazada y obtención del programa ejecutable, enteramente hecha en lenguaje de bajo nivel (Ensamblador)

6.- CONCLUSIONES.

El proyecto del registro de una Parroquia realizado en el Lenguaje de Alto nivel (C++) fue interesante, ya que se aprendió a identificar los errores que uno tiene al realizar programas en lenguaje c++ y además a mejorar el conocimiento respectivo del programa, lo mas novedoso para JHOPAT fue el trabajo que nos tomo realizar de los archivos , ya que fue un tema muy interesante que aprendimos para nuestros conocimientos propios y el de guardar en un disco duro o disquetera

7.- BIBLIOGRAFIA

• Lenguaje ensamblador y programas par IBM, PC y Compatibles “PETER ABEL“ Tercera edición 1996.

• Assembly Language For IBM Microcomputers

J. Terry Godfrey

Prentice Hall Hispanoamericana, S.A. Mexico

• Basic Assembler

A. Rojas

Ed Computec Editores S.A. de C.V. Mexico

• IBM Personal Computer Assembly Language Tutorial

Joshua Auerbach

• www.assemblybr.hpg.ig.com.br

• http://www.faroc.com.au/~blackcat

• http://www.geocities.com/SiliconValley/Park/3174

ENTRADA SIGEDY.EXE

Abril	7	8	9	10	11	12	13	14	15	16	17	18	19	20	21	22	23
Nro de dias	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15	16
1
2
3
4
5
6
7
8

Fecha Abril	7	8	9	10	11	12	13	14	15	16	17	18	19	20	21	22	23
Nro de dias	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15	16
1
2
3
4
5
6
7
8

Maquina calculadora

Digito

Borrador

Carátula

Desplegar

Cuadro

Cursor

Cuadro2

Esquinas

Cursor

Escribir

Vertical

Cursor

Escribir

Cursor

Escribir

Principal

Tiempo

Cursor

Teclado

Cadena

Cursor

Sin_eco

Cursor

Condecimal

Sumar

Restar

Visualizar

Con_asc

Introd2

Adición

Perfecto

Condecimal

Cursor

Leer

Mostrar

Opera2

Opera1

Asc_bin

Per

Introd2

Resta

Perfecto

Condecimal

Leer

Opera2

Opera1

Asc_bin

Per

Cursor

Visualizar

Con_asc

Sustraer

Mostrar

E

División

Producto

Raíz

E

Visualizar

Con_asc

Introd2

Adición

Perfecto

Condecimal

Cursor

Leer

Mostrar

Opera2

Opera1

Asc_bin

Per

Perfecto

Condecimal

Leer

Opera2

Opera1

Asc_bin

Per

Cursor

Visualizar

Con_asc

Introd2

DividirAdición

Mostrar

Perfecto

Condecimal

Leer

Opera2

Opera1

Asc_bin

Per

Cursor

Visualizar

Con_asc

Introd2

DividirAdición

Mostrar