Buscar este blog

viernes, 28 de noviembre de 2014

PRACTICA # 1 LEDS SECUENCIALES UTILIZANDO AXI

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.

 Ø  Iniciamos vivado


Ø 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. Nota*: Es muy importante que el nombre del directorio en donde se almacene el proyecto no contenga espacios ej; C:\Descripciones_SoC.


  Ø 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