Asm 51

(C) 1994,99 Ibercomp S.A.
--------------------------------------------------------------------------------------------------------
-----------------------------------------------------------------------------------------------------------------------------
-7-
--------------------------------------------------------------------------------------------------------
1 Comenzando por el principio
Muchos de los aparatos que existen en nuestro tiempo no serían posibles sin la
existencia de microcontroladores. Estos son utilizados de forma indispensable en casi
todos los aparatos electrónicos. Si no existieran los microprocesadores muchos de estos
aparatos constarían de cientos de circuitos integrados "comunes" con todos los
problemas de espacio, diseño y coste que eso conllevaría.
El uso de microcontroladores está muy extendido en todo el mundo y hoy en

día no hay motivo para que todo aquél que disponga de unos conocimientos mínimos de
electrónica dedique una parte de su tiempo en estudiar y en cierto modo adaptarse a la
tecnología del microprocesador, por ello hemos creado la gama de microcontroladores
ALTAIR.
Los equipos ALTAIR, tanto en su versión monoplaca como en su versión

autómata o entrenador son ordenadores completos y muy potentes, que contienen en una
pequeña placa una CPU con capacidad de proceso, una memoria de datos, una memoria
de programa y un número determinado de entradas y salidas de propósito general.
Si bien es verdad que inicialmente no disponen de salida de monitor, ni de

disco duro, ni disquetera, ni teclado alfanumérico completo tal y como disponen los
ordenadores personales tipo PC.
Los equipos ALTAIR están diseñados para que sean aprovechados por
ingenieros, estudiantes y entusiastas de la electrónica que deseen realizar montajes muy
complejos de una forma sencilla, barata, rápida y eficaz, montajes que no siempre
requieren de periféricos comunes disponibles en ordenadores personales tipo PC.
El microcontrolador ALTAIR puede ser considerado como una pequeña caja

negra que dispone de una serie de entradas de señal y una serie de salidas de señal. El
valor de las salidas estará en función del valor de las entradas que podrán ser analizadas,
estudiadas y procesadas en función de un programa definible por el diseñador de la
aplicación.
De este modo, el mismo montaje básico de microprocesador, memoria de

programa y datos puede servir para infinidad de aplicaciones dependiendo del programa
que se le introduzca. Aplicaciones tales como el simple control de la potencia de una
lampara incandescente, simulación de presencia, sistema de alarmas inteligente,
medición de magnitudes eléctricas (intensidad y tensión) y cálculo de sus derivadas
(potencia, trabajo, ...), control de matrices de LEDs (publicidad), control de riegos,
granjas e invernaderos, control de ascensores, puertas de garajes, sistemas de
climatización, temporizadores, control de semáforos de tráfico, relojes públicos, control
de hornos, detección de monedas, transmisión de datos, control de un toldo eléctrico etc.
Las aplicaciones de los equipos ALTAIR en el mundo son tantas que no es

posible escribir un manual que haga referencia a todas, de forma que en este nos
limitaremos simplemente a describir como programar y utilizar el equipo así como
algunas recetas que permitan a sus usuarios resolver los problemas que puedan surgir en
sus proyectos.
-----------------------------------------------------------------------------------------------------------------------------
-9-
--------------------------------------------------------------------------------------------------------
El microprocesador elegido inicialmente para los equipos ALTAIR fue el SAB
80C535 de Siemens, que es una versión mejorada del Intel 8051. Se trata de un
microprocesador de 8 bits de altas prestaciones, estándar en la industria, que con una
frecuencia de 12 MHz puede llegar a ejecutar un millón de instrucciones por segundo.
Las características principales del ALTAIR 535 son:
• 100% compatible con los microprocesadores de la familia 51.

• 256 bytes de RAM dentro del propio microprocesador.
• 48 entradas/salidas programables.
• 8 entradas analógicas con 10 bits de resolución y voltajes de referencia
programables.
• Puerto serie RS232c FULL DUPLEX con 4 modos de operación, con
velocidades fijas o programables.
• 3 temporizadores/contadores de 16 bits.
• WATCHDOG de 16 bits.
• Procesador boleano.
• 256 bits directamente direccionables.
• Ciclo de instrucción de 1 us a 12 MHz.
• 4 us para multiplicación/división de 8 bits.
• 32 Kbytes de ROM con sistema operativo y espacio para programa de
usuario.
• 32 Kbytes de RAM que indistintamente puede ser memoria de datos o
memoria de programa. Opcionalmente esta memoria puede ser no volátil
con una duración de 10 años.
• Reloj en tiempo real tipo PHANTOM WATCH.
• Compatible con los periféricos y memorias estándares de los
microprocesadores 8080/8085.
En los cuatro años que llevamos fabricando microcontroladores, la familia

ALTAIR ha crecido, y actualmente disponemos de los siguientes modelos que siguen al
ALTAIR 535 comercializado por primera vez el 12 de Octubre de 1.994:
ALTAIR 32
Se trata de un microcontrolador monoplaca basado en el 80C32 muy similar en

concepto al ALTAIR 535. Dispone, como es lógico menos entradas/salidas. En la
propia placa se ha incluido un área de prototipos. El puerto serie puede ser configurado
como RS232c o como RS485
ALTAIR 320
Los mismos microcontroladores anteriores en los que se ha sustituido la CPU

80C32 por una 87C320, que como mejoras más importantes presentan una velocidad
2.5 veces superior a la misma frecuencia de oscilador. Dispone de dos puertos serie
independientes, uno de ellos puede ser configurado como RS485.
ALTAIR 535E
-----------------------------------------------------------------------------------------------------------------------------
- 10 -
--------------------------------------------------------------------------------------------------------
Se trata de un microcontrolador compatible 100% con el ALTAIR 535 al cual
se le han añadido algunos periféricos curiosos que permiten realizar prácticas en la
enseñanza.
De este modelo tan solo se montaron 200 unidades entre 1.995 y 1.996, y
actualmente está fuera de producción.
ALTAIR 552
Un microcontrolador muy similar al ALTAIR 535, en el cual se sustituyo el

microcontrolador de Siemens por el 80c552 de PHILIPS, este dispone de puerto I2C y
salidas PWM. Se puede alimentar directamente a 220 V y dispone de una fuente
conmutada que suministra 5V con 1.5A.
ALTAIR 537
Se trata de un microcontrolador a la vez compacto y potente basado en el

microprocesador SAB80C537. Este microprocesador es un superconjunto del 80C535.
Dispone de dos puertos serie independientes, de más puertos y de una unidad aritmética.
En este manual no podemos describir con detalle cada uno de los

microcontroladores de la familia ALTAIR, ya que ello nos obligaría a revisar el manual
con demasiada frecuencia.
2 ¿Qué es un programa?
Un ordenador o microcontrolador, por si solo, no sirve para nada sino se

dispone de un programa: un alma que lo mueva y le indique en cada momento y paso a
paso que es lo que debe ir haciendo. Este programa es un conjunto de instrucciones que
entiende el equipo y que es elaborado concienzudamente por un humano, el
programador. (ej: un programa para controlar un grupo electrógeno).
Una vez arrancado el programa el microcontrolador irá escrutando de una en

una todas las instrucciones, ejecutándolas a velocidades inconmensurables para la mente
humana. Los tiempos de ejecución de la mayoría de las instrucciones se miden en
microsegundos (0.000001 segundos).
Esto le da una idea de la enorme velocidad a la que puede operar, pero a pesar
de ello, a veces pueden tardar minutos, e incluso horas en procesar una pila de datos.
Por tanto un programa es el conjunto de instrucciones necesarias para que el

microcontrolador, ejecutándolas una a una, resuelva el problema para el cual fue
concebido.
El programa debe ser cargado de algún modo previamente en la memoria del

microcontrolador, donde también se pueden introducir los datos a procesar. Procesar es
"ejecutar" un programa, esto es, a partir de unos datos de entrada que pueden cambiar
en tiempo real, se obtienen unos datos de salida en función de los de entrada. Esta
función es el resultado del programa.
-----------------------------------------------------------------------------------------------------------------------------
- 11 -
--------------------------------------------------------------------------------------------------------
Para introducir un programa en la memoria del ALTAIR hemos desarrollado
un entorno de programación bastante cómodo, el KIT de desarrollo ALTAIR versión
3.00. Gracias a este usted puede fácilmente escribir y ejecutar aplicaciones para los
equipos ALTAIR directamente desde un PC de sobremesa.
3 ¿Qué incluye el KIT de desarrollo?
El KIT desarrollo ALTAIR v.3.00 incluye todas las herramientas necesarias

para desarrollar y depurar programas sobre microprocesadores basados en la familia
8051. El KIT de desarrollo se compone de dos partes:
• Manual de instrucciones (el que está leyendo)

• Disquete 3.5" con ficheros MS DOS
En el disquete usted hallará:
• Programa de instalación.
• Editor con SHELL integrado.
• Macroensamblador 8051 con definiciones para el 51, 515, 517, 552 y 520.
• Enlazador de código objeto.
• Depurador de código fuente.
• Programa ejecutor.
• Conversor ejecutable -> binario.
• Conversor binario -> Intel Hexadecimal.
• Ejecutor remoto de ficheros Intel Hex y Binarios.
• Reseteador remoto.
• Testeador del equipo.
• Desensamblador.
• Código fuente de rutinas de gestión del puerto serie de un PC.
• Código fuente de infinidad de ejemplos.
Antes de nada le recomendamos que saque una copia de seguridad del

disquete que le hemos enviado, con el fin de reducir el riesgo que accidentalmente
pierda la información que él contiene.
Antes de proseguir lea del disquete suministrado el fichero de texto

leeme.txt. En él se describen los posibles cambios que se hayan podido producir desde
la edición de este manual.
4 Instalación del KIT de desarrollo en el disco duro
La instalación del KIT de desarrollo en el disco duro de su PC es bastante

sencilla, para ello basta con que ejecute el fichero INSTALAR.BAT que se halla en el
directorio raíz del disco suministrado, para lo cual debe teclear:
INSTALAR [destino] <Return>
-----------------------------------------------------------------------------------------------------------------------------
- 12 -
--------------------------------------------------------------------------------------------------------
Donde [destino] es la unidad donde desea instalar el KIT de desarrollo. Si no
indica unidad de destino el KIT de desarrollo se instalará en la unidad C.
Si dispone en su equipo de un MS DOS versión 4.00 o superior podrá utilizar

opcionalmente el comando XCOPY para realizar la instalación del KIT de desarrollo,
por ejemplo:
XCOPY A:*.* C:\PROGS /s <Return>
Tecleando el comando anterior se instalará el KIT de desarrollo dentro del

directorio PROGS del disco duro C.
Si no dispone de unidad de disco duro puede ejecutar y desarrollar aplicaciones

para el ALTAIR directamente desde una disquetera, para ello simplemente duplique el
disquete que le suministramos y ejecute todos los programas directamente desde él.
Para instalar el KIT de desarrollo lo único que requiere es de un ordenador 386

o superior con sistema operativo MS DOS y memoria extendida, una disquetera de alta
densidad, una tarjeta con modo texto 80x25, un monitor y un teclado y un puerto serie
estándar. Le recomendamos que adicionalmente disponga de disco duro, ratón y
memoria expandida.
El programa corre correctamente sobre equipos dotados de sistema operativo

Windows 95 o superiores, siempre y cuando sean capaces de ejecutar aplicaciones
DOS:
En algunos equipos, la tarjeta de red local ETHERNET coincide con

las direcciones del puerto serie COM2, por lo que es posible que el equipo PC se
cuelgue. Como solución puede cambiar las direcciones de la tarjeta ETHERNET o bien
utilizar el COM1 y conectar el ratón al COM3. En caso de duda consulte a su
distribuidor de informática.
5 El Editor
El KIT de desarrollo suministrado por nosotros conforma un entorno compacto

cuyo núcleo central es el editor. Desde allí se editarán, escribirán y gestionarán los
ficheros fuentes de los proyectos.
El Editor en si es muy parecido en concepto y modo de funcionamiento al

editor suministrado con el MS DOS, EDIT.EXE. De hecho puede ser utilizado para
editar cualquier tipo de fichero de texto, siempre y cuando su tamaño sea inferior a 64
Kbytes.
El editor integra también todas las funciones del SHELL, pudiéndose llamar
desde él y de forma automática a la mayoría de los programas incluidos en el KIT de
desarrollo.
-----------------------------------------------------------------------------------------------------------------------------
- 13 -
--------------------------------------------------------------------------------------------------------
El programa editor puede llamarse simplemente tecleando desde el MS DOS el
comando EDITOR51 el cual llamará a la aplicación EDITOR51.EXE que se halla en la
carpeta de ejecutables EJEC.
Al arrancar presentará en pantalla un menú de opciones en la parte superior así

como una chuletilla de las teclas de función en la parte inferior. Vea la figura 1.
Figura 1: Pantalla principal que aparece nada más cargar el programa editor.
El Editor está escrito íntegramente en lenguaje C++, para gestionar las

ventanas, menús, cuadros de dialogo, ..., se ha utilizado el paquete TURBOVISION.
Gracias a ello el editor funciona correctamente en cualquier resolución de texto
estándar. Si dispone de un monitor convencional de 14" o 15" utilizará preferentemente
una resolución de 80x25 caracteres, si por el contrario dispone de un monitor de 17" o
mayor puede utilizar sin problemas una resolución de 132x44 caracteres. Esta
resolución, soportada por la mayoría de las tarjetas de vídeo modernas, le dará de un
área de pantalla 3 veces superior, con lo que tendrá una mayor versatilidad a la hora de
trabajar con varias ventanas (proyectos).
Para seleccionar una resolución de texto mayor consulte el manual de su tarjeta

gráfica o el disquete de configuración de la misma. Estos normalmente disponen de
utilidades (VMODE, XMODE, ...) que permiten seleccionar resoluciones extendidas.
Si en lugar de utilizar resoluciones de texto decide utilizar resoluciones

gráficas, el editor seguirá funcionando correctamente, aunque todos los movimientos de
pantalla se ralentizarán de forma exagerada.
-----------------------------------------------------------------------------------------------------------------------------
- 14 -
--------------------------------------------------------------------------------------------------------
Ibercomp seguirá desarrollando y mejorando el KIT de desarrollo

ALTAIR, añadiendo todas las mejoras sugeridas por los clientes, pero siempre bajo MS
DOS y en modo texto y no bajo WINDOWS por los siguientes motivos:
• El sistema operativo WINDOWS no es profesional en el sentido que exige

al usuario de disponer una estación de trabajo potente y sobredimensionada,
que no siempre está disponible en laboratorios y centros de enseñanza.
• Los sistemas operativos gráficos son extremadamente lentos debido que

para mover una ventana han de mover cientos de Kbytes, mientras que los
sistemas de texto apenas han de mover un par de cientos de bytes.
• El WINDOWS dispone de tipos de letras proporcionales, lo cual suele

causar confusión en los editores de programas.
• La agilidad que ofrece un sistema basado en texto después de unas cuantas

sesiones es bastante superior a las que puede ofrecer un sistema gráfico.
Nosotros en ningún momento nos decantamos por un sistema operativo u otro,

cada uno dispone sus funcionalidades. Sin ir más lejos nosotros utilizamos equipos
APPLE para confección de manuales, equipos WINDOWS para diseño de placas y
equipos DOS para desarrollar aplicaciones 51. Conocemos otros ensambladores y
depuradores cruzados escritos en WINDOWS y opinamos que son incómodos.
Los menús pueden ser accedidos con la ayuda de un ratón estándar tipo
MICROSOFT o bien mediante teclado, opción que recomendamos. A continuación
describiremos la acción de cada una de las opciones de los menús.
<ALT T> Menú Altair
Este menú dispone de una sola opción denominada Acerca. Para seleccionarla
pulse con el ratón sobre ella, o bien pulse directamente la tecla <Return>. Con ello le
aparecerá en pantalla un cuadro de diálogo en el que se da información acerca de la
versión del KIT de desarrollo así como su fecha de programación. Vea la figura 2
-----------------------------------------------------------------------------------------------------------------------------
- 15 -
--------------------------------------------------------------------------------------------------------
Figura 2: Cuadro de diálogo con la información acerca. Observe que esta

pantalla hace referencia a la versión 2.20 comercializada en Setiembre de 1.996.
Para salir de él debe pulsar con el ratón sobre OK o bien pulsar directamente
sobre la tecla <Return>
<ALT A> Menú Archivo
Este menú dispone de 7 opciones que permiten cargar y grabar archivos de

texto (programas fuentes y proyectos), crear un archivo nuevo así como salir del editor.
Puede acceder a este menú pulsando con el ratón sobre él o bien pulsando
<ALT A>. Una vez desplegado puede seleccionar las opciones utilizando las teclas del
cursor y <Return>, o bien pinchándolas con el ratón. Puede salir del menú sin
seleccionar ninguna opción pulsando <ESC> o bien pinchando con el ratón fuera del
menú.
Las opciones disponibles en el Menú de Archivo son:
<F3> Abrir
Seleccionando esta opción aparece en pantalla un selector de ficheros,

mostrado en la figura 3. Gracias a este podrá seleccionar muy fácilmente el fichero que
desea editor, para ello pulse con el ratón sobre él o bien teclee directamente su nombre.
Si no dispone de ratón puede ayudarse de las teclas del cursor, el tabulador y la tecla
<Return>.
-----------------------------------------------------------------------------------------------------------------------------
- 16 -
--------------------------------------------------------------------------------------------------------
Figura 3: Selector de ficheros en la opción de apertura de archivos.
Este selector de ficheros es casi idéntico a los utilizados en el editor EDIT.EXE

del MS DOS, por lo que si tuviese alguna duda puede consultar su manual de MS DOS.
Nuevo
Esta opción crea una ventana de texto vacía denominada <sintitxx.s51>. Los
caracteres xx representan un número de 00 a 99. La primera ventana sin título que se
crea se denomina sintit00.s51, la siguiente se denomina sintit01.s51 y así
sucesivamente.
Sobre esta ventana sin título recién creada puede comenzar a editar sus
programas fuentes. Posteriormente tendrá opción de cambiar su nombre por otro más
racional.
<F2> Guardar
Esta opción guarda el texto contenido en la ventana superior en el archivo y

directorio especificado sobre ella. Si la ventana fuese del tipo <sintitxx.s51> en lugar de
guardarla se ejecuta automáticamente la opción <Guardar como>.
Allí podrá corroborar si desea guardar el contenido de la ventana como

sintitxx.s51.
Guardar como
Esta opción al igual que la anterior permite al usuario guardar en el disco el

contenido de una ventana de texto. La diferencia en este caso estriba en que el editor
presentará al usuario un selector de ficheros para que elija el nombre del fichero en el
que desea guardar el texto (vea la figura B). Este puede ser seleccionado con ayuda del
-----------------------------------------------------------------------------------------------------------------------------
- 17 -
--------------------------------------------------------------------------------------------------------
teclado o bien mediante el ratón de forma análoga al selector de ficheros de la opción
abrir.
Figura 4: Selector de ficheros en la opción guardar como. Observe el parecido

de esta figura con la anterior.
Imprimir texto
Con esta opción puede volcar el contenido parcial o completo de una ventana
sobre la impresora. Si la ventana activa (superior) no dispone de ningún texto
seleccionado se imprimirá su contenido directamente.
Si por el contrario se ha seleccionado un bloque se presentará en pantalla un

cuadro de diálogo solicitando si desea imprimir el texto completo o tan solo el bloque
marcado (vea figura 5).
-----------------------------------------------------------------------------------------------------------------------------
- 18 -
--------------------------------------------------------------------------------------------------------
Figura 5: Cuadro de diálogo de la opción imprimir. Puede indicar si desea

imprimir el texto de toda la ventana o bien el texto marcado con un bloque.
Esta opción permite también imprimir el contenido del portapapeles (la

ventana que contiene el bloque cortado o copiado).
Salir al DOS
Esta opción permite al usuario salir momentáneamente al MS DOS para

ejecutar determinado comando o programa. En esta salida momentánea no se pierden
datos ni contenidos de la ventana. El usuario podrá volver de nuevo al EDITOR51
tecleando el comando EXIT del MS DOS.
-----------------------------------------------------------------------------------------------------------------------------
- 19 -
--------------------------------------------------------------------------------------------------------
Figura 6: Puede observar el aspecto del MS DOS cuando es llamado desde el
propio editor. Ahora puede organizar su disco duro, ejecutar sus utilidades favoritas y
volver posteriormente al editor tecleando el comando EXIT.
Debe tener presente que el programa EDITOR51.EXE queda residente en

memoria, por lo que dispone de menos memoria libre que la acostumbrada, por lo cual
algunos programas pueden negarse a arrancar.
Si sale al MS DOS con esta opción no debe de volver a ejecutar de

nuevo el EDITOR51, ya que de hacerlo este residiría dos veces en la memoria,
pudiendo ocurrir resultados impredecibles.
Se desaconseja el uso de esta opción a los usuarios de WINDOWS, en

sustitución recomendamos abrir una sesión MS DOS nueva. Para pasar de una tarea a
otra pulse <ALT + TAB>.
<ALT X> Salir
Con esta opción se sale definitivamente del EDITOR51. En el caso de tener

una ventana con texto modificado el editor le solicitará mediante un cuadro de diálogo
autoexplicativo al usuario si lo desea guardar o no.
<ALT E> Menú Edición
Este menú de opciones dispone de 6 opciones. Estas opciones permiten

seleccionar bloques de texto con el fin de cópialos, moverlos o borrarlos.
Antes de realizar según que operación con bloques deberá seleccionarlos. Para
ello debe colocar el cursor sobre el inicio del bloque y extenderlo utilizando el cursor al
mismo tiempo que mantiene pulsada la tecla <Shift>.
También puede seleccionar un bloque de texto utilizando el ratón. Para mayor

información consulte en su manual MS DOS la parte que trata del editor.
Deshacer
Esta opción deshace todos los cambios realizados con el menú de edición.
Normalmente esta opción se utiliza para recuperar fragmentos de textos después de
haber realizado desastres.
<SHIFT DEL> Cortar
Coge un bloque seleccionado y lo mueve hacia el portapapeles. Este bloque

seleccionado es eliminado del texto, quedando solamente en el portapapeles.
Posteriormente puede ser puesto de nuevo en el texto utilizando la opción pegar.
<CTRL INSERT> Copiar
-----------------------------------------------------------------------------------------------------------------------------
- 20 -
--------------------------------------------------------------------------------------------------------
Copia el bloque seleccionado sobre el portapapeles. Un bloque copiado hacia
el portapapeles puede ser copiado múltiples veces sobre el texto utilizando la opción
pegar.
<SHIFT INSERT> Pegar
Copia el contenido del portapapeles sobre la posición del cursor.
Mostrar portapapeles
Esta opción muestra en una ventana el contenido del portapapeles. El

portapapeles es el lugar donde se guardan los bloques copiados o cortados del texto con
las opciones cortar o borrar respectivamente.
<CTRL DEL> Borrar
Esta opción borra el bloque seleccionado.
<ALT B> Menú Búsquedas
Este menú consta de seis opciones, que permiten buscar y sustituir secuencias
de texto. Las tres opciones disponibles son:
Buscar
Esta opción busca dentro del texto una cadena determinada. Esta cadena
determinada debe ser seleccionada mediante un cuadro de diálogo, figura 7. En el
algoritmo de búsqueda se puede tener en cuenta el significado de
mayúsculas/minúsculas o palabras completas.
Figura 7: Cuadro de diálogo de la opción Buscar, permite hacer distinción

entre mayúsculas y minúsculas y tener presente que el texto a buscar se trata de una
palabra completa.
-----------------------------------------------------------------------------------------------------------------------------
- 21 -
--------------------------------------------------------------------------------------------------------
Sustituir
Presenta un cuadro de diálogo mostrado en la figura 8. En este diálogo a parte

del texto a buscar se debe seleccionar el nuevo texto. El algoritmo de sustitución tiene
en cuenta mayúsculas/minúsculas, palabras completas, confirmación, confirmación para
sustituir y sustituir todo.
Figura 8: Cuadro de diálogo de la opción sustituir. Al igual que en buscar se

diferencia entre minúsculas y mayúsculas así como palabras completas.
<CTRL L> Repetir búsqueda
Esta opción permite repetir una búsqueda seleccionada con la opción buscar.
<ALT F8> Siguiente Error
En el caso de haberse producido errores al ensamblar con esta opción podrá

hacer que el cursor se sitúe en el siguiente error. Con ello puede ir subsanando un error
tras otro.
<ALT F7> Error Anterior
Esta opción es la antónima de la anterior. Con ella puede situar el cursor en un

error anterior.
-----------------------------------------------------------------------------------------------------------------------------
- 22 -
--------------------------------------------------------------------------------------------------------
De esta forma si al ensamblar obtiene múltiples errores puede fácilmente ir de
uno a otro con este comando y el anterior.
Al corregir errores debe tener presente que un error puede ser en

ocasiones el origen de otros errores. Por ejemplo si indicamos al ensamblador un
directorio incorrecto al incluir la definición de registros (.include reg51.def) se
generarán errores de etiqueta no definida en todos las líneas en que se utilicen etiquetas
definidas en el fichero incluido erróneamente.
Corrigiendo el primer error desaparecen todos los demás errores,

aunque para ello deberá reensamblar de nuevo el fichero.
<ALT L> Ir a Linea
Esta opción le permite posicionar el cursor en cualquier linea si conoce su

número. Al seleccionar esta opción aparecerá en pantalla un cuadro de diálogo (figura
E) en el que deberá teclear el número de la linea en la que desea posicionar el cursor.
<ALT V> Menú Ventanas
Este menú dispone de 7 opciones que permiten mover y cambiar el tamaño de

las ventanas de texto así como ordenarlas en la pantalla del ordenador. Las opciones
disponibles son:
<CTRL F5> Tamaño/mover
Esta opción permite mover y cambiar el tamaño de una ventana. Para moverla,
después de seleccionar esta opción utilice las teclas del cursor. Para cambiar su tamaño
utilice las teclas del cursor al mismo tiempo que pulsa la tecla <Shift>. Una vez
seleccionada la posición y tamaño adecuado pulse <Return>. Esta operación de cambiar
el tamaño de una ventana y moverla la puede realizar de forma mucho más simple con
ayuda de un ratón.
<F5> Zoom
Esta opción amplia una ventana a su máximo tamaño, esto es, al tamaño de la
pantalla del ordenador. Si la pantalla ya fue ampliada previamente con esta opción, al
ejecutarla por segunda vez volverá de nuevo a su tamaño inicial.
Esta operación se puede realizar directamente con el ratón simplemente

pinchando sobre las dos flechas opuestas mostradas en la esquina superior derecha de la
ventana.
Apiladas
Coloca todas las ventanas abiertas en pantalla, de forma que estés

horizontalmente unas sobre otras, figura 1-6.
Cascada
-----------------------------------------------------------------------------------------------------------------------------
- 23 -
--------------------------------------------------------------------------------------------------------
Coloca todas las ventanas ordenadas de forma que se puede ver el título de
todas ellas. En la figura F puede observar las ventanas montadas en cascada.
<F6> Siguiente
Selecciona la siguiente ventana. A pesar de que el editor pueda abrir varios

documentos o ficheros al mismo tiempo, solo se puede modificar y escribir sobre el que
está en la ventana seleccionada.
<SHIFT F6> Anterior
Opción opuesta a la anterior, permite seleccionar la ventana anterior en la lista.

Es la acción opuesta a la opción anterior.
<ALT F3> Cerrar
Esta opción cierra una ventana. Si el contenido de esta ha sido modificado, el

editor le solicitará si desea guardar su contenido en el disco de una forma análoga a la
que ocurría al abandonar el programa.
<ALT R> Errores
Llamando a esta opción se muestra en pantalla un cuadro de diálogo con la

lista de errores generadas por el ensamblador. Con ayuda de las teclas del cursor puede
posicionarse sobre un error. Pulsando <Return> o la opción [OK] selecciona un error. Si
pulsa <ESC> o la opción [CANCELAR] sale del cuadro de errores sin realizar ninguna
acción adicional.
Una vez que ha seleccionado el error, se vuelve al editor, posicionándose el

cursor en la ventana donde se detectó el error. Sino estuviese abierta la ventana donde se
localiza el error esta se abriría automáticamente.
<ALT S> Tabla ASCII
Con esta opción invoca en la pantalla un cuadro de diálogo que contiene los
primeros 128 caracteres del código ASCII. Pulsando <Return> o la opción [OK] se
mostrará un cuadro de diálogo con los siguientes 128 caracteres ASCII. Vea las figuras
H y J.
Pulsando de nuevo <Return> u [OK] se vuelve de nuevo al editor, quedando la

pantalla tal y como estaba antes de invocar la pantalla.
<ALT P> Menú de Proyectos
Las tres opciones de este menú permiten abrir, crear y cerrar los proyectos del
KIT de desarrollo. Un proyecto es un conjunto de ficheros fuente y objetos que
conforman un único programa.
-----------------------------------------------------------------------------------------------------------------------------
- 24 -
--------------------------------------------------------------------------------------------------------
Recomendamos firmemente que se utilicen las opciones de gestión de

proyectos siempre que se vaya a realizar alguna aplicación mínimamente compleja. Con
ello obtendrá varias ventajas, la primera de ellas es que podrá dividir el listado principal
en listados más pequeños, realizando así una programación modular, más estructurada y
organizada. En segundo lugar al disponer de códigos fuentes más pequeños
sobrecargará menos el conjunto Editor-Ensamblador-Enlazador-Depurador con lo que
evitará problemas espúreos.
Abrir Proyecto
Si llama a esta opción aparecerá en pantalla un selector de ficheros que le

permitirá elegir el fichero de proyecto que desea abrir o crear. Para crear un nuevo
fichero de proyecto simplemente debe seleccionar (tecleándolo) un nombre de fichero
inexistente.
Debe tener presente que todos los ficheros de proyecto terminan con .P51, por
tanto si crea un fichero de proyecto debe indicar dicha terminación. El programa
resultante de un proyecto tendrá el mismo nombre que proyecto, con la diferencia que
en vez de estar terminado por .P51 estará terminado por .E51.
Los ficheros de proyecto de esta versión del KIT de desarrollo no son

compatibles con los ficheros de proyecto de versiones anteriores. Por tanto si disponía
de ficheros de proyecto creados anteriormente no tendrá más remedio que volverlos a
crear nuevamente. De seleccionarlos puede ocurrir un resultado impredecible, aunque
en ningún caso peligrarán los datos contenidos en el disco duro.
Una vez seleccionado el proyecto se abrirá en la pantalla una ventana de

edición de proyecto (vea la figura K). Esta ventana de edición de proyectos es descrita
posteriormente en la opción de Editor de proyecto.
Cerrar Proyecto
Esta opción cierra el proyecto activo. Una vez llamada, cuando se llame a las
opciones de ensamblar, encadenar, ejecutar, depurar, ... estas actuarán sobre la ventana
superior activa y las tratará como si fuesen un programa completo, independientemente
sean parte de un proyecto o no.
Editor Proyecto
Con esta opción se llama a la ventana editora de proyectos, la misma que

aparecía después de abrir el proyecto. En esta ventana se listan todos los ficheros que
forman parte del proyecto. Estos ficheros pueden ser del tipo fuente (*.S51) o del tipo
objeto (*.O51).
Cuando se le pida el editor que realice una operación con el programa (por
ejemplo ejecutarlo) este automáticamente ensamblará los ficheros *.S51 creando
ficheros *.O51 los cuales serán encadenados junto los ficheros *.O51 definidos en el
proyecto, creando el ejecutable.
-----------------------------------------------------------------------------------------------------------------------------
- 25 -
--------------------------------------------------------------------------------------------------------
El sistema tiene cierta inteligencia y solo ensamblará aquellos ficheros que

hayan sufrido modificaciones. El criterio para obtener un fichero ejecutable es el
siguiente:
• Si la fecha/hora de la ultima modificación del fichero objeto es anterior a la

del fichero fuente este debe ser reensamblado de nuevo.
• Si algún fichero objeto tiene una fecha/hora posterior al fichero ejecutable,

todos los ficheros objeto deben ser encadenados de nuevo.
Con ello no se llama al ensamblador innecesariamente obteniéndose así un

ciclo de desarrollo más corto.
La ventana editora de proyectos dispone de tres opciones: [AÑADIR] que al

ser seleccionada muestra en pantalla un selector de ficheros en el que puede seleccionar
libremente un fichero del tipo *.S51 o *.O51. Este fichero seleccionado será añadido a
la lista.
Opción [ELIMINAR] que permite borrar un fichero de la lista del proyecto.

Para ello deberá utilizar las flechas del cursor o el ratón para posicionarse sobre el
fichero a eliminar y seleccionar esta opción.
Por último está la opción [RET EDITOR] que hace que la pantalla del editor de
proyectos desaparezca y el proyecto quede activo. Si cuando selecciona esta opción está
sobre algún fichero fuente este aparecerá en la ventana activa del editor.
<ALT U> Menú Utilidades
Este menú de seis opciones permite ensamblar, enlazar y ejecutar los ficheros
de textos editados con ayuda de las opciones anteriores. Las opciones disponibles son:
<F9> Ensamblar
Llamando a esta opción se ensamblan todos los ficheros *.S51 del proyecto
válido abierto. Si no hubiese ningún proyecto válido abierto simplemente se ensambla el
fichero de texto que hay en la ventana activa.
En caso de producirse un error se abrirá una ventana con la lista de errores.
<F8> Enlazar
Esta opción genera a partir de los ficheros objeto del proyecto, *.O51, un
fichero ejecutable tipo *.E51. Si no hubiese un proyecto abierto crea un fichero
ejecutable relacionado a partir del fichero objeto (*.O51) resultante de ensamblar la
ventana activa.
En caso de no existir los fichero objetos necesarios el editor llamará

automáticamente al ensamblador para que los genere.
-----------------------------------------------------------------------------------------------------------------------------
- 26 -
--------------------------------------------------------------------------------------------------------
Al igual que antes, en caso de producirse un error se abrirá una ventana con la
lista de errores.
<CTRL F9> Ejecutar
Con esta opción se envía al microcontrolador el programa resultante del

proyecto activo o de la ventana activa siempre y cuando haya sido ensamblado y
encadenado satisfactoriamente.
Una vez enviado el programa este será ejecutado sobre el propio

microcontrolador. (por tanto requiere un microcontrolador 51 con algún sistema
operativo compatible ALTAIR).
Esta opción le presentará en pantalla un cuadro de diálogo solicitandole si

desea que una vez enviado y ejecutado el programa sobre el microcontrolador desea que
se muestre en pantalla una terminal RS232c.
Debe tener presente que para que un programa pueda ser ejecutado con
esta opción este debe estar ubicado sobre una memoria SRAM que actúe al mismo
tiempo como memoria de datos (escritura) y como memoria de programa (lectura). En
los equipos ALTAIR 535/537 esta memoria va desde la posición $8000 a la posición
$FFFF.
Depurar
Esta opción envía el fichero ejecutable del proyecto activo o ventana

seleccionada al depurador. El depurador se encargará de cargarlo sobre la placa del
microcontrolador. Para más información lea el capítulo del depurador.
Recompilar
Una opción curiosa que permite reensamblar y encadenar de nuevo todos los
módulos que integran el proyecto activo. Normalmente no deberá ejecutar esta opción,
pero en algunos casos por motivos externos a nuestro KIT de desarrollo las fechas y
hora de los ficheros son incorrectas, por lo que para volverlas a ajustar deberá llamar a
esta opción.
Algunos errores sin sentido en el funcionamiento de las aplicaciones se

corrigen de forma automática llamando a esta opción.
Debe tener presente que en el desarrollo de su aplicación en

ensamblador intervienen muchos factores que pueden ocasionarle algún que otro
quebradero de cabeza, nuestro KIT de desarrollo no es perfecto puede fallar, del mismo
modo que falla el BORLAND C que utilizamos nosotros. En un 99% de los casos los
errores serán fallo suyo, pero el restante puede ser causado por nosotros, por
BORLAND, por MICROSOFT, por el fabricante de su ordenador, ... Busque siempre
una forma lógica para acotar los errores sin descartar que el fallo provenga de otro
lugar.
-----------------------------------------------------------------------------------------------------------------------------
- 27 -
--------------------------------------------------------------------------------------------------------
En este punto y como anécdota podemos contar que trabajando con un
ensamblador cruzado de ZILOG para la familia Z8 descubrimos que determinada
aplicación no funcionaba correctamente a pesar de que era ensamblada y lincada
correctamente. Recompilandola funcionaba, sin realizar ningún cambio sobre el listado
fuente. Después de varias semanas y haber dado mil y una vuelta descubrimos que el
error era causado por un disco duro con algunos sectores defectuosos que el MS DOS
daba por buenos. Cuando el fichero objeto caía en dichos sectores corrompía el
resultado final.
Ajustar reloj
Esta opción permite ajustar el reloj interno opcional tipo PHANTOM WATCH
que pudiese haber instalados en los microcontroladores ALTAIR. Para ello se presenta
en pantalla un cuadro de diálogo como el mostrado en la figura 1-7. En él se selecciona
hora y fecha. Para cambiar la fecha y hora del reloj del microcontrolador debe utilizar el
TABulador o el ratón para posicionar el cursor sobre el campo a modificar.
Debido a un lamentable error, en algunos sistemas operativos ALTAIR

antiguos el campo de centésimas de segundo y segundos se cruzan, de forma que los
segundos escritos son posteriormente leídos como centésimas y viceversa.
Si ajusta siempre con 0 segundos y 0 centésimas no tendrá problemas.

Internamente las rutinas leer y escribir PHANTOM WATCH funcionan correctamente.
Generar EPROM
Esta opción genera a partir del fichero ejecutable del proyecto activo una
EPROM. Esta EPROM puede contener la aplicación o parte de la misma. Normalmente
una vez depurado y probada la aplicación sobre la SRAM llega la hora de guardarlo
sobre una EPROM con el fin de dejar una aplicación definitiva.
Llamando a esta opción se muestra en pantalla un cuadro de diálogo (mostrado

en la figura L) con dos campos editables que deben ser rellenados. Uno de ellos es la
posición inicial de la EPROM, normalmente 0, y el otro es el tamaño de la EPROM,
normalmente 32768 bytes.
Una vez rellenados correctamente ambos campos debe seleccionar [OK] o

pulsar <Return>. Con ello se creará un fichero binario conteniendo el programa cuyo
nombre será el mismo que el del proyecto activo (o ventana activa sino hubiese un
proyecto seleccionando) cambiando su terminación a BIN.
Una vez generada la EPROM, el EDITOR intentará llamar automáticamente al

programador de EPROMs PROUNI con el fin intentar grabar la EPROM recién
generada.
Para una mayor información consulte la sección dedicada a describir el

conversor binario. La aplicación BIN51.EXE es llamada por esta opción.
Generar EEPROM
-----------------------------------------------------------------------------------------------------------------------------
- 28 -
--------------------------------------------------------------------------------------------------------
Cuando se desarrolla un proyecto basado en microcontrolador hay una parte
del tiempo que se pierde realizando tareas como esperar a que el ensamblador termine
su trabajo, transmitiendo el programa al microcontrolador, grabando y borrando
EPROMs, ...
En un sistema de desarrollo ideal el tiempo empleado por estos procesos

rutinarios debería ser cero, pero en la práctica siempre consumirán determinado tiempo.
Hay una parte engorrosa del desarrollo que es la puesta a punto del sistema. A
veces el programa desarrollado sobre la SRAM funciona correctamente, pero al grabarlo
en la EPROM deja de funcionar. Dado que en la EPROM no es posible depurar un
programa surge la necesidad de modificar parte del listado y grabar una nueva EPROM.
Cuando después de varias docenas de EPROMs estas se terminan deben ser borradas de
nuevo. Algunas de ellas se pierden en el proceso.
Es inteligente a la hora de localizar el problema seguir unas pautas

ordenadas basadas en buscar las diferencias entre la SRAM y la EPROM. A
continuación una selección de las confusiones más comunes:
• Una de las diferencias más importantes es que normalmente cuando un

programa arranca en la dirección 0 todos los registros de la CPU están sin
inicializar (pila, interrupciones, puerto serie, ...) Si se ejecuta sobre SRAM
el sistema operativo inicializó previamente esos parámetros.
• La memoria de datos SRAM (memoria superior) es al mismo tiempo

memoria de datos y programa, con lo cual puede ser accedida
indistintamente por las instrucciones movx y movc, sin embargo la memoria
EPROM (memoria inferior) es solo memoria de programa por lo que solo
puede ser leída con movc. Cualquier acceso con movx devolverá un valor
incoherente.
• Debe tener especial cuidado donde define las tablas de datos inicializados.
• Los vectores de interrupción reales están en los 256 primeros bytes de la

memoria de programa. En ellos se hallan (programados por nosotros) saltos
a posiciones $8000 por encima. Si usted graba la EPROM los vectores
obviamente estarán en su sitio.
Para aminorar este problema hemos diseñado una placa adaptadora que
dispone de un 82C55 que se conecta al puerto de bus de direcciones y datos de un 535 o
537 y al puerto paralelo de un PC por el otro. Si el microcontrolador dispone de una
EEPROM del tipo X28C256 con esta opción puede grabar dicha memoria tantas veces
como desee. Recuerde que si desea posteriormente volver a enviar programas a la
SRAM deberá cargar de nuevo el sistema operativo.
Esta recarga del sistema operativo lo puede realizar con el programa

EEPROM.EXE con el parámetro eprom537.bin
Terminal
-----------------------------------------------------------------------------------------------------------------------------
- 29 -
--------------------------------------------------------------------------------------------------------
Con esta opción se llama al programa terminal (TERM51.EXE), el mismo que
era aparecía en la opción ejecutar. Este terminal actúa sobre el puerto RS232c activo, y
se puede salir de él pulsando dos veces consecutivas la tecla <ESC>. En la figura M
puede ver el aspecto que tiene la terminal tonta.
Opciones
Con esta opción se presenta en pantalla un cuadro de diálogo modal, figura N,

que permite definir toda una serie de parámetros que condicionan en cierto modo el
funcionamiento del KIT de desarrollo.
Estos parámetros que puede definir son:
• Puerto serie
Permite definir el puerto serie en el cual se encuentra el microcontrolador

ALTAIR. Los puerto series válidos en la actualidad son el COM1 y el
COM2. En condiciones normales el COM2 lleva conectado el
microcontrolador, mientras el COM1 se utiliza normalmente para conectar
un Ratón compatible MICROSOFT.
Existe una incompatibilidad no ocasionada por nosotros, entre el puerto

serie COM2 y una tarjeta ETHERNET compatible NE2000. Al acceder al
puerto serie COM2 la tarjeta de RED tiende a colgarse. Este problema es
fácil de solucionar, basta con cambiar la dirección base de la tarjeta.
Si requiere de más puertos series deberá añadir una tarjeta MULTI I/O
y configurar sus puertos serie para que actúen como COM3 y COM4. (No
olvide de deshabilitar los demás interfaces de la segunda tarjeta MULTI I/O
ya que de lo contrario se interferirá con la primera). Los puertos COM3 y
COM4 no son soportados por nuestro software, ni por el MSDOS, pero sí
por el WINDOWS y por el driver de ratón MICROSOFT.
Si a pesar de todo necesita que nuestro software utilice COM3 ó COM4 por
favor contacte directamente con nosotros.
• Prioridad
En el programa depurador se puede definir la prioridad que debe tener la

interrupción del puerto RS232 del microcontrolador. La interrupción del
puerto serie es utilizada en el sistema operativo como trace.
Normalmente, y en la mayoría de las ocasiones, este parámetro carece de

importancia, pero imagine un caso que en el microcontrolador haya una
interrupción de un temporizador que incremente determinado registro en una
unidad 100 veces por segundo.
-----------------------------------------------------------------------------------------------------------------------------
- 30 -
--------------------------------------------------------------------------------------------------------
Si la prioridad del puerto serie es mayor que la del temporizador, dicho
registro no se incrementará mientras esté ejecutando el programa paso a
paso, mientras que si la prioridad del puerto serie es menor que la del
temporizador, este si que incrementará el registro a razón de 100 veces por
segundo.
Las posibles prioridades son de 0 a 3, que corresponden a las disponibles en

los microcontroladores SAB 80C535 y SAB 80C537. En otros
microcontroladores puede haber otros niveles de prioridad diferentes,
normalmente 0 ó 1. Es obligación del sistema operativo aceptar o rechazar
los valores recibidos.
• Puerto del adaptador
Este parámetro permite definir en que puerto está conectado el adaptador de

EEPROM para 537. Normalmente irá conectado a LPT1. Si lo desea, con
ayuda de 2 MULTI I/O puede tener simultáneamente conectado el adaptador
y una impresora CENTRONICS.
• Velocidad del Terminal
En este campo de texto editable debe definir la velocidad de comunicación

del puerto serie. La velocidad aquí definida será utilizada en todas las
transmisiones hacia el microcontrolador así como en el programa terminal.
La velocidad definida debe estar comprendida entre 1 baudio y 115000

baudios, siendo la más común 9600 baudios. No todas las velocidades son
posibles, estas deben estar de acuerdo a la siguiente formula que es una
limitación impuesta por el Hardware del PC:
115200
baudios =
divisor
Al aplicar la formula anterior debe tener presente que tanto el divisor de 16

bits como baudios son expresiones enteras que no admiten decimales, por
tanto las velocidades posibles son: 115200, 57600, 38400, 28800, 23040,
19200, ...
• Directorio de ejecutables
Este campo editable debe contener el directorio completo donde se hayan

los diferentes ficheros ejecutables que conforman el KIT de desarrollo.
Normalmente este directorio será: C:\ALTAIR\EJEC
• Directorio PROUNI
Este campo editable contendrá el directorio completo donde se encuentra el

programador de EPROMs. De forma que cuando se genere una EPROM se
pueda llamar automáticamente al programador de EPROMs PROUNI.
-----------------------------------------------------------------------------------------------------------------------------
- 31 -
--------------------------------------------------------------------------------------------------------
De disponer de un programador de EPROMs este normalmente estará en el
directorio C:\EPROM\
• Nº máximo de errores
Esta variable define el número máximo de errores que debe generar el

ensamblador. Esta variable es útil para facilitar la localización de errores, al
disminuir el número de ellos.
Cuando al ensamblar un fichero ensamblador cualesquiera se obtienen de

repente una gran cantidad de errores, digamos 15 o más, normalmente se
debe o bien al que el fichero fuente está preparado para otro ensamblador o
bien que se omitió la definición de un registro. Si el error se debió a dicha
omisión es indiferente presentar 5 errores relativos a dicha omisión que 200
errores.
En cualquier caso el programador normalmente subsanará los errores de uno

en uno.
• [X] Listado fuente
Esta opción activable permite indicar al ensamblador si desea que genere un

listado con el fichero objeto con información detallada o no. El fichero es
del tipo *.LST explicado en la sección dedicada al ensamblador.
Si activa esta opción el ensamblador tardará más en realizar su tarea. Dado

que normalmente no se requiere el listado recomendamos que deshabilita
esta opción.
• [X] Verificar EEPROM
Esta opción permite activar la verificación de escritura de una EEPROM a

través de nuestro adaptador 8255 para ALTAIR 537. En la mayoría de los
equipos es imposible utilizar esta opción, ya que se requiere para ello un
puerto bidireccional rápido.
Mientras que para escribir una EEPROM ha servido cualquier equipo PC

probado hasta la fecha. Sino le funciona esta opción le recomendamos que la
tenga desactivada.
• [X] Autograbación
Esta opción habilita/deshabilita la autograbación. Si la autograbación esta

habilitada los ficheros abiertos en el editor se guardarán automáticamente
antes de llamar al ensamblador, encadenador, depurador o ejecutor.
Con el fin de prevenir perdidas de información recomendamos que tenga

esta opción siempre activada.
-----------------------------------------------------------------------------------------------------------------------------
- 32 -
--------------------------------------------------------------------------------------------------------
No es una mala práctica que saque copias de seguridad de su trabajo

sobre disquetes después de cada sesión. Ello apenas le restará unos cuantos
minutos antes de comer o al finalizar el trabajo y puede ahorrarle la perdida
de horas e incluso días o semanas de trabajo. A TODOS LOS
PROGRAMADORES SE NOS HA PERDIDO EN MAS DE UNA
OCASION LOS FICHEROS FUENTE, TENIENDO QUE PERDER
TIEMPO EN RECORDAR Y RESCRIBIR.
Para salir del cuadro modal de opciones simplemente debe pulsar la tecla [OK]
, dando conformidad a todos los cambios, o bien debe pulsar [CANCELAR] ó <ESC>
para anular todos los cambios realizados en los parámetros.
<CTRL F2> Reset
Esta opción llama al programa RESET51.EXE realizando una reinicialización

en el microcontrolador. Esta reinicialización es menos efectiva que presionar
directamente el botón del RESET en el microcontrolador. Vea la sección dedicada a
describir este programa y su utilidad.
6 El ensamblador
El ensamblador es el programa que convierte un listado fuente ASCII en un

fichero objeto listo para enviar al enlazador y así conformar un fichero ejecutable en
código nativo del 8051.
Normalmente el listado fuente lo suele escribir el programador, y debe ceñirse

a unas reglas y sintaxis concreta. En el programa ensamblador que le suministramos se
contemplan todas las instrucciones definidas en el manual técnico de SIEMENS y se
utiliza la sintaxis allí definida.
Cada linea se compone de una etiqueta, un nmónico, unos argumentos y un

comentario, por ejemplo:
etiqueta: MOV A,B ;Carga el registro A con B
Si lo desea puede eliminar la etiqueta, la instrucción con sus argumentos y/o el

comentario, pudiendo estar la linea incluso en blanco.
Las etiquetas deben estar siempre a la izquierda del texto, y pueden terminarse
con dos puntos <:>. Los mnemónicos deben estar separados del margen izquierdo al
menos por un espacio, de no ser así el ensamblador confundirá el mnemónico con una
etiqueta. Normalmente se suelen tabular con el fin de que el listado sea más legible.
Los argumentos han de proseguir obligatoriamente al mnemónico y estarán

separados de este por al menos un espacio. Los argumentos entre sí normalmente
estarán separados por comas, pudiéndose insertar opcionalmente espacios entre ellos.
Habitualmente un espacio después de cada coma.
-----------------------------------------------------------------------------------------------------------------------------
- 33 -
--------------------------------------------------------------------------------------------------------
Finalmente, terminando la linea, después de los argumentos va el comentario,
que consiste en un texto cualquiera que no está sujeto a ninguna regla. Si la linea no
dispone de mnemónico con argumentos el comentario debe estar precedido por un
punto y coma <;>.
Recomendamos que utilice siempre el punto y coma, y que con el fin de

clarificar el listado se acostumbre desde un principio a alinear los comentarios, así como
de no incluir instrucción (mnemónico) en las líneas con etiqueta.
Las referencias a etiqueta no deben llevar los dos puntos, ejemplos:
;Ejemplos de sintaxis del ensamblador
inicio:
mov R0, #27 ;Carga el registro R0 con un 27
bucle:
djnz R0, bucle ;Decrementa R0 y salta a bucle
;hasta que R0 contenga un cero
Existe una etiqueta muy especial, que es ! (signo de admiración hacia abajo).
El ensamblador la interpreta como la posición actual del programa, por ejemplo:
setb P1.0 ;Pone P1.0 a 1 (lo activa)

jb P1.0,! ;Espera a que P1.0 sea 0, esto es
;a que algún otro proceso lo
;desactive (ej: interrupciones) o
;bien por electrónica externa
En este ejemplo la primera instrucción activa la patilla 0 del puerto 1. La

segunda instrucción realiza un salto condicional a la etiqueta ! si el bit recién activado
sigue activado. Como la etiqueta ! representa la posición del programa, el salto se
realizará a si mismo, esto es se repetirá la instrucción hasta que P1.0 sea 0. (por ejemplo
poniendo externamente la patilla correspondiente al puerto P1.0 a masa)
Directivas del Ensamblador
Adicionalmente a los nmónicos en cualquier parte del programa pueden

incluirse directivas de ensamblador. Las directivas son comandos que interpreta el
ensamblador, pero que no traducen a código máquina y que por tanto no son ejecutadas
por el microcontrolador. Las directivas posibles son:
.text_org
Esta directiva sirve para indicar la dirección de comienzo del código objeto que
debe generar el ensamblador. Para ello se le puede indicar un valor numérico, una
dirección entre 0 y 64K (0 .. 65535) o bien la palabra clave REL.
Si indica un valor numérico está claro que el código se generará en esa

dirección, ensamblando adecuadamente todos los saltos y llamadas a subprograma. Si
indica un valor REL, estará indicando al ensamblador que este debe generar un código
relativo que será posteriormente ubicado por el enlazador.
-----------------------------------------------------------------------------------------------------------------------------
- 34 -
--------------------------------------------------------------------------------------------------------
Esta opción se suele utilizar cuando el programa se compone de varios
módulos (listados fuente), uno de ellos, el primero indica una dirección real y los demás
listados son relativos al primero, esto es, posteriormente el enlazador los colocará en
orden justo al final del primero, el que define la dirección.
Deberá tener un cuidado especial a la hora de incluir en su listado saltos

de 11 bits (ajmp y acall). Tal y como se describe en los manuales de Intel, estas
instrucciones permiten realizar saltos absolutos dentro de una misma página de 2
Kbytes de la memoria de programa. Dado que un módulo es colocado después de otro
en el orden indicado en el proyecto es posible que un salto aparentemente corto quede
imposibilitado por estar el origen a más de 2 Kbytes.
Para eludir problemas de este tipo utilice saltos de 16 bits, cuyo único
inconveniente respecto a los de 11 es que su instrucción consume 1 byte más. Un
problema pequeño si se dispone de memoria suficiente.
Cada listado con código debe contener una y solo una directiva tipo .text_org
la cual debe estar situada antes de la primera linea con código ejecutable. Ejemplos:
.text_org $8000 ;indica que el código

;debe comenzar
;en la dirección $8000 (primera
;posición de la SRAM)
.text_org REL ;Indica que el código es relativo,

;esto es que deberá ubicarse
;después de otro módulo.
.end
Esta directiva indica fin de listado, de forma que todo lo que haya escrito
después de esta directiva será ignorado. Todos los listados a ensamblar, deben terminar
siempre con una directiva end, por ejemplo:
;----- Ejemplo de un programa inútil -----
.text_org $8000
inicio:
sjmp inicio ;Salta hasta el infinito a inicio
;sin hacer nada
.end ;Se indica fin de listado
A Q U I P U E D E H A B E R C U A L Q U I E R C O S A
De lo contrario se producirá un error al ensamblar, ya que para el ensamblador

faltará parte del listado.
.ds.b
-----------------------------------------------------------------------------------------------------------------------------
- 35 -
--------------------------------------------------------------------------------------------------------
Esta directiva indica al ensamblador que debe reservar un número de espacios,
esto es, no generar ningún tipo de código. Si los espacios son reservados en el segmento
de texto (vea .text_org) los espacios reservados se dejan con el valor inicial $FF, que es
el valor con el que están rellenas las EPROMs vírgenes. Por ejemplo la directiva .ds.b 5
reserva 5 bytes de código, por ejemplo:
.text_org $8000
inicio:
mov A,B ;Está en la dirección $8000
mov B,A ;Está en la dirección $8001
.ds.b 5 ;Reserva 5 bytes de $8002 a $8006
Esta directiva también puede emplearse para forzar a las funciones que
comiencen en una dirección determinada. Para ello deberá ayudarse de la etiqueta ! que
representa la posición actual del programa, por ejemplo:
.text_org $8000
inicio:
clr A ;Está en la dirección $8001
.ds.b $8100-! ;Reserva espacios hasta $80FF
subrutina:
add A,B ;Está en la dirección $8100
ret ;Está en la dirección $8101
Gracias a ello es posible ubicar rutinas en posiciones fijas, que luego pueden
ser llamadas directamente. Por ejemplo cuando se meten rutinas en una EPROM.
.ds.w
Esta directiva es similar a la anterior y requiere del mismo parámetro, el

número de elementos a reservar. Esta directiva en lugar de reservar espacios de 1 byte
reserva espacios de 1 palabra (word). Una palabra se compone de dos bytes. El
resultado es que .ds.w n reserva n x 2 bytes.
.ds.f
Esta nueva directiva ha sido añadida en la versión 3.00 con el fin de permitir
reservar espacio para variables y constantes en formato flotante FFP de Motorola. Cada
elemento flotante ocupa 4 bytes (2 palabras tipo word).
.dc.b
-----------------------------------------------------------------------------------------------------------------------------
- 36 -
--------------------------------------------------------------------------------------------------------
Esta directiva define un número determinado de bytes con un contenido. Para
ello después de la directiva deben colocarse una lista de valores. Estos pueden ser
números decimales, hexadecimales, caracteres y cadenas, por ejemplo:
.text_org $9000
.dc.b $1B, 'E', "ABC", 10, 13, 0
El ensamblador colocará en la posición $9000 el valor $1B, en la $9001 el

valor ASCII de 'E' ($45), en las tres posiciones siguientes los valores ASCII de 'A', 'B' y
'C' ($41, $42, $43) en la posición $9005 el valor decimal 10 ($0A), seguido de 13 ($0D)
y $00.
Esta directiva es útil para incluir dentro del código del programa tablas de
datos que pueden fácilmente leídas con las instrucciones MOVC, o por la instrucción
MOVX si se utiliza una configuración NEWMAN en lugar de HARVARD, esto es que
la memoria de programa y datos coinciden..
.dc.w
Esta es similar a la anterior, con la diferencia que se definen palabras en lugar

de bytes. Las palabras constan de dos bytes, por lo cual se pueden introducir dentro del
código del programa números de 16 bits.
Esta directiva acepta todos los argumentos de la anterior salvo textos

entrecomillados, siendo válidos números decimales, hexadecimales, binarios y códigos
ASCII (carácter entrecomillado con comillas simples - 'A').
.dc.f
Una nueva directiva similar a las anteriores que permite definir números en
coma flotante (formato FFP de Motorola). Estos números se componen de una mantisa
de 24 bits, un bit de signo y un exponente de 7 bits ordenados según el siguiente cuadro:
b31 ........... b24 b23 ........... b16 b15 ........... b8 S b6 b5 b4 ... b0
Los símbolos bx representan el bit x del número flotante de 32 bits. Los bits b0
.. b6 representan el exponente, S (b7) representa el signo. Si este es 0 el valor flotante es
positivo ó 0, si S es 1 el valor flotante es negativo.
Los bits b8 a b31 representan a la mantisa, la cual se divide en tres bytes

denominados bajo (b8 .. B15), medio (b16 .. b23) y alto (b24 .. b31).
En los registros o en la memoria estos valores se guardan de forma invertida en

lo que se conoce como formato Intel, esto es, si un registro flotante está en la posición
de memoria $30 cada uno de los bytes estará en:
$30 byte alto

$31 byte medio (más significativo de la mantisa)
$32 byte bajo (menos significativo de la mantisa)
-----------------------------------------------------------------------------------------------------------------------------
- 37 -
--------------------------------------------------------------------------------------------------------
$33 byte de signo y exponente
La posición de memoria más baja contiene el byte alto, y la posición más alta
contiene el byte de signo/exponente.
El valor del número en coma flotante V se puede obtener con la siguiente

formula:
V = M * 2 (E-88)
Donde M es el valor de la mantisa de 24 bits y E es el valor del exponente de 7

bits.
M puede ser cualquier valor entre 8388608 y 16777215 ($800000 .. $FFFFFF),

E puede ser cualquier valor entre 1 y 127.
Este formato definido inicialmente por MOTOROLA, es el mismo que

utilizamos en nuestro paquete de rutinas matemáticas que permiten: operaciones
básicas, raíz cuadrada, funciones trigonométricas, logarítmicas, conversiones ASCII a
entero, flotante y viceversa. Si desea saber más acerca de nuestras rutinas consulte
nuestro manual de rutinas matemáticas.
.var_org
Esta directiva indica que las líneas que le siguen son variables. Esto es, se
utiliza para etiquetar y definir áreas de la memoria. Existen dos posibilidades, definir
variables en la memoria RAM interna de la CPU o dentro del código del programa.
Para ello puede ayudarse de las directivas ds.b, ds.w y ds.f descritas
anteriormente, por ejemplo:
;Ejemplo de var_org
.var_org $30 IRAM
variable1:
.ds.b 1 ;Define un byte para variable 1
otra:
.ds.b 1 ;Otra variable
pila: ;A partir de aquí comienza la pila
.var_org $9000
matriz:
.ds.b $100 ;Reserva los bytes $9000 a $90FF
carga:
.ds.b 2 ;Reserva los bytes $9100 a $9101
texto:
.ds.b "Un texto",0 ;Define un texto en $9102
.text_org $8000
-----------------------------------------------------------------------------------------------------------------------------
- 38 -
--------------------------------------------------------------------------------------------------------
inicio:
mov DPTR,matriz ;Hace que DPTR apunte a la matriz
bucle:
mov SP, pila ;Indica al sistema el comienzo
;de la pila
mov variable1,B ;Pone el contenido de B en
;variable 1
mov A, otra ;Mete el contenido del acumulador
;en otra
movx @DPTR,A ;Mete A en la matriz
inc DPTR ;Incrementa puntero a la matriz
djnz otra, bucle ;Decrementa otra y salta a bucle
;hasta que otra contenga un cero.
sjmp inicio ;Repite el programa
.end ;Indica fin de listado
Debe tener presente que después de un var_org no es posible definir código

ejecutable, tan solo definir etiquetas de variables, y en el caso de definirlas en memoria
externa puede inicializarlas si lo desea con un valor predeterminado. Para utilice las
directivas .dc.b, .dc.w o .dc.f.
Si inicializa valores en la memoria externa debe tener presente que existen dos
bancos en principio independientes, la memoria de programa y la memoria de datos. La
memoria de programa solo puede ser leída con movc, mientras que la memoria de datos
solo puede ser leída con movx. En los equipos ALTAIR los 32 Kbytes de memoria
superiores (SRAM) actúan al mismo tiempo como memoria externa de datos y como
memoria externa de programa.
.hide
El código objeto generado por el ensamblador incluye el listado fuente con el

fin de permitir al depurador presentar en pantalla dicho listado fuente. Si usted lo desea
puede omitir este listado utilizando la directiva .hide. El código objeto podrá ser lincado
igualmente pero no presentará el código fuente en el depurador.
Gracias a ello es posible crear rutinas y ofrecerlas a terceras personas en código

objeto, presentando así la integridad del fuente. Estas rutinas podrán ser encadenadas,
reubicadas, acceder a etiquetas externas o redefinir registros sin que sea posible extraer
el listado fuente original.
Tenga presente que con ayuda de un desensamblador o del propio

depurador podrá obtener de nuevo un listado fuente, pero sin comentarios, ni nombres
de etiquetas originales. Siempre es posible desmontar un programa, incluso si este ha
sido introducido en una EPROM.
El único modo infalible de protegerlo contra copia fraudulenta es encriptarlo

dentro de una CPU con PROM/EPROM del tipo 87C5xx.
-----------------------------------------------------------------------------------------------------------------------------
- 39 -
--------------------------------------------------------------------------------------------------------
Resumiendo la directiva .hide tiene un efecto similar al que tiene el comando

echo off del MS DOS, que dentro de un fichero *.BAT evita que los comandos del
mismo aparezcan por pantalla.
.show
Esta directiva indica al ensamblador que debe volver a incluir el código fuente
dentro del fichero objeto que genera. Un ejemplo podría ser:
inicio:
;
; Programa normal
;
.hide
secreto:
;
; Subrutina sujeta a Copyright
; o comentarios que sobran
;
ret ;Devuelve el control
.show
visto:
;
; Esta parte aparece de nuevo.
;
En este ejemplo el ensamblador no incluye la rutina secreto comprendida entre

.hide y .show en el código objeto generado.
.global
Con .global se definen las etiquetas que deben ser globales, esto es, que pueden
ser accedidas desde otros módulos. Esta directiva va seguida de una lista de etiquetas
separadas por comas, por ejemplo:
.global serial, chr_out, fin_programa, inicio
Si usted realiza unas rutinas con el fin de comercializarlas o de crear una

librería puede suministrarlas en formato objeto, ocultando el listado con .hide y definir
las entradas de subrutinas que pueden usar otros módulos.
Las etiquetas pueden tanto hacer referencia a la memoria interna como a la

memoria externa, pudiendo así crear rutinas que sean independientes de los puertos de
entrada. Por ejemplo puede realizar una subrutina de control de un LCD que puede
-----------------------------------------------------------------------------------------------------------------------------
- 40 -
--------------------------------------------------------------------------------------------------------
aceptar que el LCD está conectado a cualquier puerto. El módulo que la llame deberá
definir el puerto donde se halla el LCD con una directiva tipo EQU.
extern
Esta es la directiva complementaria a la anterior con ella se indica al

ensamblador que determinada lista de etiquetas externas están definidas en otro módulo,
por ejemplo, el siguiente módulo completo:
.hide
;Ejemplo de un módulo que accede fuera
.global inicio ;define etiquetas a exportar

.extern principal, pila ;define etiquetas a importar
.text_org REL ;módulo relativo
inicio:
mov SP,#pila-1 ;Ajusta la pila
ljmp principal
.end ;fin de modulo
.show
Este ejemplo arranca en una posición que dependerá de otro módulo que no sea
relativo. Se ejecutará a partir de una etiqueta inicio que será llamada desde otro módulo,
ajusta la pila con una variable definida en otro módulo y salta a la función principal
definida en otro módulo. Este otro módulo podría ser:
.global principal, pila ;Define etiquetas a exportar

.extern inicio ;Define etiquetas a importar
.var_org $30 IRAM

pila: ;Define la pila
.text_org $8000 ;Define el comienzo del

;programa (módulo absoluto)
arranca: ;Etiqueta local posicionada en la dirección $8000
ljmp inicio ;Salta al otro módulo
principal:
;Posición llamada desde el otro módulo
sjmp ! ;Espera indefinidamente
.end
-----------------------------------------------------------------------------------------------------------------------------
- 41 -
--------------------------------------------------------------------------------------------------------
Ambos listados se ensamblarán por separado y posteriormente será el
encadenador el que genere un fichero ejecutable que incluya a ambos. Observe que solo
se incluye el listado fuente del segundo ya que el primero está oculto (se utilizó una
directiva .hide).
.equ
Permite asignar directamente a una etiqueta un valor, por ejemplo:
P1 equ $90 ;Define la etiqueta P1

CLKOUT equ P1.6 ;Define la etiqueta CLKOUT
Estas dos lineas definen las etiquetas P1 y CLKOUT. Estas se pueden utilizar
ahora para facilitar el acceso al puerto P1 y a la patilla CLKOUT, por ejemplo:
inicio:
mov P1,A ;Saca por el puerto P1 el acumulador
bucle:
clr CLKOUT ;Pone P1.6 a nivel bajo
nop ;Espera un ciclo
nop ;Espera otro ciclo
setb CLKOUT ;Activa P1.6
sjmp bucle ;Salta a bucle
Este programa genera una frecuencia por el pin 6 del puerto P1. Si no
dispusiéramos de la posibilidad de definir valores de etiquetas escribir este programa
sería menos nmotécnico:
inicio:
mov $90,A ;Carga en el SFR $90 el acumulador
bucle:
clr $96 ;Pone el bit $96 a nivel bajo
nop ;Espera un ciclo
nop ;Espera otro ciclo
setb $96 ;Activa el bit $96
sjmp bucle ;Salta a bucle
Ambos programas son equivalentes. La directiva equ puede ser sustituida por
el signo =, por ejemplo:
P1 = $90
CLKOUT = P1.6
.include
Con esta directiva puede incluir en el listado un fichero ASCII. Se utiliza

normalmente cuando dispone de una parte de listado que es común a muchos fuentes,
como por ejemplo definiciones de macros o registros. La forma de utilización es bien
sencilla:
-----------------------------------------------------------------------------------------------------------------------------
- 42 -
--------------------------------------------------------------------------------------------------------
.include C:\ALTAIR\FUENTES\REG517.DEF
.include C:\ALTAIR\MACROS\16BITS.DEF
;Aquí continua el listado con los registros y

;macros pertinentes definidos
.includeb
Esta directiva permite incluir dentro del código una imagen binaria de un
fichero. Gracias a ello es posible lincar en aplicaciones el sistema operativo que
comienza en la dirección $7000. Para ello basta crear un módulo fuente con el siguiente
contenido:
.text_org $7000
.includeb ..\EPROMS\OS515.BIN ;o OS51.BIN si debe
;estar en un 80C31
.end
Se podría decir por tanto que la directiva .includeb es similar a .include, con la
diferencia que .la primera incluye ficheros ASCII al fuente (previo ensamblador) y la
segunda incluye ficheros binarios al objeto (previo encadenador).
.macro
.endm
Para facilitar la programación, el ensamblador permite definir macros, estos se

definen por medio de las directivas ".macro" y ".endm".
La palabra que sigue a la directiva .macro es el nombre de la macro, y en la

linea siguiente a la directiva comienza la definición de la macro. Esta acaba con la
directiva .endm.
Durante la definición de la macro se puede utilizar la construcción @X, donde

X representa un dígito de 0 a 9, para definir los argumentos. Estas combinaciones se
sustituirán al expandir la macro por los argumentos que seguirán a la llamada de la
macro, separados por comas.
Se pueden definir hasta 256 macros por fichero. Se pueden anidar las llamadas
a macros unas dentro de otras hasta el mismo límite de la anidación de ficheros .include,
teniendo en cuenta que cada macro es equivalente a un include. Por ejemplo:
.macro suma
mov A,@0
add A,@1
.endm
Al llamar la macro anterior, se utilizará la siguiente sentencia:
suma #5,#10
-----------------------------------------------------------------------------------------------------------------------------
- 43 -
--------------------------------------------------------------------------------------------------------
Lo que se expandirá al ensamblar a:
mov A,#5
mov A,#10
Las macros pueden tener salto locales que no se interferirán con los saltos del
programa principal, por ejemplo:
.include C\ALTAIR\FUENTES\REG51.DEF
.macro espera
mov DPTR,#@0
bucle:
djnz DPL,bucle
djnz DPH,bucle
.endm
.text_org $8000
bucle:
espera 25000 ;espera 25000 ciclos
cpl P3.5 ;invierte estado del LED
espera 10000 ;espera 10000 ciclos
sjmp bucle ;salta a bucle
Este listado será automáticamente expandido por el ensamblador a:
.include C\ALTAIR\FUENTES\REG51.DEF
.macro espera
.endm
.text_org $8000
bucle:
mov DPTR,#25000
bucle0:
djnz DPL,bucle0
djnz DPH,bucle0
mov DPTR,#10000
bucle1:
djnz DPL,bucle1
djnz DPH,bucle1

sjmp bucle ;salta a bucle
.if
.else
.endif
-----------------------------------------------------------------------------------------------------------------------------
- 44 -
--------------------------------------------------------------------------------------------------------
Se han añadido estas directivas que permiten ensamblar partes del fuente si se
cumplen determinadas condiciones. Estas directivas de ensamblador, al igual que todas
las demás, no están presentes en el código objeto y no son interpretadas por el
microprocesador, sino por el propio ensamblador.
Sería muy útil disponer en el ensamblador de instrucciones similares a estas

directivas. Utilizar o no listados condicionales depende de la costumbre de cada
programador.
Se suelen utilizar para poder generar a partir de un único listado varios ficheros
objeto diferentes, por ejemplo imagínese que parte o partes del listado cambian según
sean los siguientes parámetros:
• El programa debe ubicarse en EPROM o en SRAM
• El programa es definitivo (activar WATCHDOG) o es una versión a depurar
• Es una versión completa o una versión de prueba (DEMO)
Para ello deberá definir una serie de etiquetas de una forma como la que sigue:
;
; Si la etiqueta EPROM es 0 el programa estará en SRAM si 1
; es 1 estará en la EPROM, si la etiqueta WATCHDOG es 1 se
; activará el WATCHDOG, si es 0 no se activará, si la
; etiqueta DEMO es 1 se generará una versión limitada del
; programa si es 0 se generará una versión completa.
EPROM = 0
WATCHDOG = 0
DEMO = 0
.if EPROM
.text_org $0000
.else
.text_org $8000
.endif
.include \ALTAIR\FUENTES\REG515.DEF
.if WATCHDOG
orl IEN0,#64 ;Refresca el WATCH DOG

orl IEN1,#64 ;¡¡Debe realizarse en dos ciclos!!!
.endif
;Aquí sigue el listado
En la versión actual del ensamblador no se pueden anidar las

expresiones del tipo .if. No obstante estamos trabajando para añadir esta posibilidad.
-----------------------------------------------------------------------------------------------------------------------------
- 45 -
--------------------------------------------------------------------------------------------------------
Expresiones
El lenguaje ensamblador versión 3.00 permite al usuario incluir expresiones,

que serán interpretadas por el ensamblador, por ejemplo:
mov A,#1+1 ;equivale a mov A,#2
mov DPTR,#tabla+4*2 ;Si la etiqueta tabla apunta

;a la base de una tabla de
;valores de 2 bytes, DPTR
;apuntará al quinto elemento
;--- int tabla[]
;--- tabla[4]
Las expresiones pueden incluirse también en directivas del tipo .if, para
realizar ensamblado condicional complejo, como por ejemplo:
.if (EPROM=2 && WATCHDOG=1) || EPROM=0
.else
.endif
Los operandos posibles en las expresiones son:
+ Suma && AND (multiplicación lógica)

- Resta || OR (suma lógica)
* Multiplicación~~ NOT (negación lógica)
/ División
. Modulo (resto)
& AND (multiplicación lógica bit a bit)

| OR (suma lógica bit a bit)
~ NOT (negación lógica bit a bit)
> Mayor que >= Mayor o igual que

< Menor que <= Menor o igual que
= Igual que <> Distinto que
>> Desplazamiento a la derecha (ej: 123 >> 3 = 123/8)

<< Desplazamiento a la izquierda (ej: 123 << 4 = 123*16)
También se dispone de dos operandos unários que permiten seleccionar el byte

alto o bajo de un número de 16 bits.
lb^ byte bajo

hb^ byte alto
Por ejemplo:
tabla=$1234
-----------------------------------------------------------------------------------------------------------------------------
- 46 -
--------------------------------------------------------------------------------------------------------
mov B,#hb^tabla ;byte alto de tabla

mov A,#lb^tabla ;byte bajo de tabla
Será equivalente a:
mov B,#$12 ;byte alto de tabla $12

mov A,#$34 ;byte bajo de tabla $34
A la hora de calcular, las expresiones tienen un orden de prioridad establecido,

que indica el orden en que deben ser calculadas, por ejemplo:
3+5*4 dará como resultado 23 en lugar de 32
Puede alterar si lo desea el orden de prioridad insertando paréntesis, por

ejemplo:
(3+5)*4 dará como resultado 32
No hay limitación en el número de paréntesis a incluir, aunque como

recomendación sugerimos que simplifique al máximo las expresiones, con ello evitará
errores.
El orden de prioridad preestablecido es el siguiente:
~~ ~ * / . + - << >> < <= > >= = <> & | && ||
Queda por realizar un pequeño hincapié en las operaciones lógicas. Como

habrá observado están disponibles las operaciones AND, OR y NOT "normales" y luego
otras denominadas bit a bit.
Las calificadas "normales" actúan con dos valores, verdadero y falso, un valor
cualquiera distinto de cero es verdadero y un valor cero es falso, por el contrario las
operaciones bit a bit actúan individualmente sobre cada uno de los bits de los
operandos, por ejemplo:
~~3 es igual a 0 3 es verdadero, luego al negarlo da falso que es el

valor 0.
~3 es igual a 65532 El valor 3, en binario debe representarse como

%0000000000000011, al negar cada uno de sus bits
obtendremos %1111111111111100 que equivale al
valor 65532.
Como norma general se deben utilizar las operaciones lógicas normales cuando
escribe una expresión condicional para una directiva tipo .if, y las operaciones bit a bit
cuando calcula máscaras o bits. Por ejemplo puede utilizar al activar interrupciones:
EAL = IEN0.7 ;Define cada uno de los bits de IEN0

-----------------------------------------------------------------------------------------------------------------------------
- 47 -
--------------------------------------------------------------------------------------------------------
WDT = IEN0.6
ET2 = IEN0.5
ES = IEN0.4
ET1 = IEN0.3
EX1 = IEN0.2
ET0 = IEN0.1
EX0 = IEN0.0
mov IEN0,#EAL | ES | EX0 ; Permite interrupciones

;y activa interrupciones
;serie y externa 0
Todas las operaciones se realizan utilizando matemática de 16 bits, sin tener en

cuenta desbordamientos en las operaciones.
Limitaciones del ASM51
El ensamblador incluido en el KIT de desarrollo ALTAIR tiene las siguientes

limitaciones:
• La longitud máxima de una linea es de 500 caracteres.
• La longitud máxima de las etiquetas es de 30 caracteres.
• El número máximo de etiquetas es de 5000 por módulo.
• El número máximo de referencias externas es de 1500.
• El número máximo de reubicaciones en un módulo relativo es de 1500.
• El número máximo de .includes anidados es de 20.
• El tamaño máximo del código objeto es de 64 Kbytes.
• El tamaño máximo de las áreas de variables es de 64 Kbytes.
• No pueden realizarse saltos relativos cortos (sjmp) a etiquetas externas.
• Tamaño máximo de una definición de macro es de 8 Kbytes.
Si por cualquier motivo considerase que estas restricciones limitan el

desarrollo de sus aplicaciones, por favor envíenos una carta detallando que parámetro
requiere ampliar. Recuerde que un proyecto puede contar de varios módulos, no es
necesario ni recomendable que todo un programa esté en un único listado.
Parámetros del programa ASM51.EXE
El ensamblador debe recibir un único parámetro, el nombre y directorio del

fichero que debe ensamblar. Normalmente los ficheros que contienen fuentes del 80C51
son del tipo *.S51, esto es, terminan en S51.
-----------------------------------------------------------------------------------------------------------------------------
- 48 -
--------------------------------------------------------------------------------------------------------
Nuestro ensamblador puede aceptar cualquier terminación, por lo que esta debe
ser indicada siempre.
Los nombres y directorios de los ficheros pueden ser absolutos o relativos

siendo válidos:
asm51 A:\FUENTES\EJEMPLO.S51
asm51 ..\EJEMPLO.S51
asm51 C:EJEMPLO.S51
asm51 EJEMPLO.S51
Opcionalmente puede indicar al ensamblador una serie de parámetros:
/L Indica al ensamblador que debe generar un listado del tipo *.LST

/R[n] Indica el número máximo de errores que debe generar, por defecto es de
32 errores.
Por ejemplo:
asm51 A:\FUENTES\EJEMPLO.S51 /L /R10
Ensamblará el fichero ejemplo.s51 del directorio A:\FUENTES\ generando un

listado tipo *.LST y como máximo generará 10 errores. Si se detectaran más de 10
errores el ensamblador abortaría automáticamente y dejaría de buscar otros errores.
A partir del fichero fuente el ensamblador generará varios ficheros los cuales
contienen diferentes informaciones. Estos ficheros tienen el mismo nombre que el
fichero fuente, pero un apellido propio que los identifica *.O51, *.LST, *.ERR.
• Fichero *.O51, el fichero objeto que contiene el código fuente (si el

programador no lo ocultó con la directiva .hide), la lista de etiquetas, tabla de
reubicación y como es obvio el código objeto binario. Dispone por tanto de toda la
información que pueda requerir posteriormente el encadenador y el depurador.
• Fichero *.LST, es un fichero de listado, en él se guarda un listado fuente

junto con las posiciones de memoria y el listado hexadecimal del código objeto. Al final
del listado se da una lista de etiquetas y referencias. En este listado se incluyen los
errores que pudiesen haber generado.
Si ensambla el siguiente fichero, incluido en el disco del KIT de desarrollo:
; *********************************************************
; *
; * Listado 8.1
; *
; * Programa que enciende y apaga un LED conectado en P3.5
; * Normalmente es el LED de la placa madre, aunque el
; * usuario puede conectar otro externo a P3.5 o a otro
; * puerto. Si conecta un LED externo a P3.5 utilizando
; * esquema 8.1 El LED de la placa madre se encenderá
; * cuando el LED externo se apague y viceversa. (El LED de
; * la placa dispone de un inversor)
-----------------------------------------------------------------------------------------------------------------------------
- 49 -
--------------------------------------------------------------------------------------------------------
; *
; *********************************************************
.include ..\reg51.def
.text_org $8000
LED = P3.5 ;Define el puerto del LED
inicio:
mov DPTR,#10000 ;Carga la frecuencia de parpadeo
;en DPTR
cpl LED ;Invierte el estado del LED
?in1:
djnz DPL,?in1 ;Repite bucle para byte bajo
djnz DPH,?in1 ;Repite bucle para byte alto
sjmp inicio ;Salta al inicio del programa
.end
Obtendrá como resultado el siguiente fichero:

000001: ; ***********************************************************
000002: ; *
000003: ; * Listado 8.1
000004: ; *
000005: ; * Programa que enciende y apaga un LED conectado en P3.5
000006: ; * Normalmente es el LED de la placa madre, aunque el
000007: ; * usuario puede conectar otro externo a P3.5 o a otro puerto
000008: ; *
000009: ; * Si conecta un LED externo a P3.5 utilizando esquema 8.1
000010: ; * El LED de la placa madre se encenderá cuando el LED
000011: ; * externo se apague y viceversa. (El LED de la placa dispone
000012: ; * de un inversor)
000013: ; *
000014: ; ***********************************************************
000015:
000000: .include ..\reg51.def
000001: ; **** Definici¢n de registros 8051 ***
000026:
000027:
000017: .text_org $8000
000018:
000019: LED = P3.5 ;Define el puerto del LED
000020:
000021: inicio:
000022: 008000 902710 mov DPTR,#10000 ;Carga la frecuencia de parpadeo en DPTR
000023: 008003 B2B5 cpl LED ;Invierte el estado del LED
000024: ?in1:
000025: 008005 D582FD djnz DPL,?in1 ;Repite bucle para byte bajo
000026: 008008 D583FA djnz DPH,?in1 ;Repite bucle para byte alto
000027:
000028: 00800B 80F3 sjmp inicio ;Salta al inicio del programa
000029:
000030: .end
000031:
Módulos
M¢d. Tamaño Reubicable Origen
Objeto 13 0 32768
Variables 0 1 0
Tabla de etiquetas
Nombre Valor Tipo etiq. Linea def. Módulo
P0 = 128 5 3 1
SP = 129 5 4 1
DPL = 130 5 5 1
DPH = 131 5 6 1
PCON = 135 5 7 1
TCON = 136 5 8 1
TMOD = 137 5 9 1
TL0 = 138 5 10 1
TL1 = 139 5 11 1
TH0 = 140 5 12 1
TH1 = 141 5 13 1
P1 = 144 5 14 1
SCON = 152 5 15 1
SBUF = 153 5 16 1
P2 = 160 5 17 1
-----------------------------------------------------------------------------------------------------------------------------
- 50 -
--------------------------------------------------------------------------------------------------------
IE = 168 5 18 1
P3 = 176 5 19 1
IP = 184 5 20 1
PSW = 208 5 21 1
OV = 210 5 22 1
ACC = 224 5 23 1
B = 240 5 24 1
LED = 181 5 19 0
INICIO = 32768 1 21 0
?IN1 = 32773 1 24 0
Tabla de apariciones
Nombre Valor Tipo externo
Tabla de reubicaciones
Nombre Direcc. Tipo externo
• Fichero *.ERR, este fichero se crea cuando se producen errores al

ensamblar el programa, se indica siempre la linea en que se produjo el error, el fichero
en que se produjo (en el caso de haber includes no tiene porque ser el fuente
especificado en el ensamblador) y una copia de la linea errónea.
Errores generados
El ensamblador ASM51 con el fin de facilitar al programador la realización del

programa es capaz de detectar algunos fallos de sintaxis. Estos fallos son almacenados
en el fichero *.ERR. Los posibles errores que puede obtener son:
No error
No se ha producido ningún error, esto es, el ensamblador ha sido ensamblado

correctamente.
Valor numérico fuera de rango
Se ha escrito un número que se sale del rango permitido, por ejemplo se ha

intentado asignar #300 a un registro de 1 byte. El rango para los números de un byte es
de 0 a 255 ó de -128 a +127 y los de dos bytes de 0 a 65535 ó de -32768 a +32768.
Etiqueta no definida
Se hace una referencia a una etiqueta no definida. En el programa alguna

instrucción referencia una etiqueta sin definir.
Argumento 1 no interpretable
El parámetro escrito en un mnemónico no puede interpretarse ya sea porque su

estructura es demasiado compleja o que contiene caracteres extraños.
Mnemónico o directiva inexistente
El ensamblador ha hallado en el código fuente un mnemónico no definido por

SIEMENS, ni reconocido por INTEL.
Error de entrada/salida
-----------------------------------------------------------------------------------------------------------------------------
- 51 -
--------------------------------------------------------------------------------------------------------
Se ha producido un error en el acceso del disco. Probablemente este esté lleno.
Camino o fichero inexistente
Se ha intentado acceder a un fichero que no se encuentra, ya sea porque no

existe o bien porque se le indicó un camino (directorio) incorrecto.
Error de asignación de memoria
El ensamblador ha solicitado al MS DOS un bloque de memoria y este no se lo

ha concedido. El error se debe probablemente a que el ordenador no disponía de
memoria suficiente o bien que esta estaba demasiado fragmentada.
Número de parámetros incorrecto
Se genera cuando al programador se le olvidó poner todos los parámetros a un

mnemónico.
Argumento 1 incorrecto
Se pasa un parámetro incorrecto en un mnemónico. Un parámetro incorrecto es

aquel no aceptado por SIEMENS o INTEL.
Error indefinido
Este es un error que no debe aparecer nunca. En el caso de que el ensamblador

le genere este error deberá ponerse en contacto con nosotros. Su ensamblador tendrá un
defecto.
Referencia ilegal a etiqueta externa
Se intenta realizar un salto relativo a una etiqueta externa.
Etiqueta ya definida
Intenta redefinir por segunda vez una etiqueta.
Modulo objeto o de variables no definido
No se ha definido ninguna etiqueta. Se pueden definir etiquetas directamente o

con la directiva EQU.
Nombre de macro ya utilizado
Se ha producido un error debido a que ha intentado definir más de una vez la

misma macro.
Definición de macro demasiado grande

-----------------------------------------------------------------------------------------------------------------------------
- 52 -
--------------------------------------------------------------------------------------------------------
Error que se produce cuando intenta definir una macro demasiado extensa, el
tamaño máximo de una macro sin expandir es de 8 Kbytes, unos 8192 caracteres.
Anidación con .if no permitida
Intentó anidar dos directivas if, esto es, el ensamblador detecto un segundo .if
sin haber previamente detectado el .endif del anterior. Si requiere utilizar este tipo de
directivas pruebe a sustituirlas por expresiones más complejas.
No se encuentra .if correspondiente
Se detectó una directiva del tipo .endif sin haber hallado primero la directiva .if
correspondiente.
Se ha encontrado .if sin .endif
Caso opuesto al anterior, se detectó una directiva del tipo .if sin detectar hasta
al final del listado una del tipo .endif.
Falta directiva .end al final del módulo
Se omitió al final del módulo la directiva .end Este error es el más sencillo de
solventar, para ello simplemente escríbalo. Tome la precaución de poner un <Return>
después de la directiva.
Argumento no interpretable
Se trata de una versión más moderna de los errores Argumento X no

interpretable. Al presentar este error se indica exactamente cual es el argumento no
interpretable.
Falta abrir paréntesis
Se detectó un paréntesis cerrado <)> sin haber previamente detectado la

apertura de paréntesis.
Falta cerrar paréntesis
Se trata de un error antónimo al anterior, detección de apertura de paréntesis

sin cierre del mismo.
Recuerde que en el lenguaje ensamblador, a diferencia de lo que ocurre

en C, las expresiones deben comenzar y terminar en una misma linea, teniendo por tanto
que haber un cierre de paréntesis por cada apertura. Los paréntesis son anidables.
Errores en las macros
-----------------------------------------------------------------------------------------------------------------------------
- 53 -
--------------------------------------------------------------------------------------------------------
En esta versión del ensamblador se hace una diferencia importante en los
errores producidos en las macros. Estos errores pueden producirse por una utilización
incorrecta de la macro o bien por error en el código de la macro, por ejemplo:
.macro suma
add @0,@1
.endm
suma B,A
Al expandirse creará:
add B,A
Lo cual es imposible en el ensamblador del 51. La macro está bien definida,

pero el primer parámetro debe ser siempre el Acumulador (A).
Imagínese un segundo caso:
.macro suma
ad @0,@1
.endm
suma A,B
Al expandirse creará:
ad B,A
Aquí el error no es causado por utilizar la macro incorrectamente, sino que el

error es debido a causa de un fallo en el nmónico.
En el primer caso se generará un error por cada utilización incorrecta de la

macro, mientras en el segundo caso solo se generará un error independientemente del
número de veces que se utilice la macro.
7 El enlazador
El enlazador es el programa que se encarga de unir los ficheros objeto

generados por el ensamblador para crear un fichero ejecutable. El fichero ejecutable
puede ser posteriormente enviado al microcontrolador, al depurador, al conversor
binario o al conversor INTEL hexadecimal.
El programa enlazador requiere como parámetros una lista de todos los

ficheros objeto que deben ser enlazados, por ejemplo:
enlaza51 parte1.o51 parte2.o51
Generará un código ejecutable con el nombre parte1.e51 a partir de los fichero

objeto parte1.o51 y parte2.o51. Normalmente se toma como nombre del fichero
ejecutable el nombre del primer fichero objeto, al cual se le cambia su terminación a
-----------------------------------------------------------------------------------------------------------------------------
- 54 -
--------------------------------------------------------------------------------------------------------
E51. Opcionalmente si lo desea puede especificar el nombre del fichero ejecutable
incluyéndolo en la lista de parámetros, por ejemplo:
enlaza51 union.e51 parte1.o51 parte2.o51 ; o bien

enlaza51 parte1.o51 parte2.o51 union.e51
Errores del Enlazador
El enlazador genera adicionalmente un fichero de errores con el mismo nombre

del fichero ejecutable, al que se le cambia la terminación E51 por ERR. En este fichero
puede hallar los siguientes errores:
No hay espacio para el fichero
Se indica que la memoria del disco es insuficiente para albergar el fichero.
Etiqueta no reubicable
Una etiqueta no puede reubicarse por quedar fuera de la página de 2 Kbytes.

Este error se da cuando no es posible reubicar una llamada acall ó un salto ajmp que cae
dentro de su propio módulo. Tenga presente que el enlazador no es inteligente y va
colocando los módulos objeto uno detrás de otro. Si obtiene este error pruebe a cambiar
el orden de los módulos a ensamblar.
Referencia fuera de rango
Ocurre cuando no es posible reubicar una etiqueta de otro módulo. Se da

cuando una instrucción acall o ajmp pretende llamar a una etiqueta de otro módulo que
se encuentra fuera de la página de 2 Kbytes. Al igual que en el error anterior pruebe a
cambiar el orden de los módulos.
Error creando ficheros de símbolos
El disco no dispone de espacio para crear un fichero de símbolos.
Error creando fichero ejecutable
El disco no dispone de espacio para almacenar el fichero ejecutable.
Error asignando memoria
Se produjo un error al solicitar al sistema operativo un bloque de memoria.

Probablemente el equipo disponga de una memoria insuficiente, amplíela o bien elimine
programas residentes.
8 El depurador
El depurador es un programa que permite ejecutar paso a paso un programa

sobre el microcontrolador. Cada vez que se ejecuta una instrucción es posible ver el
contenido de la memoria y los registros así como alterarlos.
-----------------------------------------------------------------------------------------------------------------------------
- 55 -
--------------------------------------------------------------------------------------------------------
Para ejecutar el depurador es necesario disponer un PC con un

microcontrolador ALTAIR equipado con sistema operativo ALTAIR y una arquitectura
similar al ALTAIR 535 original.
Para arrancar el programa depurador debe pasar una serie de parámetros:
depura51 ejecutable [puerto] [velocidad] [prioridad]
Donde ejecutable es el nombre del fichero ejecutable que debe depurarse, debe
ser del tipo *.E51 generado por nuestro ensamblador.
Puerto es el número de interface serie en el que hay disponible un

microcontrolador (por defecto el COM2), con -c1 se indica COM1 y con -c2 se indica
COM2.
El parámetro velocidad es la velocidad en baudios del puerto serie (por defecto

9600). Para indicar una velocidad diferente comprendida entre 0 y 115200 baudios
deberá teclear -vbaudios, por ejemplo -v28800 indicará 28800 baudios.
Por último prioridad es la prioridad que deben tener las interrupciones del
"trace". Estas prioridades pueden ser 0, 1, 2 y 3. Para más información acerca de su
significado consulte el capítulo 4 del manual ALTAIR. Por tanto son parámetros válidos
-p0 a -p3.
Por defecto la prioridad es cero y normalmente no deberá alterarla. Imagine por

un momento que dispone de un programa que utiliza la interrupción del temporizador 1,
la cual es llamada, en un caso hipotético, unas cien veces por segundo. Al ejecutar este
programa podríamos decir que se están ejecutando simultáneamente dos programas, uno
el principal y otro el secundario (interrupción).
Si usted desea depurar el programa principal, deberá poner la interrupción del

temporizador a un nivel de prioridad más alto que la interrupción trace (puerto serie). Si
usted desea depurar la interrupción deberá poner el trace con una prioridad superior a la
del temporizador, así de simple.
El depurador incluido en el KIT de desarrollo ALTAIR es también capaz de

depurar ficheros objeto originarios de otro sistema de desarrollo. Estos ficheros objeto
deben estar en formato INTEL HEXADECIMAL, el formato serie el siguiente:
depura51 ejecutable [puerto] [velocidad] [prioridad]

[dirección] [offset]
Ahora el ejecutable es un fichero INTEL HEX con terminación *.HEX en

lugar de un fichero ejecutable del tipo *.E51. Los parámetros puerto, velocidad y
prioridad conservan el mismo significado.
Se han añadido dos parámetros nuevos que solo cobran sentido cuando
ejecutable es un fichero INTEL HEX. Estos parámetros son dirección y offset.
-----------------------------------------------------------------------------------------------------------------------------
- 56 -
--------------------------------------------------------------------------------------------------------
El parámetro dirección indica al depurador que dirección debe comenzar a
ejecutar, por ejemplo -E$9000 indica que el programa comienza en la dirección $9000.
El parámetro offset tiene un concepto un poco arduo sino se ha encontrado con

la problemática. Este parámetro se introdujo ante un problema que surgió en la
Universidad de Terrasa en donde utilizaban un compilador de C para 51. En este
compilador de C podían definir la dirección donde debía colocarse el programa (por
ejemplo dirección $9000), pero el compilador asumía que el inicio del programa y
vectores de interrupción estaban en las primeras 256 posiciones de memoria (lo cual es
correcto en un microcontrolador basado en la familia 51).
En estas direcciones de memoria lo único que había eran saltos absolutos a

posiciones de programa superiores a la dirección $9000. Como es lógico el compilador
de C utilizado desconocía por completo que en el ALTAIR existe una imagen de los
vectores de interrupción en la dirección $8000, por lo que no era posible depurar el
programa ya que faltaban los saltos a los manejadores de interrupción.
Pues bien, el parámetro offset es capaz de mover el contenido de las primeras

posiciones de memoria a la posición $8000, por ejemplo -d128 toma las primeras 128
posiciones de memoria y las coloca en la $8000 en adelante. Con ello se consigue que
los vectores de interrupción estén en su sitio. Si necesita esta opción y tiene su concepto
poco claro, por favor contacte con nosotros.
Una vez arrancado el depurador le aparecerá una pantalla similar a la mostrada

en la figura 1.9. Esta pantalla se divide en tres partes, una donde se muestra el código
fuente, otra donde se muestran los registros y una última donde se muestran las
variables. Se puede pasar de una a otra parte, denominadas a partir de ahora ventanas,
con ayuda del tabulador. Cada una de las ventanas tiene una funcionalidad y unos
comandos propios, que describimos a continuación:
Fuente
En la pantalla del fuente se muestra a la izquierda las direcciones de la

memoria donde se halla determinada la linea fuente, seguido de uno, dos o tres bytes
hexadecimales que corresponden al código generado y el listado fuente.
El contador de programa es visible en la ventana de registros, pero también

está reflejado en la ventana fuente con un pequeño signo >. La linea con ese signo es la
próxima en ser ejecutada.
Con ayuda del cursor, pág. siguiente y pág. anterior puede mirar el código
fuente hacia adelante o hacia atrás. Incluso puede pasar de un módulo a otro si estuviese
depurando un proyecto con varios módulos o bien pasar a porciones de memoria no
pertenecientes al proyecto. (por ejemplo la EPROM con el sistema operativo ALTAIR).
El depurador dispone de los siguientes comandos:
 Ejecuta una única instrucción, un paso.
-----------------------------------------------------------------------------------------------------------------------------
- 57 -
--------------------------------------------------------------------------------------------------------
<S> Salta una instrucción sin ejecutarla. Literalmente pone el contador de
programa apuntando a la siguiente instrucción.
<E> Ejecuta el programa completo, este solo parará si halla un punto de

ruptura o bien si se pulsa la tecla para entrar de nuevo en el modo paso a paso.
 Sirve para poner o quitar puntos de ruptura. Una linea o dirección con
punto de ruptura será reflejada en pantalla mediante una franja roja. El depurador 8051
v.3.00 acepta un máximo de 8 puntos de ruptura y estos deben estar separados entre si al
menos por tres direcciones de memoria.
<V> Sirve para poner un punto de visualización. Un punto de ruptura es

similar en cierto modo a un punto de ruptura, con la única diferencia que el programa no
se para sobre él. Sirve para refrescar registros y variables presentados en la pantalla del
depurador.
Si ejecuta el programa con la opción <E> no se mostrará en pantalla el estado

de los registros del microcontrolador, este estará ocupado en ejecutar a toda velocidad el
programa. Es posible que al pasar por determinado punto necesitara ver el contenido de
los registros (refrescarlos), eso es justamente lo que permite un punto de visualización.
Los puntos de visualización son mostrados con una franja azul.
El número de puntos de ruptura más el número de puntos de

visualización no puede sobrepasar de 8.
OJO: Tenga presente que un punto de ruptura o visualización ocupa en

la memoria 3 bytes, y que por tanto no puede ponerlos en lugares críticos porque
conseguirá que el programa en el microcontrolador se vuelva loco, por ejemplo:
bucle:
inc A
lcall comprueba
sjmp bucle
comprueba:
cjne A,#12,siguiente
.
.
Si coloca el punto de ruptura o punto de visualización sobre la instrucción

sjmp, estará destruyendo la instrucción cjne. Esto es debido a que sjmp es una
instrucción de tan solo dos bytes y el punto de ruptura utiliza 3 bytes (se trata de un
ljmp $72xx), por lo que si el programa salta a comprueba ejecutará cualquier instrucción
menos la deseada.
Para subsanar el error y poder poner un punto de ruptura en el lugar deseado

bastará con añadir una instrucción nop después de sjmp, tal y como puede ver a
continuación:
-----------------------------------------------------------------------------------------------------------------------------
- 58 -
--------------------------------------------------------------------------------------------------------
bucle:
inc A
lcall comprueba
sjmp bucle
nop
comprueba:
cjne A,#12,siguiente
.
.
Ahora si pone un punto de ruptura sobre sjmp bucle destruirá la instrucción

nop, que nunca iba a ser ejecutada, en cierto modo puede decir que ha convertido la
instrucción de dos bytes en una instrucción de 3 bytes (sjmp + nop).
<T> Ejecuta el programa en modo trace, esto es, de forma lenta, mostrando
después de ejecutar cada instrucción el contenido de todos los registros presentes en la
pantalla del depurador.
 Permite ir a una posición de memoria deseada. Al presionar esta tecla le

aparecerá en pantalla un pequeño cuadro con una linea editable donde debe teclear el
número de la linea a donde desea ir.
<M> Al pulsar esta tecla se llama al editor de memoria. El editor de memoria

puede considerarse como un programa propio. Este programa es descrito con detalle
más adelante.
 Con este opción puede desensamblar una zona de la memoria sobre
disco, por ejemplo el sistema operativo ALTAIR que comienza en la dirección $7000 y
que tiene una longitud de $1000 bytes (4 Kbytes).
<N> Permite habilitar/deshabilitar el desensamblador en las zonas de la

memoria no pertenecientes al proyecto. Si deshabilita el desensamblador el visualizador
de código fuente se comporta como en versiones anteriores del depurador.
<F> Permite indicar si desea que el depurador muestre etiquetas en las áreas
desensambladas o no. Estas etiquetas del desensamblador son generadas de forma
automática a partir de su dirección física.
Registros
Si se sitúa sobre esta ventana podrá fácilmente modificar un registro. Para ello
sitúese sobre él con ayuda de las teclas del cursor. Una vez que esté sobre él pulse la
tecla <Return> con lo que podrá asignarle su nuevo valor.
Modificando el registro PC ocasionará que el programa se ejecute en esa

dirección, por lo que deberá tener un especial cuidado. También deberá tener cuidado
con el número de pila, ya que el sistema operativo ALTAIR utiliza de ella 8 bytes.
-----------------------------------------------------------------------------------------------------------------------------
- 59 -
--------------------------------------------------------------------------------------------------------
El valor del registro SP mostrado en pantalla hace siempre referencia a la pila
de la aplicación de usuario, pero siempre hay 8 bytes más, por lo que la pila del sistema
es la del usuario más 8 bytes. Por ello debe dejar en la pila un espacio de al menos 10
bytes para el depurador. Normalmente no deberá tener en cuenta este dato pudiendo
considerar la pila mostrada como correcta.
Variables
Esta ventana permite ver el contenido de etiquetas, variables o posiciones de

memoria mediante una lista desplazable con las teclas del cursor.
Para añadir un elemento a esta lista deberá pulsar la tecla <Insert> y para
borrar un elemento deberá posicionarse sobre él y pulsar <Del>.
Los elementos que puede añadir son variables definidas por etiquetas y
posiciones de memoria, que deben teclearse de la siguiente forma:
[n_elementos][@]etiqueta
Esta forma permite ver la dirección en que se halla una rutina, o bien el
contenido o dirección de un registro. El número de elementos especifica cuantos bytes
desea ver, por ejemplo:
P5 ;Mostrará la dirección del registro P5

@P5 ;Mostrará el contenido del registro P5
tabla ;Mostrará la dirección de la tabla
4@tabla ;Mostrará los cuatro bytes de la tabla
Como es lógico las etiquetas P5 y tabla deben estar definidas en el programa.
También puede realizar un acceso indirecto a la memoria, por ejemplo imagine

que tiene definido en la posición $20 un registro denominado BDAS:
BDAS ;Mostrará posición del registro BDAS $0020

@BDAS ;Mostrará contenido de BDAS
@@BDAS ;Mostrará el contenido de la posición apuntada
;por el contenido del registro BDAS
8@@BDAS ;Mostrará 8 posiciones apuntadas por

;el contenido del
;registro BDAS.
Existe otro formato añadido que permite ver el contenido de la memoria.
[n_elementos]@(dirección)
Si la dirección es menor que $FF (un byte) se mostrará el contenido de la

memoria interna y si es mayor (2 bytes) se mostrará el contenido de la memoria de
programa externa.
-----------------------------------------------------------------------------------------------------------------------------
- 60 -
--------------------------------------------------------------------------------------------------------
8@($00) ;Mostrará el contenido de los primeros 8 bytes
de
;la memoria interna, esto es los registros R0 ..
;R7 del banco 0
8@($0000) ;Mostrará el contenido de los primeros 8 bytes
;de la memoria externa
2@($FFFE) ;Mostrará los bytes contenidos en $FFFE y $FFFF
;por lo que podrá averiguar si el programa
;está residente
;o no, dependiendo si contiene $ABCD ó $CDEF u
;otro valor cualquiera.
En el área de variables también puede ver si lo desea los 8 últimos bytes que
contiene la pila de usuario. Estos se mostrarán en el orden en que pueden volver a ser
extraídos.
Para ver la pila simplemente deberá insertar la variable #SP.
En la familia 51 no existen los conceptos de pila de usuario y de pila de

sistema, pero si inserta en la pantalla de variables @SP para ver el contenido del
registro puntero de pila verá que este difiere del mostrado en la ventana de registros.
Esta diferencia se debe a que sobre lo que nosotros denominamos pila de

usuario (la pila de aplicación que esta siendo depurada) colocamos una pila adicional
que es utilizada por el depurador, más en concreto por la interrupción del puerto serie.
En la ventana de registros usted verá el valor del puntero de pila de usuario,

mientras en la ventana de variables verá el puntero de pila real, el del sistema.
Obviamente la pila que se presenta en el área de variables cuando se inserta

#SP es la pila de la aplicación no la del sistema.
Por último queda por decir que puede salir en cualquier momento del
depurador pulsando la tecla <ESC>. El programa cargado en el micro quedará en el
estado anterior, esto es, si se ejecutó seguirá ejecutándose y si estaba parado, seguirá
parado.
9 Editor de memoria
Aunque sea parte del depurador, debido a la gran cantidad de opciones que
dispone, es considerado a efectos de manual como si se tratase de un programa aparte.
Se puede acceder a este programa en cualquier momento desde el depurador de
memoria pulsando la tecla <M>.
Este programa permite editar (visualizar y modificar) todos los tipos de

memoria que dispone el 8051. A causa de las limitaciones impuestas por INTEL la
memoria de programa solo se puede leer. Dada la arquitectura de nuestros
microcontroladores la memoria externa es mostrada en un único banco, leyendo siempre
memoria de programa y escribiendo sobre memoria de datos.
-----------------------------------------------------------------------------------------------------------------------------
- 61 -
--------------------------------------------------------------------------------------------------------
Tenga la precaución de no olvidar que los 32 Kbytes inferiores de la

memoria de programa tienen memoria de datos y programa independientes. La
confusión que puede producirse en este punto será subsanada en versiones posteriores al
ensamblador.
Nada más arrancar el editor de memoria se muestra en el monitor una pantalla

similar a la mostrada en la figura O. Esta pantalla dispone en su parte inferior de una
barra de menús horizontal que puede manejar fácilmente con las teclas del cursor y con
la tecla <Return>. Las opciones disponibles son las siguientes:
EDITA
Con esta opción entra de lleno en el editor propiamente dicho. Una vez dentro
puede alterar el contenido mediante el teclado.
Con el tabulador puede pasar el cursor de la parte derecha a la parte izquierda.

La parte izquierda muestra los datos en formato Hexadecimal, mientras la parte derecha
los muestra en formato ASCII.
Las teclas del cursor, pagina anterior, pagina siguiente, primera posición,
última posición, inicio y fin funcionan en el modo habitual de estos programas.
Para volver a un menú de opciones simplemente pulse la tecla <ESC>
IR A
Esta subopción le permite ir directamente a una posición de memoria

específica. Para ello se le presentará un cuadro de diálogo, figura P, en el cual puede
introducir la posición de memoria del buffer que desea editar.
COPIA
Con esta opción puede copiar un bloque de memoria dentro del buffer del
editor. Para ello debe indicarle al programa la dirección de origen a copiar, la dirección
de destino y el número de bytes que desea copiar. Vea la figura Q.
MUEVE
Esta opción es parecida en cierto modo a la anterior, con la diferencia que el

bloque seleccionado es movido en lugar de copiado, esto es no se duplican los datos,
simplemente cambian de sitio. Vea figura R.
IMPRIME
Esta opción permite imprimir el buffer del editor o parte de él sobre una
impresora. Dado que el programador de EPROMs se conecta al mismo puerto que la
impresora puede existir algún problema que se soluciona añadiendo un segundo puerto
paralelo (LPT2) y conectando la impresora a él.
-----------------------------------------------------------------------------------------------------------------------------
- 62 -
--------------------------------------------------------------------------------------------------------
Dado que el puerto paralelo que maneja una impresora no tiene porque ser
rápido ni es necesaria ninguna característica extraña lo más razonable es comprar la
tarjeta MULTI I/O más barata, deshabilitar controladora de disco duro, floppy y puertos
serie y dejar solamente el puerto paralelo como LPT2. Si lo precisa puede configurar los
puertos serie como COM3 y COM4.
A continuación desde el MSDOS utilizando el comando MODE debe indicar al

equipo que la impresora a utilizar es el LPT2 en lugar del LPT1. Una tarea que
cualquier tienda de informática puede realizar por un precio ínfimo.
Al seleccionar esta opción aparece en pantalla un cuadro de diálogo, figura S,

en el que puede parametrizar parte del listado, pudiendo seleccionar entre impresora de
carro ancho y carro estrecho, número de filas por página, número de columnas,
alimentación de página manual/automática, dirección de inicio y dirección de final.
ASCII
Esta opción es muy interesante para eliminar basura de la pantalla del editor.
En el editor se presentan dos partes, una de ellas la de la izquierda se muestra el
contenido en hexadecimal del buffer, mientras que en la otra se muestra el contenido en
formato ASCII.
Si usted desea ver solamente los textos que pudiese contener la memoria al
seleccionar esta opción se presentarán solamente los caracteres ASCII (entre el 32 y el
128). Para deseleccionar este modo simplemente vuelva a seleccionar la opción ASCII.
RELLENA
Esta opción permite rellenar parte o todo el buffer del editor con un patrón.
Para ello le aparecerá en pantalla un cuadro de diálogo en el que debe teclear la
dirección inicial que desea rellenar, el número de bytes y el byte patrón. Dicho cuadro
es mostrado en la figura T.
BUSCA
Con esta opción puede buscar dentro del buffer una cadena alfanumérica
ASCII (un texto) o bien una cadena hexadecimal (una subrutina o una tabla).
Una vez seleccionada la opción aparecerá un cuadro de diálogo con dos lineas
editables. Vea la figura U. En la primera puede teclear la cadena ASCII que desea
buscar y en la segunda la cadena hexadecimal. Debe teclear texto en solo una de ellas.
El texto hexadecimal debe ser escrito de forma que cada dos cifras
hexadecimales (byte) haya un espacio separador.
SIGUIENTE
Esta opción repite la búsqueda pedida con la opción anterior sin presentar de
nuevo el cuadro diálogo. Esta opción es útil por si se repitieran varias veces la misma
cadena y no se deseara la primera de ellas.
-----------------------------------------------------------------------------------------------------------------------------
- 63 -
--------------------------------------------------------------------------------------------------------
MEMORIA
Con esta opción usted puede seleccionar el tipo de memoria que desea editar.
Al seleccionarla le aparecerá en pantalla una ventana, mostrada en la figura W, que
permite seleccionar entre memoria externa de datos, interna directa y externa indirecta.
10 Programa ejecutor
Se trata de un programa que permite ejecutar ficheros ejecutables sobre el

microcontrolador, siempre y cuando esté provisto de una EPROM con un sistema
operativo ALTAIR.
Estos ficheros ejecutables pueden ser del tipo *.E51 generados por nuestro KIT
de desarrollo, o bien del tipo *.HEX (INTEL HEX) generados por otro sistema.
El programa EX51.EXE debe recibir como parámetros el nombre del fichero

ejecutable que se debe enviar, la dirección de comienzo, opcionalmente el puerto serie
al cual está conectado, la velocidad de transmisión y una indicación de si desea una vez
enviado el programa arrancar el terminal de comunicaciones. Los parámetros de este
comando son:
ex51 ejecutable [puerto][velocidad][terminal]
El puerto por defecto es el COM2, y la velocidad por defecto es 9600 baudios.

A continuación varios ejemplos:
ex51 sirena.e51 -c1 -v9600 -t ;o bien

ex51 sirena.e51
Si va a ejecutar un fichero INTEL HEX existen dos parámetros adicionales a

tener en cuenta, la dirección y el offset. Estos dos parámetros son los mismos a los
descritos anteriormente en el depurador.
Imagine que dispone del siguiente fichero INTEL HEX que ha sido generado
por un compilador de C ajeno a IBERCOMP:
:08904100C180010900010800D3
:03000B0002900060
:10900000C0E0C0D0C28C758C4B758AFFB2003000B6
:10901000020509E509B40A07B2B5E4F5090508D265
:069020008CD0D0D0E0323C
:10902600438901758C4B758AFFD2A9D2AFD28CE5E4
:0B90360008C3941440F9C28C80FE2295
:0300000002904A21
:0C904A00787FE4F6D8FD7581200290913B
:10905600029026E493A3F8E493A34003F68001F27A
:1090660008DFF48029E493A3F85407240CC8C3331B
:10907600C4540F4420C8834004F456800146F6DFEA
:10908600E4800B0102040810204080909041E47EA9
:10909600019360BCA3FF543F30E509541FFEE493DF
:1090A600A360010ECF54C025E060A840B8E493A3A6
-----------------------------------------------------------------------------------------------------------------------------
- 64 -
--------------------------------------------------------------------------------------------------------
:1090B600FAE493A3F8E493A3C8C582C8CAC583CAD1
:1090C600F0A3C8C582C8CAC583CADFE9DEE780BE89
:019049000026
:00000001FF
Para ejecutarlo deberá teclear el siguiente comando:
ex51 INTEL.HEX -c1 -v9600 -e$8000 -d256
En el caso de enviar un fichero INTEL HEX, puede omitir la dirección de

ejecución, con lo que el programa se enviará pero no se ejecutará. También puede no
indicar nombre de fichero y si dirección de ejecución con lo que se ejecutará la
dirección especificada sin enviar ningún fichero.
El programa EX51 indicará si el programa pudo ejecutarse o no. El fallo al

intento de ejecutar un programa puede deberse a que el microcontrolador no responde,
ya sea porque el sistema operativo no tiene el control de las interrupciones, bien porque
está averiado, mal conectado o simplemente algún programa ejecutado anteriormente
tomo control de la interrupción serie.
11 Conversor a binario
Se trata de un programa que obtiene un fichero binario del código objeto del
proyecto a partir del fichero ejecutable. Este fichero binario puede ser utilizado, por
ejemplo, para programar una EPROM con aplicación residente.
La utilización es bastante sencilla, basta escribir el comando:
bin51 ejecutable -oORIGEN - tTAMAÑO
Donde ejecutable es el nombre y directorio del fichero ejecutable, mientras que

origen y tamaño se refieren al offset dentro de la memoria del equipo desde donde se
grabará el fichero binario y tamaño indica el número de bytes que se grabarán. El
fichero de salida tiene el mismo nombre que el fichero ejecutable, cambiando la
terminación E51 por la terminación BIN.
Este comando ha presentado muchos problemas a los usuarios, normalmente

debido a una utilización incorrecta del mismo. Supongamos que hemos realizado un
programa ejecutable que ocupa 27000 bytes denominado ejemplo.e51 y que comienza
en la dirección $0000 (.text_org $0000) y que deseamos meterlo en un sistema que
dispone de dos EPROMs de 16 Kbytes cada una.
En primer lugar escribiremos los siguientes comandos:
bin51 ejemplo.e51 -o0 -t16384

ren ejemplo.bin eprom01.bin
bin51 ejemplo.e51 -o16384 -t16384
ren ejemplo.bin eprom02.bin
Lo cual nos generará dos ficheros binarios, eprom01.bin y eprom02.bin los

cuales serán una imagen de las dos EPROMs que usted debe programar. La primera de
-----------------------------------------------------------------------------------------------------------------------------
- 65 -
--------------------------------------------------------------------------------------------------------
ellas dispondrá de los 16 primeros K de memoria y la segunda de los últimos 11 K. El
espacio no utilizado de la segunda EPROM será rellenado con el carácter $FF.
Si usted desea una única EPROM de 32 Kbytes (caso estándar en los equipos
ALTAIR) deberá teclear el comando bin51 con los parámetros que siguen:
bin51 ejemplo.e51 -o -t32768
Lo cual nos generará el fichero deseado con el programa especificado bajo la

denominación ejemplo.bin.
12 Conversor a formato hexadecimal
Esta utilidad convierte un fichero binario en un fichero hexadecimal con

formato INTEL. Este formato es estándard y puede ser leído por la mayoría de
programadores de EPROMs del mercado, incluyendo el nuestro. Requiere como
parámetros el nombre y directorio del fichero binario. Opcionalmente puede indicarle la
dirección origen del fichero.
binhex binario [-oorigen]
por ejemplo:
binhex sirena.bin
binhex sirena.bin -o$8000
El nombre del fichero hexadecimal es el mismo que el del fichero binario

especificado, cambiando su terminación a HEX.
13 Ejecutor remoto de binarios
Este sencillo programa permite enviar y ejecutar en el microcontrolador

ficheros binarios. Estos ficheros binarios pueden ser el resultado de convertir un *.e51 a
binario o resultado de otros KITs de desarrollo.
Esta aplicación requiere como parámetros el nombre y directorio del fichero

binario, puerto y velocidad, la dirección donde debe cargarse, la posición donde debe
cargarse y si debe tener terminal, su formato es:
exbin51 binario [puerto][velocidad][terminal][origen][arranque]
[puerto] es el puerto serie donde está conectado el microcontrolador. Este

puede ser -c1 para indicar COM1 ó -c2 para indicar COM2. Por defecto se utiliza el
COM2.
[velocidad] es la velocidad en baudios a la que se debe enviar el fichero binario

al microcontrolador. Por defecto esta velocidad es de 9600 baudios. Por ejemplo -
v57600 indica que se ha de transmitir el fichero a 57600 baudios.
[terminal] indica con -t si se debe llamar al programa terminal después de

ejecutar el programa. Por defecto no se llama al programa terminal.
-----------------------------------------------------------------------------------------------------------------------------
- 66 -
--------------------------------------------------------------------------------------------------------
[origen] se indica la dirección de memoria donde debe cargarse el programa,

por ejemplo -o$8000 indica dirección $8000. Por defecto se coge la dirección $0000.
[arranque] indica que dirección de memoria se ha de ejecutar, -e$8000 quiere

decir ejecutar a partir de la dirección $8000.
Sino se indica dirección de arranque el fichero no se ejecutará. Sino se indica

nombre de fichero y si dirección de arranque, se arrancará directamente.
14 Cargador de EEPROMs
A los microcontroladores ALTAIR equipados con conector de bus de

direcciones y datos (ALTAIR 537 y ALTAIR535E) se le puede añadir una pequeña
placa que se intercala entre dicho conector de buses y el puerto paralelo de un PC.
Si dispone de dicha placa adaptadora podrá sustituir la EPROM por una

EEPROM tipo X28C256, la cual podrá grabar con este programa. Este programa es
sencillo de manejar tan solo dispone de dos parámetros:
eeprom51 binario -v
binario es el nombre del fichero binario a enviar, este siempre comienza en la

dirección $0000. -v sirve para habilitar la verificación de grabación, opción que solo
funciona con algunas tarjetas MULTI I/O
Si desea escribir sobre la EEPROM el sistema operativo normal, deberá

simplemente teclear:
eeprom51 eprom537.bin
El micro arrancará con el típico parpadeo rápido, para a continuación quedarse

en reposo con el parpadeo lento.
15 Reseteador del Microcontrolador
Este programa tan solo requiere de dos parámetros opcionales, el puerto serie
en el cual está conectado el microcontrolador y la velocidad seleccionada en él. El
puerto por defecto es el COM2 y la velocidad por defecto es de 9600 baudios.
El programa reinicializa el microcontrolador, parando cualquier aplicación que

pudiese estar ejecutándose. Si el microcontrolador no responde ya sea porque está
defectuoso, no hay cable o bien porque el sistema operativo no tiene control del puerto
serie se presentará en pantalla un mensaje de error. A continuación un par de ejemplos
de como utilizar el comando Reseteador:
reset51
reset51 -c1
reset51 -c1 -b28800
-----------------------------------------------------------------------------------------------------------------------------
- 67 -
--------------------------------------------------------------------------------------------------------
El primer comando resetea un microcontrolador conectado a COM2 y a 9600
baudios (valores por defecto), el segundo resetea un controlador conectado a COM1 a
9600 baudios y el tercer comando resetea un microcontrolador conectado a COM1 a
28800 baudios.
16 Testeador de la memoria
Se trata de un programa que permite comprobar el correcto funcionamiento del

microcontrolador. Comprueba que las comunicaciones con él son correctas y
comprueba que la SRAM es correcta.
Al mismo tiempo escribe ceros en toda la memoria SRAM pudiéndose por

tanto utilizar este programa para limpiar la memoria (ej: eliminar programas residentes).
Los parámetros definen el puerto serie al cual está conectado el

microcontrolador y la velocidad del mismo, ejemplos:
test51
test51 -c1
test51 -c1 -b4800
Al igual que en otros programas, el puerto serie por defecto es el COM2 a una
velocidad de 9600 baudios. Por tanto la primera linea ejemplo testeará un
microcontrolador en COM2 a 9600 baudios, la segunda en COM1 a 9600 baudios y la
tercera en COM1 a 4800 baudios.
Debe tener presente que la velocidad en baudios seleccionadas debe coincidir

con la que tiene en el microcontrolador, normalmente 9600 baudios con un cristal de 12
MHz.
17 Desensamblador
Aunque no sea necesario hemos incluido en el KIT de desarrollo del ALTAIR

un desensamblador de código 8051 de dominio público, el DS51 8051/8052
Dissasembler V1.1 (C) 1990 by J. L. Post. Esta versión fue puesta en dominio público el
4 de Agosto de 1990. Usted puede contactar directamente con el autor en:
Jeffery L. Post
22726 Benner Ave
Torrance
CA 90505
Estados Unidos
Este desensamblador está contenido en el directorio D51, en el cual se incluye

también el manual que se acompaña con él.
Este programa permite tanto desensamblar código binario como código en

formato Intel Hexadecimal, con lo cual es posible explotar aplicaciones por terceros de
8051. La ingeniería inversa no es una práctica a nuestro juicio correcta, pero en algunas
-----------------------------------------------------------------------------------------------------------------------------
- 68 -
--------------------------------------------------------------------------------------------------------
ocasiones puede ser útil extraer de otra persona una rutina o la idea de un algoritmo.
Para ello es indispensable un desensamblador.
El ensamblador es muy sencillo de utilizar, basta teclear el comando:
D51 fichero [-d] [-b] [-x]
Donde el fichero es el nombre sin extensión del fichero a desensamblar. Este

debe terminar forzosamente en BIN o HEX (según sea binario o Intel Hexadecimal). El
parámetro opcional -d indica que deben incluirse las direcciones y datos en los
comentarios. Nosotros recomendamos no utilizar esta opción.
El parámetro -b indica que el fichero tiene formato binario en lugar de

hexadecimal. Por defecto el fichero es hexadecimal. Por último -x sirve para indicar la
dirección de comienzo del programa, que normalmente es $0000, el valor por defecto. A
continuación algunos ejemplos de como llamar a los comandos:
d51 a:\eprom -b -x$4000

d51 eprom
La primera linea desensamblará un programa denominado EPROM.BIN en la

unidad A que comienza en la dirección $4000, mientras que la segunda desensamblará
un programa denominado EPROM.HEX en el directorio actual que comienza en la
dirección $0000.
Copiar o fusilar indiscriminadamente aplicaciones ajenas constituye un

delito muy grave castigado con penas de prisión. Delito que perjudica a nuestra
industria, fuente de nuestra riqueza y progreso. Rogamos que no utilice este programa y
ningún otro de nuestro KIT para realizar prácticas ilícitas.
18 Terminal
Este programa tal y como índica el título es una terminal "tonta" para PC. Su
función es enviar al puerto serie los caracteres tecleados e imprimir por pantalla los
caracteres recibidos.
Requiere de dos parámetros opcionales que definen el puerto serie y velocidad

a la que debe actuar. Los valores por defecto son COM2 a 9600 baudios. Ejemplos de la
llamada al programa terminal:
term51
term51 -c1 -v9600
El primer ejemplo llamará al programa terminal con los parámetros por

defecto, esto es, COM2 a 9600 baudios, el segundo ejemplo utilizará el COM1 a 9600
baudios.
Una vez ejecutado el programa cualquier tecla que pulse en el teclado será
enviada al puerto serie, y cualquier carácter que reciba será mostrado en pantalla. Si
desea salir del programa deberá pulsar dos veces seguidas la tecla <ESC>.
-----------------------------------------------------------------------------------------------------------------------------
- 69 -
--------------------------------------------------------------------------------------------------------
El programa aparte de interceptar una secuencia de dos <ESC> intercepta

también cuando se pulsa <ALT R>. Esta secuencia sirve para activar o desactivar el
modo HALF DUPLEX y el modo FULL DUPLEX.
Dicho de otro modo, cuando pulsa <ALT R> y el PC emite un pitido indica
que se ha habilitado el modo HALF DUPLEX, por lo cualquier tecla pulsada además de
ser enviada al puerto serie será enviada a la pantalla. Si se pulsa <ALT R> y el PC no
emite ningún pitido, una de dos o el sistema altavoz está dañado, o bien se ha habilitado
el modo FULL DUPLEX, por el cual las teclas pulsadas solamente se envían al puerto
RS232c.
Este programa es útil para observar cuales son los datos que envía el
microcontrolador. Funciona correctamente entre dos PC conectados por el puerto serie.
En la última versión del programa terminal se añadió una opción que permite
que el programa actúe como un terminal VT52. A dicho modo se accede pulsando
<ALT C>. Cuando se está en dicho modo ser interpretan las siguientes secuencias:
ESC A Cursor Arriba
Esta secuencia mueve el cursor una linea arriba. Esta secuencia no

afecta al cursor si éste está ya en la primera linea.
ESC B Cursor Abajo
Esta secuencia mueve el cursor una linea hacia abajo. Esta secuencia
no es interpretada si el cursor ya está en la última linea.
ESC C Cursor Adelante
Esta secuencia mueve el cursor una posición a la derecha. Si el

cursor está en el lado derecho esta secuencia no tiene efecto.
ESC D Cursor Atrás
Esta secuencia mueve el cursor una posición a la izquierda. Si el

cursor ya está en la columna de la izquierda esta secuencia no tiene
efecto.
ESC E Borra la Pantalla
Esta secuencia borra toda la pantalla y pone el cursor en la fila 1 y

columna 1.
ESC H Pone el cursor en el margen izquierdo de la pantalla
Esta secuencia simplemente pone el cursor en la fila 1 y columna 1.

A diferencia de la secuencia anterior esta no borra la pantalla.
-----------------------------------------------------------------------------------------------------------------------------
- 70 -
--------------------------------------------------------------------------------------------------------
ESC I Invierte el Indice
Esta secuencia lee la fila y columna en donde se halla el cursor y las

invierte, de forma que si el cursor estaba en X,Y pasa a estar en Y,X.
ESC J Borra hasta el fin de Página
Borra toda la información de pantalla desde el cursor (inclusive)

hasta el final de la pantalla. El final de la pantalla es la posición
inferior derecha.
ESC K Borra hasta el fin de linea
Borra toda la información desde la posición del cursor hasta el final

de la linea donde se halla el cursor.
ESC L Inserta una Linea
Inserta una linea en blanco en la posición del cursor. Para ello baja
una posición todas las líneas que están por debajo del cursor, y
también la del cursor. De modo que al final de la operación la linea
del cursor está en blanco. Como es lógico, el contenido de la última
linea de la pantalla se pierde.
ESM M Borra una Linea
Borra la linea donde está el cursor y sube una posición todas las
líneas que se encuentra debajo de él. La última linea de la pantalla
es rellenada con una linea blanca.
ESC Y Posiciona el Cursor
Esta secuencia va seguida de dos caracteres que especifican columna

y fila del cursor. El primer carácter especifica fila, y el segundo
especifica columna. Para posicionar el cursor en una posición X,Y
debe enviarse la siguiente secuencia ESC Ý´ CHR$(X+32)
CHR$(Y+32).
Además de las secuencias VT52 anteriormente mencionadas, nuestro programa

terminal intercepta e interpreta las siguientes secuencias:
ESC b Selecciona el color del carácter
Con esta secuencia se puede seleccionar el color de los próximos

caracteres a imprimir. El carácter que sigue a esta secuencia debe ser
el número del color del carácter. Puede ser carácter 0..15 ó ´0´..´F´´ó
Á´..Ó´´.
ESC c Selecciona el color de fondo
-----------------------------------------------------------------------------------------------------------------------------
- 71 -
--------------------------------------------------------------------------------------------------------
Esta secuencia selecciona el color de fondo. Esta debe ser seguida
por un carácter que indica el número del color de fondo. Este
carácter tiene el mismo formato que el de la secuencia anterior.
ESC d Borra desde el inicio de la pantalla
Con ésta se borra la pantalla desde su origen (1,1) hasta la posición

del cursor.
ESC e Habilita cursor
Con esta secuencia se habilita el cursor, esto es, se obliga a que éste
aparezca parpadeando en pantalla.
ESC f Deshabilita cursor
Con esta secuencia se puede deshabilitar el cursor, esto es, que

desaparezca de la pantalla. Internamente el cursor sigue existiendo,
aunque el usuario u operador no lo puede ver a través de la pantalla.
ESC j Guarda la posición del cursor
Esta secuencia guarda las coordenadas del cursor en un buffer

interno.
ESC k Recupera la posición del cursor
Esta secuencia permite recuperar la posición del cursor que

previamente se guardo con ESC j. De este modo es posible volver al
punto anterior.
ESC l Borra una linea entera
Se borra la linea en la que se encuentra el cursor y lo posiciona en el

lado izquierdo de la pantalla. Con seta secuencia no se insetan ni
desplazan filas de la pantalla.
ESC o Borra el principio de una linea
Borra desde la primera columna de la linea del cursor hasta el cursor.
ESC p Habilita vídeo inverso
Con esta secuencia los caracteres son impresos con el color del
fondo y el fondo con el color del carácter.
ESC q Deshabilita el vídeo inverso
Esta deshace el efecto de la secuencia anterior.
-----------------------------------------------------------------------------------------------------------------------------
- 72 -
--------------------------------------------------------------------------------------------------------
ESC v Habilita el modo de corte
Esta secuencia habilita el modo de corte de las palabras. Lo cual

quiere decir que si una palabra llega al final de una linea esta
automáticamente salta a la linea siguiente, cambiando las
coordenadas del cursor a la linea siguiente. Cuando el modo está
deshabilitado y el cursor llega a la columna derecha, todos los
caracteres imprimibles serán impresos en dicha posición, posición
que permanecerá fija.
ESC w Deshabilita modo de corte
Anula el efecto de la secuencia anterior.
En el modo VT52 el programa terminal interpretará además de las secuencias

anteriormente mencionadas los códigos de control estándares, que son:
CHR$(8) BackSpace - Retrocede una posición.

CHR$(9) Tabulador - Avanza hasta el próximo tabulador.
CHR$(10) Salto de linea. Incrementa su posición una linea.
CHR$(13) Retorno de carro - Se posiciona el columna 1.
Los caracteres 32 .. 255 serán impresos en pantalla en el modo habitual. Cada

vez que se imprime un carácter el cursor avanza una posición, salvo que esté en la
última columna y el modo de corte esté deshabilitado.
19 Rutinas para el control del puerto serie de un PC
Para facilitar aun más la comunicación entre un microcontrolador ALTAIR con

un ordenador PC compatible, suministramos un listado escrito en BORLAND C v.3 que
incluye rutinas de manejo del puerto serie COM1 y COM2 a diferentes velocidades.
Estas rutinas son las mismas que hemos utilizado en nuestros programas
RESET51.EXE, DEPURA51.EXE, EJECUTA51.EXE y TEST51.EXE.
Normalmente podría pensar el usuario en utilizar las rutinas estándares del

MSDOS, pero lamentablemente no es así ya que el MS DOS tiene unas rutinas para la
gestión del puerto serie de dudoso funcionamiento.
• No se pueden configurar siempre para que funcionen sin ningún tipo de

protocolo. Muchas veces se les indica 8 bits sin paridad, ni protocolo y
siguen requiriendo las lineas DTR, CTS y RTS.
• En la recepción de datos, si no se utiliza protocolo, el MS DOS tiende a

perder gran cantidad de caracteres. Esto es debido a que el sistema MS DOS
es lento y no dispone de ningún buffer de puerto serie.
Las rutinas aquí propuestas acceden directamente al hardware del PC, enviando
y leyendo datos directamente de los registros del hardware. Con ayuda de una
interrupción guarda los datos en buffer de tamaño definible. Otra de las ventajas de
-----------------------------------------------------------------------------------------------------------------------------
- 73 -
--------------------------------------------------------------------------------------------------------
nuestras rutinas es la posibilidad de trabajar a velocidades no estándares como por
ejemplo 115 Kbaudios.
Se ofrecen 7 funciones que permiten inicializar el puerto serie, desinicializarlo,

enviar y recibir un carácter o un bloque. Las funciones disponibles así como sus
parámetros las describimos a continuación.
void inicia_rs232c(com_nr,baudrate)
int com_nr;
long baudrate;
Esta función inicializa el puerto serie. Para ello debe pasarse en com_nr el
puerto que se desea utilizar, este puede ser 1 para COM1 y 2 para COM2. El segundo
parámetro, baudrate, indica la velocidad a la que debe ponerse el puerto serie, esta
velocidad debe estar comprendida entre 1L y 115200L baudios.
Es necesario advertir que no son posibles todas las velocidades comprendidas

entre estas dos, sino que deben obedecer a la siguiente formula:
115200
baudrate =
divisor
Donde divisor es un número entero entre 1 y 65535. Por tanto las frecuencias
altas posibles son: 115200, 57600, 38400, 28800, 23040, 19200, ... Estas frecuencias no
coinciden con las que pueden obtener los equipos ALTAIR equipados con un reloj de
12 MHz, por lo que la velocidad de comunicación máxima en principio es de 9600
baudios.
Si su aplicación requiere de grandes velocidades de transferencia, puede

cambiar el cristal de 12 MHz del ALTAIR por un cristal de 11.059 MHz con lo que
serán posibles: 57600, 28800, 19200, ... baudios. Con un cristal no estándard de 7.372
MHz o 22.118 MHz son posibles 115200 baudios. Con otros cristales se obtienen otras
velocidades. Esta también depende la CPU utilizada, dado que si disponen de
generadores de baudios dedicados (80c537, 80C320, ...) pueden obtenerse velocidades
no comunes al 8051.
En todo caso estas rutinas permiten comunicarse sin errores a dos PC

compatibles entre sí a cualquier velocidad soportada por el hardware estándard de serie
de un ordenador PC. Pueden servir de utilidad para comunicarse con controladores que
dispongan de una circuitería RS232 distinta a la de los equipos ALTAIR.
void termina_rs232c(void)
Esta función desinicializa el puerto serie, devolviendo el control del mismo al

MSDOS, dejando sus parámetros originales. Esta función que ni requiere parámetros ni
devuelve ningún valor debe ser llamada antes de volver al MSDOS si previamente se ha
inicializado el puerto serie.
-----------------------------------------------------------------------------------------------------------------------------
- 74 -
--------------------------------------------------------------------------------------------------------
También debe ser llamada antes de la segunda y siguientes inicializaciones del
puerto serie. De no hacerlo así, el sistema se colgará irremediablemente cuando el
programa salga al MSDOS y se cargue desde allí otra aplicación cualquiera.
void envia_rs232c(obyte)
unsigned char obyte:
Esta rutina envía un carácter por el puerto serie. El carácter a enviar debe ser
pasado en el parámetro obyte.
int recibe_rs232c(void)
Esta función espera a que haya un carácter disponible en el puerto serie y lo

lee. El carácter leído es devuelto como resultado de la función.
int estado_rs232c(void)
La función anterior detenía la ejecución del programa hasta que hubiese

disponible un carácter a leer, de forma que si nunca llegara un byte del exterior no se
saldría de la función jamás.
Para evitar que el programa se "cuelgue" leyendo un carácter ofrecemos esta

función que devuelve:
0 Para indicar que no hay ningún carácter en el buffer.

1 Para indicar que hay un carácter.
Por tanto esta función permite al programador llamar a recibe_rs232c

solamente cuando hay algún carácter recibido disponible en el buffer de recepción.
void envia_bloque(typ, source, len)

int typ;
unsigned char *source;
unsigned int len;
Esta rutina envía un bloque de datos de longitud len, apuntado por source
precedido de un byte de cabecera dado por typ y seguido por un carácter de
comprobación o checksum. Este carácter de comprobación es calculado
automáticamente por la rutina.
Esta función se puede utilizar para enviar directamente comandos al

microcontrolador. Debe tener presente que el microcontrolador devolverá como
contestación otro paquete de información.
int recibe_bloque(typ, dest, len)

int typ;
unsigned char *dest;
int len;
-----------------------------------------------------------------------------------------------------------------------------
- 75 -
--------------------------------------------------------------------------------------------------------
Esta función recibe un bloque de longitud len y lo guarda en la dirección
apuntada por dest. El bloque recibido debe tener el mismo formato que el bloque que
envía la rutina descrita anteriormente.
En esta función debe indicarse la cabecera o comando que debe recibirse. Si la

cabecera recibida no coincide con la dada en la función se producirá un error, del mismo
modo que se producirá un error sino coincide el byte de comprobación o checksum
recibido con el calculado.
Los posibles errores devueltos por esta función son:
0 El bloque ha sido recibido correctamente.
-1 Fuera de tiempo en la recepción de cabecera.

-2 La cabecera recibida no coincide con la solicitada.
-3 Fuera de tiempo en la recepción de datos.
-4 Fuera de tiempo en el byte de comprobación checksum.
-5 El byte de comprobación recibido es erróneo.
El tiempo de espera en la recepción de bloques puede ser definido por

TIMEOUT, que normalmente tiene el valor 10. Este valor puede incrementarse o
decrementarse a voluntad.
A continuación puede ver el listado fuente completo de las rutinas descritas,

que pueden ser compiladas directamente con el BORLAND C o el TURBO C.
/*****************************************************************************
*
* Rutinas para el manejo del puerto serie de un PC a cualquier velocidad
*
* Adaptadas por Ibercomp S.R.L. - Mayo de 1993
*
*****************************************************************************/
#include <stdio.h>
#include <ctype.h>
#include <string.h>
#include <stdlib.h>
#include <dos.h> /* getvect()... */
#define BIN_READ "rb"
#define VERSION "V1.00" /* Versión de este modulo */
typedef unsigned int uint; /* definicion de algunos tipos */

typedef unsigned char uchar;
/*********** RX por buffer **************************************************/

#define RX_BUF_SIZE 512 /* Tamaño del buffer en potencia de 2
*/
static uint ser_rinx=0; /* Indice de entrada RX-Serie */
static uint ser_routx=0; /* Indice de salida RX-Serie */
static uchar ser_rx_buf[RX_BUF_SIZE]; /* Tamaño del buffer de recepción RX
*/
/*****************************************************************************
*
* Manejador de puerto serie PC
*
* Información de los registros del PC-SIO ej eb: C t 5/88 p†g. 204
*
* Fecha : 10. 12. 1992
-----------------------------------------------------------------------------------------------------------------------------
- 76 -
--------------------------------------------------------------------------------------------------------
* Compilador : Borland C++ 3.1
*
* Recepción por interrupciones, escritura directa al SIO.
*
*****************************************************************************/
#define IRQ_CTRL 0x20 /* Controlador de interrupciones */

#define IRQ_MASKE 0x21 /* Puerto para la máscara de
interrupcione*/
#define SIO_EIN 0xE7 /* Bits del SIO en el controlador. */
#define EOI 0x20 /* Fin de interrupción */
#define COM1 0x3F8 /* Dirección a la base de COM1 */

#define COM2 0x2F8 /* Dirección a la base de COM2 */
/* Offsets relativos de los registros:
*/
#define IER 1 /* Registro de habilitación de
interrup.*/
#define IIR 2 /* Registro de identificación de
interrup.*/
#define LCR 3 /* Registro de control de linea */
#define MCR 4 /* Registro de control de MODEM */
#define LSR 5 /* Registro de estado de la linea */
#define MSR 6 /* Registro de estado del MODEM */
#define COM1_VEC 0xC /* Vector SIO1 */

#define COM2_VEC 0xB /* Vector SIO2 */
#define TIMER_VEC 0x1C /* Vector del temporizador*/
static int com=COM1; /* Dirección de la base */

static int com_vec=COM1_VEC; /* Dirección de la interrupción */
static uint no_sio_mask; /* Antigua máscara de interrupción */

static void interrupt (*o_com_vec)(); /* Antiguo vector del SIO */
static void interrupt (*o_timer_vec)(); /* Antiguo vector del temporizador */
#define TIMEOUT 10 /* Debe ser rápido */

static volatile int klick_cnt=-1; /* Contador de clicks */
int hw_test(void); /* Borland C: Prototipos */

int reset(void);
/*********** Interrupci¢n del temporizador *********************************/

static void interrupt timer(){ /* Contador del sistema */
if(klick_cnt>=0) klick_cnt--; /* Se decrementa 18 veces por segundo
*/
}
/*********** Interrupción de transferencia: Los datos de entrada son

buffereados **/
static void interrupt transfer(){
ser_rx_buf[ser_rinx++]=inportb(com);
ser_rinx &= (RX_BUF_SIZE-1); /* Buffer cíclico - anillo */
klick_cnt=TIMEOUT; /* Espera de 0.25 ms */
/* 32: señala buffer de transmisión
vacio */
if(inportb(com+LSR) & (2+4+8+16)){ /**** ¿ Hallado un error ? ****/
inportb(com);
inportb(com);
inportb(com);
inportb(com);
}
outportb(IRQ_CTRL,EOI); /* ¡Arranca interrupción! */
}
/******************* seriell_put_byte() *************************************/
void envia_rs232c(register uint obyte){
while(!(inportb(com+LSR) & 32)); /* Espera a que se envíe el byte
anterior*/
outportb(com,obyte); /* emitir caracter */
}
/******* Enviar *************************************************************/

void envia_bloque(int typ, uchar* source, uint len){
-----------------------------------------------------------------------------------------------------------------------------
- 77 -
--------------------------------------------------------------------------------------------------------
uchar tx_fcs=0; /* byte de comprobación checksum */
int i;
disable(); /* Antes de transmitir vaciar buffer

*/
ser_rinx=ser_routx;
enable();
for(i=0;i<4;i++) inportb(com); /* vaciar SIO */
while(!(inportb(com+LSR) & 32)); /* Espera que el byte antiguo se halla

env*/
outportb(com,typ); /* Envia un caracter */
while(len--){
while(!(inportb(com+LSR) & 32)); /* Espera que se halla enviado el byte
antiguo */
outportb(com,*source); /**** Envia un caracter ****/
tx_fcs += *source++; /* Incrementa el contador del checksum
*/
}
while(!(inportb(com+LSR) & 32)); /* Espera a que se halla enviado el
byte */
outportb(com,tx_fcs); /* Emite la suma */
}
/******* Leer
*********************************************************************/
/******** ¿Hay algo en le buffer?

*************************************************/
int estado_rs232c(void){
register uint delta;
disable();
delta=ser_rinx-ser_routx;
enable();
return delta?1:0; /* No hay nada = 0, Hay algo = 1*/
}
/********* Leer un byte

***********************************************************/
int recibe_rs232c(void){
uchar ibyte;
if(!estado_rs232c()){
klick_cnt=TIMEOUT;
do{
if(klick_cnt<0) return -1; /* -1 Timeout */
}while(!estado_rs232c()); /* Espera mientras no haya nada */
}
ibyte=ser_rx_buf[ser_routx++]; /* Recoge un caracter */
ser_routx &= (RX_BUF_SIZE-1); /* Calculado el modulo del buffer */
return ibyte; /* Devuelve caracter leido */
}
/******* recibe_bloque(): Rutina central de lectura

*******************************/
int recibe_bloque(int typ, uchar* dest, uint len){

uchar rx_fcs=0; /* pone checksum a cero */
register int inp;
/* Primero identifica la cabecera */

if((inp=recibe_rs232c())<0) return -1; /* -1: Timeout - Typ */
if(inp!=typ) return -2; /* -2: Typ - Error */
while(len--){
if((inp=recibe_rs232c())<0) return -3; /* -3: Timeout - en datos */
rx_fcs+=(uchar)inp; /* FCS incrementa checksum */
*dest++=(uchar)inp; /* guarda en posicion */
}
if((inp=recibe_rs232c())<0) return -4; /* -4: Timeout checksum */
if(rx_fcs!=(uchar)inp) return -5; /* -5: ERROR checksum */
return 0; /* Al final OK! */
-----------------------------------------------------------------------------------------------------------------------------
- 78 -
--------------------------------------------------------------------------------------------------------
}
/******* inicia_rs232c() Inicializa puerto serie: 1,2, Baudrate

*******************/
void inicia_rs232c(int com_nr,long baudrate){
uint divisor;
int i;
if(com_nr<1 || com_nr>2){
puts("\007*** Error: Número del puerto serie incorrecto");
exit(-1);
}
if(baudrate>115200L || baudrate<1L){
printf("\007*** Error: ¡No es posible seleccionar %ld
baudios!\n",baudrate);
exit(-1);
}
com=(com_nr-1)?COM2:COM1; /* Selecciona dirección base correcta

*/
com_vec=(com_nr-1)?COM2_VEC:COM1_VEC;
divisor=(uint)(115200L/baudrate);
no_sio_mask=inportb(IRQ_MASKE) | (~SIO_EIN); /* No dispone de SIO! */

outportb(IRQ_MASKE,no_sio_mask);
outportb(com+MCR,0); /* Borra registros */

outportb(com+MSR,0);
o_com_vec=getvect(com_vec); /* Obtiene vector antiguo */

setvect(com_vec,transfer); /* Pone vector nuevo */
o_timer_vec=getvect(TIMER_VEC);
setvect(TIMER_VEC,timer);
outportb(com+LCR,0x80); /* Habilita el bit del lach divisor */

outportb(com,divisor&255); /* Divisor Bajo */
outportb(com+1,divisor>>8); /* Divisor Alto */
outportb(com+LCR,3); /* 8 Bits, 1 Stopbit, sin paridad */
outportb(com+IER,1); /* Solo Irq de entrada*/

outportb(com+MCR,0xB); /* Activa IRQ, RTS=DTR=1 */
enable(); /* Interrupciones siempre activas */
for(i=0;i<20;i++) inportb(com); /* Limpia porquería */
outportb(IRQ_MASKE, no_sio_mask & SIO_EIN); /* Envia nueva máscara */
}
/******** Desinicializa el puerto serie

*******************************************/
void termina_rs232c(void){
setvect(com_vec,o_com_vec); /* Pone antiguo manejador */
setvect(TIMER_VEC,o_timer_vec); /* Pone antiguo temporizador */
outportb(IRQ_MASKE,no_sio_mask); /* Pone antigua máscara */
}
20 Realización de un cable de comunicaciones
Para poder comunicar un equipo ALTAIR con su ordenador PC es necesario

disponer de un cable RS232c de 3 hilos realizado correctamente. Los
microcontroladores ALTAIR disponen de un conector serie DB9 macho, por lo que al
menos uno de los dos extremos del cable deberá tener un conector DB9 hembra que
encaje en él.
En los gráficos mostrados en esta página el lado derecho corresponden al

microcontrolador.
-----------------------------------------------------------------------------------------------------------------------------
- 79 -
--------------------------------------------------------------------------------------------------------
El otro extremo debe haber un cable que encaje en su ordenador personal.
Existen dos posibilidades estándares, una de ellas que el PC disponga de un conector
serie DB9 macho idéntico al del ALTAIR en cuyo caso deberá tener en el otro extremo
del cable un conector DB9 hembra. Vea la figura superior.
La otra posibilidad es que el puerto serie que disponga su PC sea presentado en

un conector DB25 macho, en cuyo caso el extremo del cable que debe ir conectado al
PC debe ser un conector DB25. Observe la segunda figura.
Tanto en un caso como en otro se requieren 3 hilos. Uno de ellos es masa o 0

voltios. Los otros dos son las lineas de datos y deben conectarse de forma que el
transmisor de un equipo conecte con el receptor del otro.
El cable DB9 > DB9 debe ser simétrico, esto es, cualquier extremo debe
poderse conectar al PC o al ALTAIR indistintamente. Por el otro lado el cable DB9 >
DB25 tiene posiciones fijas, el lado DB9 al microcontrolador y el DB25 al PC.
DB9
RS232c 9 pines
Normalmente COM1
5 5
3 3
2 2
5: TIERRA
3: TxD
2: RxD
DB25
RS232c 25 pines
Normalmente COM2
1: TIERRA 5: TIERRA
7 7: TIERRA 3: TxD
2: TxD 2: RxD
3: RxD 5
3 3
2 2
1
21 Formato Intel HEX
Aunque se salga de contexto hemos decidido incluir en este manual el formato

de los ficheros INTEL HEXADECIMAL. Este formato es ampliamente utilizado por la
mayoría de compiladores, programadores y emuladores existentes en el mercado.
Es un formato poco óptimo en cuanto al espacio que ocupa, pero que tiene dos
ventajas frente a otros formatos:
-----------------------------------------------------------------------------------------------------------------------------
- 80 -
--------------------------------------------------------------------------------------------------------
• Debido a que dispone de un número de validación (CRC) es muy fácil saber

si el fichero está corrompido o no, por lo que se reduce el riesgo de por
ejemplo grabar 500 87C51 versión OTP con código no deseado. Riesgo que
si puede existir, aunque con poca probabilidad, con ficheros binarios.
• Se puede editar directamente con cualquier editor o procesador de textos,

con lo cual es posible realizar modificaciones o comprobaciones de última
hora.
Por tanto un fichero INTEL HEXADECIMAL se trata de un fichero ASCII

donde cada linea tiene el siguiente formato:
:BBDDDDCCXXXXXXXXXX ... XXSS
BB = Número de bytes de código que hay en la linea.
DDDD = Dirección donde deben ir los datos de la linea
CC = Es un código que de valer 00 indica que es una linea normal.

CC = Es un código que de valer 01 indica que es la última linea.
XX = Son los datos que contiene dicha linea. Cada dato se compone de dos
caracteres que representan un byte en hexadecimal.
SS = CRC es el checksum de la linea. El CRC se calcula fácilmente tomando

un valor inicial 0. A este valor se le resta en 8 bits sin acarreo cada uno de los bytes de
la linea, incluyendo BB DDDD CC y XXXX ... XX
Por ejemplo, a continuación metemos un fichero hexadecimal de tan solo dos

líneas:
Inicialmente se comienza por cero y se va restando cada byte.
:019049000026
:00000001FF
Este sencillo fichero se compone de dos lineas, analizando la primera tenemos:
BB = 01 Por tanto solo hay un byte en dicha linea

DDDD = 9049 Dicho byte deberá guardarse en la posición $9049
CC = 00 Dicha linea es normal
XX = 00 Luego el valor del byte a guardar en la posición $9049 es
$00.
SS = $26 Checksum de la linea $00-$01-$90-$49
La siguiente y última linea:
BB = 00 No hay datos en la linea
-----------------------------------------------------------------------------------------------------------------------------
- 81 -
--------------------------------------------------------------------------------------------------------
DDDD = 0000 Dirección puesta a cero (ignorada en cualquier caso por no
haber datos).
CC = 01 Indica que se trata de final de fichero
XX La linea carece de caracteres de este tipo
SS = FF checksum de la linea $00 - $01
-----------------------------------------------------------------------------------------------------------------------------
- 82 -

Asm 51

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Asm 51

Enviado por

Direitos autorais:

Formatos disponíveis

(C) 1994,99 Ibercomp S.A.

El uso de microcontroladores está muy extendido en todo el mundo y hoy en

Los equipos ALTAIR, tanto en su versión monoplaca como en su versión

Si bien es verdad que inicialmente no disponen de salida de monitor, ni de

El microcontrolador ALTAIR puede ser considerado como una pequeña caja

De este modo, el mismo montaje básico de microprocesador, memoria de

Las aplicaciones de los equipos ALTAIR en el mundo son tantas que no es

Las características principales del ALTAIR 535 son:

• 100% compatible con los microprocesadores de la familia 51.

En los cuatro años que llevamos fabricando microcontroladores, la familia

Se trata de un microcontrolador monoplaca basado en el 80C32 muy similar en

Los mismos microcontroladores anteriores en los que se ha sustituido la CPU

Un microcontrolador muy similar al ALTAIR 535, en el cual se sustituyo el

Se trata de un microcontrolador a la vez compacto y potente basado en el

En este manual no podemos describir con detalle cada uno de los

Un ordenador o microcontrolador, por si solo, no sirve para nada sino se

Una vez arrancado el programa el microcontrolador irá escrutando de una en

Por tanto un programa es el conjunto de instrucciones necesarias para que el

El programa debe ser cargado de algún modo previamente en la memoria del

3 ¿Qué incluye el KIT de desarrollo?

El KIT desarrollo ALTAIR v.3.00 incluye todas las herramientas necesarias

• Manual de instrucciones (el que está leyendo)

En el disquete usted hallará:

Antes de nada le recomendamos que saque una copia de seguridad del

Antes de proseguir lea del disquete suministrado el fichero de texto

4 Instalación del KIT de desarrollo en el disco duro

La instalación del KIT de desarrollo en el disco duro de su PC es bastante

INSTALAR [destino] <Return>

Si dispone en su equipo de un MS DOS versión 4.00 o superior podrá utilizar

XCOPY A:*.* C:\PROGS /s <Return>

Tecleando el comando anterior se instalará el KIT de desarrollo dentro del

Si no dispone de unidad de disco duro puede ejecutar y desarrollar aplicaciones

Para instalar el KIT de desarrollo lo único que requiere es de un ordenador 386

El programa corre correctamente sobre equipos dotados de sistema operativo

En algunos equipos, la tarjeta de red local ETHERNET coincide con

El KIT de desarrollo suministrado por nosotros conforma un entorno compacto

El Editor en si es muy parecido en concepto y modo de funcionamiento al

Al arrancar presentará en pantalla un menú de opciones en la parte superior así

El Editor está escrito íntegramente en lenguaje C++, para gestionar las

Para seleccionar una resolución de texto mayor consulte el manual de su tarjeta

Si en lugar de utilizar resoluciones de texto decide utilizar resoluciones

Ibercomp seguirá desarrollando y mejorando el KIT de desarrollo

• El sistema operativo WINDOWS no es profesional en el sentido que exige

• Los sistemas operativos gráficos son extremadamente lentos debido que

• El WINDOWS dispone de tipos de letras proporcionales, lo cual suele

• La agilidad que ofrece un sistema basado en texto después de unas cuantas

Nosotros en ningún momento nos decantamos por un sistema operativo u otro,

<ALT T> Menú Altair

Figura 2: Cuadro de diálogo con la información acerca. Observe que esta

<ALT A> Menú Archivo

Este menú dispone de 7 opciones que permiten cargar y grabar archivos de

Las opciones disponibles en el Menú de Archivo son:

Seleccionando esta opción aparece en pantalla un selector de ficheros,

Figura 3: Selector de ficheros en la opción de apertura de archivos.

Este selector de ficheros es casi idéntico a los utilizados en el editor EDIT.EXE

Esta opción guarda el texto contenido en la ventana superior en el archivo y

Allí podrá corroborar si desea guardar el contenido de la ventana como

Esta opción al igual que la anterior permite al usuario guardar en el disco el

Figura 4: Selector de ficheros en la opción guardar como. Observe el parecido

Si por el contrario se ha seleccionado un bloque se presentará en pantalla un

Figura 5: Cuadro de diálogo de la opción imprimir. Puede indicar si desea

Esta opción permite también imprimir el contenido del portapapeles (la

Esta opción permite al usuario salir momentáneamente al MS DOS para

XCOPY A:. C:\PROGS /s <Return>