Facultad de Ciencias Informáticas

CARRERA DE INGENIERÍA EN SISTEMAS

ORGANIZACIÓN Y ARQUITECTURAS DE
COMPUTADORAS.
QUINTO NIVEL “A”

DOCENTE:
ING. VIVIANA KATIUSKA GARCIA MACIAS

TEMA:

EJERCICIOS CON LENGUAJES ESAMBLADOR

INTEGRANTE:

 Gutiérrez Baque Pablo Andrés

 Mera Rivera Jhon Jonathan

FECHA:

2/02/2018
Contenido

1. INTRODUCCIÓN ..................................................................................................................... 3
2. MARCO TEÓRICO. .................................................................................................................. 4
Lenguaje ensamblador .................................................................................................................. 4
Definición. ................................................................................................................................. 4
Características ........................................................................................................................... 4
Programa ensamblador ............................................................................................................. 5
El código fuente......................................................................................................................... 5
Campo de etiquetas. ............................................................................................................. 5
Campo de código................................................................................................................... 5
Campo de operandos y datos................................................................................................ 5
Campo de comentarios. ........................................................................................................ 5
Campo de código....................................................................................................................... 6
Instrucciones: ............................................................................................................................ 6
Directivas: .................................................................................................................................. 6
Macros:...................................................................................................................................... 6
Formato de una sentencia en ensamblador ................................................................................. 6
Etiqueta: .................................................................................................................................... 6
Mnemónico: .............................................................................................................................. 6
Operandos: ................................................................................................................................ 6
Comentarios: ............................................................................................................................. 6
EJERCICIOS..................................................................................................................................... 7
3. CONCLUSIONES ................................................................................................................... 16
Bibliografía .................................................................................................................................. 17
 1. INTRODUCCIÓN

En este informe vamos a Abarcar los conceptos, características del lenguaje

ensamblador y realizar ejercicios implementando él lenguaje.

El ensamblador, es un lenguaje de programación, creado para no necesitar

conocer el código máquina de cada CPU y que sea más fácil de recordar. Entre
las características de este lenguaje, debemos destacar que permite trabajar a
bajo nivel (por ejemplo ordenando que en el registro 1 de tu CPU se guarde el
numero 23), permitiendo una gran optimización del código, además es un
lenguaje que varía dependiendo de la CPU y está principalmente en desuso.

El único lenguaje que entienden los microcontroladores es el código máquina

formado por ceros y unos del sistema binario. El lenguaje ensamblador expresa
las instrucciones de una forma más natural al hombre a la vez que muy cercana
al microcontrolador, ya que cada una de esas instrucciones se corresponde con
otra en código máquina. El lenguaje ensamblador trabaja con nemónicos, que
son grupos de caracteres alfanuméricos que simbolizan las órdenes o tareas a
realizar. La traducción de los nemónicos a código máquina entendible por el
microcontrolador la lleva a cabo un programa ensamblador. El programa escrito
en lenguaje ensamblador se denomina código fuente (*.asm). El programa
ensamblador proporciona a partir de este fichero el correspondiente código
máquina, que suele tener la extensión *.hex.
 2. MARCO TEÓRICO.

Lenguaje ensamblador
Definición.
El lenguaje ensamblador, o assembler (en inglés assembly language y la
abreviación asm), es un lenguaje de programación de bajo nivel. Consiste en un
conjunto de mnemónicos que representan instrucciones básicas 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 de procesador y constituye la representación más
directa del código máquina específico para cada arquitectura legible por un
programador. (Lopez, 2016)

Características

Según (macias, 2016) El código escrito en lenguaje ensamblador posee una

cierta dificultad de ser entendido ya que su estructura se acerca al lenguaje
máquina, es decir, es un lenguaje de bajo nivel.

El lenguaje ensamblador es difícilmente portable, es decir, un código escrito para

un microprocesador, puede necesitar ser modificado, para poder ser usado en
otra máquina distinta. Al cambiar a una máquina con arquitectura diferente,
generalmente es necesario reescribirlo completamente.

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. (Boñuelos,
2015)

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.
Programa ensamblador

(Duran, 2013)Generalmente, un programa ensamblador (assembler en inglés)

moderno crea código objeto es decir al código que resulta de
la compilación del código fuente es un conjunto de líneas de texto traduciendo
instrucciones mnemónicas es una palabra que sustituye a un código de
operación ( de lenguaje ensamblador en opcodes es la porción de
una instrucción de lenguaje de máquina que especifica la operación a ser
realizada., y resolviendo los nombres simbólicos Nombrar las entidades hace
posible referirse a las mismas, lo cual es esencial para cualquier tipo de
procesamiento simbólico. para las localizaciones de memoria y otras entidades.

El código fuente

Está compuesto por una sucesión de líneas de texto, cada línea puede
estructurarse en hasta cuatro campos o columnas separados por uno o más
espacios o tabulaciones entre sí.

Campo de etiquetas. Expresiones alfanuméricas escogidas por el usuario para

identificar una determinada línea. Todas las etiquetas tienen asignado el valor
de la posición de memoria en la que se encuentra el código al que acompañan.

Campo de código. Corresponde al nemónico de una instrucción, de una

directiva o de una llamada a macro.

Campo de operandos y datos. Contiene los operandos que precisa el

nemónico utilizado. Según el código, puede haber dos, uno o ningún operando.

Campo de comentarios. Dentro de una línea, todo lo que se encuentre a

continuación de un punto y coma (;) será ignorado por el programa ensamblador
y considerado como comentario. (Carter, 2016)
Campo de código

Puede corresponder ese código a:

Instrucciones: son aquellos nemónicos que son convertidos por el ensamblador

en código máquina que puede ejecutar el núcleo del microcontrolador. En la
gama media (PIC16xxx) cada nemónico se convierte en una palabra en la
memoria de programa

Directivas: Pseudoinstrucciones que controlan el proceso de ensamblado del

programa, pero no son parte del código. Son indicaciones al programa
ensamblador de cómo tiene que generar el código máquina.

Macros: Secuencia de nemónicos que pueden insertarse en el código fuente del

ensamblador de una manera abreviada mediante una simple llamada. (salomon,
2018)

Formato de una sentencia en ensamblador

Etiqueta: Nombre que se le asigna a una posición de la memoria de programa.

Empieza en la 1ª columna y suele ir seguida de ':‘.
Mnemónico: Representación simbólica del campo de operación (COP).
Operandos: Representados por símbolos o constantes, separados por comas.
Comentarios: Comienzan con ';‘.
EJERCICIOS

EJEMPLO #1
Este programa dibuja una línea en la pantalla al lado aparece con un retardo de
tiempo.

Código fuente.
 EJEMPLO #2
Programa que muestra la sucesión de códigos ASCII en la esquina superior
Derecha de la pantalla, intercambiando los caracteres cada medio segundo.

Código fuente.
 EJEMPLO #3
Programa que guarda el estado de la pantalla con todos sus caracteres, después
rellena toda la pantalla con '*' y por último vuelve a dejar la pantalla como estaba.

Código fuente.
 3. CONCLUSIONES

 Como conclusión podemos decir que el lenguaje ensamblador es mas que

un tipo de lenguaje de bajo nivel en el cual es empleado para crear
programas informáticos.

 Este lenguaje es creado a base de instrucciones para intentar sustituir al

lenguaje maquina por uno similar utilizado por el hombre.

 La importancia de este es que en él se pueden hacer cualquier tipo de

programas que en otros lenguajes de alto nivel no, al igual que ocupan
menos espacio en la memoria.

 Una de las cosas importantes es que está ocupado al diseño de las

tarjetas madres, cosa que un programa común no podría hacer.
 BIBLIOGRAFÍA

 Boñuelos, O. (24 de 09| de 2015). Obtenido de

https://es.slideshare.net/iagardea/lenguaje-ensamblador
 Carter, P. (7 de 08 de 2016). Obtenido de
https://pacman128.github.io/static/pcasm-book-spanish.pdf
 Duran, J. (11 de 09 de 2013). Obtenido de
https://www.somosbinarios.es/ensamblador/
 Lopez, J. (12 de 08 de 2016). Obtenido de
https://www.unioviedo.es/ate/alberto/TEMA3-Ensamblador.pdf
 salomon, D. (04 de 02 de 2018). Obtenido de
https://www.ecured.cu/Lenguaje_ensamblador