Documenti di Didattica
Documenti di Professioni
Documenti di Cultura
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
, ya aqu
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
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
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.
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
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
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.
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.
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]
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]
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
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
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
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
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.
81 - OUT puerto,registro
Escribe en el puerto especificado, el valor del registro.
90 - NOP
Esta operacin no
hace nada.
99 - HLT
Terminar
Programa
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 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.
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:
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.
Programa
Explicado con su
Algoritmo
Descripcin
Bajar
archivo
Tamao
Autor
Nmeros Primos
primos.zip
547
bytes
Vlaye
Paridad
paridad.zip 464
bytes
Vlaye
Factorial
factorial.zip 464
bytes
Desbordamiento
de Pila
Serie Fibonacci
fibona.zip
471
bytes
Ahora te dar algunos algoritmos/ejercicios con los cuales podrs practicar a convertirlos a
Assembler
Descripcin
Numeros Perfectos
Armstrong
Numeros Pitagoricos
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:
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
Variable
Direccin
Memoria
Descripcion
limite
num
x
raiz
y
34
35
36
37
38
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)
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
Paridad
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