Universidad Autónoma de Nuevo León

Facultad de Ingeniería Mecánica y Eléctrica

Microcontroladores
Tarea #1:
Lenguaje Ensamblador

Nombre: Matrícula: Carrera:

Cristian Manuel Monreal Guzmán 1794853 IMTC

Instructor: Alejandro Torres Ramírez

Hora clase: Martes N4
Ciclo Escolar: Enero-Junio 2022

C.d Universitaria, San Nicolás de los Garza, Nuevo León.

31/01/2021
 LENGUAJE ENSAMBLADOR

El lenguaje ensamblador y sus características

El lenguaje ensamblador lo podemos definir como un lenguaje de programación,

como todo lenguaje de programación, esta acompañado de un software que permite
convertir de este lenguaje a código máquina. Pero, mas que un lenguaje de
programación, es una colección de nemotécnicos que permiten escribir código de
una manera mas legible por el ser humano. Además, a diferencia del código
maquina que solo permite el binario, el ensamblador permite escribir números en
decimal, hexadecimal, octal y por supuesto binario.

Características de las instrucciones del lenguaje ensamblador:

• Cada instrucción realiza una única y sencilla función.

• Emplean un número fijo de operandos, con una representación determinada y
concreta.
• La codificación de las instrucciones es muy sistemática y rígida.
• Las instrucciones son autocontenidas e independientes, es decir, cada
instrucción es independiente de la anterior y de la siguiente.

Dado que las instrucciones de maquina son autocontenidas, y que deben

encadenarse para formar programas, la información que ha de contener es:

• Operación a realizar (suma, producto, transferencia, etc.)

• Identificación de los operandos sobre los que debe realizarse la operación.
• Destino del resultado; la identificación del lugar donde debe almacenarse.
• Ubicación de la siguiente instrucción, normalmente este valor se auto calcula a
partir de la propia instrucción.

Programa Ensamblador

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 maquina que ejecuta directamente la CPU.

En lo que sigue se utilizan los símbolos <> para encerrar un identificador o un

numero 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.
• Numero de pasos
Hay dos tipos de ensambladores basados en cuantos pasos a través de la fuente
son necesarios para producir el programa ejecutable.
Ensambladores de un paso:
Los ensambladores de un paso pasan a través del código fuente una vez y asumen
que todos los símbolos serán definidos antes de cualquier instrucción que los
refiera.

Ensambladores de dos pasos:

Crean una tabla con todos los símbolos y sus valores en el primer paso, después
usan la tabla en un segundo paso para generar código. El ensamblador debe por lo
menos poder determinar la longitud de cada instrucción en el primer paso para que
puedan ser calculadas las direcciones de los símbolos.

• Ensambladores de alto nivel

Los ensambladores de alto nivel típicamente proporcionan todas las instrucciones

de máquina de bajo nivel de los ensambladores normales, mas sentencias como IF,
WHILE, REPEAT y FOR, en su lenguaje básico. Esto permite a los programadores
de lenguaje ensamblador, usar abstracciones de sentencias de control de alto nive,
dondequiera que una máxima velocidad o mínimo espacio no sea absolutamente
requerido, y descender a código maquina de bajo nivel cuando sea deseable código
rápido y/o corto.

• Uso del termino

En el uso profesional, el termino ensamblador es frecuentemente usado tanto para

referirse al lenguaje ensamblador como también al programa ensamblador
(convierte el código fuente escrito en el lenguaje ensamblador a código objeto que
luego será enlazado para producir lenguaje de maquina). Las dos expresiones
utilizan el término “ensamblador”.

Lenguaje

El lenguaje ensamblador refleja directamente la arquitectura y

las instrucciones en lenguaje de máquina de la CPU, y pueden ser muy diferentes
de una arquitectura de CPU a otra.
Cada arquitectura de microprocesador tiene su propio lenguaje de máquina, y en
consecuencia su propio lenguaje ensamblador ya que este se encuentra muy ligado
a la estructura del hardware para el cual se programa. Los microprocesadores
difieren en el tipo y número de operaciones que soportan; también pueden tener
diferente cantidad de registros, y distinta representación de los tipos de datos en
memoria. Aunque la mayoría de los microprocesadores son capaces de cumplir
esencialmente las mismas funciones, la forma en que lo hacen difiere y los
respectivos lenguajes ensamblador reflejan tal diferencia.

• Instrucciones de CPU

La mayoría de las CPU tienen más o menos los mismos grupos de instrucciones,
aunque no necesariamente tienen todas las instrucciones de cada grupo. Las
operaciones que se pueden realizar varían de una CPU a otra. Una CPU particular
puede tener instrucciones que no tenga otro y viceversa.

Los primeros microprocesadores de 8 bits no tenían operaciones para multiplicar o

dividir números, por ejemplo, y había que hacer subrutinas para realizar esas
operaciones. Otras CPU puede que no tengan operaciones de punto flotante y
habría que hacer o conseguir bibliotecas que realicen esas operaciones.

Las instrucciones de la CPU pueden agruparse, de acuerdo a su funcionalidad, en:

• Operaciones con enteros
• Operaciones de mover datos
• Operaciones para el control del flujo del programa
• Operaciones con números reales

• Ensamblado

La transformación del lenguaje ensamblador en código máquina la realiza un

programa ensamblador, y la traducción inversa la puede efectuar
un desensamblador. A diferencia de los lenguajes de alto nivel, aquí hay
usualmente una correspondencia 1 a 1 entre las instrucciones simples del
ensamblador y el lenguaje de máquina. Sin embargo, en algunos casos, un
ensamblador puede proveer "pseudo instrucciones" que se expanden en un código
de máquina más extenso a fin de proveer la funcionalidad necesaria y simplificar la
programación. Por ejemplo, para un código máquina condicional como "si X mayor
o igual que", un ensamblador puede utilizar una pseudoinstrucción al grupo "haga
si menor que", y "si = 0" sobre el resultado de la condición anterior. Los
Ensambladores más completos también proveen un rico lenguaje de macros que se
utiliza para generar código más complejo y secuencias de datos.
 • Ejemplos

Un programa escrito en lenguaje ensamblador consiste en una serie de

instrucciones que corresponden al flujo de órdenes ejecutables por un
microprocesador. Por ejemplo, en el lenguaje ensamblador para un procesador x86:

La sentencia:
1. “MOV AL, 61h”
Asigna el valor hexadecimal 61(97 decimal) al registro “AL”
El programa ensamblador lee la sentencia de arriba y produce su equivalente binario
en lenguaje de maquina
2. Binari: 10110000 01100001 (hexadecimal: B061)
En el segundo byte se especifica el numero 61h, escrito en binario como 01100001,
que se asignara al registro AL, quedando la sentencia ejecutable como:
3. 10110000 01100001

Diseño del lenguaje

• Elementos Básicos

Hay un grado grande de diversidad en la manera en que los autores de los

ensambladores categorizan las sentencias y en la nomenclatura que usan. En
particular, algunos describen cualquier cosa como pseudo-operación, con
excepción del mnemónico de máquina o del mnemónico extendido.

Un típico lenguaje ensamblador consiste en 3 tipos de sentencias de instrucción que

son usadas para definir las operaciones del programa:
• Mnemónicos de opcode
• Secciones de datos
• Directivas de ensamblador

• Secciones de datos

Hay instrucciones usadas para definir elementos de datos para manejar datos y
variables. Definen el tipo de dato, la longitud y la alineación de los datos. Estas
instrucciones también pueden definir si los datos están disponibles para programas
exteriores (programas ensamblados separadamente) o solamente para el programa
en el cual la sección de datos está definida. Algunos ensambladores clasifican esta
instrucción como pseudo-instrucciones.
• Directivas del ensamblador

Las directivas de ensamblador son instrucciones que le dicen al ensamblador que

haga algo. Se utiliza para configurar el programa o registrar la dirección durante el
montaje. Por ejemplo, ORG 0100h le dice al ensamblador que ensamble todo el
código subsiguiente comenzando en la dirección 0100h. DS. Define una cantidad
de espacio libre.

Los ensambladores simbólicos le permiten a los programadores asociar nombres

arbitrarios (etiquetas o símbolos) a posiciones de memoria. Usualmente, cada
constante y variable tiene un nombre para que las instrucciones puedan referir a
esas ubicaciones por nombre, así promoviendo el código autodocumentado. En el
código ejecutable, el nombre de cada subprograma es asociado a su punto de
entrada, así que cualquier llamada a un subprograma puede usar su nombre. Dentro
de subprogramas, a los destinos GOTO se le dan etiquetas. Algunos
ensambladores soportan símbolos locales que son léxicamente distintos de los
símbolos normales (ejemplo, el uso de "10$" como un destino GOTO).

• Macros

Los macro ensambladores a menudo permiten a las macros tomar parámetros.

Algunos ensambladores incluyen lenguajes macro sofisticados, incorporando
elementos de lenguajes de alto nivel tales como parámetros opcionales, variables
simbólicas, condiciones, manipulaciones de strings, operaciones aritméticas, todos
usables durante la ejecución de una macro dada, y permitiendo a las macros
guardar el contexto o intercambiar información. Así una macro puede generar un
gran número de instrucciones o definiciones de datos en lenguaje ensamblador,
basadas en los argumentos de la macro. Esto se podría usar para generar, por
ejemplo, estructuras de datos de estilo de récord o bucles "desenrollados", o podría
generar algoritmos enteros basados en parámetros complejos. Una organización,
usando lenguaje ensamblador, que ha sido fuertemente extendido usando tal suite
de macros, puede ser considerada que se está trabajando en un lenguaje de alto
nivel, puesto que tales programadores no están trabajando con los elementos
conceptuales de más bajo nivel del computador.

Las macros se usaron para personalizar sistemas de software de gran escala para
clientes específicos en la era del mainframe. También se emplearon macros por los
usuarios mismos para satisfacer las necesidades de sus organizaciones haciendo
versiones específicas de los sistemas operativos del fabricante. Esto fue hecho, por
ejemplo, por los programadores de sistema que trabajaban con el Conversational
Monitor System / Virtual Machine (CMS/VM) de IBM y con los complementos real
time transaction processing de IBM, CICS, Customer Information Control System,
el airline/financial system que comenzó en los años 1970 y todavía corre con
muchos sistemas de reservaciones computarizados (CRS) y sistemas de tarjeta de
crédito de hoy.

• Soporte para programación estructurada

Algunos ensambladores han incorporado elementos de programación

estructurada para codificar el flujo de la ejecución. El ejemplo más temprano de este
acercamiento estaba en el Concept-14 macro set, originalmente propuesto por el
Dr. H.D. Mills (marzo de 1970), e implementado por Marvin Kessler en la Federal
Systems Division de IBM, que extendió el macro ensamblador del S/360 con
bloques de control de flujo IF/ELSE/ENDIF y similares. Esto era una manera de
reducir o eliminar el uso de operaciones GOTO en el código en lenguaje
ensamblador, uno de los principales factores que causaban código espagueti en el
lenguaje ensamblador. Este acercamiento fue ampliamente aceptado a principios
de los años 1980 (los últimos días del uso de lenguaje ensamblador en gran escala).

Uso del lenguaje ensamblador

• Perspectiva Histórica

En los años 40 se intentó concebir un lenguaje más simbólico que permitiera no

tener que programar utilizando código máquina. Poco más tarde se ideó el lenguaje
ensamblador, que es la traducción del código máquina a una forma más textual.
Cada tipo de instrucción se asocia a una palabra mnemotécnica (como SUM para
sumar, por ejemplo), de forma que cada palabra tiene traducción directa en el
código máquina.

Tras escribir el programa en código ensamblador, un programa (llamado también

ensamblador) se encargará de traducir el código ensamblador a código máquina.
Esta traducción es rápida puesto que cada línea en ensamblador tiene equivalente
directo en código máquina (en los lenguajes modernos no ocurre esto).

La idea es la siguiente: si en el código máquina, el número binario 0000 significa

sumar, y el número 0001 significa restar. Una instrucción máquina que sumara el
número 8 (00001000 en binario) al número 16 (00010000 en binario) sería:
0000 00001000 00010000
Realmente no habría espacios en blanco, el ordenador entendería que los primeros
cuatro BITS representan la instrucción y los 8 siguientes el primer número y los ocho
siguientes el segundo número (suponiendo que los números ocupan 8 bits).
Lógicamente trabajar de esta forma es muy complicado. Por eso se podría utilizar
la siguiente traducción en ensamblador:
SUM 8 16

• Uso actual

El uso más común sin duda es la programación de microcontroladores, para diseñar

sistemas embebidos, el cual es un circuito integrado programable, capaz de ejecutar
las órdenes grabadas en su memoria. Está compuesto de varios bloques
funcionales, los cuales cumplen una tarea específica. Un microcontrolador incluye
en su interior las tres principales unidades funcionales de una computadora: unidad
central de procesamiento, memoria y periféricos de entrada/salida. En el hogar
pueden existir en los electrodomésticos entre una y dos docenas de
microcontroladores. Pueden encontrarse en casi cualquier dispositivo eléctrico
como lavadoras, horno de microondas, teléfonos, etc.
Es requerido un ejecutable binario independiente (stand-alone), es decir uno que
deba ejecutarse sin recursos a componentes de tiempo de ejecución o a bibliotecas
asociadas con un lenguaje de alto nivel; ésta es quizás la situación más común. Son
programas empotrados que solo almacenan una pequeña cantidad de memoria y el
dispositivo está dirigido para hacer tareas para un simple propósito.

• Aplicaciones Típicas

El lenguaje ensamblador hard-coded es típicamente usado en el ROM de

arranque del sistema (BIOS en los sistemas compatible IBM PC). Este código de
bajo nivel es usado, entre otras cosas, para inicializar y probar el hardware del
sistema antes de cargar el sistema operativo, y está almacenado en el ROM. Una
vez que ha tomado lugar un cierto nivel de inicialización del hardware, la ejecución
se transfiere a otro código, típicamente escrito en lenguajes de alto nivel; pero el
código corriendo inmediatamente después de que es aplicada la energía
usualmente está escrito en lenguaje ensamblador. Lo mismo es cierto para los boot
loaders.

El lenguaje ensamblador también es valioso en ingeniería inversa, puesto que muchos

programas solamente son distribuidos en una forma de código de máquina. El
código de máquina es usualmente fácil de trasladar hacia lenguaje ensamblador
para luego ser cuidadosamente examinado en esta forma, pero es muy difícil de
trasladar hacia un lenguaje de alto nivel. Herramientas como Interactive Disassembler,
hacen uso extenso del desensamblador para tales propósitos.

Detalles Adicionales del lenguaje ensamblador

los lenguajes ensambladores a veces pueden ser portables a través de diferentes

sistemas operativos en el mismo tipo de CPU. Las convenciones de llamadas entre
los sistemas operativos con frecuencia difieren ligeramente o en nada. y con
cuidado es posible ganar portabilidad en el lenguaje ensamblador, usualmente al
enlazar con una biblioteca de lenguaje C que no cambia entre sistemas operativos.
Un simulador de conjunto de instrucciones (que idealmente sería escrito en lenguaje
ensamblador) puede, en teoría, procesar el código
objeto/binario de cualquier ensamblador) para lograr la portabilidad incluso a través
de plataformas (con una sobrecargue no mayor que la de un interpretador
de bytecode típico). Esto es esencialmente lo que logra el microcódigo cuando una
plataforma de hardware cambia internamente.

Algunos lenguajes de muy alto nivel, como C y Borland/Pascal, soportan

ensamblado en línea, donde relativamente secciones cortas de código en
ensamblador puede ser empotradas dentro del código del lenguaje de alto nivel. El
lenguaje Forth comúnmente contiene un ensamblador usado para codificar
palabras.

Ejemplos del lenguaje ensamblador

• Ejemplo para la arquitectura x86

El siguiente es un ejemplo del programa clásico Hola mundo escrito para la
arquitectura de procesador x86 (bajo el sistema operativo DOS).

; Programa que imprime un string en la pantalla

; ---------------------------------------------
.model small ; modelo de memoria

.stack ; segmento del stack

.data ; segmento de datos

Cadena1 DB 'Hola Mundo. ; string a imprimir (finalizado en $)

.code ; segmento del código

; ---------------------------------------------
; Inicio del programa
; ---------------------------------------------
 programa:
; -------------------------------------------------------------------
; inicia el segmento de datos
; --------------------------------------------------------------------
MOV AX, @data ; carga en AX la dirección del segmento datos
MOV DS, AX ; mueve la dirección al registro de segmento
por medio de AX

; -------------------------------------------------------------------
; Imprime un string en pantalla
; --------------------------------------------------------------------
MOV DX, offset Cadena1 ; mueve a DX la dirección del string a imprimir
MOV AH, 9 ; AH = código para indicar al MS DOS que
imprima en la pantalla, el string en DS:DX
INT 21h ; llamada al MS DOS para ejecutar la función
(en este caso especificada en AH)
; --------------------------------------------------------------------
; Finaliza el programa
; --------------------------------------------------------------------
INT 20h ; llamada al MS DOS para finalizar el programa

end programa

• Ejemplo para el intel 8051

ORG 8030H
include
T05SEG:
SETB TR0
JNB uSEG,T05SEG ;esta subrutina es utilizada
CLR TR0 ;para realizar una cuenta de
CPL uSEG ;0,5 segundos mediante la
MOV R1,DPL ;interrupción del timer 0.
INVOKE
MOV R2,DPH
CJNE R2,#07H,T05SEG
CJNE R1,#78H,T05SEG
MOV DPTR,#0
RET

• Ejemplo para el Microchip PIC16F84

ORG 0
Inicio
bcf STATUS,RP0
clrf PORTB
movlw 0xFF
movwf PORTA
 bsf STATUS,RP0
Principal
movf PORTA,W
movwf Contador
movf Contador,F
btfsc STATUS,Z
goto PuntoDecimal
sublw d'9'
btfss STATUS,C
END

CONCLUSIONES

Con lo hecho en este trabajo, podemos ver la importancia del lenguaje ensamblador
y sus principales aportaciones a los lenguajes de programación, además de algunos
de sus usos durante la historia y en la actualidad. Podemos decir que el lenguaje
ensamblador es de gran importancia debido a que constituye la representación más
directa del código maquina especifico para cada arquitectura de microprocesador,
además al tratarse de un lenguaje de programación de bajo nivel, representa
instrucciones básicas para las computadoras, microprocesadores,
microcontroladores y otros circuitos integrados programables.

Del lenguaje ensamblador podemos destacar su importante velocidad, debido a que

trabaja directamente con el microprocesador al ejecutar un programa, pues al
tratarse de un lenguaje mas cercano a la máquina, la computadora lo procesa de
forma más rápida; también su eficiencia de tamaño al no ocupar mucho espacio en
memoria porque no tiene que cargar librerías y demás como los lenguajes de alto
nivel.
 BIBLIOGRAFÍA

Abel, P. (1996). Lenguaje ensamblador y programación para IBM PC y compatibles.

Pearson Educación.

Principios de arquitectura de computadoras - Miles J. Murdocca - Vincent P. Heuring

Godfrey, J. T. (1991). Lenguaje ensamblador para microcomputadoras IBM: para

principiantes y avanzados

Universidad Europea. Lenguaje Ensamblador. Laureate, International Universities.

https://www.cartagena99.com/recursos/alumnos/apuntes/INF_EST_COM_U2_R1_
T_PDF.pdf