Embed Size (px)
Citation preview
BOLLENGIER Théotime
FAU Nicolas
LANDIECH Matthieu
OUSSEINE Mwendzao
TONNELLIER Thibaud
Architecture matérielle (FPGA) pour la détection de
template en temps réel
Implantation matérielle – Interface graphique
Contenu INTRODUCTION ...................................................................................................................... 3
I. Présentation ........................................................................................................................ 3
II. Réalisation .......................................................................................................................... 4
III – Partie matérielle .................................................................................................................. 4
1 – Convertisseur Analogique Numérique ............................................................................. 4
A – Selon le cahier des charges .......................................................................................... 4
B – Ersatz ........................................................................................................................... 5
2 – Sous échantillonneur ........................................................................................................ 6
3 – Bloc Check SAD .............................................................................................................. 6
III. ARCHITECTURE MATERIELLE GÉNÉRALE ........................................................... 7
IV. ARCHITECTURE MATERIELLE DÉTAILLÉE .......................................................... 9
Le module de simulation de l'ADC ........................................................................................ 9
Le module subsampling ......................................................................................................... 9
La FIFO .................................................................................................................................. 9
Le bloc SAD ........................................................................................................................... 9
Le module match detector .................................................................................................... 10
V. Interface graphique .............................................................................................................. 10
1. Description .................................................................................................................... 11
2. Utilisation ...................................................................................................................... 13
3. Code .............................................................................................................................. 13
Conclusion ................................................................................................................................ 14
TABLE DES ILLUSTRATIONS
Figure 1 : Schéma Global ........................................................................................................... 3
Figure 2 - AD9467-FMC-EBZ board on Virtex 6 ...................................................................... 5
Figure 3 : Capture d'écran de l'interface graphique .................................................................. 10
Figure 4 : Diagramme de Classe .............................................................................................. 13
INTRODUCTION
Le but de notre projet est de réaliser un analyseur de signal permettant la détection
d’un paterne en temps réel. Notre système qui se compose d’une partie matériel (sur FPGA) et
d’une partie logiciel afin de permettre à un utilisateur de visualisé sur une interface graphique
la courbe qu’analyse la partie matériel et de sélectionner de manière ergonomique le paterne
souhaité.
Pour réaliser ce projet, différentes parties se dégagent : la gestion du CAN, l’analyse par le
FPGA, la communication entre le logiciel et le matériel.
Nous avons réalisé ce travail en sein d’une équipe de cinq, nous avons donc partagé le travail
selon les gouts et les compétences de chacun. Le développement matériel et logiciel devait
s'effectuer conjointement de façon à corréler les fonctionnalités proposées et la
communication entre les deux parties.
Ces parties seront développées dans la suite de notre rapport.
I. Présentation
Figure 1 : Schéma Global
output :
match ref/input
analog input
signal
ethernet
control link
computer
master
FPGA board
slave
hardware
development
software
development
Voici le schéma du système que nous avons conçu ; il fonctionne selon le principe
suivant : on récupère un signal analogique provenant d’une source extérieure, un
convertisseur analogique-numérique (CAN) convertie ce signal, pour qu’il soit analyser par le
FPGA.
Le FPGA a lui pour but d’envoyer le signal transmis à l’ordinateur, de récupérer le paterne
dont on souhaite savoir le nombre d’occurrence dans le signal et enfin d’effectuer l’analyse en
temps de réel du signal à la recherche du paterne.
Quant à la partie ordinateur, c’est un logiciel que nous avons programmé nous-même, et qui
permet à l’utilisateur de demander la récupération du signal numérisé, du choix du paterne et
de son envoi vers la partie matériel. C’est la partie logicielle qui est le maitre dans la relation,
l’utilisateur décide de la mise à jour et de l’envoi.
II. Réalisation
Pour la réalisation de notre projet, nous avons fait le choix de tester au fur et à mesure.
D’abord, nous avons testé le bon fonctionnement de la liaison entre l’ordinateur et la carte
FPGA à l’aide d’un programme écrit en C. Il permettait d’afficher l’état des switches sur
l’écran de l’ordinateur et d’allumer les leds de la carte à partir du PC.
Puis l'étape suivante a été d'ajouter une ROM sur le FPGA et de tester le programme, en
inscrivant dans cette même ROM une suite de valeur aléatoire. On transfert les informations
de la ROM et on les compare avec les valeurs initiales que l'on connaît, le résultat étant
identique, on en déduit que le transfert.
D’autre part, nous avons fait le choix d’écrire notre propre programme java en se basant sur
les fichiers java permettant l’affichage des courbes.
III – Partie matérielle
1 – Convertisseur Analogique Numérique
A – Selon le cahier des charges
Comme vu sur le schéma d’ensemble, l’acquisition doit, selon le cahier des charges
être fait par le convertisseur analogique numérique d’Analog Device AD9467. Sa connexion
avec la carte de développement Virtex 6 est permise par la carte mezzanine FPGA (FMC)
fournie par Analog Device. Celui-ci possède la caractéristique d’échantillonner sur 16bits à
250MHz.
Mais, sa documentation est quasiment inexistante. En effet, les meilleures explications
résident dans le wiki d’Analog Device. Celui-ci propose un programme de démonstration.
Celui-ci est très lourd : il va même jusqu’à employer le MicroBlaze pour configurer la carte.
Mais rien dans ce design ne permet d’extraire le paramétrage de l’ADC. Les maigres
datasheets fournies sur les FMC ou sur l’AD9467, ne semblent pas correspondre avec la
configuration. Ainsi, pour pouvoir prendre le contrôle de cet ADC, un travail de reverse
enginering est nécessaire. Mais, nous n’avons pas le temps pour l’effectuer. Une solution
alternative, présentée dans la partie suivante, est alors envisagée.
B – Ersatz
Le CAN étant le premier élément de ce projet, il est nécessaire de le remplacer par une
solution alternative pour que le démonstrateur puisse fonctionner. Nous avons choisi
d’implémenter une RAM contenant les valeurs d’un signal généré par Malab. Ce signal doit
correspondre au signal échantillonné dans les cas réel par le CAN. Un modèle de RAM et non
de ROM a été choisi afin de pouvoir modifier les signaux d’entrées à la volée, sans avoir à
recompiler le tout.
Figure 2 - AD9467-FMC-EBZ board on Virtex 6
Figure - Exemple de signal généré avec Matlab
La figure 4 présente un exemple de signal généré avec Matlab. Sur celui-ci nous pouvons voir
un sinus en fondamental. Celui-ci a ensuite été bruité puis un sinus d’une autre fréquence a été
ajouté. Ce dernier est fenêtré avec une fenêtre de Hann afin d’assurer la continuité aux bornes.
2 – Sous échantillonneur
Nous avons ajouté un bloc sous échantillonneur. Celui-ci nous permet d’effectuer une
moyenne arithmétique sur le nombre d’échantillon de notre choix. Il pourrait être intéressant
d’y rajouter une moyenne quadratique, et un mode poinçon. Chaque mode de sous
échantillonnage permettrait sans doute de mettre en valeur des motifs spécifiques.
3 – Bloc Check SAD
Ce bloc permet de mettre en place un seuil sur la SAD et de détecter les motifs jugés
identiques. Lorsque le seuil est dépassé, un registre est modifié, celui-ci recense le nombre de
fois où le motif a été rencontré. Aussi, lors d’une occurrence, un signal est activé pour
permettre d’allumer une LED.
III. ARCHITECTURE MATERIELLE GÉNÉRALE
L'architecture matérielle que nous avions initialement prévue est représentée sur la figure
suivante.
Celle-ci se compose principalement de 6 parties :
- Le module ACD permet le contrôle et l'acquisition des données d'entrée issues du
convertisseur analogique/numérique à une fréquence fixe.
- Le rôle du module subsampling est de sous-échantillonner ces données afin de pouvoir
travailler avec des fréquences moins élevées.
- La FIFO est une mémoire tampon de type "first in first out". Ça présence permet de palier à
la différence de vitesse entre le bus Ethernet et l'arrivée des données issues du module
subsampling. Il est ainsi possible d'envoyer 8192 échantillons consécutifs du signal d'entrée à
l'ordinateur afin que l'utilisateur puisse choisir le motif qu'il souhaite faire détecter au
dispositif.
- Le module SAD est constitué d'un pipeline qui compare en permanence les 512 derniers
échantillons du signal d'entrée avec les 512 échantillons du motif de référence. La sortie de ce
module représente la corrélation de ces deux derniers.
- Le module match detector compare la sortie du module SAD avec une valeur fournie par
ADC simulator
subsampling
FIFO SAD
pipeline
match
detector
sample out regs reference regs
subsampling regs
match count regs
CTRL regs
output :
match ref/input
ethernet bus
computer
master
FPGA board
slave
RAMaddress
counter
l'utilisateur de façon à émettre sur la sortie une impulsion de durée choisie lorsque le signal
d'entrée atteint un certain niveau de ressemblance avec le motif enregistré. Un compteur
indique le nombre de détections qui ont eu lieux.
- Le bus ipbus permet l'accès en lecture est en écriture à des registres internes du FPGA
depuis un ordinateur via la liaison Ethernet. Ce sont ces registres qui contrôlent et permettent
l'échange de données avec les modules ci-dessus.
Au cours du projet, l'utilisation du convertisseur analogique/numérique que nous étions censés
utilisé s'est avérée beaucoup plus compliqué que prévue ; c'est-à-dire que l'ADC nécessitait
l'utilisation d'un processeur implanté dans le FPGA pour pouvoir le configurer, ce qui est
rarement le cas avec ce type de circuit.
L'implantation et l'utilisation d'un processeur n'étant pas l'objet de ce projet et demandant des
ressource importantes par rapport à l'application, nous avons modifié l'architecture de la partie
matérielle de façon à pouvoir simuler le convertisseur analogique/numérique avec des valeurs
enregistrées dans le FPGA. La figure suivante présente l'architecture matérielle que nous
avons réalisée et implémentée lors de ce projet. Le système ne comporte plus d'entrée pour le
signal et le bloc ADC est remplacé par le module ACD simulator.
ADC simulator
subsampling
FIFO SAD
pipeline
match
detector
sample out regs reference regs
subsampling regs
match count regs
CTRL regs
output :
match ref/input
ethernet bus
computer
master
FPGA board
slave
RAMaddress
counter
IV. ARCHITECTURE MATERIELLE DÉTAILLÉE
Le module de simulation de l'ADC
Ce module se comporte d'une mémoire RAM d'un compteur et d'un registre. Pour écrire les
données dans la RAM, il faut faire un accès en écriture sur le registre à l'adresse 6 pour
initialiser l'adresse d'écriture de la RAM à 0. En suite chaque écriture d'un octet à l'adresse 8
écrit cet octet dans la RAM et incrémente l'adresse d'écriture de celle ci. Le compteur
incrémente à chaque cycle d'horloge l'adresse de lecture de la RAM. Les données sont lues en
boucle pour simuler le signal d'entrée du système. Le registre accessible à l'adresse 7 indique
au compteur l'adresse maximale de lecture de la RAM. Il est ainsi possible de "jouer" un
signal qui n'occupe pas la totalité de la RAM.
Le module subsampling
Ce module récupère les données issues de l'ADC avec une fréquence d'échantillonnage de 200
MHz. Le registre de 3 bits accessible à l'adresse 5 permet de sélectionner une fréquence de
sous-échantillonnage (200 MHz / 1; 200 MHz /2; 200 MHz /4; ... ; 200 MHz /128). Les
échantillons d'entrée sont moyennés de façon à fournir le signal de sortie à la fréquence
choisie. Un signal de validation indique aux autres modules lorsque le signal qu'il produit est
valide.
La FIFO
Le bit 0 du registre accessible en écriture à l'adresse 4 permet de lancer ou de stopper le
remplissage de la FIFO. Si ce bit est mis à 0, l'entrée de la FIFO est bloquée ; si ce bit est mis
à 1, alors chaque donnée issue du module de sous-échantillonnage est enregistrée dans la
FIFO tant que celle-ci n'est pas pleine. L'état de la FIFO est accessible en lecture à l'adresse 4
:
- bit 0 : entrée de la FIFO bloquée (0), non bloquée (1)
- bit 1 : FIFO vide (1), non vide (0)
- bit 2 : FIFO pleine (1), non pleine (0)
Un accès en lecture à l'adresse 3 vide la FIFO d'une donnée et la renvoie. Ce registre ce
compose comme suit :
- bit 9 : FIFO pleine (1), non pleine (0)
- bit 8 : FIFO vide (1), non vide (0)
- bits 7 à 0 : donnée issue de la FIFO
Pour faire une acquisition de 8192 échantillons d'entrée, il faut commencer par bloquer la
FIFO, puis faire des lectures jusqu'à ce qu'elle soit vide. On peut alors débloquer l'entrée de la
FIFO et attendre qu'elle soit pleine. Enfin les 8192 échantillons peuvent être lus.
Le bloc SAD
C'est le cœur de la partie matérielle. Il permet d'évaluer la corrélation entre un signal et un
motif. Ce module nous était fourni au début du projet, il s'agit d'un pipeline calculant la
somme des valeurs absolue des différences entre le motif et le signal d'entrée. Sa cadence est
d'une SAD de 512 points par cycle d'horloge. Le signal issu des sous-échantillonneurs entre
dans ce module. Le motif de référence est écrit dans le bloc SAD en écrivant successivement
ses échantillons dans le registre accessible à l'adresse 10. Ce motif de référence à une taille de
512 échantillons, de 9 bits : 8 bit de données et 1 bit indiquant au bloc SAD si cet échantillon
doit être pris en compte dans le calcul de la SAD. Ceci permet de pouvoir utiliser des motifs
de mois de 512 points. La sortie du bloc SAD est une valeur codée sur 17 bits.
Le module match detector
Ce module compare la sortie de bloc SAD avec un seuil fournit par l'utilisateur. Dès que la
valeur de la SAD dépasse le seuil, le module match detector produit une impulsion sur sa
sortie et incrémente son compteur de détection. Il faut que la valeur de la SAD redescende en
dessous du seuil avant de pouvoir déclencher à nouveau une impulsion. Le seuil de détection
peut être lu et écrit à l'adresse 9 (sur 17 bits). Le compteur de détection est accessible en
lecture et écriture à l'adresse 12. Un dernier registre accessible à l'adresse 11 permet de fixer
la durée de l'impulsion de sortie (sur 32 bits). La durée de l'impulsion est de
REG_DUREE_IMPULSION / 200000000.
V. Interface graphique
Figure 3 : Capture d'écran de l'interface graphique
1. Description
L’interface graphique est composée de différentes composantes.
Des boutons de contrôle :
- Un bouton Start, qui permet de lancer l’initialisation de la zone d’affichage du
graphique.
- Un bouton Refresh, qui permet d’acquérir et d’afficher une nouvelle trame de
8192 échantillons.
- Un bouton Send, qui permet d’envoyer au FPGA le gabarit de 512 échantillons
sélectionné par l’utilisateur, le seuil sélectionné et le délai sélectionné.
Une zone de visualisation
- Un affichage graphique, sur lequel l’utilisateur visualise la trame de 8192
échantillons envoyé par le FPGA.
- Un curseur, avec lequel l’utilisateur sélectionne le gabarit. Ce dernier se trouve
entre les deux zones rouges.
Une zone de sélection des paramètres
- Le seuil de détection correspond à la valeur en pourcentage de la ressemblance
entre le gabarit et le signal.
- Le type d’algorithme :
Deux types d’algorithmes sont proposés à l’utilisateur pour la détection du
gabarit dans la trame :
o Sum of Squared Differences (SAD)
o Sum of Absolute Differences (SSD)
Seul le SAD est intégré dans le FPGA.
- Temporisation
L’utilisateur peut sélectionner le temps durant lequel la LED reste allumée sur le
FPGA lorsque le gabarit est détecté.
Une zone d’acquisition des résultats
- Redondance dans l’échantillon :
En cliquant sur le bouton Refresh, l’utilisateur constate le nombre de redondance
du gabarit sélectionné avec le seuil de détection paramétré.
- Redondance dans le signal :
En cliquant sur le bouton Refresh, l’utilisateur ordonne une lecture du registre
contenant le nombre de redondance détecté par le FPGA dans le signal entrant.
- Reset :
Le bouton Reset permet de mettre à zéro le nombre de détection du FPGA.
2. Utilisation
Pour utiliser l’interface, veuillez suivre les étapes suivantes :
- Initialisation :
o Cliquer sur le bouton Start.
o Déplacer le ensuite le curseur, pour lancer l’affichage de la courbe.
- Acquisition :
o Cliquer sur le bouton Refresh à gauche pour recevoir une trame.
o Via le curseur il est possible de sélectionner un gabarit
o Le gabarit sélectionné peut être testé dans la trame via le bouton Refresh
de la zone « Redundancy in sample. »
- Envoi :
o Cliquer sur le bouton Send à gauche pour envoyer le gabarit sélectionné.
o Le seuil et le délai sélectionné avant l’envoie sont également envoyé.
o A chaque détection du FPGA une LED s’allumera.
o A tout moment il est possible de lire le nombre de détaction via le bouton
Refresh de la zone « Redundancy in signal. »
3. Code
Figure 4 : Diagramme de Classe
Main.java
Cette page contient seulement la fonction principale du programme.
InterfaceForm.java
Cette page contient toute la description de l’interface graphique. Elle contient également la
déclaration des actions effectuées lors de différents évènements.
OpCommunication.java
Cette page contient les déclarations des fonctions appelé lors d’appuis sur un des boutons.
UdpClient.java
Cette page contient les fonctions permettant la communication via le Protocol UDP entre
l’interface et le FPGA.
Graphique.java
Cette page contient les fonctions permettant l’affichage de la courbe.
SADComputation.java
Cette page contient les fonctions permettant de mettre en œuvre l’algorithme SAD de
détection de ressemblance entre deux blocs.
SSDComputation.java
Cette page contient les fonctions permettant de mettre en œuvre l’algorithme SSD de
détection de ressemblance entre deux blocs.
Conclusion
Pour conclure, nous avons donc réalisé un projet liant à la fois une partie matérielle et
une partie logiciel. Ce fut très enrichissant car nous avons pu voir qu’il était toujours
nécessaire de communiquer entre les deux équipes pour accorder nos violons sur l’utilisation
des registres et autres liens entre les deux parties.
A la fin de notre projet, nous avons réussi à faire communiquer les deux parties ensemble, à
faire afficher la courbe et à renvoyer le paterne. Nous n’avons pas pu finaliser la vérification
pour cause d’un problème matériel. En effet, la sonde JTAG, nécessaire au test final, n’était
plus présente après l’ajout du bloc SAD. Cela reste une déception car nous aurions voulu voir
fonctionner notre projet.
Ce projet nous a aussi permis de se rendre compte que des difficultés inattendues pouvaient
apparaitre comme cela a été le cas avec le CAN, mais nous avons su rebondir et trouver une
solution de substitution.
Enfin, quelques perspectives d’évolution pour ce projet existent : il est possible d’envisager la
prise en charge d’une mise à jour en temps réel de l’affichage, la modification de la taille du
paterne ou bien encore d’ajouter de manière matérielle le calcul de SSD pour le comparer
avec la méthode SAD.
