a

UIBUniversitat de les

Illes Balears

GRADO EN INGENIERÍA TELEMÁTICA ELECTRÓNICA DIGITAL

CONFIGURACIÓN DE DISPOSITIVOS PROGRAMABLES: INTRODUCCIÓN AL QUARTUS II

Josep L. Rosselló Noviembre 2011

2

Dispositivos lógicos programables. Existen distintos fabricantes de dispositivos lógicos programables. En esta asignatura utilizaremos los dispositivos creados por el fabricante ALTERA. Este fabricante nos proporciona distintas familias de dispositivos con diferentes propósitos, los más relevantes son los siguientes: Dispositivos de alta densidad y alta velocidad de operación: Serie STRATIX Dispositivos de integración media de bajo coste: Serie CYCLONE Dispositivos programables de muy bajo coste y consumo: Serie MAX En esta asignatura utilizaremos los dispositivos CYCLONE. Cada integrado de esta familia posee distintas funcionalidades que podemos utilizar. Para las CYCLONE III que usaremos (la EP3C16) disponemos de 15408 elementos lógicos (LEs), 516.096 bits de Memoria RAM, 346 pines de entrada/salida, 56 Multiplicadores y 4 PLLs que permiten aumentar las prestaciones del reloj interno.

Para la configuración de estas familias, el fabricante proporciona un software de diseño, compilación y programación. Este programa es el QUARTUS II. Existen dos versiones, la versión gratuita (Web Edition) y que permite configurar solo un conjunto de dispositivos determinado y la versión profesional (Subscription edition) para la gama completa. Para los dispositivos que usaremos será suficiente la versión gratuita del QUARTUS. Para más información sobre los dispositivos ALTERA y el QUARTUS II podeis acceder a www.altera.com.

3

Introducción al QUARTUS II Empecemos el programa QUARTUS II: Ejecutad el programa (Quartus II Web Edition software) instalado en los ordenadores del laboratorio de electrónica de la universidad. El Quartus funciona trabajando sobre proyectos por lo que lo primero que podéis hacer es activar un nuevo proyecto:

Es aconsejable crear una carpeta para cada proyecto individual.

4

Seguidamente añadid los archivos que creáis conveniente (para empezar no ponemos ningún archivo puesto que empezamos de cero) y le damos a NEXT. Seguidamente nos indica cuál es el dispositivo que usaremos en nuestro proyecto. En este caso es el dispositivo de las placas de entrenamiento DE0 de la empresa TERASIC, el cual viene con un dispositivo CYCLONE III EP3C16F484C6.

5

Demos a NEXT y finalizamos el “Wizard” de proyectos.

Introducción de diseños: Seguidamente podemos empezar a diseñar nuestro proyecto. Es conveniente haber razonado previamente en un papel qué es lo que realmente queremos implementar y cómo lo haremos. En este ejemplo realizaremos un proyecto en el que, mediante un contador binario, un sumador y un multiplexor, llenaremos una memoria RAM interna de la FPGA de forma que cada posición de la meomoria contenga el número ‘i+200’ con ‘i’ comprendido entre el 1 y el 255 ó solamente el número ‘i’. Seleccionaremos una u otra opción mediante un interruptor. Lo primero que hacemos es definir los pines de entrada y salida. Tendremos dos entradas; un interruptor y un reloj (que es proporcionado por la placa DE0 y que oscila a 50MHz) y una salida (el contenido de la memoria).

Schematics y entrada HDL: Comenzamos abriendo un nuevo fichero ‘bdf’ en donde insertaremos nuestro diseño de forma gráfica. Damos a New->Design Files->Block Diagram/Schematic file

6

Nos sale una pantalla en blanco. Hacemos dobre click en esta pantalla e introducimos tres entradas y una salida (3 input y 1 output). A continuación podéis ver cómo se inserta una entrada

7

A cada pin le ponemos un nombre. Por ejemplo ‘clk’ para el reloj, ‘reset’ para el reset, ‘selector’ para el interruptor con el que seleccionaremos ‘i+200’ ó ‘i’ para el contenido de la memoria y ‘qout[8..0]’ para una salida de 9 bits (puesto que el número máximo a incluir en la momoria será 255+200 que en binario se ha de representar con 9 bits). El diseño nos quedará como sigue:

Podeis guardar el archivo de forma provisional como “prova.bdf” en la carpeta que hemos abierto para el proyecto. A continuación podemos implementar un contador binario de 0 a 255. Para ello, puesto que lo queremos insertar en formato VHDL creamos un nuevo fichero (distinto al principal que estamos editando) y que será del tipo vhd.

8

Como resultado se nos abre una pantalla de edición de texto. En esta pantalla podemos insertar nuestro código VHDL de nuestro contador binario. Nos vamos a Edit->Insert Template para usar muestras que nos proporciona el QUARTUS. Nos vamos a Full design-> Arithmetic ->Counter->Binary Counter y ya tendremos insertado un contador binario en VHDL. Substituid los valores MIN_COUNT y MAX_COUNT por 0 y 255 respectivamente y eliminad el bloque ‘generic’.

9

10

Podemos guardar este fichero en la carpeta que hemos abierto antes para el proyecto. Lo nombramos como binary_counter.vhd. Para que dicho bloque que acabo de crear salga en mi librería de proyecto (librería WORK) procedemos a definir el símbolo del bloque. Activo File->Create/Update->Create Symbol Files for Current File.

Una vez creado el símbolo volvemos al fichero principal “prova.bdf” e insertamos un nuevo componente (hacemos doble click sobre el diseño) que será el contador binario creado.

11

A continuación conectamos los pines de entrada con el bloque. La entrada de enable del contador la conectamos permanentemente a uno (símbolo vcc, si quisiéramos un ‘0’ pondríamos un gnd).

12

El diseño finalmente nos queda:

13

Seguidamente ponemos un sumador (lpm_add_sub) para implementar la función ‘i+200’.

Seleccionamos dos entradas de 8b y un carry output a la salida y colocamos nuestro sumador.

14

Conectamos la salida del contador a una de las entradas del sumador y creamos una constante de valor 200 (lpm_constant) que conectaremos a la segunda entrada del sumador.

Seguidamente damos nombre a las dos salidas ‘i’ e ‘i+200’ que serán las salidas que quiero seleccionar (outa[7..0] y outb[7..0]) a la vez definimos outb[8] para el carry de salida del sumador y outa[8] conectado a gnd para igualar el número de bits de las dos salidas. Para poner los nombres a las líneas tenemos que hacer click encima de cada línea e insertamos el nombre. Una vez que tenemos las dos posibles entradas a mi memoria (outa y outb) procedemos a poner un multiplexor controlado por el interruptor ‘selector’. Para ello procedemos de forma análoga a cuando hemos insertado el sumador pero ahora usamos el ‘lpm_mux’. Seleccionamos el multiplexor con 9 bits de entrada por cada una de las dos entradas.

15

Veremos que en Project se nos crea lpm_mux0 que elijiremos para insertar. Conexiones por nombre: No es necesario conectar los bloques línea a línea, de hecho es más práctico hacer las conexiones por nombre. Si dos líneas (aunque no estén unidas a simple vista) tienen el mismo nombre, entonces son la misma línea y es como si estuviesen conectadas. Conectamos por tanto el multiplexor a ‘outa[8..0]’, ‘outb[8..0]’ y ‘selector’. No os olvideis de nombrar ‘selector’ a la línea que salga del pin selector (mirad el diseño).

16

A continuación creamos nuestra memoria “lpm_ram_dq”. Para ello le damos al botón

MegaWizard Plug-In Manager.

Seleccionamos Memory Compiler->RAM 1 Port

17

Le ponemos un nombre (p.ej. memory) y la definimos con 8 bits de anchura del bus de direcciones y 9 bits de anchura del bus de palabras (9bits, 256 words).

18

Conectamos la memoria con el resto del circuito. La dirección al valor de ‘i’ (outa), la entrada a memorizar al multiplexor, we lo conectamos a ‘vcc’ puesto que vamos a escribir en la memoria y el reloj a clk (no olvidaros de nombrar clk a la línea que sale del pin de clock). Finalmente conectamos qout a la salida de la memoria. El diseño quedará como sigue:

Compilación Una vez realizado el diseño pasamos a la compilación del sistema en donde nos desvelará si hay errores o no (Processing>Start Compilation).

19

Solucionamos los errores que nos salgan (consulta al profesor en el caso en el que no sepas como solucionarlos). Al final te proporciona un resumen del resultado de la compilación:

20

Asignación de pines

Una vez compilado el diseño procedemos a asignar entradas y salidas de diseño con pines de salida. La placa DE0 que utilizaremos está interconectada de una forma determinada y tenemos a nuestra disposición lo siguiente: 10 Interruptores 3 pulsadores 10 LEDs Cuatro dispositivos 7 segmentos Una memoria RAM de 8 MBytes Una memoria FLASH de 4MBytes Salida VGA Emisor RS-232 Interface LCD 2 Bloques de expansión Conector PS/2

21

Cada dispositivo está conectado a un pin determinado de la FPGA. La siguiente lista es la lista de asignación de pines # ****************************** # * Pin & Location Assignments * # ****************************** # Clocks: # ======= set_location_assignment PIN_G21 -to CLOCK_50 set_location_assignment PIN_B12 -to CLOCK_50_2 # DRAM Memory: # ============ set_location_assignment PIN_G8 -to DRAM_CAS_N set_location_assignment PIN_G7 -to DRAM_CS_N set_location_assignment PIN_E5 -to DRAM_CLK set_location_assignment PIN_E6 -to DRAM_CKE set_location_assignment PIN_B5 -to DRAM_BA_0 set_location_assignment PIN_A4 -to DRAM_BA_1 set_location_assignment PIN_F10 -to DRAM_DQ[15] set_location_assignment PIN_E10 -to DRAM_DQ[14] set_location_assignment PIN_A10 -to DRAM_DQ[13] set_location_assignment PIN_B10 -to DRAM_DQ[12] set_location_assignment PIN_C10 -to DRAM_DQ[11] set_location_assignment PIN_A9 -to DRAM_DQ[10] set_location_assignment PIN_B9 -to DRAM_DQ[9] set_location_assignment PIN_A8 -to DRAM_DQ[8] set_location_assignment PIN_F8 -to DRAM_DQ[7] set_location_assignment PIN_H9 -to DRAM_DQ[6]

22

set_location_assignment PIN_G9 -to DRAM_DQ[5] set_location_assignment PIN_F9 -to DRAM_DQ[4] set_location_assignment PIN_E9 -to DRAM_DQ[3] set_location_assignment PIN_H10 -to DRAM_DQ[2] set_location_assignment PIN_G10 -to DRAM_DQ[1] set_location_assignment PIN_D10 -to DRAM_DQ[0] set_location_assignment PIN_E7 -to DRAM_LDQM set_location_assignment PIN_B8 -to DRAM_UDQM set_location_assignment PIN_F7 -to DRAM_RAS_N set_location_assignment PIN_D6 -to DRAM_WE_N set_location_assignment PIN_B12 -to CLOCK_50_2 set_location_assignment PIN_C8 -to DRAM_ADDR[12] set_location_assignment PIN_A7 -to DRAM_ADDR[11] set_location_assignment PIN_B4 -to DRAM_ADDR[10] set_location_assignment PIN_B7 -to DRAM_ADDR[9] set_location_assignment PIN_C7 -to DRAM_ADDR[8] set_location_assignment PIN_A6 -to DRAM_ADDR[7] set_location_assignment PIN_B6 -to DRAM_ADDR[6] set_location_assignment PIN_C6 -to DRAM_ADDR[5] set_location_assignment PIN_A5 -to DRAM_ADDR[4] set_location_assignment PIN_C3 -to DRAM_ADDR[3] set_location_assignment PIN_B3 -to DRAM_ADDR[2] set_location_assignment PIN_A3 -to DRAM_ADDR[1] set_location_assignment PIN_C4 -to DRAM_ADDR[0] # Flash Memory: # ============= set_location_assignment PIN_R2 -to FL_ADDR[21] set_location_assignment PIN_P3 -to FL_ADDR[20] set_location_assignment PIN_P1 -to FL_ADDR[19] set_location_assignment PIN_M6 -to FL_ADDR[18] set_location_assignment PIN_M5 -to FL_ADDR[17] set_location_assignment PIN_AA2 -to FL_ADDR[16] set_location_assignment PIN_L6 -to FL_ADDR[15] set_location_assignment PIN_L7 -to FL_ADDR[14] set_location_assignment PIN_M1 -to FL_ADDR[13] set_location_assignment PIN_M2 -to FL_ADDR[12] set_location_assignment PIN_M3 -to FL_ADDR[11] set_location_assignment PIN_N1 -to FL_ADDR[10] set_location_assignment PIN_N2 -to FL_ADDR[9] set_location_assignment PIN_P2 -to FL_ADDR[8] set_location_assignment PIN_M4 -to FL_ADDR[7] set_location_assignment PIN_M8 -to FL_ADDR[6] set_location_assignment PIN_N6 -to FL_ADDR[5] set_location_assignment PIN_N5 -to FL_ADDR[4] set_location_assignment PIN_N7 -to FL_ADDR[3] set_location_assignment PIN_P6 -to FL_ADDR[2] set_location_assignment PIN_P5 -to FL_ADDR[1] set_location_assignment PIN_P7 -to FL_ADDR[0] set_location_assignment PIN_AA1 -to FL_BYTE_N set_location_assignment PIN_N8 -to FL_CE_N

23

set_location_assignment PIN_R7 -to FL_DQ[0] set_location_assignment PIN_P8 -to FL_DQ[1] set_location_assignment PIN_R8 -to FL_DQ[2] set_location_assignment PIN_U1 -to FL_DQ[3] set_location_assignment PIN_V2 -to FL_DQ[4] set_location_assignment PIN_V3 -to FL_DQ[5] set_location_assignment PIN_W1 -to FL_DQ[6] set_location_assignment PIN_Y1 -to FL_DQ[7] set_location_assignment PIN_T5 -to FL_DQ[8] set_location_assignment PIN_T7 -to FL_DQ[9] set_location_assignment PIN_T4 -to FL_DQ[10] set_location_assignment PIN_U2 -to FL_DQ[11] set_location_assignment PIN_V1 -to FL_DQ[12] set_location_assignment PIN_V4 -to FL_DQ[13] set_location_assignment PIN_W2 -to FL_DQ[14] set_location_assignment PIN_R6 -to FL_OE_N set_location_assignment PIN_R1 -to FL_RST_N set_location_assignment PIN_M7 -to FL_RY set_location_assignment PIN_P4 -to FL_WE_N set_location_assignment PIN_T3 -to FL_WP_N set_location_assignment PIN_Y2 -to FL_DQ15_AM1 # Green LEDs: # =========== set_location_assignment PIN_J1 -to LEDG[0] set_location_assignment PIN_J2 -to LEDG[1] set_location_assignment PIN_J3 -to LEDG[2] set_location_assignment PIN_H1 -to LEDG[3] set_location_assignment PIN_F2 -to LEDG[4] set_location_assignment PIN_E1 -to LEDG[5] set_location_assignment PIN_C1 -to LEDG[6] set_location_assignment PIN_C2 -to LEDG[7] set_location_assignment PIN_B2 -to LEDG[8] set_location_assignment PIN_B1 -to LEDG[9] # LCD Interface: # ============== set_location_assignment PIN_F21 -to LCD_BLON set_location_assignment PIN_F22 -to LCD_RS set_location_assignment PIN_E22 -to LCD_RW set_location_assignment PIN_E21 -to LCD_E set_location_assignment PIN_D22 -to LCD_DATA_BUS[0] set_location_assignment PIN_D21 -to LCD_DATA_BUS[1] set_location_assignment PIN_C22 -to LCD_DATA_BUS[2] set_location_assignment PIN_C21 -to LCD_DATA_BUS[3] set_location_assignment PIN_B22 -to LCD_DATA_BUS[4] set_location_assignment PIN_B21 -to LCD_DATA_BUS[5] set_location_assignment PIN_D20 -to LCD_DATA_BUS[6] set_location_assignment PIN_C20 -to LCD_DATA_BUS[7] # PS/2 Serial Port: # ================= set_location_assignment PIN_P22 -to PS2_KBCLK

24

set_location_assignment PIN_P21 -to PS2_KBDAT set_location_assignment PIN_R21 -to PS2_MSCLK set_location_assignment PIN_R22 -to PS2_MSDAT # Push Button Switches: # ===================== set_location_assignment PIN_H2 -to PB[0] set_location_assignment PIN_G3 -to PB[1] set_location_assignment PIN_F1 -to PB[2] # SD Card Interface: # ================== set_location_assignment PIN_Y21 -to SD_CLK set_location_assignment PIN_Y22 -to SD_CMD set_location_assignment PIN_AA22 -to SD_DAT0 set_location_assignment PIN_W21 -to SD_DAT3 set_location_assignment PIN_W20 -to SD_WP_N # Seven-Segment Displays: # ======================= set_location_assignment PIN_E11 -to HEX0_D[0] set_location_assignment PIN_F11 -to HEX0_D[1] set_location_assignment PIN_H12 -to HEX0_D[2] set_location_assignment PIN_H13 -to HEX0_D[3] set_location_assignment PIN_G12 -to HEX0_D[4] set_location_assignment PIN_F12 -to HEX0_D[5] set_location_assignment PIN_F13 -to HEX0_D[6] set_location_assignment PIN_D13 -to HEX0_DP set_location_assignment PIN_A13 -to HEX1_D[0] set_location_assignment PIN_B13 -to HEX1_D[1] set_location_assignment PIN_C13 -to HEX1_D[2] set_location_assignment PIN_A14 -to HEX1_D[3] set_location_assignment PIN_B14 -to HEX1_D[4] set_location_assignment PIN_E14 -to HEX1_D[5] set_location_assignment PIN_A15 -to HEX1_D[6] set_location_assignment PIN_B15 -to HEX1_DP set_location_assignment PIN_D15 -to HEX2_D[0] set_location_assignment PIN_A16 -to HEX2_D[1] set_location_assignment PIN_B16 -to HEX2_D[2] set_location_assignment PIN_E15 -to HEX2_D[3] set_location_assignment PIN_A17 -to HEX2_D[4] set_location_assignment PIN_B17 -to HEX2_D[5] set_location_assignment PIN_F14 -to HEX2_D[6] set_location_assignment PIN_A18 -to HEX2_DP set_location_assignment PIN_B18 -to HEX3_D[0] set_location_assignment PIN_F15 -to HEX3_D[1] set_location_assignment PIN_A19 -to HEX3_D[2] set_location_assignment PIN_B19 -to HEX3_D[3] set_location_assignment PIN_C19 -to HEX3_D[4] set_location_assignment PIN_D19 -to HEX3_D[5] set_location_assignment PIN_G15 -to HEX3_D[6] set_location_assignment PIN_G16 -to HEX3_DP # Toggle (slide) Switches:

25

# ======================== set_location_assignment PIN_J6 -to SW[0] set_location_assignment PIN_H5 -to SW[1] set_location_assignment PIN_H6 -to SW[2] set_location_assignment PIN_G4 -to SW[3] set_location_assignment PIN_G5 -to SW[4] set_location_assignment PIN_J7 -to SW[5] set_location_assignment PIN_H7 -to SW[6] set_location_assignment PIN_E3 -to SW[7] set_location_assignment PIN_E4 -to SW[8] set_location_assignment PIN_D2 -to SW[9] # VGA Interface: # ============== set_location_assignment PIN_L22 -to VGA_VS set_location_assignment PIN_L21 -to VGA_HS set_location_assignment PIN_K22 -to VGA_B[0] set_location_assignment PIN_K21 -to VGA_B[1] set_location_assignment PIN_J22 -to VGA_B[2] set_location_assignment PIN_K18 -to VGA_B[3] set_location_assignment PIN_H22 -to VGA_G[0] set_location_assignment PIN_J17 -to VGA_G[1] set_location_assignment PIN_K17 -to VGA_G[2] set_location_assignment PIN_J21 -to VGA_G[3] set_location_assignment PIN_H19 -to VGA_R[0] set_location_assignment PIN_H17 -to VGA_R[1] set_location_assignment PIN_H20 -to VGA_R[2] set_location_assignment PIN_H21 -to VGA_R[3] # RS-232: # ============== RX- PIN_U22 TX- PIN_U21 Por tanto, si queremos conectar nuestra entrada ‘clk’ al pin del reloj de la placa de 50MHz tendremos que hacerlo al PIN_G21. Para hacer la asignación de pines realizamos: Assignments->Pin Planner

26

A continuación nos salen las entradas/salidas que hemos definido y que tendremos que asociar con pines de la lista anterior. Por tanto, asociamos clk a PIN_G21, reset lo asociamos al SW0 (PIN_J6) y finalmente el selector lo asociamos al SW1 (PIN_H5). Volvemos a compilar el circuito para hacer efectivas las asignaciones.

Configuración del analizador lógico Signal Tap Una vez llegados a este punto procedemos a crear un fichero .stp de la aplicación Signal Tap. Con esta aplicación podré observar en tiempo real la evolución de las señales que desee. Por tanto acciono Tools->Signal Tap II Logic Analyzer y conecto la placa al ordenador.

27

En el cuadro superior derecho activo el Hardware de forma que me detecte el USB-Blaster de la placa que acabo de conectar (acciono setup y selecciono USB-Blaster). Seguidamente, en el cuadro del centro derecho selecciono la señal de trigger (aquella a partir de las variaciones de la cual capturaré mis señales) En el apartado clk selecciono mi señal de reloj de 50MHz.

28

Seguidamente, el el cuadro del centro selecciono los pines que quiero. Elijo “Design Entry (all names)” y selecciono qout, outa, outb, reset y selector).

Grabamos el fichero stp y volvemos a compilar el diesño.

29

Programación Una vez compilado el diseño pasamos a la programación del dispositivo. Asegúrate que la placa está conectada mediante el cable USB. Activa la alimentación con el pulsador rojo y pon el switch de la placa en posición RUN (no en la posición PROG). Seguidamente vete a Tools>Programmer. En principio te ha de salir ya seleccionado el fichero “prova.sof” de configuración de la FPGA. Si no sale búscalo accionando el botón “add file”. Finalmente aprieta el botón “Start” para configurar la FPGA. Asegúrate que has activado la opción Program/Configure que hay en la ventana de configuración.

Monitorización del funcionamiento del circuito mediante Signal Tap Seguidamente pasamos a monitorizar el comportamiento del cirucito. Abrimos el fichero Signal Tap que hemos configurado anteriormente y que hemos asociado al proyecto. Activamos la pestaña “Data” para observar los datos seleccionados. Seguidamente accionamos Processing>Run Analysis (ó aprtamos F5). Vemos que nos muestra una captura de la señal temporal de las entradas/salidas que hemos seleccionado. También podemos hacer una captura contínua con Processing>Autorun Analysis (F6). Si queremos ver los datos proporcionados en forma decimal seleccionamos outa, outb y qout, y presionamos el botón derecho del ratón. Nos vamos a “Bus Display Format” y seleccionamos “Unsigned Decimal”.

30

Seguidamente prueba de accionar los interruptores de reset y selector para ver el efecto en la salida. Si queremos variar la frecuencia de operación de la FPGA podemos hacerlo internamente mediante las PLLs incorporadas. Para insertar una PLL tenéis que insertar el bloque ALTPLL.

31

Teneis que incluir cuál es la frecuéncia de entrada de la FPGA (50MHz ó 20ns de período).

Seleccionad un factor multiplicador o divisor. Por ejemplo un factor divisor de 10 para obtener una frecuéncia de 5MHz. Finalmente el diseño os quedará de la siguiente forma:

32

Acordaros de renombrar todos los relojes del diseño (cambiar clk por ckl0 en el contador y la memoria). Finalmente compilad el diseño de nuevo y reconfigurad la FPGA. Una vez hecho esto volved a abrir el fichero .stp para ver el nuevo resultado. Podeis incluir el tiempo en el diagrama temporal (botón derecho, “insert time bar”. Definid un tiempo de 20ns (puesto que el muestreo de la FPGA se hace con la señal ‘clk’ y no con la ‘clk0’).

Finalmente observad el resultado.