Encender los 8
leds de la tarjeta Zedboard utilizando el PS (Process System), PL (Programmable
Logic) y SDK.
Objetivo:
Por medio de las
herramientas que ofrece vivado crear un sistema base para el Soc Zynq de la
tarjeta ZedBoard utilizando los GPIO para comunicación externa y generar un
código en SDK para que encienda secuencialmente los leds.
Requerimientos:
·
Tarjeta ZedBoard
·
Cable microusb para
programación y debug de la tarjeta
·
Vivado 2013.4 o superior
·
Mucha paciencia xD
Parte # 1.
Generando el sistema base PS
En
esta parte de la práctica se creara un sistema base utilizando el PS y un core
GPIO que permitirá la comunicación directa con los leds de la tarjeta de
desarrollo. Dicho core se implementara en la parte PL y tendrá comunicación con
el sistema PS por medio del bus de interconexión AXI.
Ø Creamos un nuevo proyecto
haciendo clic en Create New Project,
clic en next y se desplegara una ventana para poner nombre al proyecto y
ubicación del mismo.
Ø Hacemos clic en next y en la siguiente pantalla escogemos la opción
RTL Project, al no tener otros archivos fuente seleccionamos la única casilla
que se encuentra en esa opción.
Ø Al darle clic en “Next”
aparecerá la ventanilla de “Default Part” donde seleccionaremos la tarjeta de
desarrollo que estamos ocupando, en nuestro caso es la tarjeta Zedboard.
Ø Al dar clic en “Next” de la ventana anterior, el wizard de Vivado
nos entrega un resumen del proyecto creado como se muestra a continuación.
Ø Damos clic en “Finish” y se abrirá el entorno de vivado
Ø Para comenzar crearemos un “Block Design” para ello iremos a la parte izquierda de la pantalla
donde encontramos el “Flow Navigator”
dentro de él iremos a la sección de “IP integrator”
y seleccionamos la opción “Create Block
Design” y Por ultimo le damos nombre a
nuestro Bloque.
Ø Al
hacer esto se abrirá un nuevo entorno de trabajo en donde agregaremos nuestros “IP Blocks”
Ø Para agregar un nuevo “IP Block” damos clic en el icono AddIP y dentro
del cuadro de texto escribimos zynq y hacemos doble clic en ZYNQ7 Processing System.
Ø Ahora agregaremos un bloque
genérico de entradas y salidas para ello realizamos el mismo procedimiento con
la diferencia de que ahora escribiremos AXI. Con el botón “Regenerate Layout” podemos ordenar los componentes.
Ø En el lienzo de trabajo hacemos clic sobre la opción Run
Block Automation y seleccionamos /precessing_system7_0. Dejamos las
opciones por default y damos clic en aceptar.
Ø Hacemos clic en Run Connection Automation y seleccionamos
/axi_gpio_0/S_AXI y después en aceptar. De igual manera lo hacemos para
/axi_gpio_0/GPIO
Ø El lienzo de trabajo queda de la siguiente forma
Ø Hacer doble clic sobre el bloque processing_system7_0. Como no se utilizara todas las conexiones
de las tarjeta de desarrollo las deshabilitaremos en la opción MIO Configuration. Y clic en aceptar.
Ø Ahora pasaremos a validar el diseño por medio del DRC (Design Rule
Check) haciendo clic en el icono
Ø Generaremos los archivos de salida seleccionando LEDS.bd y haciendo
clic derecho seleccionar la opción Generate
Output Products… y después clic en Generate
en la ventana que aparece.
Ø Una vez concluido el proceso
anterior volver a seleccionar LEDS.bd y hacer clic derecho y escoger Create
HDL Wrapper… En la siguiente ventana dejar la opción por default: Let
vivado manager wrapper and auto-update.
Ø Hacer
clic en Generate Bitstream en el
flow navigator.
Ø Una vez terminado el proceso
anterior abrimos el diseño en la pestaña Open
Implemented Design.
PARTE # 2. SDK
Ø Seleccionamos la base de datos LEDS.bd y escogemos Export Hardware for SDK…
Ø Seleccionamos las 3 opciones mostradas:
Ø Como resultado se abrirá el SDK xilinx en eclipse.
Ø El proyecto se realizara en
C++. Primero vamos a la opción en FILE à NEW àApplication Project. Escribimos el nombre del proyecto y
seleccionamos como lenguaje C++. Hacemos clic en next y luego finish.
Ø Abrimos el archivo main.cc y agregamos el siguiente código:
/*****************************************************************************/
/* I N C L U D E F I L E S */
/*****************************************************************************/
#include
"xparameters.h"
#include
"xgpio.h"
/*****************************************************************************/
/* C O N S T A N T
S */
/*****************************************************************************/
//The
following constant maps to the name of the hardware instances that
//
were created in the Vivado system.
#define
GPIO_EXAMPLE_DEVICE_ID
XPAR_AXI_GPIO_0_DEVICE_ID
//
The following constant is used to determine which channel of the GPIO is
//
used for the LED if there are 2 channels supported.
#define
LED_CHANNEL 1
/*****************************************************************************/
/* V A R I A B L E
S */
/*****************************************************************************/
XGpio
Gpio; // The Instance of the GPIO
Driver
/*****************************************************************************/
/* M A I N */
/*****************************************************************************/
int
main(void)
{
int Status,i;
long int ust_limit = 50000000;
volatile long int delay;
// Initialize the GPIO driver
Status = XGpio_Initialize(&Gpio, GPIO_EXAMPLE_DEVICE_ID);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
// Clear the LEDs
XGpio_DiscreteWrite(&Gpio,
LED_CHANNEL, 0);
while (1)
{
for(i=0;i<255;i++)
{
XGpio_DiscreteWrite(&Gpio, LED_CHANNEL,
i);
for(delay=0;delay<ust_limit;delay++){};
}
}
return XST_SUCCESS;
}
Ø Ahora pasaremos a programar la
tarjeta Zedboard, debemos de tener la tarjeta conectada a la fuente de
alimentación así como en su conector usb hacia la pc. Además de asegurarnos que
los jumpers de los modos de configuración estén ubicados para utilizar el JTAG.
En la barra de herramientas del SDK Xilinx Tools seleccionamos Program FPGA.
Ø Por ultimo Seleccionar Run as à Launch on Hardware (GDB)
Ø Aplicación corriendo en la tarjeta de desarrollo Zedboard
No hay comentarios.:
Publicar un comentario