Ver/Abrir - sistema integral académico curn

SOFTWARE COMPILADOR EN LENGUAJE DE ALTO NIVEL QUE GENERA
CÓDIGO ENSAMBLADOR PARA LA IMPLEMENTACIÓN EN
MICROCONTROLADORES PIC 16X
JULIÁN ROBERTO HERNÁNDEZ DÍAZ
JAVIER MEZA CARABALLO
CORPORACIÓN UNIVERSITARIA RAFAEL NÚÑEZ
FACULTAD DE INGENIERÍA DE SISTEMÁS
CARTAGENA DE INDIAS D.T. Y C., JUNIO DE 2005
SOFTWARE COMPILADOR EN LENGUAJE DE ALTO NIVEL QUE GENERA
CÓDIGO ENSAMBLADOR PARA LA IMPLEMENTACIÓN EN
MICROCONTROLADORES PIC 16X
JULIÁN ROBERTO HERNÁNDEZ DÍAZ
JAVIER MEZA CARABALLO
MONOGRAFÍA PARA OPTAR AL TÍTULO DE INGENIERO DE SISTEMÁS
DIRECTOR
LUIS FERNANDO MURRILLO
INGENIERO ELECTRICISTA
CORPORACIÓN UNIVERSITARIA RAFAEL NÚÑEZ
FACULTAD DE INGENIERÍA DE SISTEMÁS
CARTAGENA DE INDIAS D.T. Y C., JUNIO DE 2005
Dedico este proyecto a mis padres por brindarme su apoyo incondicional, a Adriana
Marimón por su compresión y apoyo en todos los momentos difíciles, y ante todo a
nuestro Dios Todopoderoso por darme la sabiduría necesaria para salir adelante. A
nuestro director Luis Murillo por su paciencia y dedicación con nosotros, a Maria
Claudia Bonfante y Justo Sarabia por su orientación
JULIÁN ROBERTO HERNÁNDEZ DÍAZ
Dedico este proyecto primero que todo a Dios todopoderoso por ser la fuente de
sabiduría y conocimientos, a mis padres Engelberto Meza y Maribel Caraballo por su
ayuda incondicional y esmero brindado para verme realizado como Ingeniero de
Sistemás, a mis hermanos Enilsa y Fredys Meza y además a mi novia Sandra Arroyo
Guerrero quienes me han motivado para poder lograr la culminación de este proyecto.
Gracias, muchísimás gracias le doy a mi Dios todopoderoso y a todas las personas que
me colaboraron en la obtención de esta meta propuesta en mi vida.
JAVIER MEZA CARABALLO
AGRADECIMIENTOS
Los autores expresan sus agradecimientos a:
Dios todopoderoso, quien nos brindo la fuente de conocimientos y sabiduría necesaria
para salir adelante con este proyecto de grado.
Luis Fernando Murillo, Ingeniero de Electricista y Director de esta Tesis, por su esmero
y dedicación para la finalización del proyecto, además por su valiosa orientación y
motivación constante.
Nuestro amigo e Ingeniero de Sistemás, Justo Sarabia, por su ayuda constante y asesoría
metodológica para poder concluir con este proyecto de forma adecuada.
Maria Claudia Bonfante, Ingeniera de Sistemás, por su motivación para que saliéramos
adelante y no desvaneciéramos en el camino y poder culminar este proyecto.
A nuestros padres por el apoyo brindado en los momentos difíciles y sus reconfortantes
esfuerzos para que no nos desvaneciéramos en este propósito de nuestras vidas.
En general a todas las personas que nos colaboraron y apoyaron en la realización de este
proyecto de grado.
¡Muchas Gracias a Todos!
NOTA DE ACEPTACIÓN
_________________________
_________________________
_________________________
_________________________
_________________________
_______________________________
JURADO
_______________________________
JURADO
_______________________________
PRESIDENTE DEL JURADO
CARTAGENA, D.T. Y C, JUNIO DE 2005
GLOSARIO
ALGORITMO: Es un conjunto finito de instrucciones o pasos que sirven para ejecutar
una tarea o resolver un problema. La palabra algoritmo deriva del nombre del
matemático árabe Al-Khwarizmi, que vivió entre los siglos VII y VIII.
ARCHIVOS PLANOS: Los archivos de texto son aquellos que están compuestos
únicamente por texto sin formato, sólo caracteres. Estos caracteres se pueden codificar
de distintos modos dependiendo de la lengua usada. Algunos de los sistemás de
codificación más usados son: ASCII, ISO-8859-1 o Latín-1, Unicode, etc.
Se les conoce también como archivos de texto plano por carecer de información
destinada a generar formatos y tipos de letra (por ejemplo, tipo de letra: Arial, Courier,
Times New Roman; formato: negritas, subrayado, cursivas; tamaño, etc.).
AUTÓMATA: Es un sistema secuencial. Un autómata finito o máquina de estado finito
es un modelo matemático de un sistema que recibe una cadena constituida por símbolos
de un alfabeto y determina si esa cadena pertenece al lenguaje que el autómata reconoce.
BIT (DÍGITO BINARIO): Acrónimo de Binary Digit (dígito binario), que adquiere el
valor 1 o 0 en el sistema numérico binario. En el procesamiento y almacenamiento
informático un bit es la unidad de información más pequeña manipulada por el
computador, y está representada físicamente por un elemento como un único pulso
enviado a través de un circuito, o bien como un pequeño punto en un disco magnético
capaz de almacenar un 0 o un 1.
BYTE: Unidad de información que consta de 8 bits; en procesamiento informático y
almacenamiento, el equivalente a un único carácter, como puede ser una letra, un
número o un signo de puntuación. Como el byte representa sólo una pequeña cantidad de
información, la cantidad de memoria y de almacenamiento de una máquina suele
indicarse en kilobytes (1.024 bytes), en megabytes (1.048.576 bytes) o en gigabytes
(1.024 megabytes).
CÓDIGO FUENTE: Programa en su forma original, tal y como fue escrito por el
programador, el código fuente no es ejecutable directamente por el computador, debe
convertirse en lenguaje de máquina mediante compiladores, ensambladores o intérpretes.
CÓDIGO MÁQUINA: Es aquel con el que trabaja el microprocesador; para reaccionar
y efectuar la operación que se desea, necesita de una secuencia de señales eléctricas
almacenadas como "unos" y "ceros" en las posiciones de la memoria. Una y sólo una
secuencia de señales concreta, realiza una determinada operación.
COMPILADOR: Programa de computadora que produce un programa en lenguaje de
máquina, de un programa fuente que generalmente esta escrito por el programador en un
lenguaje de alto nivel.
CONSTANTE: Valor o conjunto de caracteres que permanecen invariables durante la
ejecución de un programa, es decir, que no cambia su valor en dicha ejecución.
DIAGRAMA DE FLUJO: Es la representación gráfica de una secuencia de
instrucciones de un programa que ejecuta un computador para obtener un resultado
determinado.
EDITOR: Es un programa de computadora empleado para crear y manipular archivos
de texto existentes, tales como programas codificados en lenguajes fuentes, listas de
nombres y direcciones.
FUNCIÓN: En programación, una rutina que hace una tarea particular. Cuando el
programa pasa el control a una función, ésta realiza la tarea y devuelve el control a la
instrucción siguiente a la que llamo.
INSTRUCCIÓN O SENTENCIA: Conjunto de caracteres que se utilizan para dirigir
un sistema de procesamiento de datos en la ejecución de una operación.
INTERFAZ: Una conexión e interacción entre hardware, software y usuario, es decir, la
plataforma o el medio que permite la comunicación entre el usuario y los diferentes
programas.
INTÉRPRETE: Dispositivo o programa que recibe una por una las sentencias de un
programa fuente, la analiza y la convierte en lenguaje de máquina si no hay errores en
ella. También se puede producir el listado de las instrucciones del programa.
LENGUAJE DE ALTO NIVEL: Son lenguajes de programación como Basic, Pascal,
Ada, etc., ya que no están en contacto directo con la computadora, por lo que el
programador no necesita saber nada respecto a las operaciones a nivel de máquina del
sistema, tienen una ejecución más lenta y requieren más memoria.
LENGUAJE ENSAMBLADOR: Tipo de lenguaje de programación en que el conjunto
de instrucciones del microprocesador se representa por mnemónicos, en vez de dígitos
binarios o hexadecimales.
LENGUAJE MÁQUINA: Es una colección de instrucciones muy detalladas y crípticas
que controlan la circuiteria interna de la máquina.
LEXEMÁS: Relativo a tokens.
MICROCONTROLADOR: Un microcontrolador es un circuito integrado que incluye
todos (o casi) los componentes necesarios para tener un sistema de control completo.
PROGRAMA: Es una colección de instrucciones que indican a la computadora que
debe hacer. Un programa se denomina software, por lo tanto, programa, software e
instrucción son sinónimos.
PROGRAMA FUENTE: Instrucción escrita por el programador en un lenguaje de
programación para plantear al computador el proceso que debe ejecutar.
PROGRAMA ENSAMBLADOR: Es un programa de computador preparado por un
programador que toma las instrucciones que no estén en lenguaje de máquina y las
convierte en una forma que puede ser usada por el computador.
REGISTRO: Es un grupo de campos relacionados entre sí que se usan para almacenar
datos e información.
RUTINA: Es el conjunto de instrucciones dentro del mismo programa, que se puede
llamar a ejecución desde diferentes partes del mismo programa.
TOKENS: Hace alusión a las unidades más simples que tiene significado.
Habitualmente un token o lexema queda descrito por una expresión regular.
VARIABLE: En programación es una estructura que contiene datos y recibe un nombre
único dado por el programador, mantiene los datos asignados a ella hasta que un nuevo
valor se le asigne o hasta que el programa termine.
LISTA DE FIGURAS
Pág.
Figura No. 1.1: Fases de un procesador de lenguaje ...................................................... 18
Figura No. 1.2: Reconocimiento de lexema ................................................................... 19
Figura No. 2.1: Pantalla de entrada datos del primer ciclo ............................................ 25
Figura No. 2.2: Formulario de lexemas y variables ....................................................... 26
Figura No. 2.3: Pantalla de entrada datos del segundo ciclo .......................................... 28
Figura No. 2.4: Caja de visualización de errores ............................................................ 28
Figura No. 2.5: Salida generada por el sistema .............................................................. 31
Figura No. 5.1: Código fuente de la evaluación No. 1. Prueba1.pic .............................. 65
Figura No. 5.2: Código ensamblador de la evaluación No. 1. Prueba1.asm .................. 67
Figura No. 5.3: Código fuente de la evaluación No. 2. Prueba2.pic .............................. 68
Figura No. 5.4: Código fuente de la evaluación No. 3. Prueba3.pic .............................. 69
Figura No. 5.5: Código ensamblador de la evaluación No. 3. Prueba3.asm .................. 70
Figura No. 5.6: Código fuente de la evaluación No. 4. Prueba4.pic .............................. 71
Figura No. 5.7: Código fuente de la evaluación No. 5. Prueba5.pic .............................. 72
Figura No. 5.8: Código fuente de la evaluación No. 6. Prueba6.pic .............................. 73
Figura No. 5.9: Código ensamblador de la evaluación No. 6. Prueba6.asm .................. 75
Figura No. 5.10: Código fuente de la evaluación No. 7. Prueba7.pic …………..…….. 76
Figura No. 5.11: Código fuente de la evaluación No. 8. Prueba8.pic ……………..….. 77
Figura No. 5.12: Código ensamblador de la evaluación No. 8. Prueba8.asm ..……….. 79
Figura No. 5.13: Mensaje de salida en MPLAB mostrando compilación satisfactoria . 80
Figura No. 6.1: Autómata de números decimales y hexadecimales ............................... 81
Figura No. 6.2: Autómata de identificadores ................................................................. 82
Figura No. 6.3: Autómata de operadores lógicos ........................................................... 82
Figura No. 6.4: Autómata que evalúa una condición ..................................................... 83
Figura No. 6.5: Autómata de etiquetas ........................................................................... 83
Figura No. 6.6: Autómata de cadena de caracteres ........................................................ 84
Figura No. 6.7: Autómata que valida los comentarios ................................................... 84
Figura No. 6.8: Autómata instrucción branch ................................................................ 85
Figura No. 6.9: Autómata instrucción count .................................................................. 86
Figura No. 6.10: Autómata instrucción debug ............................................................... 87
Figura No. 6.11: Autómata instrucción end ................................................................... 87
Figura No. 6.12: Autómata instrucción exit ................................................................... 88
Figura No. 6.13: Autómata del cic lo for...next ............................................................... 89
Figura No. 6.14: Autómata instrucción gosub ................................................................ 90
Figura No. 6.15: Autómata instrucción goto .................................................................. 90
Figura No. 6.16: Autómata instrucción high .................................................................. 91
Figura No. 6.17: Autómata del condicional if…then…elseif…endif ............................ 92
Figura No. 6.18: Autómata instrucción input ................................................................. 93
Figura No. 6.19: Autómata instrucción low ................................................................... 93
Figura No. 6.20: Autómata instrucción output ............................................................... 94
Figura No. 6.21: Autómata instrucción pause ................................................................ 94
Figura No. 6.22: Autómata instrucción random ............................................................. 95
Figura No. 6.23: Autómata instrucción read .................................................................. 96
Figura No. 6.24: Autómata instrucción return ................................................................ 96
Figura No. 6.25: Autómata instrucción sleep ................................................................. 97
Figura No. 6.26: Autómata instrucción write ................................................................. 97
Figura No. 6.27: Pseudocódigo de instrucciones que comienzan con la letra G ............ 99
Figura No. 6.28: Pseudocódigo de instrucciones que comienzan con la letra R .......... 101
LISTA DE TABLAS
Pág.
Tabla No. 1: Proceso de abstracción de datos ................................................................ 39
Tabla No. 2: Especificación del proceso MicroPic versión 1.0 ..................................... 40
Tabla No. 3: Especificación del proceso análisis léxico ................................................ 41
Tabla No. 4: Especificación del proceso análisis sintáctico ........................................... 42
Tabla No. 5: Especificación del proceso análisis semántico .......................................... 43
Tabla No. 6: Especificación del proceso generador de código ensamblador ................. 44
Tabla No. 7: Almacén de abstracción de datos .............................................................. 44
Tabla No. 8: Especificación almacén de MicroPic versión 1.0 ..................................... 45
Tabla No. 9: Especificación almacén de análisis léxico ................................................ 45
Tabla No. 10: Especificación almacén de análisis sintáctico ........................................ 46
Tabla No. 11: Especificación almacén análisis semántico ............................................ 46
Tabla No. 12: Interfaz de abstracción de datos .............................................................. 47
Tabla No. 13: Especificación de Interfaz de MicroPic Versión 1.0 .............................. 47
Tabla No. 14: Flujos de datos de abstracción de datos .................................................. 49
Tabla No. 15: Especificación de flujos de datos de MicroPic versión 1.0 .................... 51
Tabla No. 16: Especificación de flujos de datos de análisis léxico ............................... 52
Tabla No. 17: Especificación de flujos de datos de análisis sintáctico ......................... 53
Tabla No. 18: Especificación de flujos de datos de análisis semántico ........................ 53
Tabla No. 19: Especificación de flujos de datos de generador de código ensamblador 54
Tabla No. 20: Componentes léxicos, lexemas y patrones ............................................. 60
Tabla No. 21: Palabras reservadas con su descripción .................................................. 63
LISTA DE DIAGRAMÁS
Pág.
Diagrama 1: Nivel 0 general de abstracción general de datos ........................................ 33
Diagrama 2: Nivel 1 especificación del proceso MicroPic versión 1.0 ......................... 34
Diagrama 3: Nivel 2 especificación del proceso análisis léxico .................................... 35
Diagrama 4: Nivel 3 especificación del proceso análisis sintáctico ............................... 36
Diagrama 5: Nivel 4 especificación del proceso análisis semántico .............................. 37
Diagrama 6: Nivel 5 especificación del proceso generador de código ensamblador ..... 38
Diagrama 7: Autómata de instrucciones que comienzan con la letra G ......................... 98
Diagrama 8: Autómata de instrucciones que comienzan con la letra R ....................... 100
LISTA DE ANEXOS
Pág.
Anexo A: Manual de Usuario de MicroPic Versión 1.0 .............................................. 105
Anexo B: Manual de Sistema de MicroPic Versión 1.0 .............................................. 131
Anexo C: Juego de Instrucciones ................................................................................ 158
Anexo D: Autómatas, Pseudocódigos y Diagramas de Flujos de las Instrucciones en
Ensamblador ............................................................................................... 189
TABLA DE CONTENIDO
Pág.
INTRODUCCIÓN
EL PROBLEMA Y OBJETIVOS DE LA INVESTIGACIÓN ....................................... 2
ANTECEDENTES DEL PROBLEMA ........................................................................... 2
PLANTEAMIENTO DEL PROBLEMA ......................................................................... 3
JUSTIFICACIÓN DEL PROBLEMA ............................................................................. 4
OBJETIVOS DE LA INVESTIGACIÓN ........................................................................ 5
Objetivo General .............................................................................................................. 5
Objetivos Específicos ........................................................................................................ 5
METAS DE LA INVESTIGACIÓN ................................................................................ 6
PRODUCTO DE LA INVESTIGACIÓN ........................................................................ 6
ESTRATEGIAS METODOLÓGICAS ............................................................................ 7
CLASE O MODALIDAD DE LA INVESTIGACIÓN ................................................... 7
MARCO TEÓRICO ......................................................................................................... 7
MARCO CONCEPTUAL ................................................................................................ 8
1. COMPILADOR MICROPIC ................................................................................... 13
1.1 DEFINICIÓN ......................................................................................................... 13
1.2 RESEÑA HISTÓRICA .......................................................................................... 13
1.3 COMPILADOR VS INTÉRPRETE ...................................................................... 14
1.3.1 Ventajas de Compilar Frente a Interpretar .......................................................... 14
1.3.2 Ventajas del Intérprete Frente al Compilador ..................................................... 14
1.4 CLASIFICACIÓN DE COMPILADORES ........................................................... 14
1.5 FUNCIONES DE UN COMPILADOR ................................................................. 15
1.6 PARTES EN LA QUE TRABAJA UN COMPILADOR ...................................... 16
1.6.1 Fase de Análisis ................................................................................................... 17
1.6.1.1 Funciones del Analizador Léxico ..................................................................... 20
1.6.2 Fase de Síntesis .................................................................................................... 22
2. ANÁLISIS, DISEÑO Y DESARROLLO DE SOFTWARE MICROPIC ............... 23
2.1 REQUERIMIENTOS ............................................................................................. 23
2.2 MODELO DE DESARROLLO DEL SOFTWARE .............................................. 23
2.2.1 Etapas del Modelo del Prototipo ........................................................................... 24
2.3 ESPECIFICACIÓN DE REQUERIMIENTOS ..................................................... 32
2.4 DISEÑOS DE PROCESOS .................................................................................... 33
2.4.1 Nivel 0 ................................................................................................................. 33
2.4.2 Nivel 1 ................................................................................................................. 34
2.4.3 Nivel 2 ................................................................................................................. 35
2.4.4 Nivel 3 ................................................................................................................. 36
2.4.5 Nivel 4 ................................................................................................................. 37
2.4.6 Nivel 5 ................................................................................................................. 38
2.5 DICCIONARIO DE DATOS ................................................................................. 39
2.5.1 Procesos ............................................................................................................... 39
2.5.2 Almacén de Datos ................................................................................................ 44
2.5.3 Interfaz ................................................................................................................. 46
2.5.4 Flujos de Datos .................................................................................................... 48
3. REQUERIMIENTOS GENERALES DE MICROPIC ............................................ 55
3.1 EVOLUTIVIDAD Y FLEXIBILIDAD ................................................................. 55
3.2 MANTENIBILIDAD Y REPARABILIDAD ........................................................ 56
3.3 AMIGABILIDAD .................................................................................................. 56
3.4 PORTABILIDAD ................................................................................................... 57
3.5 BONDAD ............................................................................................................... 58
4. COMPONENTES LÉXICOS E INSTRUCCIONES MICROPIC .......................... 59
4.1 COMPONENTES LÉXICOS ................................................................................. 59
4.2 INSTRUCCIONES ................................................................................................. 60
5. EVALUACIÓN DEL SISTEMA MICROPIC V 1.0 ............................................... 64
5.1 EVALUACIÓN No. 1 ............................................................................................ 65
5.2 EVALUACIÓN No. 2 ............................................................................................ 67
5.3 EVALUACIÓN No. 3 ............................................................................................ 69
5.4 EVALUACIÓN No. 4 ............................................................................................ 70
5.5 EVALUACIÓN No. 5 ............................................................................................ 72
5.6 EVALUACIÓN No. 6 ............................................................................................ 73
5.7 EVALUACIÓN No. 7 ............................................................................................ 76
5.7 EVALUACIÓN No. 8 ............................................................................................ 77
6. AUTÓMATAS FORMATOS Y SINTAXIS DE PROGRAMACIÓN ………....... 81
6.1. AUTÓMATA PARA NÚMEROS …….…………………………..……………. 81
6.2. AUTÓMATA PARA IDENTIFICADOR …………………………………...….. 81
6.3. AUTÓMATA PARA OPERADORES RELACIONALES ………......……….... 82
6.4. AUTÓMATA PARA CONDICIÓN ……………………………...…………….. 83
6.5. AUTÓMATA PARA ETIQUETA ……………………………………..……….. 83
6.6. AUTÓMATA PARA CADENA DE CARACTERES ……………………….…. 83
6.7. AUTÓMATA PARA ESPACIOS EN BLANCO ……………………...……….. 84
6.8. FUNCIÓN BRANCH …...…………...…………...….………...………...…....… 85
6.9. FUNCIÓN COUNT …...…………...…………...…………...……………...…… 85
6.10. FUNCIÓN DEBUG …...…………...…………...…………...………….....…… 86
6.11. FUNCIÓN END ………………...………..……………………………..…....... 87
6.12. FUNCIÓN EXIT …………………………………………………………...….. 88
6.13. FUNCIÓN FOR…NEXT ……………..…………………….………….…...…. 88
6.14. FUNCIÓN GOSUB …...…………...…………...…………...…………...…..… 89
6.15. FUNCIÓN GOTO …...…………...…..……...…………...…………...……..… 90
6.16. FUNCIÓN HIGH …...…………...………...…………...…………......……..… 90
6.17. FUNCIÓN IF…THEN…ELSEIE…ENDIF ………..…………………...…..… 91
6.18. FUNCIÓN INPUT …...…………...…………...…………...…………...…….... 92
6.19. FUNCIÓN LOW …...…………...…………...…………...…………...…...…... 93
6.20. FUNCIÓN OUTPUT …...…………...…………...…………...………….......… 93
6.21. FUNCIÓN PAUSE …...…………...…………...…………...…………...…...… 94
6.22. FUNCIÓN RANDOM …...…………...…………...…………...………….....… 95
6.23. FUNCIÓN READ …...…………...…………...…………...………….....…..… 95
6.24. FUNCIÓN RETURN………………...……………….………………….....….. 96
6.25. FUNCIÓN SLEEP ………...…….……...…………...…………...…………...... 96
6.26. FUNCIÓN WRITE …...…………...…………...…………...…………....…..… 97
6.27. AUTÓMATA Y PSEUDOCÓDIGO QUE PERMITE EVALUAR LAS
INSTRUCCIONES (GOSUB, GOTO)…...….………...…………...…...…..… 98
6.28 AUTÓMATA Y PSEUDOCÓDIGO QUE PERMITE EVALUAR LAS
INSTRUCCIONES (RANDOM, READ, RETURN)…...…….……...……… 100
RECOMENDACIONES............................................................................................... 102
CONCLUSIONES......................................................................................................... 103
BIBLIOGRAFÍA........................................................................................................... 104
INTRODUCCIÓN
Los microcontroladores hoy en día están conquistando el mundo, los encontramos
presentes en nuestro trabajo, en nuestra casa y en nuestra vida, en general, se pueden
encontrar controlando el funcionamiento de los ratones y teclados de los computadores,
en los teléfonos, en los hornos microondas y los televisores de nuestro hogar. Pero la
invasión acaba de comenzar y el nacimiento del siglo XXI será testigo de la conquista
masiva de estos diminutos computadores, que gobernarán la mayor parte de los aparatos
que se fabrican actualmente y que usamos los humanos.
En este proyecto se pretende desarrollar un Compilador de Lenguaje de Programación
de Alto Nivel que Genera Código Ensamblador para la Implementación de un
Microcontrolador PIC de la Familia 16, brindado así la posibilidad a la comunidad
académica e industrial de disponer de esta herramienta a un bajo costo. De igual forma
haciéndonos participes a la solución del problema del poco desarrollo e implementación
de este tipo de herramientas en nuestro país.
EL PROBLEMA Y OBJETIVOS DE LA INVESTIGACIÓN
ANTECEDENTES DEL PROBLEMA
En el mundo se destacan programas compiladores para microcontroladores PIC como
Basic Stamp, el cual tiene sus antecedentes desde 1979, su creador Chip Gracey tuvo sus
primeras experiencias en programación en las computadoras Apple II. Su entusiasmo en
el Basic de Apple fue tal que fue más allá de los experimentos normales pasando a
ensayar con interfases a circuitos de electrónica.
El Basic Stamp BS2-IC, El BS2-IC se encuentra en una presentación de tableta de
ensamble de 24 pines, igual a un circuito integrado Dual-In- line, en la cual la tableta de
ensamble esta presente en configuración de 40 pines. 1
El Compilador PicBasic Pro (PBP) produce código que puede ser programado para una
variedad de microcontroladores PIC que tengan de 8 a 68 pins y varias opciones en el
chip incluyendo convertidores A/D, temporizadores y puertos seriales.
Hay algunos micros PIC que no trabajaran con el PBP, por ejemplo las series PIC
16C5X incluyendo el PIC 16C54 Y PIC 15C58. Estos micro PIC están basados en el
viejo núcleo de 12 bit en lugar del núcleo más corriente de 14 bit. El PBP necesita
alguna de las opciones que solamente están disponibles con el núcleo de 14 bit como el
stack (pila) de 8 niveles.
1
http://www.todopic.com.ar/pbp_sp.html#LOS_MICROS
2
Para propósitos generales de desarrollo usando el PBP, el PIC16F84 o PIC16C84 es la
elección común de micro PIC. Este microcontrolador de 18 pin usa tecnología flash para
el PIC16F84 y EEPROM para PIC16C84, para permitir un rápido borrado y
reprogramación para acelerar la depuración de programas. Con el clic de un mouse en el
software, el PIC16F84 puede ser borrado instantáneamente y luego ser reprogramado
una y otra vez.
El PIC16F84 y PIC16C84 además, contiene 64 bytes de memoria de datos no volátil que
puede ser usada para archivar los datos de programa y otros parámetros, aun cuando no
haya energía. A ésta área de datos, se puede acceder simplemente usando las órdenes
“Read” y “Write” del PBP. (El código programa es permanent emente guardado en el
espacio de código del micro PIC, tanto si hay o no energía). 2
PLANTEAMIENTO DEL PROBLEMA
En los últimos años los microcontroladores han tenido una gran aceptación y han sido
adoptados en una gran variedad de aplicaciones de control. La mayoría de los
electrodomésticos están implementados a partir microcontroladores. A pesar de esto, en
nuestro país no existe un software compilador en lenguajes de alto nivel para el
microcontrolador PIC que sea económico, flexible y de entorno muy amigable.
Cada vez existen más productos que incorporan un microcontrolador con el fin de
aumentar sustancialmente sus prestaciones, reducir su tamaño y coste, mejorar su
fiabilidad y disminuir el consumo. Los microcontroladores están siendo empleados en
multitud de sistemas presentes en nuestra vida diaria, como pueden ser juguetes, hornos
2
http://www.todopic.com.ar/pbp_sp.html#LOS_MICROS
3
microondas, frigoríficos, televisores, computadoras, impresoras, módems, el sistema de
arranque de automóviles, etc. Y otras aplicaciones con las que seguramente no
estaremos tan familiarizados como instrumentación electrónica, control de sistemas en
una nave espacial, etc. Una aplicación típica podría emplear varios microcontroladores
para controlar pequeñas partes del sistema. Estos pequeños controladores podrían
comunicarse entre ellos y con un procesador central, probablemente más potente, para
compartir la información y coordinar sus acciones, como de hecho, ocurre ya
habitualmente en cualquier PC.
JUSTIFICACIÓN DEL PROBLEMA
Hoy en día la oportunidad de adquirir un compilador para la implementación de un
microcontrolador PIC Familia 16 se hace costosa para el usuario promedio, dado que los
precios que se manejan en el mercado actual son demasiado altos. Por ejemplo, una
empresa industrial, centro de investigación o educación, que requiera de la
implementación de un compilador para un microcontrolador PIC debería pagar alrededor
de 200 Euros para una familia determinada de microprocesadores como la familia 16;
pero dado que más adelante se haga necesario la utilización de un microcontrolador el
cual no pertenezca a la familia de microprocesadores anteriormente adquirida, tendría
que cancelar nuevamente 200 Euros lo cual corresponde al valor de la nueva licencia.
En el mercado se encuentra una gran variedad de traductores que generan código
ensamblador para implementar un microcontroladores PIC 16, pero con precios muy
elevados, por ende se hace necesario que los Ingenieros de Sistemas participen de
manera activa en la creación e implementación de nuevos Programas Compiladores para
Microcontroladores con la finalidad de reducir los costos, dado que para nuestro país se
4
hace muy difícil invertir en sistemas de manejo de microcontroladores, debido que no se
posee una buena infraestructura económica.
OBJETIVOS DE LA INVESTIGACIÓN
Objetivo General:
Diseñar e implementar un compilador en lenguaje de programación de alto nivel que
permita generar código ensamblador para la implementación en microcontroladores PIC
de la familia 16.
Objetivos Específicos:
•
Llevar a cabo una investigación sobre el lenguaje ensamblador y máquina de los
microcontroladores PIC.
•
Investigar sobre los compiladores existentes.
•
Seleccionar la mejor herramienta de programación para el desarrollo del
software.
•
Diseñar el software.
•
Implementar y poner en marcha el software compilador de lenguaje de alto nivel.
5
METAS DE LA INVESTIGACIÓN
Basados en los conocimientos adquiridos como estudiante durante el desarrollo de la
carrera de Ingeniería de Sistemas, y las investigaciones realizadas ayudarán a la
consecución del objetivo general de esta investigación. De tal manera que sea un
verdadero soporte, como medio de consulta, para futuras investigaciones en el tema.
PRODUCTO DE LA INVESTIGACIÓN
Al término del desarrollo del proyecto se entregarán los resultados esperados los cuales
estarán conformados de la siguiente manera:
•
Software compilador de lenguaje de alto nivel para implementación un
microcontrolador de la familia PIC 16.
•
Manual de usuario.
•
Manual de sistemas.
•
CD-ROM el cual contendrá la documentación escrita y el software.
6
ESTRATEGIAS METODOLÓGICAS
CLASE O MODALIDAD DE LA INVESTIGACIÓN
La modalidad de investigación esta centrada en la Investigación Tecnológica Aplicada,
teniendo en cuenta que realizaremos énfasis en Ingenie ría de software.
MARCO TEÓRICO
Un microcontrolador es un circuito integrado de alta escala de integración que incorpora
la mayor parte de los elementos que configuran un controlador.
Un microcontrolador dispone normalmente de los siguientes componentes:
•
Procesador o UCP (Unidad Central de Proceso).
•
Memoria RAM para Contener los datos.
•
Memoria para el programa tipo ROM / PROM / EEPROM.
•
Líneas de E / S para comunicarse con el exterior.
•
Diversos módulos para el control de periféricos (Temporizadores, Puertas Serie y
Paralelo, CAD: Conversores Analógico / Digital, CDA: Conversores Digital /
Analógico, etc.).
•
Generador de impulsos de reloj que sincronizan el funcionamiento de todo el
sistema.
El microcontrolador es en definitiva un circuito integrado que incluye todos los
componentes de un computador. Debido a su reducido tamaño es posible montar el
7
controlador en el propio dispositivo al que gobierna. En este caso el controlador recibe el
nombre de controlador empotrado (embedded controller).
En cuanto a las técnicas de fabricación, cabe decir que prácticamente la totalidad de los
microcontroladores actuales se fabrican con tecnología CMOS 4 (Complementary Metal
Oxide Semiconductor). Esta tecnología supera a las técnicas anteriores por su bajo
consumo y alta inmunidad al ruido.
El MPLAB es un software que junto con un emulador y un programador de los múltiples
que existen en el mercado, forman un conjunto de herramientas de desarrollo muy
completo para el trabajo y/o el diseño con los microcontroladores PIC desarrollados y
fabricados por la empresa Arizona Microchip Technology (AMT).
El MPLAB incorpora todas las utilidades necesarias para la realización de cualquier
proyecto y, para los que no dispongan de un emulador, este programa permite editar el
archivo fuente en lenguaje ensamblador, además de ensamblarlo y simularlo en pantalla,
pudiendo ejecutarlo posteriormente en modo paso a paso y ver como evolucionarían de
forma real tanto sus registros internos, la memoria RAM y/o EEPROM de usuario como
la memoria de programa, según se fueran ejecutando las instrucciones. Además el
entorno que se utiliza es el mismo que si se estuviera utilizando un emulador. 3
MARCO CONCEPTUAL
•
PIC
(Microchip):
Los
microcontroladores
PIC
fueron
los
primeros
microcontroladores RISC, RISC generalmente implica que la simplicidad de diseño
3
www.solaris -digital.com/imagenes/mplab%20capitulo1.pdf
8
permite añadir más características a bajo precio y la línea PIC no es una excepción.
Aunque tiene pocas instrucciones (33 instrucciones el 16C5X mientras que el Intel
8048 tiene más de 90), la línea PIC tiene las características siguientes:
1. Buses de instrucciones y datos separados (arquitectura Harvard) lo que permite
el acceso simultáneo a las instrucciones y a los datos, y el solapamiento de
algunas operaciones para incrementar las prestaciones de proceso.
2. El beneficio de su diseño tan sencillo es que:
•
a.
El chip es pequeño.
b.
Pocas pastillas.
c.
Muy bajo consumo.
Microcontrolador: Un microcontrolador es un circuito integrado que incluye todos
(o casi) los componentes necesarios para tener un sistema de control completo. Los
microcontroladores incluyen típicamente: CPU, RAM, EEPROM / PROM / ROM,
I/O (input / output) serie y paralelo, Temporizadores / contadores, Sistema de
interrupciones. Los modelos más potentes incluyen además, Sistemas auxiliares (A /
D, D / A, dsp.).
Entre sus aplicaciones podemos mencionar:
Los microcontroladores frecuentemente se encuentran en:
− Aparatos
Electrodomésticos:
Microondas,
Hornos,
Frigoríficos,
Televisores, Vídeos, Equipos de sonido.
− Equipos Informáticos: Impresoras, Copiadoras láser, Módems, Unidades
de disco.
9
− Automóviles: Mando de sistemas del automóvil (ABS, Inyección,
Encendido.), Diagnósticos, Climatizador.
− Mando medioambiental: Invernadero, Fábrica, Casa.
•
Lenguaje de Alto Nivel: Son lenguajes de programación como Basic, Pascal, Ada,
etc. ya que no están en contacto directo con la computadora, por lo que el
programador no necesita saber nada respecto a las operaciones en el ámbito de
máquina del sistema. Una instrucción sencilla en un lenguaje de alto nivel podría
necesitar una página de instrucciones en lenguaje ensamblador para realizarse, pero
el programador del lenguaje de alto nivel no requiere conocer esto. Los lenguajes de
alto nivel son mucho más fáciles de usar que los lenguajes ensamblador y de
máquina; pero en general, tienen una ejecución más lenta y requieren más memoria.
La mayoría de los lenguajes de alto nivel son lenguajes de propósito general como
Pascal, Cobol, etc., pero hay también lenguajes de propósito especial, sus
instrucciones están diseñadas especialmente para algún tipo particular de aplicación
como por ejemplo: GPSS y CSMP, que son lenguajes orientados a la simulación. El
uso de un lenguaje de alto nivel ofrece tres ventajas importantes respecto al lenguaje
máquina; llamadas sencillez, uniformidad y portabilidad (independencia de la
máquina).
•
La Instrumentación y Sistemas Aerospaciales: Los microcontroladores se usan
típicamente donde la potencia de procesamiento no es importante, aunque alguien
podría encontrar atractiva la idea de controlar un horno microonda con un sistema
Unix.
10
Los sistemas basados en microprocesador y los microcontroladores se usan
extensivamente en robótica. En esta aplicación, muchas tareas específicas podrían estar
distribuidas entre un gran número de controladores dentro de un sistema. Estos
pequeños controladores pueden estar comunicados con un procesador central (o micro /
mini / mainframe), este habilitaría la información para ser procesado por la
computadora central, o para ser pasado a otros cont roladores en el sistema.
Una aplicación especial de los microcontroladores es la captura de datos: Temperatura,
humedad, lluvia, etc.
El tamaño de los microcontroladores es pequeño y consumen muy poco, esto los hace
ideales para sistemas portátiles y autónomos.
•
Lenguaje Ensamblador: El lenguaje máquina es la representación del programa tal
como la entiende el microcontrolador.
El lenguaje ensamblador es una representación alfanumérica del lenguaje máquina,
lo que facilita su lectura. Cada instrucción en lenguaje ensamblador corresponde a
una instrucción en código máquina (sin tener en cuenta macros ni directivas).
Un programa en lenguaje ensamblador es rápido y corto. Esto es porque el
programador genera el código más óptimo posible, el programador se adapta al
microcontrolador.
•
Lenguaje Máquina: Es una colección de instrucciones muy detalladas y crípticas
que controlan la circuiteria interna de la máquina. Muy pocos programas se escriben
actualmente en lenguaje máquina por dos razones importantes:
11
Primero, por que el lenguaje máquina es muy incomodo para trabajar, y Segundo,
por que la mayoría de las máquinas tienen sus repertorios de instrucciones propios.
Así un programa escrito en lenguaje máquina para una computadora no puede ser
ejecutado en otra de distinto tipo sin modificaciones importantes.
•
Registros: Los registros son áreas especiales de memoria, en los que se almacena la
instrucción que se va a ejecutar, así como toda la información necesaria para ello.
Hay registros de diferentes tipos,
cada uno de los cuales realizan distintas
funciones.
•
Compilador: Un compilador no es un programa que funciona de manera aislada,
sino que necesita de otros programas para conseguir su objetivo, el cual es obtener
un programa ejecutable a partir de un programa fuente en un lenguaje de alto nivel.
Algunos de esos programas son el preprocesador, el linker, el depurador y el
ensamblador. El preprocesador se ocupa (dependiendo del lenguaje) de incluir
ficheros, expandir macros, eliminar comentarios, y otras tareas similares. El linker se
encarga de construir el fichero ejecutable añadiendo al fichero objeto generado por el
compilador las cabeceras necesarias y las funciones de librería utilizadas por el
programa fuente. El depurador permite, si el compilador ha generado adecuadamente
el programa objeto, seguir paso a paso la ejecución de un programa. Finalmente,
muchos compiladores, en vez de generar código objeto, generan un programa en
lenguaje ensamblador que debe después convertirse en un ejecutable mediante un
programa ensamblador.
12
1. COMPILADOR MICROPIC
1.1.
DEFINICIÓN
Un traductor o compilador es cualquier programa que toma como entrada un texto
escrito en un lenguaje, llamado fuente y da como salida un programa en un lenguaje,
denominado objeto.
En el caso de que el lenguaje fuente sea un lenguaje de programación de alto nivel y el
objeto sea un lenguaje de bajo nivel (ensamblador o código de máquina), a dicho
traductor se le denomina compilador. Un ensamblador es un compilador cuyo lenguaje
fuente es el lenguaje ensamblador. Un intérprete no genera un programa equivalente,
sino que toma una sentencia del programa fuente en un lenguaje de alto nivel y la
traduce al código equivalente y al mismo tiempo lo ejecuta.
1.2.
RESEÑA HISTÓRICA
Históricamente, con la escasez de memoria de los primeros computadores, se puso de
moda el uso de intérpretes frente a los compiladores, pues el programa fuente sin
traducir y el intérprete, estos dos juntos dan una ocupación de memoria menor que la
resultante de los compiladores. Por ello los primeros computadores personales iban
siempre acompañados de un intérprete de BASIC (Spectrum, Commodore VIC-20, PC
XT de IBM, etc.). La mejor información sobre los errores por parte del compilador así
como una mayor velocidad de ejecución del código resultante hizo que poco a poco se
impusieran los compiladores. Hoy en día, y con el problema de la memoria
13
prácticamente resuelto, se puede hablar de un gran predominio de los compiladores
frente a los intérpretes, aunque intérpretes como los incluidos en los navegadores de
Internet para interpretar el código JVM de Java son la gran excepción.
1.3.
COMPILADOR VS INTÉRPRETE
1.3.1. Ventajas de Compilar Frente a Interpretar
•
Se compila una vez, se ejecuta n veces.
•
En bucles, la comp ilación genera código equivalente al bucle, pero interpretándolo
se traduce tantas veces una línea como veces se repite el bucle.
•
El compilador tiene una visión global del programa, por lo que la información de
mensajes de error es más detallada.
1.3.2. Ventajas del Intérprete Frente al Compilador
•
Un intérprete necesita menos memoria que un compilador. En principio eran más
abundantes dado que los computadores tenían poca memoria.
•
1.4.
Permiten una mayor interactividad con el código en tiempo de desarrollo.
CLASIFICACIÓN DE COMPILADORES
El programa compilador traduce las instrucciones en un lenguaje de alto nivel a
instrucciones que la computadora puede interpretar y ejecutar. Para cada lenguaje de
programación se requiere un compilador separado. El compilador traduce todo el
14
programa antes de ejecutarlo. Los compiladores son, pues, programas de traducciones,
que están insertados en la memoria por el sistema operativo para convertir programas de
cómputo en pulsaciones electrónicas ejecutables (lenguaje de máquina). Los
compiladores pueden ser de:
•
Una sola pasada.
•
Pasadas múltiples.
•
Optimación.
•
Compiladores increméntales.
•
Ensamblador.
•
Compilador cruzado.
•
Compilador con montador.
•
Autocompilador.
•
Metacompilador.
•
Descompilador.
1.5.
FUNCIONES DE UN COMPILADOR
A grandes rasgos un compilador es un programa que lee un programa escrito en un
lenguaje, el lenguaje fuente, y lo traduce a un programa equivalente en otro lenguaje, el
lenguaje objeto. Como parte importante de este proceso de traducción, el compilador
informa a su usuario de la presencia de errores en el programa fuente.
A primera vista, la diversidad de compiladores puede parecer abrumadora. Hay miles de
lenguajes fuentes, desde los lenguajes de programación tradicionales, como FORTRAN
o Pascal, hasta los lenguajes especializados que han surgido virtualmente en todas las
áreas de aplicación de la informática. Los lenguajes objeto son igualmente variados; un
15
lenguaje objeto puede ser otro lenguaje de programación o el lenguaje de máquina de
cualquier computador entre un microprocesador y un supercomputador. A pesar de
existir una aparente complejidad por la clasificación de los compiladores, como se vio
anteriormente, las tareas básicas que debe realizar cualquier compilador son
esencialmente las mismas. Al comprender tales tareas, se pueden construir compiladores
para una gran diversidad de lenguajes fuente y objeto utilizando las mismas técnicas
básicas.
Nuestro conocimiento sobre cómo organizar y escribir compiladores ha aumentado
mucho desde que comenzaron a aparecer los primeros compiladores a principios de los
años cincuenta. Es difícil dar una fecha exacta de la aparición del primer compilador,
porque en un principio gran parte del trabajo de experimentación y aplicación se realizó
de manera independiente por varios grupos. Gran parte de los primeros trabajos de
compilación estaba relacionada con la traducción de fórmulas aritméticas a código de
máquina.
1.6.
PARTES EN LAS QUE TRABAJA UN COMPILADOR
Un procesador de lenguaje esta compuesto por dos módulos: análisis y síntesis, ver
Figura No. 1.1. El módulo de análisis tiene tres fases: Análisis Léxico, Sintáctico y
Semántico. El módulo de síntesis también tiene tres fases: Generación de Código
Intermedio, y en el caso de los compiladores Generación de Código y Optimización de
Código. Los intérpretes toman el código intermedio y lo ejecutan directamente.
El módulo de análisis verifica si el programa en lenguaje fuente es correcto, y recoge la
información necesaria en las tablas de símbolos para el módulo de síntesis. En el caso de
16
que el módulo de análisis detecte la existencia de errores en el programa fuente, se
envían los mensajes correspondientes al usuario por medio del manejador de errores. Las
fases de un procesador de lenguaje tamb ién se pueden clasificar en front-end y back-end,
según la independencia de la máquina para la cual se produce el código.
1.6.1. Fase de Análisis
•
En el llamado análisis lexicográfico o léxico, el compilador revisa y controla que las
“palabras” estén bien escritas y pertenezcan a algún tipo de token (cadena) definido
dentro del lenguaje, como por ejemplo, que sea algún tipo de palabra reservada, o si
es el nombre de una variable que este escrita de acuerdo a las pautas de definición
del lenguaje. En esta etapa se crea la tabla de símbolos, la cual contiene las variables
y el tipo de dato al que pertenece, las constantes literales, el nombre de funciones y
los argumentos que reciben etc.
El programa fuente está recogido en un fichero de texto cuyos compone ntes son
caracteres. El analizador léxico debe tomar dichos caracteres y construir los
símbolos terminales de la gramática (Lexemas) que describe el lenguaje de
programación a procesar.
17
Programa fuente
FRONT-END
ANÁLISIS
ANÁLISIS LÉXICO
ANÁLISIS SINTÁCTICO
TABLA
DE
ANÁLISIS SEMÁNTICO
SÍMBOLOS
MANEJO
DE
SÍNTESIS
ERRORES
GENERACIÓN DE CÓDIGO
INTERMEDIO
GENERACIÓN DE CÓDIGO
OPTIMIZADOR DE CÓDIGO
BACK-END
Programa objeto
Figura No. 1.1: Fases de un procesador de lenguaje
El analizador léxico, o explorador (En lengua inglesa Scanner), es la parte del
procesador de lenguaje que lee los caracteres del programa fuente, y construye una
18
cadena de Lexema. Los lexemas son agrupaciones de caracteres que constituyen lo s
símbolos terminales de la gramática. Los lexemas se agrupan en componentes léxicos o
tokens, que son conjuntos de símbolos terminales de la gramática, que se pueden tratar
como unidades sintácticas, con un determinado significado sintáctico y semántico.
El análisis léxico es un análisis a nivel de caracteres, su misión es, a partir de éstos y por
medio de patrones reconocer los lexemas, enviando al analizador sintáctico el
componente léxico y sus atributos. Los atributos del componente léxico, habitualmente
sólo uno, contienen información adicional sobre el lexema, tanto a nivel sintáctico como
semántico.
Sentencia del programa fuente compuesta por caracteres
i
f
a
Tabla
de
símbolos
<
c
o
n
t
h
ANÁLISIS LEXICO
e
n
Manejo
de
errores
Serie de lexemas
if
a
<
con
then
Figura No. 1.2: Reconocimiento de lexemas
En este lenguaje de programación, se consideran componentes léxicos las siguientes
construcciones:
•
Palabras reservadas
•
Operadores (de comparación, aritméticos, asignación, lógicos, relacionales)
•
Identificadores (de variables, etiquetas,)
•
Constantes (enteros, textos, hexadecimales)
•
Signos de puntuación (paréntesis, dos puntos y coma)
19
•
Marcas de comienzo y fin de bloques
En la mayor parte de los lenguajes de programación las palabras reservadas no se
pueden utilizar como identificadores. El analizador léxico envía al analizador sintáctico
el componente léxico y un atributo con información adicional sobre el lexema en
concreto reconocido. Habitualmente los componentes léxicos tienen un sólo atributo.
1.6.1.1. Funciones del Analizador Léxico
Las principales funciones que realiza son:
•
Identificar los símbolos.
•
Eliminar los espacios en blancos, caracteres de fin de línea, etc.
•
Eliminar los comentarios que acompañan al código fuente.
•
Crear unos símbolos intermedios llamados tokens.
•
Avisar de los errores que detecte.
Pero la función más importante de este analizador es la entrega de los componentes
léxicos y sus atributos al analizador sintáctico.
•
El analizador sintáctico como su nombre lo indica se encarga de revisar que los
tokens estén ubicados y agrupados de acuerdo a la definición del lenguaje. Dicho de
otra manera, que los tokens pertenezcan a frases gr amaticales válidas, que el
compilador utiliza para sintetizar la salida. Por lo general las frases gramaticales son
representadas por estructuras jerárquicas, por medio de árboles de análisis sintáctico.
En esta etapa se completa la tabla de símbolos con la dimensión de los
identificadores y los atributos necesarios, etc.
20
Existen dos formas de analizar sintácticamente una cadena:
a) Análisis descendente: Partiendo del axioma inicial de la gramática se va
descendiendo utilizando las derivaciones izquierdas, hasta llegar a construir la
cadena analizada.
b) Análisis ascendente: Se va construyendo el árbol desde sus nodos terminales. Es
decir, se construye desde los símbolos de la cadena hasta llegar al axioma de la
gramática. En este caso, se emplean normalmente las derivaciones más a la derecha
hasta la localización de la raíz.
Simultáneamente a la fase de análisis sintáctico, además de reconocer las secuencias de
tokens, y analizar su estructura, pueden realizarse una serie de tareas adicionales, tales
como:
− Recopilar información de los distintos tokens y almacenarla en la tabla de símbolos.
− Realizar algún tipo de análisis semántico, tal como la comprobación de tipos.
− Generar código intermedio.
− Avisar de los errores que se detecten.
•
El análisis semántico se encarga de revisar que cada agrupación o conjunto de token
tenga sentido, y no sea un absurdo. En esta etapa se reúne la información sobre los
tipos para la fase posterior, en esta etapa se utiliza la estructura jerárquica de la etapa
anterior y así poder determinar los operadores, y operandos de las expresiones y
preposiciones.
21
1.6.2. Fase de Síntesis
El módulo de síntesis se encarga de la generación de código objeto, una vez que el
módulo de análisis ha verificado que el código fuente es correcto.
La tabla de símbolos es una estructura de datos que almacena la información recogida en
el módulo de análisis, y empleándose dicha información en el módulo de síntesis para la
generación del código objeto.
22
2. ANÁLISIS, DISEÑO Y DESARROLLO DE SOFTWARE
MICROPIC
2.1 REQUERIMIENTOS
Diseñar e implementar un sistema generador de código ensamblador para la familia de
microcontroladores PIC 16, instrucciones de lenguaje de cuarta generación como Visual
Basic 6.0 y Basic Stamp Editor v2.1. La base para la adquisición de datos es por
archivos planos con extensión *.PIC que servirá para generar otro archivo plano pero
con extensión *.ASM donde se estará codificado el código ensamblador.
En el sistema se distinguen los procesos de análisis léxico, sintáctico y semántico, el
primero captura todos los lexemas digitados o ingresados en el archivo fuente, el
segundo proceso verifica que todos estos lexemas denominados tokens en esta fase estén
agrupados de acuerdo a los parámetros definidos en el software y el último proceso
analiza que estos tokens tengan sentido común, es decir, que cumplan con la sintaxis
definida en MicroPic y si esta es correcta generar el código ensamblador.
2.2 MODELO DE DESARROLLO DEL SOFTWARE
MicroPic esta desarrollado en base al modelo de prototipo, evaluando situaciones del
programa antes de desarrollar la etapa final de diseño, con la información obtenida en
estas evaluaciones se procedió a desarrollar otra parte del programa, repitiendo estos
pasos para poder revelar los reque rimientos esenciales del diseño.
23
Antes de entrar en detalles en este capitulo se hace una especificación muy importante, y
es la siguiente una de las bases de este software es que es un programa que esta basado
en la programación modular y no en la orientada a objetos, se ha utilizado una clase,
varias estructuras, apuntadores, entre otros conceptos de la programación orientada a
objetos en el código implementado en el lenguaje Borland C++, sólo y únicamente para
tener una buena organización, mejor manipulación, reutilización, ahorro y tener una
mejor presentación del código al momento de utilizar dichas funciones.
2.2.1 Etapas del Modelo de Prototipo
•
Identificación de requerimientos conocidos
La idea principal del proyecto es desarrollar un sistema capaz de tomar el código fuente
digitado en instrucciones basados en el lenguaje Basic Stamp Editor v2.1 y generar su
respectivo código ensamblador. Se identificaron los requerimientos para satisfacer el
sistema final como son el análisis léxico, sintáctico, semántico y generador de código
ensamblador.
•
Desarrollo de un modelo de trabajo
Se hizo un desarrollo de un plan general como utilidad para comenzar el proceso de
construcción del prototipo, que nos permitió tener una visión y dar a conocer a nuestro
director lo que se espera de ella y el proceso de desarrollo.
En el desarrollo de este prototipo se prepararon los siguientes componentes:
24
•
El lenguaje para el diseño e implementación del sistema
El lenguaje que se utilizó para desarrollar el sistema en su primer ciclo de desarrollo fue
Visual Basic 6.0, desarrollándose en este todos los módulos necesarios para el
funcionamiento interno del sistema desde su análisis léxico hasta el análisis sintáctico
del lenguaje. Además Visual Basic utilizado como herramienta para desarrollar la
interfaz gráfica del sistema, ya que es muy fácil de usar y así obtener un diseño bastante
amigable para el usuario final.
Primer ciclo para el desarrollo del prototipo
•
Pantallas y entradas de datos
Lo primero que se desarrollo fue un sistema integrado, que mostraba las listas de
lexemas y variables tal y como se esperaba, pero estaba limitado para procesos muy
grandes y robustos, ya que se demoraba mucho para arrojar los resultados.
Figura No. 2.1: Pantalla de entrada datos del primer ciclo
25
•
Entradas de datos
En una caja de texto multilinea se digitaba el código fuente en instrucciones basadas
Basic Stamp Editor v2.1, para luego poder compilarlo. Al presionar el botón ejecutar se
procesaba la compilación del código usuario previamente digitado
•
.
Formulario de lexemas y variables
Son dos cajas de textos multilineas que mostraban todos los lexemas y variables
encontrados en el código usuario. Los lexemas y variables son muy importantes y
esenciales para poder distinguirlas de las palabras reservadas del compilador. Estas dos
cajas de textos se generan después de haber presionado el botón ejecutar del formulario
principal
.
Figura No. 2.2: Formulario de lexemas y variables
26
•
Salida del sistema
La salida del sistema presentaba como resultado el número de lexemas encontrados en el
código fuente compilado, además el número de las variables declaradas por el usuario.
El resultado de estas operaciones se visualizaba a través de cajas de texto de múltiples
líneas.
•
Revisión del prototipo
Después de la revisión del prototipo del primer ciclo se presentaron muchos
inconvenientes, entre los cuales especificamos que su compilación se hacia muy lenta y
tardía para procesos muy robustos y complejos por la cantidad de recursos que consume
Visual Basic 6.0. Por lo que se opto por la solución de trasladar el código de Visual
Basic a otro lenguaje de programación más rápido en el proceso de compilación tal
como es el caso de Borlan C++ 5.02 que trabaja bajo el entorno MS-DOS.
Segundo ciclo para el desarrollo del prototipo.
Como anteriormente se explicó, la implementación del software se realizó bajo los
lenguajes de programación Visual Basic y Borland C++. La fase de la interpretación del
código se diseñó en un lenguaje jerárquico el cual nos permitía una mayor rapidez en la
compilación este lenguaje de programación fue Borland C++ 5.02. Por último se eligió
el lenguaje de programación Visual Basic 6.0 como herramienta para la construcción de
la interfaz de usuario.
27
•
Pantallas y entradas de datos
Figura No. 2.3: Pantalla de entrada datos del segundo ciclo
En la anterior pantalla el editor de la izquierda se deben ingresar los datos esenciales
para la creación del código fuente que se desea compilar, y el de la derecha es el editor
donde se mostrar el código objeto. Se hizo de esta manera para que el usuario tuviera la
opción de modificar y manipular tanto el código fuente como el código objeto desde la
misma ventana. Además puede visualizar los posibles errores que presentan en la
compilación, ver figura No. 2.2.
Figura No. 2.4: Caja de visualización de errores
28
Esta es una especificación de la función que cumple cada uno de los botones que
conforman a la barra de herramientas del software Compilador MicroPic versión 1.0.
Este botón permite crear un nuevo documento o archivo fuente el cual tendrá la
extensión *.PIC.
Este botón permite abrir todos los documentos con extensión *.PIC existentes en
el sistema.
Este botón permite guardar los cambios realizados a los documentos abiertos, si
son por primera vez se abre la ventana Guardar como.
Este botón permite visualizar la tabla que enlista todas las variables declaradas
en el archivo fuente con sus características.
Este botón permite visualizar la tabla que enlista todos los lexemas digitados en
el archivo fuente con sus características y ubicación.
Este botón permite visualizar la tabla que enlista todas las etiquetas utilizadas en
el archivo fuente con sus características.
Este botón permite mostrar el código ensamblador como resultado de la
compilación del código fuente.
Este botón permite la compilación del código fuente.
Este botón permite la visualización de los autores de este software, versión y
29
otros detalles.
Este botón permite abrir las ayudas disponibles acerca del manejo y sintaxis de
las intrusiones que maneja MicroPic.
Este botón permite salir de la aplicación MicroPic.
Esta opción permite cambiar el estilo o la piel del
entorno gráfico.
•
Módulo esencial de compilación.
En este módulo se procesan los datos capturados o ingresados por el usuario esta
compilación sé determinada por un tiempo en el cual la lista de respuesta se hace
invisible y la caja de texto del código ensamblador cambia de color indicando que esta
en ejecución el proceso de la fase de análisis.
La interpretación del código usuario es realizada por la ejecución del programa
implementado en Borland C++ llamado Struct Semantico.exe, el cual recupera la
información suministrada por la interfaz de usuario de Visual Basic a través de la lectura
de un archivo plano el cual Struct Semantico.exe lo analiza e interpreta al lenguaje
ensamblador y este a su vez lo guarda en un archivo plano para que la interfaz de
usuario construida en visual Basic 6.0 lo muestre al usuario. En ciencia cierta la
comunicación de la interfaz de Visual Basic y Borland C++ es implementada a través de
archivos de texto. La información manejada entre cada aplicación es la de suministrar el
estado de la ejecución, es decir, si sé esta compilando o por el contrario ha finalizado,
30
además intercambiar el resultado de la compilación, la lista de variables, la lista de
lexemas, lista de etiquetas y el código interpretado (lenguaje ensamblador).
•
Salida del sistema
El sistema genera la salida de los posibles errores que se presenten en la compilación del
código fuente y a la vez si se desea visualizar su respectivo código ensamblador se debe
elegir la opción Archivo *.ASM del menú ver, siempre y cuando no se generen errores
de sintaxis en la compilación, el archivo objeto se guarda automáticamente con el mismo
nombre del archivo fuente pero sustituyendo la extensión *. PIC por *.ASM y, además
lo almacena en la misma carpeta donde esta el archivo fuente, los dos archivos son
visualizados en la misma ventana y pueden ser manipulados por el usuario.
Figura No. 2.5: Salida generada por el sistema
31
•
Revisión del prototipo
El sistema final (MicroPic) arrojó los resultados esperados, a la vez se le hicieron las
pruebas pertinentes y fueron compiladas en el software MPLAB IDE versión 6.40,
dichas pruebas fueron satisfactorias y a la vez se hicieron los respectivos documentos de
para mayor constancia. Ver resultados en el capitulo 5.
2.3 ESPECIFICACIÓN DE REQUISITOS
En esta especificación formal de requisitos se pretende proporcionar una representación
de la información y las funciones que debe cumplir el sistema, con el fin de convertirlo a
un diseño que cumpla con las exigencias inicialmente planeadas. Se recurre al análisis
estructurado como herramienta para desarrollar el análisis y las especificaciones del
software.
32
2.4 DISEÑO DE PROCESOS
2.4.1 Nivel 0. General de Abstracción de Datos
Diagrama 1: Nivel 0. General de Ab stracción de Datos
33
2.4.2 Nivel 1. Especificación del proceso MicroPic Versión 1.0
Diagrama 2: Nivel 1. Especificación del Proceso MicroPic Versión 1.0
34
2.4.3 Nivel 2. Especificación del proceso Análisis Léxico
Diagrama 3: Nivel 2. Especificación del proceso Análisis Léxico
35
2.4.4 Nivel 3. Especificación del proceso Análisis Sintáctico
Diagrama 4: Nivel 3. Especificación del proceso Análisis Sintáctico
36
2.4.5 Nivel 4: Especificación del proceso Análisis Semántico
Diagrama 5: Nivel 4. Especificación del Análisis Semántico
37
2.4.6 Nivel 5: Especificación de Proceso Generador de Código Ensamblador
Diagrama 6: Nivel 5. Especificación del Proceso Generador de Código Ensamblador
38
2.5 DICCIONARIO DE DATOS
2.5.1 Procesos
NOMBRE
FLUJOS DE
DATOS QUE
LLEGAN
DESCRIPCIÓN
Es el proceso principal que
Resultado de la
se encarga de compilar el
código fuente suministrado
MicroPic
Versión 1.0
Código inicial
por el usuario y verificar
su correcta sintaxis para
luego
convertirlo
FLUJOS DE
DATOS QUE
SALEN
Datos recuperados
en
ejecución
Código final
Código usuario
lenguaje ensamblador.
Tabla No. 1: Proceso de abstracción de datos
NOMBRE
FLUJOS DE
DATOS QUE
LLEGAN
DESCRIPCIÓN
FLUJOS DE
DATOS QUE
SALEN
Cumple con las funciones
de
adquisición
de
los
datos digitalizados por el
Manipulación
usuario y a la vez el de
de Código
almacenarlos.
De
igual
forma recuperarlos para
Datos digitalizados Código suministrado
Código almacenado
Código ingresado
Código ingresado
Lexemas
así enviárselo al proceso
analizador léxico.
Analizador
Se encarga de recorrer
39
Léxico
carácter por carácter el
código
fuente
encontrados
para
construir los lexemas con
la ayuda de los autómatas
propios del compilador.
Su
función
recolectar
es
los
encontrados
Analizador
la
de
lexemas
por
el
proceso analizador léxico
Sintáctico
para luego enviar por
Lexemas verificados
Lexemas
encontrados
Respuesta de la
ejecución
pantalla el resultado de la
sintaxis.
Este proceso se encarga
de adquirir los lexemas
dados
Analizador
por
el
proceso
analizador sintáctico para Lexemas verificados
Semántico
luego verificar si cumple
Característica de
código
con las características del
microcontrolador.
Bloque en
Se encarga de convertir el
código
de
usuario
Generador de
código ensamblador y de
código
igual
ensamblador
almacenarlos en archivos
forma
ensamblador
a
de
planos y mostrarlos por
pantalla.
Característica de
Datos en
código
ensamblador
Lista de
instrucciones
Tabla No. 2: Especificación del proceso MicroPic versión 1.0
40
NOMBRE
FLUJOS DE
DATOS QUE
LLEGAN
Código ingresado
DESCRIPCIÓN
Se encarga de ir al archivo
Recupera
fuente y recuperar carácter
caracteres
por carácter y guardarlos
Apuntador a
en una lista enlazada.
Formación de
lexemas
FLUJOS DE
DATOS QUE
SALEN
Lista de caracteres
lexemas
Toma todos los caracteres
Lexemas
Lista de caracteres
y los forma en un solo
construidos
token.
Se encarga de construir un
Determina
nodo
con
las
tipo de lexema características del lexema
Lexemas
Lexemas construidos
estructurado
construido.
Añadir a lista
lexema
Se encarga de concatenar
o
ingresar
el
nodo
encontrado a la lista de
lexemas.
Lexemas
Lexemas encontrado
estructurado
Apuntador a
lexemas
Memoria
incrementada
Nuevo lexemas
Tabla No. 3: Especificación del proceso análisis léxico
41
NOMBRE
DESCRIPCIÓN
Se encarga de recuperar
Recupera
lexema
lexemas
almacenarlos en memoria.
Busca
por
en
lexema
la
y
lista
de
FLUJOS DE
DATOS QUE
LLEGAN
Lexemas
FLUJOS DE
DATOS QUE
SALEN
Característica
encontrados
lexema
Lexema recuperado
Petición de lexemas
Verificación
palabras
reservadas
las
Característica
sintáctica
palabras
propias
del
lexema
Error de verificación
Lexema verificado
lenguaje MicroPic.
Se encarga de buscar en la
Manejo de
tabla de errores el número
errores
del
error
que
se
ha
presentado.
Error de
verificación
Descripción del
Número de error
Respuesta de la
error
Tabla No. 4: Especificación del proceso análisis sintáctico
42
ejecución
NOMBRE
FLUJOS DE
DATOS QUE
LLEGAN
DESCRIPCIÓN
FLUJOS DE
DATOS QUE
SALEN
Este proceso se encarga de
almacenar o guardar los
Lexemas
Almacenar
lexemas encontrados en
verificados
tokens
una tabla de símbolos con
sus respectivas variables Variables guardadas
Lista de variable
Lexemas analizados
genéricas.
Verifica si la sintaxis esta
Verificación
de variable
correcta y genera o crea
Lista de variables
Característica de
código
las variables genéricas.
Tabla No. 5: Especificación del proceso análisis semántico
NOMBRE
DESCRIPCIÓN
Se encarga de crear un
archivo plano donde se
Almacenar
operaciones
guardará
el
código
generado con extensión
*.ASM.
43
FLUJOS DE
DATOS QUE
LLEGAN
FLUJOS DE
DATOS QUE
SALEN
Característica de
Bloque en
código
ensamblador
Lista de bloque
Nombre del token
Datos en
Contiene los datos del
Recuperación de lenguaje ensamblador
Nombre del token
para
poder
mostrarlos
instrucciones
por pantalla.
ensamblador
Lista de
instrucciones
Tabla No. 6: Especificación del proceso generador de código ensamblador
2.5.2 Almacén de Datos
NOMBRE
FLUJOS DE
DATOS QUE
LLEGAN
DESCRIPCIÓN
FLUJOS DE
DATOS QUE
SALEN
Se encarga de almacenar
todos los códigos fuentes
Archivos
fuentes
(Lenguaje de usuario) en
archivos
planos
Código final
con
extensión *.PIC.
Se encarga de guardar el
resultado
de
la
compilación en un archivo
Archivos
planos
con extensión *.ASM; esto
solo
se
realiza
sí
Código usuario
el
proceso MicroPic a dado
un resultado sin errores.
Tabla No. 7: Almacén de abstracción de datos
44
Datos recuperados
NOMBRE
FLUJOS DE
DATOS QUE
LLEGAN
DESCRIPCIÓN
FLUJOS DE
DATOS QUE
SALEN
Se encarga de almacenar
los
Lenguaje de
usuario
códigos
fuentes
digitalizados
por
usuario
extensión
con
el Código suministrado Código almacenado
*.PIC.
Se encarga de contener el
código
Lenguaje
representativo
(ensamblador) a través de
ensamblador
archivos
con
extensión
Bloque en
ensamblador
*.ASM.
Tabla No. 8: Especificación almacén de MicroPic versión 1.0
NOMBRE
FLUJOS DE
DATOS QUE
LLEGAN
DESCRIPCIÓN
FLUJOS DE
DATOS QUE
SALEN
Se encarga de almacenar
los lexemas
CPU
totalmente
estructurados en memoria
Nuevo lexemas
de forma temporal.
Tabla No. 9: Especificación almacén de análisis léxico
45
Memoria
incrementada
NOMBRE
FLUJOS DE
DATOS QUE
LLEGAN
DESCRIPCIÓN
Contiene
todos
los
posibles errores que se
Lista de
errores
pueden presentar después
de
la
compilación
FLUJOS DE
DATOS QUE
SALEN
Número del error
Descripción del
error
de
MicroPic.
Tabla No. 10: Especificación almacén de análisis sintáctico
NOMBRE
DESCRIPCIÓN
Contiene
Variables
genéricas
las
FLUJOS DE
DATOS QUE
LLEGAN
FLUJOS DE
DATOS QUE
SALEN
Lexema analizado
Variable guardada
variables
genéricas de todos los
lexemas.
Tabla No. 11: Especificación almacén análisis semántico
2.5.3 Interfaz
NOMBRE
FLUJOS DE
DATOS QUE
LLEGAN
DESCRIPCIÓN
FLUJOS DE
DATOS QUE
SALEN
Se encarga de recoger los
Panel de
control
datos suministrados por el
usuario.
46
Código inicial
Se encarga de visualizar
los
resultados
ejecución
de
del
la
proceso
MicroPic, como son: Lista
Monitor
de
errores,
ensamblador,
Código
lista
Resultado de la
ejecución
de
lexemas, etc.
Tabla No. 12: Interfaz de abstracción de datos
NOMBRE
FLUJOS DE
DATOS QUE
LLEGAN
DESCRIPCIÓN
FLUJOS DE
DATOS QUE
SALEN
Esta interfaz permite que
el
Entrada por
teclado
usuario
pueda
interactuar a través del
Datos digitalizados
ingreso del código fuente
por teclado.
Esta interfaz cumple con
Vista por
pantalla
la función de visualizar
Respuesta de la
por pantalla los resultados
ejecución
de las diferentes fases del
compilador
tales
como
mostrar lista de errores,
Bloque en
ensamblador
código ensamblador.
Tabla No. 13: Especificación de Interfaz de MicroPic Versión 1.0
47
2.5.4 Flujos de Datos
NOMBRE
DESCRIPCIÓN
Son
los
DE DONDE SALE
A DONDE LLEGA
Panel de control
MicroPic versión 1.0
datos
digitalizados o escritos
Código
inicial
por el usuario, estos no
necesariamente
tienen
que estar almacenados.
Contiene todo el código
fuente que va a ser
Código
usuario
almacenado
en
archivo
extensión
con
un MicroPic versión 1.0
Archivos fuentes
*.PIC.
Contiene el código fuente
que necesariamente esta
Datos
almacenado, previamente
recuperados
para después llevarlo a la
compilación
por
Archivos fuentes
MicroPic versión 1.0
MicroPic versión 1.0
Archivos fuentes
el
proceso MicroPic.
Se encarga de transportar
el
resultado
Resultado de compilar
la ejecución
el
final
al
código
fuente, entre ellos esta
lista de errores o lenguaje
ensamblador.
48
Se encarga de transportar
el resultado final de la
Código final
ejecución
del
proceso MicroPic versión 1.0
MicroPic
en
archivos
Archivos planos
planos *.ASM.
Tabla No. 14: Flujos de datos de abstracción de datos
NOMBRE
Datos
DESCRIPCIÓN
Contiene
todos
DE DONDE SALE
los
caracteres ingresados por Entrada por teclado
digitalizados teclado.
A DONDE LLEGA
Manipulación de
código
En el caso que ocurra un
error de sintaxis este flujo
Respuesta de contendrá
la ejecución
la
lista
de
Analizador
errores o por el contrario
un
mensaje
Vista por pantalla
sintáctico
de
aceptación.
Código
Contiene el código dado
Manipulación de
suministrado por el usuario.
Lenguaje de usuario
código
Este flujo se encarga de
Código
suministrar
el
código
almacenado
fuente almacenado por el
Lenguaje de usuario
usuario.
49
Manipulación de
código
Contiene
Código
ingresado
el
lenguaje
usuario característico de
la aplicación MicroPic.
Manipulación de
código
Analizador léxico
Tiene las características
Lexemas
de las palabras, símbolos
encontrados
y operadores encontrados
Analizador léxico
Analizador
sintáctico
en el código fuente.
Llevan
sólo
aquellas
Lexemas
expresiones
que
hacen
verificados
parte del lenguaje de la
Analizador
Analizador
sintáctico
semántico
aplicación MicroPic.
Este flujo contiene sólo
Característica
aquellos
lexemas
que
Analizador
Generador de
de código
hacen óptimo la ejecución
semántico
código ensamblador
Generador de
Lenguaje
en código ensamblador.
Este
se
encarga
transportar
el
Bloque
ensamblador
ensamblador
para
de
código
generado
luego
ser código ensamblador
ensamblador
almacenado en un archivo
plano.
Contiene
todas
las
y
los
Datos en
instrucciones
ensamblador
parámetros que luego se código ensamblador
mostraran por pantalla.
50
Generador de
Vista por pantalla
Transporta y suministra
Lista de
instrucciones
las
instrucciones
ensamblador
en
que
Generador de
van
código ensamblador
hacer generadas a código
de máquina.
Tabla No. 15: Especificación de flujos de datos de MicroPic versión 1.0
NOMBRE
Código
ingresado
DESCRIPCIÓN
DE DONDE SALE
Contiene el lenguaje
A DONDE LLEGA
usuario característico de
Recupera caracteres
la aplicación MicroPic.
Es
una
estructura
Lista de
enlazada
sencilla
que
caracteres
guarda todo los caracteres
Recupera caracteres
Formación de
lexemas
encontrados
Contiene a los lexemas
Lexema
construido
en una variable y no en
una lista enlazada
Contiene un nodo con
Lexema
todas las características
estructurado del lexema encontrado
Contiene lexemas que se
Nuevo
lexema
van
almacenar
en
Formación de
Determina tipo de
lexemas
lexema
Determina tipo de
Añadir a lista de
lexema
lexemas
Añadir a lista de
la
lexemas
memoria
51
CPU
Contiene los apuntadores
a la lista de lexemas
Memoria
CPU
incrementada donde están todos los
Añadir a la lista de
lexemas
lexemas almacenados
Contiene
Apuntador a
lexemas
todo
el
Añadir a lista de
conjunto de lexemas que
lexemas
han sido encontrado
Recupera caracteres
Tiene las características
Lexemas
de las palabras, símbolos
Añadir a lista de
encontrados
y operadores encontrados
lexemas
en el código fuente.
Tabla No. 16: Especificación de flujos de datos de análisis léxico
NOMBRE
Petición de
lexemas
DESCRIPCIÓN
DE DONDE SALE A DONDE LLEGA
Este contiene el nodo
actual de la lista de
Recupera lexema
CPU
CPU
Recupera lexemas
lexemas
Contiene un apuntador al
Lexema
recuperado
siguiente lexema de la
lista de lexemas
Presenta
Característica
lexema
todas
las
características del lexema
encontrado
52
Recupera lexemas
Verificación
sintáctica
Error de
Contiene un índice del
verificación
error presentado
Número del
Contiene el número con
error
que se identifica el error
Recupera
Descripción
del error
Verificación
Manejo de errores
sintáctica
de
Manejo de errores
Lista de errores
Lista de errores
Manejo de errores
forma
descriptiva el error que
se cometió
Tabla No. 17: Especificación de flujos de datos de análisis sintáctico
NOMBRE
DESCRIPCIÓN
Contiene
DE DONDE SALE
todas
A DONDE LLEGA
las
Lista de
variables
genéricas Almacenamiento de
variables
encontradas en un bloque
token
Verificación de
variables
de lexemas
Contiene los token que
Lexema
van ha ser transformados
analizado
guardadas
token
Variables genéricas
a variables genéricas
Contiene
Variables
Almacenamiento de
los
lexemas
transformados
en
Variables genéricas
variables genéricas
Almacenamiento de
token
Tabla No. 18: Especificación de flujos de datos de análisis semántico
53
NOMBRE
DESCRIPCIÓN
DE DONDE SALE
A DONDE LLEGA
Lenguaje
Almacenamiento de
ensamblador
operaciones
Almacenamiento de
Recuperación de
operaciones
instrucciones
Contiene todo el lenguaje
Lista de
bloques
guardado en el archivo de
código ensamblador
Contiene la descripción
Nombre del
token
del archivo en lenguaje
ensamblador
Tabla No. 19: Especificación de flujos de datos de generador de código ensamblador
54
3. REQUERIMIENTOS GENERALES DE MICROPIC
En este capitulo se detalla con mayor profundidad los requerimientos del software
MicroPic. En el cual se diseñara e implementara un Compilador de Lenguaje de
Programación de Alto Nivel que Genera Código Ensamblador para la Implementación
de un Microcontrolador PIC de la Familia 16, utilizando archivos planos con extensiones
(*.PIC y *.ASM).
En el sistema se distinguen las fases de análisis y síntesis, la primera fases analiza que
las palabras estén escritas correctamente, hagan parte de un token, tengan sentido y no se
han absurdos esos tokens. En la segunda fase el sistema se encarga de la generación de
código objeto, una vez que el módulo de análisis ha verificado que el código fuente es
correcto. Teniendo muy en cuenta la tabla de símbolos recogidos en la fase de análisis
3.1 EVOLUTIVIDAD Y FLEXIBILIDAD
La herramienta software MicroPic debe poder evolucionar para permitir la posibilidad
de extenderse y adaptarse a posibles futuros requerimientos. Por ejemplo, a la hora de
anexar nuevos módulos como lo son: Integrar instrucciones básicas de MicroPic,
Cambiar sus parámetros.
Respecto a la flexibilidad, los algoritmos son susceptibles a cambios futuros en las
funciones facilitando así la implementación de nuevas instrucciones propias del lenguaje
55
tales como: AUXIO, LCDIN, entre otras funciones que no están implementadas en el
programa. Con estas dos características se puede lograr un buen re- uso de código.
3.2 MANTENIBILIDAD Y REPARABILIDAD
Como la mayoría de proyecto de software busca ser fiable con el tiempo, MicroPic debe
ser mantenible, es decir, que al efectuarle pequeños cambios al software este no se
transforme en altos costos en términos de tiempos de desarrollo.
Así mismo debe ser reparable, es decir que si se detecta algún error en el mismo sea
fácil repararlo sin que esto redunde en un cambio total del diseño ni demasiado tiempo
de desarrollo.
Estas dos características son fundamentales en un producto de software que pretenda
extenderse de sus programadores, y una pieza fundamental para lograr esto es una buena
documentación de software.
Esta debe ser completa y entendible, de tal forma que cuando el Software tenga que
cambiar de programador, el nuevo programador pueda comprenderlo a tal punto de que
pueda modificarlo sin ningún problema.
3.3 AMIGABILIDAD
MicroPic es un sistema muy amigable y esta diseñado para que cualquier usuario con los
conocimientos básicos de informática pueda manejarlo, a demás no se necesita ser un
56
excelente programador para determinar las condiciones propias del lenguaje, ya que
básicamente esta basado en las sintaxis del lenguaje de programación Visual Basic 6.0 y
Basic Stamp Editor v2.1 que son lenguajes de cuarta generación fáciles de manipular.
La amigabilidad es necesaria ya que si no fuera amigable los usuarios se alejarían de
esta herramienta para usar otras herramientas más agradables y sencillas.
3.4 PORTABILIDAD
Se refiere a la ventaja de utilizar el Software en varios ambientes, un software es más
portable cuando más fácil sea lograr que funcione en distintas plataformas.
Como MicroPic fue implementado en dos lenguajes de programación, uno que maneja el
diseño (Visual Basic), y el otro el aprendizaje del lenguaje MicroPic (Borland C++), el
primero esta un poco limitado por que este lenguaje utiliza librerías dinámicas que en
muchos casos no son compatibles con otras plataformas diferentes a Windows.
El otro que es Borland C++ es un lenguaje orientado a objetos de la cuarta generación
que permite crear códigos objetos que son compatibles con la mayoría de las plataformas
existentes en el mercado tales como Microsoft Windows, Unix, Linux, entre otros
sistemas operativos, por lo cual todo el análisis y manipulación de código intermedio
(lenguaje en ensamblador) esta basado bajo ventanas MS-DOS.
57
3.5 BONDAD
Por la portabilidad que presenta el programa MicroPic es que es muy rápido en su
proceso de compilación, teniendo en cuenta que el compilador de Borland C++ es
mucho más rápido que el de cualquier otro lenguaje aun así con aplicaciones muy
grandes. El tiempo de respuesta es muy rápido.
El diseño gráfico no es muy complicado es un sistema escalable, es decir, esta abierto a
cambios futuros de instrucciones del propio lenguaje. El manejo de la información se
hace a través de formatos sencillos (archivos planos)
58
4. INTRUCCIONES MICROPIC
4.1 COMPONENTES LÉXICOS
COMPONENTE
LEXEMA
DESCRIPCIÓN DEL
LÉXICO
EJEMPLO
PATRÓN
IDENTIFICADOR
x, y, valor,
x2
CADENA
“una cadena”
<letra>(<letra>|<dígito>)*
Caracteres entre comillas
OBSERVACIONES
Identificadores
Constante de cadena
dobles (“, ”)
CON_ INT
CON_HEX
[0 ... 65535]
[0x00 ...
0xFF]
CON_BIT
[0 ... 8]
CON_BYTE
[0 ... 255]
OPERADORES
ARITMÉTICOS
Constante de tipo
(λ)<dígito>(<dígito>|<letra>)* entera, hexadecimal,
bit y byte
+
“+”
Operador de suma
-
“- ”
Operador de resta
*
“*”
Operador de
multiplicación
/
“/”
AND
“ AND ”
Operador lógico
AND
OPERADORES
LÓGICOS
Operador de división
OR
“ OR ”
NOT
“ NOT ”
59
Operador lógico OR
Operador de lógico
de negación
>
>=
OPERADORES
<
RELACIONALES
“ > ” | ” > = ” | “< ” | “< = ”
Operadores de
| “ <> ”
comparación
<=
<>
OP_IGUALDAD
=
O ASIGNACIÓN
“=”
Operador de igualdad
o asignación
INT
TIPOS DE DATOS
TEXT
BIT
“int” | “text” | “bit” | “byte”
Tipos de datos
simples
BYTE
Tabla No. 20: Componentes léxicos, lexemas y patrones
4.2 INSTRUCCIONES
Las palabras reservadas del lenguaje Basic se describen en la siguiente Tabla:
INSTRUCCIÓN
DESCRIPCIÓN
Sirve para organizar lo que se hace en un IF... THEN en una sola
BRANCH
declaración o línea. Si el valor no está en el rango BRANCH no hace nada
y el programa continúa con la próxima instrucción después de BRANCH.
COUNT
DATA
La instrucción de la COUNT sirve para contar los pulsos que llegan al pin
en un tiempo determinado.
Cuando usted transmite un programa en la BASIC Stamp, se guarda en la
EEPROM que empieza a la dirección más alta (2047) y trabajando hacia la
60
dirección más baja. La mayoría de los programas no usa el EEPROM
entera, para disponible la parte baja para otros usos. DATA le permite
definir un juego de datos para guardar en las situaciones de EEPROM
disponibles.
Sirve para enviar los mensajes por pantalla del PC mientras sé esta
corriendo el programa. El nombre "debug" hace pensar en su uso más
DEBUG
popular; en los programas muestra el valor de una variable o expresión, o
indicando qué porción de un programa se está ejecutando actualmente.
DEBUG también es una gran manera de ensayar las técnicas de la
programación.
DO...LOOP permite a un programa ejecutar una serie de instrucciones
DO...LOOP
indefinidamente, o hasta que una condición especificada termine la vuelta o
el ciclo.
Cuando usted transmite un programa, este se guarda en la EEPROM que
empieza a la dirección más alta (255) y trabajando hacia la dirección más
EEPROM
baja. La mayoría de los programas no usa el EEPROM entera, para
disponible la parte baja para otros usos. La EEPROM directiva le permite
definir un juego de datos para guardar en las situaciones de EEPROM
disponibles.
END
EXIT
La instrucción END indica el final del programa.
La orden EXIT permite a un programa salir de un ciclo, es decir, rompe el
ciclo.
FOR...NEXT permite a un programa ejecutar una serie de instrucciones
para un número específico de repeticiones o iteraciones. Por defecto, cada
FOR...NEXT
tiempo a través del ciclo, incrementa el valor de la variable contador en 1.
Continuará doblando hasta que el resultado del contador salga del rango
puesto por Valor inicial y Valor final.
61
GOSUB
GOTO
Envía al programa a una subrutina.
La instrucción GOTO envía a la etiqueta o dirección que este acompañando
a la orden GOTO.
HIGH
La orden HIGH coloca el valor del pin especificado en 1.
IF...THEN prueba una condición y, si esa condición es verdadera, va a un
IF...THEN
punto en el programa especificado por una etiqueta de dirección. La
condición del IF...THEN son escritas con una mezcla de operadores lógicos
y de comparación.
IF...THEN...ELSE prueba una condición y si esta es verdadera va a un punto
en el programa especificado por una etiqueta de dirección, y si es falsa o no
IF...THEN...ELSE se cumple la condición va a otro punto en el programa especificado por una
etiqueta de dirección. Al igual que el IF...THEN están escritas con una
mezcla de operadores lógicos y de comparación.
INPUT
La orden INPUT configura el puerto a su modo de entrada, es decir, los
pines del puerto se colocan 1. Por lo general, todos los pins son de entrada.
LOW
La orden LOW coloca el valor del pin especificado en 0.
La instrucción ON...GOSUB es muy parecida a BRANCH, la cual sirve para
ON...GOSUB
organizar lo que se hace en un IF ... THEN en una sola declaración o línea.
Si el valor no está en el rango ON...GOSUB no hace nada y el programa
continúa con la próxima instrucción después de ON...GOSUB.
La instrucción ON...GOTO es muy parecida a ON...GOSUB y BRANCH, la
cual sirve para organizar lo que se hace en un IF ... THEN en una sola
ON...GOTO
declaración o línea. Si el valor no está en el rango ON...GOTO no hace
nada y el programa continúa con la próxima instrucción después de
ON...GOTO.
OUTPUT
La orden OUTPUT configura el puerto a su modo de salida, es decir, los
pines del puerto se colocan 0.
62
PAUSE
La instrucción PAUSE retrasa la ejecución de la próxima instrucción del
programa para el número especificado de milisegundos.
RANDOM genera números aleatorios que van de 0 a 65535. Que se genera
RANDOM
por un funcionamiento de la lógica que usa el valor inicial en una Variable
de sucesión de 65535 números esencialmente aleatorios.
READ
La instrucción READ se utiliza para recuperar un valor de cualquier
dirección de la EEPROM.
La orden RETURN envía al programa atrás en la dirección en el GOSUB
RETURN
inmediatamente más reciente. Si el RETURN se ejecuta sin un GOSUB
anterior, se devolverá a la primera línea ejecutable del programa;
normalmente produciendo un bicho lógico en el código.
SELECT...CASE es una instrucción avanzada que se puede usar para
SELECT...CASE reemplazar la instrucción IF...THEN...ELSE. Esta a su vez también utiliza
los operadores de la comparación.
SERIN
SEROUT
SLEEP
La orden SERIN permite el envío de datos por el puerto serial.
La orden SEROUT permite la salida de datos por el puerto serial.
Envía a MicroPic a dormir, es decir, a un estado de bajo consumo en un
tiempo indefinido.
TOGGLE
La instrucción TOGGLE invierte el estado del pin especificado,
cambiándolo de 0 a 1 y de 1 a 0.
WRITE
La instrucción WRITE guarda un valor en cualquier dirección de la
EEPROM. En cualquier situación dentro del EEPROM puede escribirse.
Tabla No. 21: Palabras reservadas con su descripción4
4
BASIC Stamp Programming Manual 2.0b – www.parallaxinc.com
63
5. EVALUACIÓN DEL SISTEMA MICROPIC V 1.0
El código fuente es creado en la carpeta MicroPic que se encuentra en C:\ Archivos de
programa, y si se desea cambiar la carpeta destino se puede hacer desde el árbol de
carpetas que se encuentra en la parte izquierda de la ventana Guardar como, además el
archivo en ensamblador se creará en la misma carpeta donde se encuentre el código
fuente y con el mismo nombre pero con extensión *.ASM.
Todo código después de compilado si no tiene errores debe crear un código en
ensamblador, en el cual las tres primeras líneas son las directivas donde están
establecidas las instrucciones propias del microcontrolador que esta en uso, en este caso
el PIC 16f84 y todos los números que se encuentren en el mismo serán tratados como
números hexadecimales sin importar el formato que tengan previamente, por medio de la
instrucción Radix; estas instrucciones estarán presentes en todos los códigos en
ensambladores que se generen.
Luego se encuentran las diferentes variables que están direccionadas, teniendo en cuenta
el tipo en que estén declaradas en el código fuente, se organizan en posiciones sucesivas
de memoria que inicia en la posición 0C y termina en la 4F, es decir, solo se tienen
disponibles 68 registros de uso general; si la variable es de tipo entero se requieren dos
registros de 8 bits cada uno, al primer registro se le adiciona la letra H para almacenar la
parte alta y al segundo la letra L para almacenar la parte baja.
Después viene el cuerpo del trabajo que inicia con la palabra reservada main y finaliza
con end
64
5.1 EVALUACIÓN No. 1
•
Prueba: El nombre del programa fuente es Prueba1.pic
En el siguiente programa se declaran seis variables de diferentes tipos y un condicional
simple donde se evalúa la condición (a > 0x01), donde el número que esta dentro de la
condición esta en formato hexadecimal, si se cumple la condición realizara las
instrucciones que le siguen.
DECLARE
BYTE a
BYTE s
INT m
BYTE x
INT v
INT p
ENDDECLARE
if a > 0x01 then
a=a+3
s = 4- x
endif
m = s * 27
end
Figura No. 5.1: Código fuente de la evaluación No. 1. Prueba1.pic
Al compilar este código se presenta un mensaje que refleja la interpretación correcta de
la sintaxis del código fuente con extensión *.PIC, el mensaje que se visualiza es el
siguiente: “!!! Correcto ¡ ¡ ¡”.
•
Producto: El nombre del programa objeto será Prueba1.asm
El producto de la compilación se presentara a continuación:
65
mulplr
mulcnd
count
L_Bytes
H_Bytes
Var1
Var2
Var3L
Var3H
Var4
Var5L
Var5H
Var6L
Var6H
main
#include "p16f84a.inc"
Radix hex
List p=16f84a
equ
0C
equ
0D
equ
0E
equ
0F
equ
10
equ
11
equ
12
equ
13
equ
14
equ
15
equ
16
equ
17
equ
18
equ
19
MOVLW
SUBWF
BTFSC
GOTO
BTFSC
GOTO
GOTO
0x0001
Var1,0
STATUS,Z
CondF1
STATUS,C
CondV1
CondF1
MOVLW
ADDWF
MOVWF
MOVF
SUBWF
MOVWF
0x03
Var1,0
Var1
Var4,0
0x04,0
Var2
MOVLW
MOVWF
MOVF
MOVWF
CALL
MOVF
MOVWF
0x1B
mulplr
Var2,0
mulcnd
Multi
L_Bytes,0
Var3L
CondV1
CondF1
66
MOVF
MOVWF
GOTO
CLRF
CLRF
MOVLW
MOVWF
MOVF
BCF
RRF
BTFSC
ADDWF
RRF
RRF
DECFSZ
GOTO
RETLW
Multi
Loop
H_Bytes,0
Var3H
Terminar
H_Bytes
L_Bytes
8
count
mulcnd,0
STATUS,C
mulplr,1
STATUS,C
H_Bytes,1
H_Bytes,1
L_Bytes,1
count,1
Loop
0
Terminar
END
Figura No. 5.2: Código ensamblador de la evaluación No. 1. Prueba1.asm
Después de la compilación del programa, se generó el código que se esperaba como
resultado final, se crearon todas las variables con sus nombres genéricos y en la
secuencia de las posiciones de memoria correspondientes.
5.2 EVALUACIÓN No. 2
•
Prueba: El nombre del programa fuente es Prueba2.pic
67
En este programa se declaran tres variables de diferentes tipos con un ciclo repetitivo
donde se inicializa la variable del ciclo en cero y finaliza en 15, esto expresa que las
instrucciones que le siguen al for se deben realizar 16 veces.
DECLARE
BYTE a
BYTE x
INT p
ENDDECLARE
for a = 0 to 15
p=x*2
next a
end
Figura No. 5.3: Código fuente de la evaluación No. 2. Prueba2.pic
Al compilar este código se presenta un mensaje que interpreta un error, el cual es
editado por el usuario en el código fuente ya que los ciclos están definidos para iniciar
desde 1 hasta el infinito, este mensaje muestra la línea, las coordenadas donde se efectuó
dicho error y se describe a continuación:
MicroPic Versión 1.0 – Error de Compilación
MicroPic – Línea
:6
MicroPic – Describe :Inicializar variable (var = 1)
MicroPic - Lexema (6,9) => ‘0’
•
Producto: Como se expreso anteriormente si hay errores en el código fuente no se
genera o crea el respectivo código ensamblador.
68
5.3 EVALUACIÓN No. 3
•
Prueba: El nombre del programa fuente es Prueba3.pic
En el siguiente programa se declaran cuatro variables todas de tipo byte, dos etiquetas y
una la instrucción Branch que se evalúa al igual que un condicional, este envía a
diferentes etiquetas dependiendo del valor que toma la variable val.
DECLARE
BYTE a
BYTE x
byte p
byte val
ENDDECLARE
BRANCH val,(caso1,caso2)
caso1:
a=x+p
caso2:
a=x-3
end
Figura No. 5.4: Código fuente de la evaluación No. 3. Prueba3.pic
•
Producto: El nombre del programa objeto será Prueba3.asm
Luego de la compilación del código fuente el cual no tuvo ningún error de sintaxis se
genera el código de la figura No. 5.5 con extensión *.ASM y el mismo nombre que
archivo que lo crea. Los resultados fueron los pertinentes o correspondientes con los
datos esperados.
69
#include "p16f84a.inc"
Radix hex
List p=16f84a
equ
0C
equ
0D
equ
0E
equ
0F
Var1
Var2
Var3
Var4
main
MOVLW
SUBWF
BTFSC
GOTO
MOVLW
SUBWF
BTFSC
GOTO
0
Var4,0
STATUS,Z
Etiq1
1
Var4,0
STATUS,Z
Etiq2
MOVF
ADDWF
MOVWF
Var3,0
Var2,0
Var1
MOVLW
SUBWF
MOVWF
GOTO
0x03
Var2,0
Var1
Terminar
Etiq1
Etiq2
Terminar
END
Figura No. 5.5: Código ensamblador de la evaluación No. 3. Prueba3.asm
5.4 EVALUACIÓN No. 4
•
Prueba: El nombre del programa fuente es Prueba3.pic
70
El siguiente código fue editado por un usuario ajeno a la aplicación MicroPic v1.0, quien
le dedicó un día de análisis a las sintaxis que utiliza el software, para luego poder editar
el código de la mejor manera posible. Después de editado procedió a compilarlo para
visualizar si este presenta errores de sintaxis o no.
DECLARE
byte s
int w
byte pi
DECLARE
gosub paso
a=w*3
paso:
s=w/3
return
w = w+pi
end
Figura No. 5.6: Código fuente de la evaluación No. 4. Prueba4.pic
El código fuente establece en sus parámetros de sintaxis que la declaración de variables
esta enmarcada o esta dentro de las dos palabras reservadas declare para iniciar y
enddeclare para finalizar la declaración. Según lo establecido en las distintas sintaxis del
código usuario el error que se presenta es utilizar una palabra reservada en el lugar no
apropiado y el mensaje que se visualiza es el siguiente:
MicroPic Versión 1.0 – Error de Compilación
MicroPic – Línea
:5
MicroPic – Describe :Se esperaba palabra reservada
MicroPic - Lexema (5,7) => ‘DECLARE’
71
•
Producto: Como hay un error de palabras reservadas no se creará el código objeto.
5.5 EVALUACIÓN No. 5
•
Prueba: El nombre del programa fuente es Prueba5.pic
En este código se espera que el compilador envíe un mensaje de error que realizó el
usuario al realizar la división por cero la cual no se permite o no existe.
declare
byte s
byte w
byte pi
enddeclare
w=pi + 8
s=w/0
end
Figura No. 5.7: Código fuente de la evaluación No. 5. Prueba5.pic
Cuando se compiló el programa o código fuente anterior se visualizó el siguiente
mensaje de error:
MicroPic Versión 1.0 – Error de Compilación
MicroPic – Línea
:7
MicroPic – Describe :División entre cero
MicroPic - Lexema (7,9) => ‘0’
•
Producto: Al igual que las pruebas anteriores el código objeto no se genera.
72
5.6 EVALUACIÓN No. 6
•
Prueba: El nombre del programa fuente es Prueba6.pic
Este código que esta digitado de forma correcta, utiliza ciclos y condicionales anidados,
el usuario final no cometió error de sintaxis y se espera un mensaje positivo al compilar
este código en MicroPic Versión 1.0.
DECLARE
BYTE a
BYTE x
INT p
ENDDECLARE
inicio:
for a = 1 to 10
for x = 1 to 10
if a < 56 then
if x = 10 then
x=2/a
else
a=2+1
endif
else
a=x/6
endif
next x
next a
final:
END
Figura No. 5.8: Código fuente de la evaluación No. 6. Prueba6.pic
•
Producto: El nombre del programa objeto será Prueba6.asm
73
Después de haber compilado el código usuario y este no presentó ningún error de
sintaxis se pudo generar el código ensamblador u objeto con extensión *.ASM, ver
figura No. 5.9.
cocte
divsor
Var1
Var2
Var3L
Var3H
main
Etiq1
#include "p16f84a.inc"
Radix hex
List p=16f84a
equ
0C
equ
0D
equ
0E
equ
0F
equ
10
equ
11
MOVLW
MOVWF
0x0A
Var1
MOVLW
MOVWF
0x0A
Var2
MOVLW
SUBWF
BTFSC
GOTO
BTFSS
GOTO
GOTO
0x38
Var1,0
STATUS,Z
CondF1
STATUS,C
CondV1
CondF1
MOVLW
SUBWF
BTFSC
GOTO
GOTO
0x0A
Var2,0
STATUS,Z
CondV2
CondF2
MOVF
MOVWF
MOVLW
CLRF
Var1,0
divsor
0x02
cocte
Ciclo1
Ciclo2
CondV1
CondV2
74
CALL
MOVF
MOVWF
GOTO
Divi
cocte,0
Var2
Salir2
MOVLW
ADDWF
MOVWF
0x01
0x02,0
Var1
GOTO
Salir1
MOVF
MOVWF
MOVF
CLRF
CALL
MOVF
MOVWF
Var1,0
divsor
Var2,0
cocte
Divi
cocte,0
Var1
DECFSZ
GOTO
Var2,1
Ciclo2
DECFSZ
GOTO
Var1,1
Ciclo1
GOTO
Terminar
SUBWF
BTFSS
GOTO
INCF
GOTO
divsor,0
STATUS,C
SUM1
cocte
Divi
RETLW
0
CondF2
Salir2
CondF1
Salir1
FinCiclo2
FinCiclo1
Etiq2
Divi
SUM1
Terminar
END
Figura No. 5.9: Código ensamblador de la evaluación No. 6. Prueba6.asm
75
5.7 EVALUACIÓN No. 7
•
Prueba: El nombre del programa fuente es Prueba7.pic
Este código es editado por un usuario, el cual presenta un error sintaxis ya que todo
código fuente o usuario debe terminar con la palabra reservada END.
declare
byte a
byte conteo
enddeclare
conteo = 20
a = conteo + 15
end
a=6
Figura No. 5.10: Código fuente de la evaluación No. 7. Prueba7.pic
Como se explicó anteriormente, el código fuente establece que se debe terminar con la
palabra reservada END, que es quien indica cual es el final del programa codificado por
el usuario y en este caso no sucedió así, ya que después del la palabra END se encuentra
una línea de código más, que en ese momento no hace cumplir la sintaxis del lenguaje de
programación. Esta línea de código representa una asignación de un número a una
variable. El mensaje de error es el siguiente:
MicroPic Versión 1.0 – Error de Compilación
MicroPic – Línea
:7
MicroPic – Describe :Utilizar ‘END’ para finalizar programa
MicroPic - Lexema (5,7) => ‘end’
76
•
Producto: Como hay un error de palabras reservadas no se genera el código objeto.
5.8 EVALUACIÓN No. 8
•
Prueba: El nombre del programa fuente es Prueba8.pic
El siguiente código fue digitado con comentarios para que cualquier persona o usuario al
momento de estudiarlo u observarlo se le hiciera más fácil la comprensión del mismo,
teniendo en cuenta que este software esta en la capacidad de eliminar cualquier texto que
se encuentre después de una comilla simple, para el este será tratado como un
comentario, y el software elimina todos los comentarios al momento de realizar la
compilación. En este caso no se presentará ningún error de sintaxis. El mensaje a
visualizar es satisfactorio.
'Programa con comentarios para un mejor entendimiento
'a otros usuarios que lo quieran estudiar
DECLARE 'Inicio de la declaración de variables
BYTE L
BYTE M
BYTE N
ENDDECLARE 'Final de la declaración de variables
IF M >= N THEN 'Condicional compuesto
L=M/N
ELSE
L=N/M
ENDIF 'Cierre del condicional
END 'Fin del programa
Figura No. 5.11: Código fuente de la evaluación No. 8. Prueba8.pic
77
•
Producto: El nombre del programa objeto será Prueba8.asm
Después de haber compilado el código fuente, el cual no presentó ningún error de
sintaxis, se pudo generar el código objeto o final (ensamblador) que esta representado en
la figura No. 5.12 con extensión *.ASM.
cocte
divsor
Var1
Var2
Var3
main
#include "p16f84a.inc"
Radix hex
List p=16f84a
equ
0C
equ
0D
equ
0E
equ
0F
equ
10
MOVLW
SUBWF
BTFSC
GOTO
GOTO
Var3
Var2,0
STATUS,C
CondV1
CondF1
MOVF
MOVWF
MOVF
CLRF
CALL
MOVF
MOVWF
GOTO
Var3,0
divsor
Var2,0
cocte
Divi
cocte,0
Var1
Salir1
MOVF
MOVWF
MOVF
CLRF
CALL
MOVF
MOVWF
Var2,0
divsor
Var3,0
cocte
Divi
cocte,0
Var1
CondV1
CondF1
78
Salir1
Divi
GOTO
SUBWF
BTFSS
GOTO
INCF
GOTO
Terminar
divsor,0
STATUS,C
SUM1
cocte
Divi
RETLW
0
SUM1
Terminar
END
Figura No. 5.12: Código ensamblador de la evaluación No. 8. Prueba8.asm
Después de generadas las diferentes pruebas en el software MicroPic versión 1.0, se
procedió a utilizar el software Microchip MPLAB 5.0 y Microchip MPLAB IDE versión
6.40, el cual permite compilar el código ensamblador que se creó en cada una de las
pruebas anteriores que no presentaron ninguna clase de errores. Para poder compilar el
código ensamblador (creado en la aplicación MicroPic), se debe crear primero que todo
un proyecto en MPLAB que debe estar ubicado en la misma carpeta donde se encuentra
el archivo con extensión *.ASM que se desea compilar, después se le añade al proyecto
creado dicho archivo; finalmente se abre el archivo desde MPLAB y se procede a
compilarlo presionando la combinación de teclas Alt + F10.
Finalmente cuando se ha compila dicho archivo el software MPLAB muestra una
ventana de mensajes con los posibles errores que se han cometido o el éxito alcanzado.
Ver Figura No. 5.13.
79
Building PRUEBA1.HEX...
Compiling PRUEBA1.ASM:
Command line: "C:\ARCHIV~1\MPLAB\MPASMWIN.EXE /p16F84 /q
C:\ARCHIV~1\MICROPIC \PRUEBA1.ASM"
Message[301] C:\ARCHIV~1\MPLAB\P16F84A.INC 35 : MESSAGE:
(Processor-header file mismatch. Verify selected processor.)
Build completed successfully.
Figura No. 5.13: Mensaje de salida en MPLAB mostrando compilación satisfactoria
80
6. AUTÓMATAS FORMATOS Y SINTAXIS DE PROGRAMACIÓN
6.1
AUTÓMATA PARA NÚMEROS
Pueden ser decimales o hexadecimales los primeros son solamente combinaciones de
dígitos y los segundos son combinaciones de dígitos con letras o viceversa estos pueden
ser positivos o negativos, teniendo en cuenta que todo número debe comenzar con un
digito, así los números hexadecimales siempre se les antepone un cero (0) y luego una
equis (x) en minúscula, después de este formato se colocan números o letras desde la A
hasta la F.
Figura No. 6.1: Autómata de números decimales y hexadecimales
6.2
AUTÓMATA PARA IDENTIFICADOR
Es una variable cuyo valor puede cambiar o ser modificado durante el desarrollo o en
tiempo de ejecución de un software o programa, todo identificador debe comenzar por
una letra.
81
Figura No. 6.2: Autómata de identificadores
6.3
AUTÓMATA PARA OPERADORES RELACIONALES
En este tipo de operadores actúan el signo igual que (=), menor que (<) y mayor que (>)
los cuales se pueden combinar para originar otros operadores más como son el menor o
igual que (<=), mayor o igual que (>=) y diferente (<>).
Figura No. 6.3: Autómata de operadores lógicos
82
6.4
AUTÓMATA PARA CONDICIÓN
Figura No. 6.4: Autómata que evalúa una condición
6.5
AUTÓMATA PARA ETIQUETA
Toda etiqueta es una variable o un nombre que obligatoriamente debe estar seguida de
dos puntos:
Figura No. 6.5: Autómata de etiquetas
6.6
AUTÓMATA PARA CADENA DE CARACTERES
Las cadenas de caracteres están representadas por cualquier carácter que se encuentre
entre comillas dobles.
83
El símbolo & significa cualquier carácter.
Figura No. 6.6: Autómata de cadena de caracteres
6.7
AUTÓMATA PARA ESPACIOS EN BLANCO
Los comentarios están definidos por cualquier carácter que se encuentre después de una
comilla simple.
El símbolo & significa cualquier carácter.
Figura No. 6.7: Autómata que valida los comentarios
84
6.8
FUNCIÓN BRANCH
Sintaxis:
“BRANCH” <MOVIMIENTO>“,” “(“<ETIQUETA1>“,” <ETIQUETA2>“,” ... “,”
<ETIQUETAn>“)”
<MOVIMIENTO>: Es una variable, constante o expresión (0 - 255) que específica el
índice de la Etiqueta.
<ETIQUETA1>, <ETIQUETA2>, ... <ETIQUETAn>: Son etiquetas que especifican
donde se encuentra el siguiente proceso. BRANCH ignorará cualquier entrada de la lista
más allá de desplazamiento 255.
Figura No. 6.8: Autómata instrucción branch
6.9
FUNCIÓN COUNT
Sintaxis:
“COUNT” <PIN>“,” <DURACIÓN>“,” <VARIABLE>
85
<PIN>: Es una cons tante (0 - 15) o una palabra reservada (PIN0 - PIN1) eso específica
que las E/S se ponen en modo de entrada por defecto.
<DURACIÓN>: Es una variable, constante o expresión (1 - 65535) que específica el
tiempo o periodo durante el cual se van a contar todos los pulsos que llegan al pin
especificado.
<VARIABLE>: Es una variable (normalmente una palabra) en donde se almacenará el
total de los pulsos que llegarán al pin especificado.
Figura No. 6.9: Autómata instrucción count
6.10 FUNCIÓN DEBUG
Sintaxis:
“DEBUG” <OUTPUTDATA> {“,” <OUTPUTDATA>}
<OUTPUTDATA>: Es una variable, constante que va (0 - 65535) que específica el
rendimiento de la información. Los datos válidos o permitidos son: caracteres ASCII
(texto, cadena y caracteres de control), los números decimales (0 - 65535),
hexadecimales ($00 - $FF) o binarios (%00000000 - %11111111).
86
Figura No. 6.10: Autómata instrucción debug
6.11 FUNCIÓN END
Sintaxis:
“END”
END: Esta instrucción le permite Al software MicroPic versión 1.0 determinar el final
de todo código fuente que se desea procesar o ejecutar. Esta orden es recomendada y
obligatoria.
Figura No. 6.11: Autómata instrucción end
87
6.12 FUNCIÓN EXIT
Sintaxis:
“EXIT”
EXIT: Permite al programa MicroPic terminar o salir de las estructuras de ciclo s
repetitivos tales como el FOR…NEXT. Esta instrucción solo esta permitida dentro de
los ciclos repetitivos.
Figura No. 6.12 Autómata instrucción exit
6.13 FUNCIÓN FOR...NEXT
Sintaxis: En la sintaxis del ciclo FOR…NEXT, la variable inicial siempre debe iniciar
en uno y la variable final termina el ciclo hasta n, y solo permite incrementar a la
variable contador de uno en uno.
“FOR” <CONTADOR> “=” <VAL_INI> “TO” <VAL_FIN>
<EXPRESIÓN>
“NEXT” <CONTADOR>
<CONTADOR>: Es una variable normalmente un byte que se usa como un contador.
88
<VAL_INI>: Es una constante numérica con el valor de uno (1).
<VAL_FIN>: Es una variable o constante (0 - 65535) que específica el valor final de la
variable Contador. Cuando el valor de Contador es fuera del rango del valo r inicial y el
valor final, el FOR...NEXT en la próxima vuelta deja de ejecutar y el programa va a
NEXT para ejecutar las siguientes instrucciones.
<EXPRESIÓN>: Una expresión es una serie de instrucciones definidas para el
compilador, y que permite validar sus respectivas sintaxis, es decir, que dentro de un
condicional se puede encontrar un ciclo, un condicional, una instrucción exit, goto, etc.
Figura No. 6.13: Autómata del ciclo for...next
6.14 FUNCIÓN GOSUB
Sintaxis:
“GOSUB” <ETIQUETA>
89
<ETIQUETA>: Es una etiqueta que específica donde esta la rutina a llamada.
Figura No. 6.14: Autómata instrucción gosub
6.15 FUNCIÓN GOTO
Sintaxis:
“GOTO” <ETIQUETA>
<ETIQUETA>: Es una etiqueta que específica dónde ir.
Figura No. 6.15: Autómata instrucción goto
6.16 FUNCIÓN HIGH
Sintaxis:
“HIGH” <PIN>
90
<PIN>: Es una constante (0 - 15) o una palabra reservada (PIN0 - PIN1) la cual
específica que las E/S se ponen en modo de entrada por defecto.
Figura No. 6.16: Autómata instrucción high
6.17 FUNCIÓN IF…THEN…ELSEIE…ENDIF
Sintaxis: La instrucción IF…THEN…ELSEIF…ENDIF maneja dos tipos de sintaxis, el
condicional simple y el compuesto.
•
Condicional simple:
“IF” <CONDICIÓN> “THEN”
<EXPRESIÓN>
“ENDIF”
•
Condicional compuesto:
“IF” <CONDICIÓN> “THEN”
<EXPRESIÓN>
“ELSE”
< EXPRESIÓN >
“ENDIF”
91
<CONDICIÓN>: Es una declaración, como “x = 7” que puede evaluarse como
verdadero o falso.
<EXPRESIÓN>: Una expresión es una serie de instrucciones definidas para el
compilador, y que permite validar sus respectivas sintaxis, es decir, que dentro de un
condicional se puede encontrar un ciclo, un condicional, una instrucción exit, goto, etc.
Figura No. 6.17: Autómata del condicional if…then…elseif…endif
6.18 FUNCIÓN INPUT
Sintaxis:
“INPUT” <PIN>
<PIN>: Es una constante (0 - 15) o una palabra reservada (PIN0 - PIN1) quien
específica que las E/S se ponen en modo de entrada por defecto.
92
Figura No. 6.18: Autómata instrucción input
6.19 FUNCIÓN LOW
Sintaxis:
“LOW” <PIN>
<PIN>: Es una constante (0 - 15) o una palabra reservada (PIN0 - PIN1) la cual
específica que las E/S se ponen en modo de entrada por defecto.
Figura No. 6.19: Autómata instrucción low
6.20 FUNCIÓN OUTPUT
Sintaxis:
“OUTPUT” <PIN>
93
<PIN>: Es una constante (0 - 15) o una palabra reservada (PIN0 - PIN1) quien
específica que las E/S se ponen en modo de entrada por defecto.
Figura No. 6.20: Autómata instrucción output
6.21 FUNCIÓN PAUSE
Sintaxis:
“PAUSE” <DURACIÓN>
<DURACIÓN>: Es un variable, constante (0 - 65535) que específica la duración de la
pausa.
Figura No. 6.21: Autómata instrucción pause
94
6.22 FUNCIÓN RANDOM
Sintaxis:
“RANDOM” <VARIABLE>
<VARIABLE>: Es una variable (normalmente una palabra) donde se producirá un
número aleatorio. Los actos inconstantes como la entrada de azar y su rendimiento del
resultado.
Figura No. 6.22: Autómata instrucción random
6.23 FUNCIÓN READ
Sintaxis:
“READ” <LOCALIZACIÓN>“,” <VARIABLE>
<LOCALIZACIÓN>: Es una variable, constante que oscila entre (0 – 255) y específica
la dirección de memoria para leer.
<VARIABLE>: Es una variable (normalmente un byte) donde el valor se guarda.
95
Figura No. 6.23: Autómata instrucción read
6.24 FUNCIÓN RETURN
Sintaxis:
“RETURN”
RETURN: Esta instrucción retorna de un subprograma o rutina que previamente fue
llamada con la instrucción GOSUB.
Figura No. 6.24: Autómata instrucción return
6.25 FUNCIÓN SLEEP
Sintaxis:
“SLEEP”
96
SLEEP: Envía a MicroPic a dormir, es decir, a un estado de bajo consumo en un tiempo
indefinido.
Figura No. 6.25: Autómata instrucción sleep
6.26 FUNCIÓN WRITE
Sintaxis:
“WRITE” <LOCALIZACIÓN>“,” <DATO>
<LOCALIZACIÓN>: Es una variable, constante que oscila entre (0 – 255) y específica
la dirección de memoria para escribir.
<DATO>: Es una variable, constante que contiene el valor a escribir.
Figura No. 6.26: Autómata instrucción read
97
6.27 AUTÓMATA Y PSEUDOCÓDIGO QUE PERMITE EVALUAR LAS
INSTRUCCIONES (GOSUB, GOTO)
Diagrama 7: Autómata de instrucciones que comienzan con la letra G
98
Figura No. 6.27: Pseudocódigo de ins trucciones que comienzan con la letra G
99
6.28 AUTÓMATA Y PSEUDOCÓDIGO QUE PERMITE EVALUAR LAS
INSTRUCCIONES (RANDOM, READ, RETURN)
Diagrama 8: Autómata de instrucciones que comienzan con la letra R
100
Figura No. 6.28: Pseudocódigo de instrucciones que comienzan con la letra R
101
RECOMENDACIONES
Este proyecto desarrolla un sistema compilador que permite generar código
ensamblador, manejando instrucciones Basic que se deben procesar o compilar para
luego generar o convertir su respectivo código ensamblador siempre y cuando no se
presenten errores de sintaxis.
Para futuros trabajos que tengan como base este proyecto se recomienda desarrollar un
módulo adicional para implementar la fase de generación de código máquina con
extensión *.HEX. Dado que la delimitación de este proyecto consistía en la generación
de código ensamblador, cuyo objetivo fue alcanzado satisfactoriamente. Con la finalidad
de brindar un mejor soporte a futuros proyectos se anexa toda la información referente a
los autómatas, pseudocódigo y diagramas de flujo de las instrucciones utilizadas en
ensamblador con sus respectivas sintaxis, además la codificación a lenguaje máquina.
Además todas las instrucciones no están implementadas para generar el código
ensamblador ya que nuestra delimitación era implementar las más utilizadas, pero se
dejo terminado el proceso de coger todas las instrucciones y verificar su sintaxis en el
código usuario, también para nuestro caso la asignación es simple, es decir, solo recibe
un parámetro o dos como máximo por la complejidad de transformarlo a su respectivo
código ensamblador, teniendo en cuenta las limitaciones con las que cuenta el
microcontrolador PIC 16f84, pero se dejo implementada la función de la asignación que
permite la combinación de todos los operadores aritméticos tales como la suma, resta,
multiplicación y división, utilizando árboles binarios e infinito número de términos. Hay
que tener en cuenta que este proyecto es un software totalmente abierto para mejorar
posteriores a su diseño inicial.
102
CONCLUSIONES
A través del presente proyecto, se efectuó la primera versión del software MicroPic
versión 1.0, el cual está basado en dos lenguajes de programación distintos tales como:
Borland C++ 5.02 y Visual Basic 6.0. El primero maneja todo el módulo para el
aprendizaje del software, es decir, quien maneja todas las etapas de recorrido, análisis
léxico, análisis sintáctico, análisis semántico e interpretación a código ensamblador y el
otro lenguaje es quien maneja el módulo de la interfaz de usuario.
MicroPic versión 1.0 refleja todas las ventajas e innovaciones planteadas en esta
investigación.
El diseño de este Software presentó ciertas dificultades al momento de manejar o definir
el entorno gráfico, ya que se quería que el usuario pudiera manipular los dos editores
desde una misma ventana y no desde diferentes, también que permitiera la presentación
de las variables, lexemas, etiquetas desde listas para poder observar sus características
más importantes, los criterios y el buen gusto para definir los colores están a la merced
del usuario.
MicroPic versión 1.0 es una herramienta que permite la traducción del código digitado
por el usuario en un lenguaje de alto nivel “instrucciones en lenguaje Basic” a otro
lenguaje de bajo nivel “ensamblador” esta conversión la realiza el lenguaje Borland C++
mediante el concepto de clase, estructuras, arreglos y apuntadores. El código fuente es
guardado en un archivo con extensión *.PIC y el código objeto con extensión *.ASM.
103
BIBLIOGRAFÍA
•
AHO SETHI ULLMAN, Compiladores Principios, Técnicas y Herramientas,
Pearson.
•
CHRISTIAN TAVERNIER, Microcontroladores Pic, Editorial Paraninfo.
•
JOSÉ ADOLFO GONZÁLEZ V., Introducción a los Microcontroladores, McGraw
Hill.
•
J. MARIA ANGULO USATEGUI, E. MARTÍN CUENCA Y J. ANGULO
MARTÍNEZ, Aplicaciones de los Microcontroladores Pic de Microchip, Editorial
McGraw Hill, 1998
•
ANGULO Y OTROS, Microcontroladores Pic, La solución en un solo chip,
Editorial Paraninfo
•
ANGULO Y OTROS, Microcontroladores Pic, Diseño de aplicaciones, Mc Graw
Hill
•
MPASM assembler. User’s Guide, Microchip
•
Curso Básico de Microcontroladores Pic. Cekit
•
MPLAB IDE User’s Guide, Microchip.
•
SANDERS, DONAL H., Informática Presente y Futuro, Editorial Mc Graw Hill,
México.
•
www.microchip.com
•
LUIS
FRINO,
Instrucciones
para
el
PIC16C84
y
PIC16F84,
http://www.frino.com.ar/basic1.htm
•
Basic Stamp BS2-IC, http://www.plazacolima.com/pagper/fuentesg/historia.htm
•
Basic Stamp 2, http://www.superrobotica.com/S310130.htm
104
MANUAL DE USUARIO
SOFTWARE COMPILADOR EN LENGUAJE DE ALTO NIVEL QUE GENERA
CÓDIGO ENSAMBLADOR PARA LA IMPLEMENTACIÓN EN
MICROCONTROLADORES PIC 16X
JULIÁN ROBERTO HERNÁNDEZ DÍAZ
JAVIER MEZA CARABALLO
CORPORACIÓN UNIVERSITARIA RAFAEL NÚÑEZ
FACULTAD DE INGENIERÍA DE SISTEMAS
CARTAGENA DE INDIAS D.T. Y C., JUNIO DE 2005
106
INTRODUCCIÓN
El software MCROPIC es una aplicación diseñada para manipular código escrito por
usuario, que utiliza un formato de instrucciones muy similar a las del Stamp Basic V2.1
que es un lenguaje para el manejo de Microprocesadores. Además el software permite
programar sin la necesidad de ser un experto en programación simplemente tener los
conocimientos básicos de Windows.
Con lo anteriormente aclarado este manual tendrá la capacidad de orientar al usuario
para el correcto manejo de las operaciones. El manual contiene información pertinente a
la instalación y manipulación del software y una detallada descripción de su interfaz.
El software maneja cinco fases o etapas fundamentales:
1. Manipulación de documentos (Nuevo, Abrir, Guardar o Actualización, Guardar
Como ó Copias de documentos, etc.).
2. Codificación de instrucciones y ejecución del documento.
3. Creación y muestreo del código ensamblador (Archivo *.ASM).
4. Muestreo de Características de Compilación
5. Ayuda (Acerca de MICROPIC, Contenido).
107
1. REQUERIMIENTOS MÍNIMOS DEL SISTEMA
MICROPIC es una aplicación basada esencialmente bajo Borland C++ que es un
lenguaje orientado a objetos de la cuarta ge neración que permite crear código objeto
*.exe compatible con la mayoría de las plataformas existentes en el mercado tales como
Microsoft Windows, Unix, Linux, entre otros sistemas operativos, por lo cual todo el
análisis y manipulación de código intermedio (lenguaje en ensamblador) esta basado
bajo ventanas MS-DOS. Aunque todo el diseño fue realizado bajo otro lenguaje de
cuarta generación como es Visual Basic 6.0 que crea código objeto *.exe que por lo
general se ejecutan sobre aquellas plataformas en las cuales se generaron.
Por lo tanto entre los requerimientos mínimos para que MICROPIC funcione
adecuadamente son los siguientes:
•
Sistema operativo: Windows NT, Windows XP, Windows Milenio, y la familia
de las plataformas Windows 9x.
•
Memoria: 64 MB, el agregado de más memoria hace que la compilación de
codificación extensa sea rápidas.
•
Procesador: familia de Procesadores Pentium II desde 400 Mhz y Familia de
Procesadores Pentium III y Pentium IV.
•
Microsoft Internet Explorer versión 4.0 y versiones superiores.
108
2. GUÍA DE INSTALACIÓN DE MICROPIC
Para el buen manejo de la aplicación MICROPIC.EXE se debe seguir cuidadosamente
los pasos de instalación. Si al seguir los pasos y se efectúa un error imprevisto por favor
consultar al soporte técnico de MIC ROPIC. Los pasos que debe seguir el usuario son los
siguientes:
1. Insertar el CD de instalación en la unidad CD - ROM de lectura de su equipo. El
programa de instalación se ejecutara automáticamente al leer el CD. Si por algún
motivo el computador en que se va a instalar el software tiene desactivada la opción
de ejecución inmediata del CD o auto - run, entonces se debe acudir a la información
del CD a través del explorador de Windows u otro programa y ejecutar la aplicación
de instalación SETUP.EXE como se muestra en la Figura No. 1 y seguir los pasos de
la instalación que le presenta asistente.
Figura No.1: Icono de instalación de MICROPIC.
2. Una vez inicializada la instalación le aparecerá la primera pantalla
Figura No.2: ventana de Inicialización
109
3. La instalación le estará mostrando una ventana de bienvenida a la configuración e
instalación del sistema MicroPic Versión 1.0, ver Figura No. 3.
Figura No. 3: Bienvenidos al programa de instalación.
4. Muestra el primer asistente que le guiará en el transcurso de la instalación (Figura
No. 4). En esta ventana se le pide al usuario que escoja la carpeta donde quiere que
se almacenen los archivos de instalación del software. Por ser una aplicación más
para su computador, la ruta que aparece por defecto es C:\Archivos de
programa \MicroPic, como ocurre cuando se desea instalar cualquier software en su
PC.
Figura No.4: Diálogo para seleccionar la ruta de instalación.
5. El directorio de instalación de la aplicación MicroPic tendrá el nombre de
“C:\Archivos de programa\MicroPic” que es donde estarán guardados los *.exe que
el software necesita para su correcta ejecución. El usuario está en la libertad de
110
cambiar dicha ruta dando clic en el botón “Cambiar directorio” y escogiendo la
carpeta deseada, como se muestra en la Figura No. 5.
Figura No. 5: Ventana para seleccionar la carpeta deseada
6. Una vez seleccionada la carpeta y comprobado si hay espacio en disco el usuario
debe proceder a iniciar la instalación del software dando clic en el botón Instalar, ver
Figura No.4. Si desea cancelar la instalación debe dar clic en el botón Salir.
7. En la secuencia de instalación el asistente pregunta si desea ingresar el software al
grupo de la barra de inicio de Windows (Figura No. 6). Presione el botón Continuar
para seguir con la instalación.
Figura No. 6: Ventana para agregar al grupo de programas existentes
111
Al iniciar la instalación el asistente le presentará una ventana de dialogo con una barra
de progreso indicando el avance de instalación de las diferentes librería necesarias para
la ejecución de MICROPIC.EXE hasta que ésta finaliza. Ver la Figura No 7.
Figura No. 7: Transcurso de la instalación
Antes de finalizar la instalación, el usuario puede detener la instalación y cancelarla. Si
esto ocurre el asistente le pedirá que confirme la acción (Figura No. 8).
Figura No.8: Confirmación de la cancelación de la instalación
Al dar clic el botón “Sí” se cancelará la instalación y, por el contrario, si se da clic en el
botón “No” la instalación continuará y finaliza con un mensaje. (Figura No. 9).
112
Figura No. 9. Confirmación de instalación completada.
Se recomienda reiniciar su equipo para actualizar la base de datos del sistema. Al
reiniciar el software estará listo para su ejecución. El asistente de instalación colocará
por defecto un acceso directo a la aplicación (MICROPIC.EXE) en la opción programas
del menú inicio de Windows.
113
3. MANEJO Y CARACTERÍSTICAS SISTEMA MICROPIC
3.1 INICIALIZACIÓN DEL SISTEMA MICROPIC
La primera interfaz que será vista por el usuario es la de inicio del sistema, en la cual se
indican algunos datos concernientes al software y sus autores, dando de igual manera la
bienvenida al usuario, esta ventana inicial tiene una duración de ejecución alrededor de
los 3 segundos sin ninguna manipulación de evento que pueda interrumpir la publicidad
del software y sus autores (ver Figura 10).
Figura No.10: Pantalla de inicialización y presentación
Una vez mostrada la ventana de inicialización y presentación de la aplicación MicroPic
versión 1.0, se prosigue a hacer visible el formulario (Software para el manejo de
Microprocesadores). Este formulario será la ventana “principal”. En este formulario
principal se puede tener acceso a los diferentes menús de operaciones.
El sistema esta constituido por una ventana principal que contendrá el desarrollo y la
presentación de operaciones que estará manipulando el sistema. Ver Figura No.11
114
Figura No. 11. Formulario Principal de MicroPic
El formulario Principal esta diseñado con un menú de opciones las cuales poseen cuatros
jerarquías operacionales o menú principal la cual se distribuye de la siguiente manera:
- Menú Archivos
- Menú Ver
- Menú Ejecutar
- Ayuda
Figura No. 12: Menú Principal de Operaciones
Además de estar constituidas por medio de Menú las operaciones, estas de igual forma
están disponibles de cómo acceso directo por medio de una barra de herramientas las
cuales contiene todas las operaciones definidas en los menús mostradas como botones de
comando que hacen más amigable la realización de acciones directas a través de un clic
115
del mouse o con un <ENTER> según la localización o el enfoque de los botones. Ver
Barra de Herramientas en la figura siguiente.
Figura No. 13: Barra de Herramientas de Operaciones
Esta es una especificación de la función que cumple cada uno de los botones que
conforman a la barra de herramientas del software Compilador MicroPic versión 1.0.
Este botón permite crear un nuevo documento o archivo fuente el cual tendrá la
extensión *.PIC.
Este botón permite abrir todos los documentos con extensión *.PIC existentes en
el sistema.
Este botón permite guardar los cambios realizados a los documentos abiertos, si
son por primera vez se abre la ve ntana Guardar como.
Este botón permite visualizar la tabla que enlista todas las variables declaradas
en el archivo fuente con sus características.
Este botón permite visualizar la tabla que enlista todos los lexemas digitados en
el archivo fuente con sus características y ubicación.
Este botón permite visualizar la tabla que enlista todas las etiquetas utilizadas en
el archivo fuente con sus características.
116
Este botón permite mostrar el código ensamblador como resultado de la
compilación del código fuente.
Este botón permite la compilación del código fuente.
Este botón permite la visualización de los autores de este software, versión y
otros detalles.
Este botón permite abrir las ayudas disponibles acerca del manejo y sintaxis de
las intrusiones que maneja MicroPic.
Este botón permite salir de la aplicación MicroPic.
Esta opción permite cambiar el estilo o la piel del
entorno gráfico.
3.2 MENÚ ARCHIVO
El Menú Archivo contiene las opciones esenciales para el manejo de los sistemas MCD
que el usuario va ha manipular, estas opciones son:
-
Menú Archivo
-
Submenú Nuevo
-
Submenú Abrir
-
Submenú Guardar
-
Submenú Guardar como
-
Submenú Cerrar
117
-
Submenú Salir
Figura No. 14. Despliegue del Menú Archivos
3.2.1 Submenú Nuevo
El submenú Nuevo tiene como principal característica de crear un nuevo documento. Por
lo cual se necesita que el usuario proporcione un nombre al nuevo documento con el
cual se guardará más adelante en un archivo plano con extensión *.pic además la
cantidad de conceptos (Nodos) con la cual se estará graficando el sistema a modelar.
Para tal fin el submenú Nuevo visualiza el formulario creación de documentos *.pic en
el cual se digitaliza el nombre del documento y se especifica el directorio en donde se
almacenará.
Figura No. 15. Ventana para guardar documentos
118
Con esta opción hay que tener cuidado, ya que si el documento que se va a crear existe,
enviará un mensaje para confirmar si desea reemplazar el archivo; si se escoge la opción
si se reemplazará el archivo de lo contrario permite cambiar el nombre o el destino del
archivo.
Figura No. 16: Confirmación de archivo existente
Esta ventana tiene la característica de ingresar el nombre del documento a través de una
caja de texto con etiqueta Nombre del archivo la cual permite el ingreso de los caracteres
tipo letras y números. El nombre del documento se digitaliza sin la necesidad de
colocarle la extensión *.PIC, ya que el sistema se encarga de adicionarlo. Además como
anteriormente se había mencionado en este formulario se especifica la ruta exacta en
donde se almacenara el documento. Según la ruta especifica el formulario recupera la
lista de los documentos *.PIC.
Solo digitalizando el nombre del documento y presionando la tecla guardar el
documento se almacenara en el directorio especificado.
El comando Cancelar es con el fin de cerrar el formulario Creación sin que este cause
alguna operación adicional.
Para manipular el código fuente de los documentos creados aparece una ventana con las
siguientes características:
119
Figura No. 17: Ventana de codificación y muestreo de lenguaje ensamblador
Caja de texto multilínea izquierda permite digitaliza del código fuente que el sistema
verifica su sintaxis para luego generar código ensamblador. Esta caja de texto de ingreso
esta limitada a 65535 caracteres. A partir de la digitalización del lenguaje de Micropic el
sistema guarda temporalmente el código de esta caja para traducirlo y mostrar el código
generado.
Caja de texto multilínea derecha permite el muestreo del código interpretado por el
sistema este código como anteriormente se ha hecho mención esta constituido en el
leguaje de bajo nivel ensamblador.
Control multilínea localizado en la parte inferior que se encarga de mostrar el resultado
de ejecutar el código fuente ingresado o recuperado por el usuario.
120
3.2.2 Submenú Abrir
El submenú Abrir se caracteriza por buscar los archivos que con anterioridad se han
creado o guardado, por lo cual al hacer clic sobre esta opción se realiza el llamado al
formulario de abertura de documentos guardados que por defecto.
Figura No. 18: Formulario para abrir documentos.
Este formulario esta diseñado con un control que enlista las carpetas en donde se pueden
buscar el archivo indicado, estos archivos tienen como característica la extensión *.PIC.
Además posee un control que muestra todos los archivos con esta extensión, cada uno de
estos archivos es un código fuente almacenado.
Solo señalando el archivo se activa el comando abrir con el cual se puede dar doble clic
o <ENTER> para ver la codificación almacenada. El comando Cancelar permite omitir
la operación de abertura de documentos por lo cual permite regresar a la pantalla
principal sin efectuarse alguna operación adicional. Método abreviado es Ctrl + A.
Si por cualquier motivo usted vuelve a intentar abrir un documento que esta actualmente
abierto este le envía un mensaje de verificación. Si escoge la opción si reemplazará al
121
archivo con el que se abrirá sin tener en cuenta los cambios no guardados de lo contrario
quedará el actual. Ver figura No. 19.
Figura No. 19: Verificación de apertura de archivo abierto.
3.3.3 Submenú Guardar
El submenú Guardar se encarga de guardar un archivo que ya ha sido abierto esto quiere
decir que esta operación se encarga de actualizar el documento que con anterioridad fue
almacenado. Al hacer clic sobre esta opción simplemente el sistema ejecuta la operación
de guardar o el de sobrescribir en el caso que ya exista este archivo y lo que se desea es
actualizar los cambios realizados en el código fuente. El método abreviado es Ctrl + G.
3.3.4 Submenú Guardar como
Este submenú se encarga de guardar los cambios realizados de un archivo en un
directorio destino diferente al actual si se desea o cambiar el nombre del documento o
archivo que se está trabajando. El método abreviado es Ctrl + D.
La ventana que se despliega al elegir esta opción es la misma que se abre al dar clic en la
opción Nuevo del menú Archivo.
122
3.3.5 Submenú Cerrar
Este submenú se encarga de cerrar el documento actualmente abierto. En el caso que se
cierre el documento y se halla efectuado cambios se activara un mensaje de
confirmación para ver si se desean guardar los cambios o no en el archivo, para mayor
tranquilidad de algunos casos se recomienda guardar todos los cambios efectuados
haciendo clic sobre la opción Guardar. Para ejecutar esta operación puede abreviarla
presionando la tecla Alt + A seguida de la tecla “C” o Ctrl + F4.
Figura No. 20: Confirmación de Guardar cambios efectuados al archivo.
3.3.6 Submenú Salir
El submenú Salir realiza la operación de Finalizar por completo el programa. Al hacer
clic sobre el menú salir se cerrará todos los formularios abiertos en el momento y si el
archivo tiene cambios y no se han guardado se envía un mensaje de confirmación al
igual que en el submenú visto anteriormente. Ver figura No. 20.
3.4 MENU VER
El menú Ver posee las opciones o submenú de eventos de:
-
Menú Ver
123
-
Submenú Barra de menú
-
Submenú Características del código
- Submenú Variables
- Submenú Lexemas
- Submenú Etiquetas
- Submenú Archivo *ASM
Figura No. 21 Menú Ver del formulario principal
3.4.1 Submenú Barra de Menú
Este submenú determina si el sistema realiza la opción de mostrar u ocultar la barra de
herramientas en donde se encuentra las operaciones de los menús principales para la
manipulación de archivo y ejecución de código fuente.
3.4.2 Submenú Características del Código
Es un submenú de nivel secundario que contiene la lista de las características esenciales
al ejecutar un documento con sintaxis correcta este menú es activo solo cuando se ha
compilado el documento fuente, en el caso contrario este menú permanece inactivo solo
hasta ejecutar la operación de compilación.
124
3.4.2.1 Submenú Variables
Este submenú se encarga de mostrar un formulario con todas las variables declaradas
dentro del código fuente de un documento activo y ejecutado. El formulario mostrará las
variables declaradas con sus respectivas variables genéricas que manipulará el código
ensamblador. Ver Figura No. 22.
Figura No. 22: Formulario lista de variables declaradas
3.4.2.2 Submenú Lexemas
Este submenú se encarga de mostrar un formulario con todos los lexemas digitalizados
dentro del código fuente de un documento activo y ejecutado. El formulario mostrará los
lexemas con las características del lexema encontrado, el tipo de lexema, la fila y
columna dentro del código fuente en donde fue almacenada. Ver Figura No. 23.
125
Figura No. 23: Lista de lexemas del código fuente
3.4.2.3 Submenú Etiquetas
Este submenú se encarga de mostrar un formulario con todas las etiquetas digitalizados
dentro del código fuente de un documento activo y ejecutado. El formulario mostrará las
etiquetas declaradas con sus respectivas etiquetas genéricas que manipulará el código
ensamblador. Ver Figura No. 24.
Figura No. 24: Lista de etiquetas del código fuente
126
3.4.2.4 Submenú Archivo *.ASM
Este menú se encarga de mostrar una caja de texto con todo el código ensamblador
generado por la compilación del código fuente. El código ensamblador se guarda
automáticamente en la misma carpeta donde encuentra el archivo fuente y se almacena
con el mismo nombre pero con la extensión *.ASM, el método abreviado de esta opción
es presionando la tecla F9. Ver Figura No. 25.
Figura No. 25: Caja que contiene el código ensamblador.
3.5 MENÚ EJECUTAR
El menú ejecutar es una de las opciones esenciales para la manipulación y construcción
del código intermedio en el cual se basa todo el sistema este menú esta constituido por:
-
Menú Ejecutar
-
Submenú Compilar.
127
Figura No. 26: Menú de opciones Ejecutar
3.5.1 Submenú Compilar
Este submenú se encarga de recolectar el código fuente almacenado en la caja de texto e
ingresarlo en un archivo plano para luego ejecutar el analizador léxico, sintáctico y
semántico. Además de crear un archivo con extensión *.ASM que posteriormente se
puede mostrar en pantalla.
La compilación de esta operación esta determinada por un tiempo en el cual la lista de
respuesta se hace invisible y la caja de texto del código ensamblador cambia de color
indicando que fase de análisis esta en ejecución.
3.6 MENÚ AYUDA
El menú ayuda posee las opciones o submenú de eventos tales como:
-
Menú Ayuda
-
Submenú Acerca de Micropic...
-
Submenú Contenido
Las cuales permanecen activas mientras no este abierto documento alguno pero si se
hace acción de estas operaciones se desactiva el menú Ayuda haciendo que no se pueda
hacer uso de una operación que sé esta ejecutando.
128
Figura No. 27: Despliegue de opciones del Menú Ayuda
3.6.1 Submenú Acerca de MicroPIC 1.0
Este submenú se encarga de presentar el nombre de la aplicación y su versión, los
autores y unas advertencias acerca del producto o software por la reproducción y
distribución sin el consentimiento o autorización de los autores.
Figura No. 28: Formulario Acerca de MicroPIC 1.0
3.6.2 Submenú Contenido
Este submenú se encarga de presentar una guía del manejo y las características con las
que trabaja el programa MicroPic versión 1.0 esta presentación se hace a través de un
129
formulario que despliega varias páginas htm describiendo las partes esenciales del
software y su manejo.
Al momento que el formulario contenido sé esta ejecutando solo se puede establece esta
única operación ya que esta operación inhabilita las demás operaciones como son las del
menú principal: Menú Archivos, Menú Ver, Menú Ejecutar y el Menú Ayuda. Al salir
de este formulario el menú principal puede establecerse a su normalidad y de esta
manera llegar a procesarse cualquiera de las opciones visibles.
Figura No. 29: Formulario contenido
130
MANUAL DE SISTEMA DEL PROYECTO MICROPIC
JULIÁN ROBERTO HERNÁNDEZ DÍAZ
JAVIER MEZA CARABALLO
CORPORACIÓN UNIVERSITARIA RAFAEL NÚÑEZ
FACULTAD DE INGENIERÍA DE SISTEMAS
CARTAGENA DE INDIAS D.T. Y C., JUNIO DE 2005
132
1. SOFTWARE COMPILADOR EN LENGUAJE DE ALTO NIVEL
QUE GENERA CÓDIGO ENSAMBLADOR PARA LA
IMPLEMENTACIÓN EN MICROCONTROLADORES PIC 16X
1.1. GENERALIDADES
El sistema esta implementado bajo la programación de los lenguajes de cuarta
generación como es el caso de Visual Basic 6.0 en el cual se estuvo trabajando toda la
interfaz de usuario. La programación de la interfaz de usuario se logro bajo
conocimientos básicos de la programación de Visual Basic. Además sé eligió el
compilador de Visual Basic 6.0 por que al momento de programar resultado es un
lenguaje muy amigable. Por otra parte se describe la programación de MicroPic v1.0
bajo él intérprete de lenguaje Borland C++ Versión 5.02 ya que este suministra una
programación jerárquica, es decir, orientado a objeto de formación de estructuras de
cuarta generación de intérpretes de código intermedio.
La codificación del desarrollo y manejo del código usuario esta dada bajo el lenguaje
Borland C++, esto quiere decir, que todas las etapas de recorrido, análisis léxico, análisis
sintáctico, análisis semántico e interpretación a código ensamblador fue diseñada bajo la
programación de Borland C++, el llamado de ejecutables construidos en este lenguaje se
realiza desde la interfaz de usuario construida en Visual Basic.
Interactuando estos dos lenguajes se logró el producto final del software MicroPic
versión 1.0. Visual Basic aportando un entorno amigable al usuario y Borland C++
ejerciendo las operaciones a través de ventanas de plataformas MS-DOS.
133
2. COMPILADOR GENERADOR DE CÓDIGO ENSAMBLADOR
2.1 PROGRAMA PRINCIPAL
El compilador o intérprete de código intermedio a lenguaje ensamblador fue construido
como anteriormente se mencionó en Borland C++ 5.02. Para ello se construyeron
librerías individuales en las cuales se hace uso en conjunto en el momento de agilizar
una compilación de código fuente.
Entre el conjunto de librerías se construyeron:
-
Librerías para la declaración de clases o estructuras.
-
Librerías para la formulación de autómatas o eventos de las estructuras antes
definidas.
Cada evento de una clase se organizó incluyendo cada una de estas funciones en
librerías con características similares como la inicial de su nombre. Ver figura No. 1.
A continuación se presenta el código principal encargado de utilizar las clases o
estructuras, para así construir objetos y acceder a los diferentes eventos de las clases o
funciones de las estructuras. El programa y la codificación principal se encuentran
localizadas en un archivo con una extensión característica de Borland C++ (*.CPP)
llamado “Struct Semantico.cpp” a partir de la cual se realizan todas las operaciones de
recolección de datos, búsqueda y análisis.
134
//LIBRERIAS NECESARIAS PARA LA EJECUCION DE PROCEDIMIENTOS
//Librerías propias de Borland C++
#include <iostream.h>
#include <conio.h>
#include <stdlib.h>
#include <stdio.h>
#include <dos.h>
#include <string.h>
//Librerías para la declaración de clases
#include <ClaseEti.h>
#include <ClaseVar.h>
#include <ClaseLex.h>
#include <ClaseAut.h>
//Librerías para la realización de Autómatas
#include <Automata_A.h>
#include <Automata_B.h>
#include <Automata_C.h>
#include <Automata_D.h>
#include <Automata_E.h>
#include <Automata_F.h>
#include <Automata_G.h>
#include <Automata_H.h>
#include <Automata_I.h>
#include <Automata_L.h>
#include <Automata_M.h>
#include <Automata_N.h>
#include <Automata_O.h>
#include <Automata_P.h>
#include <Automata_R.h>
#include <Automata_S.h>
#include <Automata_T.h>
#include <Automata_V.h>
#include <Automata_W.h>
Figura No. 1: Librerías de encabezamiento del programa principal
135
Llamado de librerías con extensión (*.h) útiles para la compilación del programa
principal de las cuales se incluyen las estructuras necesarias para la creación de eventos,
entre ellas se incluyen la lista de errores, la lista de variables, la lista de lexemas e
información de las palabras reservadas del lenguaje.
//***************************************\\
//********Programa Principal*********\\
//***************************************\\
void main()
{
//Limpiar Pantalla MS-DOS
clrscr();
//Declaración y construcción del Objeto AUTOMATAS
AUTOMATAS Obj;
//Llamado al evento BUSCA_LEXEMA de la Clase AUTOMATAS
Obj.BUSCA_LEXEMAS();
//Llamado al evento PRINCIPAL de la Clase AUTOMATAS
Obj.PRINCIPAL();
//*** Fin del Programa Principal ***//
return;
}
Figura No. 2: Programa principal realizador de operaciones
En el programa principal se describe un objeto de la clase AUTOMATAS la cual hereda
los atributos y eventos de las otras estructuras y en la cual se hace el aprendizaje del
compilador Micropic v1.0. El objeto declarado hace referencia a la función
BUSCA_LEXEMAS() que hace la búsqueda de los lexemas incluidos en el archivo
plano codigofuente.txt para luego hacer referencia al evento PRINCIPAL() que se
encarga
de
realizar
los
analizadores
sintáctico
simultáneamente.
136
y
semántico
que
trabajan
2.2 DECLARACION DE ESTRUCTURAS
Las clases en C++ son definidas de dos formas una de ellas es por medio de la palabra
reservada class que se caracteriza por que las variables declaradas dentro de ella son
tomadas por defecto privadas esto limita a que se definan los eventos externos con la
palabra reservada public.
Por otra parte, las clases en C++ también se pueden definir con la palabra reservada
struct que por defecto todas sus variables son tomadas de manera publica por lo cual se
entiende que sus eventos privados son definidos con la palabra reservada private. Para
la codificación actual utilizamos clases bajo la definición de la palabra reservada
STRUCT.
2.2.1 Estructura lista de etiquetas
struct LISTA_ETIQUETAS
{
char *Eti; //Nombre de la etiqueta
char IdEti[10]; //Nombre genérico dado a la etiqueta
struct LISTA_ETIQUETAS *s; //Etiqueta siguiente
};
Figura No. 3: Estructura de lista de etiquetas
La estructura o clase LISTA_ETIQUETAS consta de tres campos, dos de tipo cadena en
los cuales se almacenará el nombre de la etiqueta y el nombre genérico de la etiqueta
respectivamente, el nombre genérico de la etiqueta permitirá identificar a una etiqueta
cuando se encuentre codificada en el lenguaje ensamblador. Y el tercer campo es un
137
puntero que guarda la dirección de la siguiente etiqueta, estableciendo de esta manera el
tratamiento de una lista enlazada sencilla o simple.
2.2.2 Estructura lista de variables
struct LISTA_VARIABLES
{
char *Var; //Nombre de la Variable lexema
char *TipVar; //Tipo de Variable encontrada
char IdVar[10]; //Nombre genérico dado a la variable
float ValVar; //Valor de la variable
struct LISTA_VARIABLES *s; //Variable siguiente
};
Figura No. 4 Estructura de lista de variables
Clase o estructura LISTA_VARIABLES esta implementada en una Lista Enlazada
Sencilla de Variables la cual contiene cinco campos tres de tipo cadena en los cuales se
almacenara el nombre de la variable, el tipo de la variable y el nombre genérico de la
variable respectivamente, el nombre genérico de la variable permitirá identificar a una
variable cuando se encuentre codificada en el lenguaje ensamblador, el cuarto campo
contiene el valor con el cual se inicializa la variable y si no la inicializa por defecto en
cero, además el último de los campos es un puntero que almacena la dirección de la
siguiente variable.
138
2.2.3 Estructura Variables
struct VARIABLES
{
char c; //Guarda un carácter
struct VARIABLES *s; //Carácter siguiente
};
Figura No. 5: Estructura de creación de variable
La clase o estructura VARIABLES esta conformada por dos campos, uno de tipo cadena
en el cual se almacenara temporalmente los caracteres de los lexemas encontrados y esta
implementada con el concepto de lista enlazada y el otro campo es un apuntador que
almacena la dirección del siguiente carácter.
2.2.4 Estructura Lexemas
struct LEXEMAS
{
char *lex; /Nombre del lexema
int tip; //tipo de lexema
long fil; //fila en donde se encuentra
long col; //columna en donde se encuentra
long posi; //posición inicial
long posf; //posición final
struct LEXEMAS *sig; //lexema siguiente
};
Figura No. 6: Estructura de características de lexemas
139
La clase o estructura LEXEMAS consta de siete campos, uno de tipo cadena que
almacenara el nombre del lexema encontrado, el segundo es de tipo entero que permitirá
almacenar el tipo del lexema encontrado y cuatro de tipo long (fil, col, posi, posf), donde
los dos primeros permiten almacenar la fila y la columna donde se encuentra el lexema,
los otros dos son la posición donde inicia y la posición donde finaliza el lexema. Él
último campo es un puntero el cual guarda la dirección del siguiente lexema a tratar.
2.2.5 Clase autómatas
Esta es la clase principal la cual se encarga de realizar todas las operaciones básicas del
compilador MICROPIC tales como:
-
Análisis Léxico
-
Análisis sintáctico
-
Análisis semántico
-
Generador de código
Para establecer estas operaciones la clase AUTOMATAS hace referencia a las demás
estructuras utilizando el concepto de herencia de atributos.
-
ESTRUCTURA VARIABLES
-
ESTRUCTURA LISTA_VARIABLES
-
ESTRUCTURA LISTA_ETIQUETAS
-
ESTRUCTURA LEXEMAS
En esta estructura se definen todos los autómatas que determinan el tipo de lenguaje a
utilizar en software MicroPic v 1.0 entre los eventos de la clase autómatas se caracteriza
140
el procedimiento SINTACTICO() que se encarga de llamar y verificar que una línea de
código sea uno de los autómatas preescrito por el intérprete de MicroPic 1.0. A
continuación la declaración de la clase AUTOMATAS.
class AUTOMATAS
{
private:
//apuntador a archivo fuente (*.txt) y archivo ensamblador (*.asm)
FILE *f1,*fasm;
// x = variable para realizar ciclos
// Cond = indica la cantidad de condicionales encontrados
// Ciclo = indica la cantidad de ciclo repetitivos encontrados
// OpMulti = cantidad de múltiplo encontrados
// OpDivi = cantidad de cocientes encontrados
int x, mostrar, Cond, Ciclo, OpMulti, OpDivi;
//car = almacena el carácter capturado desde el archivo fuente
char car;
//Variable que contiene números convertidos en hexadecimal
char *NumHex;
//código ascii de un carácter capturado
//salir = variable para romper ciclos repetitivos
//Bandera = indica la operación realizada
int ascii,salir,cont,Bandera;
//Fila y columna en donde se encuentra un lexema
//resp = índice que indica que error se produjo
//conEti = Cantidad de etiquetas
long fila,columna,resp,contEti,Tempausa;
//Posición inicial y final de un lexema dentro del código fuente
//etapa determina la profundidad del árbol de asignación de variables
long posini,posfin,etapa;
//Declaración de Objetos de la Clase LEXEMAS
LEXEMAS *Ini,*Fin,*Rec,*Ant,*Nuevo,*rastro,*RecAux;
//Declaración de Objetos de la estructura VARIABLES
VARIABLES *vari,*nuev,*ulti;
//Declaración de Objetos de la estructura LISTA_VARIABLES
LISTA_VARIABLES *Vari,*Varf,*Varr,*Varn;
//Declaración de Objetos de la estructura LISTA_ETIQUETAS
LISTA_ETIQUETAS *Etiq,*Etif,*Etir,*Etin;
//Declaración de Objetos de la estructura ARBOL_ASIGNACION
ARBOL_ASIGNACION *Anuevo,*Araiz,*Asecun,*Arec;
141
//Variable de chequeo de valores
char *OffSet;
public:
AUTOMATAS(); //Constructor de la Clase
//Busca si existe una etiqueta en la lista de etiquetas
LISTA_ETIQUETAS *BUSCA_ETIQUETAS(char *identificador);
//se encarga de Buscar los lexemas en el código fuente
void BUSCA_LEXEMAS();
//Busca si una Variable existe en la lista de Variables
LISTA_VARIABLES *BUSCA_VARIABLES(char *VARI);
//verifica que un valor numérico este dentro de los parámetros indicados
void CONSTANT_NUMERIC(int Mini,int Maxi);
//evento de la clase autómatas que verifica la sintaxis correcta
//de una expresión condicional cuando se desconoce el numero de
parámetros
void CONDICION();
//evento de la clase autómatas que verifica la sintaxis correcta
//de una expresión condicional utilizando dos parámetros referencia
void CONDICIONES();
//verifica la sintaxis correcta de un condicional (IF THEN...END IF)
void CONDICIONAL();
//Verifica la sintaxis de las variables declaradas en el código fuente
void DECLARACION();
//Se encarga de buscar y determinar lexemas tipo variables y números
void IDENTIFICADOR_NUMERO();
//se encarga de determinar los lexemas tipo texto
void IDENTIFICADOR_TEXTO();
//verifica parámetros de las funciones de entrada/salida de datos por puerto
void INOUTDATA(long IndicaFila,int Oper);
//verifica la sintaxis de los parámetros de la función (BRANCH)
void LISTA_PARAMETROS(char *SimIni,char *SimFin);
//verifica la secuencia de parámetros que pueden ser
//variables, números o expresiones aritméticas
void
LISTA_VARI_CONS_EXPRE(char
*SimIni,char
*SimFin,long
mini,long maxi);
//Verifica la lista de parámetros LCD(IN/OUT)
void LISTDATA(long IndicaFila);
//evento que verifica dos parámetros (Nota,Periodo), [Nota,Periodo]
void NOTA_PERIODO(long IndicaFila,char *LimIni,char *LimFin);
//verifica parámetros que pueden ser variables, números y expresiones
//dentro de un rango de intervalos proporcionados (min,max)
void OPERACIONES(long min,long max);
142
//determina los lexemas operador aritmético, lógicos y símbolos
void OPERADOR_SIMBOLO();
//función que hace el llamado a los analizadores
void PRINCIPAL();
//imprime mensaje al compilar
void PRINT(long posición);
//recupera todos los lexemas de la lista que esta guardada en la memoria.
void RECUPERA_LEXEMA(long IndicaFila);
//analizador sintáctico
void SINTACTICO();
//verifica parámetro de tipo variables y numero dentro de un intervalo
void VARIABLES_CONTANTES(long IndicaFila,long mini,long maxi);
//Determina el valor decimal de un numero entero o hexadecimal
long VERIFICA_NUMERO(char *Num);
//método de búsqueda de un árbol binario en in-orden (adicional)
long BUSQUEDA_INORDEN(ARBOL_ASIGNACION *árbol);
//método de búsqueda de un árbol binario en pre-orden (adicional)
long BUSQUEDA_PREORDEN(ARBOL_ASIGNACION *árbol);
//método de búsqueda de un árbol binario en post-orden (adicional)
long BUSQUEDA_POSTORDEN(ARBOL_ASIGNACION *árbol );
//convierte un numero decimal en hexadecimal en ensamblador
void CONVERTIR_HEXADECIMAL(long numero);
//verifica asignación a través de un árbol binario de búsqueda
void ASIGNACION();
//verifica que se cumpla la asignación de solo dos operandos ya sean de tipo
//variable o número a otra exclusivamente de tipo una variable, cumpliendo
//todas las características de las operaciones aritméticas.
void ASIGNACION_SIMPLE();
void AUXIO(); //función auxio propia del lenguaje
void BRANCH(); //función branch propia del lenguaje
void COUNT(); //función count propia del lenguaje
void DTMFOUT(); //función dtmfout propia del lenguaje
void DEBUG(); //función debug propia del lenguaje
void ETIQUETAS(); //función para la creación de etiquetas
void EEPROM(); //función eeprom propia del lenguaje
void EXIT(); //función exit propia del lenguaje
void FOR_NEXT(); //función for_next propia del lenguaje
void GOTO(); //función goto propia del lenguaje
void GOSUB(); //función gosub propia del lenguaje
void HIGH(); //función high propia del lenguaje
void INPUT(); //función input propia del lenguaje
void I2CIN(); //función i2cin propia del lenguaje
void I2COUT(); //función i2cout propia del lenguaje
143
void LCDCMD(); //función lcdcmd propia del lenguaje
void LCDIN(); //función lcdin propia del lenguaje
void LCDOUT(); //función lcdout propia del lenguaje
void LOW(); //función low propia del lenguaje
void LOOKDOWN(); //función lookdown propia del lenguaje
void LOOKUP(); //función lookup propia del lenguaje
void MAINIO(); //función mainio propia del lenguaje
void OUTPUT(); //función output propia del lenguaje
void OWIN(); //función owin propia del lenguaje
void OWOUT(); //función owout propia del lenguaje
void PAUSE(); //función pause propia del lenguaje
void RANDOM(); //función random propia del lenguaje
void READ(); //función read propia del lenguaje
void RETURN(); //función return propia del lenguaje
void SLEEP(); //función sleep propia del lenguaje
void SOUND(); //función sound propia del lenguaje
void STOP(); //función stop propia del lenguaje
void TOGGLE(); //función toggle propia del lenguaje
void WRITE(); //función write propia del lenguaje
};
Figura No. 7: Clase principal autómatas
2.3 LISTA O TABLA DE ERRORES
Arreglo Bidimensional de tipo cadena el cual contiene la descripción especifica de los
posibles errores que se pueden encontrar al momento de analizar el código fuente o
código de usuario, es un arreglo de tipo char de 39 filas por tamaño de 50 caracteres
cada una de las filas.
144
char errores[39][50]={
"Nulo",
"Correcto",
"Variable no definida",
"Se espera operador",
"Faltan parámetros",
"Identificador, numero u operador desconocido",
"Se espera Identificador o Numero",
"Redundancia de Variable",
"Se espera Identificador",
"Falta tipo de dato",
"Se espera palabra reservada",
"Error de Sintaxis",
"Se espera etiqueta",
"Verificar parámetros",
"Se espera separador",
"Valor numérico entre (0-65535)",
"Valor numérico fuera del intervalo",
"Se espera paréntesis",
"Lexema desconocido del lenguaje",
"Se espera símbolo '()','[]'",
"Se espera valor numérico",
"Faltan parámetros o fuera de línea",
"Valor numérico entre (0-15)",
"Valor numérico entre (0-255)",
"Valor numérico entre (1-65535)",
"Se espera operador de igualdad '='",
"Se espera palabra reservada 'To'",
"Instrucciones con salto de línea",
"Se espera palabra reservada 'NEXT'",
"Se espera variable después del 'NEXT'",
//0
//1
//2
//3
//4
//5
//6
//7
//8
//9
//10
//11
//12
//13
//14
//15
//16
//17
//18
//19
//20
//21
//22
//23
//24
//25
//26
//27
//28
//29
"No coinciden los tipos de datos",
"Se espera operador relacional",
"Se espera palabra reservada THEN",
"Se espera palabra reservada ENDIF",
"Los factores deben ser tipo BYTE",
"El producto se debe almacenar en entero",
"División entre cero",
"Inicializar variable (var = 1)",
"Limite de variable sobrepasado" };
//30
//31
//32
//33
//34
//35
//36
//37
//38
Figura No. 8: Lista o tabla de errores
145
2.4 LISTA PALABRAS RESERVADAS
Es un arreglo matricial de tipo cadena que guarda todas las palabras reservadas
utilizadas por el compilador MICROPIC. En la lista de palabras reservadas para el
compilador Micropic existe un número limite definido por la variable max = 50 y un
tamaño de la palabra no mayor de 10 caracteres.
char reservadas[Max][10]={
"Declare",
//0
"End",
//1
"If",
//2
"Then",
//3
"Endif",
//4
"For",
//5
"To",
//6
"Step",
//7
"Next",
//8
"Int",
//9
"Byte",
//10
"Return",
//11
"Goto",
//12
"Input",
//13
"Output",
//14
"Count",
//15
"Auxio",
//16
"Return",
//17
"Mainio",
//18
"Stop",
//19
"Pause",
//20
"Exit",
//21
"Low",
//22
"High",
//23
"Toggle",
//24
"Branch",
//25
"Gosub",
//26
"Dtmfout",
//27
"Lcdcmd",
//28
"Dec",
//29
"Hex",
//30
146
"Bin",
"Str",
"Lcdin",
"Lcdout",
"Text",
"Rep",
"I2cin",
"I2cout",
"Lookdown",
"Lookup",
"Owin",
"Owout",
"Read",
“Write”,
"Sleep",
"Sound",
"Else",
"EndDeclare",
"Random"
};
//31
//32
//33
//34
//35
//36
//37
//38
//39
//40
//41
//42
//43
//44
//45
//46
//47
//48
//49
Figura No 9: Lista de palabras reservadas para MicroPic v 1.0
2.5 TIPO DE LEXEMA
Los tipos de lexemas utilizados para el software compilador MicroPic versión 1.0 están
determinados por una constante numérica. Él número total de tipos de lexemas
encontrados en el lenguaje es de once (11) y están comprendidos desde el 1 hasta el 11,
ver relación en la siguiente:
147
TIPO DE LEXEMA
CONSTANTE NUMERICA
Identificador
1
Palabra Reservada
2
Número
3
Desconocido
4
Operador Aritmético
5
Operador Relacional
6
Operador Lógico
7
Símbolo
8
Tipo de Datos
9
Cadena de Texto
10
Etiquetas
11
Tabla No. 1: Lista de lexemas y Constantes de identificación
2.5 MANEJO DE CODIFICACION IMPORTANTE
A continuación se hace referencia a la codificación más importante entre ellas se
muestran las funciones mas utilizadas al momento de recuperación, creación de lexemas
y analizadores del lenguaje. Las funciones más utilizadas son:
-
BUSCA_LEXEMAS()
-
BUSCA_ETIQUETAS()
-
BUSCA_VARIABLES()
-
RECUPERA_LEXEMA()
148
void AUTOMATAS::BUSCA_LEXEMAS(){
contEti = 0;
//---Lectura del archivo fuente---\\
f1 = fopen("CodigoFuente.txt", "r");
//Verifica si no hubo errores al abrir el archivo
if(f1==NULL)
{
exit(0);
}
//Inicializa posición de lexemas
posfin=0;
//Inicializa numero de la línea
fila=1;
//Inicializa numero de la columna
columna=0;
//Lectura de carácter
car=fgetc(f1);
//código Ascii del carácter
ascii = car;
//Recorrido del archivo fuente
while(car!=EOF){
//Identificador de variables, Etiquetas y palabras reservadas
if(((65 <= ascii && ascii <= 90)||ascii==209) ||
((97 <= ascii && ascii <= 122)||ascii==241))
{
//llamado a función que busca variable y números
IDENTIFICADOR_NUMERO();
//Ciclo para el recorrido de palabras reservadas
for(cont=0;cont<Max;cont++)
{
//verifica si es una palabra esta guarda en la lista de palabra reservada
if(strcmpi(reservadas[cont],Fin->lex)==0)
{
salir=3; //Rompe el ciclo
break;
}
}
Figura No. 10: Autómata para la búsqueda e identificación de lexema
149
LISTA_ETIQUETAS *AUTOMATAS::BUSCA_ETIQUETAS(char *identificador)
{
LISTA_ETIQUETAS *VariabEti;
int salida; //variable que indica salida del ciclo
char *etiqueta; //Variable para guardar el parámetro enviado
etiqueta = new char[strlen(identificador)+1];
Etir = Etiq; //Apuntadores a lista de etiquetas
salida = 0; //Inicializa indicador de ciclo activo = 0
sprintf(etiqueta,"%s:",identificador);//Asigna parámetro a la variable
//Ciclo para el recorrido de lista de etiquetas
while(Etir != NULL && salida == 0){
if(strcmpi(Etir->Eti,etiqueta) == 0) //Verifica etiqueta
{
VariabEti = Etir;
salida = 1;
break;
}
else
Etir = Etir->s;
}
//Verifica Si existe etiqueta
if(salida == 0)
{ resp = 0;//"Nulo" }
else
{resp = 1;//"Correcto"}
//Retorna la etiqueta encontrada
return VariabEti;
}
Figura No. 11: Autómata que verifica las etiquetas
Este autómata tiene la característica de recibir un parámetro, el cual es el lexema
encontrado y luego proceder a verificar si el lexema existe en la lista de etiquetas que
esta almacenada.
150
LISTA_VARIABLES *AUTOMATAS::BUSCA_VARIABLES(char *VARI)
{
//Variable de retorno de respuesta
LISTA_VARIABLES *valorvariable;
//Indicador de variable encontrada
Bandera = 0;
//Apuntador a la lista de variables
Varr=Vari;
while(Varr!=NULL) //Ciclo de recorrido de lista de variables
{
//compara la nueva varia VARI con la lista ya existentes
if(strcmpi(Varr->Var,VARI)==0) //verifica si existe
{
Bandera = 1; //Variable indica variable encontrada
valorvariable = Varr; //variable encontrada
break; //Rompe ciclo
}
else
Varr=Varr->s; //Apunta a la siguiente nodo
}
if(Bandera == 1) //verifica si fue encontrado
{
resp=1; //Correcto
}
else
{
resp=2; //No esta definida variable
}
//retorna variable de la lista
return (valorvariable);
}
Figura No. 12: Autómata que verifica si un lexema existe en la lista de variable
Función de la clase autómata que recibe un parámetro tipo char para luego verificar si
este parámetro existe en la lista de variables declaradas en el código fuente digitalizado
por el usuario.
151
//*******************************************************************
// AUTOMATAS PARA RECUPERAR LEXEMA SIGUIENTE
//*******************************************************************
void AUTOMATAS::RECUPERA_LEXEMA(long IndicaFila)
{
if(RecAux->sig != NULL) //Verifica nuevos Lexemas
{
//Posicionamiento en el siguiente lexema
RecAux = RecAux->sig;
//Verifica si el lexema encontrado pertenece o esta en la misma fila
if(IndicaFila == RecAux->fil)
{
resp = 1; //"Correcto"
}
else
{
resp = 11; //"Error de sintaxis"
}
}
else
{
resp = 4; //"Faltan parámetros"
}
}
Figura No. 13: Autómata encargado de recupera de la lista de lexemas
La función RECUPERA_LEXEMA() es la encargada de verificar si existen lexemas en
la lista guardada, además de verificar si el lexema siguiente pertenece a la misma fila del
lexema anterior encontrado. En el caso de encontrar un nuevo lexema en la lista la
función actualiza el apuntador Rec que es el encargado de recorrer la lista de lexemas.
152
3. CODIFICACION DE INTERFAZ DE USUARIO
3.1 EJECUCIÓN DE FUNCIÓN STRUCT SEMÁNTICO
Private Sub Menu_Compilar_Click(): Evento clic de la lista de menú Ejecutar que
realiza el llamado del ejecutable Struct Semantico.exe el cual es el encargado de realizar
la compilación del código digitalizado en la caja de texto txtcodigofuente.txt. Para esto
se verifica que este el formulario codificacion.frm abierto identificado con la variable
formulariocodigo si la respuesta es cierta se guarda la digitalización del código en un
archivo de texto llamado CodigoFuente.txt el cual utiliza struct semantico.exe para
interpretar su sintaxis.
Private Sub Menu_Compilar_Click()
'verifica sí el formulario de codificación
'de lenguaje esta abierto
If FormularioCodigo = 1 Then
'La ejecución del programa Struct semántico
'esta activo o inactivo
EjeActiva = 0
'inicializa cantidad de variables en cero
ContVari = 0
'inicializa barra de progreso en cero
Codificacion.ProBar1.Value = 0
'lista de resultados invisible
Codificacion.MsgError.Visible = False
'caja de texto de lenguaje ensamblador limpia
Codificacion.txtEnsamblador.Text = ""
'abre archivo codigofuente y lo limpia para guardar
Open "CodigoFuente.txt" For Output As #4
'guarda texto de la caja de entrada en el archivo abierto
Print #4, Codificacion.txtCodigofuente1.Text
'cierra el archivo
Close #4
153
'llamado de ejecutable de plataforma MS-DOS
Mostrar = Shell(App.Path & "\Struct semantico.exe", 0)
End If
'salida de procedimiento
End Sub
Figura No. 14: Función que hace el llamado al ejecutable de MS-DOS
3.2 FUNCION MOSTRAR_MENSAJE
Private Function MOSTRAR_MENSAJE() As String: la compilación devuelve un
mensaje agregado en un archivo localizado en directorio de struct semantico.exe
llamado resultado.dat el cual es abierto por la función MOSTRAR_MENSAJE() y
determinar si hubo algún error o por el contrario se realizo correctamente la ejecución
del código usuario. La función devuelve la última línea de datos guardado en el archivo
abierto.
Private Function MOSTRAR_MENSAJE() As String
'Activa eventos de verificación de errores
On Error GoTo ControlError1
'variable para recuperar lista de respuesta
Dim msg As String
'limpias control de lista de resultados
MsgError.Clear
'abre el archivo de resultados de la compilación
Open App.Path & "\resultado.dat" For Input As #5
'ciclo para recorrer el archivo abierto
Do While Not EOF(5)
'recupera línea de registro
Line Input #5, msg
154
'adiciona en el control Lista de resultados
MsgError.AddItem msg
'fin del ciclo
Loop
'cierra el archivo
Close #5
'retorna último mensaje de resultados
MOSTRAR_MENSAJE = msg
'salida de función
Exit Function
'etiqueta de mensaje de errores cometido
ControlError1:
'mensaje de error con su descripción
MsgBox Err.Description, vbCritical + vbOKOnly, "Error"
End Function
Figura No. 15: Función que muestra errores
3.3 FUNCION MOSTRAR_ENSAMBLADOR
Private Sub MOSTRAR_ENSAMBLADOR(): Él intérprete de código Struct
semántico se encarga de convertir la codificación del usuario y guardarla en un archivo
el cual la interfaz de usuario realizada en visual Basic recuperara posteriormente a la
ejecución correcta. Esta función se encarga de realizar este procedimiento y mostrarlo en
la caja de texto asignada para visualizar el lenguaje ensamblador proporcionado por el
intérprete.
155
Private Sub MOSTRAR_ENSAMBLADOR()
'Activa eventos de verificación de errores
On Error GoTo ControlError2
'variable para recuperar lista de ensamblador
Dim msg As String
'limpia variables
msg = ""
'limpia caja de texto
txtEnsamblador.Text = ""
'abre archivo de código interpretado
Open App.Path & "\micropic2005v1.asm" For Input As #6
'ciclo para recorrer el archivo
Do While Not EOF(6)
'hace invisible la lista de resultado
MsgError.Visible = False
'recupera datos desde el archivo
msg = msg & Input(1, #6)
'retorna evento o enfoque
y = DoEvents
'llenado de la barra de estado
If ProBar1.Value < 100 Then
ProBar1.Value = ProBar1.Value + 1
Else
ProBar1.Value = 0
End If
'fin del ciclo
Loop
'hace visible la lista de resultado
MsgError.Visible = True
'muestra resultado en la caja de texto
txtEnsamblador.Text = msg
'Crea archivo con el nombre del documento abierto
Open App.Path & "\" & NombreDocumento & ".asm" For Output As #7
Print #7, msg
'cierra el archivo
Close #7
'cierra el archivo
Close #6
‘salida de procedimiento
Exit Sub
156
'etiqueta de mensaje de errores cometido
ControlError2:
'mensaje de error con su descripción
MsgBox Err.Description, vbCritical + vbOKOnly, "Error"
End Sub
Figura No. 16: Función de mostrado del código ensamblador
157
JUEGO DE INSTRUCCIONES
JULIÁN ROBERTO HERNÁNDEZ DÍAZ
JAVIER MEZA CARABALLO
CORPORACIÓN UNIVERSITARIA RAFAEL NÚÑEZ
FACULTAD DE INGENIERÍA DE SISTEMAS
CARTAGENA DE INDIAS D.T. Y C., JUNIO DE 2005
159
1. JUEGO DE INSTRUCCIONES PARA LOS PIC’S
Con el fin de proporcionarle un texto tan práctico como sea posible, para cada
instrucción que se presenta se indica:
− Su sintaxis, indicando la notación de forma precisa.
− Su codificación con 14 bits.
Este punto le permitirá comprender cómo se llegan a codificar las instrucciones y los
modos de direccionamiento. Además, también le permitirá comprender los límites de los
tamaños impuestos a determinados datos, límites que se deben exclusivamente al
número de bits que se pueden utilizar.
Número de palabras y el número de ciclos de máquina utilizados. Puede así comprobar
que el principio fundamental de la arquitectura RISC se respeta, con una instrucción por
ciclo, salvo raras ocasiones. Los datos son todos en hexadecimal.
La notación adoptada para los datos y direcciones manipuladas por las instrucciones es
muy sencilla, y es como sigue:
− d representa estado, codificado con un bit.
− f representa un número de registro, codificado con siete bits.
− b representa un número de bit, codificado con tres bits. El bit 0 es siempre el bit de
menor peso.
− k representa un dato, el literal mencionado antes. El número de bits que se emplea
para su codificación es variable, dependiendo de la instrucción.
160
1.1 INSTRUCCIONES QUE MANEJAN REGISTROS
La mayoría de las instrucciones que manejan registros o están orientadas a los bytes
contienen dos parámetros, donde el primer parámetro es el registro con el cual el registro
de trabajo W efectuará la operación y el segundo parámetro escogerá el registro destino
donde se almacenará el resultado de la operación efectuada, todo eso dependiendo del
valor que tome el segundo parámetro, estos valores pueden ser 0 o 1, se explicara que
sucede si se coloca uno 0 un cero:
− Si d = 0, el resultado se almacenará en W.
− Si d = 1, el resultado se almacenará en el registro f.
Para el caso de las instrucciones que solo tienen un parámetro, tales como limpiar un
registro diferente al registro de trabajo y mover un registro o dato a W que son CLRF y
MOVWF respectivamente, en este caso será el registro a operar y en algunos caso hay
instrucciones que no tienen parámetro tales como limpiar el registro W que es CLRW ya
que el registro a limpiar es el de trabajo y NOP que no ejecuta ninguna operación.
Las instrucciones son la s siguientes:
ADDWF
ANDWF
CLRF
CLRW
COMF
DECF
DECFSZ
INCF
INCFSZ
IORWF
MOVF
MOVWF
NOP
RLF
RRF
SUBWF
SWAPF
XORWF
161
•
Instrucción ADDWF
La suma de esta instrucción se realiza bit a bit entre el registro de trabajo W y un
registro cualquiera. Ejemplo: el resultado se almacenará en W en este caso.
Bits
8
4
2
1
8
Byte_H
Lleva
4
2
1
Byte_L
1
1
reg = 4 9
0
1
0
0
1
0
0
1
W=2D
0
0
1
0
1
1
0
1
W=76
0
1
1
1
0
1
1
0
C=0
C=1
Si la suma lleva acarreo, es decir, si la suma lleva por que paso el limite, en este caso F
con valor de 15 se activa el bit de CARRY del registro STATUS.
ADDWF
ADD W to F
Sintaxis
Codificación
Palabras, ciclos
Operación
Bit de estado
Descripción
ADDWF f,d
00
0111 dfff
ffff
1, 1
W + f → f si d = 1 o W + f → W si d = 0
C, DC, Z
Añade el contenido de W al contenido de f, y
almacena el resultado en W si d = 0, y en f si d = 1.
ADDWF reg,0
Antes de la instrucción:
W = 17
reg = C2
Después de la instrucción: W = D9
reg = C2
Ejemplo:
Figura No. 8.1: Instrucción ADDWF
162
•
Instrucción ANDWF
Esta instrucción realiza un AND lógico bit a bit entre el registro W y un registro
cualquiera, teniendo en cuenta que la única forma que el bit de cómo resultado uno es
que el bit de los dos registros f sea uno, de lo contrario el resultado será cero. Ejemplo:
en este caso se almacenará el resultado en registro.
Bits
8
4
2
1
8
Byte_H
4
2
1
Byte_L
reg = 1 3
0
0
0
1
0
0
1
1
W = 91
1
0
0
1
0
0
0
1
reg = 1 1
0
0
0
1
0
0
0
1
ANDWF
AND W with F
Sintaxis
Codificación
Palabras, ciclos
Operación
Bit de estado
Descripción
ANDWF f,d
00
0101 dfff
ffff
1, 1
W AND f → f si d = 1 o W AND f → W si d = 0
Z
Efectúa un AND lógico entre el contenido de los
registros W y f, almacena el resultado en W si d = 0,
y en f si d = 1.
ANDWF reg,1
Antes de la instrucción:
W = 17
reg = C2
Después de la instrucción: W = 17
reg = 02
Ejemplo:
Figura No. 8.2: Instrucción ANDWF
163
•
Instrucción CLRF
CLRF
Clear F with F
Sintaxis
Codificación
Palabras, ciclos
Operación
Bit de estado
Descripción
Ejemplo:
CLRF f
00
0001 1fff
ffff
1, 1
00 → f
Z
Pone el contenido de f a cero y activa el bit Z.
CLRF reg
Antes de la instrucción:
reg = 5A
Después de la instrucción: reg = 00 y Z = 1
Figura No. 8.3: Instrucción CLRF
•
Instrucción CLRW
CLRW
Clear W register
Sintaxis
Codificación
Palabras, ciclos
Operación
Bit de estado
Descripción
Ejemplo:
CLRW
00
0001 0xxx xxxx
1, 1
00 → W
Z
Pone el registro W a cero y activa el bit Z.
CLRF W
Antes de la instrucción:
W = 5A
Después de la instrucción: W = 00 y Z = 1
Figura No. 8.4: Instrucción CLRW
164
•
Instrucción COMF
COMF
Complement F
Sintaxis
Codificación
Palabras, ciclos
Operación
Bit de estado
Descripción
COMF f,d
00
1001 dfff
ffff
1, 1
|f → f si d = 1 o |f → W si d = 0
Z
Hace complemento de f bit a bit. El resultado se
almacena de nuevo en f si d = 1, y en W si d = 0
(en este caso, f no varia).
COMF reg,0
Antes de la instrucción:
reg = 13, W = ?
Después de la instrucción: reg = 13, W = EC
Ejemplo:
Figura No. 8.5: Instrucción COMF
•
Instrucción DECF
DECF
Decrement F
Sintaxis
Codificación
Palabras, ciclos
Operación
Bit de estado
Descripción
DECF f,d
00
0011 dfff
ffff
1, 1
f – 1 → f si d = 1 o f – 1 → W si d = 0
Z
Decrementa el contenido de f en una unidad. El
resultado se almacena de nuevo en f si d = 1, y en
W si d = 0 (en este caso, f no varia).
DECF reg,1
Antes de la instrucción:
reg = 13
Después de la instrucción: reg = 12
Ejemplo:
Figura No. 8.6: Instrucción DECF
165
•
Instrucción DECFSZ
DECFSZ
Decrement F, Skip if Zero
Sintaxis
Codificación
Palabras, ciclos
Operación
Bit de estado
Descripción
DECFSZ f,d
00
1011 dfff
ffff
1, 1 (2)
f – 1 → f si d =1 o f – 1 → W si d=0 y salto si f – 1=0
Ninguno
Decrementa el contenido de f en una unidad. El
resultado se almacena de nuevo en f si d = 1, y en
W si d = 0 (en este caso, f no varia). Si el resultado
es nulo, se ignora la siguiente instrucción y, en ese
caso, esta instrucción dura dos ciclos.
aquí DECFSZ
reg,1
GOTO
ciclo
continua ...
Antes de la instrucción:
PC = dirección (aquí)
Después de la instrucción: reg = reg - 1
si reg = 0, entonces
PC = dirección continua
si reg != 0, entonces
PC =dirección (aquí +1)
Ejemplo:
Figura No. 8.7: Instrucción DECFSZ
•
Instrucción INCF
INCF
Increment F
Sintaxis
Codificación
Palabras, ciclos
Operación
Bit de estado
Descripción
INCF f,d
00
1010 dfff
ffff
1, 1
f + 1 → f si d = 1 o f + 1 → W si d = 0
Z
Incrementa el contenido de f en una unidad. El
resultado se almacena de nuevo en f si d = 1, y en
W si d = 0 (en este caso, f no varia).
INCF reg,1
Antes de la instrucción:
reg = 2A
Después de la instrucción: reg = 2B
Ejemplo:
Figura No. 8.8: Instrucción INCF
166
•
Instrucción INCFSZ
INCFSZ
Increment F, Skip if Zero
Sintaxis
Codificación
Palabras, ciclos
Operación
Bit de estado
Descripción
INCFSZ f,d
00
1111 dfff
ffff
1, 1 (2)
f + 1 → f si d =1 o f + 1 → W si d=0 y salto si f + 1=0
Ninguno
Incrementa el contenido de f en una unidad. El
resultado se almacena de nuevo en f si d = 1, y en
W si d = 0 (en este caso, f no varia). Si el resultado
es nulo, se ignora la siguiente instrucción y, en ese
caso, esta instrucción dura dos ciclos.
aquí INCFSZ
reg,1
GOTO
ciclo
continua ...
Antes de la instrucción:
PC = dirección (aquí)
Después de la instrucción: reg = reg + 1
si reg = 0, entonces
PC = dirección continua
si reg != 0, entonces
PC =dirección (aquí +1)
Ejemplo:
Figura No. 8.9: Instrucción INCFSZ
•
Instrucción IORWF
Esta instrucción realiza un OR lógico inclusivo bit a bit entre el registro W y el registro
f, teniendo en cuenta que la única forma que el bit de cómo resultado cero es que el bit
de los dos registros W y f sean ceros, de lo contrario el resultado será uno. Ejemplo:
Bits
8
4
2
1
8
Byte_H
4
2
1
Byte_L
reg = 1 3
0
0
0
1
0
0
1
1
W =91
1
0
0
1
0
0
0
1
W =93
1
0
0
1
0
0
1
1
167
IORWF
Inclusive OR W with F
Sintaxis
Codificación
Palabras, ciclos
Operación
Bit de estado
Descripción
IORWF f,d
11
0100 dfff
ffff
1, 1
W OR f → f si d = 1 o W OR f → W si d = 0
Z
Efectúa un OR lógico inclusivo entre el contenido de
W y el contenido de f, y almacena el resultado en f
si d = 1 y en W si d = 0.
IORWF reg,0
Antes de la instrucción:
reg = 13, W = 91
Después de la instrucción: reg = 13, W = 93
Ejemplo:
Figura No. 8.10: Instrucción IORWF
•
Instrucción MOVF
MOVF
Move F
Sintaxis
Codificación
Palabras, ciclos
Operación
Bit de estado
Descripción
¡Atención!
MOVF f,d
00
1000 dfff
ffff
1, 1
f → f si d = 1 o f → W si d = 0
Z
Desplaza el contenido de f a f si d =1 o a W si d =0.
El desplazamiento de f a f, que a priori parece inútil,
permite comprobar el contenido de f con respecto a
cero, ya que esta instrucción actúa sobre el bit Z.
MOVF reg,0
Antes de la instrucción:
W=?
Después de la instrucción: W = reg
Ejemplo:
Figura No. 8.11: Instrucción MOVF
168
•
Instrucción MOVWF
MOVWF
Move W to F
Sintaxis
Codificación
Palabras, ciclos
Operación
Bit de estado
Descripción
Ejemplo:
MOVWF f
00
0000 1fff
ffff
1, 1
W→f
Ninguno
Cargar f con el contenido de W.
MOVWF reg
Antes de la instrucción:
reg = ?, W = 5A
Después de la instrucción: reg = 5A, W = 5A
Figura No. 8.12: Instrucción MOVWF
•
Instrucción NOP
NOP
No Operation
Sintaxis
Codificación
Palabras, ciclos
Operación
Bit de estado
Descripción
NOP
0000 0xx0 0000
1, 1
Ninguna
Ninguno
Solo consume tiempo de maquina (en este caso, un
ciclo) como cualquier otro NOP. No hace nada.
NOP
Ejemplo:
Figura No. 8.13: Instrucción NOP
169
•
Instrucción RLF
RLF
Rotate Left F through Carry
Sintaxis
Codificación
Palabras, ciclos
Operación
Bit de estado
Descripción
RLF f,d
00
1101 dfff
ffff
1, 1
Ver descripción
C
El contenido del registro f se rota una posición a la
izquierda. El bit de más peso pasa al carry y el carry
se almacena en el bit de menos peso de f. Si d = 0,
el resultado introduce W. Si d = 1, el resultado
queda en el registro f.
7
6
5
4
3
2
1
0
C
Registro f
Ejemplo:
RLF reg,0
Antes de la instrucción:
Después de la instrucción:
C = 0, reg = 1110 0110
W=?
C = 1, reg = 1110 0110
W = 1100 1100
Figura No. 8.14: Instrucción RLF
170
•
Instrucción RRF
RRF
Rotate Right F through Carry
Sintaxis
Codificación
Palabras, ciclos
Operación
Bit de estado
Descripción
RRF f,d
00
1100 dfff
ffff
1, 1
Ver descripción
C
El contenido del registro f se rota una posición a la
derecha. El bit de menos peso pasa al carry y el
carry se coloca en el bit de más peso de f. Si d = 0,
el resultado introduce W. Si d = 1, el resultado
queda en el registro f.
7
6
5
4
3
2
1
0
C
Figura No. 8.14: Instrucción RLF
Registro f
Ejemplo:
RRF reg,0
Antes de la instrucción:
Después de la instrucción:
C = 0, reg = 1110 0110
W=?
C = 0, reg = 1110 0110
W = 0111 0011
Figura No. 8.15: Instrucción RRF
171
•
Instrucción SUBWF
La resta de esta instrucción se realiza bit a bit entre el registro de trabajo W y un registro
cualquiera. Ejemplo: el resultado se almacenará en el registro en este caso.
Bits
8
4
2
1
8
Byte_H
Lleva
4
2
1
Byte_L
1
1
reg = 0 3
0
0
0
0
0
0
1
1
W = 02
0
0
0
0
0
0
1
0
reg = 0 1
0
0
0
0
0
0
0
1
C=?
C=1
SUBWF
Substract W from F
Sintaxis
Codificación
Palabras, ciclos
Operación
Bit de estado
Descripción
SUBWF f,d
00
0010 dfff
ffff
1, 1
f – W → f si d = 1, o f – W → W si d = 0
C, DC, Z
Sustrae el contenido de W del contenido de f, y
almacena el resultado en W si d = 0 y en f si de = 1.
La sustracción se realiza en complemento a dos. Si
el resultado es negativo, el carry se pone a 0.
SUBWF reg,1
Antes de la instrucción:
reg = 1, W = 2, C = ?
Después de la instrucción: reg = FF, W = 2, C = 0
Ejemplo:
Figura No. 8.16: Instrucción SUBWF
172
•
Instrucción SWAPF
SWAPF
Swap F
Sintaxis
Codificación
Palabras, ciclos
Operación
SWAPF f,d
00
1110 dfff
ffff
1, 1
f (0 - 3) → f (4 - 7) y f (4 - 7) → f( 0 - 3),
Resultado → f o W dependiendo de d
Ninguno
Intercambia los cuatro bits de mayor peso con los
cuatro bits de menor peso de f, y almacena el
resultado en f si d = 1, o en W si d = 0.
SWAPF reg,0
Antes de la instrucción:
reg = A5, W = ?
Después de la instrucción: reg = A5, W = 5A
Bit de estado
Descripción
Ejemplo:
Figura No. 8.17: Instrucción SWAPF
•
Instrucción XORWF
Esta instrucción realiza un OR lógico exclusivo bit a bit entre el registro W y el registro
f, teniendo en cuenta que la única forma que el bit de cómo resultado cero es que el bit
de los dos registros W y f sean iguales, de lo contrario el resultado será uno. Ejemplo: el
resultado se almacenará en el registro, para este caso.
Bits
8
4
2
1
8
Byte_H
4
2
1
Byte_L
reg = A F
1
0
1
0
1
1
1
1
W=B5
1
0
1
1
0
1
0
1
reg = 1 A
0
0
0
1
1
0
1
0
173
XORWF
Exclusive OR W with F
Sintaxis
Codificación
Palabras, ciclos
Operación
XORWF f,d
00
0110 dfff
ffff
1, 1
W OR EXCLUSIVO f → f si d = 1 o
W OR EXCLUSIVO f → W si d = 0
Z
Efectúa un OR lógico exclusivo entre el contenido
de W y el contenido de f, y almacena el resultado en
f si d = 1 y en W si d = 0.
XORWF reg,1
Antes de la instrucción:
reg = AF, W = B5
Después de la instrucción: reg = 1A, W = B5
Bit de estado
Descripción
Ejemplo:
Figura No. 8.18: Instrucción XORWF
1.2 INSTRUCCIONES QUE MANIPULAN BITS
Estas instrucciones que manipulan bits o están orientadas a los bits, al igual que las
anteriores instrucciones contienen u operan con dos parámetros, el primero indica el
registro a manipular, dependiendo del valor que tenga el segundo parámetro el cual
puede tomar máximo tres bits, es decir, que el mínimo valor que puede tomar es 0 y el
máximo es el 7.
Las instrucciones son las siguientes:
BCF
BSF
BTFSC
BTFSS
174
•
Instrucción BCF
Esta instrucción pone en cero el bit indicado con el valor del segundo parámetro, en este
caso b de cualquier registro, esto a su vez le cambia el valor al registro tratado. Ejemplo:
Byte_H
Byte_L
reg = B 8
1
0
1
1
1
0
0
0
reg = 3 8
0
0
1
1
1
0
0
0
BCF
Bit Clear F
Sintaxis
Codificación
Palabras, ciclos
Operación
Bit de estado
Descripción
Ejemplo:
BCF f,b
01
00bb bfff
ffff
1, 1
0 → b( f )
Ninguno
Pone a cero el bit número b de f.
BCF reg,7
Antes de la instrucción:
reg = C7
Después de la instrucción: reg = 47
Figura No. 8.19: Instrucción BCF
•
Instrucción BSF
Esta instrucción pone en uno el bit indicado con el valor del segundo parámetro, en este
caso b de cualquiera que sea el registro, esto a su vez le cambia el valor al registro
tratado. Ejemplo:
Byte_H
Byte_L
reg = 6 D
0
1
1
0
1
1
0
1
reg = E D
1
1
1
0
1
1
0
1
175
BSF
Bit Set F
Sintaxis
Codificación
Palabras, ciclos
Operación
Bit de estado
Descripción
Ejemplo:
BSF f,b
01
01bb bfff
ffff
1, 1
1 → b( f )
Ninguno
Pone a uno el bit número b de f.
BSF reg,7
Antes de la instrucción:
reg = 0A
Después de la instrucción: reg = 8A
Figura No. 8.20: Instrucción BSF
•
Instrucción BTFSC
BTFSC
Bit Test, Skip If Clear
Sintaxis
Codificación
Palabras, ciclos
Operación
Bit de estado
Descripción
BTFSC f, b
01
10bb bfff
ffff
1, 1 o 2
Salta si b (f) = 0
Ninguno
Si el bit numero b de f es nulo, la instrucción que
sigue a esta se ignora y se trata como un NOP. En
este caso, y solo en este caso, la instrucción
BTFSC precisa dos ciclos para ejecutarse.
aquí BTFSS
reg,1
falso GOTO
inicio
verdad ...
Antes de la instrucción:
PC = dirección (aquí)
Después de la instrucción: si reg (1) = 0, entonces
PC = dirección verdad
si reg (1) = 1, entonces
PC = dirección falso
Ejemplo:
Figura No. 8.21: Instrucción BTFSC
176
•
Instrucción BTFSS
BTFSS
Bit Test, Skip If Set
Sintaxis
Codificación
Palabras, ciclos
Operación
Bit de estado
Descripción
BTFSC f, b
01
11bb bfff
ffff
1, 1 o 2
Salta si b (f) = 1
Ninguno
Si el bit numero b de f esta en uno, la instrucción
que sigue a esta se ignora y se trata como un NOP.
En este caso, y solo en este caso, la instrucción
BTFSS precisa dos ciclos para ejecutarse.
aquí BTFSS
reg,1
falso GOTO
inicio
verdad ...
Antes de la instrucción:
PC = dirección (aquí)
Después de la instrucción: si reg (1) = 1, entonces
PC = dirección verdad
si reg (1) = 0, entonces
PC = dirección falso
Ejemplo:
Figura No. 8.22: Instrucción BTFSS
1.3 INSTRUCCIONES DE CONTROL Y DE OPERANDOS INMEDIATOS
La mayoría de estas instrucciones de control y operandos inmediatos o de operaciones
con literal trabajan con un solo parámetro, que es un valor numérico el cual puede operar
directamente con el registro de trabajo W, las que no tienen parámetro son instrucciones
de control interno del microcontrolador. Las instrucciones son las siguientes:
ADDLW
ANDLW
CALL
CLRWDT
GOTO
IORLW
177
MOVLW
OPTION
RETFIE
RETLW
RETURN
SLEEP
SUBLW
TRIS
XORLW
•
Instrucción ADDLW
La suma de esta instrucción se realiza bit a bit entre el registro de trabajo y el literal o
valor a operar. Ejemplo: el resultado se almacenará siempre en W.
Byte_H
Lleva
Byte_L
1
1
1
1
19
0
0
0
1
1
0
0
1
W=2D
0
0
1
0
1
1
0
1
W=46
0
1
0
0
0
1
1
0
C=0
C=1
Si la suma lleva acarreo, es decir, si la suma lleva por que paso el limite, en este caso F
con valor de 15 se activa el bit de CARRY del registro STATUS.
ADDLW
ADD Literal to W
Sintaxis
Codificación
Palabras, ciclos
Operación
Bit de estado
Descripción
ADDLW k
11
111x kkkk kkkk
1, 1
W+k→W
C, DC, Z
Añade el contenido de W al literal k, y almacena el
resultado en W.
ADDLW 7A
Antes de la instrucción:
W = 14
Después de la instrucción: W = 8E
Ejemplo:
Figura No. 8.23: Instrucción ADDLW
178
•
Instrucción ANDLW
Esta instrucción realiza un AND lógico bit a bit entre el registro W y el literal o valor a
operar, teniendo en cuenta que la única forma que el bit de cómo resultado uno es que el
bit del registrote trabajo W y el valor del literal sea uno, de lo contrario el resultado será
cero. Ejemplo: en este caso se almacenará el resultado siempre en W.
Bits
8
4
2
1
8
Byte_H
4
2
1
Byte_L
reg = 4 D
0
1
0
0
1
1
0
1
W = C9
1
1
0
0
1
0
0
1
reg = 4 9
0
1
0
0
1
0
0
1
ANDLW
AND Literal and W
Sintaxis
Codificación
Palabras, ciclos
Operación
Bit de estado
Descripción
ANDLW k
11
1001 kkkk kkkk
1, 1
W AND k → W
Z
Efectúa un AND lógico entre el contenido de W y el
literal k, y almacena el resultado en W.
ANDLW 5F
Antes de la instrucción:
W = A3
Después de la instrucción: W = 03
Ejemplo:
Figura No. 8.24: Instrucción AN DLW
179
•
Instrucción CALL
CALL
Subrutina CALL
Sintaxis
Codificación
Palabras, ciclos
Operación
CALL k
10
0kkk kkkk kkkk
1, 2
En el caso de los 16c5X:
PC + 1 → Pila, k → PC(0-7), 0 → PC(8),
PA2 a PA0 → PC(9-11)
En el caso de los 16c64, 71, 74, 84:
PC + 1 → Pila, k → PC(0-10),
PCLATH(3,4) → PC(11,12)
Ninguno
Guarda la dirección de vuelta en la pila y después
llama a la subrutina situada en la dirección cargada
en el PC.
El modo de cálculo de la dirección difiere según la
familia PIC utilizada. También hay que posicionar
bien PA2, PA1, PA0 (16c5X) o el registro PCLATH
(en los demás PIC), antes de ejecutar la instrucción
CALL.
aquí CALL
rutina
Antes de la instrucción:
PC = dirección (aquí)
Después de la instrucción: PC = dirección rutina
Bit de estado
Descripción
¡Atención!
Ejemplo:
Figura No. 8.25: Instrucción CALL
180
•
Instrucción CLRWDT
CLRWDT
Clear Watchdog Timer
Sintaxis
Codificación
Palabras, ciclos
Operación
Bit de estado
Descripción
CLRWDT
00
0000 0110 0100
1, 1
00 → WDT y 0 → predivisor del temporizador
1 → TO 1 y 1 → PD
Pone a cero el registro contador del temporizador
watchdog, así como el predivisor.
CLRWDT
Antes de la instrucción:
contador WDT = ?
Después de la instrucción: contador WDT = 00
Ejemplo:
Figura No. 8.26: Instrucción CLRWDT
•
Instrucción GOTO
GOTO
Salto incondicional
Sintaxis
Codificación
Palabras, ciclos
Operación
GOTO k
10
1kkk kkkk kkkk
1, 2
En el caso de los 16C5X:
k → PC (0 - 8), PA2, PA1,
PA0 → PC (9 - 11).
k → PC (0 - 10),
PCLATH (3,4) → PC (11,12).
Ninguno
Llama a la subrutina situada en la dirección cargada
en el PC.
GOTO
ciclo
Antes de la instrucción:
PC = ?
Después de la instrucción: PC = ciclo
Bit de estado
Descripción
Ejemplo:
Figura No. 8.27: Instrucción GOTO
181
•
Instrucción IORLW
Esta instrucción realiza un OR lógico inclusivo bit a bit entre el registro W y el literal o
valor a operar, teniendo en cuenta que la única forma que el bit de cómo resultado cero
es que el bit de los dos registros W y f sean ceros, de lo contrario el resultado será uno.
Ejemplo: se almacenará en el registro en este caso.
Bits
8
4
2
1
8
Byte_H
4
2
1
Byte_L
reg = 5 3
0
1
0
1
0
0
1
1
W =4A
0
1
0
0
1
0
1
0
W =5B
0
1
0
1
1
0
1
1
IORLW
Inclusive OR Literal with W
Sintaxis
Codificación
Palabras, ciclos
Operación
Bit de estado
Descripción
IORLW k
11
1000 kkkk kkkk
1, 1
W OR k → W
Z
Efectúa un OR lógico inclusivo entre el contenido de
W y el literal k, y almacena el resultado en W.
IORLW
35
Antes de la instrucción:
W = 9A
Después de la instrucción: W = BF
Ejemplo:
Figura No. 8.28: Instrucción IORLW
182
•
Instrucción MOVLW
MOVLW
Move Literal to W
Sintaxis
Codificación
Palabras, ciclos
Operación
Bit de estado
Descripción
Ejemplo:
MOVLW k
11
00xx kkkk kkkk
1, 1
k→W
Ninguno
Cargar W con el literal k.
MOVLW
5A
Antes de la instrucción:
Después de la instrucción:
W=?
W = 5A
Figura No. 8.29: Instrucción MOVLW
•
Instrucción OPTION
OPTION
Load Option Register
Sintaxis
Codificación
Palabras, ciclos
Operación
Bit de estado
Descripción
¡Atención!
OPTION
00
0000 0110 0010
1, 1
W → OPTION
Ninguno
Cargar el registro OPTION con el contenido de W.
Esta instrucción no debe utilizarse en otros circuitos
que no sean los PIC 16C5X. No obstante, es
correctamente interpretada por los circuitos 16C64,
71, 74 y 84, con el fin de asegurar una
compatibilidad ascendente.
OPTION
Ejemplo:
Figura No. 8.30: Instrucción OPTION
183
•
Instrucción RETFIE
RETFIE
Return From Interrupt
Sintaxis
Codificación
Palabras, ciclos
Operación
Bit de estado
Descripción
RETFIE
00
0000 0000 1001
1, 2
Pila → PC, 1 → GIE
Ninguno
Carga el PC con el valor que se encuentra en la
parte superior de la pila, asegurando así la vuelta de
la interrupción. Pone a 1 el bit GIE, con el fin de
autorizar de nuevo que se tengan en cuenta las
interrupciones.
RETFIE
Antes de la instrucción:
PC = ?
Después de la instrucción: PC = pila
Ejemplo:
Figura No. 8.31: Instrucción RETFIE
•
Instrucción RETLW
RETLW
Return Literal to W
Sintaxis
Codificación
Palabras, ciclos
Operación
Bit de estado
Descripción
RETLW k
11
01xx kkkk kkkk
1, 2
k → W, Pila → PC
Ninguno
Carga W con el literal k, y después carga el PC con
el valor que se encuentra en la parte superior de la
pila, efectuando así un retorno de subrutina.
CALL
tabla
:
tabla ADDWF
PC
RETLW
k1
RETLW
k2
:
RETLW
kn
Antes de la instrucción:
W = 07
Después de la instrucción: W = k7
Ejemplo:
Figura No. 8.32: Instrucción RETLW
184
•
Instrucción RETURN
RETURN
Return From Subroutine
Sintaxis
Codificación
Palabras, ciclos
Operación
Bit de estado
Descripción
RETURN
00
0000 0000 1001
1, 2
Pila → PC
Ninguno
Carga el PC con el valor que se encuentra en la
parte superior de la pila, efectuando así una vuelta
de subrutina. Se trata de la instrucción RETLW
simplificada.
Esta instrucción dura dos ciclos.
Esta instrucción no existe en los PIC 16C5X.
RETURN
Antes de la instrucción:
PC = ?
Después de la instrucción: PC = pila
¡Atención!
Ejemplo:
Figura No. 8.33: Instrucción RETURN
•
Instrucción SLEEP
SLEEP
Sleep
Sintaxis
Codificación
Palabras, ciclos
Operación
SLEEP
00
0000 0110 0011
1, 1
0 → PD, 1 → TO, 00 → WDT,
0 → predivisor del WDT
TO, PD
Pone al circuito en modo sep con parada del
oscilador, es decir, lo pone a dormir (stanby).
SLEEP
Bit de estado
Descripción
Ejemplo:
Figura No. 8.34: Instrucción SLEEP
185
•
Instrucción SUBLW
La resta de esta instrucción se realiza bit a bit entre el registro de trabajo W y el literal o
valor numérico a operar. Ejemplo: el resultado se almacenará siempre en el registro W.
Bits
8
4
2
1
8
Byte_H
Lleva
4
2
1
Byte_L
1
1
02
0
0
0
0
0
0
1
0
W = 02
0
0
0
0
0
0
1
0
W =00
0
0
0
0
0
0
0
0
C=?
C=1
SUBLW
Substract W from Literal
Sintaxis
Codificación
Palabras, ciclos
Operación
Bit de estado
Descripción
SUBLW k
11
110x kkkk kkkk
1, 1
k– W →W
C, DC, Z
Sustrae el contenido de W del literal k, y almacena
el resultado en W. La sustracción se realiza en
complemento a dos.
Esta instrucción no existe en los PIC 16C5X.
SUBWF F
Antes de la instrucción:
W = 2, C = ?
Después de la instrucción: W = D, C = 1
¡Atención!
Ejemplo:
Figura No. 8.35: Instrucción SUBLW
186
•
Instrucción TRIS
TRIS
Load TRIS Register
Sintaxis
Codificación
Palabras, ciclos
Operación
Bit de estado
Descripción
TRIS f
00
0000 0110 0fff
1, 1
W → registro TRIS del puerto f
Ninguno
Carga el contenido de W en el registro TRIS del
puerto f.
Esta instrucción no debe utilizarse en otros circuitos
que no sean los PIC 16C5X. No obstante, es
correctamente interpretada por los circuitos 16C64,
71, 74 y 84, con el fin de asegurar una
compatibilidad ascendente.
TRIS puertoA
¡Atención!
Ejemplo:
Figura No. 8.36: Instrucción TRIS
•
Instrucción XORLW
Esta instrucción realiza un OR lógico exclusivo bit a bit entre el registro W y el literal a
operar, teniendo en cuenta que la única forma que el bit de cómo resultado cero es que el
bit de los dos registros W y f sean iguales, de lo contrario el resultado será uno. Ejemplo:
el resultado se almacenará siempre W.
Bits
8
4
2
1
8
Byte_H
AF
4
2
1
Byte_L
1
0
1
0
1
1
1
1
W=35
0
0
1
1
0
1
0
1
W=9A
1
0
0
1
1
0
1
0
187
XORLW
Exclusive OR Literal with W
Sintaxis
Codificación
Palabras, ciclos
Operación
Bit de estado
Descripción
XORLW k
11
1010 kkkk kkkk
1, 1
W OR EXCLUSIVO k → W
Z
Efectúa un OR lógico exclusivo entre el contenido
de W y el literal k, y almacena el resultado en W.
XORLW AF
Antes de la instrucción:
W = B5
Después de la instrucción: W = 1A
Ejemplo:
Figura No. 8.37: Instrucción XORLW
188
AUTÓMATAS, PSEUDOCÓDIGOS Y DIAGRAMAS DE FLUJOS DE LAS
INSTRUCCIONES EN ENSAMBLADOR
JULIÁN ROBERTO HERNÁNDEZ DÍAZ
JAVIER MEZA CARABALLO
CORPORACIÓN UNIVERSITARIA RAFAEL NÚÑEZ
FACULTAD DE INGENIERÍA DE SISTEMAS
CARTAGENA DE INDIAS D.T. Y C., MAYO DE 2005
190
1. AUTÓMATAS, PSEUDOCÓDIGOS Y DIAGRAMAS DE FLUJOS
DE LAS INSTRUCCIONES EN ENSAMBLADOR
1.1
AUTÓMATA, PSEUDOCÓDIGO Y DIAGRAMA PARA EVALUAR LAS
INSTRUCCIONES (ADDLW, ADDWF, ANDLW, ANDWF)
Diagrama 1: Autómata de instrucciones que comienzan con la letra A
191
192
Figura No. 1.1: Pseudocódigo de instrucciones que comienzan con la letra A
193
Diagrama 2: Diagrama de flujo de instrucciones que comienzan con la letra A
194
1.2
AUTÓMATA, PSEUDOCÓDIGO Y DIAGRAMA PARA EVALUAR LAS
INSTRUCCIONES (BCF, BSF, BTFSC, BTFSS)
Diagrama 3: Autómata de instrucciones que comienzan con la letra B
195
Figura No. 1.2: Pseudocódigo de instrucciones que comienzan con la letra B
196
Diagrama 4: Diagrama de flujo de instrucciones que comienzan con la letra B
197
1.3
AUTÓMATA, PSEUDOCÓDIGO Y DIAGRAMA PARA EVALUAR LAS
INSTRUCCIONES (CALL, CLRF, CLRW, CLRWDT, COMF)
Diagrama 5: Autómata de instrucciones que comienzan con la letra C
198
199
Figura No. 1.3: Pseudocódigo de instrucciones que comienzan con la letra C
200
Diagrama 6: Diagrama de flujo de instrucciones que comienzan con la letra C
201
1.4
AUTÓMATA, PSEUDOCÓDIGO Y DIAGRAMA PARA EVALUAR LAS
INSTRUCCIONES (DECF, DECFSZ)
Diagrama 7: Autómata de instrucciones que comienzan con la letra D
Figura No. 1.4: Pseudocódigo de instrucciones que comienzan con la letra D
202
Diagrama 8: Diagrama de flujo de instrucciones que comienzan con la letra D
203
1.5
AUTÓMATA, PSEUDOCÓDIGO Y DIAGRAMA PARA EVALUAR LA
INSTRUCCIÓN (GOTO)
Diagrama 9: Autómata de instrucción que comienza con la letra G
Figura No. 1.5: Pseudocódigo de instrucción que comienza con la letra G
204
Diagrama 10: Diagrama de flujo de instrucción que comienza con la letra G
205
1.6
AUTÓMATA, PSEUDOCÓDIGO Y DIAGRAMA PARA EVALUAR LAS
INSTRUCCIONES (INCF, INCFSZ, IORLW, IORWF)
Diagrama 11: Autómata de instrucciones que comienzan con la letra I
206
Figura No. 1.6: Pseudocódigo de instrucciones que comienzan con la letra I
207
Diagrama 12: Diagrama de flujo de instrucciones que comienzan con la letra I
208
1.7
AUTÓMATA, PSEUDOCÓDIGO Y DIAGRAMA PARA EVALUAR LAS
INSTRUCCIONES (MOVF, MOVLW, MOVWF)
Diagrama 13: Autómata de instrucciones que comienzan con la letra M
209
Figura No. 1.7: Pseudocódigo de instrucciones que comienzan con la letra M
210
Diagrama 14: Diagrama de flujo de instrucciones que comienzan con la letra M
211
1.8
AUTÓMATA,
PSEUDOCÓDIGO Y DIAGRAMA PARA EVALUAR LA
INSTRUCCIÓN (NOP)
Diagrama 15: Autómata de instrucción que comienza con la letra N
Figura No. 1.8: Pseudocódigo de instrucción que comienza con la letra N
212
Diagrama 16: Diagrama de flujo de instrucción que comienza con la letra N
213
1.9
AUTÓMATA,
PSEUDOCÓDIGO Y DIAGRAMA PARA EVALUAR LA
INSTRUCCIÓN (OPTION)
Diagrama 17: Autómata de instrucción que comienza con la letra O
Figura No. 1.9: Pseudocódigo de instrucción que comienza con la letra O
214
Diagrama 18: Diagrama de flujo de instrucción que comienza con la letra O
215
1.10 AUTÓMATA, PSEUDOCÓDIGO Y DIAGRAMA PARA EVALUAR LA
INSTRUCCIÓN (RETFIE, RETLW, RETURN, RLF, RRF)
Diagrama 19: Autómata de instrucciones que comienzan con la letra R
216
217
Figura No. 1.10: Pseudocódigo de instrucciones que comienzan con la letra R
218
Diagrama 20: Diagrama de flujo de instrucciones que comienzan con la letra R
219
1.11 AUTÓMATA, PSEUDOCÓDIGO Y DIAGRAMA PARA EVALUAR LAS
INSTRUCCIONES (SLEEP, SUBLW, SUBWF, SWAPF)
Diagrama 21: Autómata de instrucciones que comienzan con la letra S
220
221
Figura No. 1.11: Pseudocódigo de instrucciones que comienzan con la letra S
222
Diagrama 22: Diagrama de flujo de instrucciones que comienzan con la letra S
223
1.12 AUTÓMATA, PSEUDOCÓDIGO Y DIAGRAMA PARA EVALUAR LA
INSTRUCCIÓN (TRIS)
Diagrama 23: Autómata de instrucción que comienza con la letra T
Figura No. 1.12: Pseudocódigo de instrucción que comienza con la letra T
224
Diagrama 24: Diagrama de flujo de instrucción que comienza con la letra T
225
1.13 AUTÓMATA, PSEUDOCÓDIGO Y DIAGRAMA PARA EVALUAR LAS
INSTRUCCIONES (XORLW, XORWF)
Diagrama 25: Autómata de instrucciones que comienzan con la letra X
226
Figura No. 1.13: Pseudocódigo de instrucciones que comienzan con la letra X
227
Diagrama 26: Diagrama de flujo de instrucciones que comienzan con la letra X
228
1.14 TABLAS PARA EL MANEJO DE BITS DE LOS PUERTOS
Las instrucciones que utilizan una variable pin como parámetro que varía entre (0 – 15)
deben manejar la siguiente lógica para poder hacer referencia a los distintos pines de
cada puerto a utilizar, hay que tener en cuenta que solo se manejan dos puertos que son:
el Puerto A y el Puerto B, dichos puertos se pueden configurar como entrada o salida.
Los puertos inicialmente se encuentran configurados como entrada.
El Puerto A solo se utiliza desde el bit 0 hasta el bit 4 ya que los otros tres no son
manejables y Puerto B maneja todos sus bits. Ver las tablas No. 1 y 2.
Para hacer referencia al Puerto A el valor del bit debe ser de (0 – 7) y para utilizar el
Puerto B el valor debe ser de (8 – 15). Ver tabla No. 3.
Bit
Nombre
Puerto
7
RA7
6
RA6
5
RA5
4
3
RA4
RA3
PORTA
2
RA2
1
RA1
0
RA0
2
RB2
1
RB1
0
RB0
Tabla No. 1: Puerto A.
Bit
Nombre
Puerto
7
RB7
6
RB6
5
RB5
4
3
RB4
RB3
PORTB
Tabla No. 2: Puerto B.
229
PORTA
Puerto
PORTB
Valor
Pin
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Bit
0
1
2
3
4
5
6
7
0
1
2
3
4
5
6
7
Tabla No. 3: Valor de las referencias de los bits de los puertos.
Veamos un ejemplo:
Si el valor del pin es 10 el puerto que se utiliza es el puerto B haciendo referencia el bit
2 de ese puerto. Así, PORTB,2 en su respectivo lenguaje ensamblador.
230