Sistema Base con comunicación GPIO

Autor: M. en I. William Hidber Cruz

Instituto de Ciencias Nucleares, UNAM

Junio 2014

Esta práctica tiene como objetivo crear un Sistema base en el dispositivo Zynq, el cual tendrá

comunicación hacia el exterior por medio de los pines GPIO. Se ocuparan los Leds de la tarjeta de

desarrollo Zedboard para verificar que se están mandando datos hacia el exterior.

Requerimientos

La práctica requiere los siguientes dispositivos y software.

Zedboard.

Cable usb a microusb para programación de la tarjeta de desarrollo.

Vivado 2013.4 con SDK 2013.4 o Vivado 2014.1 con SDK 2014.1

Parte 1._ Diseño del Sistema base.

En esta parte del tutorial se creara el Sistema base, el cual posteriormente se programara

en SDK. EL sistema base hará referencia a la parte PS (Processing system) del dispositivo Zynq,

además ocuparemos un core GPIO el cual tendrá comunicación con los LEDs de la tarjeta de

desarrollo y estará implementado en la parte PL (Programmable logic) del dispositivo Zynq.

Iniciamos el software Vivado.

Creamos un nuevo proyecto, seleccionando la opción Create New Project. En el wizard que

se despliega a continuación seleccionamos next, ahora se desplegará la pantalla donde se

nos pedirá el directorio donde queremos guardar el proyecto. En este caso el proyecto se

llama Zynq_SistemBaseGPIO. A continuación pulsamos el botón Next.

En la siguiente ventana dejamos las opciones que están por default y pulsamos Next. En la

nueva ventana nos aseguramos que las opciones del lenguaje estén en VHDL, luego

pulsamos el botón Next. En la siguiente ventana no hacemos nada y pulsamos el botón Next.

En la nueva ventana que aparece, como no vamos a agregar archivos de restricción

pulsamos el botón Next. En la nueva ventana tenemos que asegurarnos que seleccionamos

la tarjeta de desarrollo con la que estamos trabajando, que en nuestro caso es la Zedboard.

Pulsamos el botón Next y la última ventana nos mostrara un resumen del proyecto que se

va a crear. Pulsamos Finish y con esto se abrirá el entorno de desarrollo de Vivado.

Lo primero que vamos a hacer es crear nuestro sistema base, para esto hacemos click en el

botón Create Block Design que se encuentre en el Flow Navigator (lado izquierdo de la

pantalla). Se abrirá un cuadro de dialogo en el cual le pondremos nombre a nuestro diseño.

Una vez que pulsemos el botón OK en el entorno de trabajo se abrirá el IP integrator. Desde

aquí crearemos nuestro diseño del sistema. En la parte superior del IP integrator aparece el

texto Add IP, hacemos click y se abrirá un cuadro de dialogo con diferentes cores que

podemos agregar a nuestro diseño.

Tecleamos Zynq y aparecerán dos opciones, seleccionamos ZYNQ7 Processing System y

apretamos enter. En el IP integrator aparecerá un bloque, este bloque pertenece a la parte

PS del dispositivo Zynq. Donde anteriormente apareció add IP ahora aparecerá Run Block

Automation, hacemos click y seleccionamos la opción /processing_system7_0, se

desplegara un cuadro de dialogo. En este cuadro de dialogo dejamos las opciones por

defecto. Esta opción lo que hace es realizar las conexiones que trae por defecto la parte PS

(MIO, Multiplexed Input Output) con pines externos de la tarjeta de desarrollo.

Debido a que no vamos a ocupar todas las conexiones de la tarjeta de desarrollo debemos

desconectar las innecesarias, para esto hacemos doble click sobre el bloque, con esto se

desplegara un cuadro de dialogo como el de la siguiente figura.

En la opción MIO Configuration hacemos click y posteriormente deseleccionamos todas las

interfaces que estén seleccionada. Por ultimo le damos click en el botón OK. Con esto ya

tendremos configurado nuestro bloque PS.

Ahora agregaremos los bloques necesarios (core GPIO) para comunicarnos con los LEDs de

la tarjeta de desarrollo. Para agregar un core hacemos click izquierdo con el botón derecho

del mouse y seleccionamos Add IP o también podemos presionar las teclas ctrl+I.

Adicionalmente agregamos los cores: Block memory generator y AXI Bram Controller.

Hacemos doble click en el bloque Block memory generator y en la ventana que aparece

cambiamos el valor de Memory type por True Dual Port RAM y hacemos click en el botón

OK. Nuestro lienzo de trabajo se parecerá a la figura de abajo.

Ahora colocamos el puntero del mouse sobre la salida BRAM_PORTA del core AXI BRAM

Controller, el puntero cambiara a la forma de un lápiz, hacemos click y sin soltar el botón

izquierdo del mouse arrastramos hasta la entrada BRAM_PORTA del core Block memory

generator y soltamos el botón del mouse. Hacemos lo mismo con el puerto BRAM_PORTB.

Nuestro diagrama quedara como en la figura de abajo.

En el lienzo de trabajo hacemos click sobre Run Connection Automation y seleccionamos

axi_bram_ctrl_0/S_AXI. En la ventana que aparece dejamos las opciones por defecto y

hacemos click en OK. Esto creara automáticamente un core para el bus AXI y se realizaran

las conexiones del bus AXI hacia el core AXI bram y hacia la PS. Nuestro lienzo de trabajo

ahora se parecerá a la siguiente figura.

Volvemos hacer click en Run Connection Automation y seleccionamos axi_gpio_0/S_AXI, en

la ventana que aparece dejamos las opciones por defecto y seleccionamos OK. Se harán las

conexiones automáticas con el bus AXI. Ahora volvemos hacer click en Run Connection

Automation y seleccionamos axi_gpio_0/GPIO y en la ventana que aparece seleccionamos

leds_8bits y hacemos click en el botón OK. Se creara un puerto hacia el exterior de la tarjeta,

los cuales se conectan a los leds de la tarjeta de desarrollo. Despues de esto hacemos click

en el botón la cual acomodara nuestro diseño, el resultado final será parecido a la figura

de abajo.

Ahora vamos a validar nuestro diseño por medio del DRC (Design Rule Check), para esto

hacemos click en el botón que se encuentra en el lado derecho de nuestro lienzo de

trabajo o presionando la tecla F6. Saldrá un mensaje diciendo que nuestro diseño es válido.

Salvamos nuestro proyecto presionando las teclas ctrl+S. Una vez salvado nuestro proyecto

seleccionamos la pestaña sources del entorno de trabajo.

Una vez seleccionado la pestaña source, hacemos click con el botón derecho del mouse y

seleccionamos la opción Generate Output Products. En la ventana que aparece

seleccionamos Generate. Esto tomara un par de minutos.

Una vez que haya terminado el proceso, volvemos a hacer click en el nombre de nuestro

sistema y ahora seleccionamos la opción Create HDL Wrapper. En la ventana que aparece

dejamos las opciones por defecto y seleccionamos OK. Para finalizar hacemos click en la

opción Generate bitstream en el Flow Navigator. Este proceso tomara un par de minutos,

dependiendo de la PC donde se este ejecutando. Una vez terminado el proceso aparecerá

una ventana preguntándonos si deseamos abrir el diseño implementado, lo abrimos.

Parte 2. SDK

Una vez que se abrió el diseño, en la barra de menús seleccionamos File Export Export

Hadware for SDK. En la ventana que aparece seleccionamos todas las opciones y damos

click en OK, Se abrirá SDK.

El proyecto lo realizaremos en C++. Primero vamos a la opción File New Application

Project, En la ventana que aparece le ponemos nombre a nuestro proyecto y seleccionamos

como lenguaje C++, hacemos click en Next y luego en Finish.

En el Project Explorer, abrimos la carpeta con el nombre de nuestro proyecto,

posteriormente abrimos la carpeta src y abrimos nuestro archivo main.cc para editarlo.

Creamos dos archivos más, Leds.h y Leds.cpp. Ambos archivos ubicados en la misma carpeta

src. El código para los tres archivos se muestra abajo. Para compilar solo salvamos nuestro

proyecto y automáticamente se compilara.

Leds.h

#include <xgpio.h> #include "xparameters.h" class Leds { public: /* * Constructor that initialize our GPIO core * Leds(Gpio name, GPIO Device ID, direction, channel) * @param Gpio name: Name of our Gpio device. * @param Gpio Device ID: device base address in the virtual memory * address space of our Gpio device. * @param direction: Bits set to 0 are output and bits set to 1 * are input. * @param channel: It contains the channel of our GPIO to operate on */ Leds(XGpio, u16, u32, unsigned); //Function that writes a value void dataWrite(u32); private: XGpio GpiosName; unsigned ChannelLeds; }; Leds.cpp #include <xgpio.h> #include "xparameters.h" #include "Leds.h" //Constructor Leds::Leds(XGpio GpioName, u16 deviceID, u32 writeRead, unsigned Channel) { XGpio_Initialize(&GpioName, deviceID); XGpio_SetDataDirection(&GpioName,Channel, writeRead); // set Leds as output ports GpiosName = GpioName; ChannelLeds = Channel; } void Leds::dataWrite(u32 dataLeds) { XGpio_DiscreteWrite(&GpiosName, ChannelLeds, dataLeds); }

main.cc #include <xgpio.h> #include "xparameters.h" #include "Leds.h" int main(){ XGpio leds; volatile long int delay; long int ust_limit(9999999); int i=0; //Create one Led object Leds ledsTest1(leds, XPAR_AXI_GPIO_0_DEVICE_ID, 0, 1); while(1) { for(i=0;i<255;i++) { ledsTest1.dataWrite(i); for(delay=0;delay<ust_limit;delay++){}; } } return 0; }

Una vez que tengamos los tres archivos pasaremos a programar la Zedboard. Para esto primero debemos asegurarnos que la tarjeta esté conectada, tanto a una fuente de alimentación como a nuestra PC. Además de asegurarnos que los jumpers de los modos de configuración estén configurados para utilizar el JTAG. En la barra de herramientas

seleccionamos Program FPGA ( ), esto hará que aparezca una ventana, dejamos las opciones por defecto y hacemos click en program.

Ya tendremos nuestra Zedboard programada, ahora descargaremos nuestro archivo elf(el cual se crea al compilar nuestro código) a la tarjeta. En el navegador de proyecto hacemos click derecho en la carpeta con el nombre de nuestro proyecto y seleccionamos Run As Launch on Hardware.

Con esto ya tendremos nuestra aplicación corriendo en la tarjeta.