Sistema Base con comunicacin GPIO

Autor: M. en I. William Hidber Cruz

Instituto de Ciencias Nucleares, UNAM
Junio 2014

Esta prctica tiene como objetivo crear un Sistema base en el dispositivo Zynq, el cual tendr
comunicacin hacia el exterior por medio de los pines GPIO. Se ocuparan los Leds de la tarjeta de
desarrollo Zedboard para verificar que se estn mandando datos hacia el exterior.

Requerimientos
La prctica requiere los siguientes dispositivos y software.
Zedboard.
Cable usb a microusb para programacin de la tarjeta de desarrollo.
Vivado 2013.4 con SDK 2013.4 o Vivado 2014.1 con SDK 2014.1

Parte 1._ Diseo 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,
adems ocuparemos un core GPIO el cual tendr comunicacin 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 opcin Create New Project. En el wizard que
se despliega a continuacin 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 continuacin pulsamos el botn Next.



En la siguiente ventana dejamos las opciones que estn por default y pulsamos Next. En la
nueva ventana nos aseguramos que las opciones del lenguaje estn en VHDL, luego
pulsamos el botn Next. En la siguiente ventana no hacemos nada y pulsamos el botn Next.
En la nueva ventana que aparece, como no vamos a agregar archivos de restriccin
pulsamos el botn 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 botn 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
botn 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 diseo.




Una vez que pulsemos el botn OK en el entorno de trabajo se abrir el IP integrator. Desde
aqu crearemos nuestro diseo 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 diseo.



Tecleamos Zynq y aparecern 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 opcin /processing_system7_0, se
desplegara un cuadro de dialogo. En este cuadro de dialogo dejamos las opciones por
defecto. Esta opcin 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 opcin MIO Configuration hacemos click y posteriormente deseleccionamos todas las
interfaces que estn seleccionada. Por ultimo le damos click en el botn 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 botn derecho
del mouse y seleccionamos Add IP o tambin 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 botn
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 lpiz, hacemos click y sin soltar el botn
izquierdo del mouse arrastramos hasta la entrada BRAM_PORTA del core Block memory
generator y soltamos el botn 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 automticamente 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 harn las
conexiones automticas 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 botn 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 botn la cual acomodara nuestro diseo, el resultado final ser parecido a la figura
de abajo.

Ahora vamos a validar nuestro diseo por medio del DRC (Design Rule Check), para esto
hacemos click en el botn que se encuentra en el lado derecho de nuestro lienzo de
trabajo o presionando la tecla F6. Saldr un mensaje diciendo que nuestro diseo es vlido.
Salvamos nuestro proyecto presionando las teclas ctrl+S. Una vez salvado nuestro proyecto
seleccionamos la pestaa sources del entorno de trabajo.



Una vez seleccionado la pestaa source, hacemos click con el botn derecho del mouse y
seleccionamos la opcin 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 opcin Create HDL Wrapper. En la ventana que aparece
dejamos las opciones por defecto y seleccionamos OK. Para finalizar hacemos click en la
opcin 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 preguntndonos si deseamos abrir el diseo implementado, lo abrimos.



Parte 2. SDK

Una vez que se abri el diseo, en la barra de mens 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 opcin 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 ms, Leds.h y Leds.cpp. Ambos archivos ubicados en la misma carpeta
src. El cdigo para los tres archivos se muestra abajo. Para compilar solo salvamos nuestro
proyecto y automticamente 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
alimentacin como a nuestra PC. Adems de asegurarnos que los jumpers de los modos de
configuracin estn 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 cdigo) 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 aplicacin corriendo en la tarjeta.