Captulo I.

Programar en Ensamblador es ms sencillo de lo que creemos. La dificultad al

programar en cdigo mquina se encuentra en que tenemos que indicar al procesador
cada cosa que queremos que haga. Pero nuestro programa Ensamblador nos facilitar
bastante las cosas.
Este es el primer ejemplo que vamos a analizar en este tutorial de Ensamblador. En l
hay una serie de comandos que forman parte de las instrucciones del procesador y otra
que forma parte del programa ensamblador. Este programa suma los nmeros ! y " y
mete el resultado en la direccin de memoria #$%$%.
ORG &4000 & 'ireccin de (nicio) instruccin para el Ensamblador
4000 LD A, &03 & *ete ! en el +cumulador
4002 ADD A, &05 & ,uma " al nmero que est en el +cumulador
4004 LD (&4040), A & *ete el contenido del +cumulador en la direccin
#$%$%
4007 RET & -.etorna- a donde estaba
Empecemos/ ORG es la instruccin del programa Ensamblador y le indica la direccin
de memoria de inicio donde se va a generar el cdigo/ al decir 0.1 #$%%% estamos
dicindole que el programa se ensambla 2se traduce a los bytes que entiende el
procesador3 a partir de la direccin #$%%%.
El resto de operaciones que salen/ L') +'' y .E4 son instrucciones del procesador.
.ecordemos que el cdigo +,* es casi lo mismo que escribir el programa en cdigo mquina
pero un poco ms fcil) usamos mnemnicos en lugar de los bytes que entiende el procesador.
Estos mnemnicos los traduce el programa ensamblador. 5emos pensado que el *+6+* en
.0* o el que viene integrado en el 7in+PE son las mejores alternativas por claridad y facilidad
de uso y nos referiremos a stos a la hora de generar los listados de los programas.
,i utilizamos *+6+* en .0*) para introducir nuestro programa) arrancamos *+6+*
escribiendo 8m) seleccionamos T Text Editor y E Edit Text y simplemente tecleamos nuestro
programa. 9uando hayamos terminado) con E,9 volveremos al men anterior y con A Assemble
Text) ensamblaremos el cdigo en memoria.
,i utilizamos el *+6+* integrado de 7in+PE) entramos en el +ssembler pulsando :; o el
botn correspondiente) elegimos New en el men File para teclear nuestro listado y Assemble-
Assemble para colocar el programa en la memoria.
9on la instruccin LD A,&03) le estamos pidiendo al <=% que meta el valor #%! en el
+cumulador) que es el registro de trabajo del <=%. El L' + 2de Loa' +3 es en realidad
el mnemnico de la instruccin con el opcode #!E) que es el byte que el Ensamblador
meter en la memoria y que entender nuestro <=%. >amos a olvidarnos de los opcodes)
ya hablaremos de ellos ms adelante.
ADD A,&05 indica que se sume el nmero #%" al que hay en el acumulador. El valor
nuevo se guarda en el acumulador. ,i lo ponemos en frmula matemtica) +?+@#%".
LD (&4040),A indica al <=% que el nmero que tiene el acumulador lo guarde en una
posicin de memoria) en #$%$%.
En este caso) hemos utilizado la direccin #$%$% como variable resultado. En Ensamblador
tenemos un par de mtodos para definir variables/
reulta!o e"u &4040 & indicamos al programa ensamblador que siempre que encuentre la palabra
& resultado en el cdigo fuente) al ensamblar lo traduzca por #$%$%.
L' 2resultado3)+

reulta!o !# &00 & en este caso no sabemos cul es la direccin de resultado) depende de la
& posicin de esta lAnea en el listado pero el programa ensamblador calcula
& cual es el valor y lo usa para sustituir la palabra resultado al ensamblar.
L' 2resultado3)+
'e esta manera) nos ahorramos el tener en cuenta en que direccin se guarda cada variable de
nuestro programa) refirindonos a ella con su etiqueta.
RET) lo que hace es que retorne el programa a la ltima llamada 29+LL3. Es como un
.E4B.C que retorna al 10,BD que lo llam. ,i es el final del programa) como en este
caso) retornar al Dasic.
,i introducimos nuestro programa en memoria y lo ejecutamos desde Dasic con CALL
&4000) veremos que aparentemente nada ha ocurrido. Pero si tecleamos $RI%T
$EE&(&4040) tendremos nuestro flamante resultado/ '.
Cuestro <=% tiene aparte del +cumulador otros ; registros de = bits ms) que se llaman
D) 9) ') E) 5 y L. La instruccin L' +) #%! se puede aplicar a cualquiera de los otros
registros de = bits del procesador) o sea) que podemos introducir un byte en cualquiera
de ellos. Pero no sucede lo mismo con el +'' o el L' 2#$%$%3)+. Estas instrucciones
no son aplicables a los otros registros. ,i tenemos que meter el contenido de) por
ejemplo) D en una posicin de memoria) no podemos hacer L' 2#$%$%3)D ya que esta
instruccin no eEiste) tendrAamos que usar el +cumulador como intermediario. Lo
vemos en este otro ejemplo junto con alguna cosilla ms/
ORG &4000 & 'ireccin de (nicio) instruccin para el Ensamblador.
4000 LD (, &05 & *ete " en el registro D.
4002 LD C, &03 & *ete ! en el registro 9.
4004 LD A, ( & 90P(+ el contenido de D en el +cumulador.
4005 ADD A, C & ,uma el nmero del registro 9 al que est en el
+cumulador
400) LD (&4040), A & *ete el contenido del +cumulador en la direccin #$%$%
400* RET & -.etorna- a donde estaba.
Este programa tiene el mismo resultado que el anterior) pero dando un pequeFo rodeo/
Gcarga- los nmeros a sumar en D y 9 y que asA podamos ver la posibilidad de mover
datos entre registros. 9omo la instruccin de suma de = bits +'' es slo aplicable al
acumulador) 90P(+*0, el contenido de D en el +cumulador. Luego le sumamos el
contenido del registro 9/ aquA vemos que no slo podemos sumar al +cumulador el
nmero que le indiquemos) sino tambin uno que est contenido en otro registro.
.esultaba ms sencillo el otro programa) pero ste ilustra bien el hecho de que podemos
tener cargados los registros a modo de parmetros 2hemos sumado el 90C4EC('0 de
un registro3. Este uso de parmetros afectar) por ejemplo) a las Rut+,a !el -+r./are.
Estas rutinas del :irmHare nos sern de gran ayuda en estos comienzos) ya que nos
ofrecen operaciones bsicas ya hechas. Ejemplos claros de esto son la que se encuentra
en #DD"+ llamada T0T O1T$1T) que nos mostrar en pantalla el carcter cuyo
cdigo +,9(( se encuentra en el +cumulador) o T0T 2ET C1R2OR en #DDI" que
posiciona el cursor de teEto en el nmero de columna guardado en 5 y el de fila
guardado en L. >emos su uso en este ejemplo/
ORG &4000 & 'ireccin de (nicio) instruccin para el Ensamblador.
4000 CALL &(()C & .utina del :irmHare T0T CLEAR 3I%DO3. Dorra la
pantalla de teEto) lo que serAa un 9L,
4003 LD 4, &54 & 9arga #J$ en el registro 5. 9olumna #J$) K% decimal.
4005 LD L, &0C & 9arga #%9 en el registro L. :ila #%9) JK decimal.
4007 CALL &((75 & .utina del :irmHare 464 ,E4 9B.,0.) posiciona el
cursor de teEto en la columna 5 y y fila L
400A LD A, &2A & 9arga #K+ en el +cumulador) +,9(( de asterisco.
400C CALL &((5A & .utina del :irmHare 464 0B4PB4) imprime en
pantalla el carcter cuyo +,9(( est en el +cumulador.
400- RET & -.etorna- a donde estaba.
5ay instrucciones que nos permitirn modificar el contenido de un registro por ejemplo
I%C) que (C9rementar el contenido del registro en una unidad o DEC) que
'E9rementar una unidad el nmero contenido en el registro en cuestin. 'e esto se
podrAa deducir que si insertamos estas lAneas antes del .E4 podremos pintar dos
asteriscos/
400- I%C L & (C9rementa el registro L en una unidad) aumenta el
nmero de fila.
4050 CALL &((75 & .utina del :irmHare 464 ,E4 9B.,0.) posiciona el
cursor de teEto en la columna 5 y y fila L
4053 CALL &((5A & .utina del :irmHare 464 0B4PB4) imprime en
pantalla el carcter cuyo +,9(( est en el +cumulador.
Probadlo. LMu ha ocurridoN .esulta que el 464 ,E4 9B.,0.) corrompe el contenido
del +cumulador) 5 y L) como hacen tambin otras rutinas. Para prevenir esto
deberAamos haber movido su contenido a otros registros antes de llamar a la rutina y
luego recuperarlo) recordad que disponemos tambin de D) 9) ' O E y que sabemos
mover contenidos de un registro a otro) asA que ser fcil modificar nuestro programa.
LMuin se animaN
.epasamos/
ORG %% & 'ireccin de (nicio) instruccin para el Ensamblador.
PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP
CALL %% & Llamada a una direccin) que puede ser una rutina del
:irmHare) es un 10,BD del que volvemos con
RET & -.etorna- a donde estaba.
PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP
LD R, % & 9arga el byte C en el registro .) que puede ser +) D) 9)
') E) 5 o L
LD R, R6 & 9opia el contenido del registro . en el registro .Q.
LD A, (%%) & *ete el contenido del +cumulador en la direccin CC.
LD (%%), A & 9arga el contenido de la direccin CC en el
+cumulador.
PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP
ADD A, % & ,uma el byte #C al que hay en el +cumulador.
ADD A, R & ,uma el byte contenido en el registro . al que hay en el
+cumulador. El resultado se queda en el +cumulador.
PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP
I%C R & (C9rementa el byte contenido en . en una unidad.
DEC R & 'E9rementa el byte contenido en . en una unidad.