Acquisition et traitement du signal Issu d'un vélocimètre Laser
←
→
Transcription du contenu de la page
Si votre navigateur ne rend pas la page correctement, lisez s'il vous plaît le contenu de la page ci-dessous
Rapport de stage année 2009
2ème année Ingénieur ENSEEIHT Electronique
Acquisition et traitement du signal
Issu d’un vélocimètre Laser
Pierre-Adrien Lefebvre
Maître de stage : Francis Bony
Tuteur Technique : Julien Perchoux
Laboratoire d'Optoélectronique pour les Systèmes Embarqués
INP - ENSEEIHT
Sommaire
1. Remerciements ............................................................................................................................... 4
2. Présentation du laboratoire et du projet dans son ensemble........................................................ 4
3. Objectifs du stage ........................................................................................................................... 5
4. Environnement de développement ................................................................................................ 6
5. Obtention et analyse des données ................................................................................................. 7
6. Méthode de comptage des impulsions .......................................................................................... 9
a. Présentation de la méthode........................................................................................................ 9
b. Simulation sous Matlab ............................................................................................................... 9
c. Implémentation dans le FPGA - tests ........................................................................................ 11
d. Avantages et inconvénients de la méthode – perspectives et commentaires ......................... 16
7. Méthode de détection du pic de FFT ............................................................................................ 17
a. Présentation de la méthode...................................................................................................... 17
b. Simulation sous Simulink........................................................................................................... 19
c. Avantages et inconvénients de la méthode – perspectives et commentaires ......................... 23
8. Conclusion du stage ...................................................................................................................... 24
9. Annexes ......................................................................................................................................... 25
3
1. Remerciements
Je voudrais tout d’abord remercier Francis Bony et Julien Perchoux pour m’avoir éclairé tout au long
de ce projet et pour m’avoir fait part de leur bonne humeur. Je ne veux pas oublier non plus de
remercier les autres membres du laboratoire ainsi que le personnel technique pour m’avoir
présenté l’ensemble du dispositif expérimental et avoir répondu à mes questions durant ce stage.
2. Présentation du laboratoire et du projet dans son ensemble
Le laboratoire
Les activités de recherche du LOSE ont pour objectif premier la conception de systèmes embarqués
(SE) de mesure optoélectroniques innovants actifs (basés sur des lasers) ou passifs (basés sur des
caméras). Pour cela, une bonne maîtrise de l’ensemble de la chaîne de mesure est nécessaire, de la
conception du capteur (couche physique) à son traitement numérique des données (couche basse).
Parmi les thèmes principaux de recherche du laboratoire, on trouve en particulier les systèmes de
mesure actifs (télémétrie LASER, mesures interférométriques pour les systèmes embarqués) et les
applications de traitement de l’image et de télécommunication (réseaux de neurones pour la
télémétrie spatiale, vision temps réel…).
M. Thierry Bosch dirige actuellement le laboratoire.
Le projet
Il consiste à trouver un moyen efficace et faible coût pour mesurer la vitesse à l’aide d’un LASER.
L’éventail des perspectives envisagées est extrêmement large puisqu’elles peuvent s’étendre à des
applications liées à l’industrie automobile (équipements de sécurité principalement) jusqu’aux
applications biomédicales (évaluation de la vitesse d’un flux sanguin). Ce procédé pourrait être à
terme largement répandu du fait des coûts de fabrication qui restent très raisonnables.
Le projet s’appuie déjà sur des recherches approfondies sur la mesure de déplacement et de vitesse
grâce à la rétro-injection optique. Comme le montre la figure ci-dessous, le LASER émet une onde
lumineuse en direction d’un disque en rotation (cible mouvante). Une très faible partie de la
lumière émise est rétrodiffusée vers le LASER. Les ondes émise et reçue interagissent dans la cavité
LASER comme le décrit la théorie du self-mixing. En amplifiant les petites variations de tension aux
bornes de la cavité, il est possible de remonter jusqu’à l’information fréquentielle. En s’appuyant
ensuite sur la théorie de l’effet Doppler, on sait que le pic de fréquence reçu est proportionnel à la
vitesse de rotation de la cible multiplié par le cosinus de l’angle du faisceau avec la cible.
4Figure 1 - Schéma de principe du banc d'essai
Une publication IEEE a déjà été publiée concernant le principe de la rétroinjection optique et le
phénomène de self-mixing dans la cavité LASER (Photodiode-free Doppler velocimeter based onself-
mixing effect in commercial VCSELs). Le principal avantage de cette méthode de mesure
vélocimétrie est de s’appuyer sur des diodes LASER VCSEL qui comportent une photodiode interne
intégrée. Ces composants ont un coût de production très faible et donnent donc un avenir
prometteur au projet.
3. Objectifs du stage
Il a été démontré grâce à la théorie et l’expérience que l’information fréquence à la sortie de la
photodiode du LASER VCSEL permettait de remonter (à un cosinus près) à la vitesse d’une cible. Il
reste donc à mesurer cette fréquence de manière relativement précise. La principale difficulté
consiste à récupérer cette information sur un signal qui reste assez bruité.
Il m’a été confié dans un premier temps de m’intéresser à une mesure reposant sur un principe de
comptage et de filtrage. Le signal à la sortie de l’amplificateur d’instrumentation passe dans un
comparateur à hystérésis afin de s’affranchir de DAC (Digital to Analog Converter) coûteux et
gourmands en énergie lorsqu’ils sont rapides. Le signal est ensuite traité dans un FPGA lors de la
phase de développement logicielle.
Le stage doit se dérouler par une première phase d’analyse des données obtenues en sortie de
l’amplificateur avec MATLAB et SIMULINK afin de mettre au point une méthode de comptage
efficace et d’afficher la valeur du pic de fréquence.
54. Environnement de développement
Voici le matériel et les logiciels utilisés dans ce projet :
Xiling ISE v10.1– IP Cores FFT, FIFO.
Matlab 2008a – Simulink
Xilinx System Generator assure la passerelle entre ces deux logiciels afin de traduire en vhdl
et IP-Cores le code modélisé sous Simulink et vice-versa.
Carte Spartan-3 du Development Kit de Digilent (voir photographie ci-dessous).
Figure 2 - Digilent Spartan 3 develoment kit board
La carte Digilent utilisée est équipée du XC3S200 dont les caractéristiques principales sont
énumérées dans le tableau ci-dessous :
Figure 3 – La famille Spartan 3 de Xilinx
65. Obtention et analyse des données
Dans un premier temps, il a fallu procéder à l’acquisition des données en sortie de l’amplificateur de
courant photo-détecté. On utilise pour cela un oscilloscope, dont la fréquence d’échantillonnage est
réglée sur 2.5 MHz. La condition de Shannon est en pratique très largement respectée : fe > 10
fmax. On procède alors à l’acquisition de 100 000 points à différentes vitesses de rotation. On
obtient alors plusieurs fichiers de données au format .CSV qu’il nous faut ensuite traiter avec
Matlab.
Afin de faciliter l’analyse et la visualisation des données expérimentales obtenues (signal temporel,
FFT), il a fallu créer une interface graphique à l’aide de l’outil GUIDE (Graphic User Interface
Development Environment) sous Matlab. L’interface graphique permet de sélectionner le fichier CSV
à afficher et de tracer la réponse fréquentielle du signal échantillonné. La figure suivante présente
un aperçu de ladite interface graphique :
Figure 4 - Interface graphique analyse des données
La réponse temporelle est représentée en bas à gauche et la réponse fréquentielle en haut à droite.
Le reste fera l’objet d’explications ultérieures.
Les figures suivantes montrent l’évolution de la position du pic de fréquence fondamentale en
fonction de la vitesse du moteur, donnée en Volts. La vitesse du moteur est sensiblement
proportionnelle à la DDP appliquée entre ses bornes. La FFT est réalisée sur 16384 points, dont
8192 points de donnée. L’abscisse représente la densité spectrale d’énergie normalisée par rapport
au nombre de points.
7U=0V
U = 0.7 V
U=2V
U=3V
U=4V
U=5V
8On observe bien le glissement du pic fréquentiel vers les fréquences croissantes lors de
l’augmentation de la vitesse comme le prévoit la théorie de Doppler.
L’amplificateur du courant photo-détecté utilisé coupant aux alentours de 150 kHz, les mesures aux
delà de cette fréquence ne pas exploitables.
6. Méthode de comptage des impulsions
a. Présentation de la méthode
Le signal issu de la cavité LASER passe après amplification dans un comparateur à hystérésis afin
d’être traité de manière binaire. La méthode repose sur la détection et le comptage des fronts
montants présents sur une entrée du FPGA.
b. Simulation sous Matlab
La simulation passe par la création d’un fichier .m. Le code concernant la simulation (fichier
Comptage_Doppler.m) est donné en annexe. Les valeurs contenues dans le fichier .CSV choisies
sont stockées dans un tableau et traitées par un comparateur à hystérésis dont le seuil est réglable
(Deadband comparateur dans la précédente fenêtre de simulation). La valeur du seuil est réglée par
défaut à 0.02.
On mesure ensuite la fréquence sur un nombre N d’échantillons (Nb de points de calcul). N est
réglable est égal à 1000 par défaut. On filtre également les fronts montants parasites en
considérant comme un front montant le passage de 0 à 1 pendant au moins une durée égale à 2
échantillons.
Le signal de sortie est ensuite filtré par un filtre numérique passe bas (ordre 80), fc = 200 kHz. Les
coefficients du filtre ont été calculés avec FDA Tool et la réponse du filtre est donnée par la figure
suivante. Le filtre permet de « lisser » la valeur du pic de fréquence mesuré. Le filtre est du type FIR
equiripple.
Figure 5 - Réponse fréquentielle du FIR
9Les figures suivantes présentent les résultats obtenus par comptage par tranche de 1000
échantillons. On remarque qu’après un certain temps de montée, la fréquence mesurée tend à
converger (sauf à vitesse nulle). L’axe des ordonnées correspond à la fréquence en Hertz.
U=0V
U = 0.7 V
U=2V
U=3V
U=4V
U=5V
10c. Implémentation dans le FPGA - tests
Simulation du flot de données incident
Les tests ont été effectués en dehors du banc d’essai : le flot de données incident à donc été simulé
en plaçant les données expérimentales à la sortie du comparateur à hystérésis en ROM.
Les données sont placées dans une ROM capable de contenir les 100 000 bits du signal
échantillonné à l’oscilloscope. Pour créer cette ROM, on utilise dans Xilinx ISE l’IP-CORE « Bloc
Memory Generator ». Les valeurs d’initialisation de la ROM sont transférées grâce à un fichier .COE
à la syntaxe particulière. Ce fichier est créé par le code gérant l’interface graphique précédemment
développée, en appuyant sur le bouton « Générer fichier .COE pour ROM Xilinx ».
La ROM est créée grâce à l’utilisation des Block RAM internes au FPGA. La figure suivante décrit
l’emplacement de ces blocks.
Figure 6 - Placement des Blocks RAM
Le composant créé s’appelle ici ROM_x (x correspond au numéro de l’échantillon étudié à charger
dans le FPGA). On utilise un compteur 0-99999 afin d’adresser la ROM de manière circulaire.
Du fait du nombre limité de Block RAM dans le FPGA, on ne peut pas contenir plus d’un fichier de
mesure à la fois.
La figure de la page suivante décrit de manière complète l’architecture utilisée.
11Figure 7 - Schéma général de la méthode de comptage embarquée sur FPGA
12Description des composants utilisés
Architecture du projet Xilinx ISE
Figure 8 - Architecture du projet Xilinx Comptage
Clk_rom
Clk_50M : horloge de 50 MHz propre à la carte.
Rst : reset propre à la carte
H_rom : sortie de l’horloge 2.5 MHz correspondant à la fréquence d’échantillonnage
réelle i.e. la fréquence à laquelle on doit lire les données enregistrées en ROM.
Compteur_100000
Compteur circulaire de 0 à 99 999. Le compteur est synchronisé avec l’horloge
générée par H_rom.
Rom_3
Il s’agit une mémoire ROM contenant les 100 000 points de mesure correspondant
aux données d’un fichier .CSV obtenue avec l’oscilloscope. Addra(16:0) correspond
au bus d’adresse et douta correspond au bit lu en ROM.
Rising_edge_detector
Il s’agit d’un détecteur de front montant classique avec synchronisation sur l’horloge
d’échantillonnage H_rom.
13Compteur_HF
Compte le nombre de fronts montant durant une durée égale à N fois la période
d’échantillonnage de 2.5 MHz. Le résultat est ensuite transféré sur la sortie
o_Resultat_HF(15:0).
Filter
Il s’agit d’un filtre passe-bas généré avec l’IP-CORE « FIR-Compiler ». La fréquence de
coupure est d’environ 150 kHz avec une pente très raide pour éliminer les fréquences
inutiles au-delà de la bande passante du circuit d’amplification du photo-détecteur
intégré au LASER. La réponse fréquentielle du filtre est donnée par la figure suivante.
Figure 9 - Réponse du FIR passe-bas (Fe = 2.5 MHz)
Moyenne
Ce bloc effectue la moyenne arithmétique sur un certain nombre d’échantillons (128
ici) afin de rendre la sortie du filtre moins sensible aux variations parasites de la
position du pic dans le spectre fréquentiel. Le moyenneur somme 128 échantillons en
entrée et effectue ensuite un décalage binaire vers la droite de 7 bits pour obtenir le
résultat de la moyenne :
14E_RST Moy_out
Figure 12 - Test de la lecture de la ROM
Le moyenneur a été rajouté après avoir constaté des fluctuations de la fréquence affichée.
La figure suivante montre le test du dispositif pour U = 3 V. La fréquence affichée est sensiblement
la même que celle du pic de FFT du spectre donné pour U = 3 V.
Figure 13 - Test de la méthode de comptage
d. Avantages et inconvénients de la méthode – perspectives et commentaires
Inconvénients
• La fréquence mesurée à la sortie peut sembler parfois très instable, en particulier pour les
fréquences Doppler basses (inférieures à 50 kHz). La méthode semble assez imprécise.
Avantages
• Synthèse très peu coûteuse en nombre de portes, le coût de mise en œuvre sera donc
réduit tout comme la consommation électrique.
16• Rapidité de traitement. Il faut 0.4 ms pour acquérir 1000 échantillons à 2.5 MHz donc on
pourrait prendre 10000 échantillons (4 ms) et rester proche d'un système temps réel afin de
gagner en précision au niveau de la mesure.
• On peut essayer d’améliorer la stabilité de la sortie fréquence en effectuant une moyenne
glissante.
Perspectives - Conclusions
Il semble que cette méthode soit plus adaptée pour fournir une information grossière d’un
mouvement (si le problème des oscillations parasites à vitesse nulle est résolu) qu’une mesure
précise de la vitesse du mobile.
En effet, l'efficacité du traitement des données semble varier en fonction de la table de
données choisies. Il faudrait tester le code dans des conditions de mesure réelles (sans la ROM)
pour éliminer les artefacts de mesure pouvant résulter du parcours en boucle de la ROM. Ici, au
mieux, on obtient une variation maximale de 5 kHz autour du pic (pour les données correspondant
au pic à 80 kHz)
Les opérations de filtrage numérique et moyenne mériteraient d'être optimisées afin
d’augmenter la fiabilité de la mesure.
7. Méthode de détection du pic de FFT
a. Présentation de la méthode
Il s’agit d’étudier ici une alternative à la méthode de comptage précédente.
Cette méthode repose sur une mesure directe de la fréquence de plus forte densité spectrale en
s’appuyant sur une FFT. On procède à l’acquisition de N échantillons et on effectue une FFT sur 2N
échantillons (zéro-padding). Les N échantillons sont stockés dans une mémoire FIFO (First In First
Out) qui joue le rôle de tampon lors de l’opération de zéro-padding.
On envisage alors d’implémenter cette méthode sur un FPGA optimisé pour les calculs de type DSP
comme le Spartan 3A DSP – 3400. Cette catégorie de FPGA contient des slices DSP spécialement
désignées pour les opérations propres au traitement du signal afin d’accélérer les opérations MAC
(Multiply and ACcumulate) successives. La figure suivante présente l’architecture interne d’un slice
DSP du Spartan 3A DSP – 3400. Le nombre de ces slices est limité et varie selon la taille du FPGA :
17Figure 14 - Structure d'un Slice DSP48A
Pour plus de renseignements concernant l’utilisation de ces slices, il convient de se référer au
manuel de l’utilisateur « XtremeDSP DSP48A for Spartan-3A DSP FPGAs ».
Toute la phase de développement et de simulation s’est effectuée sous Simulink and utilisant l’outil
Xilinx System Generator afin d’acquérir des blocs VHDL dans Simulink et d’exporter le projet
Simulink en projet Xilinx ISE.
Pour tester le projet, il faut :
1) Lancer le fichier "Load_Data_FFT.m" pour choisir le fichier à charger en mémoire.
2) Lancer le modèle .mdl et exécuter la simulation (bouton run) pour différents fichiers de
mesure.
Le paragraphe suivant présente de manière générale les composants Xilinx utilisés dans Simulink
ainsi que le fonctionnement détaillé du système. Pour plus de renseignements concernant le
fonctionnement propre à chaque bloc IP, il conviendra de se référer aux documentations Xilinx
correspondantes.
18b. Simulation sous Simulink
La simulation du filtre est séparée en deux blocs distincts : Acquisition et Traitement.
Figure 15 - Structure du projet FFT
Acquisition
Figure 16 - Acquisition du signal pour FFT
Le bloc principal de la partie acquisition est une mémoire FIFO à double accès : chaque accès
pouvant avoir son propre débit de données. L’écriture et la lecture non pas a être forcément
synchrones. La partie « écriture » de la FIFO est représenté par le bloc To_FIFO. Les donnés de
simulation chargées en mémoire parle fichier .m préalablement lancé sont récupérées grâce au
composant From Workspace. Ces points de mesures sont ensuite convertis en flux de données
binaires grâce au comparateur à hystérésis Relay_0.02. Carré entrée permet de visualiser le flux
incident sur Gateway In qui représente le pin d’entrée du FPGA (le numéro de patte est
paramétrable).
19Cast permet de convertir les données incidentes en données à virgule fixe (13 bits dont 12 pour la
partie décimale). Ce format constituera notre standard tout au long de la chaîne d’acquisition et de
traitement.
La profondeur de la mémoire FIFO a été fixée à 1024, mais cette valeur peut être modifiée selon
que l’on souhaite un maximum de fiabilité (flux de données incident ininterrompu lors du
traitement), ou un taux d’occupation minimum du FPGA. On affiche également, à titre informatif
lors de la simulation, l’occupation mémoire de la FIFO afin de s’assurer qu’un débordement n’a pas
lieu (ce qui couperait le flux d’entrée ici grâce la boucle entre la sortie full et WE (Write Enable)).
Traitement
20On retrouve ici la partie « lecture » de la FIFO, From_FIFO. Pulse Generator 1 et Step servent
ici à émuler le signal de reset global du circuit.
Après reset, on met en marche un compteur circulaire de 0 à 2047 (Counter) et on active un
signal à l’état haut lorsque le compteur est entre 1024 et 2047 (bloc Relational). Ce signal
commande la lecture de la FIFO ainsi que la commande select d’un multiplexeur 2-> 1 : Mux. Ce
système, associé à la lecture de la FIFO, permet de réaliser de manière très efficace l’opération de
zéro-padding : on enregistre N points de données (N = 1024 ici) dans la FIFO et on lit simultanément
la FIFO deux fois plus vite qu’on ne l’écrit. On rajoute N zéros à la fin.
On effectue ensuite une FFT sur 2N points (soit 2048 ici).
Figure 17 - Compteur circulaire et commande du multiplexeur pour zero-padding
Figure 18 - Flux de données arrivant sur le bloc FFT (on remarque le zéro-padding)
Le zéro-padding impose la création de zones de vitesses d’horloge différentes puisque la
lecture doit être deux fois plus rapide que l’écriture. Cela est rendu possible par la décomposition
du système global en sous-blocs (Acquisition et Traitement) et par la création d’un objet System
Generator pour chacun d’eux. La vitesse des flux de données est paramétrée par ces blocs. Il est à
noter que Simulink utilise des fréquences normalisées par rapport à la fréquence de l’horloge
principale (50 MHz ici).
21On trace ensuite la FFT avec l’IP Core de Xilinx « Fast Fourier Transform 6.0 ». L’utilisation de
ce bloc permet de bénéficier d’une architecture optimisée, facile d’utilisation et entièrement
paramétrable. On utilise ici le « pipelined mode » qui permet de calculer la FFT et de procéder à
l’acquisition des points de données en même temps. Cet aspect est essentiel pour l’impératif
temps-réel de notre application. En revanche, cela se traduit par un alourdissement de
l’architecture et donc de la consommation électrique. Le bloc calcule ici le FFT sur 2048 points (dont
1024 de signal).
Figure 19 - Calcul de la FFT
Le multiplieur permet d’élever au carré la sortie de la FFT avant passage par le détecteur de
maximum (Black Box). Le composant Black Box permet d’importer de créer des blocs Simulink
définis par l’utilisateur grâce à un fichier VHDL. Certains impératifs de syntaxe (noms de signaux
d’horloge et de reset en particulier) sont à respecter dans le fichier VHDL, il convient donc de se
référer à la documentation de ce bloc dans l’aide de XIlinx System Generator.
Le composant est capable alors de chercher le maximum ainsi que sa position au sein d’un flux de
donné. Le composant est réinitialisé à la fin de chaque calcul de FFT, signalé par un passage à 1 du
signal « early done » (edone). Ce signal est à l’état haut un coup d’horloge avant la fin du calcul de la
FFT.
Figure 20 – FFT après élévation au carré
22La figure précédente représente la distribution de la puissance en fonction de la fréquence. Les pics
primaires représentent les pics de continu et les pics secondaires correspondent aux pics de
fréquence Doppler. On remarque que le spectre est symétrique par rapport à Fe/2.
La figure suivante donne la position du maximum de FFT (en bas) et son amplitude (en haut)
détectée (hors pic DC et en tenant compte de la symétrisation du spectre) :
Figure 21 - FFT : Position et amplitude des maximums
On note tout d’abord que la position des pics est relativement régulière alors que leur puissance ne
l’est pas (ce qui peut engendrer certaines imprécisions au niveau de la mesure).
Un registre permet ensuite de mémoriser la position entre deux mesures afin de l’afficher.
La position du pic sur la FFT est directement proportionnelle à la fréquence du signal mesuré,
connaissant la fréquence d’échantillonnage.
c. Avantages et inconvénients de la méthode – perspectives et commentaires
Inconvénients
• Méthode plus complexe donc forcément plus coûteuse qui a terme devra faire appel à des
ASICs performants dans le calcul de la FFT.
• Besoin d’une mémoire de stockage des échantillons incidents.
Avantages
• Méthode qui semble être en simulation beaucoup plus précise. Il faudrait cependant la
tester en conditions réelles.
• Calcul de la fréquence en continu grâce au mode « pipelined » du composant FFT. Le calcul
de la FFT est rapide grâce à l’utilisation des DSP slices. Cette vitesse de calcul varie en
fonction de la fréquence de fonctionnement du bloc de calcul mais restera aux alentours de
50 µs (pour une évaluation plus précise, se référer aux tables données dans la
documentation du bloc FFT, fournie avec le dossier du projet).
23Perspectives – Conclusions
Il s’agit là d’une méthode efficace certes, mais beaucoup plus lourde que la méthode de comptage.
Elle est donc à réserver aux applications où une mesure précise de la vitesse est requise.
8. Conclusion du stage
Ce stage au sein du laboratoire LOSE de l’ENSEEIHT m’a permis tout d’abord de découvrir le monde
la recherche. Même si le cahier des charges au départ n’est pas très précis (il s’agissait au départ de
traiter le signal obtenu par rétro-injection optique dans une cavité LASER afin de retrouver
l’information fréquence afin de remonter à la vitesse), il a fallu faire preuve d’imagination et de
rigueur afin de chercher des méthodes de mesure, de les évaluer et de trouver les outils nécessaires
à leur mise en œuvre. C’est dans ce cadre que ce stage m’a permit de découvrir l’outil Xilinx System
Generator permettant d’assurer le lien de manière très efficace entre un développement hardware
de bas niveau (Xilinx ISE) et un environnement de développement et de simulation de plus haut
niveau (Simulink).
Il a donc fallu que je me familiarise avec ces outils de développement ainsi qu’avec l’utilisation des
différents IP Cores, sortes de boîtes noires sous le couvert de la propriété intellectuelle.
La première méthode – dite de comptage – m’a aussi permit d’être plus familier avec la
programmation Matlab (gestion de fichiers de données) et l’outil GUIDE permettant de réaliser des
interfaces graphiques. La méthode reposant sur la FFT est plus orientée simulation sous Simulink.
Il est cependant regrettable de n’avoir pas eu le temps de tester ces méthodes dans des conditions
réelles qui seules permettront de les valider.
Il en reste néanmoins que ce stage a été pour moi l’occasion de me rapprocher du monde de la
recherche, de ses avantages (flexibilité dans le travail et les horaires) ainsi que de ses inconvénients
(mise à l’épreuve de l’imagination, nécessité de résultats, constante recherche d’informations et de
données qui prennent beaucoup de temps à trier…). Ce stage fut très enrichissant au vu des
compétences acquises en matière d’utilisation de la suite Xilinx. Il m’a également fortement
sensibilisé aux contraintes liées aux systèmes embarqués.
249. Annexes
Comptage_Doppler.m
% --- Executes during object creation, after setting all properties.
function Files_ListBox_CreateFcn(hObject, eventdata, handles)
% hObject handle to Files_ListBox (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles empty - handles not created until after all CreateFcns called
% Hint: listbox controls usually have a white background on Windows.
% See ISPC and COMPUTER.
if ispc && isequal(get(hObject,'BackgroundColor'),
get(0,'defaultUicontrolBackgroundColor'))
set(hObject,'BackgroundColor','white');
end
clc;
curr_dir_filtered = strcat(pwd, '/*.csv') % pwd : récupère le répertoire courant
liste_fichier = dir(curr_dir_filtered); % Liste des fichiers à l'adresse indiqué dont
l'extension est .csv
nb_fichier = size(liste_fichier); % Renvoi le nombre de fichiers trouvés
liste_menu = '';
for i=1:nb_fichier; % Boucle comptant de 1 à
nb_fichier
liste_menu = strvcat(liste_menu, liste_fichier(i).name) % Concaténation des noms de
fichiers récupérés avec liste_menu
end
set(hObject,'String',liste_menu);
% --- Executes on button press in SelectFile_Btn.
function SelectFile_Btn_Callback(hObject, eventdata, handles)
% hObject handle to SelectFile_Btn (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
% 1) Récupération des données du fichier CSV sélectionné
list_entries = get(handles.Files_ListBox,'String')
index_selected = get(handles.Files_ListBox,'Value')
csv_filename = list_entries(index_selected, :)
% Importation du fichier csv
selected_file = strcat(pwd, '\', csv_filename)
DELIMITER = ',';
HEADERLINES = 14;
newData1 = importdata(selected_file, DELIMITER, HEADERLINES);
% Création des variables d'environnement à partir des champs
% [temps, amplitude]
vars = fieldnames(newData1)
t_A = newData1.(vars{1});
t_A(:,1) = t_A(:,1) + 0.02;
A = t_A(:,2);
assignin('base', 't', t_A(:,1)); % On déssymétrise le temps par rapport à 0
assignin('base', 'A', t_A(:,2));
% 2) Affichage des données sur le graphique
25plot(handles.axes1, t_A(:,1),t_A(:,2));
NFFT = 2^nextpow2(8192); % Next power of 2 from length of y
Y = fft(t_A(:,2), NFFT)/8192;
f = 2.5e6/2*linspace(0,1,NFFT/2);
plot(handles.axes2, f,2*abs(Y(1:NFFT/2)))
set(handles.axes2, 'XLimMode','manual');
set(handles.axes2, 'XLim', [0 3e5]);
set(handles.axes2, 'YLimMode','manual');
set(handles.axes2, 'YLim', [0 0.15]);
% 3) Calcul de la fréquence en utilisant une méthode de comptage
S = size(t_A); % On récupère le nombre de points
Nb_pts = S(1); % 100 000 points en général
count = 0;
index_result = 1;
front_montant = 0;
front_descendant = 0;
fe = 2500000;
N_F = str2num(get(handles.Edit_NF, 'string'));
str = 'Mesure de la fréquence par comptage tous les -';
str = strcat(str, num2str(N_F), '- échantillons');
set(handles.Legende_Comptage, 'string', str);
T = (0:1/fe:(Nb_pts-1)/fe)';
Deadband = str2num(get(handles.Edit_Deadband, 'string'));
for i=3:Nb_pts
% remplissage du tableau des fréquences mesurées
% if (mod(T(i), N_F/fe)==0) % On mesure la fréquence tous les N_F points
if (mod(i, N_F)==0) % On mesure la fréquence tous les N_F points
val_count(index_result,1) = count;
val_count(index_result,2) = T(i);
%val_count(index_result, 2) = T(i);
index_result = index_result + 1;
count = 0;
end;
% détection des fronts montants et descendants
% (deadband : [-0.02, +0.02])
if ((A(i-2)< Deadband && A(i-1) > Deadband && A(i) > Deadband) &&
front_montant == 0)
% détection front montant sur double 1
front_montant = 1;
front_descendant = 0;
% Incrémentation de la variable de comptage des fronts
count = count + 1;
elseif ((A(i-2)> -Deadband && A(i-1) < -Deadband && A(i) < -Deadband) &&
front_montant == 1)
% détection front montant sur double 0
front_montant = 0;
front_descendant = 1;
end;
end
% on convertit le comptage de fronts montants en fréquence :
val_count = val_count * fe / N_F;
plot(handles.axes3, val_count);
% set(handles.axes3, 'YLimMode','manual');
% set(handles.axes3, 'YLim', [0 100]);
26coeff_num = [0.028 0.053 0.071 0.053 0.028];
coeff_det = [1.000 -2.026 2.148 -1.159 0.279];
Y = filter(coeff_num, coeff_det, val_count);
plot(handles.axes3, Y);
Load_Data_FFT.m
% --- Executes during object creation, after setting all properties.
function Files_ListBox_CreateFcn(hObject, eventdata, handles)
% hObject handle to Files_ListBox (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles empty - handles not created until after all CreateFcns called
% Hint: listbox controls usually have a white background on Windows.
% See ISPC and COMPUTER.
if ispc && isequal(get(hObject,'BackgroundColor'),
get(0,'defaultUicontrolBackgroundColor'))
set(hObject,'BackgroundColor','white');
end
clc;
curr_dir_filtered = strcat(pwd, '/*.csv') % pwd : récupère le répertoire courant
liste_fichier = dir(curr_dir_filtered); % Liste des fichiers à l'adresse indiqué
dont l'extension est .csv
nb_fichier = size(liste_fichier); % Renvoi le nombre de fichiers trouvés
liste_menu = '';
for i=1:nb_fichier; % Boucle comptant de 1 à
nb_fichier
liste_menu = strvcat(liste_menu, liste_fichier(i).name) % Concaténation des noms
de fichiers récupérés avec liste_menu
end
set(hObject,'String',liste_menu);
% --- Executes on button press in SelectFile_Btn.
function SelectFile_Btn_Callback(hObject, eventdata, handles)
% hObject handle to SelectFile_Btn (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
% 1) Récupération des données du fichier CSV sélectionné
list_entries = get(handles.Files_ListBox,'String')
index_selected = get(handles.Files_ListBox,'Value')
csv_filename = list_entries(index_selected, :)
% Importation du fichier csv
selected_file = strcat(pwd, '\', csv_filename)
DELIMITER = ',';
HEADERLINES = 14;
newData1 = importdata(selected_file, DELIMITER, HEADERLINES);
% Création des variables d'environnement à partir des champs
% [temps, amplitude]
vars = fieldnames(newData1)
t_A = newData1.(vars{1});
t_A(:,1) = t_A(:,1) + 0.02;
% on sous-échantillonne 10 fois pour que fmax = 250 kHz (suffisant ici)
A_se = t_A(:,2);
27A_se = A_se(1:10:length(A_se));
t_se = t_A(:,1);
t_se = t_se(1:10:length(t_se));
assignin('base', 't', t_se); % On déssymétrise le temps par rapport à 0
assignin('base', 'A', A_se);
% 2) Affichage des données sur le graphique
plot(handles.axes1, t_A(:,1),t_A(:,2));
NFFT = 2^nextpow2(8192); % Next power of 2 from length of y
Y = fft(t_A(:,2), NFFT)/8192;
f = 2.5e6/2*linspace(0,1,NFFT/2);
plot(handles.axes2, f,2*abs(Y(1:NFFT/2)))
set(handles.axes2, 'XLimMode','manual');
set(handles.axes2, 'XLim', [0 3e5]);
set(handles.axes2, 'YLimMode','manual');
set(handles.axes2, 'YLim', [0 0.15]);
Max.vhd
---------------------------------------------------------------------------
-- Recherche du maximum
---------------------------------------------------------------------------
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;
entity Max is
Port ( rst : in STD_LOGIC;
clk_box : in STD_LOGIC;
ce_box : in STD_LOGIC;
A : in STD_LOGIC_VECTOR (15 downto 0);
S : out STD_LOGIC_VECTOR (15 downto 0);
fin : out STD_LOGIC;
i_out : out STD_LOGIC_VECTOR (15 downto 0);
o_tmp : out STD_LOGIC_VECTOR (15 downto 0);
S_pos : out STD_LOGIC_VECTOR (15 downto 0));
end Max;
architecture Behavioral of Max is
signal tmp : STD_LOGIC_VECTOR (15 downto 0);
signal tmp_pos : STD_LOGIC_VECTOR (15 downto 0);
signal i : STD_LOGIC_VECTOR (15 downto 0);
begin
process(rst, A, i, tmp, clk_box, ce_box, tmp_pos)
begin
if rst = '1' then
i '0');
finelsif rising_edge(clk_box) and ce_box = '1' then
if A > tmp and A > 1000 and i > 100 and i < 1024 then
-- on ne tient pas compte des 100 premières valeurs (=> pic DC), et de la symétrie
du spectre
tmpVous pouvez aussi lire
