1. No category

UNIVERSIDADE DE VIGO
ESCOLA TÉCNICA SUPERIOR
DE ENXEÑEIROS DE TELECOMUNICACIÓN
PROYECTO FIN DE CARRERA
DESARROLLO DE UN MICROPROCESADOR
DIDÁCTICO MEDIANTE FPGAs
Autor: Álvaro García Varela
Tutor: Luis Jacobo Álvarez Ruiz de Ojeda
Curso 2003/2004
EL TRIBUNAL NOMBRADO PARA EL PRESENTE PROYECTO DE
FIN DE CARRERA, COMPUESTO POR:
PRESIDENTE:
VOCAL:
SECRETARIO:
ACUERDAN OTORGARLE LA CALIFICACIÓN DE:
Vigo, a
de
de 2003
A miña filla Inés,
para que a partir de agora, teñamos máis
tempo para pintar “tríngulos” e ver “calículas”.
Agradecimientos
Terminan aquí, cuatro años de intensivo trabajo después de once años apartado del
mundo universitario. Desde el momento en que tomé la decisión de volver a las aulas,
varias han sido las personas que, de alguna manera, me han ayudado a la hora de
alcanzar este objetivo a las cuales quiero manifestar mi agradecimiento.
En principio, agradecer a mi amigo Javier Fariñas el haberme animado en su momento
a matricularme. A la directora de la Biblioteca Universitaria de Santiago de
Compostela, Mariví Pardo, por su sensibilidad, humanidad y comprensión a la hora de
compatibilizar mi trabajo en este servicio con la obligaciones propias del estudio.
A aquellos profesores, que sin renunciar a las exigencias propias de las asignaturas,
han sabido entender mi situación laboral y me han facilitado las cosas. Dentro de este
grupo quiero recordar especialmente a Áurea Martínez Varela, Antonio García Pino,
Fernando Aguado Agelet , Fernando Pérez Fontán y a Jacobo Álvarez Ruíz de Ojeda.
Tengo una especial deuda con José Lino Monteagudo Pereira, amigo desinteresado
donde los haya, donde siempre he encontrado a alguien dispuesto a echar una mano en
lo que hiciese falta. Hago extensivo este agradecimiento, a toda su familia que siempre
se han preocupado por mi evolución como si fuese uno más de la familia.
Finalmente, agradecer a mi mujer Sole y mi hija Inés todos estos años de renuncia.
Resumen
En este Proyecto Fin de Carrera, se aborda el estudio de la viabilidad del diseño e
implementación de un procesador con fines didácticos, con el objeto de poder ser
incluido como parte práctica de una asignatura de la especialidad de electrónica, dentro
del currículum de un Ingeniero de Telecomunicaciones.
Para ello, se han desarrollado todos los pasos que debería acometer el alumno desde
su inicio, consistente en la definición del juego de instrucciones y arquitectura del
procesador, hasta su consecución final con la implementación del mismo en un
dispositivo programable del tipo FPGA1. El diseño del procesador se ha complementado
con el desarrollo de dos herramientas software de apoyo.
Palabras Clave:
™ Microprocesador.
™ Juego de instrucciones.
™ Dispositivos programables FPGA Spartan-II.
™ Ensamblador.
™ Puerto paralelo.
1
FPGA: Field Programmable Gate Array
“Computers in the future may weight no more than 1.5
tons” (Las computadoras del futuro puede que no pesen
más de tonelada y media)
Popular Mechanics, Marzo de 1949
“I think there is a world market for maybe five computers”
(Pienso que la demanda mundial de ordenadores será de
no más de 5 máquinas).
Thomas Watson. CEO de IBM (1943)
Índice General
1. Introducción ............................................................................................................... 1
1.1. Objetivo ................................................................................................................. 2
1.2. Estructura de la memoria ....................................................................................... 3
2. Fundamentos sobre Microprocesadores................................................................... 7
2.1. Perspectiva histórica .............................................................................................. 7
2.2. La arquitectura de Von Neumann .......................................................................... 9
2.3. Estructura básica de una CPU.............................................................................. 10
2.3.1. La Unidad de Control ............................................................................... 11
2.3.2. El registro de instrucción (IR) .................................................................. 12
2.3.3. La Unidad Aritmético Lógica (ALU) ....................................................... 13
2.3.4. El registro de estado (STATUS)............................................................... 14
2.3.5. La unidad de direccionamiento................................................................. 14
2.3.6. Registros auxiliares................................................................................... 15
2.4. La memoria .......................................................................................................... 16
2.5. Instrucciones ........................................................................................................ 16
2.5.1. Modos de direccionamiento...................................................................... 17
2.5.1.1. Direccionamiento implícito ......................................................... 18
2.5.1.2. Direccionamiento inmediato........................................................ 18
2.5.1.3. Direccionamiento directo............................................................. 18
2.5.1.4. Direccionamiento indirecto.......................................................... 18
2.5.1.5. Direccionamiento relativo............................................................ 18
I
2.5.1.6. Direccionamiento indexado..........................................................18
2.5.2. Clasificación de las instrucciones .............................................................19
2.6. Temporización de las instrucciones .....................................................................20
2.7. Interrupciones.......................................................................................................20
3. Introducción al diseño con dispositivos programables (FPGAs). .........................21
3.1. Introducción a los circuitos digitales configurables.............................................21
3.2. Fases en el diseño de circuitos con FPGAs..........................................................24
4. Desarrollo del microprocesador didáctico ERIC ...................................................27
4.1. Especificaciones generales ...................................................................................28
4.2. El juego de instrucciones......................................................................................28
4.2.1. Modos de direccionamiento ......................................................................29
4.2.2. Clasificación de las instrucciones .............................................................29
4.2.2.1. Transferencias de datos ................................................................30
4.2.2.2. Operaciones aritméticas ...............................................................30
4.2.2.3. Operaciones con banderas............................................................30
4.2.2.4. Operaciones lógicas......................................................................31
4.2.2.5. Flujo de programa ........................................................................31
4.2.3. Formato de las instrucciones .....................................................................32
4.3. Implementación física de Eric..............................................................................36
4.4. Estructura del microprocesador............................................................................38
4.4.1. Organización de la memoria .....................................................................40
4.4.2. El corazón del procesador .........................................................................43
4.4.2.1. El acumulador y el registro auxiliar B .........................................45
4.4.2.2. El registro de instrucción (IR)......................................................45
4.4.2.3. El registro de estado (STATUS) ..................................................45
4.4.2.4. El contador de programa (PC)......................................................46
4.4.2.5. El registro de direccionamiento de memoria (MAR)...................47
4.4.2.6. Multiplexores y bufferes triestado................................................49
4.4.2.7. La Unidad Aritmético Lógica (ALU)...........................................50
4.4.2.8. La Unidad de Control (UC)..........................................................53
II
4.4.2.8.1. Descripción de las señales .......................................... 55
4.4.2.8.2. El diagrama de estados ............................................... 57
4.4.2.8.3. El registro de gestión de interrupciones (IER)............ 60
4.4.2.8.4. El detector de flancos.................................................. 60
4.4.2.8.5. El generador de ciclos de espera................................. 62
4.4.2.9. El Sniffer...................................................................................... 65
4.4.3. El decodificador de 7 segmentos .............................................................. 68
4.5. ERIC y la XSA-50 ............................................................................................... 69
4.6. Ejecución de las instrucciones ............................................................................. 72
4.6.1. Temporización de las señales ................................................................... 72
4.6.2. Las interrupciones..................................................................................... 74
4.6.3. La ruta de datos......................................................................................... 74
4.6.3.1. Ejemplo: MOVX A,@B .............................................................. 75
4.6.3.2. Ejemplo: ACALL addr12 ............................................................ 78
5. Desarrollo del software de soporte .......................................................................... 83
5.1. EricMON ............................................................................................................. 83
5.1.1. Descripción general del programa ............................................................ 85
5.1.2. Modo LOAD............................................................................................. 86
5.1.3. Modo RUN ............................................................................................... 89
5.1.4. Modo STEP............................................................................................... 90
5.1.5. Implementación ........................................................................................ 92
5.1.5.1. El puerto paralelo en modo SPP .................................................. 93
5.1.5.2. Arquitectura software de las XSTOOLS ..................................... 94
5.1.5.3. La clase PPORT........................................................................... 96
5.1.5.4. La clase EricPORT ...................................................................... 97
5.1.5.5. La librería Console..................................................................... 100
5.1.6. Compatibilidad........................................................................................ 100
5.2. EricASM ............................................................................................................ 102
5.2.1. Descripción general del programa .......................................................... 103
5.2.2. Implementación ...................................................................................... 103
5.2.2.1. PARSER.Y ................................................................................ 105
III
5.2.2.2. SYMBOL.C................................................................................105
6. Prueba final..............................................................................................................107
6.1. Instalación de la prueba......................................................................................107
6.2. Conexión del LCD al ERIC ...............................................................................108
6.3. Ejecución de la prueba .......................................................................................109
7. Conclusiones y líneas futuras .................................................................................111
7.1. Conclusiones ......................................................................................................111
7.2. Líneas futuras .....................................................................................................115
8. Presupuesto ..............................................................................................................117
Referencias...................................................................................................................119
Contenido del CD ........................................................................................................121
A. Juego de instrucciones (ISA) del ERIC ................................................................123
A.1. Registros internos ..............................................................................................123
A.2. Memoria ............................................................................................................123
A.3. Modos de direccionamiento ..............................................................................124
A.4. Reset ..................................................................................................................124
A.5. Interrupciones....................................................................................................124
B. Microinstrucciones .................................................................................................137
C. Manual del monitor EricMON..............................................................................141
C.1. Requisitos previos..............................................................................................141
C.2. Instalación del software .....................................................................................142
C.3. Ejecución de la aplicación .................................................................................142
C.3.1. Modo LOAD...........................................................................................143
C.3.2. Modo RUN .............................................................................................145
IV
C.3.3. Modo STEP............................................................................................ 146
D. Manual del ensamblador EricASM...................................................................... 147
D.1. Comando ........................................................................................................... 147
D.2. Opciones del comando ...................................................................................... 147
D.3. Instrucciones ..................................................................................................... 149
D.4. Directivas .......................................................................................................... 149
D.5. Sintaxis del lenguaje ......................................................................................... 150
D.5.1. Generalidades......................................................................................... 150
D.5.2. Comentarios ........................................................................................... 150
D.5.3. Números................................................................................................. 150
D.5.4. Cadena de caracteres.............................................................................. 151
D.5.5. Símbolos ................................................................................................ 151
D.5.6. Expresiones ............................................................................................ 151
D.6. Ejemplo de un fichero fuente ............................................................................ 152
E. El entorno de desarrollo ISE WebPACK............................................................. 153
E.1. Descripción HDL o esquemáticos ..................................................................... 155
E.2. Síntesis............................................................................................................... 156
E.3. Posicionamiento y enrutado .............................................................................. 156
E.4. Simulación......................................................................................................... 156
E.5. Generación del bitstream y programación......................................................... 157
E.6. Tabla de prestaciones ........................................................................................ 158
F. La tarjeta de desarrollo XSA-50. .......................................................................... 159
F.1. Descripción de la tarjeta .................................................................................... 160
F.1.1. Los dispositivos programables: .............................................................. 160
F.1.2. El reloj programable ............................................................................... 161
F.1.3. La RAM dinámica .................................................................................. 161
F.2. La RAM FLASH ............................................................................................... 162
F.2.1. El visualizador de 7 segmentos .............................................................. 162
F.3. Puerto VGA y PS2............................................................................................. 163
V
F.3.1. Banco de interruptores DIP y pulsador ...................................................163
F.3.2. El puerto paralelo ....................................................................................164
F.4. Las utilidades XSTOOLS ..................................................................................166
F.4.1. GXSTEST (XSTEST).............................................................................166
F.4.2. GXSSETCLK (XSSETCLK)..................................................................166
F.4.3. GXLOAD(XSLOAD).............................................................................167
F.4.4. GXPORT(XSPORT)...............................................................................167
F.5. Listado de conexiones ........................................................................................168
G. FPGAs de la familia SPARTAN II DE XILINX. ................................................171
G.1. Arquitectura.......................................................................................................172
G.2. Bloques de entrada/salida (IOBs)......................................................................173
G.3. Bloques lógicos configurables (CLBs)..............................................................173
G.3.1. Tablas de consulta LUT (Look-Up Table) .............................................174
G.3.2. Lógica de acarreo (Carry Logic) ............................................................175
G.3.3. Amplificadores (BUFTs)........................................................................175
G.3.4. Lógica adicional .....................................................................................175
G.4. Bloques de memoria (BRAM) ..........................................................................175
G.5. Matriz de interconexión programable ...............................................................176
G.6. Caminos de interconexión local ........................................................................176
G.6.1. Caminos de interconexión de propósito general ....................................177
G.6.2. Caminos de interconexión globales........................................................178
G.7. DLL (Delay-Locked Loop) ...............................................................................178
G.8. Exploración periférica (boundary scan) ............................................................178
H. LCD PowerTIP 1602-H. ........................................................................................179
I. Intregración del proyecto en un IDE. ....................................................................181
J. Listados y esquemas ................................................................................................185
VI
Índice de Figuras
Figura 1: Computador elemental según Von Neumann.................................................... 9
Figura 2: Diagrama de bloques genérico de una CPU.................................................... 10
Figura 3: Informaciones de entrada de la Unidad de Control......................................... 11
Figura 4: La Unidad Aritmético Lógica (ALU).............................................................. 13
Figura 5: Estructura matricial de una FPGA de Xilinx .................................................. 23
Figura 6: Fases del diseño de un circuito mediante FPGAs ........................................... 25
Figura 7: Fases de desarrollo del entorno WebPACK de Xilinx.................................... 26
Figura 8: Estructura de campos del primer byte de una instrucción............................... 32
Figura 9: Tarjeta XSA-50 de la casa XESS utilizada en este proyecto .......................... 37
Figura 10: Tarjeta D2XL de la casa DIGILENT también probada en este proyecto ..... 37
Figura 11: Diagrama principal de bloques del ERIC (TOP.SCH).................................. 39
Figura 12: Esquema de la memoria del ERIC según el modelo de FPGA ..................... 41
Figura 13: Primitiva RAMB4_S8 utilizada como base de los módulos de memoria ..... 42
Figura 14: Esquema de bloques del corazón del procesador (CPU_CORE.SCH) ......... 44
Figura 15: El acumulador ............................................................................................... 45
Figura 16: El contador de programa ............................................................................... 46
Figura 17: El registro de direccionamiento de memoria................................................. 47
Figura 18: Relación de MAR con otros bloques del circuito ......................................... 48
Figura 19: Multiplexor tipo MUX2_8Z.......................................................................... 49
Figura 20: Unidad Aritmético Lógica............................................................................. 50
Figura 21: Diagrama de una máquina de estados tipo Mealy......................................... 53
Figura 22: La Unidad de Control del ERIC.................................................................... 54
I
Figura 23: Diagrama de estados de la Unidad de Control...............................................59
Figura 24: Registro de gestión de interrupciones............................................................60
Figura 25: Estructura interna de la Unidad de Control (CONTROL_UNIT.SCH) ........61
Figura 26: Subunidades del bloque de estados de espera (WAIT_STATES.SCH) ........63
Figura 27: Cronograma del generador de ciclos de espera asociado a la ROM..............64
Figura 28: Bloque SNIFFER...........................................................................................65
Figura 29: Decodificador binario a 7 segmentos ............................................................68
Figura 30: Adaptación de las señales del ERIC a la tarjeta XSA-50 ..............................71
Figura 31: Fase FETCH de la instrucción MOVX A,@B ..............................................76
Figura 32: Fase DECODE de la instrucción MOVX A,@B...........................................76
Figura 33: Fase EXECUTE de la instrucción MOVX A,@B.........................................77
Figura 34: Fase STORE de la instrucción MOVX A,@B ..............................................77
Figura 35: Fase FETCH de la instrucción ACALL addr12 ............................................80
Figura 36: Fase DECODE de la instrucción ACALL addr12.........................................80
Figura 37: Fase EXECUTE de la instrucción ACALL addr12.......................................81
Figura 38: Fase SUBR1 de la instrucción ACALL addr12.............................................81
Figura 39: Fase SUBR2 de la instrucción ACALL addr12.............................................82
Figura 40: Fase SUBR3 de la instrucción ACALL addr12.............................................82
Figura 41: Proceso a seguir desde el fichero fuente a la carga en el ERIC.....................87
Figura 42: Ejemplo de una sesión en modo LOAD ........................................................88
Figura 43: Ejemplo de una sesión en modo STEP ..........................................................91
Figura.44: Vista general del entorno de programación Visual C++ ...............................94
Figura.45: Esquema jerárquico de los objetos de las utilidadaes XSTOOLS.................95
Figura 46: Ventana en MS-DOS para invocar el programa EricMON .........................142
Figura 47: Menu principal del programa EricMON......................................................143
Figura 48: Submenú del modo LOAD del programa EricMON...................................143
Figura 49: EricMON mostrando un mensaje de error en modo LOAD........................144
Figura 50: Volcado de datos en memoria en el modo LOAD del programa EricMON144
Figura 51: Submenú del modo RUN del programa EricMON......................................145
Figura 52: Submenú del modo STEP del programa EricMON.....................................146
Figura 53: Ejemplo de un fichero fuente para el ensamblador EricASM .....................152
Figura 54: Ventana del Project Manager del entorno WebPACK ................................153
II
Figura 55: Esquema organizativo del entorno WebPACK ........................................... 154
Figura 56: Ventanas del simulador ModelSIM de la casa Mentor ............................... 157
Figura 57: Tarjeta XSA-50 de Xess.............................................................................. 159
Figura 58: Esquema general de la tarjeta XSA-50 ....................................................... 160
Figura 59: Conexión de la FPGA y la DRAM enana XSA-50..................................... 161
Figura 60: Conexión entre la FPGA, el CPLD y la FLASH en la XSA-50.................. 162
Figura 61: Detalles de las conexiones VGA y PS2 de la XSA-50 ............................... 163
Figura 62: Detalles de la conexión del la XSA-50 con el puerto paralelo.................... 165
Figura 63: Conexionado entre el puerto paralelo y distintas partes de la XSA-50....... 165
Figura 64: Ventana de dialogo de GXSTEST .............................................................. 166
Figura 65: Ventana de diálogo de GXSSETCLK......................................................... 166
Figura 66: Ventana de diálogo de GXLOAD ............................................................... 167
Figura 67: Ventana de diálogo de GXPORT ................................................................ 167
Figura 68: Esquema interno de una FPGA de la familia Spartan-II............................. 172
Figura 69: Diagrama de bloques de los IOBs de una FPGA Spartan-II ....................... 173
Figura 70: Diagrama de bloques de un SLICE de una Spartan-II ................................ 174
Figura 71: Tamaño de los bloques RAM según el modelo de Spartan-II..................... 175
Figura 72: Enrutado local de una Spartan-II................................................................. 176
Figura 73: Líneas de interconexión de propósito general en una Spartan-II ................ 177
Figura 74: Vistas anterior y posterior del LCD PowerTIP 1602 .................................. 179
Figura 75: Características mecánicas y diagrama de bloques del LCD-1602H ........... 180
Figura 76: Vista general del editor ConTEXT utilizado como IDE ............................. 181
Figura 77: Ejemplo de configuración de F9 para que ejecute EricASM ...................... 182
Figura 78: Ejemplo de configuración de F10 para que ejecute EricMON ................... 183
Figura 79: Ejemplo de configuración de F11 para que ejecute el XSLOAD ............... 184
III
Índice de Tablas
Tabla 1: Instrucciones de transferencia de datos ............................................................ 30
Tabla 2: Instrucciones aritméticas .................................................................................. 30
Tabla 3: Instrucciones de manipulación de banderas ..................................................... 30
Tabla 4: Instrucciones lógicas......................................................................................... 31
Tabla 5: Instrucciones de control de flujo de programa ................................................. 31
Tabla 6: Formato de los campos según el tipo de instrucción ........................................ 34
Tabla 7: Mapa de distribución de las instrucciones del ERIC........................................ 35
Tabla 8: Bloques BRAM disponibles según el modelo de FPGA.................................. 40
Tabla 9: Configuraciones posibles de un bloque BRAM de una Spartan-II .................. 40
Tabla 10: Tabla de operaciones de la ALU .................................................................... 51
Tabla 11: Asignación de registros a la entrada del multiplexor del SNIFFER............... 67
Tabla 12: Códigos visualizados en función del estado de la UC.................................... 68
Tabla 13: Asignación de las señales del ERIC a lo terminales (pines) de la XSA-50.... 69
Tabla 14: Descripción del vector de señales (SV).......................................................... 73
Tabla 15: Resumen de los pasos necesarios para ejecutar MOVX A,@B ..................... 75
Tabla 16: Resumen de los pasos necesarios para ejecutar ACALL addr12 ................... 79
Tabla 17: Descripción de las señales del puerto paralelo y su relación con ERIC......... 93
Tabla 18: Conexiones entre el LCD y la XSA-50 ........................................................ 108
Tabla 19: Resumen del juego de instrucciones del ERIC............................................. 125
Tabla 20: Microinstrucciones de las instrucciones del tipo MOV................................ 137
Tabla 21: Microinstrucciones de las instrucciones del tipo MIX ................................. 138
Tabla 22: Microinstrucciones de las instrucciones de carga e interrupción ................. 138
I
Tabla 23: Microinstrucciones de las instrucciones del tipo ALU .................................139
Tabla 24: Microinstrucciones de las instrucciones del tipo JMP ..................................140
Tabla 25: Prestaciones de los distintos productos software de Xilinx ..........................158
Tabla 26: Listado de las conexiones de la tarjeta XSA-50 ...........................................169
Tabla 27: Tipos de dispositivos de la familia Spartan-II ..............................................171
Tabla 28: Configuraciones posibles de los bloques RAM ............................................176
II
Capítulo 1
Introducción
Tradicionalmente, los planes de estudio de carreras técnicas han abarcado el estudio
de los fundamentos de la computación desde dos puntos de vista bien diferenciados y
complementarios. Un punto de vista teórico, donde se realiza el estudio genérico de un
procesador particularizado posteriormente en el estudio de un microprocesador
comercial. Otro punto de vista más práctico, consistente en la realización de programas
en ensamblador que posteriormente son probados, simulados y depurados sobre alguno
de los procesadores estudiados en la fase teórica.
Habitualmente, los profesores evidencian en los alumnos una desconexión entre los
conceptos sobre arquitectura, estudiados en la fase teórica, y el funcionamiento de los
programas que se prueban en el laboratorio.
Para superar esta limitación, en algunos centros de enseñanza, es común observar
prácticas orientadas a que el alumno diseñe su propio procesador, simulando su
comportamiento a partir de lenguajes de alto nivel. No obstante, para los docentes afines
al área de la electrónica, la opinión es que estas prácticas no resuelven la laguna
formativa, convirtiéndose al final en un estudio casi teórico de arquitecturas.
Por este motivo, el presente proyecto propone como solución, el diseño e
implementación de un procesador por parte del alumno, basado en el uso de dispositivos
programables tipo FPGAs.
1
2
Introducción
1.1.
Objetivo
El objetivo principal de este proyecto, ha sido el analizar la viabilidad de introducir
esta tarea como parte práctica de una asignatura de la especialidad de electrónica dentro
del currículum de un Ingeniero de Telecomunicaciones.
Para ello, se han llevado a cabo todos aquellos pasos que debería realizar el alumno,
desde la definición del juego de instrucciones, pasando por el diseño del procesador y su
posterior implementación en un dispositivo programable tipo FPGA, mediante el uso
de las herramientas CAD adecuadas. De este modo, se han podido obtener conclusiones
sobre la dificultad de cada uno de los pasos, y generar de paso material y
documentación útil para la labor formativa del personal docente.
La labor desarrollada en este proyecto, ha dado lugar al desarrollo de un procesador
con fines didácticos que hemos querido bautizar con el nombre de ERIC (Educational
Reduced Instruction set Computer), resultado de la combinación de dos conceptos
manejados a lo largo del libro: procesador educativo y juego reducido de instrucciones.
A los objetivos anteriores se le han añadido otros, no contemplados inicialmente en el
anteproyecto, orientados a facilitar el diseño y la explotación del ERIC por parte del
alumno. Estas contribuciones han consistido en la realización de dos aplicaciones: un
programa monitor denominado EricMON y un programa ensamblador denominado
EricASM.
Introducción
1.2.
3
Estructura de la memoria
La estructura de la presente memoria está formada por siete capítulos y diez
apéndices, cuyo contenido se describe a continuación.
™ Capítulo 1: Introducción. En este capítulo, se realiza una descripción general
sobre los objetivos perseguidos con la realización de este Proyecto Fin de
Carrera.
™ Capítulo 2: Fundamentos sobre microprocesadores. En este capítulo, se hace
un recorrido sobre las bases teóricas que fundamentan los procesadores,
describiendo los elementos más relevantes de un microprocesador.
™ Capítulo 3: Introducción al diseño con dispositivos programables (FPGAs).
En este capítulo, se hace una breve introducción a los dispositivos programables,
centrando la descripción en la estructura interna de las FPGAs. También se
describe la metodología de trabajo utilizada en el desarrollo de proyectos
basados en este tipo de dispositivos.
™ Capítulo 4: Desarrollo del microprocesador didáctico ERIC. Es el capítulo
fundamental de la obra, donde se describe cada uno de los elementos que
componen el ERIC. Partiendo de unas especificaciones de inicio y un juego de
instrucciones, se va diseñando paso a paso cada uno de los elementos que
componen el microprocesador, explicando en cada caso las decisiones
adoptadas. Se hace un especial énfasis, en describir las operaciones llevadas a
cabo por la CPU en la ejecución de las instrucciones.
™ Capítulo 5: Desarrollo del software de soporte. Este capítulo, describe la
motivación que ha conducido al desarrollo de los dos programas de soporte al
ERIC. Se explica detalladamente las distintas clases y métodos que sustentan el
EricMON. También se describen las partes que conforman el ensamblador
EricASM, explicando las labores acometidas en la adaptación del programa a
partir del AS31.
™ Capítulo 6: Prueba final. El diseño e implementación del ERIC, concluye con
la ejecución de una prueba para comprobar el correcto funcionamiento del
sistema. Este capítulo describe los pasos a seguir para acometer dicha prueba.
4
Introducción
™ Capítulo 7: Conclusiones y líneas futuras. En este capítulo se hace una
valoración sobre lo conseguido en el presente proyecto. Se analizan los puntos
de especial dificultad que puede dificultar su implantación como asignatura. Se
proponen soluciones y alternativas para acometer dicha implantación.
™ Capítulo 8: Presupuesto. Este último capítulo, recoge los costes de material y
mano de obra de ingeniería invertidos en el desarrollo del presente proyecto.
Antes de iniciar la descripción de los apéndices, comentar que se ha dado una especial
relevancia a esta parte de la memoria con el objeto de facilitar el desglose de
información que, según criterio del profesor, sea preciso proporcionar al alumno para
acometer la tarea de desarrollar el procesador.
™ Apéndice A: Juego de instrucciones (ISA) del ERIC. En este apéndice, se
hace una descripción detallada de todas las instrucciones soportadas por el
ERIC.
™ Apéndice B: Microinstrucciones. Resumen de cada una de las etapas en que se
ha divido la ejecución de cada instrucción, así como las señales de control
implicadas.
™ Apéndice C: Manual del monitor EricMON. En esta parte, se describen las
prestaciones del monitor así como el modo de utilización.
™ Apéndice D: Manual del ensamblador EricASM. Describe las prestaciones
del ensamblador así como el modo de usarlo.
™ Apéndice E: El entorno de desarrollo ISE WebPACK. En este apéndice se
describe, de una manera muy general, las prestaciones del entorno de trabajo
proporcionado por Xilinx, para el desarrollo de diseños basados en dispositivos
programables de esta firma.
™ Apéndice F: La tarjeta de desarrollo XSA-50. Este apéndice describe, cada
una de las partes que constituyen la tarjeta de desarrollo utilizada en este
proyecto.
™ Apéndice G: FPGAs de la familia SPARTAN II de Xilinx. Describe los
recursos hardware más relevantes, que proporciona el uso de las FPGAS de la
familia Spartan-II.
Introducción
5
™ Apéndice H: LCD Powertip 1602.-H. Describe aspectos mecánicos y físicos
del visualizador LCD utilizado en la fase de prueba del sistema.
™ Apéndice I: Integración del proyecto en un IDE. Tanto el procesador, como
las aplicaciones software, pueden ser ejecutadas desde un entorno de desarrollo
integrado aprovechando la funcionalidad de editores gratuitos. Este apéndice
explica como configurar uno.
™ Apéndice L: Listados y esquemas. Este apéndice, recoge todos listados VHDL
del diseño así como los esquemas realizados en el entorno WebPACK.
Capítulo 2
Fundamentos sobre Microprocesadores
2.1.
Perspectiva histórica
La idea de un sistema de procesamiento de información, que sea reconfigurable a
través de un programa guardado en alguna forma de memoria, es muy antigua,
remontándonos a principios del siglo XIX. Charles Babbage [1791-1871] fue quien
proyectó el primer computador mecánico, capaz de ejecutar secuencias de operaciones
automáticamente, conocido como máquina diferencial. La complejidad de los
elementos mecánicos necesarios para su funcionamiento, imposibilitó su construcción
dada las limitaciones tecnológicas de la época.
Con el nacimiento de la electrónica se volvieron a realizar intentos en la construcción
de computadores. En 1941, se inicia la construcción del ENIAC (Electronica Numeral
Integrator and Computer) el primer computador funcional de la historia. Esta máquina
tenía alrededor de 19.000 válvulas y fue construida por la Escuela de Ingeniería
Eléctrica de Moore. Fue puesta en funcionamiento en el año 1945 y se retiró en 1955.
Su principal inconveniente, era que debía ser programado manualmente accionando una
serie de interruptores, conectando y desconectando cables.
En 1945 el matemático húngaro-americano John Von Neumann2 [1903-1957], que ya
había formado parte del equipo de desarrollo del ENIAC, publicó un artículo First Draft
of a Report on the EDVAC que sentó los principios de construcción de los
2
También conocido porque participó en el diseño de la bomba atómica y de la bomba de hidrogeno.
7
8
Fundamentos sobre Microprocesadores
computadores, a pesar de que el EDVAC no llegó a construirse nunca. Dentro de estas
ideas, que hoy conocemos como arquitectura de Von Newmann, estaba la de utilizar un
programa almacenado en memoria.
Tras el ENIAC, vendrían otros computadores basados en válvulas de vacío conocidos
como ordenadores de primera generación, caracterizados por su elevado tamaño y baja
fiabilidad. La aparición de los transistores en 1947, daría lugar a la segunda generación,
subsanando parcialmente los problemas de tamaño, introduciendo el uso de discos
magnéticos para guardar la información y memoria basadas en ferritas. La tercera
generación, se iniciaría con el advenimiento de los circuitos integrados en 1961,
permitiendo con ello una gran reducción de tamaño y un aumento en la complejidad de
los computadores.
La aparición de los circuitos integrados de gran escala de integración (VLSI), permitió
el diseño de un procesador en un solo chip que daría lugar al nacimiento de los
microprocesadores. El 4004 de Intel (1971) fue el primer dispositivo de este tipo. Este
logro, permitió seguir reduciendo el tamaño y bajar los costes, consiguiendo de este
modo una mayor difusión del microprocesador impensable hasta el momento. Desde
entonces, los microprocesadores no han dejado de evolucionar, mejorando sus
prestaciones según lo han hecho el número de transistores disponibles (Ley de Moore3)
En la actualidad, gracias a gran cantidad lógica y a la capacidad de configuración de
los circuitos programables del tipo FPGA, cualquier diseñador con cierta experiencia
puede realizar su propio procesador.
3
En un chip, la densidad de transistores se duplica cada 18 meses.
La arquitectura de Von Neumann
2.2.
9
La arquitectura de Von Neumann
Como ya comentamos con anterioridad, Von Neumann desarrolló una arquitectura
sobre la estructura interna de un computador que, aún hoy es la base en la que se
asientan la mayoría de los procesadores actuales. Esta arquitectura, se caracteriza por
una división funcional en bloques tal como se muestra en la siguiente figura:
CPU
ALU
MÓDULO
DE
E/S
MEMORIA
UNIDAD DE
CONTROL
Figura 1: Computador elemental según Von Neumann
Los elementos esenciales son la memoria y el procesador. La memoria, es el lugar de
almacenamiento donde se guardan instrucciones y los datos de los programas. El
procesador, es un intérprete de un juego de instrucciones cuya finalidad es:
™ Extraer la instrucción de memoria y decodificarla.
™ Ejecutar la instrucción.
™ Localizar la siguiente instrucción y volver al primer paso.
Este proceso continúa de manera recurrente y de esta forma, el ordenador puede
ejecutar cualquier tipo de programa por grande que sea su complejidad. Veamos a
continuación, una descripción más detallada de cada uno de estos bloques y su
configuración interna.
10
2.3.
Fundamentos sobre Microprocesadores
Estructura básica de una CPU
B
U
S
SEÑALES DE CONTROL
REGISTRO B
ACUMULADOR
ALU
REGISTROS
AUXILIARES
CONTADOR DE
PROGRAMA
UNIDAD
DE
DIRECCIONAMIENTO
D
E
D
A
T
O
S
UNIDAD
DE
CONTROL
REGISTRO DE
REGISTRO DE
STATUS
INSTRUCCIÓN
I
N
T
E
R
N
O
BUFFER DEL
BUS DE DATOS
BUS DE DIRECCIONES
BUS DE DATOS
RELOJ
RESET
Figura 2: Diagrama de bloques genérico de una CPU
BUS DE CONTROL
Estructura básica de una CPU
2.3.1.
11
La Unidad de Control
El bloque que gobierna y coordina todas las operaciones, que tienen lugar dentro de
la CPU, es la Unidad de Control (UC). Se trata, de un circuito secuencial que genera las
microinstrucciones que recibirán los elementos operativos como la ALU, registros, etc.
Órdenes tales como, que un registro almacene un dato o lo entregue al bus, que un
registro se incremente, decremente, que la ALU ejecute una función determinada de su
repertorio, todas ellas proceden de la UC.
Para que la Unidad de Control pueda desempeñar su función, necesita disponer de dos
informaciones de distinta procedencia:
™ La INSTRUCCIÓN, procedente del exterior de la CPU.
™ El STATUS, procedente del interior de la CPU.
INSTRUCCIÓN
UNIDAD
DE
MICRO-ÓRDENES
CONTROL
STATUS
RELOJ
Figura 3: Informaciones de entrada de la Unidad de Control
La instrucción es un valor binario que indica a la CPU la función que debe realizar. La
Unidad de Control, interpreta el significado de la instrucción y la descompone en
operaciones elementales (microinstrucciones), de tal modo que, los elementos internos
de la CPU puedan llevar a cabo la tarea encomendada.
Por otro lado, la acción de la unidad de control está condicionada por la historia
anterior de la CPU, reflejada en los bits del registro de estado (STATUS), que indicarán
12
Fundamentos sobre Microprocesadores
que las operaciones previas han dado como resultado un valor nulo, con acarreo,
desbordamiento, etc. En función de esta información, el controlador puede generar
microinstrucciones diferentes para una misma instrucción.
La Unidad de Control es un circuito síncrono, es decir, que todos sus cambios vienen
marcados por un reloj externo utilizado para coordinar el funcionamiento interno del
sistema. Cada salida de la Unidad de Control, genera una microinstrucción específica
destinada a actuar sobre un elemento de la CPU. Por ejemplo, una de estas señales da
lugar a que un dato se escriba en un registro determinado, otra señal activa la salida de
un registro cuyo contenido se vuelca en un bus interno, otras indican a la ALU que
debe realizar una suma, etc.
2.3.2.
El registro de instrucción (IR)
La CPU es capaz de ejecutar un número finito de acciones que le vienen señaladas
desde la memoria de programa, mediante una combinación binaria que se denomina
instrucción. Una instrucción es, por lo tanto, un conjunto de unos y ceros que indicará a
la CPU cuál es la operación que debe realizar. La UC es la encargada de desgranar el
significado de la instrucción y generar las correspondientes microinstrucciones.
Para llevar a cabo esta tarea, la instrucción extraída de la memoria deberá almacenarse
momentáneamente durante el tiempo que invierta la UC en ejecutar las
microinstrucciones. Esto proceso, se realiza con la ayuda de un registro conocido como
registro de instrucción (IR). Dicho registro, tendrá tantos bits como la longitud de
palabra del microprocesador.
La forma en que la instrucción es extraída de la memoria, no es diferente de cualquier
otro proceso de lectura, sin embargo, la CPU debe discernir de algún modo que esta
información leída es precisamente una instrucción y no otro dato cualquiera. Por otro
lado, dicha instrucción es una combinación binaria que en nada se diferencia de
cualquier otra información contenida en memoria. El único hecho diferencial, que
permite que esa palabra binaria sea llevada al registro de instrucción, es precisamente
que en ese instante la CPU espera una instrucción y no, otro tipo de dato.
Estructura básica de una CPU
2.3.3.
13
La Unidad Aritmético Lógica (ALU)
Es habitualmente, un circuito combinacional capaz de realizar ciertas operaciones de
tipo lógico o de tipo aritmético entre dos operandos, generando un resultado que se
almacena en un registro denominado acumulador. Para ello, es preciso que cada uno de
los operandos esté situado en la entrada correspondiente de la ALU. Estas variables de
entrada determinarán la salida de la ALU de acuerdo con las tablas de verdad a las que
responde. Las entradas de control determinarán la operación a realizar. Por ejemplo, 3
líneas de control permiten definir 8 operaciones diferentes que podrían ser: AND, OR,
XOR, NOT, NAND, suma binaria y resta binaria.
El acumulador, es un registro de carga y salida en paralelo que, recoge el resultado de
la operación de la ALU. La orden de memorización del resultado, en el registro
acumulador, procede de la UC y deberá llegar después de que los operandos hayan sido
memorizados en sus respectivos registros y con el tiempo suficiente de retraso, para que
la salida de la ALU haya alcanzado su valor estable.
B
U
S
D
E
ACUMULADOR
REGISTRO B
STATUS
D
A
T
O
S
CTRL
ALU
Figura 4: La Unidad Aritmético Lógica (ALU)
I
N
T
E
R
N
O
14
Fundamentos sobre Microprocesadores
La estructura habitual de una ALU incluye el uso de tres registros: dos registros de
operando y un registro acumulador. No obstante, la mayoría de los fabricantes optan por
suprimir uno de los registros de operando sustituyéndolo por el propio acumulador, tal
como puede verse en la figura anterior. De esta forma, el acumulador cumple dos
cometidos: antes de la operación almacena un operando y después almacena el
resultado.
La ALU, aparte de llevar a cabo operaciones lógico-aritméticas, suele actualizar el
estado de los bits de estado en función del resultado de la operación, pudiendo utilizarse
esta información en operaciones posteriores.
2.3.4.
El registro de estado (STATUS)
El registro de estado, también llamado registro de códigos de condición, está formado
por un conjunto de biestables independientes, denominados comúnmente como
banderas (flags). Cada uno de ellos, está destinado a memorizar un determinado suceso
que ha tenido lugar dentro de la CPU. Los sucesos que suelen estar señalados mediante
banderas son habitualmente los siguientes:
™ El resultado de una operación ha sido nulo (Zero o Z).
™ El resultado de una operación ha generado acarreo (Carry o C).
™ El resultado de una operación desborda la capacidad de un registro (Overflow o
OV).
El estado de las banderas, es consultado por la UC y condicionará su modo de
funcionamiento en el desarrollo de algunas instrucciones, normalmente los saltos
condicionados.
2.3.5.
La unidad de direccionamiento
Para poder acceder, tanto a las instrucciones como a los datos, la CPU a de tener
capacidad de direccionamiento de la memoria. Con esta finalidad, la CPU dispone
tanto de un bus de datos como de un bus de direcciones. El número de líneas de estos
Estructura básica de una CPU
15
buses, definen la capacidad máxima de memoria soportada, así como, la longitud de la
instrucción que va a manejar el computador.
Cuando la CPU se dirige a la memoria, para encontrar instrucciones del programa
que está ejecutando, suele hacerlo en posiciones consecutivas. En este caso, el circuito
interno de la CPU que se encarga de presentar su contenido en el bus de direcciones, es
el llamado contador de programa (PC). El número de bits de este registro síncrono, está
en relación con el tamaño del bus de direcciones.
Pero el programa, no siempre se ejecuta de forma estrictamente consecutiva, sino que
pueden producirse saltos o rupturas de secuencia, lecturas o escrituras de datos en
posiciones de memoria completamente aleatorias, saltos a posiciones relativas al
contenido del PC, etc. Para ello, la CPU debe disponer de capacidades adicionales de
direccionamiento, que le permitan llevar a cabo estas tareas, que se traducen en
operaciones como el cambio del contenido del PC, calcular direcciones relativas a la
actual, guardar o cargar una dirección a partir de los datos procedentes del bus de datos,
etc. Normalmente, toda esta funcionalidad no es posible con la ayuda de un único
registro, por lo que se hace necesaria la ayuda de registros auxiliares (MAR),
sumadores, multiplexores, etc.
2.3.6.
Registros auxiliares
Para la ejecución de determinadas instrucciones, a veces, se hace necesario el uso de
registros auxiliares internos, inaccesibles por el usuario, que permitan llevar estas
tareas. Su función, aunque hay muchas posibles, podría decirse que es la de
almacenamiento temporal sin necesidad de acudir a la memoria externa, y la de ayuda a
la generación de direcciones de memoria.
Dentro de estos registros auxiliares, requiere una atención especial un registro que
suelen incluir todos los procesadores: el STACK POINTER o puntero de pila.
16
Fundamentos sobre Microprocesadores
2.4.
La memoria
La memoria es uno de los módulos fundamentales de un procesador. Es el lugar donde
se guarda la información sobre el programa a ejecutar, así como los datos que se vayan
generando. Aunque existen varias modalidades de memoria, clasificadas según la
tecnología con la que se fabrican, todas ellas pueden catalogarse en memorias:
™ ROM
De solo lectura, orientadas al almacenamiento de programas ya
que mantienen su contenido en ausencia de alimentación.
™ RAM
De
lectura/escritura
de
acceso
aleatorio,
orientadas
al
almacenamiento de datos o de programas de manera temporal. No
mantiene su información en ausencia de alimentación.
Independientemente del tipo, un módulo de memoria, es un conjunto de celdas de
almacenamiento con circuitos asociados, que permiten la transferencia de información
entre el interior de la memoria y el mundo exterior.
2.5.
Instrucciones
Una instrucción, es una información elemental que se suministra a la CPU en forma
de combinación binaria, a partir de la cual la CPU desarrolla una secuencia de acciones,
que le permiten llevar a cabo una determinada manipulación de la información. El
conjunto de instrucciones que soporta una CPU se conoce como juego de instrucciones,
y determina las capacidades del procesador.
La asignación de los códigos binarios, a cada una de las instrucciones, no se realiza de
forma aleatoria, sino que, es el resultado de un estudio detallado, con el objeto de
simplificar las labores de decodificación por parte de la unidad de control.
Los bits de la combinación binaria que constituyen la instrucción, se dividen en
grupos denominados campos. Los campos más comunes, que se encuentran en los
distintos formatos de instrucciones, son los siguientes:
Instrucciones
17
™ Un campo de código de operación, que especifica la operación que se debe
realizar.
™ Un campo de dirección, que designa una dirección de la memoria o un código
para elegir un registro del procesador.
™ Un campo de modo, que especifica la forma en que se interpretará el campo de
dirección.
El código de operación de una instrucción, es un grupo de bits que definen diversas
operaciones del procesador, como puede ser: la adicción, la sustracción, complemento,
etc. Los bits que definen el campo de modo, especifican diversas alternativas para
escoger los operandos del campo de dirección.
La longitud de la instrucción es variable; así, podemos encontrarnos instrucciones
codificadas en una única palabra como otras que pueden ocupar dos, tres o más
palabras. Todo dependerá de la complejidad de la instrucción, del número de
operaciones, de la diversidad de los modos de direccionamiento, etc. La elección de un
juego de instrucciones extenso o reducido ha dado lugar a dos tipos de concepción sobre
la arquitectura de los procesadores, conocidos como CISC4 o RISC5. Se dice que un
juego de instrucciones es ortogonal, si cada operación se puede realizar con cualquier
tipo de operando y cualquier modo de direccionamiento.
2.5.1.
Modos de direccionamiento
Los datos necesarios para que se ejecute una instrucción, y que son especificados por
el operando, pueden ser accesibles de diferentes formas, llamados modos de
direccionamiento. De este modo, se añade versatilidad a las operaciones que es capaz
de realizar la CPU, facilitando la realización de programas o acelerando la ejecución de
los mismos. Los modos de direccionamiento disponibles en una CPU pueden ser muy
variados, incluyendo en muchos casos, combinación de varios en una misma
instrucción. En cualquier caso, existen ciertos modos que, aunque puedan variar de
nombre, obedecen a una misma forma de operar. Estos modos son:
4
CISC: Complex Instruction Set Computer
5
RISC: Reduced Instruction Set Computer
18
Fundamentos sobre Microprocesadores
2.5.1.1.
Direccionamiento implícito
También llamado inherente. Es el modo en el que no se hace ninguna referencia a
memoria. Se aplica a aquellas instrucciones que se ejecutan en la CPU, sin necesidad
de intercambiar datos con memoria. Las instrucciones no tienen operando.
2.5.1.2.
Direccionamiento inmediato
En este modo, las instrucciones necesitan un dato que está contenido en la propia
instrucción, en el campo de dirección.
2.5.1.3.
Direccionamiento directo
También llamado absoluto. El dato necesario para la instrucción, está contenido en
una posición de memoria. El operando es precisamente la dirección de memoria en
donde se encuentra ese dato.
2.5.1.4.
Direccionamiento indirecto
El dato necesario para la instrucción, está contenido en una posición de memoria
denominada dirección efectiva. El operando es una dirección de memoria que actúa
como dirección intermedia. El contenido de esta posición es la dirección efectiva.
2.5.1.5.
Direccionamiento relativo
Localiza el dato en una posición de memoria que se encuentra distanciada un cierto
número de posiciones con relación al contador de programa. Esta distancia u offset, es
el número indicado por el operando y suele ir codificado en complemento a dos, dando
lugar, a una dirección positiva (adelante) o negativo (atrás). La dirección efectiva se
calcula, sumando la dirección actual al offset.
2.5.1.6.
Direccionamiento indexado
Este modo requiere que la CPU tenga un registro auxiliar, denominado índice. La
dirección efectiva, se encuentra sumando, el contenido de este registro con el operando
de la instrucción. Puede haber múltiples variantes de este modo.
Instrucciones
2.5.2.
19
Clasificación de las instrucciones
Es posible, realizar una clasificación de las instrucciones de un procesador tomando
como base, la función que realizan. Así, podemos encontrar instrucciones:
™ Aritméticas. Son aquellas instrucciones que operan con la ALU.
™ Lógicas. Realizan operaciones lógicas y modifican el registro de estado.
™ De bifurcación. Modifican la secuencia normal de ejecución de un programa.
Puesto que la secuencia de ejecución la controla el contador del programa, estas
instrucciones actúan sobre este registro. Algunas instrucciones pueden verificar
el estado de alguno de los flags del registro de estado. Si es así, las instrucciones
son de salto condicionado. Si el salto se realiza en cualquier caso se les conoce
como incondicionales.
™ Transferencia de datos. Mueven datos de un sitio a otro, sin modificar el valor
de éste, ni el registro de estado. Las instrucciones de entrada/salida, son un caso
especial de instrucciones de transferencia.
™ De bit. Tiene como función modificar un solo bit, o leer su estado. Son típicas,
aquellas que modifica alguno de las banderas del registro de estado.
™ Otras instrucciones. Existen otras instrucciones que no se pueden clasificar en
ninguna de las categorías anteriores. Algunas de ellas, controlan la operación del
microprocesador; como son las de parada del procesador, o las que no ejecutan
ninguna operación.
20
2.6.
Fundamentos sobre Microprocesadores
Temporización de las instrucciones
Cuando un código de operación llega al registro de instrucciones de la CPU, la unidad
de control desarrolla una secuencia de acciones preestablecidas, hasta completar su
ejecución. Como se ha dicho anteriormente, el controlador es un subsistema secuencial
síncrono, que va cambiando de estado, en función de una señal de reloj externa. Cada
una de las acciones elementales (microinstrucciones) necesarias, para la ejecución de
una instrucción, tarda un ciclo de reloj en completarse. El número total de
microinstrucciones, y por tanto, de ciclos de reloj, dependerá de la complejidad de la
instrucción.
La velocidad de ejecución de un microprocesador, depende fundamentalmente de la
máxima frecuencia de reloj que admite, condicionada por razones tecnológicas. Pero
juega también un papel importante, la habilidad que hayan desarrollado sus diseñadores
para acortar el número de ciclos de reloj necesarios para cada instrucción. La técnica
denominada pipelining, permite acortar tiempos, haciendo que la unidad de control
efectúe varias operaciones en paralelo, en lugar de hacerlo consecutivamente.
2.7.
Interrupciones
Las interrupciones, constituyen quizá, el mecanismo más importante para la conexión
del microprocesador al mundo exterior, sincronizando la ejecución de los programas
con los acontecimientos externos. El funcionamiento de las interrupciones, es similar al
de las subrutinas, de las cuales se diferencian del procedimiento con que se ponen en
marcha.
Del mismo modo, que las subrutinas se ejecutan cada vez que en el programa aparece
la instrucción de llamada, las interrupciones se ponen en marcha, al activarse un
terminal de entrada de la CPU, es decir, mediante un mecanismo hardware.
Capítulo 3
Introducción al diseño con dispositivos
programables (FPGAs).
3.1.
Introducción a los circuitos digitales configurables
El continuo avance de la microelectrónica a finales de los años 70, dio como resultado
la creación de circuitos de muy gran escala de integración VLSI6.
Este hecho, permitió el desarrollo de diferentes tipos de circuitos y sistemas
electrónicos digitales como fueron: las matrices lógicas programables PLA7, las
matrices lógicas Y-programables PAL8, los circuitos integrados semimedida, etc. A
pesar de estos avances, los dispositivos mencionados, no proporcionaron una solución
claramente satisfactoria a la resolución de determinados problemas prácticos; si se
utilizaban dispositivos custom las prestaciones eran elevadas pero, a un coste
prohibitivo, si se recurría a las lógicas programables, sus prestaciones eran reducidas y
en ambos casos, su capacidad de reprogramación era nula.
Según la tecnología lo fue permitiendo, surgió el interés por desarrollar circuitos
integrados cuyo comportamiento hardware pudiese ser modificado tantas vece, como
fuese necesario, del mismo modo, que se hace con un programa software.
6
VLSI: Very Large Scale of Integration
7
PLA: Programmable Logia Array
8
PAL: Programmable Array Logic
21
22
Introducción al diseño con dispositivos programables (FPGAs).
Esto dio lugar, al nacimiento de los dispositivos programables, que se caracterizaron
por disponer de un elevado número de recursos lógicos y de interconexión, definibles
por el usuario, de modo parecido a lo que se podía hacer hasta el momento con las
MPGA9, pero sin la necesidad de implementar las interconexiones mediante una
máscara metálica, sino, por medio de interruptores programables.
Estos circuitos, se clasifican habitualmente en dos tipos: los Dispositivos Lógicos
Programables (PLD10) y los Conjuntos Configurable de Puertas (FPGA11). Las FPGAs
se diferencian básicamente de los PLD en su mayor nivel de integración, debido a una
arquitectura más compleja, tanto a nivel de recursos lógicos como de interconexión.
Como el presente proyecto está fundamentado en el uso de la FPGAs, vamos a destacar
las características más relevantes de este tipo de dispositivos.
Aunque es obvio, que un dispositivo hecho a medida siempre dispondrá de mayores
prestaciones que uno configurable, el uso de las FPGAs, está recomendado para
aquellas aplicaciones, donde el número de unidades a producir no justifica el desarrollo
de un ASIC. Por otro lado, la facilidad del prototipado, permite disponer de unidades
funcionales mucho antes que con los ASICs; reduciendo de este modo los tiempos de
desarrollo. Otras de sus ventajas, es su capacidad de reconfiguración en cualquier
instante, lo que se traduce en que, dentro de una misma tarjeta una FPGA puede
desempeñar distintas funciones, dependiendo de la configuración cargada. Por ejemplo,
en el momento de arranque de una tarjeta, la FPGA puede ser programada para realizar
un chequeo de todo el circuito, para posteriormente ser reconfigurado y comportarse
como un microprocesador.
A nivel de arquitectura, todas las FPGAs se caracterizan por disponer sus recursos
lógicos en forma matricial, unidos por medio de líneas de interconexión horizontales y
verticales.
9
MPGA: Mask Programmable Gate Array
10
PLD: Programmable Logic Device
11
FPGA: Field Programmable Gate Array
Introducción a los circuitos digitales configurables
23
Figura 5: Estructura matricial de una FPGA de Xilinx
Básicamente, están formadas por un núcleo con múltiples Bloques Lógicos
Configurables (CLB12), recursos de interconexión controlados por las Matrices de
Conmutación (MC), y una periferia de bloques de entrada/salida configurables (IOB13).
Por último, debemos mencionar que las tecnologías de fabricación de las FPGAs están
en su totalidad basadas en transistores MOS, siendo posible tres técnicas a la hora de
programar el comportamiento de los interruptores programables. La más empleada en la
actualidad, es la SRAM (memoria estática de acceso aleatorio), donde cada bit define el
comportamiento de un interruptor. Su mayor ventaja es la posibilidad de su
reconfiguración, pero precisa de circuitos adicionales para almacenar la configuración
de forma permanente, dada su volatilidad.
12
CLB: Configurable Logic Block
13
IOB: Input Output Block
24
Introducción al diseño con dispositivos programables (FPGAs).
3.2.
Fases en el diseño de circuitos con FPGAs
Las etapas básicas del diseño y realización de un sistema digital mediante FPGAs, son
comunes al diseño con cualquier otro tipo de circuitos (semimedida, totalmente a
medida, etc.), aunque existen diferencias en la forma de realizarlas con cada circuito. En
primer lugar, es necesario distinguir dos fases en la realización de un sistema: el diseño
y la implementación.
El diseño consiste, en la descripción abstracta y general de un circuito, definiendo su
comportamiento, que debe ajustarse a la realización de las tareas dictadas por las
especificaciones. La implementación, es la fase en que este diseño abstracto se
materializa físicamente en los circuitos elegidos.
El diseño y realización de un circuito mediante FPGAs, puede dividirse en las
siguientes etapas:
™ Descripción del diseño. En esta fase se especifica la función del sistema digital.
™ Verificación del diseño. En esta fase se verifica el correcto funcionamiento del
diseño descrito anteriormente.
™ Compilación e implementación del diseño. En esta fase, se transforma el
diseño que se ha descrito, de forma que sea posible su implementación física en
el dispositivo físico escogido.
Aunque el orden del proceso, es básicamente el descrito en los puntos anteriores,
existen interrelaciones entre las fases, tal como se pueden observar en la figura
siguiente, dando lugar a un progresivo refinamiento del diseño mediante las sucesivas
iteraciones de estos tres pasos fundamentales.
Fases en el diseño de circuitos con FPGAs
25
Especificaciones
Lista de conexiones
DESCRIPCIÓN
DEL
Retro-anotación
DISEÑO
Lista
de
conexiones
VERIFICACIÓN
DEL
DISEÑO
Datos del
diseño
enrutado
IMPLEMENTACIÓN
DEL
DISEÑO
Figura 6: Fases del diseño de un circuito mediante FPGAs
La fase de descripción del diseño consiste en, detallar el circuito que se ha obtenido a
partir de las especificaciones iniciales. Esta descripción, puede hacerse básicamente de
dos modos:
™ Descripción estructural. Consistente en, la realización de las interconexiones
entre los diferentes elementos que componen el circuito, por medio de esquemas
realizados con herramientas CAD.
™ Descripción de comportamiento. Consistente en, expresar el funcionamiento
del circuito con la ayuda de algún Lenguaje de Descripción Hardware (HDL14)
del tipo VHDL, Verilog, etc.
Lo más habitual, es realizar la descripción del diseño mediante la combinación de
ambas formas.
Una vez realizado el diseño del sistema, y antes de proceder a la implementación del
mismo, debe realizarse una verificación de este mediante las apropiadas simulaciones
funcionales y temporales.
14
HDL: Hardware Description Language
26
Introducción al diseño con dispositivos programables (FPGAs).
El proceso de diseño concluye con la compilación de proyecto sobre el dispositivo
elegido, dando como resultado un fichero de programación de la FPGA.
Dependiendo de la herramienta CAD elegida, variará la denominación y el número de
etapas antes descritas, aunque, la filosofía del trabajo sigue siendo la misma. En la
siguiente figura, podemos ver las distintas fases de desarrollo de la herramienta
WebPACK de Xilinx.
Figura 7: Fases de desarrollo del entorno WebPACK de Xilinx
Capítulo 4
Desarrollo del microprocesador didáctico
ERIC
El punto de partida, en el diseño de cualquier procesador, es fijar las prestaciones que
queremos que realice. Estas especificaciones quedan reflejadas por una parte en el
juego de instrucciones o ISA15, y por otro lado, en las capacidades a nivel de
direccionamiento de memoria, soporte de dispositivos de E/S, manejo de interrupciones,
etc. Ambas partes están íntimamente relacionadas.
A la hora de determinar las prestaciones del procesador, se ha tenido en mente ante
todo, el valor didáctico de las mismas y por otro lado, el ajustando calendario de
tiempo disponible por parte del alumno para su implementación. Por estas razones, se a
huido intencionadamente de arquitecturas extensas a nivel de instrucciones, con
múltiples modos de direccionamiento o con ejecuciones en un ciclo de reloj, por el
contrario nos hemos conformado con una buena combinación entre complejidad y
valor pedagógico.
La combinación de dos ideas: por un lado, la implementación de un procesador con
un juego de instrucciones reducido RISC, y por otro lado, el objetivo didáctico del
mismo, dio lugar al nombre del procesador que denominamos ERIC (Educational
Reduced Instruction set Computer), y que pasamos a describir.
15
Instruction Set Architecture
27
28
Desarrollo del microprocesador didáctico ERIC
4.1.
Especificaciones generales
A continuación, se resume esquemáticamente las prestaciones de ERIC:
™ Arquitectura Von Neumann.
™ Juego de instrucciones reducido (RISC).
™ Bus de datos de 8 bits.
™ Bus de direcciones de 12 bits.
™ Bus de entrada/salida de 4 bits.
™ Memoria ROM de 4096 bytes.
™ Memoria RAM de 256 bytes.
™ Pila de 64 bits.
™ Soporte de una interrupción.
4.2.
El juego de instrucciones
El juego de instrucciones de ERIC se encuadra dentro de la filosofía RISC, esto es,
un conjunto reducido de instrucciones. Esta decisión se fundamenta únicamente en la
simplicidad a la hora de ser implementadas, lo que se traduce en una mayor sencillez a
la hora de ser decodificadas, y en un menor consumo de los recursos de la FPGA.
Otros aspectos inherentes a la filosofía RISC, como el uso intensivo de registros
internos, la facilidad para implementar instrucciones en un ciclo de reloj, reducción de
los accesos a memoria externa, etc., no han sido contemplados en este proyecto por lo
que en este sentido ERIC, no es un autentico RISC.
En cualquier caso, lo que se ha buscado es un repertorio representativo de las
instrucciones que podemos encontrar en cualquier procesador, tanto RISC, como CISC,
siendo el 8051 el modelo que ha inspirado gran parte de las instrucciones del ERIC.
El juego de instrucciones
4.2.1.
29
Modos de direccionamiento
Con el fin, de que el alumno se familiarice con los distintos modos de
direccionamiento que finalmente podrán encontrar en cualquier procesador comercial,
se ha decido incluir los siguientes modos:
™ Implícito
Instrucciones que no precisan de campo de dirección (CD).
™ Registro
Instrucciones que hacen referencia al registro en el CD.
™ Inmediato
La instrucción va acompañada del operando que precisa.
™ Directo
El CD hace referencia a una posición de memoria donde se
encuentra el operando.
™ Indirecto
El CD hace referencia a una posición de memoria o registro,
donde se encuentra la dirección, que a su vez hace referencia al
operando.
™ Relativo
Instrucciones que hacen referencia a una dirección relativa en el
CD.
4.2.2.
Clasificación de las instrucciones
Ateniéndonos a su funcionalidad, es posible clasificar las instrucciones en diferentes
grupos. A continuación, se resume todas las instrucciones disponibles con información
relevante como:
™ Hex
Valor en hexadecimal de la instrucción.
™ Nemotécnico Nombre de la instrucción.
™ Descripción
Operación que realiza.
™ C1, C2, C3
Campos en que ha sido dividida la instrucción para su posterior
tratamiento por parte de la Unidad de Control.
™ C, Z, O
Banderas afectadas en cada operación (Carry, Zero, Overflow).
™ Modo
Modo de direccionamiento.
30
Desarrollo del microprocesador didáctico ERIC
4.2.2.1.
Transferencias de datos
HEX NEMOCTÉCNICO DESCRIPCIÓN
(A) <- (addr4)
2# IN A,addr4
(addr4) <- (A)
3# OUT addr4, A
03
PUSH A
13
POP A
04
PUSH B
14
POP B
05
PUSH F
15
POP F
C0
C1
D0
D1
D2
D3
E1
E2
F#
MOV A,#dato
MOV B,#dato
MOV A,addr8
MOV B,addr8
MOV addr8,A
MOV addr8,B
MOV A,@B
MOVX A,@B
MOVX A,addr12
((SP)) <- (A)
(SP) <- (SP) + 1
(SP) <- (SP) - 1
((SP)) <- (A)
((SP)) <- (B)
(SP) <- (SP) + 1
(SP) <- (SP) - 1
((SP)) <- (B)
((SP)) <- (Flags)
(SP) <- (SP) + 1
(SP) <- (SP) - 1
((SP)) <- (Flags)
(A) <- dato
(B) <- dato
(A) <- (addr8)
(B) <- (addr8)
(addr8) <- A
(addr8) <- B
(A) <- ((B))
(A) <- ((B))
(A) <- (addr12)
C1
00
00
C2
10
11
C3 C Z O
xxxx
xxxx
BYTES
MODO
1
1
INMEDIATO
00
00
0011
1
IMPLICITO
00
01
0011
1
IMPLICITO
00
00
0100
1
IMPLICITO
00
01
0100
1
IMPLICITO
00
00
0101
1
IMPLICITO
00
01
0101
1
IMPLICITO
11
11
11
11
11
11
11
11
11
00
00
01
01
01
01
10
10
11
0000
0001
0000
0001
0010
0011
0001
0010
xxxx
2
2
2
2
2
2
1
1
2
INMEDIATO
INMEDIATO
INMEDIATO
DIRECTO
DIRECTO
DIRECTO
DIRECTO
INDIRECTO
INDIRECTO
DIRECTO
Tabla 1: Instrucciones de transferencia de datos
4.2.2.2.
HEX
40
41
42
43
54
55
Operaciones aritméticas
NEMOCTÉCNICO DESCRIPCIÓN
(A) <- (A) + (B) + (C)
ADDC A,B
(A) <- (A) - (B) - (C)
SUBC A,B
(A) <- (A) + 1
INC A
(A) <- (A) - 1
DEC A
(B) <- (B) + 1
INC B
(B) <- (B) - 1
DEC B
C1
01
01
01
01
01
01
C2
00
00
00
00
01
01
C3 C Z O
0000 x x x
0001 x x x
0010
x
0011
x
0100
x
0101
x
BYTES
MODO
1
1
1
1
1
1
REGISTRO
REGISTRO
REGISTRO
REGISTRO
REGISTRO
REGISTRO
Tabla 2: Instrucciones aritméticas
4.2.2.3.
HEX
7D
7E
7F
01
02
Operaciones con banderas
NEMOCTÉCNICO DESCRIPCIÓN
(C) <- 0
CLR C
(C) <- 1
SET C
(C) <- /(C)
CPL C
(IEN) <- 1
ION
(IEN) <- 0
IOF
C1
01
01
01
00
00
C2
11
11
11
00
00
C3
1101
1110
1111
0001
0010
C Z O
0
1
x
Tabla 3: Instrucciones de manipulación de banderas
BYTES
MODO
1
1
1
1
1
REGISTRO
REGISTRO
REGISTRO
IMPLICITO
IMPLICITO
El juego de instrucciones
4.2.2.4.
HEX
46
47
48
49
4A
31
Operaciones lógicas
NEMOCTÉCNICO DESCRIPCIÓN
(A) <- (A) * (B)
AND A,B
(A) <- (A) v (B)
OR A,B
(A) <- (A) A (B)
XOR A,B
(A) <- 0
CLR A
(A) <- /(A)
CPL A
4B
RLC A
4C
RRC A
(An + 1) <- (An)
(A0) <- (C)
(C) <- (A7)
(An) <- (An + 1)
(A7) <- (C)
(C) <- (A0)
C1
01
01
01
01
01
C2
00
00
00
00
00
C3 C Z O
0110
x
0111
x
1000
x
1001
1
1010
x
BYTES
MODO
1
1
1
1
1
REGISTRO
01
00
1011 x
1
REGISTRO
01
00
1100 x
1
REGISTRO
BYTES
MODO
REGISTRO
REGISTRO
REGISTRO
REGISTRO
Tabla 4: Instrucciones lógicas
4.2.2.5.
Flujo de programa
HEX NEMOCTÉCNICO DESCRIPCIÓN
80
JZ rel
81
JNZ rel
82
JC rel
83
JNC rel
84
JO rel
85
JNO rel
88
SJMP rel
90
RET
91
RETI
A#
ACALL addr12
B#
00
0F
AJMP addr12
NOP
HALT
(PC) <- (PC) + 2
si (A) = 0
entonces (PC) + rel
(PC) <- (PC) + 2
si (A) != 0
entonces (PC) + rel
(PC) <- (PC) + 2
si (C) = 1
entonces (PC) + rel
(PC) <- (PC) + 2
si (C) = 0
entonces (PC) + rel
(PC) <- (PC) + 2
si (OV) = 0
entonces (PC) + rel
(PC) <- (PC) + 2
si (OV) != 0
entonces (PC) + rel
(PC) <- (PC) + rel
(SP) <- (SP)-1
(PCl) <- ((SP))
(SP) <- (SP)-1
(PCh) <- ((SP))
(SP) <- (SP)-1
(PCl) <- ((SP))
(SP) <- (SP)-1
(PCh) <- ((SP))
ION <- 1
((SP)) <- (PCh)
(SP) <- (SP) + 1
((SP)) <- (PCl)
(SP) <- (SP) + 1
(PC) <- addr12
(PC) <- addr12
(PC) <- (PC) + 1
(PC) <- (PC)
C1
C2
C3
C Z O
10
00
0000
2
RELATIVO
10
00
0001
2
RELATIVO
10
00
0010
2
RELATIVO
10
00
0011
2
RELATIVO
10
00
0100
2
RELATIVO
10
00
0101
2
RELATIVO
10
00
1000
2
RELATIVO
10
01
0000
1
IMPLICITO
10
01
0001
1
IMPLICITO
10
10
xxxx
2
DIRECTO
10
00
00
11
00
00
xxxx
0000
1111
2
1
1
DIRECTO
IMPLICITO
IMPLICITO
Tabla 5: Instrucciones de control de flujo de programa
Aunque la funcionalidad de mayoría de las instrucciones son evidentes, es posible
disponer de una información más detallada en el Apéndice: Juego de Instrucciones del
ERIC.
32
4.2.3.
Desarrollo del microprocesador didáctico ERIC
Formato de las instrucciones
Cada instrucción codificada en binario, contiene un número de campos que ofrecen la
información pertinente que necesita la Unidad de Control, para ejecutar la instrucción
en la CPU. Normalmente, el número de campos, la anchura en bits y el nombre que
recibe cada uno, suele variar de instrucción a instrucción.
En el caso de ERIC, y buscando la máxima simplicidad, se ha estructurado cada
instrucción en un número de campos fijos y de ancho fijo que se han denominado C1,
C2 y C3. Por otro lado, es posible encontrar instrucciones de 1 ó 2 bytes. La siguiente
figura resume la estructura del primer byte:
C2
7
6
C1
5
4
3
2
1
0
C3
Figura 8: Estructura de campos del primer byte de una instrucción
El significado de cada uno de los campos es variable, dependiendo en cada momento
del contexto de la instrucción que estemos interpretando. Esto es debido, a lo limitado
del número de bits disponibles para codificar, no siendo posible establecer significados
de carácter general y por lo tanto, es necesario ir cambiando el significado de cada
campo según el caso.
Veamos en cualquier caso, ciertas ideas de carácter general que se han aplicado a la
hora de establecer los códigos al juego de instrucciones.
El juego de instrucciones
33
El campo C1 (2 bits) es utilizado para realizar una primera división de las
instrucciones en grupos funcionales:
™ 11 (MOV)
Instrucciones de transferencias de datos con memoria.
™ 10 (JMP)
Instrucciones de control del flujo del programa, es decir, todas
aquellas que tenga que ver con saltos, llamadas a subrutinas, etc.
™ 01 (ALU)
Instrucciones que en su ejecución utilizan la ALU. En este grupo
se
incluyen
las
instrucciones
lógicas,
aritméticas
y
de
manipulación de banderas vistas con anterioridad.
™ 00 (MIX)
Instrucciones de transferencias de datos con el exterior, con la pila
y algunas otras, que no pueden catalogarse en alguno de los grupos
anteriores.
Al lado de cada valor posible del C1, se ha añadido un nemotécnico que define el
sentido de cada grupo de instrucciones (MOV para las de transferencia, JMP para las
de salto, ALU para las que tiene relación con la ALU y MIX al grupo de las
misceláneas). Vemos por lo tanto que C1, se comporta como una parte del código de
operación.
El campo C2 (2 bits) es el campo de significado más variable. En algunos casos se
comporta como campo de destino, otras como indicador de modo de dirección, otras
como ampliación del código de operación.
El campo C3 (4 bits), normalmente indica un código de operación, o bien, alguna
parte de una dirección en los modos directo, o la totalidad, en el modo inmediato.
Veamos a continuación el significado de cada uno de los campos, según la instrucción
o grupo de instrucciones:
34
Desarrollo del microprocesador didáctico ERIC
BYTE 1
C1
C2
11 Tipo MOV
00
01
10
11
10
01
00
BYTE 2
C3
Modo Inmediato
Modo Directo
Modo Indirecto (Reg B)
Ext. Cod. Operación
xxxx
xxxx
xxxx
xxxx
Cod. Operación
Cod. Operación
Cod. Operación
addr12(11:8)
#dato
addr8(7:0)
addr12(7:0)
Tipo JMP
00 Modo Relativo
01 Modo Implícito
10 Ext. Cod. Operación
xxxx Cod. Operación
xxxx Cod. Operación
xxxx addr12(11:8)
rel
00 Registro Destino A
01 Registro Destino B
1X No hay registro destino.
xxxx Cod. Operación
xxxx Cod. Operación
xxxx Cod. Operación
-
0X Ext. Cod. Operación
10 Ext. Cod. Operación
11 Ext. Cod. Operación
xxxx Cod. Operación
xxxx addr4(3:0)
xxxx addr4(3:0)
-
addr12(7:0)
Tipo ALU
Tipo MIX
Tabla 6: Formato de los campos según el tipo de instrucción
De la tabla anterior, solo comentar el significado y la manera de codificar algunas de
las informaciones.
™ addr4
Dirección de 4 bits. Va codificada en los bits de menor peso de la
instrucción.
™ addr8
Dirección de 8 bits. Va codificadas en el segundo byte.
™ addr12
Dirección de 12 bits. Los bits más significativos de addr12 van
codificados en los bits de menor peso de la instrucción. El resto va
en el segundo byte.
™ rel
Dirección relativa. Va codificada en el segundo byte.
™ #dato
Va codificado en el segundo byte.
ION
7
8
JNZ rel
JC rel
JNC rel
0110
SJMP rel
F
E
D
C
0000
0001
MOV
B, #dato
MOV
B, addr8
MOVX
A,@B
MOV
addr8,A
MOV
addr8,B
0010
0011
0100
0101
Tabla 7: Mapa de distribución de las instrucciones del ERIC
0111
1000
MOVX A, addr12
AJMP addr12
MOV
A, #dato
MOV
A, addr8
MOV
A,@B
B
RETI
ACALL addr12
RET
9
JNO rel
A
JZ rel
8
JO rel
XOR A,B
1001
CLR A
1010
CPL A
A
1011
RLC A
B
1100
RRC A
C
CLR C
D
SET C
E
CPL C
HALT
F
0101
0100
0011
0010
0001
0000
1101
1110
1111
1111
1110
1101
1100
1011
1010
1001
1000
0111
OR A,B
9
7
DEC B
AND A,B
6
0110
INC B
POP F
PUSH F
5
6
5
4
DEC A
POP B
PUSH B
4
OUT addr4, A
POP A
PUSH A
3
3
INC A
IOF
2
IN A, addr4
ADDC A,B SUBC A,B
NOP
1
2
1
0
0
El juego de instrucciones
35
36
4.3.
Desarrollo del microprocesador didáctico ERIC
Implementación física de Eric
Para la realización práctica del diseño, se seleccionó inicialmente la tarjeta de
desarrollo de Xess XSA-50. Dicha tarjeta posee como corazón una FPGA del tipo
Spartan-II XC2S50 de 50.000 puertas. Además, dispone de otra serie de dispositivos
como una memoria DRAM de 8 Mbytes, una memoria FLASH de 128 Kbytes, un
CPLD, etc. Para más información sobre las características de la tarjeta consultar el
apéndice: La tarjeta de desarrollo XSA-50.
El entorno de desarrollo utilizado ha sido el WebPack 5.1, de la casa Xilinx. El
WebPack viene acompañado de una versión de evaluación del simulador ModelSim de
la casa Mentor Graphics, que también ha sido utilizado. Para más información sobre el
ISE WebPack consultar el apéndice: El entorno de desarrollo ISE WebPACK.
El diseño del procesador se ha realizado casi totalmente en VHDL16, por entender que
los lenguajes HDL, aceleran los tiempos de desarrollo, aunque sea a costa de perder
algo de objetividad sobre lo que realmente se sintetiza. Por otra parte, el lenguaje
VHDL es de estudio obligatorio dentro de la titulación de Ingeniero de
Telecomunicación, por lo que esta decisión no debería acarrear ningún problema.
Además, el uso del VHDL como lenguaje de síntesis, pone de relieve ciertas
limitaciones del lenguaje que no se manifiestan hasta que se acomete un trabajo real,
por lo que, es posible aprovechar este trabajo para profundizar en el estudio del
lenguaje.
Aunque es posible una descripción completa del procesador en VHDL, se han
incluido numerosos esquemáticos, con el fin de favorecer la comprensión de la
interacción de los distintos componentes que conforman el procesador. También se ha
recurrido a los esquemáticos a la hora de implementar las memorias por su inmediatez,
a partir de las primitivas.
16
VHSIC Hardware Description Language
Implementación física de Eric
Figura 9: Tarjeta XSA-50 de la casa XESS utilizada en este proyecto
Figura 10: Tarjeta D2XL de la casa DIGILENT también probada en este proyecto
37
38
Desarrollo del microprocesador didáctico ERIC
4.4.
Estructura del microprocesador
Cuando se decidió acometer la idea de desarrollar este proyecto, se tenía en mente el
implementar un microprocesador utilizando como memorias del mismo, alguna de las
disponibles en la tarjeta XSA-50. Tras analizar las particularidades de cada una de ellas,
se decidió descartar esta idea por la dificultad que entrañaba. Por un lado, la memoria
DRAM necesita que se implemente un controlador de memoria dinámica en la propia
FPGA y por otro lado, la memoria FLASH comparte gran parte de sus terminales de
acceso con el puerto paralelo, complicando enormemente su gestión.
Dado que las FPGAs de tipo Spartan-II poseen bloques específicos de memoria
(BRAM), se optó por explotar este recurso e incorporar la memoria RAM y ROM al
propio diseño del procesador. Con esta decisión, se ha conseguido por una parte
simplificar el diseño y por otra parte, no depender de las posibilidades hardware de la
tarjeta de desarrollo, por lo que se facilita la movilidad del diseño a tarjetas equipadas
únicamente con la FPGA pertinente. En este sentido, durante la ejecución de este
proyecto surgió la posibilidad de probar el proyecto en una tarjeta de la casa Digilent,
demostrando lo acertado de la decisión al funcionar sin problemas.
El diseño del microprocesador se ha realizado de manera modular, siguiendo la
metodología top-down. En la siguiente página, podemos observar la estructura en
bloques del nivel más alto del diseño, es decir el top.
Como se puede observar en la figura, ERIC está formado por cuatro bloques
claramente diferenciados:
™ La memoria RAM.
™ La memoria ROM.
™ El corazón del procesador.
™ Un conversor binario a 7 segmentos.
que pasamos a desarrollar a continuación.
Estructura del microprocesador
Figura 11: Diagrama principal de bloques del ERIC (TOP.SCH)
39
40
4.4.1.
Desarrollo del microprocesador didáctico ERIC
Organización de la memoria
Dependiendo del modelo de FPGA Spartan-II utilizada, es posible disponer de un
número variables de bloques BRAM, tal como se muestra en la siguiente tabla:
Tabla 8: Bloques BRAM disponibles según el modelo de FPGA
Comentar que, cada bloque tiene una capacidad de 4096-bits y que es posible
configurarlo de múltiples maneras, variando el tamaño de la memoria y la anchura del
bus de datos. Independientemente de la configuración elegida, siempre se consume la
totalidad del bloque, siendo posible agrupar bloques para formar memorias con mayores
capacidades. La memoria puede ser de simple o doble puerto y siempre es síncrona.
Para más información sobre las prestaciones de las FPGAs Spartan-II consultar el
apéndice: FPGAs de la familia SPARTAN II DE XILINX
Tabla 9: Configuraciones posibles de un bloque BRAM de una Spartan-II
Según
esto,
veamos
cuantos
bloques
especificaciones de memoria del ERIC.
necesitamos
para
implementar
las
Estructura del microprocesador
™ ROM
41
Con un tamaño igual a 4096 bytes, necesitamos por lo tanto 8
bloques.
™ RAM
Aunque de tamaño igual a 256 bytes, consumiremos igualmente un
bloque de 4096 bits.
™ STACK
Con un tamaño igual a 64 bytes necesitamos un bloque.
Resumiendo, necesitamos 10 bloques para disponer de las especificaciones máximas,
o lo que es lo mismo, una Spartan-II XC2S100 (100.000 puertas). Dado que la tarjeta
XSA-50 está equipada con una XC2S50 de 8 bloques, no es posible implementar la
totalidad del esquema de memoria.
Para poder seguir trabajando con la XSA-50, y con otras tarjetas de menor capacidad
(Digilent D2XL) se optó por reducir la ROM a la mitad de sus especificaciones
iniciales, es decir 2048 bytes. Con esta nueva configuración sólo son necesarios 6
bloques, siendo suficiente una XC2S30. De este modo, la organización de la memoria
según el tipo de FPGA utilizada, queda tal como se muestra en la siguiente figura:
Memoria de
Memoria de
Programa (ROM)
Datos (RAM)
0xFF
0xFFF
FPGA
XC2S100
0x00
0x7FF
Memoria de
FPGA
XC2S30
Stack
0x3F
0x002
0x000
RESET
Salto a la rutina de
INTERRUPCIÓN
0x00
Figura 12: Esquema de la memoria del ERIC según el modelo de FPGA
42
Desarrollo del microprocesador didáctico ERIC
Aunque hasta ahora hemos estado hablando de ROM y de RAM, es obvio que el
único tipo de memoria que se puede realizar es de tipo RAM. Aun así, vamos a seguir
utilizando esta denominación, como sinónimo de memoria de programa (no
modificable) y de memoria de datos (modificable).
A nivel de diseño, todos los módulos de memoria han sido realizados por medio de
esquemáticos a partir de la primitiva RAMB4_S8 (512x8 bits). Esta memoria es de
simple puerto y síncrona, lo que implica ciertas diferencias a tener en cuenta respecto a
las memorias asíncronas, tradicionalmente usadas con microprocesadores. La primera
diferencia radica, en el desglose del bus de datos en dos: uno para la entrada y otro para
la salida. La otra diferencia, es el momento a partir del cual podemos disponer de los
datos, puesto que una vez aplicada una dirección deberemos esperar al siguiente flanco
de subida del reloj, para disponer de los datos.
Figura 13: Primitiva RAMB4_S8 utilizada como base de los módulos de memoria
Los esquemas ROM.SCH, RAM.SCH y STACK.SCH reflejan la manera en que han
sido implementadas las distintas unidades de memoria. Hay que destacar, que el diseño
de la ROM es fácilmente ampliable puesto que el decodificador utilizado ya contempla
la totalidad de lo bloque posibles, aunque en este caso solo direccione la mitad. A todas
las memorias, se han añadido bufferes triestado a sus salidas para posibilitar su
conexión al mismo bus de datos.
Estructura del microprocesador
4.4.2.
43
El corazón del procesador
Comúnmente, a la descripción de procesadores en HDL para su implementación en
FPGA se les denomina CORES. El bloque que vamos a describir, el más extenso por
otra parte, representa el corazón de ERIC de ahí su nombre (CPU_CORE.SCH).
Veamos las distintas partes que lo componen:
™ El acumulador y el registro auxiliar B.
™ El registro de instrucciones (IR).
™ El registro de estado.
™ El contador de programa (PC).
™ El registro de direccionamiento de memoria (MAR).
™ La Unidad Aritmético Lógica (ALU).
™ La Unidad de Control (UC).
™ La pila o STACK.
™ El contador de la pila (SC)
™ El bloque SNIFFER.
™ Multiplexores varios.
A grandes rasgos, podemos comprobar que están todos los bloques típicos de un
microprocesador comercial, con la salvedad del bloque SNIFFER. Este bloque, que se
muestra en el esquema siguiente de forma distinta a los demás, no es como tal, una parte
del procesador, sino un bloque añadido que posibilita la salida y entrada de datos de
ERIC con el mundo exterior.
Por otra parte, también podemos comprobar que hay 3 buses de carácter general por
los que circula la información entre los distintos módulos del procesador. Lo habitual es
encontrar un bus de direcciones y otro de datos. Aquí se ha desglosado el bus de datos
en dos: uno de entrada DIN(7:0) para los datos procedentes de la memoria hacia el
procesador, y otro de salida DOUT(7:0), para los datos de salida del procesador hacia la
memoria. La justificación de este desglose, es que las memorias síncronas utilizadas
poseen el bus de de entrada y de salida de datos, de forma independiente.
44
Desarrollo del microprocesador didáctico ERIC
Figura 14: Esquema de bloques del corazón del procesador (CPU_CORE.SCH)
Estructura del microprocesador
4.4.2.1.
45
El acumulador y el registro auxiliar B
La finalidad del acumulador y del registro auxiliar B, es la de servir de buffer
temporal de datos. Estos datos pueden proceder de distintas fuentes: las memorias, de la
ALU o del exterior.
A nivel de diseño hardware, ambos registros han sido descritos en VHDL como un
LATCH de 8 bits por flanco de subida, con entradas de LOAD y RESET asíncronas.
Figura 15: El acumulador
Cuando RST esta activa17 se pone a 0 todo el registro. El circuito, almacenará el dato
presente en la entrada durante el flanco de subida de la señal de reloj, siempre que la
señal LOAD, esté activa.
4.4.2.2.
El registro de instrucción (IR)
La finalidad del registro de instrucción, es la de servir de buffer temporal de una
instrucción procedente de la memoria de programas. A nivel hardware, es un registro
idéntico al acumulador.
4.4.2.3.
El registro de estado (STATUS)
La finalidad del registro de estado, es la de almacenar las banderas (C, Z y OV)
procedentes de la ALU. A nivel hardware, es un registro idéntico al acumulador con la
particularidad de ser de 4 bits.
17
Las señales se consideran activas a nivel alto salvo que se indique lo contrario.
46
4.4.2.4.
Desarrollo del microprocesador didáctico ERIC
El contador de programa (PC)
La finalidad del contador de programa, es la de apuntar a la dirección de memoria
desde donde se va a extraer la próxima instrucción. Aunque las direcciones son
normalmente consecutivas, es posible que existan saltos en esta secuencia. Dichos
saltos, pueden ser absolutos o relativos al valor que posea en ese momento el contador.
Figura 16: El contador de programa
La base para construir este módulo es un contador de 12 bits, es decir, de igual
anchura que el bus de direcciones. El contenido del contador aparece en
ADDR_OUT(11:0). La cuenta, se realiza en el flanco de subida de la señal de reloj
siempre que E_PCUP y UP estén activas.
El motivo por el cual existen dos señales de habilitación, tiene su origen en la forma
en como se accede a la memoria ROM. Al ser ésta síncrona, se precisa de al menos18,
un ciclo de reloj de espera para disponer del dato direccionado. Este hecho, imposibilita
el acceder e incrementar el PC en una misma microinstrucción, ya que su duración es
superior a un ciclo de reloj y el resultado de la cuenta sería errónea.
Para solucionar este problema, se ha dispuesto de dos señales de habilitación: una de
UP que utiliza la UC cuando desea incrementar en una unidad el valor del PC, y otra
E_PCUP que es controlada por el contador de tiempos de espera, activándose
18
Idealmente un ciclo de espera es suficiente, aunque retardos debido al enrutado puede aconsejar
incrementar este valor.
Estructura del microprocesador
47
únicamente en el último ciclo de espera. De este modo, el PC sólo contará una unidad
independientemente de lo que dure el tiempo de acceso a la ROM.
Cuando se produce un salto en la secuencia, es necesario cambiar el contenido del
contador. Cuando se trata de un salto absoluto, la señal LD (LOAD) cambia el valor de
cuenta por el presente en ADDR_IN(11:0). Si el salto es relativo, se deberá activar la
señal REL; esto ocasiona que se realice la suma, en complemento a dos, entre los bits
ADDR_IN(7:0) y el valor actual del contador. Todas estas operaciones se realizan de
manera síncrona.
El contador posee adicionalmente dos señales de RESET asíncronas. RST0 pone el
contador a 0x000 y se activa por parte de la UC en el momento de atención a una
interrupción. RST2 pone el contador a 0x002 y se activa con la señal de RESET global
del procesador.
4.4.2.5.
El registro de direccionamiento de memoria (MAR)
La finalidad del registro MAR, es la de servir de apoyo al PC en los momentos en que
se necesita acceder temporalmente una posición de memoria, que difiere de la
disponible en el PC. Este hecho está normalmente asociado, al uso de instrucciones de
transferencia. Adicionalmente a esta función, MAR también es utilizado como buffer
temporal vinculado al PC.
Figura 17: El registro de direccionamiento de memoria
Cuando se ejecuta una instrucción de transferencia es posible encontrarnos con varios
tipos de direcciones: addr4, add8 y addr12.
48
Desarrollo del microprocesador didáctico ERIC
Para comprender bien la relación de MAR, con el resto de los bloques, es importante
recordar como vienen codificadas las direcciones antes comentadas: addr4 se debe
extraer de IR, addr8 de un segundo byte y addr12 de IR y del segundo byte. Por este
motivo, es necesario desglosar el bus de direcciones de entrada en 2 bloques y disponer
de 3 señales de carga.
Figura 18: Relación de MAR con otros bloques del circuito
De este modo si se desea cargar una dirección:
™ addr4
Se activará LD4 y se cargarán los datos presentes en
ADDR_H(3:0).
™ addr8
Se activará LD8 y se cargarán los datos presentes en
ADDR_L(7:0).
™ addr12
Se activará LD12 y se cargarán los datos presentes en
ADDR_H(3:0) y en ADDR_L(7:0)
Estructura del microprocesador
49
La carga de estos datos se realiza de manera síncrona. El dispositivo dispone de una
señal de RST asíncrona que al ser activada pone el registro a 0.
En las instrucciones de salto, MAR también es utilizado para almacenar
temporalmente la dirección de salto, que posteriormente se cargará en el PC.
4.4.2.6.
Multiplexores y bufferes triestado
Para poder controlar el camino que va a seguir los datos en el interior de la CPU, es
necesario el uso de multiplexores y bufferes triestado. En este diseño se han incluido los
siguientes bloques:
™ BUFT4:
Buffer triestado. La entrada es una señal de 4 bits y la salida una
de 8 bits. Cuando está activo, los 4 bits de mayor peso son 0 y los
de menor peso proceden de la señal de entrada.
™ MUX2_4:
Multiplexor de 2 entradas de 4 bits.
™ MUX2_8:
Multiplexor de 2 entradas de 8 bits.
™ MUX2_8Z:
Multiplexor de 2 entradas de 8 bits con salida triestado.
™ MUX2_12:
Multiplexor de 2 entradas de 12 bits.
™ MUX2P_8Z: Multiplexor de 2 entradas, una de 8 bits y otra de 4 bits con salida
de 8 bits triestado. En un caso selecciona la señal de 8 bits y en el
otro, la señal de 4 bits completándola con 0 en la parte alta.
Figura 19: Multiplexor tipo MUX2_8Z
50
4.4.2.7.
Desarrollo del microprocesador didáctico ERIC
La Unidad Aritmético Lógica (ALU)
La finalidad de la ALU es realizar operaciones de tipo lógico o aritmético. Se trata de
un circuito combinacional, que realiza una operación utilizando las entradas A(7:0) y
B(7:0) obteniéndose el resultado en C(7:0). La operación a realizar se selecciona por
medio de las señales de control CTRL(3:0).
Algunas operaciones, modifican alguno de las banderas (Carry, Zero y Overflow). En
estos casos, el resultado se presenta en FLAGS_OUT(3:0) para su posterior escritura en
el registro de estado. Por otra parte, hay operaciones que precisan conocer el registro de
estado para ser evaluadas. La entrada de esta información se realiza vía FLAGS_IN(3:0)
Figura 20: Unidad Aritmético Lógica
Con 4 bits de control es posible realizar 16 operaciones. El código elegido para
realizar cada una de las operaciones, está íntimamente relacionado con el código de
operación de las instrucciones aritméticos/lógicas.
Si analizamos el juego de las instrucciones del grupo lógico, aritmético y de
flags correspondientes al tipo ALU, tal como ya comentamos al hablar de los formatos
de las instrucciones, veremos que el campo C3 coincide con el código de control de la
ALU. De este modo, al decodificar la instrucción por parte de la Unidad de Control,
simplemente hay que asignar el contenido del C3 directamente a las líneas de control de
la ALU.
Estructura del microprocesador
51
Veamos que operaciones realiza la ALU.
COD. CTRL
0000
0001
0010
0011
0100
0101
0110
0111
1000
1001
1010
1011
NEMOTÉCNICO
ALU_OPC_ADDC
ALU_OPC_SUBC
ALU_OPC_INC_A
ALU_OPC_DEC_A
ALU_OPC_INC_B
ALU_OPC_DEC_B
ALU_OPC_AND
ALU_OPC_OR
ALU_OPC_XOR
ALU_OPC_CLR_A
ALU_OPC_CPL_A
OPERACIÓN
CARRY ZERO OVERFLOW
C= A+B+CARRY_IN
X
X
X
C= A-B-CARRY_IN
X
X
X
C= A+1
X
C= A-1
X
C= B+1
X
C= B-1
X
C= A AND B
X
C= A OR B
X
C= A XOR B
X
C= 0
1
C= NOT (A)
X
C(0)=CARRY_IN
ALU_OPC_RLC_A
X
C(7:1)= A(6:0)
1100
ALU_OPC_RRC_A
1101
1110
1111
ALU_OPC_CLR_C
ALU_OPC_SET_C
ALU_OPC_CPL_C
C(7)=CARRY_IN
C(6:0)= A(7:1)
-
X
-
-
0
1
NOT C
-
-
Tabla 10: Tabla de operaciones de la ALU
™ ALU_OPC_ADDC: Suma el contenido del registro A y B junto con el acarreo
disponible en el registro de estado (CARRY_IN).
™ ALU_OPC_SUBC:
Resta el contenido del registro B junto con el acarreo
disponible en el registro de estado (CARRY_IN), del
registro A.
™ ALU_OPC_INC_A: Incrementa el valor de A.
™ ALU_OPC_DEC_A: Decrementa el valor de A.
™ ALU_OPC_INC_B: Incrementa el valor de B.
™ ALU_OPC_DEC_B: Decrementa el valor de B.
™ ALU_OPC_AND:
Realiza la operación lógica AND entre A y B.
™ ALU_OPC_OR:
Realiza la operación lógica OR entre A y B.
™ ALU_OPC_XOR:
Realiza la operación lógica XOR entre A y B.
™ ALU_OPC_CLR_A: Pone el acumulador a 0.
™ ALU_OPC_CPL_A: Invierte el contenido del acumulador.
™ ALU_OPC_RLC_A: Desplaza el contenido del acumulador hacia la izquierda.
52
Desarrollo del microprocesador didáctico ERIC
C
7
0
™ ALU_OPC_RRC_A: Desplaza el contenido del acumulador hacia la derecha.
C
7
0
™ ALU_OPC_CLR_C: Pone la bandera de acarreo a 0.
™ ALU_OPC_SET_C: Pone la bandera de acarreo a 1.
™ ALU_OPC_CPL_C: Invierte el valor de la bandera de acarreo.
Tal como vemos en la Tabla 10, algunas operaciones modifican el estado de las
banderas. Las banderas existentes son:
™ CARRY:
Se pone a 1 si el resultado de la operación genera un
acarreo. En el caso de la suma y de la resta, podemos
considerar el acarreo como un 9 bit del resultado.
™ ZERO:
Se pone a 1 si el resultado de la operación es igual a 0.
™ OVERFLOW:
Se pone a 1 si el resultado de la operación genera un
rebosamiento. El rebosamiento es útil cuando se realiza
operaciones de suma o resta con signo. Se activa, cuando
sumando dos números de un signo el resultado es del
signo contrario. Algo similar ocurre en la resta cuando
debiendo esperar un resultado de un signo, se obtiene el
contrario.
Estructura del microprocesador
4.4.2.8.
53
La Unidad de Control (UC)
La finalidad de la Unidad de Control (UC) es generar las señales de control adecuadas
que permitan coordinar las distintas partes de la CPU. El objetivo de estas señales es la
ejecución de microoperaciones de procesado de la información, resultado de la
interpretación de la instrucción.
El núcleo de la UC es una máquina de estados de tipo Mealy. Como toda máquina de
estados, dispone de una parte secuencial y una parte combinacional tal como se puede
observar en la siguiente figura:
Próximo Estado
I
(NS)
N
(Combinacional)
P
NS
Estado Actual
(CS)
RESET
(Secuencial)
CS
U
T
S
Salidas Lógicas
(Combinacional)
O U T P U T S
Figura 21: Diagrama de una máquina de estados tipo Mealy
La máquina arranca de un estado inicial marcado por la activación de la señal
asíncrona reset. A partir de ahí, y coincidiendo con el flanco de bajada del reloj, la
máquina irá pasando de un estado a otro, en función de los valores que vaya tomando la
variable próximo estado (NS). El valor de dicha variable, procedente de la parte
combinacional, es una función de las entradas externas y del valor de estado actual
(CS)19.
19
NS (Next State) y CS (Current State)
54
Desarrollo del microprocesador didáctico ERIC
Figura 22: La Unidad de Control del ERIC
Estructura del microprocesador
4.4.2.8.1.
55
Descripción de las señales
Veamos el significado de cada una de las señales de entrada, que van a condicionar la
evolución del a máquina de estados:
™ CLK:
Reloj.
™ RST:
Reset asíncrono.
™ IR(3:0):
Bus procedente del registro de instrucción.
™ FLAGS(3:0):
Bus procedente del registro de estado.
™ MODE(1:0):
Indicador del modo de funcionamiento. Los tres modos
posibles son: ejecutar el programa en modo continuo, paso
a paso o bien, proceder a la carga de un programa en la
ROM.
™ RISE_STROBE: Procedente del detector del flanco de subida de la señal
STROBE. Esta señal permite la sincronización en el modo
paso a paso (STEP) con el mundo exterior. La activación de
la misma, indica a la UC que debe ejecutar otra instrucción.
™ WAIT_STATE:
Indica a la máquina de estados, que debe esperar por algún
dispositivo que todavía no ha terminado su trabajo. Estos
dispositivos son los de entrada/salida y las memorias. La
espera se realiza introduciendo ciclos de espera, repitiendo
el estado actual.
™ IER:
Señal
procedente
del
registro
de
control
de
las
interrupciones. Su activación le indica a la UC que hay una
solicitud de interrupción.
Veamos ahora el significado de las señales de salida manejadas por la UC:
™ IO:
Selección de un dispositivo de entrada/salida.
™ RAM_CE:
Selección de la RAM.
™ ROM_CE:
Selección de la ROM.
™ STACK_CE:
Selección del STACK.
56
Desarrollo del microprocesador didáctico ERIC
™ WE:
Escritura/lectura.
™ PC_RST:
Reset del contador de programa (PC).
™ PC_UP:
Incrementar PC en una unidad.
™ PC_LD:
Cargar dato en el PC.
™ PC_REL:
Sumar la dirección relativa presente en su entrada, con el
valor actual del contador.
™ E_PCUP:
Habilita la señal PC_UP para que pueda contar.
™ A_LD:
Cargar dato en el registro A.
™ B_LD:
Cargar dato en el registro B.
™ F_LD:
Cargar dato en el registro de FLAGS.
™ IR_LD:
Cargar dato en el registro IR.
™ MAR_LD4:
Cargar dato en el registro MAR en el modo addr4.
™ MAR_LD8:
Cargar dato en el registro MAR en el modo addr8.
™ MAR_LD12:
Cargar dato en el registro MAR en el modo addr12.
™ SC_UP:
Incrementar el contador del STACK (SC).
™ SC_DOWN:
Decrementar el SC.
™ HALT:
Indica que el procesador está parado o a ejecutado la
instrucción HALT. En cualquier caso, el procesador se
encuentra detenido.
™ SNIF_RST:
Reiniciar el bloque SNIFFER.
™ ENABLE_IER:
Habilita interrupciones.
™ DISABLE_IER:
Deshabilita interrupciones.
™ STATE(3:0):
Muestra el estado en que se encuentra la UC.
™ ALU_CTRL(3:0): Señal de control de la ALU.
™ S_MUXn:
Selección de la señal del multiplexor MUXn
™ E_MUXn:
Habilita la salida del multiplexor MUXn en el caso de los
multiplexores triestado.
™ E_BUFn:
Habilita la salida del buffer BUFn.
Estructura del microprocesador
4.4.2.8.2.
57
El diagrama de estados
Toda máquina de estados, lleva asociado un diagrama de estados que indica como se
va a comportar dependiendo de las señales de entrada. Este diagrama ha de contemplar
por un lado la ejecución de las distintas instrucciones y por otro lado, las mejoras que se
han introducido al diseño como son, la ejecución paso a paso, continuo y carga de la
memoria ROM.
Como ya veremos en otro apartado de esta memoria, la ejecución de una instrucción
está estructurada en una serie de fases básicas que podemos resumir:
™ FETCH:
Fase de búsqueda de la instrucción. La UC genera las
señales de control que va a permitir cargar una instrucción
procedente de la ROM, en el registro de instrucción.
™ DECODE:
Fase de decodificación y lectura de operandos.
™ EXECUTE:
Fase de ejecución. Con los datos de IR y la lectura de
operandos adicionales se procede a la ejecución de la
instrucción, mediante la generación de las señales de
control pertinentes.
Aunque en la mayoría de los casos, estos tres estados son suficientes, algunas
instrucciones por su complejidad precisan de un mayor número de estados. En concreto
aquellas instrucciones relacionadas con direccionamientos indexados (MOV/X A,@B),
o con tratamiento de subrutinas pertenecen a este tipo (CALL, RET y RETI). Para dar
soporte a estas instrucciones, se ha ampliado el grafo con los siguientes estados:
™ STORE:
Utilizado por las instrucciones con direccionamiento
indexado.
™ SUBR1 … 3:
Utilizado por la instrucciones con llamadas y retorno de
subrutinas.
58
Desarrollo del microprocesador didáctico ERIC
Al margen de la ejecución de las instrucciones, la máquina de estado debe dar soporte
a las interrupciones, a los distintos modos de ejecución y a la carga de programas. Ello
implica un mayor número de estados:
™ RESET:
Estado inicial de arranque al partir del cual se bifurca en
función del valor de la señal MODE(1:0). Esta señal va a
condicionar o bien, los modos de ejecución o bien pasar a
modo de carga de programa en ROM.
™ ERROR:
Estado que alcanzará la máquina de estados en el caso de
tener que interpretar una instrucción no soportada.
™ STOP:
Estado que alcanzará la máquina de estados al interpretar la
instrucción HALT.
™ END_CYCLE:
Cada vez que una instrucción termina su ejecución pasará a
este estado, salvo que se trate de la instrucción HALT.
Dependiendo del modo de ejecución, se puede continuar
ejecutando instrucciones, o bien esperar por la señal de
sincronización STROBE. Si las interrupciones están
habilitadas, éstas son procesadas a partir de este punto.
™ INT1 … 4:
Estados implicados en la atención a una interrupción.
™ LOAD1 … 6:
Si la señal MODE(1:0) esta en modo LOAD, esto le indica
a la máquina de estados que debe ponerse en modo carga de
programa. La máquina evolucionará a lo largo de todos
estos estados hasta terminar la carga, donde la UC deberá
ser reiniciada.
En cada uno de estos estados, las señales de salida van adoptando distintos valores
que permiten la ejecución de las distintas microinstrucciones en que se divide la
instrucción, o bien los procesos antes reseñados de carga y ejecución. Dado que este
apartado es de vital importancia para entender el funcionamiento del procesador, vamos
a posponerlo y representar únicamente, de manera gráfica, la máquina de estado
mostrando la interconexión entre los distintos estados, así como, las señales implicadas.
Estructura del microprocesador
59
RESET
MODE=STEP
&
STROBE=0
RESET
MODE=LOAD
MODE=RUN
MODE=STEP
&
STROBE=1
LOAD1
FETCH
LOAD2
DECODE
STOP
EXECUTE
ERROR
STROBE=0
STROBE=1
LOAD3
LOAD4
STROBE=1
STORE
SUBR1
LOAD5
SUBR2
LOAD6
SUBR3
STROBE=0
MODE=RUN
MODE=STEP
&
STROBE=1
END_CYCLE
IER=1
MODE=STEP & STROBE=0
INT1
INT2
INT3
INT4
Figura 23: Diagrama de estados de la Unidad de Control
60
4.4.2.8.3.
Desarrollo del microprocesador didáctico ERIC
El registro de gestión de interrupciones (IER)
Dentro de la unidad de control, también es posible encontrar algunos bloques
necesarios para una correcta gestión de algunas señales. Uno de estos bloques, es el
registro de gestión de interrupciones (IER) que dependiendo de su programación
permite o inhibe las interrupciones, controlando de este modo su atención por parte de
la máquina de estados de la UC.
Figura 24: Registro de gestión de interrupciones
Si se activa la señal ENABLE, el registro aceptará interrupciones memorizando en la
salida cualquier cambio en positivo que se produzca en la entrada. Si se activa
DISABLE, la salida se pone a 0, independientemente de lo que ocurra en la entrada. De
este modo, es posible aceptar o rechazar una interrupción, a la vez que se almacena una
solicitud para su posterior tratamiento.
4.4.2.8.4.
El detector de flancos
Otro bloque, que forma parte de la UC es el detector de flancos. Como el propio
nombre indica, su función es la de detectar el flanco de subida, en este caso, de la señal
STROBE para acondicionarla para su posterior uso por parte de la UC. La duración de
esta señal no debe superar la duración de un ciclo, ya que la máquina de estados no
funcionaría apropiadamente.
Estructura del microprocesador
Figura 25: Estructura interna de la Unidad de Control (CONTROL_UNIT.SCH)
61
62
4.4.2.8.5.
Desarrollo del microprocesador didáctico ERIC
El generador de ciclos de espera
Cuando la máquina de estados, accede a partes del circuito más lentos que ella misma,
ésta ha de esperar. Dicha demora, se realiza prologando el estado actual a la espera de
recibir una señal externa que le indique que puede continuar. Dicha señal externa
procede de un bloque, implementado aquí dentro de la propia UC, y que se conoce
como el generador de ciclos de espera. La señal externa es WAIT_STATE, ya descrita
al comentar las señales de entrada a la máquina de estados.
Cuatro, son los dispositivos que precisan que se espere por ellos, que son: los distintos
bloques de memoria, es decir, la ROM, RAM y el STACK, así como, los dispositivos
de entrada/salida.
En el caso de la memoria síncronas, los datos invierten un ciclo de reloj desde que son
aceptados hasta la devolución del resultado. Por ejemplo, en el caso de la lectura por
parte de la máquina de estados, ésta escribirá la dirección coincidiendo con un flanco de
bajada de la señal de reloj. En el flanco de subida siguiente, la memoria aceptará la
información y en el siguiente entregará el dato solicitado. Por lo tanto, es preciso
introducir un ciclo de espera, valor que puede verse incrementado si a las características
intrínsecas de las memorias le añadimos los efectos debidos a los retardos de
propagación de las señales, en el interior de la FPGA.
La diferencia de velocidad entre la CPU y los dispositivos externos obliga también, a
esperar. Esta diferencia puede ser mínima en algunos casos y muy amplia en otros.
Para poder configurar independientemente, los ciclos de espera para cada uno de los
casos descritos, se ha diseñado este bloque como la suma de cuatro. Cada subunidad
está formado por un contador que es disparado por las señales de selección pertinente:
RAM_CE, ROM_CE, STACK_CE e IO. Por defecto, cada contador posee un valor de
cuenta coincidente con el número de ciclos de espera programado. Cuando se activa la
señal, se inicia una cuenta regresiva que finaliza al alcanzar el valor 0. Durante el último
ciclo, se activa la señal de WAIT_STATE, indicándole a la máquina de estados que la
espera ha terminado, y que puede continuar.
Estructura del microprocesador
Figura 26: Subunidades del bloque de estados de espera (WAIT_STATES.SCH)
63
64
Desarrollo del microprocesador didáctico ERIC
Cuando se describió el contador de programa, se comentó el problema que existía al
intentar realizar el incremento conjuntamente con el acceso a la memoria ROM. El
problema, consiste en que, no se puede activar la señal de incrementar sin más, ya que
el acceso a la memoria ROM precisa de más de un ciclo de reloj, lo que ocasionaría que
el contador contase más de una unidad. La solución pasa, por aprovechar el generador
de tiempos de espera asociado a la ROM, para proporcionar una ventana temporal al
finalizar la espera.
Figura 27: Cronograma del generador de ciclos de espera asociado a la ROM
En el anterior cronograma, podemos ver que el contador de ciclos de espera, tiene
programado un valor de 3. Al activarse ROM_CE, representado aquí como la señal
RST, se inicia el decremento activándose la señal WAIT_STATE. Cuando el contador
alcanza el valor 0, WAIT_STATE vuelve a su valor inicial indicando que la espera a
terminado.
E_PCUP, es la señal utilizada por el contador de programa, para incrementar su valor
en una unidad. Cuando el valor de cuenta vale 1, es decir un ciclo de reloj antes de que
concluya el contador, se genera un pulso. Este pulso, es demorado medio ciclo de reloj,
con el fin de hacer coincidir el flanco de subida a la mitad de la ventana temporal,
momento en que el contador realizará su incremento.
Estructura del microprocesador
4.4.2.9.
65
El Sniffer
La finalidad de este bloque, es permitir el acceso al contenido de los registros internos
del ERIC desde el mundo exterior. Otra función que realiza, es la de posibilitar la
introducción de datos desde el exterior con destino a la memoria ROM. Desde el punto
de vista funcional, este bloque no puede ser considerado como parte de un procesador
ya que no está involucrado en el procesado de la información, cumpliendo únicamente
una función de introducción/extracción de la información interna. Por este motivo, en el
esquema, este bloque es mostrado con un color/tono distinto del resto.
La información proporcionada, junto con el uso del programa EricMON, es de mucha
utilidad, para poder entender y seguir como se va modificando el contenido de los
registros, según se va interpretando cada instrucción. También es de mucha utilidad, en
la fase de desarrollo, ya que permite analizar una gran cantidad de información.
Figura 28: Bloque SNIFFER
El diseño de este bloque se ha realizado en dos partes: una dedicada a la captura de la
información hacia el exterior, y otra que permite la introducción de la información
desde el exterior hacia el bus de datos interno del procesador.
66
Desarrollo del microprocesador didáctico ERIC
La parte dedicada a la captura de datos de los registros ha sido realizada con un
contador de 7 bits conjuntamente con un multiplexor de 16 entradas de 4 bits. Se ha
elegido este número de entradas por ser común divisor de todos los registros, puesto que
los hay de 4, 8 y de 12 bits.
La lectura, se realiza por medio de una única línea de salida SNIF_DOUT,
sincronizada por un reloj externo denominado SNIF_CLK. La ejecución de los pasos
precisos para la lectura, es una acción combinada entre la UC, el SNIFFER y el
programa EricMON, que son expuestos a continuación:
1. El proceso se inicia con la inicialización del contador por parte de la UC, a
través de la señal SNIF_RST. Este evento se producirá, cada vez que la UC
inicie la fase FETCH de interpretación de una instrucción, o bien en algún otro
caso donde se requiere leer el contenido de los registros, por ejemplo en la carga
de datos en modo LOAD.
2. Tras el reset, el contador se posiciona en el valor más alto, multiplexando en este
caso la señal de HALT de la UC. Esta señal permite al EricMON conocer
cuando el ERIC ha terminado de procesar una instrucción, y proceder a su
lectura.
3. Cuando EricMON decide su lectura, va generando pulsos a través de
SNIF_CLK, obteniendo el valor de un bit multiplexado por la línea
SNIF_DOUT. Se pueden leer hasta 16x4 bits de información, por lo que será
preciso generar toda esta cantidad de pulsos y lecturas. EricMON irá agrupando
esta información, reconstruyendo los datos originales de los registros.
4. Con la lectura del último bit el proceso concluye. En ese momento, EricMON
generará una señal de STROBE, para indicar a la UC que puede continuar con
otra instrucción, lo que desencadenará el regreso al paso 1 antes descrito.
Reseñar que el proceso de lectura sólo se produce en el modo de ejecución paso a
paso (STEP). La siguiente tabla, resume la asignación de los distintos registros a las
entradas del multiplexor:
Estructura del microprocesador
ENTRADA
0
1
2
3
4
5
6
7
8
9
A
B
C
D
E
F
REGISTRO
A_REG(7:4)
A_REG(3:0)
B_REG(7:4)
B_REG(3:0)
F_REG(3:0)
IR_REG(7:4)
IR_REG(3:0)
PC_ADDR(11:8)
PC_ADDR(7:4)
PC_ADDR(3:0)
MAR_REG(11:8)
MAR_REG(7:4)
MAR_REG(3:0)
SP_ADDR(7:4)
SP_ADDR(3:0)
STATE(3:0)
67
OBSERVACIONES
Acumulador
Acumulador
Registro B
Registro B
Registro de estado (FLAGS)
Registro de instrucciones
Registro de instrucciones
Contador de programa
Contador de programa
Contador de programa
Registro MAR
Registro MAR
Registro MAR
Contador del STACK
Contador del STACK
Estado de la unidad de control
Tabla 11: Asignación de registros a la entrada del multiplexor del SNIFFER
La parte dedicada a la introducción de datos desde el exterior, ha sido diseñada a
partir de un registro de desplazamiento de 8 bits, que hace las funciones de conversor de
datos serie-paralelo. Está conversión, sólo se realiza si el SNIFFER detecta, a través de
la señales MODE(1:0), que el ERIC se encuentra en modo LOAD. En este modo, el bus
de datos interno del ERIC está a disposición del SNIFFER. Veamos los pasos llevados a
cabo en este proceso:
1. El proceso se inicia por parte de EricMON programando el modo LOAD a
través de las señales MODE(1:0). La UC utilizará la señal de HALT como
señal de sincronización, poniendo ésta a nivel activo. La combinación de
ambos señales habilita el buffer triestado permitiendo que los datos del
conversor vayan a parar al bus de datos interno del ERIC.
2. EricMON escribe bit a bit el dato que quiere enviar. Para ello sincronizará
los pulsos de reloj de SNIF_CLK con la introducción de datos a través de
SNIF_DIN. Al concluir con el 8 bit, generará un pulso de STROBE a la UC,
indicándole que ya ha terminado, repitiéndose de nuevo todo el proceso.
Para completar la comprensión sobre la interacción del SNIFFER con el EricMON, se
recomienda la lectura del capítulo dedicado a este programa, sección modo LOAD.
68
4.4.3.
Desarrollo del microprocesador didáctico ERIC
El decodificador de 7 segmentos
Para finalizar la descripción del esquema de bloques, solo nos queda por comentar el
visualizador de 7 segmentos. Este bloque posibilita la presentación del estado en que se
encuentra la UC, a través del visualizador de 7 segmentos disponible en la XSA-50.
Figura 29: Decodificador binario a 7 segmentos
La implementación se realiza mediante un decodificador, que traslada la codificación
binaria del estado de la UC a un código alfanumérico a visualizar. Dicho codificador
implementa la siguiente tabla:
CÓDIGO
0
1
2
3
4
E
H
P
A
U
L
ESTADO
RESET
FETCH
DECODE
EXECUTE
STORE
ERROR
HALT
END_CYCLE
SUBR1 … 3
INT1 … 4
LOAD1 … 6
Tabla 12: Códigos visualizados en función del estado de la UC
ERIC y la XSA-50
4.5.
69
ERIC y la XSA-50
Hasta aquí, hemos visto las distintas partes en que ha sido divido el diseño del ERIC.
Esta implementación, finaliza con la asignación de las señales del ERIC a los terminales
físicos de la tarjeta elegida, la XSA-50 en este caso. A continuación, vamos a resumir la
lista de conexiones relacionando, el número de terminal de la FPGA, el nombre de la
señal que sale al exterior y la equivalente del ERIC.
PIN
P88
P50
P48
P42
P47
P65
P51
P58
P78
P77
P79
P80
P83
P84
P85
P86
P87
P93
P94
P66
P74
P75
P76
P67
P39
P62
P60
P46
P57
P49
P41
XSA-50
XCLK
XPPD0
XPPD1
XPPD2
XPPD3
XPPD4
XPPD5
XPPD6
XPPS6
XD0
XD1
XD2
XD3
XD4
XD5
XD6
XD7
XIO
XWE20
XADDR0
XADDR1
XADDR2
XADDR3
XLED0
XLED1
XLED2
XLED3
XLED4
XLED5
XLED6
XFLASHCE
ERIC
CLK
RST
MODE0
MODE1
STROBE
IRQ
SNIF_CLK
SNIF_DIN
SNIF_DOUT
D0
D1
D2
D3
D4
D5
D6
D7
IO
WE
ADDR0
ADDR1
ADDR2
ADDR3
LED0
LED1
LED2
LED3
LED4
LED5
LED6
-
OBSERVACIONES
Señal de reloj
Señal de reset
Señal de selección de modo 0
Señal de selección de modo 1
Señal STROBE
Señal IRQ
Señal de reloj del SNIFFER
Señal de datos de entrada del SNIFFER
Señal de salida de entrada del SNIFFER
Bus de datos D0
Bus de datos D1
Bus de datos D2
Bus de datos D3
Bus de datos D4
Bus de datos D5
Bus de datos D6
Bus de datos D7
Señal de selección de entrada/salida
Señal de lectura/escritura (Invertida)
Bus de direcciones. ADDR0
Bus de direcciones. ADDR1
Bus de direcciones. ADDR2
Bus de direcciones. ADDR3
Led 0 del visualizador de 7 segmentos
Led 1 del visualizador de 7 segmentos
Led 2 del visualizador de 7 segmentos
Led 3 del visualizador de 7 segmentos
Led 4 del visualizador de 7 segmentos
Led 5 del visualizador de 7 segmentos
Led 6 del visualizador de 7 segmentos
Deshabilitación de la FLASH en la XSA.
Tabla 13: Asignación de las señales del ERIC a lo terminales (pines) de la XSA-50
20
La señal WE se invierte al salir al exterior, para que sea activa a nivel bajo.
70
Desarrollo del microprocesador didáctico ERIC
Para posibilitar la movilidad del diseño, y que pueda ser usado en otras tarjetas, se a
diseñado un esquema de bloques por encima del nivel TOP (teóricamente el más alto),
donde se relacionan las señales propias del ERIC, mostradas en el nivel TOP, con las
particularidades propias de esta tarjeta simbolizadas por el bloque XSA 50 PINOUT.
La idea es, que cuando se quiera adaptar el diseño a otra tarjeta sólo sea necesario
modificar un único bloque, es este caso el XSA 50 PINOUT, y no tocar nada del resto
del diseño.
ERIC y la XSA-50
71
Figura 30: Adaptación de las señales del ERIC a la tarjeta XSA-50
(XSA50_PINOUT.SCH)
72
4.6.
Desarrollo del microprocesador didáctico ERIC
Ejecución de las instrucciones
En este apartado, vamos a analizar el proceso interno de interpretación y ejecución de
las instrucciones, donde se van ha ver implicados cada uno de los bloques que
conforman el procesador.
4.6.1.
Temporización de las señales
La parte fundamental que coordina a cada uno de los bloques funcionales del
procesador, es la UC. La Unidad de Control, va cambiando de estado sincronizadamente
con el flanco de bajada del reloj. Por el contrario, el resto de elementos de la CPU
realizan operaciones sincronizados por el flanco de subida. La razón de esto, es que la
UC pueda activar las señales de control, dando tiempo suficiente para que se propaguen
por el interior de la CPU, antes de que los elementos del procesador realicen su función.
El tiempo de asentamiento de estas señales, desde que son generadas por la UC hasta
que son utilizadas, es por lo tanto, de medio ciclo, diferencia entre el flanco de bajada y
el de subida. En consecuencia, el tiempo de propagación de cualquier señal a de ser
inferior a la mitad del ciclo de trabajo, limitando de este modo la frecuencia máxima de
trabajo del procesador.
ERIC funciona a una velocidad de 1 Mhz. Esta frecuencia ha sido elegida con el fin
de minimizar los posibles problemas de propagación antes comentados. Se han hecho
pruebas a 50 Mhz encontrándose inestabilidades en el diseño originado por estos
retardos. Hay que pensar que medio ciclo de reloj a 50 Mhz son 10 ns, tiempo similar al
retardo máximo reportado por el WebPACK. Bajando la velocidad a 1 Mhz, el
procesador dispone de 500 ns, tiempo más que suficiente para la propagación de
señales.
El modo de funcionamiento de todo el sistema, salvo los elementos puramente
combinacionales, es funcionar sincronizadamente con la señal de reloj. De este modo, la
UC va habilitando ventanas temporales, normalmente de un ciclo de reloj de duración,
durante el cual los elementos ejecutan su función sincronizadamente con el flanco de
subida.
Ejecución de las instrucciones
73
Cada grupo de señales de control, generadas durante un estado de la UC, es conocido
como microinstrucción y es la base que determina que se realice una cosa y no otra,
desglosando de esta manera, la ejecución de una instrucción en unidades más pequeñas.
Las señales de control, involucradas en estas microinstrucciones, ya han sido
comentadas al tratar la descripción de la UC. Con el fin de facilitar su tratamiento de
forma tabular, así como de facilitar su implementación a la hora de definir el
comportamiento de la máquina de estados, se han agrupado estas señales en un vector.
Dicho vector es conocido como vector de señales (SV21) donde cada bit representa una
señal de control.
La siguiente tabla nos muestra esta relación:
SV
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
SEÑAL DE CONTROL
IO
RAM_CE
ROM_CE
WE
PC_UP
PC_LD
IR_LD
A_LD
B_LD
F_LD
S_MUX1
HALT
ENABLE_IER
DISABLE_IER
MAR_LD8
MAR_LD12
SV
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
SEÑAL DE CONTROL
S_MUX2
S_MUX3
E_MUX3
SNIF_RST
S_MUX4
S_MUX5
PC_REL
STACK_CE
SC_UP
SC_DOWN
E_BUF1
S_MUX6
E_MUX6
S_MUX7
MAR_LD4
PC_RST
Tabla 14: Descripción del vector de señales (SV)
21
SV procede de Signal Vector
74
Desarrollo del microprocesador didáctico ERIC
4.6.2.
Las interrupciones
Aunque el tratamiento de una interrupción, no es una instrucción recogida en el juego
de instrucciones de un procesador, a nivel interno es tratada como si lo fuera. La
instrucción equivalente es la llamada a subrutina: ACALL addr12. La diferencia con
esta instrucción es, que se desactiva el registro IER para que no se produzca ninguna
interrupción durante la llamada de atención, y que la llamada es el resultado de un
proceso hardware.
Dado que a nivel de microinstrucciones es similar a ACALL, y que esta instrucción va
a ser analizada en detalle en el apartado siguiente, sólo vamos a realizar una breve
descripción de las tareas realizadas en cada estado:
™ INT1:
Se guarda la parte alta del PC en el STACK.
™ INT2:
Se incrementa el SC.
™ INT3:
Se guarda la parte baja del PC en el STACK.
™ INT4:
Se incrementa el SC, se deshabilita IER y se reinicia el PC a la
posición 0x002.
4.6.3.
La ruta de datos
Un concepto, que aparece en los textos que tratan aspectos relativos a
microprocesadores, es el de la ruta de datos22. Dicho concepto, define el camino seguido
por los datos en las distintas fases en la ejecución de una instrucción. La representación
gráfica de la ruta de datos, es una buena manera de mostrar como la UC va ejecutando
cada una de las microinstrucciones.
Con el fin de explicar la manera que tiene el procesador de ejecutar las instrucciones,
vamos a elegir dos ejemplos representativos y proceder a analizar las distintas fases de
ejecución, las señales de control que se activan, representado en cada caso la ruta de
datos que sigue la información. Las instrucciones elegidas son: MOVX A,@B y
ACALL addr12.
22
Datapath en inglés
Ejecución de las instrucciones
4.6.3.1.
75
Ejemplo: MOVX A,@B
Como podemos comprobar, revisando el juego de instrucciones, esta instrucción
realiza una lectura de la memoria RAM depositando el dato en el acumulador. El modo
de direccionamiento es el indexado, utilizando para ello el registro auxiliar B. Vamos a
ver, los pasos implicados en cada una de las 4 fases en que ha sido dividida la
instrucción:
™ FETCH:
Se va a buscar la instrucción a la ROM, en la posición indicada
por el PC. El dato obtenido se guardará en el registro IR. Para ello
se activa ROM_CE, IR_LD. Como es principio de instrucción se
reinicia el SNIFFER por medio de SNIF_RST y se incrementa el
PC con PC_UP. El acceso a ROM dispara el contador de tiempos
de espera.
™ DECODE:
El contenido del registro B es encaminado hasta la entrada del
registro MAR. Para ello, se activa las señales S_MUX3(E1),
E_MUX3 y S_MUX4(E1).
™ EXECUTE: Se guarda el dato procedente del registro B en MAR, activando la
señal MAR_LD8.
™ STORE:
El dato guardado en MAR contiene la dirección donde está el
dato que se debe guardar en A. Para proceder a su lectura, se
activa S_MUX2(E1) para que la dirección de MAR pase al bus de
direcciones, y se activa ROM_CE y A_LD. El acceso a ROM
introduce ciclos de espera.
INSTRUCCIONES ESTADO
MOVX A,@B
FETCH
DECODE
EXECUTE
STORE
io
ram_
ce
rom_
ce
we
pc_u
p
pc_ld
ir_ld
a_ld
b_ld
f_ld
s_m
ux1
halt
en_ie
r
dis_
ier
mar_
ld8
mar_
ld12
s_m
ux2
s_m
ux3
e_m
ux3
snif_
r st
s_m
ux4
s_m
ux5
pc_r
el
stac
k_ce
sc_u
p
sc_d
own
e_bu
f1
s_m
ux6
e_m
ux6
s_m
ux7
mar_
ld4
pc_r
st
La siguiente tabla resume los pasos antes descritos.
1
1
1
1
1 1
1 1
1
1
1
1
1
1
Tabla 15: Resumen de los pasos necesarios para ejecutar MOVX A,@B
VECTOR DE
SEÑALES
2
0
0
2
A
0
0
1
0
0
0
0
0
0
2
0
1
6
6
8
0
8
8
0
0
0
0
0
0
0
0
0
76
Desarrollo del microprocesador didáctico ERIC
Figura 31: Fase FETCH de la instrucción MOVX A,@B
Figura 32: Fase DECODE de la instrucción MOVX A,@B
Ejecución de las instrucciones
Figura 33: Fase EXECUTE de la instrucción MOVX A,@B
Figura 34: Fase STORE de la instrucción MOVX A,@B
77
78
Desarrollo del microprocesador didáctico ERIC
4.6.3.2.
Ejemplo: ACALL addr12
La instrucción ACALL addr12 es una instrucción de salto a subrutina. El modo de
direccionamiento es el directo, proporcionando la dirección de 12 bits parte codificada
en la instrucción y parte en el segundo byte, tal como corresponde a la codificación de
addr12. Como toda llamada a subrutina, el procesador ha de salvaguardar el contenido
del contador de programa antes de realizar el salto. Vamos a ver los pasos implicados en
cada una de las 6 fases en que se ha subdividido la instrucción:
™ FETCH:
Se va a buscar la instrucción a la ROM, en la posición indicada
por el PC. El dato obtenido se guardará en el registro IR. Para
ello, se activa ROM_CE, IR_LD. Como es principio de
instrucción, se reinicia el SNIFFER por medio de SNIF_RST y se
incrementa el PC con PC_UP. El acceso a ROM dispara el
contador de tiempos de espera.
™ DECODE:
La UC decodifica la instrucción, analizando para ello los campos
C1 y C2 del primer byte. Esto, le indica que debe proceder a la
lectura de un segundo byte por lo que procede de nuevo a una
lectura en la ROM. Para ello, se activa de nuevo ROM_CE,
almacenando el dato entrante en el registro MAR junto a los 4
bits de menor peso de IR, activando para ello MAR_LD12. El
acceso a ROM introduce de nuevo ciclos de espera.
™ EXECUTE: Se guarda en el STACK la parte alta del PC, es decir los 4 bits de
mayor peso. Para ello se activa S_MUX6(E1) y E_MUX6 del
multiplexor M6, consiguiendo encaminar parte del PC por el bus
de datos hacia la entrada del STACK. Mediante la activación de
STACK_CE y WR se consigue escribir el dato en la pila, en la
posición apuntada por el puntero del STACK (SC). El acceso al
STACK ocasiona ciclos de espera
™ SUBR1:
Se incrementa el valor de SC. Esta instrucción dura exactamente
un ciclo de reloj.
Ejecución de las instrucciones
™ SUBR2:
79
Se guarda en el STACK la parte baja del PC, es decir los 8 bits de
menor peso. Para ello se activa S_MUX6(E0) y E_MUX6, del
multiplexor M6 consiguiendo encaminar parte del PC por el bus
de datos hacia la entrada del STACK. Mediante la activación de
STACK_CE y WR se consigue escribir el dato en la pila, en la
posición apuntada por el puntero del STACK (SC). El acceso al
STACK ocasiona ciclos de espera
™ SUBR3:
Se incrementa el valor de SC y se carga en el PC, en dato
previamente almacenado en el MAR, mediante la activación de la
señal PC_LD. Esta instrucción también dura un ciclo de reloj.
INSTRUCCIONES ESTADO
ACALL addr12
FETCH
DECODE
EXECUTE
SUBR1
SUBR2
SUBR3
io
ram_
ce
rom_
ce
we
pc_u
p
pc_ld
ir_ld
a_ld
b_ld
f_ld
s_m
ux1
halt
en_ie
r
dis_
ier
mar_
ld8
mar_
ld12
s_m
ux2
s_m
ux3
e_m
ux3
snif_
rst
s_m
ux4
s_m
ux5
pc_r
el
stac
k_ce
sc_u
p
sc_d
o wn
e_bu
f1
s_m
ux6
e_m
ux6
s_m
ux7
mar_
ld4
pc_r
st
Todo lo comentado con anterioridad, viene recogido en la siguiente tabla:
1
1
1
1
1
1
1
1
1
1 1
1
1
1
1
1
1
VECTOR DE
SEÑALES
2
2
1
0
1
0
A
8
0
0
0
4
0
0
0
0
0
0
0
1
0
0
0
0
1
0
0
0
0
0
0
0
1
0
1
0
0
0
1
8
0
8
0
0
8
0
8
0
Tabla 16: Resumen de los pasos necesarios para ejecutar ACALL addr12
El apéndice Microinstrucciones, recoge una descripción pormenorizada sobre las
señales involucradas en cada una de las etapas en que se ha dividido la ejecución de
cada una de las instrucciones del ERIC, de manera similar a la tabla anteriormente
mostrada.
80
Desarrollo del microprocesador didáctico ERIC
Figura 35: Fase FETCH de la instrucción ACALL addr12
Figura 36: Fase DECODE de la instrucción ACALL addr12
Ejecución de las instrucciones
Figura 37: Fase EXECUTE de la instrucción ACALL addr12
Figura 38: Fase SUBR1 de la instrucción ACALL addr12
81
82
Desarrollo del microprocesador didáctico ERIC
Figura 39: Fase SUBR2 de la instrucción ACALL addr12
Figura 40: Fase SUBR3 de la instrucción ACALL addr12
Capítulo 5
Desarrollo del software de soporte
Adicionalmente al diseño e implementación del procesador ERIC, se han desarrollado
una serie de programas de apoyo con el fin de facilitar el manejo del mismo. Se trata
por un lado, de un programa monitor enfocado a explotar las posibilidades del ERIC de
una manera más amigable, y por otro lado, de un ensamblador que permita la creación
sencilla de programas.
5.1.
EricMON
A la hora de diseñar el ERIC, surgió la necesidad de dar solución a una serie de
interrogantes sobre la forma de explotar, de una manera sencilla y amigable, las
funcionalidades del procesador, en concreto el control de los modos de ejecución y la
generación de interrupciones. Tradicionalmente, este control se ha realizado con la
ayuda de pulsadores que mediante su activación desencadenan la generación de las
señales pertinentes, permitiendo de este modo la ejecución paso a paso de un programa,
pasar a modo ejecución continua o generar una interrupción en un momento dado.
Aunque la solución, es aparentemente muy sencilla, adolece de una serie de
inconvenientes:
™ Precisa que la tarjeta de desarrollo posea pulsadores y en la cantidad adecuada.
Este hecho condiciona la tarjeta de desarrollo a utilizar, puesto que las tarjetas
más simples no poseen ningún pulsador, por lo que hay que recurrir a hardware
83
84
Desarrollo del software de soporte
adicional. Por otro lado, los pulsadores que podemos encontrarnos en estas
tarjetas son bastante simples y de bajas prestaciones.
™ Precisa incluir en el diseño, circuitos antirebotes.
™ El diseño del conjunto ERIC más pulsadores lo hace más dependiente de un tipo
de tarjeta en concreto, dificultando su emigración a otro tipo de tarjetas.
™ El uso repetitivo de los pulsadores puede llegar a ser tedioso, sobre todo, en el
caso de la ejecución paso a paso donde cada paso requiere una pulsación.
Adicionalmente a este problema, existía otro sobre que información interna del ERIC
se quería visualizar y cómo. Lo común, en estos casos, es la utilización de
visualizadores de 7 segmentos conectados a los registros que queremos estudiar. Esta
solución, aunque sencilla, padece de serias limitaciones:
™ Es preciso 2 visualizadores de 7 segmentos por cada registro que queremos
mostrar ya que cada visualizador muestra 4 bits. Dado lo limitado de este tipo de
dispositivos en las placas de desarrollo, que pueden variar desde ninguno hasta
4, la visualización se reduce a mostrar el contenido de 1 o 2 registros como
máximo. Normalmente, el registro elegido es el acumulador, por ser uno de los
más activos. Esta información es insuficiente para evaluar la evolución interna
del procesador.
™ La decodificación, de binario a 7 segmentos, debe ser realizada dentro de la
propia FPGA, lo que obliga a incluir en el diseño módulos adicionales ajenos al
propio procesador.
™ En el supuesto de disponer de suficientes visualizadores de 7 segmentos, es
preciso disponer en la FPGA de un gran número de terminales de salida, no
siempre disponibles dependiendo del modelo de FPGA.
Puesto que, el sistema de desarrollo de una FPGA obliga necesariamente al uso de un
PC conectado a la tarjeta de desarrollo vía puerto paralelo, parece más apropiado para el
control del ERIC el uso de estos recursos con la ayuda del software adecuado. Esto,
motivó el diseño de un programa monitor al que se le denominó con el nombre de
EricMON (Eric MONitor). A partir de las especificaciones ya comentadas, se procedió
posteriormente a añadirle alguna funcionalidad más que a continuación se detalla.
EricMON
5.1.1.
85
Descripción general del programa
EricMON, es una aplicación MS-DOS que puede correr en cualquier máquina que
disponga como sistema operativo Windows9x, Windows NT, Windows 2000 o XP. El
programa ha sido estructurado en tres partes que controlan los dos modos posibles de
ejecución así como la carga de un programa en ROM. En el apéndice Manual del
monitor EricMON, podemos encontrar un manual sobre su uso.
Cada uno de estos modos de trabajo, han sido denominados:
™ LOAD
Permite la carga de un fichero ensamblado en formato .BYTE en la
ROM del procesador.
™ RUN
Ejecuta un programa en modo continuo (sin pausas entre
instrucciones), permitiendo arrancar o detener el programa en
cualquier momento. También es posible generar una interrupción
durante la ejecución del mismo.
™ STEP
Ejecuta un programa en el modo paso a paso, visualizando en cada
momento la evolución de la totalidad de los registros internos que
conforman el ERIC. Dentro de este modo, es posible variar el
número de pasos a realizar en cada interacción. También es posible
generar una interrupción en cualquier momento del proceso.
El programa ha sido escrito en C++, aunque se ha buscado la máxima sencillez en la
programación, evitando intencionadamente las definiciones ininteligibles. En este
sentido, el estilo de programación es más propio del C clásico, que de las complejas
construcciones propias de las programaciones orientadas a objeto.
Sin entrar en demasiadas profundidades, ya que el visionado de los ficheros fuentes
son suficientemente explícitos, vamos a comentar las particularidades de cada uno de
los modos.
86
5.1.2.
Desarrollo del software de soporte
Modo LOAD
El cometido, de esta parte del programa, es cargar el contenido de un fichero
ensamblado en la ROM del ERIC. El fichero deberá estar escrito en formato BYTE.
El formato BYTE, es uno de los múltiples formatos de salida del ensamblador
EricASM, que también se describe en este capítulo, y que se caracteriza en que cada
línea del fichero describe una posición de memoria y el contenido de la misma en
formato ASCII. Ejemplo:
0000: B0
0001: 2D
0006: 6F
Vamos a ver las distintas etapas llevadas a cabo por el programa:
1. El proceso se inicia mostrando en consola las opciones posibles, lo que se
consigue con la función PrintCommandLoad().
2. A continuación, se le indica al procesador que se desea cargar un programa
lo que se consigue con la ayuda de la función LoadMode().
3. La pulsación de la tecla F, origina que se solicite el nombre de un fichero sin
extensión, que deberá estar ubicado en el mismo directorio desde donde se
está ejecutando el EricMON. El programa le añade la extensión .BYTE e
intenta abrirlo. En el caso de que esta apertura sea fallida, se genera un
mensaje de error y se aborta el proceso.
4. En caso afirmativo, se procede a su lectura línea a línea, escribiendo la
información obtenida en un array que representa la imagen de la memoria de
la ROM. El array es inicializado a 0 antes de proceder a la lectura del
fichero. Los pasos 3 y 4 son llevados a cabo por la función ReadByteFile().
5. El proceso de carga se realiza de manera sincronizada con el procesador, ya
que realmente es el procesador el que realiza la escritura/lectura de los datos.
La señal de sincronización es la señal HALT del procesador, que deberá
estar a nivel alto indicando al programa que se encuentra listo. El programa
comprueba esta condición y en el caso contrario el programa genera un
mensaje de error y aborta el proceso.
EricMON
87
Editor de Texto
Ensamblar
Fichero
.ASM
EricASM
Cargar
Fichero
.BYTE
EricMON
Figura 41: Proceso a seguir desde el fichero fuente a la carga en el ERIC
6. Si todo está correcto, se procede a escribir el primer dato correspondiente a
la posición de memoria 0x000, dado que el procesador ERIC se encuentra
posicionado en este punto. La escritura se hace en serie, vía pin SNIF_DIN,
generando un pulso de reloj de SNIF_CLK por cada bit. Este paso es llevado
a cabo por la función Sniffer_Write().
7. Al finalizar la escritura de un byte, se genera la genera un pulso de STROBE
indicando al procesador que hay un dato listo.
8. A partir de esta señal de sincronización, el procesador copia el dato
suministrado en el acumulador, y a partir de ahí, efectúa una operación de
escritura en la memoria de programa. Una vez escrito, el procesador
comprueba que el dato ha sido bien grabado procediendo a su lectura,
dejando el resultado en el registro auxiliar B. La finalización de este paso es
indicado al programa mediante la señal HALT del procesador.
9. El programa procede a leer el contenido interno de los registros mediante la
función DumpLoad(), comprobando que el valor del PC y del registro B son
los esperados. En caso negativo, se genera un mensaje de error y se aborta el
proceso.
88
Desarrollo del software de soporte
10. Si todo va bien, se imprime la dirección y el dato procesado y se pasa a la
siguiente posición del array, repitiendo los pasos del 5 al 10. Por su parte el
procesador habrá incrementado en una unidad el valor del PC. Los puntos
del 5 al 10 son llevados a cabo por la función Load().
En este apartado, solo queda comentar que la dimensión del array antes mencionado,
es de 2048 posiciones, es decir, se corresponde con el tamaño de la ROM en versión
reducida. Si se desea trabajar con otro tamaño de ROM, es necesario modificar el
parámetro TAM_ROM23 y volver a compilar el programa.
Figura 42: Ejemplo de una sesión en modo LOAD
23
Las variables y definiciones de EricMON se encuentran en EricPort.h
EricMON
5.1.3.
89
Modo RUN
El cometido de esta parte de la aplicación, es controlar el modo de ejecución del
programa existente en memoria. En este modo, la ejecución se realiza de manera
continuada sin la inserción de pausas entre la ejecución de instrucciones.
Una vez cargado el programa, e introducidos en este modo, la ejecución se inicia
mediante la pulsación de la tecla RETURN. Cada vez que se pulsa la tecla RETURN,
el sistema conmuta entre los estados de ejecución y pausa. Durante la ejecución, es
posible generar una interrupción mediante la pulsación de la tecla I. También es posible
reiniciar la ejecución del programa pulsando la tecla R.
Vamos a ver las distintas etapas llevadas a cabo por el programa:
1. El proceso se inicia mostrando en consola las opciones posibles, por medio
de la función PrintCommandStep().
2. El programa principal averigua si se ha pulsado alguna de las teclas
anteriormente descritas.
3. Si se ha pulsado RETURN, se invoca a la función RunMode() que averigua
el estado de ejecución del procesador, consultando internamente el valor de
la variable running. En el caso de estar detenido, la función indica al
procesador que se pase a modo RUN y en el caso contrario, que se pase al
modo STEP. Esta situación va alternando entre RUN y STEP en cada
pulsación de la tecla.
4. Si se ha pulsado la tecla I se invoca la función Interrupt().
5. Si se ha pulsado la tecla R se invoca la función Reset().
Comentar en este punto, que es posible iniciar la ejecución de un programa, detenerlo
y pasar al modo STEP para continuar su ejecución.
90
5.1.4.
Desarrollo del software de soporte
Modo STEP
El cometido de esta parte de la aplicación, es controlar el modo de ejecución del
programa existente en memoria. En este modo, la ejecución se realiza de manera
interrumpida insertando una pausa entre la ejecución de cada instrucción.
Una vez cargado el programa, e introducidos en este modo, la ejecución se inicia
mediante la pulsación de la tecla RETURN. Cada vez que se pulsa la tecla RETURN,
se ejecuta una instrucción y a continuación se muestra el estado de los registros internos
del procesador ERIC. La visualización, diferencia mediante colores los cambios de
estado de los registros entre lecturas consecutivas. El número de instrucciones
ejecutadas en cada interacción es modificable, siendo el valor por defecto de 1. Al igual
que pasaba en el modo RUN, es posible generar una interrupción pulsando la tecla I o
bien reiniciar la ejecución pulsando R.
Vamos a ver las distintas etapas llevadas a cabo por el programa:
1. El proceso se inicia mostrando en consola las opciones posibles, por medio
de la función PrintCommandStep().
2. A continuación, se programa el procesador en el modo STEP por medio de
la función StepMode().
3. El programa principal, averigua si se ha pulsado alguna de las teclas
anteriormente descritas.
4. Si se ha pulsado RETURN, se genera un pulso en la señal STROBE del
procesador, indicándole que ya puede ejecutar una instrucción. Esto se
realiza mediante la función Strobe(). El programa queda a la espera de que
ERIC le indique que a ejecutado la instrucción.
5. La señal utilizada para la sincronización de ambos procesos es la señal
HALT. Cuando ERIC finaliza la ejecución de una instrucción activará esta
señal indicando que se encuentra detenido.
6. En este punto, se procede a la lectura de los registros internos del ERIC con
la ayuda de la función DumpStep(). La función generará un error de timeout
EricMON
91
si la señal HALT no se activa en el espacio de tiempo de 2 sg. En este caso,
la lectura se realiza igualmente pero los datos pueden no ser validos.
7. Se procede a la visualización mediante la función PrintDumpStep().
8. Si la variable N, que indica el número de instrucciones a ejecutar por
interacción, es mayor que 1 se repetirán los pasos 4, 5 6 y 7.
9. Si se ha pulsado la tecla I se invoca la función Interrupt().
10. Si se ha pulsado la tecla R se invoca la función Reset().
Figura 43: Ejemplo de una sesión en modo STEP
92
Desarrollo del software de soporte
5.1.5.
Implementación
El punto de partida para la implementación del software, fue aprovechar la conexión
con el puerto paralelo entre el PC y la tarjeta de desarrollo, como medio de intercambio
de información. Dado que para la programación de la tarjeta, el puerto paralelo debe
estar configurado como SPP (Standard Parallel Port) se eligió este modo como
configuración de trabajo. Por otro lado, el SPP es el modo más sencillo de todos los
posibles y además el más compatible.
El siguiente punto a tratar fue el método a seguir para dialogar con el puerto paralelo.
En los sistemas operativos Windows95 y 98 la programación del puerto paralelo se
puede hacer de manera directa. No ocurre lo mismo, para los sistemas basados en el
entorno NT ,es decir, Windows NT, 2000 y XP, donde la gestión del puerto paralelo es
realizado en exclusiva por el sistema operativo, siendo necesario la instalación de un
driver para posibilitar el acceso al mismo.
Dado que el entorno de trabajo, para el diseño de la FPGA (WebPack) precisa de un
sistema operativo NT y, que se buscaba una solución lo más abierta posible, se decidió
acometer la programación del puerto paralelo vía driver.
Para trabajar con las tarjetas de desarrollo de Xess, es obligatorio el instalar un
conjunto de utilidades denominadas las XSTOOLS. Estas utilidades, realizan funciones
de configuración de distintos aspectos de la tarjeta vía puerto paralelo, instalando para
ello un driver conocido como UNIOO.DLL. Por otro lado, Xess suministra los ficheros
fuente de sus utilidades por lo que a partir de esta información fue posible desarrollar el
EricMON sin necesidad de empezar de cero y utilizando el mismo driver.
Como ya se ha comentado, la instalación del driver UNIOO.DLL va implícita en la
instalación de las XSTOOLS. En el caso de no trabajar con tarjetas Xess, es necesario
instalar el driver de manera aislada, siendo esto posible con la ayuda del programa
PORT95NT.EXE que se puede localizar en el CD de instalación de las utilidades de
Xess, bien desde la web del fabricante, o bien en el CD que acompaña el proyecto.
EricMON
5.1.5.1.
93
El puerto paralelo en modo SPP
Aunque este puerto, fue diseñado originariamente para permitir la comunicación entre
el ordenador y la impresora, a lo largo de la historia del PC han proliferado diseños
ajenos a la impresión, que han aprovechado las capacidades de comunicación
bidireccional de este puerto.
El puerto paralelo del PC, dispone de 17 líneas de comunicación distribuidas en tres
grupos: 8 líneas de datos, 4 de control y 5 de estado. Estas líneas han sido utilizadas en
este proyecto para permitir la comunicación entre el ERIC y el programa EricMON.
Veamos las características de cada una de estas líneas y su relación con el ERIC.
PIN
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
SEÑAL P. PARALELO
CONTROL 0
DATA 0
DATA 1
DATA 2
DATA 3
DATA 4
DATA 5
DATA 6
DATA 7
STATUS 6
STATUS 7
STATUS 5
STATUS 4
CONTROL 1
STATUS 3
CONTROL 2
CONTROL 3
DIRECCION
OUT
OUT
OUT
OUT
OUT
OUT
OUT
OUT
OUT
IN
IN
IN
IN
OUT
IN
OUT
OUT
SEÑAL ERIC
RST
MODE 0
MODE 1
STROBE
IRQ
SNIF_CLK
SNIF_DIN
SNIF_DOUT
-
Tabla 17: Descripción de las señales del puerto paralelo y su relación con ERIC
Para poder acceder a cada una de las señales, deberemos escribir o leer en la dirección
del correspondiente registro de 8 bits:
™ DATA
Dirección base, normalmente la 0x378 (LPT1)
™ STATUS
Dirección base + 1.
™ CONTROL
Dirección base + 2.
Como ya se comentó con anterioridad, la escritura y la lectura no puede realizarse
directamente en entornos NT.
94
Desarrollo del software de soporte
5.1.5.2.
Arquitectura software de las XSTOOLS
El punto de partida del desarrollo, fue el estudio de la arquitectura de los distintos
módulos de las XSTOOLS. En este punto, es necesario aclarar que las utilidades de
XESS están disponibles en dos formatos: en modo gráfico y en modo línea de comando
en formato texto. Por ejemplo, es posible descargar el fichero .bit en la FPGA
utilizando bien la utilidad GXLOAD (para entorno Windows) o XSLOAD (entorno
MS-DOS). Los ficheros fuentes, a los que nos referimos aquí, son los relativos a las
utilidades en versión línea de comando.
Las utilidades de las XSTOOLS 4.0 han sido desarrolladas con Microsoft Visual C++
5.0, por lo que EricMON también está escrito en C++.
Figura.44: Vista general del entorno de programación Visual C++
EricMON
95
Analizada la documentación, sobre la arquitectura del software de las XSTOOLS, nos
encontramos con una descripción de objetos, métodos y clases que se resumen en la
siguiente figura:
Figura.45: Esquema jerárquico de los objetos de las utilidadaes XSTOOLS
A pesar de lo amplio de la jerarquía de objetos de las XSTOOLS, EricMON sólo
aprovecha las clases PPORT, XSError y Utils. De estas tres, sólo vamos a describir la
PPORT por ser la que maneja el puerto paralelo, siendo las otras dos clases subsidiarias
de PPORT y de escaso interés para el proyecto.
Para más información, consultar en la sección de documentos del CD, XSTOOLS
Source Documentation 4.0
96
Desarrollo del software de soporte
5.1.5.3.
La clase PPORT
PPORT es el objeto que maneja el puerto paralelo vía el driver UNIOO.DLL antes
comentado. Dicha clase, ofrece una serie de métodos de los cuales sólo nos interesan
tres:
bool Setup(XSError* e, unsigned int n, unsigned int invMask);
void Out(unsigned int v, unsigned int loPos, unsigned int hiPos);
unsigned int In(unsigned int loPos, unsigned int hiPos) const;
™ Setup(): Permite la inicialización del puerto paralelo, indicando el canal de
errores a utilizar, el LPT del puerto paralelo, y una máscara de inversión.
™ Out(): Permite la escritura en un registro del puerto paralelo. Existe un registro
asignado a cada grupo de líneas del puerto paralelo, esto es: datos, control y
status24. La función trata a los 3 registros de 8 bits como un único registro de 24
bits donde se reparte el primer byte (0 …7) para el registro de datos, segundo
byte (8 … 15) para el registro de status y el último (16 … 23) para el de control.
Dependiendo del valor asignado a loPOS y hiPOS tendremos acceso a todo el
registro o sólo a una parte. Ej.- Si queremos escribir un dato en las líneas de C1
y C2 deberemos escribir OUT(dato,16,17).
™ In(): Funciona de manera similar a OUT, salvo que realiza una operación de
lectura y devuelve un dato entero. Ej. Para leer la línea S6 deberemos escribir
dato=IN(8,8)
Es importante mencionar que la tarjeta XSA-50 invierte las líneas D0 y D1 del bus de
datos del puerto paralelo. El objeto PPORT realiza internamente este cambio, de tal
modo que el dato no se ve afectado. No obstante, si vamos a utilizar otra tarjeta, es
necesario proceder a la inversión de estas señales bien a nivel de hardware o a nivel de
software.
24
Hay que tener en cuenta que PPORT puede trabajar también en modo EPP.
EricMON
5.1.5.4.
97
La clase EricPORT
La clase EricPORT, es una clase derivada de la PPORT y por lo tanto hereda los
métodos antes comentados de configuración, lectura y escritura del puerto paralelo. Se
han añadido nuevos métodos que dan respuesta a las necesidades funcionales de
EricMON, y que a continuación se detallan:
void Reset(void);
void PrintVersion(void);
void Interrupt(void);
void PrintCommandEricmon(void);
void Strobe(void);
void PrintCommandStep(void);
void RunMode(void);
void PrintCommandRun(void);
void StepMode(void);
void PrintCommandLoad(void);
void LoadMode(void);
void PrintInterrupt(void);
void Sniffer_clk(void);
void PrintRun(void);
int Sniffer_read(void);
void PrintReset(void);
void Sniffer_write(unsigned int a);
void PrintPromptEricmon(void);
int DumpStep(void);
void PrintPromptStep(void);
int DumpLoad(void);
void PrintPromptRun(void);
int ReadByteFile(void);
void PrintPromptLoad(void);
int Load(void);
void PrintDumpStep(void);
int hex2int(char *a);
void PrintDumpLoad(void);
™ Reset(): Genera un pulso en el terminal RST del procesador, consiguiendo de
este modo la inicialización de la CPU.
™ Interrupt(): Genera un pulso en el terminal IRQ del procesador, solicitando de
este modo un servicio de atención a la interrupción generada.
™ Strobe(): Genera un pulso en el terminal STROBE del procesador. Esta señal
controla la evolución de la ejecución del proceso en el modo paso a paso.
™ StepMode(): Asigna el valor 0 al bus MODE(1:0) del procesador. En este
modo, el procesador ejecuta el programa en el modo paso a paso. Es el valor por
defecto asignado al procesador al ser reiniciado.
98
Desarrollo del software de soporte
™ RunMode(): Asigna el valor 1 al bus MODE(1:0) del procesador. En este
modo, el procesador ejecuta el programa en el modo continuo.
™ LoadMode(): Asigna el valor 2 al bus MODE(1:0) del procesador. En este
modo, el procesador se dispone a recibir el programa para la ROM.
™ Sniffer_clk(): Genera un pulso en el terminal SNIF_CLK. Esta señal controla la
evolución del módulo SNIFFER, utilizado tanto para la lectura de los registros
internos, como para la carga de datos en ROM en el modo LOAD.
™ Sniffer_read(): Devuelve un byte, resultado de la lectura de la información
disponible en el pin SNIF_DOUT del procesador. La lectura es serie.
™ Sniffer_write(): Escribe un byte en el registro de desplazamiento del módulo
SNIFFER del procesador. La escritura se hace vía el pin SNIF_DIN del
procesador y por tanto es serie.
™ DumpStep(): Realiza un lectura de la información disponible en los registros
internos del procesador. La lectura se hace sincronizadamente con la señal
HALT del procesador. Si transcurrido un tiempo (2 sg) el procesador no indica
estar listo, se realiza igualmente la lectura generándose un error de timeout de
lectura. La información obtenida queda almacena para su posterior
visualización.
™ DumpStep(): Igual que DumpStep(), salvo que se le ha retirado la parte de
sincronización con el procesador y la gestión del timeout.
™ ReadByteFile(): Solicita el nombre de un fichero ensamblado con extensión
.BYTE. Si el fichero no se encuentra se genera un error de apertura. En caso
afirmativo, interpreta el fichero según el formato BYTE, y genera internamente
una imagen del contenido de la ROM.
™ Load(): Carga la imagen generada por ReadByteFile() en el procesador ERIC
vía bloque SNIFFER. La sincronización de los distintos pasos de la carga se
realiza vía señal HALT del procesador. En el caso de no estar disponible se
genera un error. Cada dato cargado es comprobado inmediatamente,
procediendo a la lectura de lo grabado con la ayuda de la función DumpLoad().
En caso de que se detecte alguna incongruencia se genera un mensaje de error.
EricMON
99
™ hex2int(): Interpreta una cadena ascii con caracteres hexadecimales y devuelve
el valor entero correspondiente.
™ PrintVersion(): Visualiza en consola el nombre del programa y su versión.
™ PrintCommandEricmon(): Visualiza en consola la ayuda sobre los comandos
disponibles en el menú principal de EricMON.
™ PrintCommandStep(): Visualiza en consola la ayuda sobre los comandos
disponibles en el submenú STEP.
™ PrintCommandRun(): Visualiza en consola la ayuda sobre los comandos
disponibles en el submenú RUN.
™ PrintCommandLoad(): Visualiza en consola la ayuda sobre los comandos
disponibles en el submenú LOAD.
™ PrintInterrupt(): Visualiza el mensaje de solicitud de interrupción.
™ PrintRun(): Visualiza en consola el mensaje de que el procesador está en
ejecución si éste está detenido y viceversa.
™ PrintReset(): Visualiza el mensaje de que el procesador ha sido reseteado.
™ PrintPromptEricmon(): Visualiza en consola el prompt del menú principal.
™ PrintPromptStep(), PrintPromptRun(), PrintPromptLoad(): Visualiza
en
consola el prompt de los submenús STEP, RUN y LOAD.
™ PrintDumpStep(): Visualiza en consola el contenido de los registros internos
del procesador, leídos previamente por la función DumpStep(). Se destacan
aquellos valores que han variado desde la última llamada a la función. Los datos
son mostrados en hexadecimal salvo el acumulador y el registro auxiliar que
también se muestran en binario. Los banderas son visualizadas con su carácter
representativo (C,Z y O).
™ PrintDumpLoad(): Visualiza en consola el contenido de los registros PC y
registro auxiliar B, leídos previamente por la función DumpLoad(). La razón de
esta lectura, es que durante la carga de datos en ROM se realiza una
comprobación del contenido en el registro B.
100
Desarrollo del software de soporte
5.1.5.5.
La librería Console
Aunque C++ dispone de clases que dan soporte a la visualización de aspectos gráficos
en pantalla, lo cierto es que su definición resulta muy engorrosa y poco clara, por lo
menos, para persona ajenas al mundo de la programación en C++. El hecho se agrava,
cuando se trata de realizar aplicaciones en modo consola25. Con el fin de simplifica,r y a
la vez hacer un código lo más claro posible, se decidió incluir dentro del proyecto la
librería Console, de distribución gratuita y libre que incorpora al C++ las funciones
habituales que se disponían en C de la librería CONIO.H (gotoxy, clrscr, textcolor, etc.).
EricMON utiliza sólo alguna de las funciones disponibles que paso a comentar
brevemente:
™ textbackground (): Fija el color de la ventana, es decir del background.
™ textcolor (): Modifica el color con que se va a visualizar el texto.
™ clrscr (): Limpia la ventana y fija el cursor en la posición 1,1.
™ delline(): Borra la línea donde está el cursor. El cursor se mueve hasta el
primer carácter.
™ gotoxy(): Mueve el cursor a las coordenadas fijadas por x e y.
™ wherey(): Devuelve el valor de la coordenada y donde está el cursor.
5.1.6.
Compatibilidad
El uso de EricMON no está limitado a un entorno donde la protagonista sea una
tarjeta de Xess. A pesar de utilizar funciones procedentes de las fuentes de las
XSTOOLS, EricMON puede funcionar con variedad de hardware siempre que se tenga
en cuenta algunas salvedades que garanticen su compatibilidad.
25
Aplicaciones que se ejecutan en ventanas tipo MS-DOS.
EricMON
101
La tarjeta XSA-50, y en general todas las de la casa XESS, invierten los terminales
D0 y D1 del puerto paralelo. Esta inversión ya es tenida en cuenta por la clase PPORT
que de manera transparente al programador invierte el signo de estos 2 bits. Hay que
tener la precaución, al trabajar con otras tarjetas, de invertir en el diseño estos dos bits o
bien modificar el software para que no realice internamente esta inversión.
Si no se instalan las XSTOOLS, deberemos instalar por separado el driver de gestión
del puerto paralelo, que podemos encontrar en el CD adjunto.
Recordemos también que esta versión de EricMON, sólo soporta 2048 bytes de
RAM, por lo que si queremos trabajar tamaños de ROM superiores es necesario volver
a compilar el programa con las modificaciones oportunas.
102
5.2.
Desarrollo del software de soporte
EricASM
En el desarrollo del proyecto, surgió la necesidad de disponer de un ensamblador que
facilitase la construcción de los programas que debería correr después en ERIC. La
codificación manual de programas, aparte de ser engorrosa es susceptible de multitud de
errores, por lo que el manejo de una herramienta de este tipo es siempre deseable.
Por otro lado, tenemos que la construcción de un ensamblador con un mínimo de
prestaciones como puede ser: un buen detector de sintaxis, flexibilidad a la hora de
escribir el código fuente, soporte a etiquetas, etc., no es una tarea fácil y en cualquier
caso laboriosa. Por este motivo, en lugar de desarrollar un ensamblador desde cero se
optó por investigar si era posible disponer de algún programa de libre distribución que
fuese susceptible de ser adaptado al procesador ERIC.
Dado que ERIC está inspirado en el juego de instrucciones del 8051, se inicio la
búsqueda en Internet de un ensamblador del 8051 que proporcionase su código fuente y
que fuese de dominio público. Tras analizar múltiples programas, sopesando siempre la
complejidad del software, la búsqueda concluyó con el AS31. Este software es fruto del
trabajo de Ken Stauffer (Universidad de Calgary), aunque a lo largo de esta última
década a sido mejorado con la contribución de otras personas.
Por lo tanto, EricASM es una versión del AS31 al que se le ha modificado lo
necesario para adaptarlo del 8051 al ERIC, heredando de este modo toda la
funcionalidad del programa original.
EricASM
5.2.1.
103
Descripción general del programa
EricASM es una aplicación MS-DOS, que puede correr prácticamente en cualquier
máquina del tipo PC. El único requisito del sistema operativo, es que permita ejecutar
aplicaciones MS-DOS, por lo que funciona perfectamente en cualquier entorno
Windows.
El programa posee las prestaciones propias de un ensamblador comercial como son:
™ Soporte de directivas (.equ, .org, .db, .byte …).
™ Número en múltiples formatos (hex, bin, octal, decimal).
™ Manejo de expresiones (+, -, *, / , mod, desplazamientos, etc.).
™ Manejo de etiquetas.
™ Cálculo automático de direcciones a etiquetas.
™ Múltiples formatos de salida (byte, hex, srec, …)
Es posible encontrar un manual de uso en el apéndice: Manual del ensamblador
EricASM.
5.2.2.
Implementación
Cada vez que alguien diseña un ensamblador o un compilador, ha de acometer la
programación de una serie de procedimientos comunes a todas estas aplicaciones. Estos
procedimientos, podrían resumirse, en realizar análisis sintácticos en función de unas
normas establecidas, convertir los códigos nemotécnicos en códigos binarios, detectar
etiquetas y generar una base de datos de ellas para posteriormente referenciarlas, etc.
Yacc y Bison son herramientas desarrolladas para la creación de compiladores26. A
partir de la descripción de reglas sintácticas, nemotécnicos, etc., estos programas son
capaces de generar ficheros fuentes, normalmente en lenguaje C, simplificando la labor
de programación. El EricASM está escrito en Yacc.
26
Un ensamblador no deja de ser un tipo particular de compilador.
104
Desarrollo del software de soporte
Veamos los ficheros implicados en el programa y la función de cada uno de ellos:
PARSER.Y:
Es el fichero en formato Yacc. En el se especifican los
nemotécnicos de las distintas instrucciones, así como la reglas
que rigen las sintaxis del ensamblador. El fichero es pasado al
programa Yacc dando como resultado el fichero parser.c que
se deberá compilar y linkar con el resto de los programas en C.
EMITTER.C
Dentro de este fichero, están definidos cada uno de los modos
de salida soportados (Hex, Byte, Srec ….).
LEXER.C
Este fichero proporciona las reglas léxicas del ensamblador.
SYMBOL.C
Este fichero, contiene las equivalencias entre los símbolos y el
código hexadecimal que debe aparecer en el fichero
ensamblado.
ERICASM.C
Programa principal, desde donde se invocan los distintos
programas según las opciones elegidas.
Solo ha sido necesario modificar dos ficheros para adaptar el AS31 al EricASM. Estos
ficheros son PARSER.Y y SYMBOL.C. El fichero ERICASM.C simplemente es el
resultado de renombrar el nombre del compilador original AS31.C.
La compilación de las distintas partes del programa, ha sido realizada con la ayuda del
entorno de programación de libre distribución DJGPP (GNU C y C++). El DJGPP es un
entorno muy completo y complejo, con múltiples utilidades y que se puede descargar de
la pagina web http://www.delorie.com/dgjpp. El CD adjunto al proyecto, incluye una
copia del DJGPP utilizada en este proyecto.
La gestión de la compilación del proyecto se realiza con la ayuda de la utilidad
MAKE y el fichero MAKEFILE. Una de las ventajas de compilar el proyecto con un
compilador GNU, es que su portabilidad al entorno UNIX de LINUX es bastante
sencilla. Veamos someramente los cambios realizados en los dos ficheros antes
mencionados.
EricASM
5.2.2.1.
105
PARSER.Y
Como ya se ha comentado PARSER.Y es un fichero fuente para ser utilizado con los
compiladores YACC o BISON27. El fichero está estructurado en 5 partes denominadas:
GRAMMER:
En esta parte se definen los símbolos (TOKENS) que va a
manejar el ensamblador. Estos símbolos, incluyen todas las
instrucciones y nombre de registros. Esta parte ha sido
adaptada al ERIC.
DIRECTIVIES:
Define la sintaxis de las distintas directivas soportadas. No
se ha modificado nada con respecto al AS31.
EXPRESSIONS: Define la sintaxis de las distintas expresiones soportadas
por el ensamblador (+, -, *, /, etc.). No se ha modificado
nada.
INSTRUCTIONS: Define la relación de las instrucciones, definidas en el
apartado GRAMMAR, relacionándolo con los modos de
direccionamiento que se comentan a continuación. Esta
parte ha sido modificada.
ADDRESSING MODES:
Define
la
sintaxis
de
los
distintos
modos
de
direccionamiento soportados por cada instrucción. Esta
parte ha sido modificada.
5.2.2.2.
SYMBOL.C
Este fichero, define que código numérico va a insertar el ensamblador, en función de
la instrucción y del modo de direccionamiento. El trabajo de adaptación ha consistido
en cambiar las tablas donde se relacionan instrucciones y códigos.
27
Hoy en día se usa más BISON que YACC
Capítulo 6
Prueba final
Una vez descritas, tantos la parte hardware como software del proyecto solo queda
probar el conjunto. Para la prueba, se decidió conectar el ERIC a un visualizador LCD
con el fin de escribir un programa que verificase el buen funcionamiento de gran parte
de las instrucciones del repertorio, especialmente las de entrada/salida.
6.1.
Instalación de la prueba
Para el buen funcionamiento de la prueba, es importante realizar una serie de pasos
previos que garanticen una correcta interacción entre las distintas aplicaciones. Los
ficheros necesarios pueden encontrarse en el CD adjunto.
Los pasos son los siguientes:
™ Instalación del driver de gestión del puerto paralelo. Esto puede realizarse bien
instalando las utilidades de XESS, recomendado si se está trabajando con
tarjetas de desarrollo de este fabricante, o bien instalar el driver de manera
aislada mediante la utilidad PORT95NT.EXE, disponible en el CD anexo.
™ Crear un directorio y copiar en él los programas EricASM y EricMON. Para
evitar problemas, es recomendable que todos los ficheros generados por el
ensamblador estén en el mismo directorio.
™ Copiar el fichero LCD.ASM en el directorio anteriormente creado.
™ Copiar el fichero ERIC.BIT en el directorio anteriormente creado.
107
108
6.2.
Prueba final
Conexión del LCD al ERIC
El LCD, dispone de 16 señales distribuidas a lo largo de un conector de 8x2 pines. La
siguiente tabla recoge la descripción de cada una de estas señales, los terminales
correspondientes al LCD y su conexión con las señales del ERIC.
PIN NOMBRE
VSS
1
VDD
2
VO
3
RS
4
R/W
5
E
6
DB0
7
DB1
8
DB2
9
DB3
10
DB4
11
DB5
12
DB6
13
DB7
14
A
15
K
16
ERIC
GND
A0
WR
IO
D0
D1
D2
D3
D4
D5
D6
D7
-
XSA-50
GND
+5
GND
P66
P94
P93
P77
P79
P80
P83
P84
P85
P86
P87
-
DESCRIPCION
GND
+5
Aunque variable, funciona conectada a GND
Selección de los registros IR o DR
Lectura/Escritura
Habilitación del dispositivo
D0 del bus de datos
D1 del bus de datos
D2 del bus de datos
D3 del bus de datos
D4 del bus de datos
D5 del bus de datos
D6 del bus de datos
D7 del bus de datos
Iluminación +. No es obligatorio.
Iluminación -. No es obligatorio.
Tabla 18: Conexiones entre el LCD y la XSA-50
Aunque V0 se puede conectar a un potenciómetro para ajustar su tensión, la realidad
es que prácticamente está a un potencial muy próximo a GND, por lo que en esta prueba
se ha decidido conectarlo directamente a masa. Los terminales 15 y 16 del LCD son
utilizados para la iluminación general y su conexión es opcional.
El LCD dispone de dos registros: el IR o registro de instrucciones y el DR o registro
de datos. A través del IR, la CPU envía los comandos al LCD: limpiar el visualizador,
posicionar el cursor en una posición, hacer parpadear un carácter, etc. A través del DR
la CPU envía los datos que desea representar.
Es posible encontrar más información sobre el LCD y sobre su programación en el
apartado de documentación del CD adjunto.
Ejecución de la prueba
6.3.
109
Ejecución de la prueba
Los pasos a realizar para ejecutar la prueba son:
™ Ensamblar el fichero fuente LCD.ASM, para obtener un fichero BYTE que
pueda ser descargado en el ERIC, mediante la ejecución de la siguiente
sentencia:
ericasm -Fbyte –L lcd.asm
™ Descargar el fichero ERIC.BIT en la FPGA. Para ello podemos utilizar la
utilidad gráfica GXLOAD o bien el comando en línea XSLOAD. En este último
caso, la sintaxis completa del comando es:
xsload –P 1 –fpga eric.bit
™ Arrancar el programa EricMON.
™ Una vez dentro, cargar el fichero LCD y proceder a su ejecución en modo RUN.
Aunque es posible la ejecución en el modo STEP, no es recomendable dado los
numerosos bucles programados que haría muy tedioso el seguimiento del
programa.
™ Si el programa se ejecuta correctamente deberemos ver el siguiente mensaje:
Procesador ERIC
™ Si durante la visualización del mensaje, generamos una interrupción pulsando la
tecla I, podemos ver el siguiente mensaje:
INTERRUPCION
Capítulo 7
Conclusiones y líneas futuras
7.1.
Conclusiones
Tal como se describía en los objetivos del proyecto, se ha realizado el diseño e
implementación del diseño de un procesador didáctico, con el fin de valorar la
viabilidad de su implantación en una asignatura de electrónica, dentro del plan de
estudios de un Ingeniero de Telecomunicaciones. Adicionalmente, se han desarrollado
dos programas, creo que muy útiles, como herramienta de apoyo que facilitará alcanzar
este objetivo por parte del alumnado.
Otro de los objetivos marcados por el autor, ha sido también exponer el trabajo del
diseño de la manera más didáctica posible, para que ésta sirva de base para la acción
formativa por parte del profesor, facilitando el desglose controlado de información a
partir de sus numerosos apéndices.
La conclusión de todo el proyecto es que, aunque sin ser el diseño de un procesador
didáctico una tarea que represente un reto especialmente complicado, su ejecución
implica un gran número de horas de trabajo que pueden superar ampliamente el tiempo
disponible en un laboratorio estimadas alrededor de 60 horas. Otro inconveniente, es el
gran número de aplicaciones y conceptos que ha de manejar el alumno para poder
acometer el diseño, puesto que ha de tener una base relativamente buena en el
conocimiento del VHDL, así como conocer las distintas herramientas del entorno de
111
112
Conclusiones y líneas futuras
desarrollo: captura de esquemas, conocer las librerías de la Spartan-II, detectar los
problemas de síntesis, saber entender los informes, etc.
Todos estos inconvenientes, pueden reducirse con una adecuada introducción por
parte del profesor sobre algunos puntos teóricos especialmente delicados. A
continuación describo algunos, que a mi entender precisan de esta atención:
™ Describir de manera esquemática, pero clara, los recursos disponibles en las
FPGAs, en concreto la posibilidad del disponer de bloques BRAM, su
correspondiente primitiva en los esquemáticos y sus posibilidad de
configuración. Si el alumno desconoce este recurso y el modo de utilizarlo,
puede hacerle perder mucho tiempo, puesto que, la síntesis VHDL no infiere
bien las descripciones de memorias síncronas, o bien hace uso de las LUT
haciendo inviable el proyecto por falta de recursos.
™ Suministrar un juego de instrucciones ya definido tanto a nivel funcional como
de codificación binaria. El desarrollar por uno mismo un juego de instrucciones
es algo realmente didáctico, pero que requiere una gran cantidad de tiempo y
modificaciones constantes en el diseño. Si adicionalmente, se quiere reducir más
el tiempo de diseño, es posible reducir el juego de instrucciones, eligiendo unas
cuantas de cada grupo, ya que, instrucciones similares incrementan la
complejidad del diseño pero no aportan un valor especialmente didáctico. Hay
que recordar, que se puede desarrollar un microprocesador funcional con sólo 2
instrucciones.
™ Pasar de un conocimiento del VHDL, desde un marco teórico a otro enfocado a
la síntesis, también acarrea ciertas dificultades. Es importante que el alumno
sepa escribir código VHDL que el sintetizador sepa inferir fácilmente. Esto es
especialmente importante a la hora de describir las máquinas de estados. Una
introducción adecuada sobre estas limitaciones puede ahorrar mucho tiempo. En
el CD adjunto se añaden dos guías orientadas en este sentido.
™ Otro aspecto importante, que se puede tener en cuenta para reducir los tiempos
de implantación, sería el establecer un orden en el diseño haciendo algunas
recomendaciones sobre como acometer determinadas partes del diseño. Por
ejemplo, la implementación de la ROM no debe acometerse desde un principio
Conclusiones
113
como un bloque RAM de la Spartan-II, sino que, es más recomendable definirla
de tal manera que se puedan escribir pequeños programas.
Al margen de estos problemas a nivel formativo que puedan surgir, hay otros relativos
al equipamiento que también deberían tenerse en cuenta:
™ La placa XSA-50, dispone de una gran cantidad de periferia que, en el diseño
tratado en este proyecto, lejos de ser una ventaja es más bien un inconveniente.
Documentarse y entender las peculiaridades de la tarjeta, requiere una cantidad
considerable de tiempo. Por otra parte la conexión de dispositivos externos es
bastante engorrosa. Por estos motivos, es aconsejable el uso de tarjeta de
desarrollo más simple, mejor conectorizada y que simplemente posea la FPGA
requerida. Las placas probadas de Digilent, propuestas por el tutor de este
proyecto, son una buena opción.
™ El entorno de desarrollo WebPack de Xilinx, tiene a su favor el ser un programa
gratuito y con funcionalidad más que suficiente para acometer diseños como el
abordado en este proyecto. En su contra, la exigencia de que el equipamiento
informático sea de última generación, ya que por defecto demanda una máquina
equipada con Windows XP, cuyos requisitos mínimos puede que no se
corresponda con las dotaciones actuales de los laboratorios de prácticas. Por otro
lado, aunque se cumplan estos mínimos, es preciso disponer de un ordenador
bien equipado para que las fases de ensayo, prueba y error sea lo más ágiles
posibles, ya que al contrario dilataríamos aun más el tiempo de desarrollo.
™ Otro posible inconveniente es el uso del simulador ModelSIM. La versión de
evaluación utilizada en este proyecto, está limitada a 500 líneas de código. Para
el autor, esto ha sido más que suficiente ya que se han hecho muy pocas
simulaciones y se ha utilizado básicamente el EricMON para la depuración de la
Unidad de Control, que es la parte más compleja del sistema. Si el alumno
deseará hacer un uso más intensivo del simulador, es probable que la limitación
de líneas acarrease un problema. En este sentido, tal vez fuese aconsejable
estudiar la viabilidad de convertir este proyecto al entorno Linux por las
siguiente razones:
114
Conclusiones y líneas futuras
ƒ
El sistema operativo es gratuito y menos exigente a nivel de máquina.
ƒ
Es posible disponer de gran cantidad de compiladores y material de libre
distribución, entre ellos simuladores VHDL.
ƒ
Es posible reprogramar con relativa facilidad los programas del proyecto.
La adaptación del EricASM es prácticamente trivial y el EricMON se
podría realizar sin muchos problemas, puesto que también existen
fuentes de las XSTOOLS en Linux que podría servir de base para la
adaptación.
El único problema a este posible cambio, es que no hay una versión de WebPACK
para Linux, y que habría que utilizar alguna de las variantes no gratuitas como ISE
Foundation.
Para cerrar este apartado, la conclusión final es que sí es viable, la implantación de la
tarea de desarrollo de un procesador didáctico, siempre que se haga una adecuada
planificación de la asignatura. De hecho, si analizamos los planes de estudio de algunas
ingenierías que podemos encontrar en la red, podemos observar que la idea de diseñar
un microprocesador sobre una FPGA ya ha sido llevada a la práctica, por lo que hay que
suponer su viabilidad.
Líneas futuras
7.2.
115
Líneas futuras
Aunque el proyecto, en sí, es de suficiente complejidad para el objetivo perseguido, es
posible incluir nuevos diseños como complemento al ERIC con el fin de mejorarlo, y
dedicarlo a otros fines que los inicialmente propuestos. En este sentido, se pueden
apuntar líneas futuras como:
™ Integrar en la misma FPGA bloques que mejoren las comunicaciones con el
exterior, como pueden ser un controlador de VGA, un controlador de
comunicaciones serie, decodificadores de teclado, etc.
™ Aumentar las prestaciones del procesador, incorporando nuevas instrucciones,
nuevos modos de direccionamiento y un mayor nivel de manejo de
interrupciones.
™ Hacer una versión de ERIC con capacidad de procesado en pipeline.
A nivel software también es posible mejorar las prestaciones del diseño, incorporando
mayores prestaciones al EricMON como pueden ser:
™ Simular un teclado y un terminal de texto, que permita interaccionar con el
ERIC como si tuviésemos conectado físicamente estos dispositivos. Esto
facilitaría la entrada y salida de datos con los programas diseñados, aumentando
su valor didáctico.
™ Posibilitar el visionado de las zonas de memoria RAM y STACK sin necesidad
de destruir los datos, y poder descargarlos a disco para su análisis en otras
aplicaciones.
™ Posibilitar la descargar los datos obtenidos en modo STEP y grabarlos en un
fichero para su estudio posterior.
™ Incluir algún sistema de puntos de ruptura en modo STEP, del mismo modo que
existe en los depuradores, tomando como base los valores que van tomando los
datos visualizados en pantalla.
Capítulo 8
Presupuesto
Material Hardware
CANT
1
1
1
1
1
1
CONCEPTO
Ordenador Pentium IV 2,4 Ghz, 256 Mb, 80 G, monitor 17"
Tarjeta de desarrollo XSA-50 de XESS
Fuente de alimentación de 2A, 12 V
LCD
Cables puerto paralelo, alimentación y del LCD
Material fungible (papel, toner, CDs, conectores, ...)
TOTAL MATERIAL HARDWARE
PRECIO
UNIDAD
1.200
150
30
40
60
120
PARCIAL
1.200
150
30
40
60
120
1.600 €
Material Software
CANT
1
1
1
1
1
CONCEPTO
Sistema operativo Windows XP
Microsoft Office XP
Compilador Microsoft Visual C++ 6.0
Xilinx WebPACK 5.2.
Compilador GNU de C
TOTAL MATERIAL SOFTWARE
117
PRECIO
UNIDAD
180
360
600
-
PARCIAL
180
360
600
1.140 €
118
Presupuesto
Mano de obra de ingeniería
CANT
100
16
230
40
40
16
100
1
CONCEPTO
Estudio, documentación y análisis del proyecto
Estudio del WebPACK
Diseño e implementación de ERIC
Programación de EricMON
Adaptación de AS31 a EricASM
Estudio y programación del test del LCD
Redacción de la memoria
Conceptos varios (encuadernación, viajes, etc.)
TOTAL MANO DE OBRA DE INGENIERÍA
PRECIO
€/HORA
30
30
30
30
30
30
30
150
PARCIAL
3.000
480
6.900
1.200
1.200
480
3.000
150
16.410 €
Presupuesto final
CONCEPTO
Material Hardware
Material Software
Mano de obra de ingeniería.
PARCIALES
1.600
1.140
16.410
19.150 €
TOTALES
TOTAL + IVA (16%)
22.214 €
IVA 16%
256
182
2.626
3.064 €
Referencias
[1]
L. Jacobo Álvarez Ruiz de Ojeda. Diseño de aplicaciones mediante PLDs y
FPGAs. Tórculo Edicións, 2001.
[2]
Fernando Pardo Carpio, José A. Boluda Grau. VHDL : lenguaje para síntesis
y modelado de circuitos. RAMA 1999.
[3]
E. Mandado. Procesadores programables. El microprocesador. Boixareu
Editores. 1980.
[4]
Michel A. Lynch. Microprogrammed State Machine Design. CRC Press, cop.
1993.
[5]
David A. Patterson, John L. Hennessy. Estructura y diseño de computadores.
Editorial Reverté, S.A. 2000.
[6]
J. Frutos Redondo, R. Rico López. Arquitectura de computadores. Servicio de
publicaciones de la Universidad de Alcalá de Henares. 1995.
[7]
M. Morris Mano. Ingeniería computacional: Diseño del hardware. PrenticeHall International, 1983.
[8]
Antonio
García
Guerra.
Sistemas
Digitales:
Ingeniería
microprocesadores: Servicio de publicaciones de la ETSIT-UPM.
En formato electrónico PDF y disponibles en el CD adjunto:
119
de
los
120
Presupuesto
[9]
Xilinx, Inc. ISE 5 In-Depth Tutorial.
[10] Xilinx, Inc. Libraries Guide.
[11] Xilinx, Inc. Synthesis and Simulation Design Guide.
[12] Xilinx, Inc. Spartan and SpartanXL Families FPGA.
[13] Xilinx, Inc. Programmable Logic Design Quick Start Hand Book.
[14] Actel, Corp. Actel HDL Coding: Style Guide.
[15] Xess, Corp. Introduction to WebPACK 5.2 for FPGAs.
[16] Xess, Corp. XSA Parallel Port Interface.
[17] Xess, Corp. XSA Board 1.0 User Manual.
[18] Xess, Corp. XSTOOLs V4.0 User Manual.
[19] Peter J. Ashenden. The VHDL Cookbook. Dept. Computer Science University
of Adelaide South Australia.
[20] Silicore, Corp. SLC1657 8-Bit Risc µC Core: Technical Reference Manual.
[21] PowerTIP. PC 1602 H
[22] Cristalfontz America, Inc. LCD PC 1602 H
Contenido del CD
Esta memoria se completa con el CD adjunto. El contenido del CD-ROM esta
estructurado en los siguientes directorios, dónde podemos encontrar:
™ Proyecto
ƒ
ERIC. Ficheros correspondientes al diseño del ERIC realizado con el
programa Webpack 5.2.
ƒ
EricASM. Ficheros correspondientes al diseño del ensamblador.
ƒ
Xess. Ficheros de Xess, librerías y utilidades para la compilación del
programa EricMON, realizado con el programa Microsoft Visual C++.
ƒ
Prueba. Ficheros necesarios para la realización de la prueba final.
™ Programas
ƒ
DJGPP. Compilador de C/C++ de libre distribución utilizado para la
compilación del EricASM.
ƒ
XSTOOLS. Incluye la versión 4.0 de las utilidades XSTOOLS utilizadas
en este proyecto. Se incluyen también los ficheros fuente para Windows,
sobre las que se ha desarrollado EricMON, y los ficheros fuente para
Linux por si fuesen necesarios en un futuro. En el caso de no instalar las
XSTOOLS, se incluye la utilidad para la instalación del driver necesario
para poder trabajar con el EricMON (PORT95NT.EXE)
ƒ
WebPACK 5.2. Entorno de desarrollo utilizado para el diseño del ERIC.
ƒ
ConTEXT. Editor de texto para Windows de libre distribución, sobre el
que se puede implementar un IDE. Se incluye el fichero de
121
122
Presupuesto
configuración, con las palabras reservadas de ERIC, para que el
programa las resalte en color.
™ Memoria. Incluye la presente memoria en formato PDF y Word XP.
™ Presentación. Incluye la presentación del proyecto en formato PowerPoint XP.
™ Documentación. Incluye la documentación utilizada para la realización de este
proyecto, en formato PDF.
™ Utilidades. Incluye una ayuda para VHDL y las hojas de cálculo utilizadas para
describir el juego de instrucciones y las tablas necesarias para el cálculo de los
vectores de señal, de cada una de las instrucciones del ERIC.
Apéndice A
Juego de instrucciones (ISA) del ERIC
Antes de adentrarnos en la descripción del juego de instrucciones del ERIC, es preciso
echar un vistazo a algunos aspectos sobre la arquitectura del procesador con el fin de
poder hacer un uso adecuado de las instrucciones.
A.1.
Registros internos
ERIC dispone de tres registros accesibles por el usuario que son:
™ A
El acumulador.
™ B
El
registro
auxiliar
con
el
que
se
realizan
operaciones
lógicas/aritméticas. También se utiliza como registro índice en algunas
instrucciones de transferencia.
™ F
Registro de banderas (flags). Este registro está compuesto por las
banderas de acarreo (C), zero (Z) y overflow (O)
™ IER
A.2.
Registro para el control de las interrupciones.
Memoria
ERIC dispone de los siguientes bancos de memoria:
™ RAM
256 bytes (0x00 … 0xFF).
™ PILA
64 bytes (0x00 … 0x3F).
™ ROM
2048 o 4096 bytes dependiendo del tipo de FPGA utilizada (0x000 …
0x7FF para XC2S30 ó 0x000 … 0xFFF para XC2S100).
123
124
Juego de instrucciones (ISA) del ERIC
A.3.
Modos de direccionamiento
El juego de instrucciones de ERIC, maneja varios modos de direccionamiento que
son codificados del siguiente modo:
™ addr4
Representados por los bits de menos peso de la propia instrucción. Ej.IN A, 0x3 se codifica como 0x23 donde 0x2 indica la instrucción IN y
0x3 indica la dirección addr4 (0 0 1 1).
™ addr8
Se codifica con la ayuda de un segundo byte que acompaña a la
instrucción. Ej.- MOV A, 0xAA se compone de un primer byte 0xD0
que representa la instrucción y un segundo byte, 0xAA que representa
la dirección addr8.
™ addr12 Es una combinación de los modos anteriores. Los 4 bits de mayor peso
de addr12 van codificados en los bits de menor peso de la instrucción.
El resto de addr12 va en el segundo byte. Ej.- AJMP 0x8FF se
descompone en 0x28 (0x2 & 0x8) y 0xFF para el segundo byte.
™ rel
Representado por un segundo byte en complemento a 2. Se pueden
representar saltos relativos de +128/-127
™ #dato
A.4.
Representado por un segundo byte.
Reset
Cuando ERIC recibe la señal de reset, se ponen a 0 todos los registros y memorias,
salvo la memoria ROM, que sólo se pone a 0 durante la operación de encendido. Las
interrupciones son deshabilitadas. El contador de programa apunta en este momento a
la dirección 0x002.
A.5.
Interrupciones
Para poder atender las interrupciones, es necesario por un lado poner a 1 el registro
de interrupción (IER) y por otro incluir la instrucción de salto absoluto a la rutina de
servicio, en la posición 0x000 de la memoria ROM. Cuando ERIC acepta una
interrupción el PC irá buscar una instrucción a esa posición.
Juego de instrucciones (ISA) del ERIC
125
Operaciones Aritméticas
HEX
40
41
42
43
54
55
NEMOCTÉCNICO
ADDC A,B
SUBC A,B
INC A
DEC A
INC B
DEC B
DESCRIPCIÓN
C1
01
01
01
01
01
01
C2
00
00
00
00
01
01
C3
0000
0001
0010
0011
0100
0101
BYTES CICLOS
C1
01
01
01
01
01
C2
00
00
00
00
00
C3
0110
0111
1000
1001
1010
BYTES CICLOS
4B RLC A
(An + 1) <- (An)
(A0) <- (C)
(C) <- (A7)
01
00
4C RRC A
(An) <- (An + 1)
(A7) <- (C)
(C) <- (A0)
01
(A) <- (A) + (B) + (C)
(A) <- (A) - (B) - (C)
(A) <- (A) + 1
(A) <- (A) - 1
(B) <- (B) + 1
(B) <- (B) - 1
1
1
1
1
1
1
3
3
3
3
3
3
C Z O
x x x
x x x
x
x
x
x
MODO DIR.
MODO DIR.
REGISTRO
REGISTRO
REGISTRO
REGISTRO
REGISTRO
REGISTRO
Operaciones Lógicas
HEX
46
47
48
49
4A
NEMOCTÉCNICO
AND A,B
OR A,B
XOR A,B
CLR A
CPL A
DESCRIPCIÓN
(A) <- (A) * (B)
(A) <- (A) v (B)
(A) <- (A) A (B)
(A) <- 0
(A) <- /(A)
1
1
1
1
1
3
3
3
3
3
C Z O
x
x
x
1
x
1011
1
3
x
REGISTRO
00
1100
1
3
x
REGISTRO
C1
01
01
01
00
00
C2
11
11
11
00
00
C3
1101
1110
1111
0001
0010
BYTES CICLOS
C1
00
00
C2
10
11
C3
xxxx
xxxx
BYTES CICLOS
00
00
00
REGISTRO
REGISTRO
REGISTRO
REGISTRO
REGISTRO
Manipulación de Flags
HEX
7D
7E
7F
01
02
NEMOCTÉCNICO
CLR C
SET C
CPL C
ION
IOF
DESCRIPCIÓN
(C) <- 0
(C) <- 1
(C) <- /(C)
(IEN) <- 1
(IEN) <- 0
1
1
1
1
1
3
3
3
2
2
C Z O
0
1
x
MODO DIR.
REGISTRO
REGISTRO
REGISTRO
IMPLICITO
IMPLICITO
Transferencia de datos
HEX NEMOCTÉCNICO
2# IN A,addr4
3# OUT addr4, A
13 POP A
04 PUSH B
14 POP B
05 PUSH F
15 POP F
MOV A,#dato
MOV B,#dato
MOV A,addr8
MOV B,addr8
MOV addr8,A
MOV addr8,B
MOV A,@B
MOVX A,@B
MOVX A,addr12
C Z O
MODO DIR.
1
1
3
4
INMEDIATO
0011
1
3
IMPLICITO
01
0011
1
3
IMPLICITO
00
00
0100
1
3
IMPLICITO
00
01
0100
1
3
IMPLICITO
00
00
0101
1
3
IMPLICITO
00
01
0101
1
3
IMPLICITO
00
00
01
01
01
01
10
10
11
0000
0001
0000
0001
0010
0011
0001
0010
xxxx
2
2
2
2
2
2
1
1
2
2
2
3
3
3
3
4
4
3
INMEDIATO
(A) <- (addr12)
11
11
11
11
11
11
11
11
11
(addr4) <- (A)
((SP)) <- (A)
(SP) <- (SP) + 1
(SP) <- (SP) - 1
((SP)) <- (A)
((SP)) <- (B)
(SP) <- (SP) + 1
(SP) <- (SP) - 1
((SP)) <- (B)
((SP)) <- (Flags)
(SP) <- (SP) + 1
(SP) <- (SP) - 1
((SP)) <- (Flags)
03 PUSH A
C0
C1
D0
D1
D2
D3
E1
E2
F#
DESCRIPCIÓN
(A) <- (addr4)
(A) <- dato
(B) <- dato
(A) <- (addr8)
(B) <- (addr8)
(addr8) <- A
(addr8) <- B
(A) <- ((B))
(A) <- ((B))
INMEDIATO
INMEDIATO
DIRECTO
DIRECTO
DIRECTO
DIRECTO
INDIRECTO
INDIRECTO
DIRECTO
Flujo de programa
HEX NEMOCTÉCNICO
DESCRIPCIÓN
C1
C2
C3
80 JZ rel
(PC) <- (PC) + 2
si (A) = 0
entonces (PC) + rel
10
00
0000
2
3
RELATIVO
81 JNZ rel
(PC) <- (PC) + 2
si (A) != 0
entonces (PC) + rel
10
00
0001
2
3
RELATIVO
82 JC rel
(PC) <- (PC) + 2
si (C) = 1
entonces (PC) + rel
10
00
0010
2
3
RELATIVO
83 JNC rel
(PC) <- (PC) + 2
si (C) = 0
entonces (PC) + rel
10
00
0011
2
3
RELATIVO
84 JO rel
(PC) <- (PC) + 2
si (OV) = 0
entonces (PC) + rel
10
00
0100
2
3
RELATIVO
85 JNO rel
(PC) <- (PC) + 2
si (OV) != 0
entonces (PC) + rel
10
00
0101
2
3
RELATIVO
88 SJMP rel
(PC) <- (PC) + rel
10
00
1000
2
3
RELATIVO
90 RET
(SP) <- (SP)-1
(PCl) <- ((SP))
(SP) <- (SP)-1
(PCh) <- ((SP))
10
01
0000
1
6
IMPLICITO
BYTES CICLOS
C Z O
Tabla 19: Resumen del juego de instrucciones del ERIC
MODO DIR.
126
Juego de instrucciones (ISA) del ERIC
ACALL
addr12
Función:
Llamada absoluta
Descripción:
Llamada en modo de direccionamiento absoluto a una subrutina. La dirección de
destino (addr12) se construye con los 4 bits menos significativos de la instrucción,
unido al segundo byte que le acompaña.
Bytes:
2
Ciclos de reloj: 6
Codificación:
10 10 addr(11:8) | addr(7:0)
Operaciones:
((SP))
(SP)
((SP))
(SP)
ADDC
A, B
Función:
Suma con acarreo
Descripción:
ADDC suma simultáneamente el contenido de los registros A, B y el flag C. El
resultado se deposita en A.
Flags:
C, OV y Z
Bytes:
1
←
←
←
←
HEX [A#][##]
(PCh)
(SP) + 1
(PCl)
(SP) + 1
Ciclos de reloj: 3
Codificación:
01 00 0000
Operaciones:
(A)
AJMP
addr12
Función:
Salto absoluto
Descripción:
AJMP transfiere la ejecución del programa a la dirección apuntada. La dirección de
destino “addr12” se construye con los 4 bits menos significativos de la instrucción,
unidos al segundo byte que acompaña. Por lo tanto, esta instrucción puede direccionar
hasta 4096 bytes.
Bytes:
2
←
HEX [40]
(A) + (B) + (C)
Ciclos de reloj: 3
Codificación:
10 11
addr(11:8) | addr(7:0)
HEX [B#][##]
Operaciones:
(PC)
←
AND
A, B
Función:
Función lógica AND.
Descripción:
AND realiza la función lógica bit a bit entre los operados A y B.
Flags:
Z
Bytes:
1
addr12
Ciclos de reloj: 3
Codificación:
01 00 0110
HEX [46]
Juego de instrucciones (ISA) del ERIC
Operaciones:
(A)
←
CLR
A
Función:
Limpia el acumulador
Descripción:
CLR pone a 0 el registro del acumulador
Flags:
Z
Bytes:
1
127
(A) ^ (B)
Ciclos de reloj: 3
Codificación:
01 00 1001
Operaciones:
(A)
CLR
C
Función:
Limpia el flag de C.
Descripción:
CLR pone a 0 el flag de C.
Flags:
C
Bytes:
1
←
HEX [49]
0
Ciclos de reloj: 3
Codificación:
01 00 1001
Operaciones:
(C)
CPL
A
Función:
Complementa el acumulador
Descripción:
CPL invierte el contenido del acumulador.
Flags:
C
Bytes:
1
←
HEX [7D]
0
Ciclos de reloj: 3
Codificación:
01 00 1010
Operaciones:
(A)
CPL
C
Función:
Complementa el flag de acarreo.
Descripción:
CPL invierte el contenido del flag de acarreo.
Flags:
C
Bytes:
1
←
HEX [4A]
/(A)
Ciclos de reloj: 3
Codificación:
01 00 1111
Operaciones:
(C)
DEC
A
Función:
Decrementa el acumulador.
←
HEX [7F]
/(C)
128
Juego de instrucciones (ISA) del ERIC
Descripción:
DEC disminuye en una unidad el contenido del registro acumulador. Cuanto el valor sea
0x00, esto dará lugar a un desbordamiento con el consiguiente resultado 0xFF.
Flags:
Z
Bytes:
1
Ciclos de reloj: 3
Codificación:
01 00 0011
Operaciones:
(A)
DEC
B
Función:
Los mismo que DEC A pero con el registro B.
Codificación:
01 01 0101
Operaciones:
(B)
←
←
HEX [43]
(A) - 1
HEX [55]
(B) - 1
HALT
Función:
Detiene el procesador.
Descripción:
HALT detiene la ejecución del procesador. Solo es posible salir de este estado
activando la señal reset del procesador.
Bytes:
1
Ciclos de reloj: 2
Codificación:
00 00 1111
HEX [0F]
IN
A, addr4
Función:
Lee de un puerto I/O.
Descripción:
Copia el contenido del puerto de entrada/salida apuntada por “addr4” en el acumulador.
Bytes:
1
Ciclos de reloj: 3
Codificación:
00 10 addr(3:0)
Operaciones:
(A)
INC
A
Función:
Incrementa el acumulador.
Descripción:
INC aumenta en una unidad el contenido del acumulador. Cuanto el valor sea 0xFF,
esto dará lugar a un desbordamiento con el consiguiente resultado 0x00.
Flags:
Z
Bytes:
1
←
HEX [2#]
(addr4)
Ciclos de reloj: 3
Codificación:
01 00 0010
Operaciones:
(A)
INC
B
Función:
Los mismo que INC A pero con el registro B.
←
HEX [42]
(A) + 1
Juego de instrucciones (ISA) del ERIC
Codificación:
01 00 0100
Operaciones:
(B)
←
129
HEX [54]
(B) + 1
IOF
Función:
Desactiva las interrupciones.
Descripción:
IOF imposibilita que el procesador sea interrumpido por una IRQ.
Bytes:
1
Ciclos de reloj: 2
Codificación:
00 00 0010
Operaciones:
(IEN)
←
HEX [02]
1
ION
Función:
Activa las interrupciones.
Descripción:
ION posibilita que el procesador sea interrumpido por una IRQ.
Bytes:
1
Ciclos de reloj: 2
Codificación:
00 00 0001
Operaciones:
(IEN)
JC
rel
Función:
Salto si C está a 1.
Descripción:
JZ salta a la dirección relativa apuntada por “rel” si el flag de carry está activado (1). En
el caso contrario, continúa con la instrucción siguiente. La dirección “rel” viene en el
segundo byte que acompaña a la instrucción.
Bytes:
2
←
HEX [01]
1
Ciclos de reloj: 3
Codificación:
10 00 0010
| rel
Operaciones:
(PC)
(PC)
(PC) + rel
(PC) + 2
JNC
rel
Función:
Similar a JC salvo que salta si C está a 0.
Codificación:
10 00 0011
| rel
Operaciones:
(PC)
(PC)
(PC) + rel
(PC) + 2
JNO
rel
Función:
Similar a JC salvo que salta si OV está a 0.
Codificación:
10 00 0101
| rel
Operaciones:
(PC)
(PC)
(PC) + rel
(PC) + 2
←
←
←
←
←
←
HEX [82][##]
si C=1
si C=0
HEX [83][##]
si Z=0
si Z=1
HEX [85][##]
si OV=0
si OV=1
130
Juego de instrucciones (ISA) del ERIC
JNZ
rel
Función:
Similar a JC salvo que salta si Z está a 0.
Codificación:
10 00 0001
| rel
Operaciones:
(PC)
(PC)
(PC) + rel
(PC) + 2
JO
rel
Función:
Similar a JC salvo que salta si OV está a 1.
Codificación:
10 00 0100
| rel
Operaciones:
(PC)
(PC)
(PC) + rel
(PC) + 2
JZ
rel
Función:
Similar a JC salvo que salta si Z está a 1.
Codificación:
10 00 0000
| rel
Operaciones:
(PC)
(PC)
(PC) + rel
(PC) + 2
MOV
A, #dato
Función:
Mueve byte de memoria RAM.
Descripción:
Copia en el acumulador, el valor de “dato”.
Bytes:
2
←
←
←
←
←
←
HEX [81][##]
si Z=0
si Z=1
HEX [84][##]
si OV=1
si OV=0
HEX [80][##]
si Z=1
si Z=0
Ciclos de reloj: 2
Codificación:
11 00 0000 | dato
Operaciones:
(A)
MOV
A, @B
Función:
Mueve byte de memoria RAM.
Descripción:
Copia en el acumulador, el dato de la posición de memoria apuntada en el contenido del
registro B.
Bytes:
1
←
HEX [C0][##]
dato
Ciclos de reloj: 4
Codificación:
11 10 0001
Operaciones:
(A)
MOV
A, addr8
Función:
Mueve byte de memoria RAM.
Descripción:
Copia en el acumulador, el contenido de la posición indicada en “addr8”. Dicha
información se obtiene del segundo byte.
Bytes:
2
←
HEX [E1][##]
((B))
Juego de instrucciones (ISA) del ERIC
131
Ciclos de reloj: 3
Codificación:
11 00 0000
Operaciones:
(A)
MOV
addr8, A
Función:
Mueve byte de memoria RAM.
Descripción:
Copia el contenido del acumulador en la posición de memoria indicada en “addr8”.
Dicha información se obtiene del segundo byte.
Bytes:
2
←
HEX [C0][##]
(addr8)
Ciclos de reloj: 3
Codificación:
11 01 0010
HEX [D2][##]
Operaciones:
(addr8) ←
MOV
addr8, B
Función:
Similar a MOV addr8, A pero en este caso con el registro B.
Codificación:
11 01
Operaciones:
(addr8) ←
MOV
B, #dato
Función:
Similar a MOV A, #dato pero en este caso con el registro B.
Codificación:
11 00
0001
Operaciones:
(B)
←
MOV
B, addr8
Función:
Similar a MOV A, addr8 pero en este caso con el registro B.
Codificación:
11 01
0001
Operaciones:
(B)
←
MOVX
A, @B
Función:
Similar a MOV A, @B. En este caso se accede a una posición de la ROM comprendida
(A)
0011
HEX [D3][##]
(B)
HEX [C1][##]
dato
HEX [D1][##]
(addr8)
entre 0x00 y 0xFF.
Codificación:
11 10
0010
Operaciones:
(A)
←
MOVX
A, addr12
Función:
Mueve byte de memoria ROM.
Descripción:
Copia en el acumulador, el contenido de la posición indicada en “addr12”. Dicha
dirección se forma con el segundo byte.
Bytes:
2
Ciclos de reloj: 3
HEX [E2][##]
((B))
132
Juego de instrucciones (ISA) del ERIC
Codificación:
11 11
add(11:8) | add(7:0)
Operaciones:
(A)
←
HEX [F#][##]
(addr12)
NOP
Función:
No operación.
Descripción:
NOP consume el tiempo de 2 ciclos máquina sin hacer nada.
Bytes:
1
Ciclos de reloj: 2
Codificación:
00 00 0000
Operaciones:
(PC)
OR
A, B
Función:
Función lógica OR.
Descripción:
OR realiza la función lógica bit a bit entre los operados A y B.
Flags:
Z
Bytes:
1
←
HEX [00]
(PC) + 1
Ciclos de reloj: 3
Codificación:
01 00 0111
Operaciones:
(A)
OUT
addr4, a
Función:
Escribe en un puerto I/O.
Descripción:
Copia el contenido del acumulador en el puerto de entrada/salida apuntada por “addr4”.
Bytes:
2
←
HEX [47]
(A) v (B)
Ciclos de reloj: 4
Codificación:
00 11 addr(3:0)
HEX [3#]
Operaciones:
(addr4) ←
POP
A
Función:
Extrae un dato de la pila y lo guarda en el acumulador.
Descripción:
POP extrae el dato, apuntado por SP, de la pila. Antes de la operación, el puntero SP se
decrementa y posteriormente se obtiene un valor que se guarda en el acumulador.
Bytes:
1
(A)
Ciclos de reloj: 3
Codificación:
00 01 0011
HEX [13]
Operaciones:
(SP)
←
((SP)) ←
POP
B
Función:
Similar a POP A, pero en este caso con el registro B.
(SP) - 1
(A)
Juego de instrucciones (ISA) del ERIC
133
Codificación:
00 01 0100
HEX [14]
Operaciones:
(SP)
←
((SP)) ←
POP
F
Función:
Similar a POP A, pero en este caso con F.
Codificación:
00 01 0101
Operaciones:
(SP)
←
((SP)) ←
PUSH
A
Función:
Guarda el contenido del acumulador en la pila.
Descripción:
PUSH guarda el contenido del acumulador en la posición de la pila apuntado por SP.
Posteriormente incrementa el valor del puntero SP.
Bytes:
1
(SP) - 1
(B)
HEX [15]
(SP) - 1
(F)
Ciclos de reloj: 3
Codificación:
00 00 0011
Operaciones:
((SP))
(SP)
PUSH
B
Función:
Similar a PUSH A, pero en este caso con el registro B.
Codificación:
00 00 0100
Operaciones:
((SP))
(SP)
PUSH
F
Función:
Similar a PUSH A, pero en este caso con el registro F.
Codificación:
00 00 0101
Operaciones:
((SP))
(SP)
←
←
←
←
←
←
HEX [03]
(A)
(SP) + 1
HEX [04]
(B)
(SP) + 1
HEX [05]
(F)
(SP) + 1
RET
Función:
Retorna de una subrutina.
Descripción:
RET extrae de la pila la dirección de retorno. Al ser la dirección de 12 bits es necesario
realizar dos lecturas.
Bytes:
1
Ciclos de reloj: 6
Codificación:
10 01 0000
Operaciones:
(SP)
←
(PCl) ←
(SP)
←
(PCh) ←
HEX [90]
(SP) - 1
((SP))
(SP) - 1
((SP))
134
Juego de instrucciones (ISA) del ERIC
RETI
Función:
Retorna de una interrupción.
Descripción:
RETI extrae de la pila la dirección de retorno. Al ser la dirección de 12 bits es necesario
realizar dos lecturas. Se habilita la posibilidad de nuevas interrupciones.
Bytes:
1
Ciclos de reloj: 6
Codificación:
10 01 0001
Operaciones:
(SP)
←
(PCh) ←
(SP)
←
(PCl)
←
(IEN) ←
HEX [91]
(SP) - 1
((SP))
(SP) - 1
((SP))
1
RLC
Función:
Rotación a al izquierda a través del flag de C.
Descripción:
Los 8 bits del acumulador y el flag C son rotados 1 bit a la izquierda. El bit 7 se mueve
a C, y C pasa al bit 0.
Flags:
C
Bytes:
1
Ciclos de reloj: 3
Codificación:
01 00 1011
Operaciones:
(An)
(A0)
(C)
←
←
←
HEX [4B]
(An + 1)
(C)
(A7)
RRC
Función:
Rotación a la derecha a través del flag de C.
Descripción:
Los 8 bits del acumulador y el flag C son rotados 1 bit a la derecha. El bit 0 se mueve a
C, y C pasa al bit 7.
Flags:
C
Bytes:
1
Ciclos de reloj: 3
Codificación:
01 00 1100
Operaciones:
(An)
(A7)
(C)
SET
C
Función:
Pone a 1 el flag C.
Descripción:
SET pone a 1 el flag C.
Flags:
C
Bytes:
1
←
←
←
HEX [4C]
(An + 1)
(C)
(A0)
Juego de instrucciones (ISA) del ERIC
135
Ciclos de reloj: 3
Codificación:
01 11 1111
Operaciones:
(C)
SJMP
rel
Función:
Salto relativo.
Descripción:
El control del programa salta incondicionalmente a la dirección relativa “rel”. La
dirección de salto se calcula como la suma de la dirección actual más la dirección
relativa. Por lo tanto, la cobertura de este salto es de +128/-127.
Bytes:
2
←
HEX [7E]
1
Ciclos de reloj: 3
Codificación:
10 00 1000
| rel
Operaciones:
(PC)
(PC) + rel
SUBC
A, B
Función:
Resta con acarreo
Descripción:
SUBC substrae el contenido de los registros B y el flag C al contenido del acumulador.
El resultado es depositado en A.
Flags:
C, OV y Z
Bytes:
1
←
HEX [88][##]
Ciclos de reloj: 3
Codificación:
01 00 0001
Operaciones:
(A)
XOR
A, B
Función:
Función lógica XOR.
Descripción:
XOR realiza la función lógica bit a bit entre los operados A y B.
Flags:
Z
Bytes:
1
←
HEX [41]
(A) - (B) - (C)
Ciclos de reloj: 3
Codificación:
01 00 1000
Operaciones:
(A)
←
HEX [48]
(A) ¥ (B)
Apéndice B
Microinstrucciones
En este apéndice, se resumen los valores adoptados por la señal SV (Signal Vector) de
la Unidad de Control. Dicho valor es una función de las instrucciones y del estado en
que se encuentre en el proceso de ejecución de la misma. Han sido estructuradas en
INSTRUCCIONES ESTADO
MOV A,#dato
MOV B,#dato
MOV A,addr8
MOV B,addr8
MOV addr8,A
MOV addr8,B
MOV A,@B
MOVX A,@B
MOVX A,addr12
io
ram_
ce
rom_
ce
we
pc_u
p
pc_ld
ir_ld
a_ld
b_ld
f_ld
s_m
ux1
halt
en_ie
r
dis_
ier
mar_
ld8
mar_
ld12
s_m
ux2
s_m
ux3
e_m
ux3
snif_
rst
s_m
ux4
s_m
ux5
pc_r
el
stac
k_ce
sc_u
p
sc_d
own
e_bu
f1
s_m
ux6
e_m
ux6
s_m
ux7
mar_
ld4
pc_r
st
función del tipo de instrucción: MOV, MIX, ALU, JMP.
FETCH
DECODE
1
1
1
1
1
FETCH
DECODE
1
1
1
1
1
FETCH
DECODE
EXECUTE
1
1
1
1
1
FETCH
DECODE
EXECUTE
FETCH
DECODE
EXECUTE
FETCH
DECODE
EXECUTE
FETCH
DECODE
EXECUTE
STORE
1
1
1
1
1
1
1
1
1
2 A 0 0 1 0 0 0
2 8 0 2 0 0 0 0
5 0 0 0 A 0 0 0
1
2 A 0 0 1 0 0 0
2 8 0 2 0 0 0 0
5 0 0 0 E 0 0 0
1 1 1
1
1
1
A
0
0
1
0
0
0
0
0
0
2
0
1
6
6
8
0
8
8
0
0
0
0
0
0
0
0
0
1
1
2
0
0
2
A
0
0
1
0
0
0
0
0
0
2
0
1
6
6
8
0
8
8
0
0
0
0
0
0
0
0
0
1
1 1
1 1
1
1
1
1
2
0
0
4
1
1
1
1
1
1
1 1
1 1
1
FETCH
DECODE
EXECUTE
1
1
1
1
2 A 0 0 1 0 0 0
2 8 0 2 0 0 0 0
4 0 8 0 8 0 0 0
1
1
1
FETCH
DECODE
EXECUTE
STORE
1
1
1
1
2 A 0 0 1 0 0 0
2 8 0 2 0 0 0 0
4 1 0 0 8 0 0 0
1
1
1
1
1
1
1
1
1
2 A 0 0 1 0 0 0
2 8 8 0 0 0 0 0
1
1
1
1
1
1
1
1
1
2 A 0 0 1 0 0 0
2 9 0 0 0 0 0 0
1
1
1
1
1
1
1
1
1
1
1
1
1
Tabla 20: Microinstrucciones de las instrucciones del tipo MOV
137
VECTOR DE
SEÑALES
2 A 0 0 1 0 0 0
2 8 0 1 0 0 0 0
2 1 0 0 8 0 0 0
Microinstrucciones
INSTRUCCIONES ESTADO
io
ram_
ce
rom_
ce
we
pc_u
p
pc_ld
ir_ld
a_ld
b_ld
f_ld
s_m
ux1
halt
en_ie
r
dis_
ier
mar_
ld8
mar_
ld12
s_m
ux2
s_m
ux3
e_m
ux3
snif_
rst
s_m
ux4
s_m
ux5
pc_r
el
stac
k_ce
sc_u
p
sc_d
own
e_bu
f1
s_m
ux6
e_m
ux6
s_m
ux7
mar_
ld4
pc_r
st
138
VECTOR DE
SEÑALES
NOP
FETCH
DECODE
1
1
1
1
2 A 0 0 1 0 0 0
0 0 0 0 0 0 0 0
HALT
FETCH
DECODE
1
1
1
1
2 A 0 0 1 0 0 0
0 0 0 0 0 0 0 0
ION
FETCH
DECODE
1
1
1
1
2 A 0 0 1 0 0 0
0 0 0 8 0 0 0 0
FETCH
DECODE
1
1
2 A 0 0 1 0 0 0
0 0 0 4 0 0 0 0
FETCH
DECODE
EXECUTE
1
FETCH
DECODE
EXECUTE
1
FETCH
DECODE
EXECUTE
1
FETCH
DECODE
EXECUTE
1
FETCH
DECODE
EXECUTE
1
FETCH
DECODE
EXECUTE
1
FETCH
DECODE
EXECUTE 1
1
FETCH
DECODE
EXECUTE 1
STORE
1
IOF
PUSH A
POP A
PUSH B
POP B
PUSH F
POP F
IN A,addr4
OUT addr4, A
1
1
1
1
1
1
2 A 0 0 1 0 0 0
1 0 0 0 2 1 0 0
0 0 0 0 0 0 8 0
1
1
1
1
1
1
1
2 A 0 0 1 0 0 0
0 0 0 0 0 0 4 0
0 1 0 0 0 1 0 0
1
1
1
1
1
1
2 A 0 0 1 0 0 0
1 0 0 0 6 1 0 0
0 0 0 0 0 0 8 0
1
1
1 1
1
1
1
1
2 A 0 0 1 0 0 0
0 0 0 0 0 0 4 0
0 0 8 0 0 1 0 0
1
1
1
1
1
1
2 A 0 0 1 0 0 0
1 0 0 0 0 1 2 0
0 0 0 0 0 0 8 0
1
1
1
1
1
1
1
2 A 0 0 1 0 0 0
0 0 0 0 0 0 4 0
0 0 4 0 0 5 0 0
1
1
1
1
1
1
1
2 A 0 0 1 0 0 0
0 0 0 0 0 0 0 2
8 1 0 0 8 0 0 0
1
1
1
1
1
1
2
0
9
1
1
1
1
1
1
1
1
1
A
0
0
0
0
0
0
0
0
0
0
0
1
0
A
A
0
0
0
0
0
0
0
0
0
2
0
0
INSTRUCCIONES ESTADO
LOAD
INTERRUPCION
LOAD1
LOAD2
LOAD3
LOAD4
LOAD5
LOAD5
INT1
INT2
INT3
INT4
io
ram_
ce
rom_
ce
we
pc_u
p
pc_ld
ir_ld
a_ld
b_ld
f_ld
s_m
ux1
halt
en_ie
r
dis_
ier
mar_
ld8
mar_
ld12
s_m
ux2
s_m
ux3
e_m
ux3
snif_
rst
s_m
ux4
s_m
ux5
pc_r
el
stac
k_ce
sc_u
p
sc_d
own
e_bu
f1
s_m
ux6
e_m
ux6
s_m
ux7
mar_
ld4
pc_r
st
Tabla 21: Microinstrucciones de las instrucciones del tipo MIX
1
1
1 1
1
1
1
1
1
1 1
1
1
1
1
1 1
1
1
1
1
1
1
1
Tabla 22: Microinstrucciones de las instrucciones de carga e interrupción
VECTOR DE
SEÑALES
0
0
0
3
2
0
0
0
1
0
8
0
0
1
1
0
8
0
0
0
0
0
0
0
1
0
0
3
0
1
0
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
1
0
1
0
0
0
0
0
0
0
0
0
0
0
0
4
0
0
0
0
1
0
1
0
1
8
0
8
8
0
8
1
INSTRUCCIONES ESTADO
ADDC A,B
SUBC A,B
INC A
DEC A
INC B
DEC B
AND A,B
OR A,B
XOR A,B
CLR A
CPL A
RLC A
RRC A
CLR C
SET C
CPL C
139
io
ram_
ce
rom_
ce
we
pc_u
p
pc_ld
ir_ld
a_ld
b_ld
f_ld
s_m
ux1
halt
en_ie
r
dis_
ier
mar_
ld8
mar_
ld12
s_m
ux2
s_m
ux3
e_m
ux3
snif_
rst
s_m
ux4
s_m
ux5
pc_r
el
stac
k_ce
sc_u
p
sc_d
own
e_bu
f1
s_m
ux6
e_m
ux6
s_m
ux7
mar_
ld4
pc_r
st
Microinstrucciones
FETCH
DECODE
EXECUTE
1
FETCH
DECODE
EXECUTE
1
FETCH
DECODE
EXECUTE
1
FETCH
DECODE
EXECUTE
1
FETCH
DECODE
EXECUTE
1
FETCH
DECODE
EXECUTE
1
FETCH
DECODE
EXECUTE
1
FETCH
DECODE
EXECUTE
1
FETCH
DECODE
EXECUTE
1
FETCH
DECODE
EXECUTE
1
FETCH
DECODE
EXECUTE
1
FETCH
DECODE
EXECUTE
1
FETCH
DECODE
EXECUTE
1
FETCH
DECODE
EXECUTE
1
FETCH
DECODE
EXECUTE
1
FETCH
DECODE
EXECUTE
1
1
1
1
1
1
1
1
1 1
1
1
1 1
1
1
1 1
1
1
1
1
1
1
2 A 0 0 1 0 0 0
0 0 2 0 0 0 0 0
0 1 6 0 0 0 0 0
1
2 A 0 0 1 0 0 0
0 0 2 0 0 0 0 0
0 1 6 0 0 0 0 0
1
2 A 0 0 1 0 0 0
0 0 2 0 0 0 0 0
0 1 6 0 0 0 0 0
1
2 A 0 0 1 0 0 0
0 0 0 0 0 0 0 0
0 1 6 0 0 0 0 0
1
2 A 0 0 1 0 0 0
0 0 2 0 0 0 0 0
0 0 E 0 0 0 0 0
1
2 A 0 0 1 0 0 0
0 0 2 0 0 0 0 0
0 0 E 0 0 0 0 0
1
2 A 0 0 1 0 0 0
0 0 2 0 0 0 0 0
0 1 6 0 0 0 0 0
1
2 A 0 0 1 0 0 0
0 0 2 0 0 0 0 0
0 1 6 0 0 0 0 0
1
2 A 0 0 1 0 0 0
0 0 2 0 0 0 0 0
0 1 6 0 0 0 0 0
1
2 A 0 0 1 0 0 0
0 0 2 0 0 0 0 0
0 1 6 0 0 0 0 0
1
2 A 0 0 1 0 0 0
0 0 2 0 0 0 0 0
0 1 6 0 0 0 0 0
1
2 A 0 0 1 0 0 0
0 0 2 0 0 0 0 0
0 1 6 0 0 0 0 0
1
2 A 0 0 1 0 0 0
0 0 2 0 0 0 0 0
0 1 6 0 0 0 0 0
1
2 A 0 0 1 0 0 0
0 0 2 0 0 0 0 0
0 0 4 0 0 0 0 0
1
2 A 0 0 1 0 0 0
0 0 2 0 0 0 0 0
0 0 4 0 0 0 0 0
1
2 A 0 0 1 0 0 0
0 0 2 0 0 0 0 0
0 0 4 0 0 0 0 0
1 1
1
1
1 1 1
1
1
1
1 1 1
1
1
1
1
1
1
1
1
1
1
1
1 1
1
1
1 1
1
1
1 1
1
1
1 1
1
1
1 1
1
1
1 1
1
1
1 1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
VECTOR DE
SEÑALES
1
1
Tabla 23: Microinstrucciones de las instrucciones del tipo ALU
Microinstrucciones
INSTRUCCIONES ESTADO
JZ rel
io
ram_
ce
rom_
ce
we
pc_u
p
pc_ld
ir_ld
a_ld
b_ld
f_ld
s_m
ux1
halt
en_ie
r
dis_
ier
mar_
ld8
mar_
ld12
s_m
ux2
s_m
ux3
e_m
ux3
snif_
rst
s_m
ux4
s_m
ux5
pc_r
el
stac
k_ce
sc_u
p
sc_d
own
e_bu
f1
s_m
ux6
e_m
ux6
s_m
ux7
mar_
ld4
pc_r
st
140
FETCH
DECODE
EXECUTE
1
1
1
1
si Z=0
FETCH
DECODE
EXECUTE
1
1
si C=1
FETCH
DECODE
EXECUTE
1
1
si C=0
FETCH
DECODE
EXECUTE
1
1
si OV=1
FETCH
DECODE
EXECUTE
FETCH
DECODE
EXECUTE
1
1
FETCH
DECODE
EXECUTE
1
1
FETCH
DECODE
EXECUTE
1
1
FETCH
DECODE
EXECUTE
SUBR1
SUBR2
SUBR3
1
1
FETCH
DECODE
EXECUTE
SUBR1
SUBR2
SUBR3
1
FETCH
DECODE
EXECUTE
SUBR1
SUBR2
SUBR3
1
si Z=1
JNZ rel
JC rel
JNC rel
JO rel
JNO rel
si OV=0
SJMP rel
AJMP addr12
ACALL addr12
RET
RETI
1
1
1
1
2 A 0 0 1 0 0 0
2 8 0 2 0 0 0 0
0 4 0 0 0 2 0 0
1
2 A 0 0 1 0 0 0
2 8 0 2 0 0 0 0
0 4 0 0 0 2 0 0
1
2 A 0 0 1 0 0 0
2 8 0 2 0 0 0 0
0 4 0 0 0 2 0 0
1
2 A 0 0 1 0 0 0
2 8 0 2 0 0 0 0
0 4 0 0 0 2 0 0
1
2 A 0 0 1 0 0 0
2 8 0 2 0 0 0 0
0 4 0 0 0 2 0 0
1
2 A 0 0 1 0 0 0
2 8 0 2 0 0 0 0
0 4 0 0 0 2 0 0
1
2 A 0 0 1 0 0 0
2 8 0 2 0 0 0 0
0 4 0 0 0 2 0 0
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
2 A 0 0 1 0 0 0
2 8 0 1 0 0 0 0
0 4 0 0 0 0 0 0
1
2
2
1
0
1
0
A
8
0
0
0
4
0
0
0
0
0
0
0
1
0
0
0
0
1
0
0
0
0
0
0
0
1
0
1
0
0
0
1
8
0
8
0
0
8
0
8
0
2
0
0
0
0
0
A
0
0
0
0
4
0
0
0
0
0
0
0
0
2
0
3
0
1
0
0
0
0
0
0
0
1
0
1
0
0
4
0
4
0
0
0
0
2
0
4
0
2
0
0
0
0
0
A
0
0
0
0
4
0
0
0
0
0
0
0
0
2
0
3
8
1
0
0
0
0
0
0
0
1
0
1
0
0
4
0
4
0
0
0
0
2
0
4
0
1
1
1
1
1
1
1
1
1
1
1 1
1
1
1
1
1
1
1
1
1
1
1
1
1 1
1
1
1
1
1
1
1
1
1
1
1
1 1
1
VECTOR DE
SEÑALES
1
1
1
Tabla 24: Microinstrucciones de las instrucciones del tipo JMP
Todas estas tablas, han sido generadas con la ayuda de la hoja de cálculo Excel. Es
posible encontrarlas en la sección de utilidades del CD que acompaña el proyecto. Es
importante reseñar que para poder trabajar con ellas, es necesario tener instalada la
función BIN.A.HEX(), no disponible en la instalación por defecto que hace el
OFFICE28.
28
El autor disponía de la versión Excel 2002 disponible en el OFFICE XP PROFESIONAL
Apéndice C
Manual del monitor EricMON
C.1.
Requisitos previos
EricMON es un programa monitor de apoyo al procesador ERIC. Por lo tanto, su uso
debe realizarse conjuntamente con una placa de desarrollo, Xess, Digilent o cualquier
otra provista de la FPGA adecuada, donde se haya implementado el procesador.
EricMON, es una aplicación MS-DOS que funciona bajo cualquier sistema operativo
Windows (9x, NT, 2000, XP). La comunicación con la tarjeta, se realiza por medio del
puerto paralelo que deberá estar configurado como SPP (Standard Parallel Port) y con la
dirección 0x378. La aplicación no se comunica directamente con el dispositivo, por lo
que previamente deberemos tener instalado el driver de manejo del puerto paralelo
(iniio.sys).
El programa de instalación de dicho driver se llama PORT95NT.EXE y puede ser
encontrado en el CD-ROM que acompaña a esta memoria, o bien, ser descargarda de la
página web del fabricante (DriverLinx). Si se tienen instaladas la utilidades XSTOOLS
de XESS, no es necesario realizar este paso ya que la instalación de las mismas incluye
la instalación del driver.
141
142
Manual del monitor EricMON
C.2.
Instalación del software
Crear un directorio y copiar el programa ERICMON.EXE. Para facilitar su
integración con el ensamblador EricASM, se recomienda que ambos programas estén
juntos en el mismo directorio. De este modo los programas ensamblados serán más
fácil de localizar. Para este manual, se ha elegido como ejemplo el directorio c:\eric .
C.3.
Ejecución de la aplicación
Una vez realizados los pasos previos, podemos pasar a ejecutar la aplicación. Para
ello debemos abrir una ventana MS-DOS e invocar el programa tecleando:
C:\eric\ericmon
Figura 46: Ventana en MS-DOS para invocar el programa EricMON
La aplicación nos mostrará el prompt EricMON> junto a una breve ayuda sobre las
tres opciones disponibles tecleado la inicial de cada modo:
™ L
Modo LOAD o modo carga.
™ S
Modo STEP o modo ejecución paso a paso.
™ R
Modo RUN o modo ejecución en modo continuo.
Manual del monitor EricMON
143
Veamos una descripción más detallada de cada uno de estos modos.
Figura 47: Menú principal del programa EricMON
C.3.1.
Modo LOAD
Esta opción permite cargar un programa ensamblado en la memoria ROM de ERIC.
Figura 48: Submenú del modo LOAD del programa EricMON
Pulsando la tecla F, EricMON nos solicitará el nombre del fichero ensamblado.
144
Manual del monitor EricMON
Es importante destacar en este punto, que dicho fichero deberá haber sido ensamblado
con el formato BYTE (EricASM –Fbyte). Al introducir el nombre del fichero, no es
necesario introducir la extensión ya que internamente el programa busca el fichero con
extensión .BYTE. En el caso de no encontrar el fichero indicado, o que existan
problemas de comunicación con el procesador ERIC, el programa mostrará los
mensajes pertinentes abortando la operación.
Figura 49: EricMON mostrando un mensaje de error en modo LOAD
Figura 50: Volcado de datos en memoria en el modo LOAD del programa EricMON
Manual del monitor EricMON
145
Si todo funciona correctamente, EricMON nos mostrará la evolución de la descarga,
representando la posición de memoria en curso junto al dato almacenado. Esto nos
permite comprobar, en caso de problemas, que es lo que ha cargado realmente el
programa.
C.3.2.
Modo RUN
Una vez cargado el programa en memoria, ERIC esta preparado para ejecutarlo. En
modo RUN, la ejecución se realiza en modo continuo, esto es, sin interrupciones.
Figura 51: Submenú del modo RUN del programa EricMON
Pulsando la tecla RETURN es posible iniciar/detener la ejecución del programa. En
este modo también es posible reiniciar el procesador (pulsando R) o bien, solicitar una
interrupción (pulsando I).
Con el programa detenido, es posible continuar la ejecución en el modo paso a paso
del programa, desde el punto en que se había detenido, sin necesidad de reiniciar el
procesador.
146
C.3.3.
Manual del monitor EricMON
Modo STEP
En este modo, es posible ejecutar el programa cargado en modo paso a paso. De esta
manera, se puede obtener información sobre la evolución de los registros internos de
ERIC al ir interpretando cada una de las instrucciones. También representa una buena
herramienta a la hora de depurar variaciones del diseño, implementación de nuevas
instrucciones, etc.
Figura 52: Submenú del modo STEP del programa EricMON
Cada vez que se pulsa la tecla RETURN se ejecuta una instrucción. Es posible variar
el número de instrucciones a ejecutar por interacción, variando el valor de N. Al igual
que en el modo RUN, es posible reiniciar el procesador (R) y solicitar una interrupción
(I).
EricMON, realiza la lectura de los registros de manera sincronizada con ERIC,
esperando un máximo de 2 segundos por los datos. En el caso de no estar disponibles, el
programa mostrará un mensaje de expiración del TIMEOUT de lectura, volcando
finalmente los datos que deberán ser tomados con reservas.
Apéndice D
Manual del ensamblador EricASM
Esta documentación es una adaptación del manual del AS31 de Ken Stauffer
(Universidad de Calgary), a las características propias del ERIC.
D.1.
Comando
EricASM [-Fformat] [-Aarg] [-l] infile.asm
El ensamblador genera un fichero objeto de salida con el nombre infile, seguido de
una extensión que depende de la opción de formato elegida. Si no se elige ninguna
opción, se utilizará la forma HEX por defecto. Esta conversión se realiza en dos fases:
una en la que se analiza la sintaxis y se crea una tabla de símbolos, y una segunda donde
se hace la traslación a código objeto.
El fichero infile.asm deberá ser un fichero de texto plano (sin formatear).
D.2.
Opciones del comando
Las opciones del comando, deben aparecer antes del nombre del fichero fuente.
Ambas opciones no son obligatorias. El texto de cada opción, debe aparecer unido al
mismo argumento, es decir “-Fod” es un argumento valido y no lo es “-F od”.
147
148
Manual del ensamblador EricASM
™ -Fformat: Esta opción especifica el formato de salida. Las opciones disponibles
son:
ƒ
hex
Este formato es un Intel HEX, usado comúnmente por los
programadores de EPROM.
ƒ
tdr
Este formato genera un fichero ASCII de dígitos hexadecimales
formateados de tal forma que puede ser usado por un TDR’s
Debbuger. Esta opción admite un argumento (Ver opción –A)
donde se le puede definir una dirección base, a tener en cuenta
por el contador de localización (Location Counter) del
ensamblador. Esta dirección se define en decimal y por defecto
toma el valor de 64*1024 (0x10000). Para especificar un offset
de 100 deberá teclear “Ftdr –A100” a la hora de invocar el
programa.
ƒ
byte
Este formato es simplemente una dirección y un byte en cada
línea en ASCII.
ƒ
od
Este formato consiste en una dirección seguida de 16 bytes en
hexadecimal. Al final de cada línea se incluye el equivalente
ASCII de estos 16 bytes.
ƒ
srec2,
ƒ
srec3,
ƒ
srec4 Este formato genera una salida de tipo “srecord” con direcciones
de 2, 3 o 4 bytes. La opción –A puede ser usada para definir una
dirección base de offset que por defecto es la 0x0000.
™ - Aarg: Esta opción permite definir una dirección base que será utilizada por el
generador de direcciones interno del ensamblador. Esta opción es valida
únicamente para los formatos HEX y TDR.
™ -l: Esta opción le indica al ensamblador que genere, adicionalmente al fichero
ensamblado, un fichero de texto que incluye el fichero fuente junto al código
ensamblado en formato hexadecimal. El fichero generado tendrá de nombre el
fichero fuente seguido de la extensión .LST.
Manual del ensamblador EricASM
D.3.
149
Instrucciones
EricASM soporta todas las instrucciones del procesador ERIC recogidas en este
documento en el apéndice A.
D.4.
Directivas
EricASM soporta las siguientes directivas:
™ .ORG expresión: Indica al ensamblador, la dirección de inicio del programa,
desde donde debe empezar a ensamblar. Se genera un error, si el código
generado excede la posición 0xFFF (4095), que es la dirección más alta que
maneja el ERIC.
™ .EQU símbolo, expresión: Asigna al símbolo el valor de la expresión que viene
a continuación.
™ .DB expresión, expresión …
™ .BYTE expresión, expresión …: Ambas directivas originan que se inserte en
formato byte el valor especificado por la expresiones. Esta opción, también
puede ser usada para especificar una cadena de caracteres.
™ .WORD expresión, expresión …: Similar a la opción .BYTE pero la
codificación se hace en formato WORD.
™ .END: Esta directiva es ignorada.
™ .SKIP expresión: Añade el valor de la expresión, al contador de localidad del
ensamblador. La expresión debe ser fijada en bytes.
150
D.5.
Manual del ensamblador EricASM
Sintaxis del lenguaje
A la hora de redactar los ficheros fuente, es necesario tener en cuenta ciertas reglas
sintácticas que aseguren un funcionamiento correcto del ensamblador.
D.5.1.
Generalidades
Tanto los comandos, directivas, instrucciones, etc., pueden ser utilizados tanto en
minúscula como en mayúscula. Se puede utilizar cualquier carácter (A..Z), número
(0..9) y caracteres especiales (#,_,- ….).
D.5.2.
Comentarios
Todos los caracteres precedidos del símbolo “;” son ignorados y considerados
comentarios hasta que se encuentra un carácter newline.
D.5.3.
Números
Por defecto los números son considerados en formato decimal, salvo que se precedan
de las siguientes expresiones:
™ 0X o 0x
Indica un número en hexadecimal. Ej.- 0x00ff
™ 0B o 0b
Indica un número en binario. Ej.- 0b1100110010
™ O
Indica un número en octal. Ej.- 0377
o bien que se terminen con los siguientes caracteres:
™ Hoh
Indica un número en hexadecimal. Sin embargo, si el primer carácter
no es numérico, es necesario encabezar la cifra con un 0 o con 0x.
Ej.- 20h, 0x20, 0ffh, 0xffh
™ Bob
Indica un número en binario, salvo vaya precedido por 0x. Ej.1100110010b
™ Dod
Indica un número en decimal, salvo vaya precedido por 0x. Ej.- 129d
™ Ooo
Indica un número en octal, salvo que vaya precedido por 0x. Ej.377o.
Manual del ensamblador EricASM
D.5.4.
151
Cadena de caracteres
Cualquier secuencia de caracteres delimitadas por dobles comillas (“) es considerada
como una cadena de caracteres (string). Se consideran caracteres válidos, todos los
caracteres del código ASCII así como las secuencias de escape \b, \n, \r, \t quedando
excluido \0. Las cadenas de caracteres han de ser definidas mediante el uso de la
directiva .BYTE.
D.5.5.
Símbolos
Un símbolo puede ser cualquier conjunto de caracteres alfanuméricos incluido el
guión bajo (_). Para asegurar que el ensamblador pueda distinguir entre símbolos y
números, los primeros deberán empezar siempre por un carácter alfabético.
D.5.6.
Expresiones
En general, las expresiones pueden ser utilizadas en cualquier lugar donde sea
necesario un valor o un símbolo. Las expresiones, pueden incluir los siguientes
operadores que a continuación se detallan, ordenados por orden de precedencia:
™ -
Cambio de signo
™ &
AND lógica
™ |
OR lógica
™ *
Multiplicación de enteros
™ \
División de enteros
™ %
Módulo de enteros
™ +
Suma de enteros
™ -
Resta de enteros
™ <<
Desplazamiento a la izquierda
™ >>
Desplazamiento a la derecha
Adicionalmente a estos operadores, existe un símbolo especial ‘*’ que puede ser
utilizado para representar el valor actual del contador de localización (LC), utilizado por
el ensamblador.
152
D.6.
Manual del ensamblador EricASM
Ejemplo de un fichero fuente
Figura 53: Ejemplo de un fichero fuente para el ensamblador EricASM
Apéndice E
El entorno de desarrollo ISE WebPACK
Figura 54: Ventana del Project Manager del entorno WebPACK
WebPACK™ ISE™ es un conjunto de herramientas gratuitas, de la casa Xilinx, que
conforman un entorno de desarrollo, cuya finalidad es la de poder realizar diseños
basados en sus dispositivos programables de los tipo CPLD y FPGA.
153
154
El entorno de desarrollo ISE WebPACK
La versión profesional de las herramientas del WebPACK se denomina Foundation
ISE.
El corazón central de las aplicaciones es el Project Navigator, que está estructurado
siguiendo las distintas fases del desarrollo de un proyecto: captura, síntesis,
implementación y generación del fichero de programación (bitstream).
Figura 55: Esquema organizativo del entorno WebPACK
El entorno de desarrollo ISE WebPACK
155
Desde el Project Navigator, es posible invocar las distintas herramientas de apoyo
para la generación de los distintos ficheros: generador de diagramas de estado,
generador de banco de pruebas (testbench), analizador de tiempos, simulador, etc.
Debemos reseñar que en la versión de estudiante algunas de estas aplicaciones están
disponibles en versión demo, por lo que, o bien no funcionan (caso del simulador) o
bien tienen limitadas sus capacidades (caso del simulador). A pesar de todo, WebPACK
es una herramienta suficientemente funcional.
Puesto que, una descripción operativa del uso de la herramienta puede llegar a ocupar
decenas de páginas (incluso una descripción somera), veamos brevemente las
características generales de cada una de las fases de un desarrollo completo,
recomendando la lectura de alguno de los tutoriales, incluidos en el CD de este
proyecto, a aquellas personas que deseen saber más.
E.1.
Descripción HDL o esquemáticos
ISE, permite la entrada de la descripción funcional del diseño, bien a través de
esquemáticos, bien a través de lenguajes de descripción de hardware (HDL). Para el
primer caso, el sistema incluye una herramienta CAD para la captura de esquemas con
las características típicas de este tipo aplicaciones: biblioteca de símbolos, editor de
símbolos, conexionado, etc. En el segundo caso, es posible elegir alguno de los HDL
soportados: VHDL, VERILOG, ABEL dependiendo su disponibilidad para el tipo de
dispositivo programable elegido.
Para facilitar la descripción HDL de ciertos módulos (testbench, diagramas de estado,
etc.), el sistema incluye herramientas de apoyo como son HDL Bencher, StateCAD,
etc., aunque están limitadas en el número de líneas de código que pueden generar.
156
E.2.
El entorno de desarrollo ISE WebPACK
Síntesis
Una vez concluida la descripción funcional del diseño, el sistema comprueba la
consistencia de los distintos módulos y procede a su síntesis, infiriendo los distintos
componentes del circuito. Durante el proceso, el sistema genera una serie de informes
que nos informan sobre la evolución del proceso, recomendaciones de diseño,
simplificaciones, etc.
E.3.
Posicionamiento y enrutado
Tras la síntesis el sistema está preparado para ubicar nuestro diseño en el dispositivo
programable elegido. En este punto del diseño, es necesario fijar físicamente las
distintas señales de entrada/salida de nuestro circuito dentro del dispositivo programable
elegido.
Con esta finalidad, el sistema incluye un editor (Constraints Editor). Con esta
información y la resultante de la síntesis, la aplicación procede a asignar, posicionar y
enrutar (map, place & route) el diseño. Cada una de estas subfases, va acompañada de la
generación de informes sobre la evolución de la actividad. Si deseamos analizar como
ha quedado la implementación del diseño, es posible hacerlo con la ayuda de la utilidad
FloorPlan.
E.4.
Simulación
Cada uno de los circuitos diseñados, son susceptibles de ser simulados con el fin de
verificar el correcto funcionamiento del diseño. WebPACK non incluye ningún
simulador propio, aunque sí incluye la posibilidad de instalar uno de la casa Mentor
Graphics™. Esta aplicación, se denomina ModelSIM, y existe una versión profesional y
otra de evaluación limitada a 500 líneas de código VHDL (para la que es necesario
registrarse vía Internet).
El entorno de desarrollo ISE WebPACK
157
Figura 56: Ventanas del simulador ModelSIM de la casa Mentor
E.5.
Generación del bitstream y programación
Una vez concluidos con éxito los pasos anteriores, ya se puede proceder a la
generación del fichero de programación (bitstream) que va a definir el comportamiento
del dispositivo programable elegido. El sistema incluye la aplicación iMPACT, que
permite, tanto la generación de ficheros para su grabación vía una memoria serie del
tipo (E)PROM, como la programación directa del dispositivo mediante un cable
conectado a un ordenador personal, a través de, alguno de los medios que permite el
dispositivo programable (Boundary-Scan, SelectMap, etc.)
158
E.6.
El entorno de desarrollo ISE WebPACK
Tabla de prestaciones
Tabla 25: Prestaciones de los distintos productos software de Xilinx
Apéndice F
La tarjeta de desarrollo XSA-50.
Figura 57: Tarjeta XSA-50 de Xess
La XSA-50 es una tarjeta de desarrollo, de la casa Xess Corporation™, orientada al
desarrollo de aplicaciones basadas en la FPGA de Xilinx Spartan-II XC2S50. A la
FPGA le acompañan otros dispositivos como son una memoria dinámica de 8 Mbytes,
otra de tipo Flash de 128 Kbytes y un CPLD XC9572XL así como varios componentes
como un oscilador programable, un visualizador de 7 segmentos, un pulsador y distintos
tipos de conectores. Se alimenta con 9 V en continua, y la programación se realiza por
el puerto paralelo con la ayuda de utilidades que acompañan la tarjeta.
159
160
La tarjeta de desarrollo XSA-50.
F.1.
Descripción de la tarjeta
La FPGA posee conexiones prácticamente con cualquiera de los dispositivos
auxiliares que constituyen la placa, tal como podemos ver en el siguiente esquema de
bloques:
Figura 58: Esquema general de la tarjeta XSA-50
Veamos brevemente las particularidades de cada conexión, así como los aspectos más
relevantes de cada dispositivo.
F.1.1.
Los dispositivos programables:
La tarjeta dispone de dos dispositivos programables a saber:
™ Una FPGA SPARTAN II XC2S50 de la casa Xilinx con una capacidad de
50.000 puertas lógicas equivalentes.
™ Un CPLD XC9572XL, cuya finalidad es doble: por un lado es susceptible de
ser programado al igual que la FPGA, en el desarrollo de una aplicación y
por otro lado, realiza las funciones de interfaz entre el mundo exterior
(puerto paralelo) y los distintos componentes (memorias, FPGA y oscilador)
a la hora de ser programados.
La tarjeta de desarrollo XSA-50.
F.1.2.
161
El reloj programable
Se trata del circuito integrado DS1075 de la casa Dallas que provee de señal de reloj
tanto a la FPGA como al CPLD. La frecuencia máxima de trabajo es de 100 Mhz, que
puede ser dividida por un número entero comprendido entre 1 y 2052. La programación
del mismo se realiza vía software, con la ayuda de la utilidad XSTEST (ir al apartado
de utilidades para más información).
F.1.3.
La RAM dinámica
La placa incorpora una memoria síncrona dinámica SDRAM de la casa Hynix
HY57V561620T-H, con una capacidad de 8 Mbytes (4M x 16). Como toda RAM
dinámica, para poder utilizarla es necesario incorporar un controlador de refresco. En
este sentido Xess proporciona una nota de aplicación que incluye un listado en VHDL
para la implementación del mismo (XSA SDRAM.controller).
Figura 59: Conexión de la FPGA y la DRAM enana XSA-50
Es posible cargar/descargar el contenido de la memoria por medio de la utilidad
XSLOAD.
162
F.2.
La tarjeta de desarrollo XSA-50.
La RAM FLASH
La placa, incorpora una memoria FLASH de la casa Atmel AT49F002, con una
capacidad de 128 Kbytes. Tanto el CPLD como la FPGA, tienen acceso a la memoria
FLASH, siendo el CPLD el encargado de cargar/descargar su contenido por medio de la
utilidad XSLOAD. Dado que el modelo de FPGA, que incorpora la XSA-50, no permite
guardar el diseño de manera permanente, es posible utilizar la memoria FLASH con
este cometido. Destacar la necesidad de fijar el terminal /CE a 1 en el caso de no utilizar
la memoria FLASH, con el fin de evitar conflictos de hardware.
Figura 60: Conexión entre la FPGA, el CPLD y la FLASH en la XSA-50
F.2.1.
El visualizador de 7 segmentos
La tarjeta incorpora un visualizador de 7 segmentos, activos a nivel alto que pueden
ser utilizados indistintamente por la FPGA o por el CPLD.
La tarjeta de desarrollo XSA-50.
F.3.
163
Puerto VGA y PS2
La tarjeta dispone, de dos conectores normalizados que permiten la conexión de un
teclado y un monitor. Destacar que, a pesar de ser denominados PS2 y VGA, no existe
en la tarjeta ningún hardware, que por defecto haga las funciones de interfaz con los
dispositivos conectados a los mismos, es decir, no hay ningún controlador VGA ni
controlador de teclado, siendo la conexión puramente física.
Figura 61: Detalles de las conexiones VGA y PS2 de la XSA-50
F.3.1.
Banco de interruptores DIP y pulsador
La tarjeta, incorpora un banco de 4 interruptores DIP de 2 posiciones, conectados a
VCC por medio de resistencias. En el caso de que no se utilicen, es recomendable
dejarlos en posición de abiertos, para que los terminales de la FPGA puedan ser
asignados para otros fines. Comparte terminales de la FPGA con los terminales A14 …
A17 de la memoria Flash.
La tarjeta también incluye un pulsador conectado a VCC por medio de una resistencia.
El pulsador aplica un valor bajo (0 lógico) al ser pulsado y alto cuando esta sin pulsar.
Comparte terminal de la FPGA con el terminal de datos del puerto PS2
164
F.3.2.
La tarjeta de desarrollo XSA-50.
El puerto paralelo
El puerto paralelo es la interfaz principal de la tarjeta con el mundo exterior. A través
de él, es posible la programación de los dispositivos, la carga/descarga de datos, así
como el uso que posteriormente podamos hacer de él en nuestros diseños.
Para la programación de los distintos dispositivos, el puerto paralelo ha de
configurarse en modo SPP (Modo estandar o compatible), no siendo recomendable el
uso de otros modos (EPP, ECP …). En este modo, el puerto paralelo dispone de 12
líneas de salida repartidas en 4 líneas de control (PPC0…PPC3) y 8 de datos (PPD0
…PPD7), y de 5 líneas de entrada conocidas como status (PPS3 … PPS7).
Las líneas de control (PPC1 …PPC3) se conectan directamente a los terminales JTAG
del CPLD, obteniendo la realimentación vía PPS7. PPC0, es utilizada para la
programación del oscilador. Estas líneas, son de uso exclusivo de la tarjeta y por lo
tanto no pueden ser utilizadas por el diseñador. El resto PPD0 … PPD7 y PPS3 … PPS6
pueden ser utilizadas como líneas de propósito general. Hay que destacar que las líneas
PPD0 y PPD1 están conectadas a la FPGA por medio de unos inversores SchmittTrigger.
El resto de los dispositivos (SDRAM, FLASH y FPGA) son programados a través del
CPLD e incluso a través de la FPGA (en el caso de la SDRAM). En función del
dispositivo a programar y de lo que queremos hacer con él (ej.- cargar o descargar el
contenido de la SDRAM) se modifica el contenido del CPLD/FPGA. De este modo,
existe una secuencia a la hora de programar los dispositivos: SDRAM, FPGA, FLASH
y CPLD. Todas estas reprogramaciones, se realizan de manera automática por medio de
las utilidades XSTOOLS por lo que el diseñador sólo debe preocuparse de sus diseños.
Si el diseñador no utiliza el CPLD, éste quedará configurado con el fichero
dwnldpar.swf (utilizado para la programación de la FPGA), permitiendo de este modo
una conexión directa entre el puerto paralelo y la FPGA.
La tarjeta de desarrollo XSA-50.
Figura 62: Detalles de la conexión del la XSA-50 con el puerto paralelo.
Figura 63: Conexionado entre el puerto paralelo y distintas partes de la XSA-50
165
166
F.4.
La tarjeta de desarrollo XSA-50.
Las utilidades XSTOOLS
La tarjeta viene acompañada de unas herramientas software, conocidas como las
XSTOOLS, cuya finalidad son la programación, comprobación y manejo del puerto
paralelo. Todas estas utilidades son gráficas para el entorno Windows (9x, 2000, etc.) y
poseen su equivalente a nivel de comando MS-DOS (entre paréntesis). Veamos
brevemente cuáles son estas utilidades y cuáles son sus funciones.
F.4.1.
GXSTEST (XSTEST)
La finalidad del mismo es comprobar que existe buena comunicación entre el
ordenador y la tarjeta. Para ello, el puerto paralelo deberá estar configurado como SPP y
la frecuencia del oscilador de la tarjeta deberá ponerse en 50 Mhz.
Figura 64: Ventana de dialogo de GXSTEST
F.4.2.
GXSSETCLK (XSSETCLK)
La finalidad del mismo, es la de fijar la frecuencia del oscilador programable,
introduciendo para ello el valor de división del reloj. Antes de la programación, y con la
XSA-50 apagada, es necesario cambiar la posición del puente J6 a SET devolviéndolo a
su posición original una vez realizada la programación.
Figura 65: Ventana de diálogo de GXSSETCLK
La tarjeta de desarrollo XSA-50.
F.4.3.
167
GXLOAD(XSLOAD)
Con la ayuda de esta utilidad es posible programar tanto el CPLD como de la FPGA,
así como cargar/descargar el contenido de las memorias FLASH y SDRAM. Para la
programación de los dispositivos programables, se deberá seleccionar el fichero .BIT o
.SVF, arrastrarlo y dejarlo caer sobre la casilla FPGA/CPLD. En el caso de programar
las memorias, habrá que arrastrar un fichero con el formato elegido en la opción
UPLOAD FORMAT, dentro de la casilla correspondiente. En el caso de querer
descargar el contenido de las mismas, será preciso fijar las direcciones bajas y altas que
se quieren volcar así como el tipo de formato del fichero.
Figura 66: Ventana de diálogo de GXLOAD
F.4.4.
GXPORT(XSPORT)
Permite programar el contenido del registro de las líneas de datos del puerto paralelo.
Figura 67: Ventana de diálogo de GXPORT
168
F.5.
La tarjeta de desarrollo XSA-50.
Listado de conexiones
La tarjeta de desarrollo XSA-50.
Tabla 26: Listado de las conexiones de la tarjeta XSA-50
169
Apéndice G
FPGAs de la familia SPARTAN II DE XILINX.
La Spartan-II™, es una familia de la FPGAs (Field Programmable Gate Array) de la
casa Xilinx. Se denomina II por pertenecer a la tecnología de ASICs programables de
segunda generación.
Disponible en 6 formatos, con una densidad de puertas comprendida entre las 15.000
a las 200.000 puertas, la frecuencia máxima de trabajo puede llegar a 200 Mhz.
Tabla 27: Tipos de dispositivos de la familia Spartan-II
El uso de esta familia de FPGAs está orientado al desarrollo de aplicaciones con un
alto consumo de recursos, donde la versatilidad y la reprogramación sean aspectos a
tener en cuenta.
171
172
G.1.
FPGAs de la familia SPARTAN II DE XILINX.
Arquitectura
Como todas las FPGAs, la familia Spartan-II, posee una configuración básica en
cuadrícula (array) compuesta por CLBs (Configurable Logic Blocks) e IOBs
(Input/Output Blocks), al que se le han añadido algunos elementos, como son 4 DLLs
(Delay-Locked Loops) y varios bloques de memoria SRAM (de 4096 bits cada uno) en,
cantidad variable según el dispositivo concreto, con el fin de aportarle una mayor
funcionalidad. Todos estos elementos, están interconectados por una potente jerarquía
de líneas de interconexión versátiles.
Figura 68: Esquema interno de una FPGA de la familia Spartan-II
La configuración de la Spartan-II, se realiza por medio de la programación de las
celdas internas de la memoria SRAM de configuración, que pueden ser programadas un
número ilimitado de veces. La configuración, puede ser leída a partir de memorias serie
externas de tipo (E)PROM (Master Serial Mode) o bien escribiendo directamente en el
dispositivo por medio algunos de los siguientes modos disponibles (Slave Serial, Slave
Parallel o Boundary Scan).
FPGAs de la familia SPARTAN II DE XILINX.
G.2.
173
Bloques de entrada/salida (IOBs)
Los IOBs de la Spartan-II soportan hasta 16 tipos diferentes de niveles lógicos
estándar, siendo su estructura básica la mostrada a continuación:
Figura 69: Diagrama de bloques de los IOBs de una FPGA Spartan-II
Según el tipo de dispositivo, es posible disponer entre 86 a 284 I/Os. Las entradas,
pueden ser memorizadas mediante biestables o bien conectadas directamente a la lógica
interna. Las salidas, tienen capacidad tres estados (3-state) y es posible su
realimentación de nuevo al interior del circuito. También es posible, definir
características como la pendiente de cambio (slew-rate), resistencias de puesta a uno
(pull-up) o puesta a cero (pull-down), keeper y retardos programables.
G.3.
Bloques lógicos configurables (CLBs)
La unidad básica a partir de la que está construido un CLB es la celda lógica LC
(Logic Cell). Una LC, incluye una memoria de acceso aleatorio estática (SRAM) con 4
variables de dirección (tabla de consulta), que permite generar una función lógica de 4
174
FPGAs de la familia SPARTAN II DE XILINX.
entradas, una lógica de acarreo (Carry Logic) y un biestable de almacenamiento. Cada
CLB incluye 4 de estas LCs, por lo que uniendo todos los recursos disponibles es
posible realizar una función lógica de 5 o 6 entradas.
Figura 70: Diagrama de bloques de un SLICE de una Spartan-II
G.3.1.
Tablas de consulta LUT (Look-Up Table)
Cada LUT permite la definición de una función lógica de 4 entradas. También es
posible definir en su lugar una SRAM síncrona de 16x1 bits, o bien, combinar las 2
LUTs para definir una SRAM de 16x2 ó 32x1 bits.
Cada LUT está provista de un registro de desplazamiento de 16-bits, ideal para ser
usado en captura de datos a alta velocidad o en modo ráfaga (burst-mode) como en el
caso de los DSPs.
FPGAs de la familia SPARTAN II DE XILINX.
G.3.2.
175
Lógica de acarreo (Carry Logic)
Este bloque permite la realización de funciones aritméticas y lógicas a alta velocidad.
Cada CLB dispone de 2 cadenas independientes de arrastre acarreo (carry).
G.3.3.
Amplificadores (BUFTs)
Cada CLB dispone de 2 amplificadores (buffers) de tres estados (3-state) que pueden
conectarse a los buses internos.
G.3.4.
Lógica adicional
Los multiplexores denominados F5 (no aparecen en la figura) permiten la
implementación de una función lógica de 5 entradas, ser usados como multiplexor 4:1 o
bien realizar funciones lógicas de hasta 9 entradas, combinando varias tablas de
consulta. Los multiplexores F6 permiten la implementación bien de una función lógica
de 6 entradas, bien de un multiplexor de 8:1 o bien, la realización de funciones de hasta
19 entradas
Cada CLB posee además 4 caminos de retorno, uno por cada LC, que permite líneas
de entrada adicionales o ser usadas como líneas de conexionado local sin consumir para
ello recursos de interconexión generales.
G.4.
Bloques de memoria (BRAM)
La familia SPARTAN-II incorpora varios bloques de memoria estática SRAM, en
número variable según el tipo de dispositivo, tal como se puede observar en la siguiente
tabla:
Figura 71: Tamaño de los bloques RAM según el modelo de Spartan-II
176
FPGAs de la familia SPARTAN II DE XILINX.
Cada uno de estos bloques es de 4096-bits. Esta memoria, puede ser utilizada de
varias formas: RAM de simple o doble puerto de tamaño variable tanto en el bus de
datos como el de direcciones. Esta SRAM es siempre síncrona (SSRAM) y se incluyen
líneas dedicadas para facilitar la interconexión entre los bloques RAM y el resto de los
CLBs.
Tabla 28: Configuraciones posibles de los bloques RAM
G.5.
Matriz de interconexión programable
Spartan, dispone de distintos recursos a nivel de conexionado mejorados con respecto
a otras familias, con el fin de alcanzar mayores frecuencias de trabajo. A continuación
se describen los distintos tipos.
G.6.
Caminos de interconexión local
Los caminos de interconexión local, mostrados en la figura, permiten:
Figura 72: Enrutado local de una Spartan-II
FPGAs de la familia SPARTAN II DE XILINX.
177
™ Interconexión entre LUTs, biestables y la matriz de conexión general (GRM).
™ Realimentación interna en los CLBs, proporcionando de este modo alta
velocidad de conexionado entre LUTs dentro del mismo CLB o,
encadenamiento de los mismos con un mínimo retardo.
™ Conexión directa de alta velocidad entre CLBs que ocupen posiciones
adyacentes en línea horizontal.
G.6.1.
Caminos de interconexión de propósito general
Los caminos de interconexión de propósito general, que son los utilizadas más
habitualmente y los que soportan la mayoría de la carga de conexión, están constituidos
por canales horizontales y verticales que discurren entre las filas y las columnas de los
CLBs.
Los recursos disponibles para esta tarea son los siguientes:
™ Una GRM adyacente a cada CLB. La GRM es una matriz que permite el
conexionado entre líneas horizontales y verticales, así como el conexionado
entre el CLB y las líneas de propósito general.
™ 24 líneas de conexión entre GRM adyacentes en cualquiera de las cuatro
direcciones.
™ 96 buses de 16 líneas con amplificadores (buffer), que permiten la conexión
entre los GRM adyacentes en cualquiera de las cuatro direcciones.
™ 12 líneas con amplificador (buffer) de largo recorrido (long lines), bidirecionales
para la distribución de señales a lo largo de la FPGA de manera rápida y
eficiente.
Figura 73: Líneas de interconexión de propósito general en una Spartan-II
178
FPGAs de la familia SPARTAN II DE XILINX.
G.6.2.
Caminos de interconexión globales
Estos recursos de conexionado son utilizados para la distribución de relojes y señales
que precisan de una elevada cargabilidad (fan-out) de salida. Spartan-II establece dos
niveles:
™ Caminos primarios, consistentes en 4 líneas globales con terminales de entrada
dedicados, que permiten la distribución de señales con alta cargabilidad (fanout) y con un mínimo desfase (skew).
™ Caminos secundarios, consistentes en 24 líneas distribuidas a partes iguales
entre la parte superior e inferior del dispositivo. Son más flexibles, al no estar
restringidas únicamente a la distribución a señales de reloj, a cambio de
introducir mayores retardos.
G.7.
DLL (Delay-Locked Loop)
Cada una de las 4 líneas globales, dedicadas a la distribución de relojes, lleva asociado
un DLL cuya finalidad es la de reducir los desfases (skew), en las señales de reloj,
mejorando de este modo la sincronización entre las señales de reloj externas e internas.
El modo de funcionamiento de cada DLL consiste en monitorizar la señal de reloj
procedente del exterior, y la distribuida en el dispositivo, y ajustar de manera dinámica
un valor de retardo, de tal modo que sea la señal interna sea una versión retardada en un
ciclo exacto de la señal externa.
Adicionalmente a esta función, los DLLs permiten disponer de la señal de reloj
desfasada en cuadratura, lo que permite doblar internamente las frecuencias de las
señales de reloj externas, o bien, disponer de la señal dividida por un factor de 1.5, 2,
2.5, 3, 4, 5 ,8 ó 18. Dispone de 6 salidas.
G.8.
Exploración periférica (boundary scan)
La familia Spartan-II presenta los elementos necesarios para la utilización del método
boundary scan conforme al estandar IEEE 1149.1.
Apéndice H
LCD PowerTIP 1602-H.
Figura 74: Vistas anterior y posterior del LCD PowerTIP 1602
El LCD 1602-H es una visualizador de cristal líquido de 2 líneas de 16 caracteres. A
continuación se detalla una información elemental del dispositivo. Para una información
más detallada consultar la hoja de características disponible en el CD.
179
180
LCD PowerTIP 1602-H.
Figura 75: Características mecánicas y diagrama de bloques del LCD-1602H
Apéndice I
Intregración del proyecto en un IDE.
Figura 76: Vista general del editor ConTEXT utilizado como IDE
Aunque, es posible trabajar con todas la aplicaciones del proyecto de manera aislada,
abriendo en cada caso la ventana pertinente de MS-DOS e invocando manualmente
181
182
Intregración del proyecto en un IDE.
cada uno de los programas, también es posible integrar el conjunto alrededor de un
IDE29 mejorando de esta manera la interfaz de trabajo.
El corazón del IDE puede ser cualquier editor de texto en Windows que disponga de
ciertas funcionalidades como son la posibilidad de ejecutar programas externos, la
captura de la salida de ventanas tipo consola. Existen multitud de programas con estas
características en la red.
Figura 77: Ejemplo de configuración de F9 para que ejecute EricASM
29
Integrated Development Enviroment.
Intregración del proyecto en un IDE.
183
Para este proyecto, se ha elegido el editor de texto ConTEXT de distribución gratuita
y que posee las siguientes características: simple, orientado a programadores, resalta
visualmente las palabras reservadas de los lenguajes, soporta la ejecución de
aplicaciones externas, etc.
Las figuras de este apéndice, recogen los parámetros a configurar en el menú de
opciones de entorno, para que las teclas programables puedan ejecutar cada una de las
aplicaciones del proyecto, o bien por medio de iconos relacionados con estas teclas.
Figura 78: Ejemplo de configuración de F10 para que ejecute EricMON
Estas configuraciones están asociadas a la extensión del fichero que estemos
manejando, en este caso partimos de que estamos editando un fichero en ensamblador
184
Intregración del proyecto en un IDE.
con extensión ASM. Como para el seguimiento de los programas, es importante estar
visualizando la versión ensamblada, con extensión LST, es importante también
configurarla del mismo modo.
Figura 79: Ejemplo de configuración de F11 para que ejecute el XSLOAD
El editor tiene capacidad de colorear las palabras reservadas de un lenguaje. Estos
lenguajes, pueden también ser configurados junto a la definición de estas palabras. En el
CD anexo se incluye el fichero de configuración para que soporte los nemotécnicos
propios del juego de instrucciones del ERIC. Para más información sobre el programa
consultar la página del autor de ConTEXT http://fixedsys.com/context/
Apéndice J
Listados y esquemas
185