Intégration d`un SOPC sur FPGA SPARTAN6 XILINX

Intégration PSOC
06/02/2014
Intégration d’un processeur spécialisé et de la logique
Programmable au sein d’un FPGA
1) Problématique et objectifs
L’objectif de cette séance est d’intégrer un processeur spécialisé (PS) avec la logique programmable (PL) sur
un FPGA. Le processeur spécialisé sur le Kit ATLYS SPARTAN 6 est baptisé Microblaze (voir cours sur les
SOPC) et reste façonnable. On donne le symbole ci-dessous du PS (le system top). La suite logicielle software
development kit SDK nous permettra de développer la partie software du PS. La partie PL ne sera pas
modélisée en VHDL, on utilisera des IPCORE pré-câblés comme le clocking wizard et l’IPCORE counter.
L’IPCORE counter sera simplement un compteur de 2 bits avec une horloge CLK et un reset synchrone sclr. Le
FPGA sera connecté à 2 LEDS qui seront l’image binaire des sorties du compteur LED0 et LED1 du kit.
L’interrupteur SW1 permettra de générer le signal d’horloge. Sw0 actif au ‘0’ logique nous permettra de
réinitialiser le compteur via la broche sclr.
PAGE 1
PETITPA
Intégration PSOC
06/02/2014
2) Méthodologie
La méthodologie est la suivante :
XPS
Xilinx platform
studio
ISE
Integrated system
editor
SDK software
development
kit
Définir la plateforme du
système microprogrammé
CPU microblaze
- Créez notre schematic sous
ISE afin d’intégrer notre CPU
des blocs de fonction
numérique écrite en VHDL et
des IPCORE propriétaires le
tout synthétisé sur un FPGA
-Simulez avec lsim le
comportement du système
- Programmez avec impact
la partie matérielle du FPGA
Développez en langage C
notre programme pour le cpu
microblaze et programmez la
partie logicielle FPGA
On aura besoin de créer un répertoire projet et trois sous-répertoires pour nos 3 étapes :
ISE pour l’intégration RTL VHDL
XPS pour la création et la configuration du processeur spécialisé PS
SDK pour le développement logiciel du SOPC
PAGE 2
PETITPA
Intégration PSOC
06/02/2014
3) Partie 1 :définir et configurer le processeur spécialisé
Lancez le logiciel XPS
On définit par la suite un board support package (BSB) qui sera fonction de l’architecture matérielle du FPGA
et du kit ATLYS
La Prise en compte matériel du board support package de la carte ATLYS XILINX DIGILENT
PAGE 3
PETITPA
Intégration PSOC
06/02/2014
La configuration du PS et les IPCORE intégrables du BSP s’effectue sur la fenêtre suivante :
PAGE 4
PETITPA
Intégration PSOC
06/02/2014
Cliquez sur next
On peut intégrer dans le PS, des IPCORE compatibles avec le CPU microblaze. La fenêtre de droite nous donne
tous les IPCORE qui constituent l’architecture actuelle du PS
Dans notre application on va Intégrer dans le PS, l’IPCORE gpio afin de piloter notre compteur et de récupérer
des consignes sur SW0 et SW1.
On reliera par la suite le processeur spécialisé via le GPIO à l’IPCORE compteur et aux interrupteurs SW0 et
SW1 comme ceci est indiqué dans la figure suivante :
PAGE 5
PETITPA
Intégration PSOC
06/02/2014
L’Intégration de l’IPCORE gpio dans le PS se fait par le bus AXI4lite du CPU Microblaze
Le paramétrage de l’IPCORE gpio a lieu par la suite :
PAGE 6
PETITPA
Intégration PSOC
06/02/2014
En cliquant sur system on peut définir la plage d’adresse du périphérique dans la cartographie mémoire du CPU
Microblaze. Si on laisse par défaut ces adresses le logiciel SDK définira automatiquement une plage d’adresse
libre pour le périphérique gpio. La définition du choix de la plage d’adresse n’est donc pas obligatoire.
En cliquant sur + sur la figure on voit apparaitre les broches d’entrées sorties du périphériques gpio, coté
gauche le bus AXI4lite et coté droit le bus du gpio qu’il va falloir configurer par la suite.
PAGE 7
PETITPA
Intégration PSOC
06/02/2014
On peut changez le nom de note périphérique gpio et on aperçoit la connexion du périphérique au bus
AXI4LITE du PS:
PAGE 8
PETITPA
Intégration PSOC
06/02/2014
On doit connecter les broches de sorties et d’entrées du GPIO sur les broches externes du CPU microblaze :
Pour le port de sortie du GPIO :
PAGE 9
PETITPA
Intégration PSOC
06/02/2014
Pour le port d’entrée du GPIO :
On peut faire apparaitre la cartographie mémoire du CPU Microblaze qui nous sera utilie lors du
développement logicielle sur SDK
PAGE 10
PETITPA
Intégration PSOC
06/02/2014
On peut lancer une vérification architecturale du PS en cliquant sur run DRC (design rule check)
Mais en fait, il y a un bug. Sur l’axi_gpio, les ports GPIO_IO et GPIO2_IO sont restés en l’air alors qu’ils
auraient dû être supprimés. Si vous faites un DRC, il y a deux erreurs. Pour corriger ce bug, il faut éditer le
fichier system.mhs qui contient toutes les informations concernant le PS. Il faut faire apparaitre l’onglet «
Project » puis double cliquez sur le fichier :
PAGE 11
PETITPA
Intégration PSOC
06/02/2014
Lancez à nouveau un DRC (design rule check ) et Sauvegardez le projet
A ce stade notre processeur spécialisé a été façonné, on va donc intégrer ce PS dans un environnement matériel
plus complexe sous ISE
PAGE 12
PETITPA
Intégration PSOC
06/02/2014
4) Partie 2 : Intégration matérielle sous ISE
Lancez le logiciel ISE qui traite les FPGA du type VIRTEX, SPARTAN, ZINQ, ARTIX ….
Créez un nouveau projet sur ISE
PAGE 13
PETITPA
Intégration PSOC
06/02/2014
Comme vu lors des TPS VHDL, choisir notre FPGA de la carte ATLYS :
Cliquez sur finish
PAGE 14
PETITPA
Intégration PSOC
06/02/2014
Associez le système CPU Microblaze à notre projet
Naviguez vers le dossier XPS
PAGE 15
PETITPA
Intégration PSOC
06/02/2014
Générez le code source VHDL faisant apparaitre l’entité du CPU Microblaze
On va modifier l’entité afin de faire apparaitre nos broches d’entrée-sorties qui nous permettront de nous
connecter au compteur et aux interrupteurs SW0 et SW1
PAGE 16
PETITPA
Intégration PSOC
06/02/2014
En sélectionnant system_top on peut vérifier la syntaxe VHDL du module CPU en double cliquant sur check
syntax
On doit par la suite intégrer l’IPCORE compteur
En sélectionnant system_top on peut vérifier la syntaxe VHDL du module CPU par check syntax
PAGE 17
PETITPA
Intégration PSOC
PAGE 18
06/02/2014
PETITPA
Intégration PSOC
06/02/2014
On va paramétrer le compteur
On intégre l’IPCORE du type clocking wizard
PAGE 19
PETITPA
Intégration PSOC
06/02/2014
Suivre la procédure vue lors des TPS VHDL pour produire une horloge à 100MHz sans entrée RESET et
LOCKED
On va créer un symbole pour le cœur de CPU Microblaze
PAGE 20
PETITPA
Intégration PSOC
06/02/2014
On verra par la suite que le symbole créé du CPU microblaze aura la forme suivante :
PAGE 21
PETITPA
Intégration PSOC
06/02/2014
Nos différentes entités (CPU, CLOCKING, compteur) seront reliées ensemble sur un top schematic, on va
donc créer un top schematic
PAGE 22
PETITPA
Intégration PSOC
06/02/2014
Complétez alors le schéma
PAGE 23
PETITPA
Intégration PSOC
06/02/2014
Le schéma final aura l’aspect suivant et permettra d’intégrer dans notre FPGA, deux IPCORE préfabriqués (PL)
, et un PS CPU microblaze
Pour associer les broches aux broches externes du FPGA , deux possibilités s’offrent à nous :
Complétez directement un fichier de contrainte .ucf en maitrisant la syntaxe
Se servir du logiciel plan ahead pour établir ce fichier de contrainte
Sélectionner implementation
Contraints file
PAGE 24
PETITPA
Intégration PSOC
PAGE 25
06/02/2014
PETITPA
Intégration PSOC
06/02/2014
Le fichier top_schema.ucf est créé automatiquement
PAGE 26
PETITPA
Intégration PSOC
06/02/2014
Il nous reste à programmer matériellement et façonner notre FPGA (voir la procédure lors des TPs VHDL).
Afin de développer le logiciel du CPU microblaze, double cliquez sur export hardware to sdk sans l’exportation
du ficher de programmation matérielle bit
PAGE 27
PETITPA
Intégration PSOC
06/02/2014
5) Développement logiciel en langage C du processeur spécialisé
Le lancement du logicielle SDK eclipse s’effectue automatiquement
SDK (software development kit)
PAGE 28
PETITPA
Intégration PSOC
06/02/2014
Le BSP board support package a été créé par XPS
PAGE 29
PETITPA
Intégration PSOC
06/02/2014
Modifiez le fichier source en C afin qu’il réponde à notre application.
PAGE 30
PETITPA
Intégration PSOC
06/02/2014
#include <stdio.h>
#include "platform.h"
//#include <sleep.h>
#include "xparameters.h"
#include "xgpio.h"
void print(char *str);
void usleep(unsigned int useconds);
int main()
{
int Status, i;
u32 Data_out, Data_in;
XGpio Gpio; /* The Instance of the GPIO Driver */
init_platform();
xil_printf("essai tp10\n");
/*
* Initialize the GPIO driver
*/
Status = XGpio_Initialize(&Gpio, 0);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* GPIO channel 2 = en entrée
*
*/
XGpio_SetDataDirection(&Gpio, 2, 0xffffffff);
/*
* GPIO channel 1 = sortie
*
*/
XGpio_SetDataDirection(&Gpio, 1, 0x00000000);
Data_out = 0;
Data_in = XGpio_DiscreteRead(&Gpio, 2);
xil_printf("Datain = %x\n", Data_in);// etat des ports
while(1){
Data_in = XGpio_DiscreteRead(&Gpio, 2);// lecture des ports entrées
xil_printf("Datain = %x\n", Data_in);
if (Data_in==0x01)// fonctionnement libre du compteur
for (i = 0; i < 4; i++) {
// les 8 bits faibles de data_out sont
// envoyés sur channel 2
Data_out=0x00;
XGpio_DiscreteWrite(&Gpio, 1, Data_out);
usleep(1000000);
Data_out=0x01;//
XGpio_DiscreteWrite(&Gpio, 1, Data_out);
//Data_out++;
// lecture dans l'ordre de SW5 , SW7 , SW12-1 , SW12-2
//Data_in = XGpio_DiscreteRead(&Gpio, 1);
//xil_printf("Datain = %x\n", Data_in);
}
else
PAGE 31
PETITPA
Intégration PSOC
06/02/2014
{
Data_out=0x02;
XGpio_DiscreteWrite(&Gpio, 1, Data_out);
}
}
return 0;
}
void usleep(unsigned int useconds)
{
int i,j;
for (j=0;j<useconds;j++)
for (i=0;i<15;i++) asm("nop");
}
La compilation se fait logiquement automatiquement quand on sauvegarde l’environnement
File save project
PAGE 32
PETITPA
Intégration PSOC
06/02/2014
Cliquez droit puis sur new pour lancer la configuration
La page principale apparait :
PAGE 33
PETITPA
Intégration PSOC
06/02/2014
Définir le comportement de la carte ATLYS après la fin de configuration
On peut émuler la liaison série RS232 du kit FPGA sur la prise usb/UART (port com8 ici)
Cliquez sur run dans le menu le fichier de programmation est chargé dans la mémoire vive du kit FPGA et
l’application matérielle et logicielle doivent se lancer
PAGE 34
PETITPA