Qu es SimuProc?

SimuProc es un Simulador de un Procesador Hipottico con el cual podrs aprender

las nociones bsicas para empezar a programar en lenguaje ensamblador, en el cual
podemos observar todo el proceso interno de ejecucin del programa a travs de
cada ciclo del procesador.
SimuProc con su gran variedad de instrucciones (50+) es un simulador con el cual
tienes infinitas posibilidades de pruebas.
Incluye soporte para nmeros de punto flotante usando IEEE 754 y enteros desde 2GB hasta 2GB
Qu mas incluye?
Un Editor con resaltador de sintaxis para escribir mas facilmente tus programas.
SimuProc tambin incluye un conversor de bases por si se necesita realizar alguna
conversin de una base a cualquier otra base. Soporta todas las bases desde
base2 a base36. Y conversin de numeros de punto flotante de decimal a IEEE 754
y viceversa.
Preguntas mas Frecuentes
Cmo puedo trabajar con nmeros no enteros (de punto flotante)? A partir de
la version 1.4 ya es posible hacer operaciones con estos numeros usando las
instrucciones ADDF SUBF MULF y DIVF, para llevar los numeros de registros a
memoria y viceversa usando LDF y STF, y para mostrar estos en pantalla usando el
puerto 1 con las instrucciones IN y OUT.
Como trabajar con Nmeros de mas de 16 bits (mayores de 65535)? Con las
instucciones aritmeticas para numeros flotantes, puedes tambien trabajar con
enteros entre -2147483647 y 2147483647.
Muchas de las instrucciones que manejas no las he utilizado, podras
proporcionarme informacin de las instrucciones? El 90% de las instrucciones
son de un procesador Intel, las otras son para abreviar otras instrucciones mas
complicadas como interactuar con el usuario para pedir datos de entrada o
escribirlos en pantalla.
Do you have an English version of your program? Desde la versin 1.3 de
SimuProc est disponible en ambos, ingles y espaol. Si el usuario lo desea este
tambien se puede traducir a otros idiomas.
Sabes algunos sitios sobre ensamblador? Si, mira algunos a la derecha en el
cuadro de enlaces.
Hay versin para GNU/linux? no, pero lo puedes hacer funcionar mediante wine
Tengo una duda o pregunta o quiero hacer algn comentario o aclaracin, qu
puedo hacer? Puedes usar la pgina de comentarios de SimuProc.

Que es el ensamblador o Assembler?

El assembler es un lenguaje de programacin de bajo nivel.
Necesitas saber un Poco de la estructura de un computador para poder entender algo.
La CPU es el corazn de un computador, casi todas las computaciones ocurren dentro de esta.
La memoria Ram es el lugar donde los programas estn cargados para poder ser ejecutados.

La CPU trabaja usando binario. Electrnicamente esto es hecho con switches que estn o
encendidos o apagados. Esto es representado por ceros y unos. Un solo BIT o digito binario
requiere un cable o switch dentro de la CPU. Usualmente los datos son manipulados en
BYTES o mltiplos de bytes. Un byte es un grupo de ocho bits. Un byte luce as: 01101011
Esto es un inconveniente para leer, decir y escribir, as que los programadores usan
hexadecimal para representar los bytes. Convertir entre binario y hexadecimal no es difcil.
Primero se divide el byte en dos nybbles (Medio byte) as:
0110 1011
Luego usando la siguiente tabla:
BINARIO
0000
0001
0010
0011
0100
0101
0110
0111
1000
1001
1010
1011
1100
1101
1110
1111

HEXADECIMAL
DECIMAL
0
0
1
1
2
2
3
3
4
4
5
5
6
6
7
7
8
8
9
9
A
10
B
11
C
12
D
13
E
14
F
15

0110 1011 = 6B
Gracias a la cantidad de instrucciones que soporta el SimuProc tienes muchas posibilidades
para resolver bastantes problemas y hacer una gran variedad de programas, y como se trata
de un Simulador puedes programar sin miedo a equivocarte y hacerle un dao a tu
computador.
Empezemos a Programar!
Para empezar a programar primero necesitas tener un problema a resolver, luego planteas un
algoritmo o pseudocdigo que resuelva dicho problema. Teniendo ya el algoritmo, procedes a
convertirlo en assembler, esto no es muy difcil, en la pagina de Programas para el SimuProc
puedes ver varios ejemplos.
El simulador solo entiende lenguaje ensamblador(assembler).
Para ejecutar programas en el simulador, hay que escribirlos primero en este lenguaje. En la
sgte pgina explico cada instruccin con sus parmetros si los necesita para que pueda
comenzar a escribir los programas.
Luego de tener el programa ya en ensamblador se carga en el simulador, ya sea desde un
archivo, usando el Editor interno entrndole las instrucciones manualmente.
Como crear programas en SimuProc:

Se pueden entrar instrucciones manualmente desde la ventana ppal, pero la manera mas fcil
es hacerlo desde El editor 2. Entramos a los Editores presionando el botn Editor
la barra de herramientas.

en

En el panel derecho (Editor 2) podremos escribir el programa, las instrucciones sern

resaltadas; puedes presionar el botn derecho del Mouse en este editor para acceder a ms
opciones.

Despus de escribir tu programa, procedes a enviarlo al Editor 1 usando el botn

puedes observar como va a quedar distribuido tu programa en memoria.

, ya aqu

Para finalmente enviarlo a memoria presionas el botn

.
Si tu programa no presenta errores de sintaxis, este pasar inmediatamente a la memoria de
SimuProc.
En el cual ya podrs comenzar la simulacin.
Luego de tener el programa ya cargado en la memoria simulada del procesador, se puede
salvar en un archivo .SMP o .ASM desde el editor que el simulador crea para no tener que
volver a escribir el programa nuevamente.

Instrucciones Soportadas
Con las instrucciones que soporta este simulador se pueden escribir una gran
cantidad de programas para resolver muchos problemas diferentes.
Las describir as:
XX - INST [parmetro]
Donde:
XX significa el Cdigo de la Instruccin
INST es la instruccin

Ac pondr
algunos ejemplos

[parmetro] es el parmetro si esta tiene o

[parametro1,parametro2] si el parmetro es doble
Estas son las instrucciones soportadas por la versin actual:
01 - LDA [mem]
Cargue en AX el contenido Digamos que en la posicin de memoria 1F
de la direccin de Memoria esta el valor 10111, despus de ejecutada la
especificada.
instruccin LDA 1F se obtiene que AX=10111
Es equivalente a usar la instruccin MOV
AX,1F
Hay casos donde es mejor usar MOV si se
desea pasar datos sin tener que pasarlos por
AX.

02 - STA [mem]
Guarde el contenido
Supongamos que tengo el valor 1010110 en el
de AX en la direccin registro AX y quiero llevarlo a la posicin
de Memoria
de memoria 3C, la instruccin es STA 3C
especificada.
Es equivalente a usar la instruccin MOV 3C,AX
Es mejor usar MOV debido a que si quiero pasar
algn dato de una direccin de memoria a otra
usando LDA y STA serian dos instrucciones: LDA
mem1 y luego STA mem2, mientras que con MOV
ser as: MOV mem2,mem1

03 - XAB
Intercambia los valores de los registros Esta instruccin no necesita
AX y BX
parmetros.

04 - CLA
Hace AX = 0

06 - PUSH [registro]
Enva el valor del registro especificado a la pila

07 - POP [registro]
Trae de la Pila el ultimo Valor llevado por PUSH (indicado por el registro
SP) y lo almacena en el registro especificado.
Nota: En todas las instrucciones desde 08 hasta la 18, Dest puede ser una direccin
de Memoria o un Registro
08 - INC [dest]
Incrementa en 1 el destino
Si en la posicin de memoria EB
especificado, el parmetro puede ser esta el valor 1001, al ejecutar INC EB

una direccin de memoria o un

registro.

se obtiene que ahora el valor de EB

es 1010.

09 - DEC [dest]
Decremento en 1 el destino especificado, Si el destino queda = 0, se
vuelve Z = 1

10 - MOV [dest,orig]
Copia el valor almacenado en el origen al
destino. El destino y/o origen pueden ser
registros o direcciones de memoria o
combinacin de estos.

Para copiar lo que esta en la

posicin de memoria 12E a la
posicin D2 se usa la
instruccin MOV D2,12E

11 - AND [dest,orig]
Y lgico, hace un Y lgico entre todos los Si en AX tengo el numero
bits de los dos operndos escribiendo el 1001101 y en la pos 3F tengo el
resultado en el destino. Los parmetros numero 11011. al ejecutar la
pueden ser direcciones de memoria o
instruccin AND AX,3F obtendr
Registros. La siguiente regla aplica:
en AX el resultado 1001.
1 AND 1 = 1
El Y lgico lo que hace es dejar
1 AND 0 = 0
los bits en comn que tengan los
0 AND 1 = 0
dos nmeros.
0 AND 0 = 0

12 - NOT [destino]
NO lgico, invierte los bits del
operando formando el
complemento del primero.
NOT 1 = 0
NOT 0 = 1

13 - OR [dest,orig]
O inclusive lgico, todo bit activo
en cualquiera de los operndoos
ser activado en el destino. La
siguiente regla aplica:
1 OR 1 = 1
1 OR 0 = 1
0 OR 1 = 1
0 OR 0 = 0

Si en AX tengo 10011 al ejecutar NOT

AX obtengo AX=1111111111101100

Si en 3A tengo el numero 1001101 y

en la pos 3B tengo el numero 11011. al
ejecutar la instruccin OR 3A,3B
obtendr en 3A el resultado 1011111.

14 - XOR [dest,orig]
O exclusivo, realiza un O
Si en 3A tengo el numero 1001101 y en
exclusivo entre los operndoos y la pos 3B tengo el numero 11011. al
almacena el resultado en

destino. La siguiente regla aplica: ejecutar la instruccin XOR 3A,3B

1 XOR 1 = 0
obtendr en 3A el resultado 1010110.
1 XOR 0 = 1
0 XOR 1 = 1
0 XOR 0 = 0

15 - ROL [dest,veces]
Rota los bits a la izquierda las
veces especificadas(en decimal),
los bits que salen por la izquierda
re-entran por la Derecha. En el
Carry Flag queda el ultimo bit
rotado.

Supongamos que en la posicin 7E

tengo el numero 101110
Al Ejecutar...
obtengo en 7E C=
ROL 7E,2
10111000 0
ROL 7E,7
1011100000000 0
ROL 7E,13 1100000000000101 1

16 - ROR [dest,veces]
Rota los bits a la derecha las veces especificadas(en decimal), los Bits
que salen por la derecha re-entran por la izquierda. El Carry Flag guarda
el ultimo bit rotado.

17 - SHL [dest,veces]
Desplaza los bits a la izquierda el numero de veces especificado(en
decimal), agregando ceros a la derecha, el Carry Flag guarda ultimo bit
desplazado.

18 - SHR [dest,veces]
Desplaza los bits a la Derecha el numero Supongamos que en la
de veces especificado(en decimal),
posicin 1A tengo el numero
agregando ceros a la izquierda, el Carry 101110
Flag guarda ultimo bit desplazado.
Al
obtengo en C=
Ejecutar...
1A
SHR 1A,2
1011 1
SHR 1A,6
0 1
SHR 1A,11
0 0

20 - ADD [mem]
Sumar:
AX = AX + el
contenido de la
direccin de
memoria.

Si el resultado de la suma supera los 16 bits, el

resultado queda asi: en BX los bits mas significativos
y en BX los menos, tambien se activa el Overflow
flag.

21 - SUB [mem]
Restar:
AX = AX - el contenido de la direccin de memoria.

22 - MUL [mem]
Multiplicar:
Si el resultado de una operacin fuera
AX = AX * el contenido de la
101101000111100010111 (21 bits)
direccin de memoria.
Los registros quedaran as:
Si el numero resultante supera su A = 1000111100010111 (los ltimos
longitud en binario de 16 bits, este 16bits)
resultado se parte almacenando los B = 10110
(los primeros Bits
bits mas significativos en el
(los mas significativos))
Registro BX.
Tambin se activa el Flag Overflow,
para indicar que en la ultima operacin
sucedi esto.

23 - DIV [mem]
Dividir:
AX = AX / el contenido de la direccin de memoria, BX=AX % el contenido
de la dir de memoria (BX = modulo o residuo).

24 - CLN
Limpia el Negative Flag. N = 0

25 - CLC
Limpia el Carry Flag. C = 0

26 - STC
Pone el Carry Flag. C = 1

27 - CMC
Complementa (invierte) el Carry Flag. Si C = 1 vuelve C = 0 y viceversa.

29 - LOOP [mem]
Decrementa CX y salta a la Pos de memoria si CX no es cero.

30 - JMP [mem]
Salto incondicional. PC = direccin de memoria donde esta la siguiente
instruccin a ejecutar"

31 - JEQ [mem]

Saltar si son iguales.

Si Z = 1, PC = contenido de la memoria.

Funcin equivalente en C:
if (AX == mem)

32 - CMP [mem]
Compara AX con
Supongamos que en AX tengo el numero 10110 y
[mem], si AX es
en la posicin de memoria 4G tengo el numero
mayor, Z=0 N=0, si es 1100, al ejecutar la instruccin CMP 4G obtengo
igual Z=1 N=0, si es que como el numero almacenado en AX es mayor
menor Z=0 N=1
entonces los Flags de Control me quedan as: Z=0 y
N=0
Nota: Solo en las versiones 1.3.6.2 y anteriores En
AX quedaba el resultado de la resta (de la
comparacin), Ahora ya no. Sugerencia: si necesita
el valor original de AX puede usar la pila para
almacenarlo temporalmente.

33 - JME [mem]
Saltar si es
Supongamos que ejecuto esta instruccin as JME 3F
Menor.
inmediatamente despus de ejecutar la instruccin del
Si N = 1, PC ejemplo que coloque en la instruccin 32, al ejecutar JME 3F
= contenido se verifica el Flag N, y como en este caso se encuentra en 0
de la
(porque el numero no es menor) entonces no se realiza
memoria.
dicho Salto a 3F porque el valor de PC no se modifica, el
programa sigue su ejecucin.
Funcin equivalente en C:
if (AX < mem)
y Si necesitas hacer un:
if (AX <= mem)
inmediatamente despues de la instruccion JME colocas una
JEQ

34 - JMA [mem]
Saltar si es
Supongamos que ejecuto esta instruccin as JMA 2B
Mayor.
inmediatamente despus de ejecutar la instruccin del
Si Z = 0 y N = ejemplo que coloque en la instruccin 32, al ejecutar JMA
0, PC =
2B se verifican los Flag N y Z, y como en este caso los dos
contenido de son 0 (porque el numero es menor) entonces si se realiza
memoria.
dicho Salto a 2B ya que el valor del PC se modifica, el
programa sigue su ejecucin saltando a la dir de mem
especificada.
Funcin equivalente en C:
if (AX > mem)

35 - JC [mem]
Saltar si el Carry Flag esta activado.
Si C = 1, PC = contenido de memoria.

36 - JNC [mem]

Saltar si el Carry Flag no esta activado.

Si C = 0, PC = contenido de memoria

37 - JO [mem]
Saltar si el Overflow Flag esta Activado.
Si O = 1, PC = contenido de memoria

38 - JNO [mem]
Saltar si el Overflow Flag no esta activado.
Si O = 0, PC = contenido de memoria

39 - JNE [mem]
Saltar si no son iguales.
Si Z = 0, PC = contenido de memoria.

Funcin equivalente en C:
if (AX != mem)

40 - LDT
Lee un valor del
Esta instruccin es para comunicarse con el usuario,
Teclado y lo lleva pidindole que entre un Dato; Puede colocar una
al registro AX
descripcin del dato que pide, que se mostrar en
tiempo de ejecucin.

41 - EAP
Escribe en Pantalla Esta instruccin tambin es para comunicarse con el
el contenido del
usuario; Puede colocar una descripcin del dato que
registro AX
se entrega, este se mostrar en tiempo de ejecucin.

42 - MSG
Muestra un mensaje en pantalla

Ej: MSG "Hola Mundo !!"

50 - LDB [mem]
La instruccin carga en AX el contenido ej: Digamos que BX=10 ; LDB 1A
de memoria almacenado en [mem] + BX carga el contenido de 1C en AX

51 - STB [mem]
guarda el contenido de AX en la
direccin [mem] + BX

ej: Digamos que BX=101 ; STB 3A

guarda AX en 3F

55 - LDF [mem]
Carga en BX y AX un
Ej:Supongamos que el nmero
numero de 32 bits (IEEE) 01000010110010001000000000000000 est
que esta almacenado en cargado en memoria as:
la dir [mem] y
02A 0100001011001000 (Los dgitos mas
mem+1. En BX quedan significativos)
los digitos mas
02B 1000000000000000 (Los dgitos menos
Significativos
significativos)
Un LDF 2A dejara el siguiente resultado:
BX: 0100001011001000
AX: 1000000000000000
-------------------------Nota: Para pedirle al usuario o mostrar estos
numeros IEEE 754 en pantalla, usar puerto 1,
con las instrucciones IN AX,1 y OUT 1,AX

56 - STF [mem]
Guarda en [mem] y mem+1 Ej: siendo AX y BX = al ejemplo anterior, un
el contenido de BX y AX
STF 2A deja la memoria como el ejemplo
anterior.

60 - ADDF [mem]
Suma nmeros de 32 bits: Estos numeros IEEE 754 son numeros que
En BX y AX queda el
pueden ser de punto flotante, o enteros desde resultado de la suma de
2147483647 hasta 2147483647, si en cualquier
estos mas el contenido de operacin de estas aritmeticas, se sobrepasa
[mem] y mem+1
este valor, se activa el Overflow flag.

61 - SUBF [mem]
Resta el numero de 32 bits: BX y Puedes utilizar esta instruccin como
AX = BX y AX - [mem]y mem+1
un CMP para numeros de 32 bits.

62 - MULF [mem]
Multiplicacin:
BX y AX = BX y AX *
[mem]y mem+1

Si el resultado es > 2147483647, Resultado =

2147483647 y Overflow Flag = 1

63 - DIVF [mem]
Division:
BX y AX = BX y AX / [mem]y mem+1, en CX queda el residuo de la
division en entero de 16 bits

64 - ITOF

Conversin de Entero a Real:

Convierte un nmero entero (16bits) almacenado en AX al mismo numero
pero representado en Real IEEE754(32bits), el Resultado de la
conversin queda en BX (bits mas significativos) y AX
Los registros de control cambian de acuerdo al numero convertido: "Z" si
el numero es cero, "N" si el numero es negativo.

65 - FTOI
Conversin de Real a Entero:
Convierte un nmero Real(32bits) a su equivalente en entero BX y AX en
un entero (16bits), el Resultado queda en AX.
Los registros de control cambian de acuerdo al numero convertido: "Z" si
el numero es cero, "N" si el numero es negativo, "O" si el numero real es
mayor de 65535.

80 - IN registro,puerto
Lleva al Registro el valor
retornado por el puerto
especificado.

Ej: IN AX,8 ;lleva a AX el valor retornado

por el puerto 8 (Reloj: los segundos del
sistema).

81 - OUT puerto,registro
Escribe en el puerto especificado, el valor del registro.

90 - NOP
Esta operacin no
hace nada.

99 - HLT
Terminar
Programa

til para cuando se modifica la memoria para parchar

cdigo y desactivar instrucciones.

Todo Programa lleva esta instruccin para indicarle al

simulador que el programa ha terminado su ejecucin.

Especificaciones
Memoria:
La Memoria es el dispositivo que almacena toda la informacin del programa que se
ejecuta, tanto datos como instrucciones. Esta en realidad no es parte del
procesador, sino que es un dispositivo a parte al que el procesador accede para ir
leyendo las instrucciones y datos del programa.
La capacidad de la memoria Simulada es de 4096 posiciones de 16 bits cada una:
Desde 0 hasta 4095, o sea en hexadecimal:
Desde 000 hasta FFF.
Esta memoria es suficiente para ejecutar gran variedad de simples y complejos

programas.
El simulador trabaja con constantes y variables en binario y direcciones (posiciones
de memoria) en Hexadecimal.

Registros Generales:
Los registros generales del procesador se usan para almacenar informacin de uso
rpido, ya que se accede a ellos a una velocidad mucho ms alta que la memoria.
En ellos se pueden almacenar direcciones de memoria a las que se va a acceder
bastante a lo largo de la ejecucin del programa, o directamente variables que se
desean usar.
Este Procesador consta de 3 registros de propsito general, AX, BX y CX cada uno
con 16 bits de capacidad.

Registros Apuntadores como:

PC IP: Program Counter o Instruction Pointer, Contiene la direccin de memoria de
la prxima instruccin a ejecutar y es incrementado en cada nueva instruccin.
MAR: Memory Address Register. (Registro de Direccin de Memoria) es el registro
en el que se almacena la direccin de memoria a la que se quiere acceder.
MDR: Memory Data Register o Memory Buffer Register, es un registro intermedio en
el que se almacenan los datos que se escriben o leen de memoria. En el caso de
una lectura, se pone en el MAR la direccin y se activa la seal de leer, obteniendo
en el MDR el dato buscado. En el caso de una escritura, se pone en el MAR la
direccin y en el MDR el dato a escribir en memoria, despus de activa la seal de
escribir, de esta forma almacenamos en memoria el dato.
IR: Instruction Register, en este registro se introduce la instruccin a ejecutar,
despus de haberla ledo de memoria accediendo a ella mediante la direccin
sealada en el PC; El contenido de este registro se puede dividir en cdigo de
operacin (el cdigo que seala la operacin que se realizar) y operandos. Puede
haber 2 operandos o slo uno. Ac es donde se decodifica e interpreta la instruccin
as: se descompone la instruccin leda de forma que se pueda saber cual es la
operacin que se desea realizar y cuales son los operandos, en su caso, o el
desplazamiento en caso de que se trate de una instruccin de bifurcacin...

Registros de Pila:
BP: Base Pointer, Puntero de base de la pila. El valor de por defecto es F80 , Este
puede cambiarse desde un programa, asignndole otra direccin de memoria con la
instruccin MOV. Digamos que quiero reservar mas espacio para la pila haciendo
que esta comience desde la posicin CF1, entonces copio esta direccin de memoria
en cualquier pos de memoria; supongamos que lo copie en la direccin 3B entonces
uso la instruccin MOV BP,3B y as BP es igual a CF1.
Mientras se ejecuta el programa se puede visualizar en una barra de porcentaje el
uso de la pila.
Mas adelante hablare de la Pila.
SP: Stack Pointer, Puntero de la pila, indica en que prxima direccin de la pila esta
disponible, es decir, apunta a la cima de la pila. Este valor se cambia
automticamente cuando se usan las instrucciones PUSH POP.

Registros de Control (Flags)

Estos registros se usan para poder controlar el comportamiento de un programa los
cuales se activan despus de cada operacin, segn sea el resultado de la
instruccin ejecutada.
Zero flag: se vuelve 1 si el resultado de la ultima operacin = 0
Negative Sign flag: Se vuelve 1 si el resultado de la ultima operacin es igual a un
numero negativo.
Carry flag: se activa cuando la operacin realizada ha producido un acarreo.
Overflow flag: se activa cuando la operacin produjo desbordamiento (overflow) , es
decir, el resultado ocupaba ms de los 16 bits que caben en un registro.
Estos flags se usan principalmente en instrucciones de bifurcacin (por ejemplo, si
queremos que, en caso de que el resultado de la ltima operacin fuera cero, el
programa se salte varias de las instrucciones siguientes, comprobamos el flag cero y
si est activo el programa salta, esto se consigue con la instruccin JEQ).
En la ALU (Arithmetic Logic Unit) - (Unidad Arimtica y Lgica) es donde el
procesador realiza las operaciones matemticas, (suma, resta, multiplicacin...) y las
operaciones lgicas (AND, OR, desplazamiento de bits...).

Caractersticas
El Simulador incluye unas Utilidades:

Editor Interno:
Herramienta para escribir tus programas mas fcilmente, tiene resaltado
de sintaxis, soporte de Deshacer, Rehacer, Desplazamiento o tabulacin
de cdigo seleccionado (presionando ctrl. Shit I U) , marcadores
(presionando Ctrl Shit. 1-9 para marcar y ctrl. 1-9 para ir al marcador), y
otras opciones configurables
Modificador de Memoria:
Lo usas para inicializar las variables y/o constantes de tu programa en
ciertas posiciones de memoria cuando lo escribiste.
Tambin puedes modificar posiciones de Memoria en cualquier momento,
ya sea antes durante la ejecucin de un programa en caso de que se
necesite ya sea para depurar este modificando variables, o las mismas
instrucciones con sus parmetros.
Conversor de Bases:

Tambin dispones de un
Conversor de bases por si
se necesita realizar alguna
conversin de una base a
cualquier otra, soporta
desde base2 a base36.
Tambien conversin para
numeros de punto flotante a
IEEE 754 y vice versa

Estadsticas:
El simulador constantemente le estar mostrando las estadsticas del
programa en ejecucin, como numero de instrucciones ejecutadas, que
clase de instrucciones y la velocidad de la simulacin.
Vigilante de Memoria:
Disponemos de un
vigilante de memoria con
el cual se pueden observar
variables en las posiciones
de memoria, este trae un
historial que muestra los
ltimos 5 valores de las
posiciones vigiladas.

Dispositivos Virtuales:

Cada computador real utiliza dispositivos perifricos de alguna clase para

conectarse con el mundo exterior. As que SimuProc tambin esta
provedo por unos dispositivos de E/S, tambin simulados.
Estos estn conectados a unos puertos virtuales los cuales pueden ser
accedidos con las instrucciones In y Out dependiendo del tipo de
dispositivo
Puerto 1: Teclado y Pantalla
Usado solo Para pedirle al usuario un numero de 32 bits, o para imprimir
uno en pantalla, ej: IN AX,1 ;pide al usuario un numero IEEE 754
ej: OUT 1,AX ; escribe en pantalla el numero de 32 bits formado por BX y
AX
Puerto 8 : Reloj
Lee los segundos del sistema, retorna un numero en binario (entre 0 y 59)
al registro especificado. (Sirve para generar nmeros aleatorios)
Puerto 9: Switches
Este dispositivo, consiste de 16 switches en fila enumerados de 0 a 15.
Cualquier switch puede ser encendido resultando un 1 lgico
correspondiente al bit del switch.
Puerto 13: PC-Speaker (Nota: no todos los PC modernos tienen
conexion a un Speaker interno)
Genera sonidos a travs del altavoz de tu PC.
Para generar un Sonido necesitas dar la frecuencia y la duracin en
milisegundos.
La frecuencia debe ser entre 7Hz y 32767Hz
La frecuencia es leda del registro especificado en la instruccin, y la
duracin es leda del registro BX
Ejemplo: Supongamos que AX = 101000101000 y BX = 111110100
OUT 13,AX ; produce un sonido de 2600Hz durante 500 ms
Para averiguar los Hz de algunas notas se puede usar la sgte formula:
Frecuencia, en Hertz = 440 * 2^[(octavo-4) + (nota/12)]
Donde las notas comienzan as:
A=0 A#=1 B=2 C=3 C#=4 D=5 D#=6 E=7 F=8 F#=9 G=10 G#=11
siendo:
C=Do D=Re E=Mi F=Fa G=Sol A=La B=Si
Por ejemplo: C6 => 440 * 2^[(6-4) + 3/12)] = 2093 Hz, casi 2.1 kHz

Otras Caractersticas:
La velocidad de Simulacin puede ser cambiada en cualquier momento y se puede apagar la
animacin para una ejecucin mucho mas rpida.
Puedes seguir el acceso en memoria de las instrucciones y/o variables a medida que se
ejecuta la simulacin.
Al ejecutarse el Simulador este chequea que Windows este usando fuentes pequeas y que la
resolucin sea mnimo de 800x600. en otro caso sacara un dialogo para cambiarla si el usuario
desea.
El Simulador registra los archivos de tipo .SMP para que se puedan abrir programas con solo
darle doble clic a estos desde el explorador de Windows.

Hay dos Barras de Porcentaje que muestran el porcentaje de uso de la memoria simulada y
porcentaje de uso del espacio reservado para la pila en ese momento!
A los Registros de control (flags) se les puede dar Doble clic para hacer un cambio forzado de
estos en caso de que necesite depurar su programa. O si da clic con el botn derecho del
mouse saldr un men para seleccionar que flag quiere activar/desactivar.
Para cargar programas en el simulador se pueden entrar las instrucciones manualmente por
la interfaz del programa o
El simulador puede abrir varios tipos de archivos:
Abre los archivos .SMP que son los creados por este mismo cuando se salvan.
Abre archivos de extensin .TXT o .ASM que son compatibles con la versin anterior de este
simulador. bien, puedes usar mejor el editor Interno.
La Pila:
La pila es simplemente un conjunto de datos que se almacenan en una zona de memoria,
generalmente al final, y en la cual los datos se guardan de la siguiente manera: LIFO, es decir,
Last In, First Out (Ultimo en entrar, Primero en salir).
La Pila es un buffer usualmente implementado como un bloque de n bytes o words
consecutivos. En este simulador cada posicin de memoria es de 16 bits
Usos para la pila:
Ya sea para almacenar Datos, para llevar control del programa, la pila se usa para pasar
variables entre funciones y para almacenar variables locales.
El programador es el responsable de reservar el espacio apropiado para la pila. Ya antes
explique como hacerlo en este simulador.
Un problema con las pilas es que el programador las puede hacer muy pequeas y puede que
ocurra un stack overflow o desbordamiento de pila si se esta intentando usar la instruccin
PUSH para enviar algo cuando ya la pila esta llena; o stack underflow si se usa la instruccin
POP estando la pila vaca.
Por cada PUSH debe de haber luego un POP. Cuando un programa o funcin termina su
ejecucin la pila debe quedar como estaba antes de que este se ejecutara, sino hay errores en
este.

Programas para SimuProc

La versin 1.4 trae algunos programas de ejemplo incluidos en el editor en el boton de ayuda
de la barra de herramientas.
Tambien estos son algunos Programas o algoritmos que puede bajar para usar con el
simulador, o para ver simplemente como se programa en Assembler.
Algunos estn debidamente explicados con su respectivo algoritmo.

Programa
Explicado con su
Algoritmo

Descripcin

Bajar
archivo

Tamao

Autor

Nmeros Primos

Halla los nmeros primos hasta n.

primos.zip

547
bytes

Vlaye

Paridad

Calcula la Paridad de un Numero

paridad.zip 464
bytes

Vlaye

Factorial

Encuentra el Factorial de un numero

factorial.zip 464
bytes

Desbordamiento
de Pila

Programa que Causa un desbordamiento de overflow.zip 792

pila
bytes

Serie Fibonacci

Encuentra los nmeros de la serie de

Fibonacci hasta n

fibona.zip

471
bytes

Ahora te dar algunos algoritmos/ejercicios con los cuales podrs practicar a convertirlos a
Assembler

Nombre del Algoritmo

Descripcin

Numeros Perfectos

Un numero es perfecto cuando la suma de todos los numeros menores y

divisibles por el, es igual al mismo numero.

Armstrong

Un nmero es de Armstrong si la suma de los dgitos que lo componen

elevados al cubo es igual al nmero.

Numeros Pitagoricos

Los numeros pitagoricos son aquellos en que se cumple que el cuadrado de

uno es igual a la suma de los cuadrados de los otros dos.

Calculo con Matrices

por ejemplo Sacar la inversa de una matriz.

Ecuacin de 2do grado

Resolverla

Otros algoritmos que puedes intentar son: Las torres de Hanoi, Seno, Coseno, Constante E.
Ac puede compartir sus programas:

Nmeros primos
Programa que halla los numeros primos hasta n:

Bajelo Aca ya listo para el Simulador: primos.zip

El algoritmo para hallar los numeros primos es el siguiente:

PROGRAMA
leo limite
num=1
MQ num<=limite Haga
Si num<=3
Imprima Num
Sino Si num % 2 == 0
Break
Sino
x=3
raiz=RaizC(num)
MQ x<=raiz Haga
Si num % x ==0 break SI
x= x+2
FinMQ
imprima num
FinSi
FinSi
num=num+1
FinMQ
FIN PROGRAMA

Funcion RaizC()
y=1
mq (y != raiz) (y != raiz+1) haga
raiz = y
y = ( y + ( num / y )) / 2
fin mq

//Programa Numeros Primos

//Leo el limite o valor hasta donde quiero hallar numeros primos
//inicializo num en 1
//Repito este bucle hasta que num > limite
//Si el modulo de num/2 = 0 es porque el numero es par.

//aca RaizC() es la funcion que se explica mas adelante.

Funcion para hallar la raiz cuadrada de un numero

//inicializo y en 1
//Hago un Bucle que no termine hasta que "y" sea diferente de raiz o raiz+1

Ahora para escribirlo en assembler organizare la memoria del simulador asi:

Variable

Direccin
Memoria

Descripcion

limite
num
x
raiz
y

34
35
36
37
38

Limite hasta donde quiero que lleguen los primos

empieza en 1 y termina cuando llega a limite
variable usada para hallar si el numero es primo
variable raiz, almacena la raiz de num
variable usada en RaizC()

2
3
0
1

3A
3B
3C
3D

Constante
Constante
Constante
Constante

numero
numero
numero
numero

2
3
0
1

(en
(en
(en
(en

binario
binario
binario
binario

10)
11)
0)
1)

Ahora pasemos ese Algoritmo a Assembler, al frente de cada instruccin esta

comentado despues del punto y coma que hace esta.
El programa quedaria asi:

Dir
00:
01:
02:
03:
04:
05:
06:
07:
08:
09:
0A:
0B:
0C:
0D:
0E:
0F:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
1A:
1B:
1C:
1D:
1E:
1F:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
2A:
2B:
2C:
2D:
2E:
2F:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
3A:
3B:
3C:
3D:
3E:
3F:
40:

Instruccin y
Parmetros

Comentarios

NOP
MOV 35,3D
LDT
MOV 34,AX
MOV AX,34
CMP 35
JME 32
MOV AX,35
CMP 3B
JMA D
MOV AX,35
EAP
JMP 30
MOV AX,35
DIV 3A
MOV AX,BX
CMP 3C
JMA 13
JMP 30
MOV 36,3B
MOV 38,3D
MOV AX,38
CMP 37
JEQ 23
MOV AX,37
INC AX
CMP 38
JEQ 23
MOV 37,38
MOV AX,35
DIV 38
ADD 38
DIV 3A
MOV 38,AX
JMP 15
MOV AX,37
CMP 36
JME 2E
MOV AX,35
DIV 36
MOV AX,BX
CMP 3C
JEQ 30
INC 36
INC 36
JMP 23
MOV AX,35
EAP
INC 35
JMP 04
HLT

;No operacion
;num = 1
;leo del teclado el Limite
;almaceno limite en 34
;cargo limite en AX (Comienzo MQ)
;comparo limite con num
;Si limite es menor que num voy a fin de MQ
;AX=num
;comparo num con 3
;si num > 3 voy a SINO
;AX = num
;Escribo num en pantalla
;voy a FINSI
;AX=num SINO
;AX = AX/2 , BX = modulo
;paso el modulo a AX
;comparo mod con 0
;salto si mod > 0
;break
;x=3
;y=1
;cargo Y en AX (COMIENZO MQ del raiz())
;comparo y con raiz
;si y=raiz salgo del mq
;AX=raiz
;AX=AX+1
;comparo raiz con y
;si raiz=y salgo del mq
;raiz = y
;AX = num
;AX = num/y
;AX = AX + Y
;AX = AX / 2
;y = al valor del Registro AX
;Salto a repetir el blucle MQ del raizC()
;FINMQraiz() y AX = raiz
(COMIENZO MQ2)
;comparo raiz con y
;si raiz < x voy a fin MQ2
;AX = num
;AX = AX / x
;AX = residuo que esta en BX
;Comparo residuo con 0
;si residuo = 0 salgo del SI
;x= x+1
;x= x+1
;voy a MQ2
;AX = num
FIN MQ2
;imprimo num en pantalla
;FINSI
;hago loop
;FIN MQ y PROGRAMA

10

;Inicializo raiz en 2

10
11
0
1

;Con el editor de memoria del simulador almaceno las constantes

;Constante 2
;Constante 3
;Constante 0
;Constante 1

Paridad

Programa que chequea la paridad de un numero:

bajelo aca.
Dir
00:
01:
02:
03:
04:
05:
06:
07:
08:
09:
0A:
0B:
0C:
0D:

CLA ;AX = 0
MOV BX,AX ;BX = 0
LDT ;Leo del Teclado Numero a chequear Paridad AX = Numero
MOV CX,D ;CX = 16
16 ya esta almacenado en la pos D
ROL AX,1 ;roto las pos en binario del numero, 1 posicion a la izq
JNC 7 ;Si el ultimo bit rotado no era 1 entonces salto para no incrementar
INC BX ;BX = BX +1
LOOP 4 ;CX = CX - 1 y cuando CX = 0 sale del loop
XAB ;intercambio AX con BX
EAP ;Escribo en pantalla AX. Que es la paridad del numero
HLT ;Fin Programa
10000 ;16 en binario