Este documento presenta la estructura de un programa en lenguaje ensamblador, incluyendo la organización de las etiquetas, instrucciones, operandos y comentarios en cuatro columnas. También describe las herramientas de programación como editores de texto y compiladores, y resume brevemente la evolución de Windows a través de sus diferentes versiones desde 1985 hasta la actualidad.

1. Instituto de estudios superiores
metropolitano
Carrera: Ingeniería en Tecnología de Información
Solís Pérez Juan Carlos
Investigación: Lenguaje Ensamblador
Catedrático: Ing. Juan Reynoso Hernández
Colaborador:
Instalación Metropolitano Villa flores Chiapas

2. Introducción
El programa ensamblador es el programa que realiza la traducción de
un programa escrito en ensamblador a lenguaje máquina. Esta
traducción es directa e inmediata, ya que las instrucciones en
ensamblador no son más que nemotécnicos de las instrucciones
máquina que ejecuta directamente la CPU.

3. Marco teórico
Fundamentos del lenguaje ensamblador ------------------------------------------- 4
Microprocesador -------------------------------------------------------------------------- 5
Interrupciones ----------------------------------------------------------------------------- 8
Estructura de un programa en el lenguaje ensamblador-----------------------10
Entorno de programación --------------------------------------------------------------14
Evolución de Windows ------------------------------------------------------------------17
Conclusión ---------------------------------------------------------------------------------21
Bibliografía -------------------------------------------------------------------------------- 22

4. Los fundamentos del lenguaje ensamblador
Es un lenguaje de programación de bajo nivel para los computadores,
microprocesadores, microcontroladores y otros circuitos integrados
programables. Implementa una representación simbólica de los códigos de
máquina binarios y otras constantes necesarias para programar una arquitectura
dada de CPU y constituye la representación más directa del código máquina
específico para cada arquitectura legible por un programador. Esta
representación es usualmente definida por el fabricante de hardware, y está
basada en los mnemónicos que simbolizan los pasos de procesamiento (las
instrucciones), los registros del procesador, las posiciones de memoria y otras
características del lenguaje. Un lenguaje ensamblador es por lo tanto específico
de cierta arquitectura de computador física (o virtual). Esto está en contraste con
la mayoría de los lenguajes de programación de alto nivel, que idealmente son
portátiles.

5. Muchos sofisticados ensambladores ofrecen mecanismos adicionales para
facilitar el desarrollo del programa, controlar el proceso de ensamblaje, y la
ayuda de depuración. Particularmente, la mayoría de los ensambladores
modernos incluyen una facilidad de macro, y se llaman macro ensambladores.
Microprocesador
La Unidad Central de Proceso (CPU, por sus siglas en inglés) tiene 14 registros
internos cada uno de 16 bits. Los primeros cuatro, AX, BX, CX y DX, son de
uso general y se pueden usar también como registros de 8 bits. Es decir, AX se
puede dividir en AH y AL (AH es el byte alto, high, y AL es el byte bajo, low) Lo
mismo es aplicable a los otros tres (BX en BH y BL, CX en CH y CL y DX en DH
y DL)

6. Estos son los únicos registros que pueden usarse de modo dual (en 8 o 16
bits)
Los registros de la CPU son conocidos por sus nombres propios, que son:
·· AX (acumulador)
·· BX (registro base)
·· CX (registro contador)
·· DX (registro de datos)
·· DS (registro del segmento de datos)
·· ES (registro del segmento extra)
·· SS (registro del segmento de pila)
·· CS (registro del segmento de código)
·· BP (registro de apuntadores base)
·· SI (registro índice fuente)
·· DI (registro índice destino)
·· SP (registro del apuntador de pila)
·· IP (registro del apuntador de siguiente instrucción)
·· F (registro de banderas)

7. Cada instrucción en lenguaje ensamblador del 8088 está compuesta de 4
campos:
etiqueta operación operando comentario
El campo comentario se utiliza para propósitos de documentación y es opcional.
Campo etiqueta: Una etiqueta debe comenzar con un carácter alfabético y puede contener
hasta 31 caracteres, incluyendo:
·· Letras de la A a la Z
·· Números del 0 al 9
·· Los símbolos especiales: - $ . @ %
No se puede utilizar un nombre que coincida con una palabra reservada o directiva del
ensamblador. Si el nombre incluye un punto, entonces el punto debe ser el primer carácter.
Campo operación: Contiene el nemotécnico de la instrucción, que es de 2 a 6 caracteres.
Campo operando: Contiene la posición o posiciones donde están los datos que van a ser
manipulados por la instrucción.
Campo comentario: Se utiliza para documentar el código fuente del ensamblador. Debe
separarse del último campo por al menos un espacio e iniciar con ;.
Cuando inicia un comentario en una línea ésta deberá tener en la primera
columna el carácter ;.

8. Interrupciones
El manejo de interrupciones es una técnica de programación, basada en un
mecanismo automático en el hardware del microcontrolador, que permite dar
atención a algún dispositivo ó circuito interno o externo, únicamente en el
momento en que ésta se requiera. Una interrupción es en realidad una
llamada a una subrutina, pero iniciada por el hardware del propio periférico y
no por la instrucción "CALL". La interrupción es asíncrona y puede ocurrir en
cualquier instante durante la ejecución del programa principal.

9. BOLT-INTERRUPCIONES-
18F2550-2.ASM
EJEMPLO DE
INTERRUPCIONES TIMER 0
BOLT-INTERRUPCIONES-
18F2550-2.HEX
KEYBOLT.inc ARCHIVO AUXILIAR
El sistema Bolt 18F2550 utiliza los primeros 2K de su memoria de código para almacenar su programa
Bootloader. En este programa, hay un vector para redireccionar la interrupción a la dirección 0x808, de
tal forma que el usuario tenga espacio de memoria suficiente para programar sus subrutinas de
atención de interrupciones. En seguida se muestran un ejemplo del manejo de las interrupciones en el
sistema Bolt, utilizando la interrupción del temporizador 0.
En el ejemplo se combinan 2 tareas: en la tarea 1, el procesador enciende y apaga el led RB7 con un
período de 1 segundo. Esta tarea está realizada por medio de la interrupción del TIMER 0. En la tarea 2,
que está a cargo del programa principal, el microcontrolador realiza una cuenta binaria en los bits
RB0...RB3. El período de la cuenta en este caso es de 200 ms.
NO OLVIDE GUARDAR EN MEMORIA EL REGISTRO W Y EL REGISTRO STATUS AL ENTRAR A LA
SUBRUTINA DE INTERRUPCIÓN

10. Estructura de un programa en el lenguaje ensamblador
Para hacer la tarea del programador más grata, se usan algunas convenciones. Cada uno puede adoptar las que más le
agraden y ayuden para ser más productivo. En general, las convenciones son cualquier acción que facilita la revisión y
comprensión de un programa, especialmente el que uno mismo ha escrito cuando tiene que revisarlo algunos meses
después.
Comentamos algunas convenciones que usaremos:
Los ficheros de código fuente llevarán la extensión *.ASM
Los ficheros de listado llevarán la extensión *.LST
Los ficheros de código objeto llevarán la extensión *.OB]
Los ficheros de errores llevarán la extensión *.ERR
Los ficheros ejecutables en formato Intel Hex llevarán la extensión *.HEX
Comentario descriptivo del programa (utilizar una cabecera estandarizada).
Definir el microcontrolador que se usará (con las directivas LIST e INCLUDE).
Introducir las opciones de compilación (que serán vistas más adelante) (opcional).
Establecer las constantes que se usarán (con la directiva EQU).
Reservar espacios de memoria (directiva RES) (si es necesario).
Configurar los puertos.
Desarrollar el programa con comentarios, en lo posible explicando cada línea de código..
Los mnemónicos escritos en minúscula y las constantes y variables en mayúscula hacen que el código escrito sea más
visible.
Colocar las rutinas en el mismo sitio, todas contiguas.
Dibujar diagramas de flujo o escribir seudocódigo.

12. Hemos visto la estructura general. Ahora veremos la posición de los elementos del código
por 4 columnas:

13. Columna 1: Etiquetas. Las etiquetas se rigen por las siguientes normas:
Debe situarse en la primera columna.
Debe contener únicamente caracteres alfanuméricos.
El máximo de caracteres es de 31.
Columna 2: Operación. En esta columna se situarán las instrucciones. El campo del código de
operación es el único que nunca puede estar vacío; éste siempre contiene una instrucción o
una directiva del ensamblador.
Columna 3: Operandos El campo de operandos o de dirección puede contener una dirección o
un dato, o puede estar en blanco. Normanmente contendrá registros o literales con los que se
operará (f, l o k , b y w).
Columna 4: Comentario. El campo del comentario o de etiquetas es opcional. Aquí se situará
cualquier comentario personalizado que deseemos. Estos son útiles para saber qué hace un
programa sin tener que descifrar el código entero. El compilador (ensamblador) ignorará todo
texto más allá del carácter punto y coma ";".

14. Entorno de programación
Las herramientas imprescindibles para comenzar a programar son las
siguientes:
Editor de texto - Se puede utilizar una variedad de editores de texto. Entre los
más comunes están GNU Emacs, vi que es un editor muy básico y KWrite.
gcc - El compilador gcc debe estar instalado.
El compilador gcc
El proceso de traducción de un programa escrito en un lenguaje de alto nivel a
un archivo objeto ejecutable consta de varias etapas. A continuación se
describen las etapas correspondientes al conjunto de herramientas de
compilación gcc que permite traducir programas escritos en el lenguaje de
programación C.

15. Para ejecutar el programa se escribe:
linux> ./ejemplo
Lo cual producirá como salida:
programa de ejemplo
linux>
Opciones
El compilador gcc se puede ejecutar con varias opciones. Cabe destacar que
Linux diferencia entre mayúsculas y minúsculas por lo cual un comando (u
opción) en mayúscula será diferente a un comando (u opción) con el mismo
nombre en minúscula. Entre las opciones más importantes tenemos:
o
indica el nombre del archivo de salida, cuando no se usa, el
compilador genera un archivo llamado a.out por defecto
-S
no ensambla, la salida es un archivo en lenguaje
ensamblador con el sufijo .s
-c
no enlaza, la salida será un archivo en código objeto con el
sufijo .o su contenido se encuentra en binario. Se puede
utilizar la herramienta objdump para desensamblar este
archivo y visualizar su contenido
-O
opción de optimización, se acompaña con un número que
indica el nivel de optimización deseado. Se puede escoger
entre O0, O1, O2 u O3
-g produce información para la depuración del programa

16. Usando el programa ejemplo anterior, el comando:
linux> gcc -O2 -S -o ejemplo.s ejemplo.c
Produce como salida el programa en lenguaje ensamblador:
file "ejemplo.c"
.section .rodata.str1.1,"aMS",@progbits,1
.LC0:
.string "programa de ejemplo"
.text
.p2align 2,,3
.globl main
.type main,@function
main:
pushl %ebp
movl %esp, %ebp
subl $8, %esp
andl $-16, %esp
subl $12, %esp
pushl $.LC0
call puts
xorl %eax, %eax
leave
ret
.Lfe1:
.size main,.Lfe1-main
.ident "GCC: (GNU) 3.2.2
20030222 (Red Hat Linux 3.2.2-
5)"

17. Evolución de Windows
Windows y su evolución a través de los años.
Microsoft presentó Windows 8, la última versión del un sistema operativo que
nació en 1985 y revolucionó el mundo

18. Windows es uno de los sistemas operativos más usados. Su compatibilidad y
apertura hacia casi todos los procesadores ha ayudado al programa creado por
Microsoft a posicionarse del mercado de las computadoras de escritorio y
laptops. Ahora, con Windows 8, la empresa californiana busca hacerse fuerte en
los dispositivos móviles como las Tablet.

19. WINDOWS 1.0 (1985). Con este empezó todo. Fue el primer sistema operativo de 16 bits
de Microsoft y corría con DOS.
WINDOWS 1.02 (1986). La versión “internacional” del primer Windows no tuvo mucha
acogida.
WINDOWS 2.0 (1987). Esta versión perdió terreno en comparación con el sistema
operativo de interfase gráfica de Mac.
WINDOWS 3.0 (1990). El primero de los sistemas operativos de Windows que se
popularizó. Sus versiones posteriores hicieron énfasis en aprovechar los elementos
multimedia y en arreglar errores de programación.

20. WINDOWS 95 (1995). El siguiente paso en la evolución fue un paso a la modernidad en
32 bits. Integró la primera barra de “Inicio” y la posibilidad de agregar widgets al escritorio
WINDOWS 98 (1998). La popularidad de Windows creció más gracias a esta versión. Su
Segunda Edición arregló muchos errores.
WINDOWS 2000 (2000). El primer sistema operativo que dejó de estar basado en
programación DOS y migró al sistema NT. Ese sería el estándar.
WINDOWS XP (2001). Mucho más estable, fácil de usar y popular que sus antecesoras.
Fue en su momento el sistema más vendido.
WINDOWS VISTA (2006). Nadie lo recibió bien: pese a que era gráficamente bueno,
consumía muchos recursos del sistema.
WINDOWS 7 (2009). Este sistema operativo redimió a Microsoft y se convirtió en el de
venta más rápida en la historia.
WINDOWS 8 (2012). El cambio más dramático hasta ahora, eliminó la famosa barra de
inicio y empezó a trabajar con un mosaico de iconos.

21. Conclusión
Un programa en ensamblador está compuesto por líneas, conteniendo cada
una de ellas un comentario, una única instrucción o una directiva.
En lo que sigue se utilizan los símbolos <> para encerrar un identificador o un
número que el programador debe escribir; los símbolos [] encierran
elementos opcionales; los símbolos {} encierran elementos que se puede
escribir consecutivamente varias veces; el carácter | separa elementos
opcionales.
Los programas hechos por un programador experto en lenguaje ensamblador
son generalmente mucho más rápidos y consumen menos recursos del
sistema (memoria RAM y ROM) que el programa equivalente compilado
desde un lenguaje de alto nivel. Al programar cuidadosamente en lenguaje
ensamblador se pueden crear programas que se ejecutan más rápidamente y
ocupan menos espacio que con lenguajes de alto nivel.

22. Bibliografía
http://www.z80.de/z80/z80code.htm
http://atc2.aut.uah.es/personal_archivos/ACastejon.html
http://www.monografias.com/trabajos76/estructura-programa-
ensamblador/estructura-programa-ensamblador.shtml#ixzz3jqjf9MUt
http:// el comercio.pe/tecnología/Windows-a-través-de-los-años
http://www.monografias.com/trabajos76/estructura-programa-
ensamblador/estructura-programa-ensamblador2.shtml#ixzz3jqkBoqP9