Creación de un Proyecto con la Placa de Desarrollo de FPGA Terasic DE0-Nano

El DE0-Nano es una de las placas de desarrollo para FPGA más populares debido a su bajo costo (menos de $100) y porque usa el FPGA Cyclone IV de Altera. El Cyclone IV es un circuito integrado lógico de bajo costo y bajo consumo de poder con más de 22 mil elementos lógicos.

La placa contiene:

- 2 conectores de 20 pines, 72 GPIO (pines de entrada y salida), dos pines de +5V, dos de +3V3 y cuatro de tierra

- 1 conector de 26 pines, 18 GPIO y 8 pines de entrada analógica para el ADC

- 1 ADC (convertidor de señal analógica a digital) de 12 bits

- 1 EEPROM de 2Kb (memoria reprogramable)

- 1 acelerómetro

Fig 1. Placa de Desarrollo de FPGA Terasic DE0-Nano

Terasic también provee programas para facilitar el uso del DE0-Nano: El panel de control (Control Panel) y el creador de sistemas (System Builder). El Control Panel permite comunicaciones y control del DE0-Nano desde una computadora. Desafortunadamente, tuve problemas para instalar el programa en mis 2 computadoras, por lo que no lo incluiré en esta guía.

El System Builder es una herramienta bastante útil que simplemente crea los archivos necesarios para comenzar un proyecto. Los archivos creados incluyen:
- .QPF: Archivo proyecto para Altera Quartus II
- .V: Archivo de Verilog declarando los puertos de entrada y salida del FPGA
- .QSF: Archivo con la asignación y configuración de pines de FPGA
- .SDC: Archivo para verificación y prueba de tiempos
- .HTML: Descripción detallada de cada pin

Fig 2. Mapa físico del DE0-Nano

Toda la información en esta guía puede ser encontrada en la página web de Terasic (en inglés) en la pestaña “Resources”. A continuación les dejo los pasos para crear un proyecto en el DE0-Nano.



1. PREPARACION DEL SOFTWARE


1.1. Software de Altera

Primero, necesitamos descargar Quartus II de la página web de Altera. Quartus II es un ecosistema que nos permite compilar, sintetizar, verificar y analizar nuestro código, además de crear mapas de RTL, simulaciones, entre otras cosas.

A menos que tengas acceso a una licencia pagada, vamos a usar la versión Web Edition.

Fig 3. Altera Quartus II main window

Puedes descargar Quartus II v15.0 y ModelSim en la página web de Altera. El archivo pesa varios GB y tarda entre 10 a 20 minutos en instalar debido a su tamaño.


1.2. Software de Terasic

El DE0-Nano viene acompañado de un CD-ROM con los manuales, proyectos de muestra y los programas necesarios para usar nuestra placa. Si no tienes el CD-ROM, puedes descargar una copia en la página de Terasic.

Es posible crear nuestro proyecto sin utilizar el System Builder. Sin embargo, ese programa nos ahorrará bastante tiempo al crear el archivo QSF de sistema.


1.3. Altera USB Blaster

Para poder conectar el FPGA con Quartus II necesitamos instalar el driver respectivo. Por fortuna, este viene incluido con la descarga de Quartus II, pero tiene que ser instalado manualmente.

Para instalar el driver:

- Conecta el DE0-Nano a tu computadora utilizando un cable de mini-USB.
- Abre el menú de Inicio y escribe “Administrador de Dispositivos” o “Device Manager” dependiendo de tu versión de Windows.
- Una vez abierto el Administrador, busca la opción para “Otros Dispositivos”.
- Haz click con el botón derecho del ratón en el dispositivo con la símbolo amarillo y selecciona “Actualizar software de Controlador...”
- Luego, selecciona Buscar Controlador en mi Computadora y selecciona la carpeta donde Quartus II esta instalado. Asegúrate de seleccionar el cuadrito para Incluir Subcarpetas.



2. CREACION DEL PRIMER PROYECTO

2.1. System Builder

Necesitamos dos archivos para comenzar: El archive de proyecto para Quartus II (QPF) y el archivo de configuración (QSF). Afortunadamente, el System Builder puede crearlos por nosotros.

- En el CD-ROM, abre la carpeta Tools y dentro de ésta, la carpeta DE0_Nano_SystemBuilder. En ella encontrarás el archivo ejecutable DE0_Nano_SystemBuilder.ex
- Una vez abierto el System Builder, nombra tu proyecto,  selecciona “GPIO Default” y crea un nombre genérico para ambos conectores.
- Luego, selecciona “Generate” y escoge dónde quieres guardar tu nuevo proyecto.

Fig 4. Terasic DE0-Nano System Builder

2.2. Quartus II

- Abre la carpeta donde creaste tu Nuevo proyecto y abre el archive QPF. Esto abrirá el programa Quartus II.
- Haz click en el menú Project (proyecto) y luego en Add/Remove Files (agregar/remover archivos) y luego sobre el ícono con los puntos suspensivos (…)
- Busca y elige el archivo con formato .V (Verilog) y luego haz click en Add y luego en OK.
- Double click on the Verilog file to see the template for our project.
- En la ventana principal de Quartus II, busca la pestaña Files para ver los archivos en el proyecto y haz doble click sobre el archivo de Verilog que agregaste.

Fig 5. Agregando archivos a proyecto

Fig 6. Quartus II mostrando los archivos en el proyecto

El archivo de verilog contiene las instancias de cada pin del FPGA gracias al System Builder.

Como nuestro objetivo es simplemente crear un circuito para probar nuestra placa, reemplaza el código en tu archivo Verilog con el código que les dejo a continuación.

NOTA: El módulo principal tiene que tener el mismo nombre que el proyecto. En mi caso, uso el nombre Project1.


module Project1(        // Modulo principal debe tener mismo nombre
input CLOCK_50,         // que el archive de proyecto
output reg [7:0]LED
);

reg   [25:0]count;     
reg   clk2;
reg   state=0;

// divisor de freqcuencia 50MHz a 1Hz
always@(posedge CLOCK_50)
    begin
        if(count==26'd25_000_000)    // cuenta hasta 25M ciclos de reloj
            begin                    // cambia clk2 hi or lo
             count<=0;               
             clk2 <= ~clk2;         
            end
        else
            begin
             count<=count+1;
            end
    end    

// maquina de estados para LEDs
always @(posedge clk2)
      begin
             case(state)
             1'b0:      begin
                  LED[7:0] <= 8'b01010101;
                  state <= 1'b1;
                  end
            1'b1:       begin
                  LED[7:0] = 8'b10101010;
                  state <= 1'b0;
                  end
            Default: begin
                  state <= 1'b0;
                  end
            endcase    
      end
endmodule


El código hace dos cosas, crea un divisor de reloj de 1Hz y crea una máquina de estados para hacer parpadear los LED en la placa.

Si no deseas copiar y pegar el codigo que les deje arriba, puedes descargarlo en un archivo de Verilog desde mi repositorio de Github bajo el nombre Project1.v
Recuerda cambiar el nombre del archivo y del módulo principal con el mismo nombre de tu proyecto. Sólamente necesitas agregarlo a tu proyecto (ver sección 2.2).



2.3. Compilación el Proyecto

- Cuando tu código de Verilog este listo, haz doble click en Compile Design. El proceso normalmente tarde uno o dos minutos dependiendo de tu sistema.
- Asumiento que no hay errores, haz doble click en EDA Netlist Writer para crear un archivo binario para configurar el FPGA.
- Finalmente, haz doble click en Program Device para abrir el programador de Quartus II.


2.4. Configuración el FPGA

- En la ventana principal de Quartus II Programmer debe de aparecer el archivo SOF creado por tu proyecto.
- En la esquina superior izquierda, haz click en Hardware Setup y selecciona “USB-Blaster”. Si no te aparece esa opción, mira la sección 1.3 de esta guía.
- Finalmente, haz click en “Start” en la ventana principal de Programmer y mira tu DE0-Nano en acción.

Nota: Los FPGA son dispositivos volátiles, por lo tanto perderás la configuración apenas desconectes la fuente de poder. Para mantener la configuración, debes de guardarla en la memoria flash montada en la placa.

Fig 7. Seleccionando hardware para programar el dispositivo

Fig 8. Notificación de programación exitosa del FPGA

2.5. Código de Prueba DE0-Nano


Si simplemente deseas probar tu placa, puedes descargar el archivo SOF que he creado para este proyecto y cargarlo en el FPGA usando Quartus II Programmer (ver sección 2.4)

Creating a Project with the Terasic DE0-Nano FPGA Development Board

The DE0-Nano is one of the most popular development boards due to its low price (less than $100) and the Altera Cyclone IV FPGA, a low-cost, low-power device that provides more than 22K logic elements.

The board features:

- 2 x 20-pin headers, providing a total of 72 GPIO pins, two +5V pins, two +3V3 pins and four GND pins.

- 1 x 26-pin header, providing 18 GPIO pins and 8 pins for analog input.

- 1 x  12-bit ADC

- 1 x 2Kb EEPROM

- 1 x Accelerometer

Fig 1. Terasic DE0-Nano FPGA board

Terasic also provides software with a Control Panel and a System Builder. The Control Panel allows you to communicate with the board using your computer. Unfortunately, I was unable to make the program run in two different computers, so I won't be including it in my tutorials. The System Builder simply creates some basic files to help you starting a project: a QPF file (Quartus II project file), a Verilog file (declaring all I/O), a QSF file (FPGA pin assignment), a SDC file (timing constraints for testing) and an HTML file to view the descriptions of the I/Os.

Fig 2. DE0-Nano device layout

Most of the information in this tutorial can be found in far more detail in Terasic’s website in the Resources tab.

Here are the steps to create a project from scratch:

1. PREPARING THE SOFTWARE

1.1. Altera Software

Unless you have access to a paid license, we will be using the Web Edition of Altera Quartus II. This HDL analysis and synthesis tool provides compilation, timing analysis, RTL diagrams and simulation, among other features. The second tool that we want to install is ModelSim,  a simulation tool.

Fig 3. Altera Quartus II main window

You can download Quartus II v15.0 and ModelSim in Altera's website. 

1.2. Terasic Software

While it is possible to start a project without the software provided by Terasic, I recommend copying it to your computer since it provides the manuals, a few sample projects and the System Builder. 

If you don’t have the CD-ROM that came with the board, you can download the contents from this link.

1.3. Altera USB Blaster

In order to interface our DE0-Nano with our computer, we need to install its respective driver. Fortunately, no downloads are necessary if you already installed Quartus II.

To install the driver:

- Connect the DE0-Nano to your computer using a mini-USB cable.

- Go to Start Menu, type “Device Manager” and click on it once it appears under Control Panel.

- In the Device Manager, expand the Other Devices branch.

- Right-click on Unknown Device and click on Update Driver Software.

- Select “Browse my computer for driver software”, click on “Search for driver software in this location” and select the folder where Quartus II is installed. Make sure “Include subfolders” is marked.

2. CREATING YOUR FIRST PROJECT

2.1. System Builder

We need two files to start a project: The Quartus II project file (QPF) and the Settings File (QSF), which contains the PIN assignments, constraints, I/O settings and the pin timings.

Out of convenience, we are going to use the System Builder to create a Settings File specific to the DE0-Nano, the project file and template Verilog file:

- In the CD-ROM provided by Terasic, find the Tools folder, then the DE0_Nano_SystemBuilder folder and open DE0_Nano_SystemBuilder.exe

- In the System Builder, give a name to your project, select GPIO Default for both GPIO headers and give a prefix name for each header.

- Next, click on Generate and select a folder to place the new files.

Fig 4. Terasic DE0-Nano System Builder

2.2. Quartus II

- Open the QPF file that you created using the System Builder. This will open our project in Altera Quartus II.

- Click on the Project menu, then  Add/Remove Files in Project and click on the icon with the 3 dots (…)  

- Find the Verilog (.v) file created by the System Builder, click on Add and then OK.

The Verilog file should now appear in the Files window in Quartus II.

- Double click on the Verilog file to see the template for our project.

The Verilog file will have instantiations for all the FPGA pins available through the DE0-Nano board.

Fig 5. Adding files to project

Fig 6. Quartus II showing files in project

Since we want to create a simple project to test our board, we will delete the code in the Verilog file and paste the following code. 

NOTE: The top module must match the name of the project. I used Project1 in my example, so make sure that you change it accordingly. 

module Project1(        // The top-level module must match the name

input CLOCK_50,         // of the project file

output reg [7:0]LED

);

reg   [25:0]count;     

reg   clk2;

reg   state=0;

// clock divider 50MHz to 1Hz

always@(posedge CLOCK_50)

    begin

        if(count==26'd25_000_000)    // counts 25M clk cycles and

            begin                    // toggles clk2 hi or lo

             count<=0;               

             clk2 <= ~clk2;         

            end

        else

            begin

             count<=count+1;

            end

    end    

// state machine blinks on-board LEDs

always @(posedge clk2)

      begin

             case(state)

             1'b0:      begin

                  LED[7:0] <= 8'b01010101;

                  state <= 1'b1;

                  end

            1'b1:       begin

                  LED[7:0] = 8'b10101010;

                  state <= 1'b0;

                  end

            Default: begin

                  state <= 1'b0;

                  end

            endcase    

      end

endmodule

The code does two things. It creates a clock divider to create a 1Hz clock, and a state machine to make the on-board LEDs blink.

Note: If you do not want to copy and paste the code provided above, you can get a copy of my Project1.v Verilog file from my Github repository. Just make sure that you change the name of the file and the top-module to match the name of your project. All you need to do is add the file through the Projects menu.

2.3. Compiling the Design

- Once you Verilog file is ready, double-click on Compile Design. The compilation process should take a minute or two.

- Assuming there are no errors, double-click on EDA Netlist Writer.

- Finally, double-click on Program Device to open the Quartus II Programmer.

2.4. Configuring the FPGA

- In the Quartus II Programmer main window you should be able to see the SOF file for your project and the model number of your FPGA.

- In the top left, click on Hardware Setup and select “USB-Blaster” in the drop down menu. If you don’t see that option, read up section 1.3.

- Finally, press Start and the DE0-Nano should be configured.

Note: You are configuring the FPGA only. FPGAs are volatile devices, and will lose their configuration as soon as you power cycle it. To make your configuration permanent, you’ll have to create a file using Quartus II to configure the flash memory on the DE0-Nano.

Fig 7. Selecting programming hardware

Fig 8. Board programmed successfully

2.5. Test Code for the DE0-Nano

If you simply want to test your DE0-Nano board, here’s the SOF file that I created. Simply load it in the Quartus II Programmer (no need to open the compiler) and repeat section 2.4.

Microprocesadores vs Microcontroladores vs FPGA

Cuando hablamos de circuitos digitales, oímos de dispositivos lógicos como CPUs, microprocesadores, microcontroladores, PLDs, ASICs, FPGAs, entre otros. Pero, en qué se diferencian?


En este artículo trataré de explicar sus principales diferencias sin entrar en muchos detalles técnicos.

CPU vs Microprocesador

El CPU (Unidad Central de Procesos en inglés) es la parte de un sistema que secuencia y ejecuta instrucciones usando aritmética básica, lógica, control y operaciones de entrada y salida. El CPU es la parte encargada de los procesos, por lo que también se le conoce como procesador.

En sus inicios, los CPUs estaban conformados por varios tubos de vacío interconectados con cables y eran tan grandes que ocupaban salones enteros. Años después, el transistor fue inventado y los CPU se volvieron más pequeños. Sin embargo, estos sistemas aún necesitaban bastante espacio.

Cuando los circuitos integrados fueron inventados, las unidades de proceso pudieron ser construidas en pequeños chips de silicona. Esos chips son lo que conocemos como microprocesadores.

En teoría, el CPU se refiere al procesador principal de un sistema y por lo tanto no todos los microprocesadores son necesariamente CPUs. Un buen ejemplo de esta diferencia sería la consola de videojuegos Sega Genesis. El sistema posee 2 microprocesadores, el Motorola 68K para la ejecución de juegos, video, entradas, etc, y el Zilog H80 para el proceso de sonidos. En este caso, el 68K es el CPU. Sin embargo, en práctica, la gente se refiere a casi todos los microprocesadores como CPUs.

Fig 1. Foto de ENIAC en U de Pennsylvania. El sistema contenía 18,000 tubos de vacío y usaba 174KW de poder

Fig 2. Microprocesador Intel 8086

Microprocesador vs Microcontrolador

Un microprocesador (MPU o µprocesador) no posee pines de entrada y salida (I/O), memoria u otros periféricos. En lugar de eso, sus pines funcionan como un bus para interactuar con componentes externos como I/O, memoria RAM, ROM, puertos seriales, etc.

Un microcontrolador (MCU o µcontrolador) integra el CPU, ROM, RAM, I/O y otros periféricos en un solo circuito integrado. Básicamente, es un sistema entero dentro de un chip.

Los microcontroladores son convenientes porque nos permiten programar la interfaz del CPU con todos los periféricos sin preocuparse por problemas de compatibilidad o diferencia de voltajes. Además, un microcontrolador cuesta menos que un sistema con microprocesador. Su principal desventaja es que están limitados por los periféricos construídos en el chip.

Un microprocesador es capaz de ejecutar cálculos más extensos y al depender de componentes externos, el sistema puede expandirse a diseños bastante complejos.  El ejemplo más común de un sistema con microprocesador sería una computadora de escritorio.

Fig 3. Diagrama comparando un microprocesador y un microcontrolador

ASIC vs PLD vs FPGA

Un Circuito Integrado de Aplicación Específica (ASIC) es un chip diseñado especialmente para ejecutar tareas específicas.

Los Dispositivos Lógicos Programable (PLD) y Matriz de Puertas Programables en Campo (FPGA) son dispositivos que pueden ser reprogramados para crear distintos circuitos digitales.

En pocas palabras, los PLDs y FPGAs son circuitos reprogramables mientras que los ASIC no.

Mientras que los 3 dispositivos pueden ser usados para crear circuitos digitales, los ASICs están optimizados para esas tareas. Además, consumen menos poder y pueden procesar señales más rápidamente. Para algunas aplicaciones, ésta pequeña diferencia puede hacer de los ASIC la única opción viable. No obstante, el ciclo de diseño de un ASIC dura bastante tiempo, es costoso y al no ser reprogramable, no pueden ser modificados por lo que deben pasar por un riguroso ciclo de prueba. Por otro lado, los PLD y FPGA dan bastante flexibilidad pues al ser reprogramables, los ciclos de prueba, validación y rediseño son más cortos.


PLD vs FPGA

La diferencia de estos dos dispositivos están en la arquitectura.

Los PLD están hechos de macroceldas y usan lógica combinatoria (Y, O) y flip-flops para crear sus circuitos. Los PLD originales fueron diseñados para reemplazar decenas de puertas lógicas de la familia 7400 (Y, O, NO).  El tipo más común de PLD es el Dispositivo Lógico Programable Complejo (CPLD) que básicamente contiene múltiples PLD interconectados.

Los FPGA están hechos de bloques lógicos, interconexiones y I/O. Los FPGA son volátiles, por lo que una memoria externa debe almacenar la configuración del dispositivo.

Para crear circuitos, los CPLD usan una combinación de cientos de puertas lógicas (Y, O, NO), por lo que el proceso se llama lógica combinatoria. Por otro lado, los FPGA usan Tablas de Consulta (LUT) para reconfigurar sus matrices de puertas.

Debido a su estructura, los CPLD pueden procesar señales más rapidamente. Sin embargo, debido al tamaño de las macroceldas, los CPLD están limitados a unos 500 flip-flops por dispositivo. Por otro lado, los FPGA pueden ser usados para crear circuitos más complejos ya que pueden contener más de 150,000 flip-flops.


Microcontrolador vs FPGA

Ahora hablaremos de los dos dispositivos más utilizados en la mayoría de proyectos.

Básicamente, un microcontrolador es un procesador con diferentes circuitos (periféricos) construidos dentro de un mismo chip. Todo lo que debemos de hacer para utilizarlo es programar el procesador con un lenguage como ensamblaje (assembly), C o C++.

Un FPGA es como un circuito en blanco con miles de puertas lógicas esperando a ser configuradas para crear otros circuitos. De hecho, podemos usar un FPGA para diseñar un procesador. Para configurarlos, usamos un Lenguaje de Descripción de Hardware (HDL) como Verilog o VHDL.

Para la mayoría de aplicaciones, los microcontroladores son la mejor solución. Son más baratos, fáciles de programar, consumen menos poder y contienen en sus periféricos todo lo que podamos necesitar.

Los microcontroladores usan procesos secuenciales (una tarea a la vez) mientras los FPGA pueden ejecutar procesos en paralelo. Debido a esto, los FPGA son la mejor opción para aplicaciones con señales de alta velocidad o que se procesan en tiempo real.

Microprocessor vs Microcontroller vs FPGA

Whenever we talk about digital systems, we hear about logic devices like CPUs, microprocessors, microcontrollers, PLDs, ASICs, FPGAs, among others. But, what is the difference between them?

This article will attempt to explain their main differences without getting too technical.

CPU vs Microprocessor

The CPU (Central Processing Unit) is the part of a system that sequences and executes instructions by performing basic arithmetic, logic, control, as well as input and output operations. It is the part of the system that does all the processing.

Back in the day, the CPU was a combination of vacuum tubes wired together and were housed in multiple cabinets. We are talking about computers that occupied entire rooms. Later on, the transistor made an appearance and the CPUs became much smaller. However, these CPUs still occupied lots of space.

When the integrated circuit was invented, scientists were able to put the entire processing unit in a small silicon chip. This is what we know as the microprocessor.

Technically, a CPU refers to the main processor in the system. Therefore, not all microprocessors are CPUs. A good example of this situation would be the Sega Genesis video-game console. It contains 2 microprocessors, the Motorolla 68K to handle most instructions, video processing, etc. and the Zilog H80 for sound processing. In this case, only the 68K would be the CPU. Nonetheless, for most people, both terms are interchangeable.

Fig 1. Photo of U of Pennsylvania's ENIAC. The system used 18,000 vacuum tubes and dissipated 174KW of power

Fig 2. The Intel 8086 microprocessor

Microprocessor vs Microcontroller

A microprocessor unit (aka MPU or µprocessor) usually won't have I/O pins, memory or other peripherals. Instead, it uses its pins as a bus to interface with external components such as digital and analog I/O, RAM, ROM, serial ports, etc.

A microcontroller unit (aka MCU or µcontroller) integrates a CPU core (microprocessor), ROM and RAM memory, I/O pins, as well as other peripherals like serial ports, counters, clocks, etc. in one chip.

Microcontrollers are convenient because they put a full system in one chip without having to worry about compatibility issues or voltage level differences. They are also cheaper than using a microprocessor system. Their main disadvantage, is that they are limited by the amount of built-in peripherals.

Microprocessors are capable of performing more extensive calculations and because of the use of external components, they can be expanded to very complex systems at the board-level. A good example of a microprocessor system would be a personal computer.

Fig 3. Diagram comparing a microprocessor and a microcontroller

ASIC vs PLD vs FPGA

An Application Specific Integrated Circuit (ASIC) is a chip customized to perform a specific task rather than general-purpose applications.

A Programmable Logic Device (PLD) and a Field Programmable Gate Array (FPGA) are devices that can be reconfigured to create different digital circuits.

Simply put, PLDs and FPGAs are reprogrammable while ASICs aren't.

The 3 devices could potentially perform the same tasks, however ASICs are optimized for them. This means, they use less power and can process signals in less time. In some high speed applications, this difference in efficiency can make an ASIC the only option available. On the downside, ASICs are very expensive, take a long time to be designed and validated, and making any changes requires making a new device. They are only feasible if the chip needs to be mass produced. A good example of ASICs would be the Bitcoin miners.


PLD vs FPGA

The original PLDs were designed to replace a few dozen 7400-series chips (AND, OR, NOT gates). They are made of macrocells with combinatorial logic (AND, OR) and flip-flops. The most common type of PLD is the Complex Programmable Logic Device (CPLD), which is basically multiple PLDs connected in one chip. They are non-volatile, which means you don't need to reconfigure them after turning off the power.

A FPGA is made of logic blocks, interconnects and I/O. To create circuits, FPGAs configures an array of logic gates following Look-up tables (LUTs). They are volatile, so they need to be reconfigured every time they are powered up. The configuration file is usually stored in a EEPROM or NAND memory.

Because of their simple structure, CPLDs can be used to perform faster tasks than FPGAs. However, because of the size of the macrocells, CPLDs are usually limited to have less than 500 flip-flops. FPGAs on the other hand, can be used for larger and more complex designs since they can contain more than 150,000 flip-flops.


Microcontroller vs FPGA

We already described the difference between those two, but when should we pick one over the other?

In simple terms, a microcontroller is a processor with different circuits (peripherals) already built for you. All you need to do is program it and it will be ready to use. They are usually programmed using assembly, C or C++.

A FPGA is a blank chip with a bunch of logic gates for you to build whatever you want. In fact, you could technically build a small microprocessor with a FPGA. To configure them, you need to code them using a Hardware Description Language (HDL) like Verilog or VHDL.

For most applications, a microcontroller will be the simplest solution. They are cheap, easy to program and consume less power.

Microcontrollers do sequential processing (run one task at a time) while FPGAs can run multiple processes in parallel. This makes FPGAs better suited for high-speed or real-time applications like DSP.

Mojo v2 Placa de Desarrollo de FPGA

Hace un par de años, ayudé a financiar un proyecto de Embedded Micro para crear Mojo (se pronuncia mou-llo), una placa de desarrollo de FPGA. La placa contiene:

- FPGA Spartan-6 XC6SLX9
- 84 pines de entrada/salida (I/O)
- 8 pines de entrada análoga
- 8 LEDs de uso genérico
- 1 botón de reinicio (reset)
- 1 LED para el estado de configuración del FPGA
- Regulador de voltaje entrante para 4.8V - 12V (5V recomendado)
- Microcontrolador ATmega32U4 para configurar FPGA, interfaz de USB y leer pines análogos
- Memoria flash integrada a la tarjeta para el archivo de configuración del FPGA

El microcontrolador usa una secuencia de arranque compatible con Arduino, para permitir cargar código usando simplemente USB. Embedded Micro también provee un cargador basado en java para cargar el codigo .bin para el Spartan-6 usando simplemente USB.

Esta placa de desarrollo me pareció muy conveniente gracias al potente FPGA Spartan-6. Además, en comparación a la mayoría de placas de desarrollo ofrecidas por Xilinx o Altera, el precio de ~$80 es de fácil acceso para los entusiastas.

Si deseas comprar la placa, o buscar instrucciones para descargar e instalar los programas requeridos por el Mojo, vista la página web de Embedded Micro.

Para la mayoría de mis proyectos de FPGA en este blog, estaré usando el Mojo v2.

Máquina de Estado Finita en Verilog - Usando botón para transiciones

Este código es un ejemplo de una máquina de estado en Verilog y puede ser usado en la placa de FPGA  Mojo.

El código enciende uno de los 8 LEDs a la vez en el Mojo. El LED encendido cambia cada vez que el botón de reinicio (Reset) en el Mojo es presionado.


module LED_state_machine1(

    input   clk,           // reloj de 50MHz   
    input   nRst,          // entrada de botón reset   
    input   cclk,          // reloj del microcontrolador AVR
    output  reg[7:0]led,   // salida a 8 LEDs en tarjeta  
    

  // las siguientes conexiones son para el microcontrolador en el Mojo
    output  spi_miso,          // conexiones SPI para AVR
    input   spi_ss,
    input   spi_mosi,
    input   spi_sck,
    output  [3:0] spi_channel, // AVR selección de canal
    input   avr_tx,            // AVR Tx => FPGA Rx
    output  avr_rx,            // AVR Rx => FPGA Tx
    input   avr_rx_busy        // AVR Rx buffer lleno
    );
// sólo para Mojo. asignar alta impedancia si pines no son usados.
assign  spi_miso = 1'bz;
assign  avr_rx = 1'bz;
assign  spi_channel = 4'bzzzz;

reg       rst;     // crea registro para botón

reg  [3:0]state=0; // crea registros para estados

always@(posedge clk)
 rst <= ~nRst;     // connects reset button to rst register

//beginning of state-machine
// inicio de máquina de estado
always@(posedge rst)  // máquina transiciona si rst es presionado
   begin              // comenzar secuencia de máquina de estado
    case(state)
     3'd0: begin
            led[7:0]<=8'b0000_0001;  // sólo led[1] encendido
            state <= 3'd1;           // saltar a estado 3'd0
           end
     3'd1: begin
            led[7:0]<=8'b0000_0010;  
            state <= 3'd2;           
           end           
     3'd2: begin
            led[7:0]<=8'b0000_0100;
            state <= 3'd3;
           end
     3'd3: begin
            led[7:0]<=8'b0000_1000;
            state <= 3'd4;
           end
     3'd4: begin
            led[7:0]<=8'b0001_0000;
            state <= 3'd5;
           end
     3'd5: begin
            led[7:0]<=8'b0010_0000;
            state <= 3'd6;
           end
     3'd6: begin
            led[7:0]<=8'b0100_0000;
            state <= 3'd7;
           end
     3'd7: begin
            led[7:0]<=8'b1000_0000; // 
            state <= 3'd0;          // volver a estado 0
           end
     default: state <= 3'b0; 
    endcase
   end
  end

endmodule

Máquina de Estado Finita en Verilog - LEDs cambiando automáticamente

Este código es un ejemplo de una máquina de estado en Verilog y puede ser usado en la placa de FPGA  Mojo.

El código enciende uno de los 8 LEDs a la vez en el Mojo. Los LED cambian automáticamente a 1Hz.


module LED_state_machine2(

    input   clk,           // reloj de 50MHz   
    input   rst_n,         // entrada de botón reset   
    input   cclk,          // reloj del microcontrolador AVR
    output  reg[7:0]led,   // salida a 8 LEDs en tarjeta  
    

  // las siguientes conexiones son para el microcontrolador en el Mojo
    output  spi_miso,          // conexiones SPI para AVR
    input   spi_ss,
    input   spi_mosi,
    input   spi_sck,
    output  [3:0] spi_channel, // AVR selección de canal
    input   avr_tx,            // AVR Tx => FPGA Rx
    output  avr_rx,            // AVR Rx => FPGA Tx
    input   avr_rx_busy        // AVR Rx buffer lleno
    );

// sólo para Mojo. asignar alta impedancia si pines no son usados.
assign  spi_miso = 1'bz;
assign  avr_rx = 1'bz;
assign  spi_channel = 4'bzzzz;

reg [25:0] count;      // crea registros para contador 
reg        clk2;
reg  [2:0] state=0;    // crea 8 registros para estados
wire rst = ~rst_n;     // conecta botón de reinicio a registro rst


// divisor de reloj 50MHz a 1Hz
always@(posedge clk)
    begin
        if(count==26'd25000000)  // cuenta 25M ciclos de clk              begin                  // cambia clk2 a alto o bajo
            count<=0;            
            clk2 <= ~clk2;       
          end
        else
          begin
            count<=count+1;
          end
    end    


// inicio de máquina de estado
always@(posedge clk2) // máquina cambia a 1Hz
 begin                // con transición de clk2
  if(rst)             //
   state <= 3'd0;     // volver a estado 0 si rst es presionado
  else                //
   begin              // comenzar secuencia de máquina de estado
    case(state)
     3'd0: begin
            led[7:0]<=8'b0000_0001;  // sólo led[1] encendido 
            state <= 3'd1;           // salta a estado 3'd1
           end
     3'd1: begin
            led[7:0]<=8'b0000_0010;  
            state <= 3'd2;           
           end           
     3'd2: begin
            led[7:0]<=8'b0000_0100;
            state <= 3'd3;
           end
     3'd3: begin
            led[7:0]<=8'b0000_1000;
            state <= 3'd4;
           end
     3'd4: begin
            led[7:0]<=8'b0001_0000;
            state <= 3'd5;
           end
     3'd5: begin
            led[7:0]<=8'b0010_0000;
            state <= 3'd6;
           end
     3'd6: begin
            led[7:0]<=8'b0100_0000;
            state <= 3'd7;
           end
     3'd7: begin
            led[7:0]<=8'b1000_0000; 
            state <= 3'd0;          // volver a estado 0
           end
     default: state <= 3'b0; 
    endcase
   end
  end

endmodule

Divisor de Reloj en Verilog

Este código es un ejemplo de un divisor de reloj de 50MHz a 5MHz en Verilog.

Nota: Este código sólo puede dividir frecuencias por números pares (2, 4, 6, 10, etc).  Para dividir frecuencias de reloj por números impares, visita éste articulo.

Los dispositivos lógicos programables operan a velocidades bastante altas. Por ejemplo, el reloj para el FPGA de la tarjeta Mojo opera a 50MHz. Si designáramos un circuito para encender y apagar un LED,  el LED lo haría a 50 o 25 millones de ciclos por segundo (dependiendo del diseño) y por lo tanto, sería imposible de observar con la vista.

Para solucionar esa situación, podemos usar el reloj del FPGA para crear relojes mas lentos. El concepto es simple. El circuito cuenta un número determinado de ciclos de reloj para cambiar una nueva señal a alta o baja. Esta nueva señal sería nuestro nuevo reloj.

La fórmula para calcular el nuevo reloj es simple:

   contador = (reloj_entrante / reloj_nuevo) / 2

entonces, para crear un reloj de 5MHz usando un reloj de 50MHz, nuestro contador usaría 5 ciclos de reloj entrante:

   contador = (50MHz / 5MHz) / 2 = (10) / 2 = 5

En la figura 1, simulamos el divisor de reloj de 50MHz a 5MHz usando Xilinx ISim para mostrar el comportamiento del reloj entrante (clk), el contador (count) y el nuevo reloj (clk2). Nótese que por cada 5 ciclos de clk, clk2 transiciona. La barra amarilla muestra el vector count cuando llega al valor 5 (3'b101) y es seguida por la transición en clk2.

Fig. 1. Simulación de divisor de reloj de 50MHz a 5MHz.

Ejemplo de código:

module clock_divider(
   input           clk,     // reloj entrante de 50MHz
   output reg      clk2,      // nuevo reloj de 5MHz
    );

reg [3:0] count;

// divisor de reloj 50MHz a 5MHz
always@(posedge clk)
    begin
        if(count==4'd4)      // cuenta 5 ciclos (0-4) de reloj    
            begin
              count<=0;      // reinicia cuenta a 0
              clk2 <= ~clk2; // transiciona clk2 a alto o bajo
            end
        else
            begin
            count<=count+1;  //  aumenta contador
            end                  end