Mediante el uso de FPGA es posible probar y analizar físicamente los modelos de

control que se generan mediante Matlab y Simulink, de tal forma que se genera una

plataforma de prototipado rápido dado que podemos convertir el programa de simulink

directamente desde Matlab a código HDL sin la necesidad de saber al detalle la

programación de forma manual, en este tutorial se mostrara como crear la aplicación

para encender y apagar un led con una frecuencia de 1Hz, así como con una

frecuencia de 5 Hz pudiendo seleccionar mediante un interruptor la frecuencia a la que

oscilara el led.

Para ello seguiremos la siguiente metodología:

Matlab-Simulink
Programar Funciones

Matlab-Simulink
Archivos Conv. a HDL

Quartus II
Símbolos

Quartus II
Diagrama

Quartus II
Asignación de Pines
+ Compilación

Quartus II
Programar FPGA Juan Camilo Marulanda I
Universidad Autónoma De Manizales
2016
 Figura 1 Metodología

Para iniciar calculamos la base del reloj que utilizaremos para la tarjeta DE0-Nano el

cual tiene capacidad para manejar relojes que van desde 200ns a 850µs y usaremos

una base de 100µs con el propósito de generar pulsos de 1 segundo de duración para

la señal de entrada, siguiendo Figura 1 Metodología, iniciamos con:

Matlab-Simulink Abrimos nuestro programa Matlab el cual debe tener

Programar Funciones
instalada la librería hdl coder, abriendo la pantalla inicial

como se muestra en la Figura 2 Pantalla Inicial de Matlab y ahí abriremos la librería de

Simulink.

Abrir Simulink

Figura 2 Pantalla Inicial de Matlab

Juan Camilo Marulanda I

Universidad Autónoma De Manizales
2016
Esto nos llevará a la Figura 3 librería de Simulink en donde abriremos un nuevo modelo

Abrir nuevo modelo

Figura 3 librería de Simulink

Y se abrirá el nuevo modelo como se muestra Figura 4 nuevo modelo en donde

generaremos nuestro modelo utilizando los bloques de la librería de simulink.

Juan Camilo Marulanda I

Universidad Autónoma De Manizales
2016
 Figura 4 nuevo modelo

Lo primero es generar los contadores que es nuestra señal de entrada, para

hacer que el led oscile con la frecuencia deseada de 1 Hz. ó con 5 Hz.

Así si usamos una base de tiempo de 100µs, esto es 0.000100 segundos así para

generar 1 segundo tenemos que multiplicar por 10000, si queremos el led apagado el

50% del tiempo y encendido el otro 50% entonces hacemos uso de un comparador el

cual comparara la entrada del contador contra 5000.

Y con la misma base de tiempo para generar una frecuencia de 5 Hz. requerimos un

tiempo de t = 1/f = 1/5 Hz = 0.2 segundos, así si tenemos 0.000100 segundos para

generar 0.2 segundos debemos multiplicar por 2000 y para el ciclo de trabajo del 50%

requeriremos un comparador contra 1000.

De la librería de simulink nos posicionamos en Sources y seleccionamos nuestra

entrada en que es un Counter Limited como se muestra en la Figura 5 Selección de

entrada y lo introducimos en nuestro modelo.

Abrir nuevo modelo

Juan Camilo Marulanda I

Universidad Autónoma De Manizales
2016
 Figura 5 Selección de entrada

Lo arrastramos a nuestro modelo y nos queda como en la Figura 6 Contador

Arrastramos al
nuevo modelo

Figura 6 Contador

Y con doble click derecho del mouse sobre el bloque Counter Limited abrimos sus

propiedades como se muestra en la

Introducimos 10000
en upper limit para
generar 1 segundo
Doble click derecho
del mouse

Juan Camilo Marulanda I

Universidad Autónoma De Manizales
2016
 Figura 7 Configuración del 1er. Contador

Repetimos los pasos anteriores para introducir un nuevo contador y generarle la base

de tiempo para 5 Hz.

Introducimos
Doble click derecho 2000 en upper
del mouse limit para generar
0.2 segundos

Figura 8 Configuración de 2do. Contador

Seleccionamos el comparador como se muestra en la Figura 9 Comparadores

De Logic and bit Operations

seleccionamos Compare to
constant y lo arrastramos al
modelo; hacemos esto dos
veces

Juan Camilo Marulanda I

Universidad Autónoma De Manizales
2016
 Figura 9 Comparadores

Configuramos los comparadores de acuerdo a los cálculos realizados quedando como

se muestra en la

Introducimos 5000
para el primer
comparador y 2000
para el segundo
comparador en
Constant Value

Doble click derecho

del mouse Seleccionamos Boolean en
Output data type

Figura 10 Configuración de Comparadores

Introducimos un switch selector a nuestro modelo como se muestra en la

De Commonly
Used Blocks

Seleccionamos Switch y lo
arrastramos al modelo

Figura 11 Switch
Juan Camilo Marulanda I
Universidad Autónoma De Manizales
2016
Seleccionamos una entrada selectora para activar el switch, una salida y conectamos

como se muestra en la siguiente Figura 12 modelo terminado.

Seleccionamos y
arrastramos al
modelo, conectamos
y renombramos la
entrada y la salida

Figura 12 modelo terminado

Posteriormente salvamos el archivo de nuestro modelo en una carpeta de trabajo en

donde pongamos todos los archivos del proyecto quedando como la Figura 13 Modelo

de aplicación para encendido de y apagado de led, así mismo agrupamos la aplicación

como se muestra en la Figura 14 Sistema agrupado.

Juan Camilo Marulanda I

Universidad Autónoma De Manizales
2016
 Figura 13 Modelo de aplicación para encendido de y apagado de led

Figura 14 Sistema agrupado

Una vez que ya lo hemos salvado, entonces continuamos con el paso 2 de la

metodología:

Matlab-Simulink Con control + E sacamos el dialogo de configuración y en la

Archivos Conv. a HDL
opción de solver configuramos como se muestra en la Figura

15 Configuración Solver

Seleccionamos
discrete

Seleccionamos
Seleccionamos 1 lo que
Solver significa que es
Seleccionamos un ciclo
Fixed-step

Figura 15 Configuración Solver

Juan Camilo Marulanda I
Universidad Autónoma De Manizales
2016
Ahí mismo en configuración de parámetros seleccionamos HDL Code Generator como

se ve en la Figura 16 Configuración HDL Code Generator

En Target seleccionamos
el archivo que estamos
trabajando, el lenguaje
VHDL y el folder de
trabajo

Seleccion
amos HDL
Seleccionamos
Code Generamos el
Generate HDL Code
Generator código

Figura 16 Configuración HDL Code Generator

Y en el área de trabajo de Matlab nos sale el mensaje de la Figura 17 Mensaje al

generar el código HDL.

En este archivo se
Importante que muestre cero encuentra nuestro código
errores

Figura 17 Mensaje al generar el código HDL

Juan Camilo Marulanda I

Universidad Autónoma De Manizales
2016
Al abrir nuestro el archivo con el código nos lo muestra así:

-- -------------------------------------------------------------
--
-- File Name: C:\Users\MA\Desktop\Ejemplo1\LEDONOFF\LEDONOFF.vhd
-- Created: 2016-03-02 20:12:27
--
-- Generated by MATLAB 8.3 and HDL Coder 3.4
--
--
-- -------------------------------------------------------------
-- Rate and Clocking Details
-- -------------------------------------------------------------
-- Model base rate: 1
-- Target subsystem base rate: 1
--
--
-- Clock Enable Sample Time
-- -------------------------------------------------------------
-- ce_out 1
-- -------------------------------------------------------------
--
--
-- Output Signal Clock Enable Sample Time
-- -------------------------------------------------------------
-- led_0 ce_out 1
-- -------------------------------------------------------------
--
-- -------------------------------------------------------------

-- -------------------------------------------------------------
--
-- Module: LEDONOFF
-- Source Path: LEDONOFF/LEDONOFF
-- Hierarchy Level: 0
--
-- -------------------------------------------------------------
LIBRARY IEEE;
USE IEEE.std_logic_1164.ALL;
USE IEEE.numeric_std.ALL;

ENTITY LEDONOFF IS
PORT( clk : IN std_logic;
reset : IN std_logic;
clk_enable : IN std_logic;
Key1 : IN std_logic;
ce_out : OUT std_logic;
led_0 : OUT std_logic
);
END LEDONOFF;

ARCHITECTURE rtl OF LEDONOFF IS

-- Signals
SIGNAL enb : std_logic;
SIGNAL switch_compare_1 : std_logic;
SIGNAL Counter_Limited1_count : unsigned(15 DOWNTO 0); -- ufix16
SIGNAL Counter_Limited1_out1 : unsigned(15 DOWNTO 0); -- uint16
SIGNAL Compare_To_Constant1_out1 : std_logic;

Juan Camilo Marulanda I

Universidad Autónoma De Manizales
2016
 SIGNAL Counter_Limited_count : unsigned(15 DOWNTO 0); -- ufix16
SIGNAL Counter_Limited_out1 : unsigned(15 DOWNTO 0); -- uint16
SIGNAL Compare_To_Constant_out1 : std_logic;
SIGNAL Switch_out1 : std_logic;

BEGIN
enb <= clk_enable;

switch_compare_1 <= '1' WHEN Key1 > '0' ELSE

'0';

-- Count limited, Unsigned Counter

-- initial value = 0
-- step value = 1
-- count to value = 2000
Counter_Limited1_process : PROCESS (clk, reset)
BEGIN
IF reset = '1' THEN
Counter_Limited1_count <= to_unsigned(16#0000#, 16);
ELSIF clk'EVENT AND clk = '1' THEN
IF enb = '1' THEN
IF Counter_Limited1_count = 2000 THEN
Counter_Limited1_count <= to_unsigned(16#0000#, 16);
ELSE
Counter_Limited1_count <= Counter_Limited1_count + 1;
END IF;
END IF;
END IF;
END PROCESS Counter_Limited1_process;

Counter_Limited1_out1 <= Counter_Limited1_count;

Compare_To_Constant1_out1 <= '1' WHEN Counter_Limited1_out1 <= 1000 ELSE

'0';

-- Count limited, Unsigned Counter

-- initial value = 0
-- step value = 1
-- count to value = 10000
Counter_Limited_process : PROCESS (clk, reset)
BEGIN
IF reset = '1' THEN
Counter_Limited_count <= to_unsigned(16#0000#, 16);
ELSIF clk'EVENT AND clk = '1' THEN
IF enb = '1' THEN
IF Counter_Limited_count = 10000 THEN
Counter_Limited_count <= to_unsigned(16#0000#, 16);
ELSE
Counter_Limited_count <= Counter_Limited_count + 1;
END IF;
END IF;
END IF;
END PROCESS Counter_Limited_process;

Counter_Limited_out1 <= Counter_Limited_count;

Compare_To_Constant_out1 <= '1' WHEN Counter_Limited_out1 <= 5000 ELSE

'0';

Juan Camilo Marulanda I

Universidad Autónoma De Manizales
2016
 Switch_out1 <= Compare_To_Constant1_out1 WHEN switch_compare_1 = '0' ELSE
Compare_To_Constant_out1;

ce_out <= clk_enable;

led_0 <= Switch_out1;

END rtl;

Quartus II Continuamos con la metodología y para ello abrimos el

Símbolos
programa Quartus II y lo primero que hacemos es crear un

Nuevo proyecto en File, New Project Wizard como se muestra en la Figura 18 New

Project Wizard y seguimos los pasos.

Figura 18 New Project Wizard

Le damos Next y seleccionamos el folder de trabajo y le asignamos nombre al proyecto

como se muestra en la Figura 19 Selección de folder de trabajo y nombre del proyecto.

Juan Camilo Marulanda I

Universidad Autónoma De Manizales
2016
 Figura 19 Selección de folder de trabajo y nombre del proyecto

Una vez hecho esto seguimos con la configuración dándole click al botón de Next y

agregamos nuestro archivo hdl generado con Matlab como se muestra en la Figura 20

Selección de Archivo

Buscamos el archivo y le
damos click al botón Add y
después a Next

Figura 20 Selección de Archivo

Juan Camilo Marulanda I

Universidad Autónoma De Manizales
2016
En el siguiente paso hay que configurar la familia del dispositivo y el dispositivo en si

como se muestra en la Figura 21 Selección del Dispositivo.

Familia de la FPGA y modelo de la

FPGA y damos click en Finish para
terminar de configurar el proyecto

Figura 21 Selección del Dispositivo

Juan Camilo Marulanda I

Universidad Autónoma De Manizales
2016
El siguiente paso es proteger nuestros pines de entrada-salida que no sean usados

para evitar dañarlos por accidente, activando el estado de alta impedancia (Tri-state)

para ello nos vamos al menú de Assigments --- Device --- Device and Pins Options---

unused pins ---- as input tri-state como se ve en la Figura 22 Configurando los pins no

usados como Input TRI-STATE.

Figura 22 Configurando los pins no usados como Input TRI-STATE

Juan Camilo Marulanda I

Universidad Autónoma De Manizales
2016
El siguiente paso es abrir un Block diagram schematic file que es el archivo donde

vamos a trabajar como se muestra en la Figura 23 Abrir un Block Diagram Schematic

File

File, New y seleccionamos Block

Diagram Schematic File

Figura 23 Abrir un Block Diagram Schematic File

Luego, en insert symbol abrimos la pantalla Mega Wizard Plug in Manager

Juan Camilo Marulanda I

Universidad Autónoma De Manizales
2016
 Seleccionamos la compuerta para insertar
componentes y en la ventana de Symbol
seleccionamos MegaWizard Plug-in Manager y le
damos a Next

Figura 24 Abriendo MegaWizard Plug-in Manager

Nos vamos hasta la ventana 2 de 14 y configuramos como aparece en la Figura 25

Selección de AtPLL.

De I/O seleccionamos AltPLL y en el

tipo de archive de salida VHDL
seleccionamos el nombre del archivo
ALTPPL0

Figura 25 Selección de AtPLL

Juan Camilo Marulanda I
Universidad Autónoma De Manizales
2016
Nos brincamos a la página 3 de 14 con next y seleccionamos la frecuencia de 50 MHz

como se muestra en la figura

50 MHz

Figura 26 Selección de frecuencia del PLL

En la página 4 de 14 nos aseguramos que nada tenga check-up como se ve en la

Figura 27 No Check-ups

Figura 27 No Check-ups

Juan Camilo Marulanda I

Universidad Autónoma De Manizales
2016
De aquí nos vamos hasta la página 8 de 14 y ponemos el reloj de salida en 0.01MHz.

Como se ve en la Figura 28 Pagina 8 de 14 Output clock frecuencia

10 MHz y
Finalizamos

Figura 28 Pagina 8 de 14 Output clock frecuencia

Después asignamos Pines

Aquí lo que vamos a hacer es asignar pines, antes

Quartus II
de Asignación
hacer de Pines
+ Compilación la asignación de pines hay que realizar los
siguientes pasos:

Seleccionamos Processing---- > Start ---- > Start Analysis & Synthesis

Juan Camilo Marulanda I

Universidad Autónoma De Manizales
2016
Luego Seleccionamos Assigment – pin planner como se ve en la imagen

Y nos aparece la siguiente imagen en la cual en Location vamos a realizar la

asignación de pines para las entradas y salidas

Juan Camilo Marulanda I

Universidad Autónoma De Manizales
2016
Y compilamos seleccionano Processing ---> Start Compilation

Juan Camilo Marulanda I

Universidad Autónoma De Manizales
2016
 Quartus II
Programar FPGA Una vez compilado el programa, programamos la FPGA de la

siguiente manera, seleccionamos Tools --- > Programmer

Y nos sale la siguiente pantalla en donde verificamos que la fpga está conectada,

agregamos el archivo e iniciamos en start viendo el progreso de la descarga

Juan Camilo Marulanda I

Universidad Autónoma De Manizales
2016
Y probamos nuestro circuito, podemos capturar la información de los datos del

experimento por medio de Tools --- > SignalTap II Logic Analyzer

El cual abre la siguiente Pantalla y podemos capturar los datos de nuestro experimento

y exportarlos a archivo .csv. con el propósito de analizarlo en Matlab.

Juan Camilo Marulanda I

Universidad Autónoma De Manizales
2016
 Juan Camilo Marulanda I
Universidad Autónoma De Manizales
2016