UNIVERSIDAD POLITÉCNICA DE TULANCINGO

LENGUAJE ENSAMBLADOR

U
Nombre del alumno
Franco Gomez Oswaldo

Carrera:
INGENIERÍA ROBÓTICA

P Nombre de la Asignatura:

Programación de sistemas embebidos

Nombre del Docente:

José de Jesús Monter Vargas

T Cuatrimestre:

Septiembre - diciembre 2021

Grupo:

IR-71

Tulancingo de Bravo, Hidalgo a 07 de octubre del 2021.

1
NOMBRE
LENGUAJE ENSAMBLADOR
OBJETIVO
Implementar programas de bajo nivel que hagan uso de los
periféricos de entradas y salidas haciendo uso de Mplab y el
PIC16F84A.
MARCO TEÓRICO
Lenguaje ensamblador
El lenguaje ensamblador o assembly 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.
Se podría decir que un lenguaje de programación es un conjunto
de símbolos, palabras clave, códigos y reglas semánticas.
Estos son utilizados para crear una secuencia o serie de
instrucciones algorítmicas, las cuales serán utilizadas para crear
un programa que pueda controlar el comportamiento tanto
físico como lógico de una computadora. Esto es con el objetivo
de obtener un determinado resultado.
Podría definirse en muy pocas palabras que el lenguaje de
programación es un sistema estructurado de comunicación.
Este permite el nexo entre el programador y el dispositivo que
está programando.
Lenguaje máquina
El llamado “Lenguaje máquina” es uno de los lenguajes más
viejos que existen; se forma mediante la combinación de “1” y
“0”, es decir que es un lenguaje que sólo usa el sistema binario.
Esto es así debido a que este es el único sistema que los
dispositivos y computadoras son capaces de interpretar.
Lenguaje de programación de bajo nivel
La función básica de este lenguaje de programación es la de
actuar a modo de interfaz entre el hardware y el software de un
determinado dispositivo.
Lenguaje ensamblador
2
El lenguaje sobre el cual se profundiza en este artículo. El
lenguaje ensamblador, o Assembly Language en inglés fue el
primer intento en la búsqueda de un sustituto más sencillo de
comunicarse de forma directa con el hardware de un
dispositivo.
Cabe destacar en este punto que el número IEV de los
programas del tipo ensamblador dado por la International
Electrotechnical Commission es el 171-05-17, y está inscripto
en la categoría “Digital technology – Fundamental concepts /
Software”.
Este tipo de lenguajes actúan como conversores, ya que los
dispositivos utilizan el lenguaje binario, y el programador un
lenguaje de programación más flexible y sencillo de usar. Este
es llamado lenguaje de alto nivel.
LENGUAJE ENSAMBLADOR
• 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.
 Figura 1: Representación del programa ensamblador

El código fuente
Figura 2: Ejemplo de 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
El ensamblador MPASM (distribuido por Microchip) soporta
tabulaciones entre sí.
los sistemas de numeración decimal, hexadecimal, octal,
Campo de etiquetas. Expresiones alfanuméricas escogidas por binario y ASCII.
el usuario para identificar una determinada línea. Todas las
Los nemónicos que tengan una constante como operando
etiquetas tienen asignado el valor de la posición de memoria en
deberán incluirla respetando la sintaxis que se indica a
la que se encuentra el código al que acompañan.
continuación.
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.
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.
Figura 3: Nemónicos
Las constantes hexadecimales que empiecen por una letra
deben ir precedidas de un cero para no confundirlas con una
etiqueta. Ejemplo: movlw 0F7h
El juego de instrucciones
• Es un juego reducido de 35 instrucciones muy
simples. Procesador RISC
• La mayoría de las instrucciones se ejecuta en 4 ciclos
de reloj; los saltos y llamadas a subprogramas se
ejecutan en 8 (no se aprovecha pipeline)
• Todas las instrucciones tienen la misma longitud en
la gama media: 14 bits.
• Por lo tanto, el cálculo del tiempo de ejecución y de
lo que ocupa un programa resulta simple
• Las instrucciones se pueden clasificar atendiendo a
dos criterios: formato y funcionabilidad.

3

Figura 4: Juego de instrucciones PIC16F84A (Anexo 1)
Relación entre el código binario y el lenguaje ensamblador
En el código binario se utilizan ceros y unos, mientras que el
lenguaje ensamblador es una colección de símbolos
mnemónicos que representan: operaciones, nombres
simbólicos, operadores y símbolos especiales.
La relación entre estos dos lenguajes sería que el binario es el
lenguaje que la máquina entiende y el ensamblador se acerca
más lenguaje de esta.
Manejo de la memoria: Direccionamiento (interno y externo)
El manejo de la memoria depende de que procesador tenga la
máquina, entre los cuales a continuación se mencionan los
siguientes:
Memoria de Programa
Memoria Externa de Datos
Memoria Interna de Datos
Registros de Funciones Especiales
Memoria de Bit.
El espacio de la Memoria de Programa contiene todas las
instrucciones, datos, tablas y cadenas de caracteres (strings)
usadas en los programas. Esta memoria se direcciona
principalmente usando el registro de 16 bits llamado Data
Pointer. El tamaño máximo de la Memoria de Programa es de
64 Kbytes.
La Memoria Externa de Datos contiene todas las variables y
estructuras de datos que no caben en la memoria interna del
Microprocesador. Esta memoria se direcciona principalmente
por el registro de 16 bits Data Pointer , aunque también se puede
4
direccionar un banco de Memoria Externa de Datos de 256
bytes usando los dos primeros registros de propósito general .
Programación del Microcontrolador PIC16f84
El PIC16F84A Microcontrolador es ideal para aquellos que
están adentrándose en el mundo de la electrónica y
programación, debido a su baja inversión y conjunto reducido
de instrucciones que lo hacen muy amigable y más sencillo de
utilizar que otros microcontroladores de la familia PIC.
El PIC16F84 es un microcontrolador a 8 bits de la familia PIC
perteneciente a la Gama Media (según la clasificación dada a
los microcontroladores por la misma empresa fabricante)
Microchip.
Figura 5: PIC16F84 de Microchip
Se trata de uno de los microcontroladores más populares del
mercado actual, ideal para principiantes, debido a su
arquitectura de 8 bits, 18 pines, y un conjunto de instrucciones
amigable para memorizar y fácil de entender, internamente
consta de:
• Memoria Flash de programa (1K x 14 bits).
• Memoria RAM (68 registros x 8 bits).
• Un temporizador/contador (timer de 8 bits).
• Un divisor de frecuencia.
• Varios puertos de entrada-salida (13 pines en dos
puertos, 5 pines el puerto A y 8 pines el puerto B).
Otras características son:
• Manejo de interrupciones (de 4 fuentes).
• Perro guardián (watchdog).
• Bajo consumo.
• Frecuencia de reloj externa máxima 10MHz. (Hasta
20MHz en nuevas versiones). La frecuencia de reloj
interna es un cuarto de la externa, lo que significa que
con un reloj de 20MHz, el reloj interno sería de 5MHz
y así pues se ejecutan 5 Millones de Instrucciones por
Segundo (5 MIPS)
• No posee conversores analógicos-digital ni digital-
analógicos.
 • Pipe-line de 2 etapas, 1 para búsqueda de instrucción
y otra para la ejecución de la instrucción (los saltos
ocupan un ciclo más).
• Repertorio de instrucciones reducido (RISC), con tan
solo 35 instrucciones distintas.
• 4 tipos distintos de instrucciones, orientadas a byte,
orientadas a bit, operación entre registros, de salto.

Al microcontrolador se le diseña de tal manera que tenga todos

los componentes integrados en el mismo chip. No necesita de
otros componentes especializados para su aplicación, porque
todos los circuitos necesarios, que de otra manera correspondan
a los periféricos, ya se encuentran incorporados. Así se ahorra
tiempo y espacio necesario para construir un dispositivo.

Cabe destacar que se utilizó el cristal oscilador de cuarzo de

DESARROLLO
2. De los códigos realizados en la actividad 3, abra los archivos
txt con el software MPLAB, en implemente su código para
generar los archivos . HEX (Referencia: Pag. 117, Libro
Enrique Palaciones, et. Al.).
3. Implemente los archivos “.HEX” generados en el simulador
y compruebe que su programa hace lo que pide cada inciso.
4MHz conectado a tierra con dos capacitores de 22pF en los
pines de OSC1 Y OSC2 del PIC16F84A. Para observar el
correcto funcionamiento se colocaron generadores lógicos
digitales que pueden dar un 1 o un 0 lógico en los pines del
puerto A, además de lectores lógicos en los pines del puerto B.
Cabe destacar que este circuito funcionará para los 10
programas que se realizaron.
SIMULACIÓN

Para el desarrollo de la práctica se usó el software de MpLab Se utilizarán los programas elaborados en el trabajo número 3,
de Microchip para utilizar el lenguaje ensamblador para anterior a esta entrega, así que después de instalar MpLAB se
programar el PIC16F84A. carga el primer programa y se compila. A continuación, se
explica cada ejercicio realizado.

Elemental_01.asm:
Por el Puerto B se obtiene el dato de las cinco líneas del Puerto
A, al que está conectado un array de interruptores, sumándole
el valor de una constante, por ejemplo 74. Es decir:
(PORTB)=(PORTA)+Constante.

Cabe destacar que el primer programa esta como anexo 2 en

este mismo documento.

Para comenzar se abre MPLAB y se configura de acuerdo al

Figura 6: MPLAB PIC que estamos utilizando:

Para poder verificar que el funcionamento es correcto se

utiliza el software de Proteus, se construyó el siguiente
circuito para simular los 10 ejercicios que se realizaron:

5

Figura 7: Selección de PIC
Además de seleccionar la herramienta de simulación:
Figura 8: Selección de herramienta
Después de dar en NEW FILE, se copia el programa desde el
bloc de notas, y se pega en el entorno de MpLab:
6
Figura 9: Código de programa elemental 01
Se debe guardar el programa en un archivo .asm, y
posteriormente se le da en construir para saber si el programa
no tiene errores de sintaxis, si el programa es correcto:
Figura 10: Correcta compilación de código
Una vez construido el programa se sabe que no tiene errores,
así que es tiempo de pasar al simulador electrónico, que en
este caso es Proteus, para cargar el programa al PIC16F84A se
da doble clic en este y se selecciona el archivo .hex existente
en la carpeta resultante al compilar el programa.

Figura 11: Colocación de programa en PIC del simulador de
Proteus
Se da en simular y se tiene el circuito resultante funcionando.
Funcionamiento del programa: el código esta realizado para
hacer una suma, claro que la entrada es en binario y por lo tanto
la salida también, pero la suma es +74 en decimal, y el resultado
se da en binario por medio de los pines del puerto B. En la
figura 12 se ve que se está ingresando 00000, el 0 en decimal y
si se suma 74 se tendría que dar el 74 en binario, el cual es
01001010, y se observa que el programa actúa de forma
correcta:
Figura 12: Programa_1, se coloca 00000 en binario(0 en
decimal), y resulta 01001010.
El programa realiza el correcto funcionamiento, la figura 13
muestra otro ejemplo colocando el decimal 20(10100),
sumando 74 se obtiene 94 (01011110).
7
Figura 13: Programa_1, se coloca 10100 en binario(20 en
decimal), y resulta 01011110(94 en decimal).
SIGUIENTES PROGRAMAS:
Para la simulación de los siguientes programas se siguieron los
mismos pasos para lograr verificar el funcionamiento correcto
del programa realizado.
Elemental_02.asm:
Por el Puerto B se obtiene el dato del Puerto A multiplicado por
2. Es decir: (PORTB)=2(PORTA)=(PORTA)+(PORT A).
Cabe destacar que el programa utilizado en este ejercicio como
anexo 3 en este mismo documento.
Funcionamiento del programa: El programa realiza una
multiplicación de número binarios, lo que hace es multiplicar
por 2(decimal) el numéro binario ingresado. La figura 14
muestra el ingreso del dato 20 decimal (10100) y de como
resultado en la salida 40 decimal (10100).
Figura 14: Programa_2, se coloca 10100 en binario(20 en
decimal), y resulta 00101000(40 en decimal).
La figura 15 muestra el programa cundo se ingresa el dato 12
decimal (1100) y se observa el resultado 24 decimal (11000)
en los pines del puerto B.
 Figura 14: Programa_2, se coloca 01100 en binario (12 en
decimal), y resulta 00011000(24 en decimal). Figura 15: Programa_3, se coloca 00000 en la entrada y se
obtiene 01010101 en la salida ya que se los pares se hacen 1.

El programa funciona de la forma correcta y resuelve la

problemática planteada.

Elemental_03.asm:
Por el Puerto B obtiene el dato del Puerto A, pero en la salida
los bits pares se fijan siempre a "1". El orden de los bits será
"b7 b6 b5 b4 b3 b2 b1 b0", siendo los pares el b6, b4, b2 y el
b0. Por ejemplo, si por el Puerto A se introduce el dato b'---
01100', por el Puerto B se visualiza b'01011101'. Observar que
los bits pares están a "1" (efectivamente: Puerto B =
b'x1x1x1x1') y los impares permanecen con el dato del puerto
de entrada (efectivamente: Puerto A = b'---x1x0x' y Puerto B =
b'xxxx1x0x').

Cabe destacar que el programa utilizado en este ejercicio como
anexo 4 en este mismo documento.
Funcionamiento del programa: El programa cumple la
función de pasar los mismos datos del puerto A al puerto B pero
con la condición de que los bits pares siempre serán 1, pero
ahora irán invertidas las salidas, es decir, b7 tomará el lugar de
b1, b6 el de b2, etc. La figura 15 muestra el ingreso de los bits
00000 y da como resultado en la salida 01010101 ya que se
están invirtiendo todos los pares, es decir, b6, b4, b2, b0, esto
siempre serán 1 sin importar la entrada.
Como otro ejemplo se ponen los bits 11111 en la entrada, y
como salida se obtiene 01011111 porque en este caso se
cumple la condición de que todos sean 1 en la salida, solo se
aprecian los primeros 5 ya que solo son 5 bits de entrada.
Figura 16: Programa_3, se coloca 11111 em la entrada y se obtienen
01011111 ya que la entrada es de 5 bits y los pares se hacen 1
El programa 3 realiza las instrucciones correspondientes y
resuelve bien la problemática planteada.
Elemental_04.asm:
Por el Puerto B obtiene el dato del Puerto A, pero en las salidas
los bits impares se fijan siempre a "0". El orden de los bits será
"b7 b6 b5 b4 b3 b2 b1 b0", siendo los impares el b7, b5, b3 y
b1. Por ejemplo, si por el Puerto A se introduce el dato b'---
01100', por el Puerto B se visualiza b'00000100'. Observar que
los bits impares están a "0" (efectivamente: Puerto B =
b'0x0x0x0x') y los pares permanecen con el dato del puerto de
entrada (efectivamente: Puerto A = b'---0x1x0' y Puerto B = b'-
--0x1x0').

Cabe destacar que el programa utilizado en este ejercicio como

anexo 5 en este mismo documento.

Funcionamiento del programa: El programa cumple la

función de pasar los mismos datos del puerto A al puerto B pero
con la condición de que los bits impares siempre serán 0, pero

8
ahora irán invertidas las salidas, es decir, b7 tomará el lugar de
b1, b6 el de b2, etc. La figura 17 muestra el ingreso de los bits
01010 y da como resultado en la salida 00000000 ya que se
están colocando a 0 todos los impares, y por ende serán todos 0
porque los únicos 1 de la entrada son los impares.
Figura 17: Programa_4, se coloca 01010 en la entrada y se obtienen
00000000 ya que la entrada es de 5 bits y los impares se hacen 0.
Como otro ejemplo, la figura 18 muestra en la entra los bits
11111, como los bits impares se ponen a 0, en la salida
obtenemos 00010101, no hay que tomar en cuenta los primeros
3 bits.
Figura 18: Programa_4, se coloca 11111 en la entrada y se obtienen
00010101 ya que la entrada es de 5 bits y los impares se hacen 0.
El programa 4 resuelve la problemática planteada de forma
correcta y es funcional.
Elemental_05.asm:
Por el Puerto B se obtiene el dato del Puerto A invertidos los
unos y ceros. Por ejemplo, si por el Puerto A se introduce "---
11001", por el Puerto B aparecerá "xxx00110" (no importa el
estado de los tres bits superiores del Puerto B).
9
Cabe destacar que el programa utilizado en este ejercicio como
anexo 6 en este mismo documento
Funcionamiento del programa: El programa cumple la
función de pasar los mismos datos del puerto A al puerto B pero
con la condición de que estos se van a invertir. La figura 19
muestra el ingreso de los bits 10101 y da como resultado en la
salida 11101010 ya que se están invirtiendo, los datos de los
pines b5, b6, b7 no tiene interés en este programa.
Figura 19: Programa_5, se coloca 10101 en la entrada y se obtienen
11101010 ya que se invierten los datos.
Como otro ejemplo, la figura 20 muestra la entrada de los bits
00100, y ya que estos se invierten, la salida da xxx11011.
Figura 20: Programa_5, se coloca 00100 en la entrada y se obtienen
11111011 ya que se invierten los datos.
El programa 5 resuelve la problemática planteada de forma
correcta y es funcional.
Elemental_06.asm:
Por el Puerto B obtiene el dato del Puerto A intercambiando
los nibbles alto y bajo. Por ejemplo, si por el Puerto A se
introduce "---11001" por el Puerto B aparecerá "1001xxx1".
Cabe destacar que el programa utilizado en este ejercicio
como anexo 7 en este mismo documento.
Funcionamiento del programa: El programa cumple la
función de pasar los mismos datos del puerto A al puerto B pero
con la condición de los nibbles alto y bajo se van a intercambiar,
la figura 21 muestra la entrada de los datos 11001, teniendo en
la salida 1001xxx1, observe:
Figura 21: Programa_6, se coloca 11001 en la entrada y se obtienen
1001xxx1 ya que se intercambian los nibbles alto y bajo.
Otro ejemplo se ve en la figura 22, se introducen los datos
10011, y ya que se están intercambiando los nibbles alto y
bajo, se obtiene 0011xxx1, observe:
Figura 22: Programa_6, se coloca 10011 en la entrada y se obtienen
0011xxx1 ya que se intercambian los nibbles alto y bajo.
El programa 6 resuelve la problemática planteada de forma
correcta y es funcional.
Elemental_07.asm:
Por el Puerto B obtiene el dato del Puerto A desplazando un bit
hacia la izquierda, por la derecha entrará un "1". Por ejemplo,
si por el Puerto A se introduce "---11001", por el Puerto B
aparecerá "xx110011" (no importa el estado de los dos bits
superiores del Puerto B).
Cabe destacar que el programa utilizado en este ejercicio
como anexo 8 en este mismo documento.
10
Funcionamiento del programa: El programa cumple la
función de pasar los mismos datos del puerto A al puerto B pero
los bits se desplazan 1 lugar hacia la izquierda, entrando en la
derecha un 1. La figura 23 muestra el funcionamiento con esté
ejemplo.
Figura 23: Programa_7, se coloca 11001 en la entrada y se obtienen
xx110011 ya que se recorrió un lugar a la izquierda, introduciendo un
1 en la derecha.
Otro ejemplo se muestra en la figura 24, donde se introducen
en la entrada los bits 10001, y por ende, el programa hará que
se trasforme a un xx100011.
Figura 24: Programa_7, se coloca 10001 en la entrada y se obtienen
xx100011 ya que se recorrió un lugar a la izquierda, introduciendo un
1 en la derecha.
El programa 7 resuelve la problemática planteada de forma
correcta y es funcional.
Elemental_08.asm:
Por el Puerto B se obtiene el dato del Puerto A desplazando un
bit hacia la derecha, por la izquierda entrará un "0". Por
ejemplo, si por el Puerto A se introduce "---11001", por el
Puerto B aparecerá "0xxx1100".
 Cabe destacar que el programa utilizado en este ejercicio como
anexo 9 en este mismo documento.
Funcionamiento del programa: El programa cumple la
función de pasar los mismos datos del puerto A al puerto B pero
los bits se desplazan 1 lugar hacia la derecha, y entrando en la
derecha un 0. La figura 25 muestra el funcionamiento, si
ponemos los bits 11001. En la salida se tendrá 0xxx1100.
Figura 25: Programa_8, se coloca 11001 en la entrada y se obtiene
0xxx1100 ya que se recorrió un lugar a la derecha, introduciendo un
0 en la izquierda.
Otro ejemplo se muestra en la figura 26, donde se introducen
en la entrada los bits 10001, y, por ende, el programa hará que
se trasforme a un 0xxx1000.
Figura 26: Programa_8, se coloca 10001 en la entrada y se obtienen
0xxx1000 ya que se recorrió un lugar a la derecha, introduciendo un
0 en la izquierda.
El programa 8 resuelve la problemática planteada de forma
correcta y es funcional.
Elemental_09.asm:
11
Por el Puerto B se obtiene el dato del Puerto A invirtiendo los
bits pares. Los impares se dejan como en la entrada.
Cabe destacar que el programa utilizado en este ejercicio como
anexo 10 en este mismo documento.
Funcionamiento del programa: El programa cumple la
función de pasar los mismos datos del puerto A al puerto B pero
invirtiendo los impares, es decir, los bits de posición 1, 3 y 5 se
van a invertir dependiendo de su valor. La figura 27 muestra el
funcionamiento, si ponemos los bits 00000. En la salida se
tendrá xxx10101:
Figura 27: Programa_9, se coloca 00000 en la entrada y se obtiene
xxx10101 ya que se están invirtiendo los bits impares.
Otro ejemplo es introduciendo los datos 11111, y ya que se
invierten, en la salida se tiene xxx01010. Ver figura 28.
Figura 28: Programa_9, se coloca 11111 en la entrada y se obtiene
xxx01010 ya que se están invirtiendo los bits impares.
Otro ejemplo con este programa es introduciendo los bits
10101, y ya que se invierten los valores de los bits impares se
tiene como salida xxx00000. Ver figura 29.

Figura 29: Programa_9, se coloca 10101 en la entrada y se obtiene
xxx00000 ya que se están invirtiendo los bits impares.
El programa 9 resuelve la problemática planteada de forma
correcta y es funcional.
Elemental_10.asm:
Por el Puerto B se obtiene el dato de las cinco líneas del Puerto
A al que están conectado un array de interruptores. Esta
operación la realizará una única vez. Después el programa
entrará en modo "Standby" o de bajo consumo del cual no podrá
salir después.
Cabe destacar que el programa utilizado en este ejercicio como
anexo 11 en este mismo documento.
Funcionamiento del programa: El programa cumple la
función de pasar los mismos datos del puerto A al puerto B pero
esto solo lo hará una sola vez y entrará en una forma parecida
al Stanby, es decir, al dar simular en Proteus, lo valores de la
entrada se formarán también en la salida. La figura 30 muestra
el funcionamiento.
Figura 30: Programa_10, se coloca 10101 en la entrada y se obtiene
xxx10101 (los mismos que en la entrada)y sólo se hace una vez.
12
Ya que esto solo se puede hacer, aunque se cambien los valores
de los bits de la entrada, la salida no va a cambiar el valor de
ningún bit, y que el programa lo mantiene en modo stanby, la
figura 31 muestra este funcionamiento. Una instrucción en el
programa hace que esto sea posible y se puede ver en el anexo
11 de esta entrega,
Figura 31: Programa_10, aunque se cambien los valores de la
entrada, los de la salida no van a cambiar a menos de que se detenga
y se vuelva a simular el programa.
RESULTADOS
Se obtuvieron 10 programas diferentes que posteriormente
fueron simulados en software. Estos están presentes en los
anexos 2-11 de la presente actividad y las simulaciones en su
respectiva área en el desarrollo.
El tema principal fue el manejo de las activaciones de entradas
y salidas del microcontrolador, siendo algo básico pero
demasiado importante para los programas que se deberán hacer
posteriormente.
El control del microcontrolador en esta actividad fue enfocado
al manejo de entradas y salidas, utilizando el lenguaje
ensamblador para lograr esto: la entrada permite que el
microcontrolador pueda monitorear factores o agentes externos
a él, como, por ejemplo: La activación de un interruptor, el
pulsado de un botón o el valor que le entrega un sensor.
Podríamos decir que a través de estas el micro capta la
información necesaria para ejecutar ciertas acciones. Las
entradas pueden ser analógicas o digitales. La salida permite al
micro controlar otros dispositivos como leds, motores, buzzers,
etc. Los microcontroladores utilizan las salidas para ejecutar las
acciones que le fueron programadas. Al igual que las entradas,
las salidas también pueden ser digitales o analógicas.
El lenguaje ensamblador es ideal para escribir programas
embebidos, debido a que utilizan muy poca memoria.
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.
En los primeros días de la programación, la mayoría de las
aplicaciones se escribían parcial o totalmente en lenguaje
ensamblador. Tenían que ajustarse en una pequeña área de
memoria y se ejecutaban de la manera más eficiente posible en
los procesadores lentos. A medida que la memoria aumentó su
capacidad y los procesadores su velocidad, los programas se
hicieron más complejos. Los programadores cambiaron a
lenguajes de alto nivel tales como C, FORTRAN y COBOL,
los cuales contenían una cierta capacidad de estructuración. Los
lenguajes de programación orientados a objetos más recientes,
tales como C++, C# y Java, han hecho posible la escritura de
programas complejos que contienen millones de líneas de
código. Es raro ver programas de aplicación extensos
codificados por completo en lenguaje ensamblador, ya que se
requeriría mucho tiempo para escribirlos y darles
mantenimiento. En vez de ello, el lenguaje ensamblador se
utiliza para optimizar ciertas secciones de los programas de
aplicación en relación con la velocidad y para tener acceso al
hardware de la computadora. Un ensamblador es un programa
que ejecuta la computadora y convierte instrucciones en un
patrón de bits. El procesador puede usarlo para realizar
operaciones básicas. Algunas personas llaman a estas
instrucciones lenguaje ensamblador y otras usan el término
lenguaje ensamblador.
El programador puede escribir un programa usando una serie
de estas instrucciones de ensamblador. Esta secuencia de
declaraciones de ensamblador, conocida como código fuente o
el programa fuente, se especifica en el programa ensamblador
cuando iniciamos el programa. El programa ensamblador toma
cada instrucción del programa en el programa fuente y genera
un flujo de bits o patrón correspondiente (una serie de ceros y
unos de cierta longitud). La salida del programa ensamblador
se denomina código objeto o programa objeto con respecto al
programa fuente de entrada. La secuencia de ceros y unos que
componen el programa objeto también se denomina código
máquina. Entonces podemos ejecutar el programa objeto en
cualquier momento.
13
CONCLUSIONES
La complejidad de los procesadores actuales hace la
optimización cada vez más difícil para los compiladores,
además las prestaciones cada vez mayores de los procesadores
hacen que la mayoría de las CPU permanezcan desocupadas la
mayor parte del tiempo. Esto hace que la velocidad de ejecución
de código no sea ya un problema. El lenguaje ensamblador se
utiliza principalmente para traducir lenguajes de alto nivel en
código máquina, o para funciones críticas o en procesos
industriales, sobre todo si es importante el tiempo real.
También se utiliza si se necesita un ejecutable independiente
(stand-alone) que deba ejecutarse sin recursos. Son programas
empotrados que solo disponen de una pequeña cantidad de
memoria y está dirigido para hacer tareas con propósito simple,
por ejemplo en teléfonos, sistemas de ignición de combustible
para automóviles, control de aire acondicionado, sensores y
sistemas de seguridad.
El lenguaje ensamblador no suele ser portable, en otras
palabras, el código para un microprocesador no sirve para
ejecutarse en otro (modelo o marca diferentes) por lo que es
necesario modificarlo para usarlo en otro microprocesador de
diferente modelo o arquitectura diferentes. En estos casos el
código debe reescribirse.
El lenguaje ensamblador permite controlar exactamente las
tareas realizadas por el microprocesador y es capaz de crear
código imposible de imitar en un lenguaje de alto nivel, ya que
el lenguaje ensamblador dispone de instrucciones que no están
disponibles en los lenguajes de alto nivel. El lenguaje
ensamblador también es valioso para hacer ingeniería inversa,
pues muchos programas son distribuidos exclusivamente como
código de máquina. El código de máquina es fácil de trasladar
hacia lenguaje ensamblador para luego ser examinado en esta
forma, aunque sigue siendo muy difícil trasladarlo a un
lenguaje de alto nivel. También existen herramientas para hacer
esto último de forma automática.
REFERENCIAS
[1] Lenguaje ensamblador. Importancia del lenguaje
ensamblador. Recuperado el 6 de octubre de 2021 de:
https://www.monografias.com/trabajos14/lenguaje-
ensamblador/lenguaje-ensamblador.shtml
[2] Ingeniería Mecafenix. Microcontrolador PIC. Recuperado
el 5 de octubre de 2021 de:
https://www.ingmecafenix.com/electronica/microcontrolador-
pic-partes-aplicaciones/
ANEXOS
ANEXO 1 INSTRUCCIONES DE PIC16F84A

14
ANEXO 2 Programa_elemental_01

;*********************************** Elemental_01.asm ***********************************

; Por el Puerto B se obtiene el dato de las cinco líneas del Puerto A, al que está conectado

; un array de interruptores, sumándole el valor de una constante, por ejemplo 74.

; Es decir: (PORTB)=(PORTA)+Constante

; ZONA DE DATOS *********************************************************************

__CONFIG _CP_OFF & _WDT_OFF & _PWRTE_ON & _XT_OSC

LIST P=16F84A ; Procesador que se utiliza.

INCLUDE <P16F84A.INC> ; Definición de algunos operandos utilizados.

Constante EQU d'74' ; En sistema decimal se pone así.

; ZONA DE CÓDIGOS *******************************************************************

ORG 0 ; El programa comienza en dirección 0.

Inicio

bsf STATUS,RP0 ; Pone a 1 el bit 5 del STATUS. Acceso al Banco 1.

clrf TRISB ; Las líneas del Puerto B se configuran como salidas.

movlw b'00011111' ; Las 5 líneas del Puerto A se configuran como entradas.

movwf TRISA

bcf STATUS,RP0 ; Pone a 0 el bit 5 de STATUS. Acceso al Banco 0.

Principal

movf PORTA,W ; Carga el registro de datos del Puerto A en (W).

addlw Constante ; (W)=(PORTA)+Constante.

movwf PORTB ; El contenido de W se deposita en el puerto de salida.

goto Principal ; Crea un bucle cerrado e infinito.

END ; Fin del programa.

15
; ===================================================================

; Creado por Oswaldo Franco Gomez

; Programacion de sistemas embebidos

; Ingeniería en robótica

; ===================================================================

ANEXO 3 Programa_elemental_02

;*********************************** Elemental_02.asm ***********************************

; Por el Puerto B se obtiene el dato del Puerto A multiplicado por 2.

; Es decir: (PORTB)=2(PORTA)=(PORTA)+(PORT A).

; ZONA DE DATOS *********************************************************************

__CONFIG _CP_OFF & _WDT_OFF & _PWRTE_ON & _XT_OSC

LIST P=16F84A ; Procesador utilizado.

INCLUDE <P16F84A.INC> ; Definición de algunos operandos utilizados.

; ZONA DE CÓDIGOS *******************************************************************

ORG 0 ; El programa comienza en la dirección 0.

Inicio bsf STATUS,RP0 ; Pone a 1 el bit 5 del STATUS, acceso al Banco 1.

clrf TRISB ; Las líneas del Puerto B se configuran como salidas.

movlw b'00011111'

movwf TRISA ; Las líneas del Puerto A como entradas.

bcf STATUS,RP0 ; Pone a 0 el bit 5 de STATUS. Acceso al Banco 0.

Principal

16
 movf PORTA,W ; Carga el registro de datos del Puerto A en (W).

addwf PORTA,W ; (W)=(PORTA)+(PORTA)=2(PORTA).

movwf PORTB ; El contenido de W se deposita en el Puerto B.

goto Principal ; Crea un bucle cerrado e infinito.

END ; Fin del programa.

; ===================================================================

; Creado por Oswaldo Franco Gomez

; Programación de sistemas embebidos

; Ingenieria robotica

; ===================================================================

ANEXO 4 Programa_elemental_03

;Programa_elemental_03.asm

;=======================================================================

LIST p=PIC16F84A

INCLUDE <p16F84a.inc>

__CONFIG _XT_OSC & _CP_OFF & _PWRTE_ON & _WDT_OFF

ERRORLEVEL -302

;=======================================================================

;*********************************** Elemental_03.asm ***********************************

;Por el Puerto B obtiene el dato del Puerto A, pero en la salida los bits pares se fijan siempre a "1".

;El orden de los bits será "b7 b6 b5 b4 b3 b2 b1 b0", siendo los pares el b6, b4, b2 y el b0.

;Por ejemplo, si por el Puerto A se introduce el dato b'---01100', por el Puerto B se visualiza b'01011101'.

;Observar que los bits pares están a "1" (efectivamente: Puerto B = b'x1x1x1x1') y los impares permanecen con

;el dato del puerto de entrada (efectivamente: Puerto A = b'---x1x0x' y Puerto B = b'xxxx1x0x').

17
; Defino las variables

;=======================================================================

#DEFINE bank0 bcf STATUS,RP0

#DEFINE bank1 bSf STATUS,RP0

;=======================================================================

ORG 0x000

goto Inicio

ORG 0X004

retfie

Inicio

bank1

clrf TRISB

movlw 0x1F

movwf TRISA

bank0

Principal

movf PORTA,W ;muevo el PORTA al work

iorlw b'01010101' ;hago una or entre el literal(valor en binario)y ; el work (PORTA)

movwf PORTB ;muevo el work al file(PORTB)

goto Principal

END

;=======================================================================

; Creado por Oswaldo Franco Gomez

; Programación de sistemas embebidos

; Ingeniería robótica

;=======================================================================

ANEXO 5 Programa_elemental_04

18
;*********************************** Elemental_04.asm ***********************************

; Por el Puerto B obtiene el dato del Puerto A, pero en las salida los bits impares se

; fijan siempre a "0". El orden de los bits será "b7 b6 b5 b4 b3 b2 b1 b0", siendo los

; impares el b7, b5, b3 y b1.

; Por ejemplo si por el Puerto A se introduce el dato b'---01100', por el Puerto B se

; visualiza b'00000100'. Observar que los bits impares están a "0" (efectivamente:

; Puerto B = b'0x0x0x0x') y los pares permanecen con el dato del puerto de entrada

; (efectivamente: Puerto A = b'---0x1x0' y Puerto B = b'---0x1x0').

; ZONA DE DATOS *********************************************************************

__CONFIG _CP_OFF & _WDT_OFF & _PWRTE_ON & _XT_OSC

LIST P=16F84A ; Procesador utilizado.

INCLUDE <P16F84A.INC> ; Definición de algunos operandos que se utlizan.

Mascara EQU b'01010101' ; Máscara de bits impares siempre a "0", este es el trabajo importante.

; ZONA DE CÓDIGOS *******************************************************************

ORG 0 ; El programa comienza en la dirección 0.

Inicio bsf STATUS,RP0 ; Pone a 1 el bit 5 del STATUS. Acceso al Banco 1.

clrf TRISB ; Las líneas del Puerto B se configuran como salidas.

movlw b'00011111'

movwf TRISA ; Las 5 líneas del Puerto A como entrada.

bcf STATUS,RP0 ; Pone a 0 el bit 5 de STATUS. Toma acceso al Banco 0.

Principal

movf PORTA,W ; Carga el registro de datos del Puerto A en W

andlw Mascara ; Pone a "0" los bits pares.

movwf PORTB ; El contenido de W se deposita en la salida.

goto Principal ; Se crea un bucle infinito.

19
 END ; Fin del programa.

; ===================================================================

; Creado por Oswaldo Franco Gomez

; Programación de sistemas embebidos

; Ingeniería robótica

; ===================================================================

ANEXO 6 Programa_elemental_05

;*********************************** Elemental_05.asm ***********************************

;Por el Puerto B se obtiene el dato del Puerto A invertidos los unos y ceros.

;Por ejemplo, si por el Puerto A se introduce "---11001", por el Puerto B aparecerá "xxx00110"

;(no importa el estado de los tres bits superiores del Puerto B).

; ZONA DE DATOS *********************************************************************

LIST p=PIC16F84A

INCLUDE <p16F84a.inc>

__CONFIG _XT_OSC & _CP_OFF & _PWRTE_ON & _WDT_OFF

ERRORLEVEL -302

;=======================================================================

; Defino las variables

;=======================================================================

#DEFINE bank0 bcf STATUS,RP0

#DEFINE bank1 bSf STATUS,RP0

;=======================================================================

ORG 0x000

20
goto Inicio

ORG 0X004

retfie

Inicio

bank1

clrf TRISB ; Las líneas del Puerto B se configuran como salidas

movlw 0x1F

movwf TRISA ; Las 5 líneas del Puerto A como entrada.

bank0

Principal

comf PORTA,W ;Complemento el PORTA y lO guardo en el work

movwf PORTB ;muevo el work al file(PORTB)

goto Principal

END

; ===================================================================

; Creado por Oswaldo Franco Gomez

; Programación de sistemas embebidos

; Ingeniería robótica

; ===================================================================

ANEXO 7 Programa_elemental_06

;*********************************** Elemental_06.asm ***********************************

;Por el Puerto B obtiene el dato del Puerto A intercambiando los nibbles alto y bajo.

;Por ejemplo, si por el Puerto A se introduce "---11001" por el Puerto B aparecerá "1001xxx1".

; ZONA DE DATOS *********************************************************************

LIST p=PIC16F84A

INCLUDE <p16F84a.inc>

__CONFIG _XT_OSC & _CP_OFF & _PWRTE_ON & _WDT_OFF

21
ERRORLEVEL -302

;=======================================================================

; Defino las variables

;=======================================================================

#DEFINE bank0 bcf STATUS,RP0

#DEFINE bank1 bSf STATUS,RP0

;=======================================================================

ORG 0x000

goto Inicio

ORG 0X004

retfie

Inicio

bank1

clrf TRISB ; Las líneas del Puerto B se configuran como salidas

movwf TRISA ; Las 5 líneas del Puerto A como entrada.

bank0

Principal

swapf PORTA,W

movlw 0x1F

movwf PORTB

goto Principal

END

; ===================================================================

; Creado por Oswaldo Franco Gomez

; Programación de sistemas embebidos

; Ingeniería robótica

; ===================================================================

ANEXO 8 Programa_elemental_07

22
;*********************************** Elemental_07.asm ***********************************

; Por el Puerto B obtiene el dato del Puerto A desplazando un bit hacia la izquierda,

;por la derecha entrará un "1". Por ejemplo, si por el Puerto A se introduce "---11001",

;por el Puerto B aparecerá "xx110011" (no importa el estado de los dos bits superiores

;del Puerto B).

; ZONA DE DATOS *********************************************************************

; ZONA DE DATOS *********************************************************************

__CONFIG _CP_OFF & _WDT_OFF & _PWRTE_ON & _XT_OSC

LIST P=16F84A ; Procesador utilizado.

INCLUDE <P16F84A.INC> ; Definición de algunos operandos utilizados.

; ZONA DE CÓDIGOS ********************************************************************

ORG 0 ; El programa comienza en la dirección 0.

Inicio

bsf STATUS,RP0 ; Acceso al Banco 1.

clrf TRISB ; Las líneas del Puerto B se configuran como salida.

movlw b'00011111' ; Las 5 líneas del Puerto A se configuran como entrada.

movwf TRISA

bcf STATUS,RP0 ; Acceso al Banco 0.

Principal

bsf STATUS,C ; Este es el "1" que entrará por la derecha.

rlf PORTA,W ; Rota los bits una posición a la izquierda y lo

movwf PORTB ; lleva al Puerto B para que se visualice.

goto Principal ; Se crea un bucle cerrado e infinito.

END ; Fin del programa.

; ===================================================================

; Creado por Oswaldo Franco Gomez

; Programación de sistemas embebidos

; Ingeniería robótica

23
; ===================================================================

ANEXO 9 Programa_elemental_08

;*********************************** Elemental_08.asm ***********************************

; Por el Puerto B se obtiene el dato del Puerto A desplazando un bit hacia la derecha, por

; la izquierda entrará un "0". Por ejemplo, si por el Puerto A se introduce "---11001",

; por el Puerto B aparecerá "0xxx1100".

; ZONA DE DATOS *********************************************************************

__CONFIG _CP_OFF & _WDT_OFF & _PWRTE_ON & _XT_OSC

LIST P=16F84A ; Procesador utilizado.

INCLUDE <P16F84A.INC> ; Definición de algunos operandos utilizados.

; ZONA DE CÓDIGOS ********************************************************************

ORG 0 ; El programa comienza en la dirección 0.

Inicio

bsf STATUS,RP0 ; Acceso al Banco 1.

clrf TRISB ; Las líneas del Puerto B se configuran como salida.

movlw b'00011111' ; Las 5 líneas del Puerto A se configuran como entrada.

movwf TRISA

bcf STATUS,RP0 ; Acceso al Banco 0.

Principal

bcf STATUS,C ; Este "0" es el que entrará por la izquierda.

rrf PORTA,W ; Rota los bits una posición a la derecha y lo

movwf PORTB ; lleva al Puerto B para que se visualice.

goto Principal ; Se crea un bucle cerrado e infinito.

24
 END ; Fin del programa.

; ===================================================================

; Creado por Oswaldo Franco Gomez

; Programación de sistemas embebidos

; Ingeniería robótica

; ===================================================================

ANEXO 10 Programa_elemental_09

;*********************************** Elemental_09.asm ***********************************

; Por el Puerto B se obtiene el dato del Puerto A invirtiendo los bits pares. Los impares

; se dejan como en la entrada.

; Por ejemplo, si por el Puerto A se introduce "---11001", por el Puerto B aparecerá

; "xxx01100". Observar que los bits pares están invertidos (efectivamente:

; Puerto A = "---1x0x1" y Puerto B = "xxxx0x1x0") y en los impares permanece el dato del

; puerto de entrada (efectivamente: Puerto A = "---x1x0x' y Puerto B = b'xxxx1x0x').

; ZONA DE DATOS *********************************************************************

__CONFIG _CP_OFF & _WDT_OFF & _PWRTE_ON & _XT_OSC

LIST P=16F84A ; Procesador utilizado.

INCLUDE <P16F84A.INC> ; Definición de algunos operandos utilizados.

Mascara EQU b'01010101' ; Máscara para invertir los bits pares mediante la

; función XOR con "1".

; ZONA DE CÓDIGOS ********************************************************************

ORG 0 ; El programa comienza en la dirección 0.

Inicio

bsf STATUS,RP0 ; Acceso al Banco 1.

clrf TRISB ; Las líneas del Puerto B se configuran como salida.

25
 movlw b'00011111' ; Las 5 líneas del Puerto A se configuran como entrada.

movwf TRISA

bcf STATUS,RP0 ; Acceso al Banco 0.

Principal

movf PORTA,W ; Carga el registro de datos del Puerto A en W.

xorlw Mascara ; Invierte los bits pares, dejando igual los impares.

movwf PORTB ; El resultado se visualiza por el puerto de salida.

goto Principal ; Se crea un bucle cerrado e infinito.

END ; Fin del programa.

; ===================================================================

; Creado por Oswaldo Franco Gomez

; Programación de sistemas embebidos

; Ingeniería robótica

ANEXO 11 Programa_elemental_10

;*********************************** Elemental_10.asm ***********************************

; Por el Puerto B se obtiene el dato de las cinco líneas del Puerto A al que están conectado

; un array de interruptores. Por ejemplo, si por el Puerto A se introduce "---11001", por

; el Puerto B aparecerá "xxx11001" (el valor de las tres líneas superiores no importa).

; Esta operación la realizará una única vez. Después el programa entrará en modo

; "Standby" o de bajo consumo del cual no podrá salir después.

; ZONA DE DATOS *********************************************************************

__CONFIG _CP_OFF & _WDT_OFF & _PWRTE_ON & _XT_OSC ; Configuración para el

; grabador.

LIST P=16F84A ; Procesador utilizado.

INCLUDE <P16F84A.INC> ; Definición de algunos operandos utilizados.

26
; ZONA DE CÓDIGOS ********************************************************************

ORG 0 ; El programa comienza en la dirección 0.

Inicio

bsf STATUS,RP0 ; Acceso al Banco 1.

clrf TRISB ; Las líneas del Puerto B configuradas como salida.

movlw b'00011111' ; Las 5 líneas del Puerto A configuradas como entrada.

movwf TRISA

bcf STATUS,RP0 ; Acceso al Banco 0.

Principal

movf PORTA,W ; Carga el registro de datos del Puerto A en W.

movwf PORTB ; El contenido de W se deposita en el Puerto B.

sleep ; El programa entra en modo "Bajo Consumo" del cual no

; podrá salir.

END ; Fin del programa.

; ===================================================================

; Creado por Oswaldo Franco Gomez

; Programación de sistemas embebidos

; Ingeniería robótica

; ===================================================================

27