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
[Link]
Carter, P. (7 de 08 de 2016). Obtenido de
[Link]
Duran, J. (11 de 09 de 2013). Obtenido de
[Link]
Lopez, J. (12 de 08 de 2016). Obtenido de
[Link]
salomon, D. (04 de 02 de 2018). Obtenido de
[Link]
