Repositorio Institucional de Documentos

Diseño de microcontrolador compatible con 80251 Proyecto fin de carrera Ingeniería industrial Universidad de Zaragoza Centro Politécnico Superior Departamento ingeniería electrónica y comunicaciones Área de Tecnología electrónica Autor Director D. Fernando Gracia Royo Prof. José ignacio García Nicolás Diseño de microcontrolador compatible con 80251 Resumen En el presente proyecto hemos estudiado la arquitectura de la familia de microcontroladores 80251 de Intel con el fin de poder diseñar un IP en VHDL sintetizable del mismo. Basados en la arquitectura clásica de 8 Bits de su predecesora, la familia de microcontroladores 8051, incrementa su capacidad de computación con la extensión del tamaño de los datos con los que opera, pudiendo ser estos de 8, 16 y 32 Bits. Dichos microcontroladores trabajan con un conjunto de instrucciones tipo Cisc con instrucciones de distinto número de Bytes. Así mismo, dependiendo de la instrucción se invierten diferentes intervalos de tiempo en desarrollarlas. Cada instrucción está asociada a un número de ciclos de máquina dependiendo de la complejidad de la operación a realizar o los accesos a memoria que se deban realizar. La compatibilidad con programas diseñados para la arquitectura del 51 implica que el microprocesador pueda trabajar en dos modos: fuente y binario. Cada uno tiene una serie de instrucciones específicas y para poder trabajar con ellas en el otro modo se necesita un Opcode de escape, incrementando el tamaño de las instrucciones en un Byte. El estilo que siguen estos microprocesadores a la hora de apilar los datos en las memorias es del tipo big-endian, es decir, la parte de mayor peso de una palabra se coloca en la posición de la memoria más baja. Nuestro objetivo ha sido el diseño del núcleo del microcontrolador 80251 en VHDL sintetizable para evaluar el número de puertas equivalentes. También se han realizado mejoras de diseño para minimizar el número de ciclos de máquina requeridos por las instrucciones. Para lograrlo se ha optimizado el acceso a las memorias para datos desalineados implementando una configuración de memorias que permite acceder a las memorias en un ciclo de reloj. En el desarrollo del diseño se ha tenido en cuenta el consumo de recursos de la FPGA realizando procesos de síntesis periódicos para asegurar un tamaño de hardware adecuado. La utilidad de este proyecto es reemplazar al 8051 de tres ciclos de reloj por ciclo de máquina. El motivo es el incremento velocidad de ejecución de programas al poder operar con datos de 1, 2 o 4 Bytes y aprovechar la reducción en el tamaño de código que permite obtener el conjunto de instrucciones adicionales. Índice Capítulo 1: Introducción........................................................................................................1 1.1- Estudio del microcontrolador 80251..........................................................................2 1.2- Diseño del núcleo en VHDL......................................................................................3 1.3- Pruebas y resultados................................................................................................4 Capítulo 2: Microcontrolador 80251.....................................................................................7 2.1- Características técnicas de la arquitectura 251(comercial).......................................8 2.2- Espacio de memoria.................................................................................................8 2.3 Modos de funcionamiento..........................................................................................9 2.3.1 Mapa de instrucciones......................................................................................10 2.4 Registros internos.....................................................................................................11 2.4.1 Registros Special Function Registers (SFR): ...................................................12 2.4.2 Banco de registros: ..........................................................................................12 2.4.3 Registros especiales: .......................................................................................14 2.5 Modos de direccionamiento.....................................................................................16 2.5.1 Direccionamiento directo...................................................................................16 2.5.2 Direccionamiento indirecto................................................................................17 2.5.3 Direccionamiento de bits...................................................................................17 2.6 Programación...........................................................................................................18 2.6.1 Formato de los Datos........................................................................................18 2.6.2 Notaciones de los datos....................................................................................19 2.6.3 Clasificación de las instrucciones....................................................................19 Capítulo 3: Diseño del núcleo del microprocesador 80251................................................23 3.1 Procesos básicos del microprocesador. ..................................................................24 3.1.1 Opción 1: Modo secuencial...............................................................................24 3.1.2 Opción 2: Modo Pipeline. .................................................................................25 3.1.3 Opción 3: Modo mixto.......................................................................................25 3.2 Configuración de las memorias. ..............................................................................26 3.3 Bloques del núcleo...................................................................................................27 Capítulo 4: Pruebas y resultados.......................................................................................31 4.1 Comprobación del código VHDL..............................................................................31 4.2 Verificación del código VHDL...................................................................................33 4.3 Pruebas de síntesis..................................................................................................36 4.4 Comparativa entre arquitecturas..............................................................................37 Capítulo 5: Conclusiones....................................................................................................39 5.1 Conclusiones sobre el Proyecto...............................................................................39 5.2 Futuras líneas de desarrollo.....................................................................................40 5.3 Conclusiones personales.........................................................................................41 Anexo 1 Esquemáticos.................................................................................................................43 Anexo 2 Lista de instrucciones.....................................................................................................53 Anexo 3 Descripción de los bloques del diseño...........................................................................61 Índice de figuras Figura 2.3.1_1: Formato de las instrucciones y ejemplos de instrucciones trabajando en modo binario y fuente.........................................................................................................10 Figura 2.3.1_1: Formato de las instrucciones y ejemplos de instrucciones trabajando en modo binario y fuente.........................................................................................................10 Figura 2.3.1_2: Mapa de memoria trabajando en modo binario.........................................11 Figura 2.3.1_3: Mapa de memoria trabajando en modo fuente..........................................11 Figura 2.4.1_1: Espacio de memoria para los Special Function Register (SFR). ..............12 Figura 2.4.2_1: Banco de registros y su nomenclatura dependiendo del formato como se direcciona...........................................................................................................................13 Figura 2.4.3_1: Registros compartidos entre el banco de registros y el banco SFR. Se indican las direcciones en ambos bancos..........................................................................15 Figura 2.4.3_2: Registros PSW0 y PSW1 junto con la definición de todos sus Flags........15 Figura 2.6.1_1: Orden de almacenamiento de datos en formato Big-endian.....................19 Figura 3.3_1: Diagrama de Gant del proceso de diseño....................................................27 Figura 3.3_2: Esquemáticos de todos los bloques presentes en el núcleo........................29 Figura 4.1_1: Resultado de una simulación en Modelsim..................................................33 Figura 4.1_1: Resultado de una simulación en Modelsim..................................................33 Figura 4.2_3: Resultado de la simulación en Keil uvion4...................................................35 Figura 4.2_4: Visor de ondas del Modelsim en la última instrucción del programa............35 Figura 4.3_1: FPGA usada en las pruebas de síntesis......................................................36 Figura A3.1_1: Esquemático del bloque Fetch_C2............................................................62 Figura A3.2_1: Esquemático del bloque Decode_C2.........................................................63 Figura A3.3_1: Esquemático del bloque Reg_block_C2....................................................64 Figura A3.3_2: Algoritmo para obtener la dirección física de los registros.........................65 Figura A3.3_3: Algoritmo para escribir registros como RAM..............................................66 Figura A3.3_4: Algoritmo de lectura de registros como RAM.............................................67 Figura A3.3_5: Código para generar la dirección con direccionamiento indirecto..............68 Figura A3.3_6: Algoritmo de lectura de los bloques RAM..................................................69 Figura A3.3_7: Algoritmo de escritura de bloques RAM.....................................................69 Figura A3.4_1: Esquemático del bloque Alu.......................................................................70 Figura A3.5_1: Esquemático del bloque Registros_PSW...................................................71 Figura A3.5_2: Asignación de los Flags de los registros PSW a través de la señal de entrada PSW_REGISTER..................................................................................................71 Figura A3.6_1: Esquemático del bloque Diviblock2............................................................72 Figura A3.6_2: Código de inicialización de variables y detector del comienzo del número. ...........................................................................................................................................73 Figura A3.6_3: Algoritmo principal de la división................................................................73 Índice de tablas Tabla 1: Bits direccionados con el formato compatible del 51 (bit51). Dependiendo de la dirección se accede hasta la dirección 2F de la memoria RAM o a ciertas direcciones de los registros SFR................................................................................................................18 Tabla 2: Número de bits de los formatos de los datos........................................................18 Tabla 3: Notación de los registros dependiendo del tamaño y de la arquitectura...............19 Tabla 4: Instrucciones aritméticas......................................................................................20 Tabla 5: Instrucciones lógicas.............................................................................................20 Tabla 6: Instrucciones de bit...............................................................................................21 Tabla 7: Instrucciones de salto condicional junto con la condición de salto......................21 Tabla 8: Instrucciones de salto absoluto.............................................................................22 Tabla 9: Instrucciones de llamada y retorno.......................................................................22 Tabla 10: Modo de trabajo secuencial con cinco ciclos de reloj por ciclo de máquina.......24 Tabla 11: Modo de trabajo paralelo. Las instrucciones solo tardan un ciclo de reloj en completarse........................................................................................................................25 Tabla 12: Modo de trabajo mixto. Es el que finalmente utilizamos en nuestro diseño........25 Tabla 13: Recursos de la FPGA usados con arquitectura del 251. ...................................36 Tabla 14: Informe de tiempos. Estima la frecuencia máxima del reloj................................36 Tabla 15: Resultados obtenidos tras ejecutar un programa con variables en formato “Char”, “Int” y “Long Int”. ....................................................................................................37 Tabla 16: Recursos usados por el núcleo del microprocesador 8051................................37 Tabla 17: Resultados en unidades de área y nanosegundos obtenidos al procesar el diseño con Synopsys. A partir de este dato se han calculado el espacio total en el circuito, la frecuencia máxima del reloj y el número de puertas equivalentes.................................38 Tabla 18: Espacio de las memorias RAM...........................................................................38 Bibliografía Intel corporation. “8X251SA, 8X251SB, 8X251SP, 8X251SQ Embedded Microcontroller User´s Manual”. 1996 ISBM: 272795-002. Srefan Sjoholm, Lennart Lindh. “VHDL for Designer”. Prentice Hall. 1997 ISBM: 0- 13-473414-9. Roger Lipsett, Carl Schaefer, Cary Ussery. “VHDL: Hardware Desciption and Design”. KAP. 1989 ISBM: 0-7923-9030-X. Diseño de microcontrolador compatible con 80251. Capítulo 1: Introducción. Este proyecto se ha realizado en el departamento de ingeniería Electrónica y Comunicaciones, área de Tecnología Electrónica. El objetivo es crear un IP sintetizable que pueda ser usado en futuros proyectos dentro de FPGA´s. El objetivo de este proyecto es el diseño de un núcleo compatible con los microcontroladores de la familia 80251. Se busca tener un sustituto del microcontrolador 8051 de 8 bits con tres ciclos de reloj por ciclo de máquina que ya existe. El 251 es una arquitectura de 8 bits que es capaz de operar con datos de 8, 16 y 32 bits. La ampliación de tamaño de los datos permite ejecutar instrucciones más rápido y reducir el número de instrucciones necesarias para realizar una operación, reduciendo el código de los programas. En este proyecto solo se diseñará el núcleo del microprocesador junto con las memorias para datos (RAM) y memorias para el código (ROM). No se diseñará ningún periférico ni habrá sistema de interrupciones. El diseño se realizará en VHDL con el fin de crear un IP sintetizable. El diseño del microprocesador parte del estudio del funcionamiento del núcleo del microcontrolador a través de su manual técnico. De dicho estudio se ha deducido qué se deberá implementar en el diseño y qué partes quedan fuera del alcance por estar destinado al control de periféricos. Se ha tenido cuidado de no extendernos demasiado en el uso de recursos hardware, puesto que debería ser capaz de funcionar en una FPGA. Como mejora de diseño nos hemos planteado reducir el número de ciclos de máquina de las instrucciones, que dependen de cada instrucción y pueden ser de varios ciclos. El objetivo es conseguir que el máximo posible de instrucciones requieran un solo ciclo de 1 Capítulo 2: Microcontrolador 80251. 2.1- Características técnicas de la arquitectura 251(comercial). DBus de direcciones de 24 bit, que permiten acceder hasta 16MB de memoria. DBus de direcciones independiente entre la parte de memoria para datos de variables y datos de programa. DHasta 16 KB de memoria interna destinada a almacenar los programas ampliable a 64KB con memoria externa. D1KB de memoria RAM interna ampliable con memoria externa. DBancada de registros internos en la CPU accesibles como Bytes, Words y Double-words. D269 instrucciones que nos permiten operar con datos en formatos de 8, 16 y 32 bits. DReducción del número de ciclos de reloj de 12 ciclos del 51 a los 2 ciclos. DCompatibilidad con programas realizados para la arquitectura 51 a través de la creación de dos modos de trabajo, binary y source. Otras características técnicas de estos microcontroladores son la inclusión de una serie de periféricos. Entre ellos se encuentran Timers, Counters, watchdog.... 2.2- Espacio de memoria. Como ya se ha mencionado, la arquitectura del 251 posee un bus de datos interno de 24 bits, que permitiría disponer hasta 16MB de memoria. La memoria está dividida en varias zonas que pueden ser accedidas simultáneamente gracias a que existen varios buses conectados entre sí. Por ejemplo, la zona de código tiene un bus independiente que nos permite leer a la vez datos y código. El problema llega cuando se pretende leer datos en la memoria de código desde el programa. En este caso tan solo se puede realizar la lectura del dato deteniendo el Fetch. El espacio de memoria está dividido en cinco zonas. Como dentro la familia 80251 hay diferentes modelos, para esta sección hemos usado el 83C251SB: DMemoria de código: Localizada desde FF:0000 hasta FF:FFFF. Esta zona está reservada para código de programa y constantes. Este espacio está dividido en dos zonas, una interna y otra externa. La memoria interna es de 16 KB para nuestro modelo, el resto es externa. DMemoria externa 1: Localizada desde FE:0000 hasta FE:FFFF. Esta zona de memoria está reservada para introducir bloques de memoria externa. DMemoria externa 2: Localizada desde 01:0000 hasta 01:FFFF. Igual que antes, esta zona es para colocar memoria externa. 8 Diseño de microcontrolador compatible con 80251. DMemoria RAM interna: Localizada desde 00:0000 hasta 00:FFFF. Igual que la memoria de código está dividida en dos zonas, una que contiene la RAM interna, que va desde 00:0000 hasta 00:1FFF y una segunda zona que puede ser completada con más memoria externa. La RAM interna es de 1024 Bytes. Existe una quinta zona que va desde la 02:0000 hasta la FD:FFFF reservada que no es accesible por el usuario. A continuación se muestra el mapa de memoria de arquitectura 251: 2.3 Modos de funcionamiento. La arquitectura del 251 es compatible con sus predecesora, la 51. Uno de los aspectos más importantes para conseguir esta compatibilidad es poder reutilizar los programas realizados para la anterior tecnología, sin necesidad de recompilar el código. Las instrucciones poseen tamaños variados, desde 1 Byte hasta 5 Bytes en el peor de los casos. Sin embargo, siempre con el primer Byte y en algunos casos con el segundo se sabe de qué instrucción se trata. El resto son datos y direcciones que no influyen en el tipo de instrucción. La arquitectura del 51 usa todos los Opcodes posibles en 8 bits salvo el A5, por lo que las nuevas instrucciones de la arquitectura del 251 no caben. La solución adoptada fue utilizar el Byte A5 como Byte de escape y dividir el espacio de instrucciones en tres partes. Una parte fija para ambas arquitecturas, y las otras con instrucciones propias de cada una de las arquitecturas. 9 Fuente: 8X251SA, 8X251SB, 8X251SP, 8X251SQ Embedded Microcontroller User´s Manual. Figura 2.2_1: Espacio de memoria RAM y su direccionamiento. Capítulo 2: Microcontrolador 80251. De esta forma se adopto dos modos de trabajo, en el que el espacio de instrucciones cambia dependiendo del tipo de instrucciones que se pretendan usar. El primer modo se llama Binario (o Binary) y contiene todas las instrucciones del 51. Este modo se usa para reutilizar programas ya creados y no recompilarlos a la nueva tecnología. Para acceder a las instrucciones nuevas se debe poner el prefijo A5, que es el denominado Byte de escape. El segundo modo se denomina fuente (o Source) y agrupa todas las instrucciones nuevas de esta arquitectura. Estas instrucciones pueden trabajar con rangos mayores en direccionamiento directo e indirecto y con más registros. También aparecen nuevas instrucciones que realizan más operaciones. Al trabajar con datos más grandes y con más modos de direccionamiento es capaz de operar mucho más rápido y con menor código. Las instrucciones que se sustituyen en este modo se pueden usar añadiendo el prefijo A5. La razón de que se decantasen por incluir dos modos de trabajo y no usar siempre el prefijo en las nuevas instrucciones es que en los microcontroladores comerciales leer un Opcode extra supone más ciclos de máquina por instrucción. Poniendo dos modos se consigue reducir el tiempo de ejecución de los programas, ya que pondremos el modo de trabajo de aquel que tengamos más instrucciones. El problema antes mencionado de velocidad de acceso a las instrucciones se debe a que los microcontroladores 80251 funcionan con ciclos de máquina variables y la lectura del prefijo supone la adhesión de un ciclo de máquina más. En nuestro caso no supone ningún inconveniente y se podría trabajar directamente en el modo binario sin que suponga un tiempo de ejecución mayor. Es decir, trabajar en un modo u otro da el resultado en el mismo tiempo de ejecución. 2.3.1 Mapa de instrucciones. Las instrucciones se dividen en tres bloques: Un bloque fijo y común, uno con instrucciones especificas del 51 y otro con instrucciones especificas del 251. La división se hace atendiendo a los Opcodes de las instrucciones, tomándose los Nibbles (4 Bits) de menor peso. El bloque común está compuesto por los Opcodes que van desde el “x0” hasta el “x7”, mientras que el segundo y el tercero van desde el “x8” hasta el “xF”. Según el modo de trabajo, al leer el Opcode interpretara una instrucción u otra. A continuación se muestran unos ejemplos gráficos que ilustran el formato de las instrucciones y como se diferencian dependiendo del modo de trabajo: 10 Fuente:Elaboración propia. Figura 2.3.1_1: Formato de las instrucciones y ejemplos de instrucciones trabajando en modo binario y fuente. Formato de las instrucciones por nibbles 7A Ejemplos de instrucciones dependiendo del modo de trabajo Modo Opcode Source Binary “42” ORL A, dir8 ORL A, dir8 “8C” DIV Rm, Rm MOV dir8, Rn “A5” “8C” MOV dir8, Rn DIV Rm, Rm Nibble 1 (mayor peso) Nibble 2 (menor peso) Diseño de microcontrolador compatible con 80251. Las siguientes figuras muestran el mapa de instrucciones dependiendo del modo de trabajo. La primera figura se corresponde con el funcionamiento en modo binario y el segundo funciona en modo fuente. Observamos como dependiendo del modo de trabajo debemos introducir el prefijo A5 para las instrucciones del otro modo. 2.4 Registros internos. Además de las memorias RAM/ROM interna, los microcontroladores 80251 cuentan con un banco de registros y los SFR´s. La diferencia entre los bloques RAM y los registros son que los registros están formados por biestables por lo que se puede acceder simultáneamente a varios registros. Otra característica es que al efectuarse un Reset, estos registros se ponen a cero, mientras que la RAM mantiene los datos. Podemos clasificar los registros en tres tipos: Special Function Registers (SFR), banco de registros y registros especiales. 11 Fuente: 8X251SA, 8X251SB, 8X251SP, 8X251SQ Embedded Microcontroller User´s Manual. Fuente: 8X251SA, 8X251SB, 8X251SP, 8X251SQ Embedded Microcontroller User´s Manual. Figura 2.3.1_2: Mapa de memoria trabajando en modo binario. Figura 2.3.1_3: Mapa de memoria trabajando en modo fuente. Capítulo 2: Microcontrolador 80251. 2.4.1 Registros Special Function Registers (SFR): Estos registros incluyen los periféricos del microcontrolador, los puertos, las interrupciones, el acumulador... No todo el espacio reservado es accesible, tan solo una parte está ocupada. A estos registros se accede con direccionamiento directo como si fuera RAM. Las direcciones comprendidas entre “80H” hasta “FFH” están reservadas para estos registros. La figura 2.4.1_1 muestra los registros existentes junto con su nombre y la dirección RAM donde se encuentran. 2.4.2 Banco de registros: La estructura del banco de registros es bastante compleja. Para empezar, los registros pueden ser direccionados en forma de Byte(R), Word (W) u Double-word (DW). Aunque se direccionen datos más grandes, los registros englobados son los mismos, pero es capaz de acceder a más registros. En otras palabras, hay un total de 16 registros que son accesibles con una instrucción tipo Byte. Esos 16 registros pueden ser accesibles con una instrucción de Word, pero de dos en dos. Además podemos acceder a un total de 32 Bytes con este direccionamiento. Con los Double-word pasa lo mismo, podemos acceder a los mismos 32 Bytes que con el direccionamiento Word o a los 16 del tipo Byte, pero en este caso se amplía 8 Bytes más. El direccionamiento de estos 8 12 Fuente: 8X251SA, 8X251SB, 8X251SP, 8X251SQ Embedded Microcontroller User´s Manual. Figura 2.4.1_1: Espacio de memoria para los Special Function Register (SFR). Diseño de microcontrolador compatible con 80251. Bytes se corresponde a la parte alta de las direcciones. En estos casos los datos están siempre alineados, empezando por cero o por valores pares que van de dos en dos o de cuatro en cuatro. En la figura 2.4.2_1 se puede observar el banco de registros y para cada tipo de formato los Bytes que engloba. Los registros que no aparecen en el recuadro de cada tipo de direccionamiento son porque no son accesibles. Se accede a los registros a partir de cuatro bits del Opcode de la instrucción. Por lo general, la parte alta del Opcode suele ser la dirección y la parte baja es el tamaño del dato. Aunque con Bytes solo se pueden acceder a los 16 primeros registros, la nomenclatura del resto de direccionamientos parte del valor del primer registro que tendría si se direccionara como Byte. Por ejemplo, el W18 contiene los registros R18 y R19 registros que no pueden ser accedidos como Bytes. Los registros que van desde R0 hasta R7 (W0-W6 o DW0 y DW4) son registros que se despliegan lateralmente en 4 filas haciendo un total de 32 Bytes. Se controlan con los Bits RS de los registros PSW0 o PSW1. Dependiendo del valor de RS que va desde “00” hasta “11” seleccionamos una de las 4 filas. Cuando direccionamos un registro comprendido en el rango antes mencionado se accede directamente a una de estas filas. Estos 32 Bytes tienen otra peculiaridad, y es que además de funcionar como registros lo hacen como la parte baja de la memoria. Tanto en direccionamiento directo como indirecto si pretendemos leer o escribir cualquier dirección entre la “00H” y la “1FH” lo hace en estos registros. El despliegue se hace siguiendo el orden ascendente de RS, por lo que la fila de RS = “00b”corresponde con las direcciones de la “00H” a la “08H”, mientras que la dirección RS = “11b” se corresponden desde la “19H” a la “1FH”. 13 Fuente: 8X251SA, 8X251SB, 8X251SP, 8X251SQ Embedded Microcontroller User´s Manual. Figura 2.4.2_1: Banco de registros y su nomenclatura dependiendo del formato como se direcciona. Capítulo 2: Microcontrolador 80251. Como forma parte de la RAM, el acceso a estos registros no es alineado. Podemos acceder a cualquier registro independientemente del tipo de dato sin necesidad que sea par. En nuestro diseño se ha ampliado el banco de registros de 64 a 84 registros, eliminando el vacío que hay entre el registro 32 hasta el 55. En la figura 2.4.2_2 Vemos como se despliega el banco de registro para formar la parte baja de la memoria RAM. La dirección de la izquierda representa el registro PSW que contiene el vector RS. La dirección de la derecha se corresponde a la memoria RAM. 2.4.3 Registros especiales: Estos registros en realidad forman parte de los dos grupos anteriores a la vez. En otras palabras, se pueden acceder a ellos desde el banco de registros o desde los registros SFR. Por lo general tienen funciones especiales dentro de las instrucciones. Se corresponden con el DPTX, SPX y los acumuladores. Por orden de mayor a menor, primero nos encontraríamos el SPX, con 2 Bytes y se corresponde a DR60, el DPTX con 3 Bytes y dirección DR56, y por último los acumuladores de un Byte A y B con direcciones R11 y R10 respectivamente. Los registros SPX y DPTS son punteros que direccionan en el primer caso la dirección de la pila y en el segundo forma la parte alta de la dirección cuando se accede a memoria externa. En la pila que antes hemos comentado es una parte de la memoria en donde se almacenan datos importantes cuando se realizan subrutinas o interrupciones, como es el caso del PC (Program Counter) o del PSW1. La figura 2.4.3_1 se observa los registros en el banco de registros y en espacio de memoria con sus respectivas direcciones en ambos espacios. 14 Fuente: 8X251SA, 8X251SB, 8X251SP, 8X251SQ Embedded Microcontroller User´s Manual. Figura 2.4.2_2: Registros desplegables que funcionan como la parte baja de la memoria RAM. Se puede observar la asignación del espacio de memoria para cada registro. Diseño de microcontrolador compatible con 80251. Otros registros especiales son los PSW (Program Status Word) que si bien no son accesibles desde el banco de registros, estos registros se ven modificados al ejecutar un gran número de instrucciones. Casi todas instrucciones modifican algunos bits de estos registros sin necesidad de ser direccionados. Cada bit tiene funcionas propias y se denominan Flags. En la figura 2.4.3_2 se aprecia ambos registros y cuál es la función de cada Flag. 15 Fuente: 8X251SA, 8X251SB, 8X251SP, 8X251SQ Embedded Microcontroller User´s Manual. Figura 2.4.3_2: Registros PSW0 y PSW1 junto con la definición de todos sus Flags. Fuente: 8X251SA, 8X251SB, 8X251SP, 8X251SQ Embedded Microcontroller User´s Manual. Figura 2.4.3_1: Registros compartidos entre el banco de registros y el banco SFR. Se indican las direcciones en ambos bancos. Capítulo 2: Microcontrolador 80251. 2.5 Modos de direccionamiento. La arquitectura del 251 posee gran variedad de modos de direccionamiento por los que una instrucción puede obtener los datos necesarios para operar con ellos. Además de leer datos de la RAM o de los registros existen otras formas de obtener estos datos: DDireccionamiento de registros: La instrucción contiene el registro que se pretende leer. La dirección es de 4 bits y puede direccionar Bytes, Words o Doublewords como se ha comentado en la sección 2.4. DDireccionamiento directo: La instrucción contiene la dirección de la memoria, pudiendo estar en 1 Byte o en 2 Bytes (8 o 16 bits). Con este direccionamiento se accede a direcciones fijas pero debemos tener cuidado con los SFR que se encuentran entre las direcciones “80H” y “FFH”. En la sección 2.5.1 se amplía la información. DDireccionamiento indirecto: En este caso la dirección se encuentra en un registro. Para acceder al dato se lee primero este registro que es procesado para obtener la dirección real. En la sección 2.5.2 se amplía la información. DDireccionamiento inmediato: En este caso el dato no está ni en memoria RAM ni en registros, sino que la instrucción contiene el dato. Puede ser de 8 bits o de 16 bits. DDireccionamiento con desplazamiento: Caso especial del indirecto, la instrucción contiene el registro que contiene la dirección de RAM y a la vez un offset que será sumado a la dirección. El resultado es la dirección donde está el dato. El offset puede ser de 16 o 24 bits. DDireccionamiento relativo: Similar al direccionamiento con desplazamiento pero este hace referencia a instrucciones de salto. El resultado de la suma del valor del PC y el offset da una dirección de programa al que el PC debe saltar. DDireccionamiento de Bits: Hay dos tipos de direccionamiento de bits. Pero en ambas se obtiene una dirección de un Byte y la posición del bit. En la sección 2.5.3 se amplía la información. El resultado de las operaciones, cuando hay que escribirlo, se realiza direccionando las memorias internas o registros. No tienen tantos modos de direccionamiento como con la lectura de datos. Sin embargo en la lista anterior queda por explicar con más de profundidad algunos tipos de direccionamiento de las memorias RAM. 2.5.1 Direccionamiento directo. La dirección a la que accede está dentro de la instrucción, direccionando posiciones fijas de variables. Las direcciones son de 8 o 16 bits aunque la extensión de las memorias de los dispositivos comerciales solo alcanzan hasta los 10 bits de direcciones. En nuestro caso la memoria abarca los 16 bits de direcciones pues usamos memorias 16 Diseño de microcontrolador compatible con 80251. internas más grandes. Debemos tener cuidado con las direcciones comprendidas entre “80H” y “FFH” que se corresponden a los SFR. Aunque sean registros, se acceden mediante direccionamiento directo. La memoria RAM que hay detrás solo se puede acceder con direccionamiento indirecto. El rango de acceso con este direccionamiento va desde la dirección “0000H” hasta la “FFFFH”. Solo depende si usamos 8 o 16 bits. 2.5.2 Direccionamiento indirecto. La dirección a la que se desea acceder esta dentro de un registro. Los registros pueden tener el tamaño de un Byte compatible con la arquitectura del 51, de 2 Byte o un Word, que nos permite acceder a la primera zona de memoria, y por último 4Bytes o Double-word, dándonos acceso a los 16Mb. Los dos últimos tan solo permiten leer o escribir dos Bytes. La instrucción contiene la dirección del registro donde se almacena la dirección de la memoria que se desea acceder. En algunas instrucciones a la dirección leída del registro se le suma un valor fijo. El rango de acceso de este caso va de “00H” hasta la “FFH” con direccionamiento indirecto compatible con el 51. De la dirección “0000H” hasta la “FFFFH” si usamos Word como base de la dirección. Y si elegimos Double-word podemos acceder desde “00:0000H” hasta la dirección “FF:FFFFH”. 2.5.3 Direccionamiento de bits. Este direccionamiento obtiene de un Byte determinado el valor de un bit. Por lo tanto se necesita dos direcciones, la del Byte y la del bit. Se sigue dos estrategias, dependiendo de la tecnología de la arquitectura. La versión del 251 sigue una estrategia muy simple, ya que la instrucción contiene la dirección del dato y la posición del bit a leer. Sin embargo la versión del 51 es más complicada, ya que ambas direcciones se encuentran en un Byte y dependiendo del valor de este accede a RAM o a los SFR. La primera mitad accede a los 16 primeros Bytes y la segunda mitad se mueve por los registros SFR que terminan en cero u ocho: S:80H, S:88H, S:90H…. 17 Capítulo 3: Diseño del núcleo del microprocesador 80251. 3.1 Procesos básicos del microprocesador. El funcionamiento de un microprocesador se divide en cinco procesos que se realizan secuencialmente. Estos cinco procesos son: Fetch, Decode, Read, Execute y Write. El primer proceso es el Fetch y es el encargado de leer el código en una dirección determinada de la memoria mediante un puntero llamado PC (Program Counter). Los datos leídos se almacenan en una pila interna y conforme se va desarrollando la ejecución de los programas, suministra al siguiente proceso estos datos. También se encarga de la lectura de esta memoria cuando una instrucción necesita un dato que está en código. El siguiente proceso es el Decode. Decodifica las instrucciones que le llegan del Fetch y genera una serie de señales de control. Casi todas las señales de control se generan con este proceso, incluidas las de lectura o escritura de las memorias y el control del Execute. El proceso Read recibe del anterior la dirección y el formato de dato y lee de la memoria o del banco de registros. Los datos los envía directamente al proceso Execute. El proceso Execute es el encargado de realizar las operaciones de las instrucciones. Los datos llegan en su mayoría del proceso Read y la operación a realizar del Decode. El último proceso es el Write, escribe en RAM o registros el resultado del Execute. Es casi igual al proceso Read. Como se puede observar, cada proceso genera información esencial para el siguiente proceso. Hasta que el proceso no ha finalizado no se puede continuar con el siguiente. Aunque se pueden seguir estrategias para acelerar el proceso de ejecución de las instrucciones. Las más comunes son el desarrollo en paralelo de estos procesos. Otras formas son aumentar los buses de lectura de memorias, tanto RAM como de código. Antes de comenzar nuestro diseño tuvimos muy en cuenta la estrategia que debíamos seguir para conseguir la mayor velocidad en la ejecución de las instrucciones. Nos planteamos diferentes estrategias para conseguir minimizar el tiempo de ejecución de una instrucción. También tuvimos en consideración el tamaño del bus de lectura de las memorias para poder realizar las lecturas y escrituras a tiempo. 3.1.1 Opción 1: Modo secuencial. La forma básica de desarrollo. Cada proceso se realiza al finalizar el anterior. Este método es sencillo y requiere muy poco hardware. Sin embargo es muy lento al requerir siempre al menos 5 ciclos para cada instrucción. Presenta el problema de la lectura de código por lo que debemos seleccionar una memoria que permita leer los Opcodes que 24 Fuente: Elaboración propia. Tabla 10: Modo de trabajo secuencial con cinco ciclos de reloj por ciclo de máquina. Ciclo 1 Ciclo 2 Ciclo 3 Ciclo4 Ciclo 5 Ciclo 6 Ciclo 7 Ciclo 8 Ciclo 9 Ciclo 10 Fetch Decode Read Execute Write Fetch Decode Read Execute Write Diseño de microcontrolador compatible con 80251. necesitamos. La solución optima es realizar por instrucción dos Fetch en una memoria de 32 bits por el tema de cuando salte no tengamos problemas con el Fetch. 3.1.2 Opción 2: Modo Pipeline. En esta opción se realizan todas las tareas a la vez, pero de diferentes instrucciones. Esta opción reduce el tiempo de ejecución de una instrucción a tan solo un ciclo de máquina, y si el acceso a memoria está bien dimensionado se consigue que el ciclo máquina sea de tan solo un ciclo de reloj. Por contra la complejidad de esta forma es muy alta. Además el resultado de una instrucción puede ser requerida antes de que sea escrita, teniendo que interrumpir la ejecución de la instrucción. También se puede dar el caso de que el sistema pretenda leer y escribir en la RAM a la vez. La figura 2.1.2 muestra esta estrategia funcionando sin pausas. 3.1.3 Opción 3: Modo mixto. Es una mezcla de los dos anteriores. Por un lado es más rápido que el modo secuencial, por el otro, es más sencillo que el modo paralelo. No hay que interrumpir la ejecución de las instrucciones, pero en algunos casos si la ejecución del programa. La configuración de las memorias en este caso adquiere especial relevancia. La tabla 12 muestra este modo de funcionamiento. Se realiza por un lado el Fetch de las instrucciones, eligiendo un tamaño de memoria grande para poder ir almacenando Opcodes. Debido a la configuración de las memorias, podemos hacer el Decode y el Read de las memorias en el mismo ciclo de reloj. Lo mismo ocurre con el Execute y el Write. En definitiva, cada instrucción hace en un ciclo de máquina el Fetch y en el siguiente se hace el Decode-Execute. Este método consigue un ciclo de máquina de dos ciclos de reloj y cada instrucción solo requiere un ciclo de máquina. La opción seleccionada finalmente es esta última, trabajando en modo mixto con memoria de datos de 32 Bits. Se consigue un ciclo de máquina de dos ciclos de reloj y todas las instrucciones salvo excepciones tienen una duración de un ciclo. 25 Fuente: Elaboración propia. Fuente: Elaboración propia. Tabla 11: Modo de trabajo paralelo. Las instrucciones solo tardan un ciclo de reloj en completarse. Ciclo 1 Ciclo 2 Ciclo 3 Ciclo 4 Ciclo 5 Ciclo 6 Ciclo 7 Ciclo 8 Ciclo 9 Fetch 1 Fetch 2 Fetch 3 Fetch 4 Fetch 5 Fetch 6 Fetch 7 Fetch 8 Fetch 9 Decode 1 Decode 2 Decode 3 Decode 4 Decode 5 Decode 6 Decode 7 Decode 8 Read 1 Read 2 Read 3 Read 4 Read 5 Read 6 Read 7 Execute 1 Execute 2 Execute 3 Execute 4 Execute 5 Execute 6 Write 1 Write 2 Write 3 Write 4 Write 5 Tabla 12: Modo de trabajo mixto. Es el que finalmente utilizamos en nuestro diseño. Ciclo 1 Ciclo 2 Ciclo 3 Ciclo 4 Fetch 1.1 Fetch 1.2 Fetch 2 Fetch 3 Fetch 4 Decode 1 Execute 1 Decode 2 Execute 2 Decode 3 Execute 3 Read 1 Write 1 Read 2 Write 2 Read 2 Write 3 Capítulo 3: Diseño del núcleo del microprocesador 80251. 3.2 Configuración de las memorias. Otro factor muy importante que determina la velocidad del núcleo es el acceso a las memorias. La estrategia elegida en el apartado anterior requería poder leer y escribir en un solo ciclo, mientras se realizaba el Decode y el Execute. Para abordar este problema solo hemos tenido en cuenta la configuración que debemos usar. Como las FPGA tienen bloques internos de RAM, no hay problemas de tiempos de acceso a las mismas. Antes de continuar, es importante recordar que las memorias tienen un ancho de palabra que puede ser de 1 Byte, 2 Bytes, 4 Bytes... etc. La dirección del dato que el microprocesador pretende leer no será la misma que la dirección física en la memoria. Como el ancho de palabra de las memorias es exponente de 2, normalmente la dirección de memoria es la parte superior de la dirección global y la parte baja selecciona la posición de comienzo de lectura. El problema que se nos presenta son las lecturas de varios Bytes que sobrepasan el ancho de las palabras de la memoria. Es decir, cuando hay que leer al menos dos líneas de memoria para obtener el dato completo. Este caso es inevitable debido a que los datos no están alineados y el comienzo de un dato puede estar en la parte alta de la dirección. A continuación se muestran unos ejemplos gráficos en una memoria genérica para poder ver con más claridad el problema: La solución adoptada para estos problemas es poner dos bloques de memoria en paralelo. De esta forma podemos leer en dos direcciones consecutivas en un solo ciclo. Aun así queda pendiente el tamaño de palabra de las memorias. El tamaño mínimo para no tener problemas es igual al tamaño del dato más grande que se puede acceder, en este caso son 4 Bytes o 32 bits. Se pueden seleccionar memorias más grandes, pero no se consigue ningún beneficio adicional. 26 DIRECCIÓN BYTE 1 BYTE 2 ..................................... BYTE N-1 BYTE N 1 XX XX ..................................... XX XX 2 XX XX ..................................... XX XX Ejemplo 2: Lectura de 4 Bytes a partir de la posición N-1. DIRECCIÓN BYTE 1 BYTE 2 ..................................... BYTE N-1 BYTE N 1 XX XX ..................................... XX XX 2 XX XX ..................................... XX XX Observase que si la memoria es de 2 bytes se necesitaran hacer 3 lecturas. DIRECCIÓN BYTE 1 BYTE 2 1 XX XX 2 XX XX 3 XX XX Como se observa, para la lectura de este dato hay que leer dos direcciones de Ram. Si estas dos direcciones están en el mismo bloque de memoria, habrá que hacer dos lecturas en dos ciclos. Diseño de microcontrolador compatible con 80251. Nuestro espacio de memoria RAM está dividido en dos bloques de memoria de 4 Bytes de palabra. Para la lectura o escritura se coge la dirección dada por las instrucciones y se divide en tres partes: los dos primeros bits, el tercer bit y el resto de bits. Los dos primeros bits representan la posición del primer Byte en la palabra. El segundo selecciona el bloque de memoria y la tercera parte la fila. El tamaño de cada memoria es de 1024 direcciones, que nos ofrece un tamaño total de memoria RAM de 8KB. En la siguiente figura puede verse una representación del espacio de memoria. 3.3 Bloques del núcleo. El diseño del núcleo del procesador se ha realizado en 6 bloques interconectados entre sí. Cada proceso interno del microprocesador está representado por un bloque. Los dos restantes son bloques especiales que se ha decidido sacarlos fuera para facilitar el diseño. 27 Fuente: Elaboración propia. Fuente: Elaboración propia. Figura 3.2_1: Espacio de memoria RAM total de nuestro diseño y la estructura de las direcciones. Dirección: xxxxxxxxxxxxxxxxxxxxxx-y-zz Parte 1: zz Parte 2: y Parte 3: xxxxxxxxxxxxxxxxxxxxxx Bloque 1 Bloque 2 y = '0' y = '1' 1024 1023 1022 1021 1020 ... 4 3 2 1 0 Posición (Parte 1)*: 3210 3210 * Valores binarios puestos en base decimal. Dirección de memoria (Parte 3)* Figura 3.3_1: Diagrama de Gant del proceso de diseño. Fetch diseño retoques retoques retoques retoques diseño retoques retoques Decode diseño diseño retoques diseño diseño diseño diseño Execute diseño diseño diseño retoques retoques Read–Write diseño retoques diseño retoques retoques retoques T Capítulo 3: Diseño del núcleo del microprocesador 80251. Se ha seguido un orden de diseño de los bloques atendiendo a las necesidades que surgen en cada momento. Primero se ha diseñado el bloque del proceso Fetch, puesto que necesitamos los Opcodes de las instrucciones. Después, se ha diseñado el bloque del proceso Decode. Tras este proceso se ha diseñado el bloque de control de las memorias RAM y de los registros. Este bloque se encarga tanto de leer como de escribir las memorias. Cuando ya se han tenido disponibles los datos, se ha procedido con el diseño del bloque encargado de realizar el Execute. Todos los bloques se han diseñado por partes, alcanzando unos objetivos que se han propuesto dependiendo de las necesidades puntuales del conjunto. Conforme se ha ido avanzando con el diseño se han requerido nuevas funciones en algunos bloques. Como se ve en la figura 3.3_1, todos los bloques han tenido varias fases de diseño y siempre se han ido haciendo pequeños cambios para ajustar ciertas señales. Cuando se indica retoques en la figura, se refiere a esos pequeños cambios. Con diseño se refiere a la introducción de nuevas funciones que antes no estaban y que el estado del diseño solicita. Los nombres de cada bloque y su correspondiente función son: DFetch_c2: Se encarga de realizar el Fetch. DDecode_c2: Realiza el Decode. DAlu: Realizar el proceso Execute. DReg_block_c2: Lee y escribe los registros y la RAM. DDiviblock2: Realiza la operación de la división. No se realiza en el bloque Alu por motivos que más adelante se explicaran. DRegistros_PSW: Contiene los registros PSW. No están con el resto de los registros SFR debido al gran número de ocasiones que se modifica. DRamsp1kx32: Bloques de la memoria RAM. Las FPGA´s tienen en su interior bloques de RAM configurables. Este bloque simula el comportamiento de la memoria que hemos elegido. No son sintetizables, solo sirve para realizar simulaciones y ver cómo se comporta la memoria. En la figura 3.3_2 podemos ver los bloques que forman el núcleo. Se corresponde al tercer nivel de los esquemáticos. La descripción de los bloques, Packages y otras entidades se encuentra en el anexo 3. Aquí se ven los procesos en los que están dividido cada bloque. Se explica la función de cada uno. También muestra los algoritmos más complicados haciendo una breve descripción de ellos. 28 Diseño de microcontrolador compatible con 80251. 29 Fuente: Elaboración propia. Figura 3.3_2: Esquemáticos de todos los bloques presentes en el núcleo. Capítulo 3: Diseño del núcleo del microprocesador 80251. 30 Diseño de microcontrolador compatible con 80251. Capítulo 4: Pruebas y resultados. En esta sección vamos a ver las operaciones que se han realizado para comprobar el diseño. Se empiezan con la verificación del código para comprobar que funciona correctamente. Posteriormente se comparará el resultado de una simulación en un compilador del 251 con el resultado de nuestro microprocesador. Finalmente se hace una prueba de síntesis para comparar los recursos usados con los que usa el 8051 sin periféricos. 4.1 Comprobación del código VHDL. Las pruebas se han realizado mediante simulaciones en Modelsim 6.2. Cada bloque ha sido probado independientemente. Como se ha comentado en el capítulo anterior, la mayoría de bloques han sido diseñados en un momento determinado y luego completados o ajustados. Implica que las pruebas de los bloques se hayan tenido que ir haciendo periódicamente. Se han creado varios proyectos paralelos en donde probar las primeras versiones de los bloques. En ellos se ha introducido el bloque de prueba en un estado de diseño bastante avanzado. También se han creado bloques de Test que generan señales que son enviadas a los bloques de prueba. A las señales generadas en estos bloques se les denomina Testbench y se busca que abarquen todo el rango de utilidad del diseño de prueba. Al probar todas las combinaciones posibles se verifica que funcionara correctamente al colocar el bloque en el proyecto definitivo. 31 Capítulo 4: Pruebas y resultados. Algunas pruebas requieren además del bloque de test, otros bloques ya diseñados. No hay problemas en introducir en la pruebas cuantos bloques se necesiten, pero tenemos que tener cuidado a la hora de hacer modificaciones en estos. Si introducimos alguna modificación se deben pasar las pruebas de nuevo. Aunque las primeras pruebas se hacen de forma individual en proyectos paralelos, las pruebas finales se deben hacer en el proyecto principal. Incluso algunos bloques se prueban directamente desde el proyecto principal. Tal es el caso del bloque Alu que no tiene sentido probarlo individualmente cuando necesita todos los bloques. El bloque Decode, que es el más grande y el que ha requerido más modificaciones, ha sido probado de forma mixta. Se ha creado un sub-proyecto en el que se han probado las primeras fases del diseño. Pero las últimas fases, entre las que están las asignaciones de todas las instrucciones, han sido probadas en el proyecto principal. Las pruebas en este caso se han realizado al mismo tiempo en que se diseñaban. Los Testbench en este punto no son señales, sino que se han creado vectores de Opcodes que lee el Fetch para probar directamente las instrucciones. Se mira que el Decode genera bien las señales de control y que el Execute las interpreta correctamente. Se han probado las 269 instrucciones en los dos modos de funcionamiento. Para cada instrucción se han realizado las pruebas necesarias para abarcar todas las posibilidades que tienen. Si la instrucción modifica los Flags se han hecho pruebas para que los modifique todos y comprobar que no cambia algún Flag no deseado. Para realizar las pruebas se deben compilar los archivos de los bloques con Modelsim. También deben ser compilados los Packages y otras entidades. Para realizar la compilación se ha creado un programa que permite compilar todos los archivos a la vez y no tener que ir uno por uno con cada archivo. Una vez compilado debemos seleccionar las señales que pretendemos comprobar e introducirlas en el visor de señales. Por último se escribe el tiempo de simulación y se comprueba el resultado en forma de señales. Por lo general los resultados de las simulaciones son como se pueden ver en la figura 4.1_1. La simulación aporta información que nos permite verificar que los datos se copian correctamente en el destino, podemos ver si las operaciones aritméticas dan el resultado correcto y cambian bien los Flags, ver si las comparaciones entre variables se hacen correctamente en el momento adecuado.... 32 Diseño de microcontrolador compatible con 80251. 4.2 Verificación del código VHDL. Una cosa es que nuestro diseño funcione bien como lo hemos hecho y otra es que el funcionamiento se ajuste al diseño original. El principal motivo por el cual nuestro diseño no funciona igual al original es que el Datasheet no es muy explicito a la hora de describir algunas instrucciones y además contiene erratas. Para comprobar que funciona igual que el 251 original se debe comparar el resultado que ofrece nuestro diseño con el resultado que daría el 251. La comparación se hace ejecutando el mismo programa en un compilador y en nuestro diseño. Hemos usado el compilador Keil uvision4 para la verificación del código. Se escribe un programa en C en el compilador y este se encarga de compilarlo y generar un archivo en hexadecimal que cargaremos en nuestro diseño. Se han programado en C una serie de programas sencillos que ejecutan operaciones matemáticas. Entre ellos, uno que multiplica dos matrices 3x3 como se muestra a continuación y que va a ser el ejemplo desarrollado en esta sección: 33 Fuente: Elaboración propia. Figura 4.1_1: Resultado de una simulación en Modelsim. Capítulo 5: Conclusiones. ejecución de las instrucciones. Finalmente se ha optado por realizar el Fetch de forma independiente, el Decode-Read y el Execute-Write se realizan secuencialmente. La configuración de las memorias internas para lograr el menor ciclo ha sido poner dos memorias en paralelo de cuatro Bytes de ancho de palabra para las memorias RAM, mientras que la memoria del código de programa es también de cuatro Bytes de palabra pero tan solo una memoria. El diseño se ha realizado a partir de unos esquemáticos, que por una parte representan el proyecto desde la placa hasta el núcleo, y por otra representa dentro del núcleo los diferentes bloques que han sido diseñados. El núcleo se ha dividido en 6 bloques, 4 de ellos se encargan de los procesos internos del microprocesador y los otros dos los complementan con funciones especiales. Los bloques han sido compilados y puestos a prueba con el programa Modelsim. Con el compilador Keil uvision 4 se ha comparado la forma de funcionamiento de nuestro microprocesador con uno comercial, mostrando ambos el mismo resultado tras realizar las simulaciones. Por último, se han hecho pruebas de síntesis que han pasado satisfactoriamente. Este diseño tiene las siguientes características: DDos ciclos de reloj por ciclo de máquina. DFrecuencia de reloj máxima de 25 MHz, frecuencia de máquina de 12.5 Mips. DReducido número de instrucciones que requieren más de un ciclo de máquina para ejecutarse. DLa memoria RAM interna está dividida en dos bloques de memoria en paralelo con tamaño de palabra de 4 Bytes. DUn bloque de memoria ROM para código con tamaño de palabra de 4 Bytes. DEl tamaño del Hardware generado nos permite introducirlo en la FPGA sobrando suficientes recursos para periféricos. 5.2 Futuras líneas de desarrollo. Del microcontrolador solo se ha diseñado el núcleo, sin periféricos ni interrupciones. Para poder contar con una IP completa del microcontrolador 80251 se deberían diseñar los periféricos e introducirlos en el diseño. El diseño de la mayoría de los periféricos se puede hacer de forma independiente de nuestro diseño. El control de estos dispositivos se hace mediante los registros SFR, así como la lectura o transmisión de datos. El diseño se debería hacer en un bloque independiente junto al bloque del núcleo (segundo nivel de los esquemáticos), y solo habría que sacar del bloque Reg_block_c2 señales de control hasta este nivel. Para implementar los puertos habría que hacer más modificaciones dentro de nuestro diseño. Los puertos son bidireccionales, con lo que pueden funcionar como 40 Diseño de microcontrolador compatible con 80251. entradas o salidas, y van desde el núcleo hasta la placa. Se tendrá que tener en cuenta que algunos periféricos usan pines de los puertos como entradas o salidas. Por último está el tema de las interrupciones. Los periféricos en muchas ocasiones informan al microprocesador que han terminado o se han producido cambios mediante interrupciones. De esta forma evitamos tener que leerlos periódicamente y se gana en eficiencia. Además se evita la perdida de información por tardar demasiado en leer un dato. Las interrupciones detienen la ejecución del programa realizando un salto a una determinada dirección. Las interrupciones ejecutan una rutina y cuando la terminan continúan con la ejecución del programa donde se había quedado. Para ello antes de realizar el salto guardan el Program Counter (PC). La gestión de interrupciones se hace mediante SFR´s permitiendo habilitar las interrupciones y darles prioridad. Otra vía de desarrollo puede ser mejorar el ciclo de máquina que dure un ciclo de reloj, siguiendo un modo de trabajo Pipeline. Este modo de trabajo necesitará implementar una memoria de código similar a nuestra memoria RAM, que permita leer las instrucciones completas en un ciclo de reloj. También se deberá diseñar el Hardware pensado para poder leer las instrucciones antes de ser escritas en memoria, debido a que aparecerán dependencias entre instrucciones. Es ente caso la verificación será mucho más complicada, al tener las instrucciones dependencias entre ellas. 5.3 Conclusiones personales. La realización de este proyecto me ha supuesto un gran reto a la hora de diseñar con VHDL. Comprender el funcionamiento del microcontrolador para desarrollar una IP sintetizable no ha sido una tarea fácil. En algunos casos encontrar la solución a un problema me ha supuesto un gran esfuerzo pero al final siempre he conseguido encontrar una solución adecuada. A veces, las partes que parecen más sencillas y obvias son las que más dificultad me han supuesto. Este proyecto no sólo ha enriquecimiento mi conocimiento sobre el diseño con VHDL, también he aprendido a usar otros programas. Gracias a este proyecto he aprendido a dividir diseños en bloques. También he mejorado el uso de Modelsim, que lo manejo con mayor soltura, y la realización de esquemáticos. Los programas Keil y Symplify 9.2 nunca los había usado y he tenido que aprender a usarlos. Estoy muy satisfecho con el trabajo realizado. Después de tanto tiempo y esfuerzo ver funcionar el diseño es muy gratificante. Aunque con la experiencia adquirida haría las cosas de diferente manera. Lo cual creo es que algo normal, ya que ha sido la primera vez que me he enfrentado con un microcontrolador por dentro, y conforme el proyecto ha ido avanzando me he encontrado con problemas que he tenido que resolver. 41 Capítulo 5: Conclusiones. 42