مقراطيــة الشعبيــةيــة الجزائريــة الدي الجمـهورREPUBLIQUE ALGERIENNE DEMOCRATIQUE ET POPULAIRE N° d’ordre : …. Série : …. Mémoire Présenté en vue de l’obtention du Diplôme de Master en Electrotechnique Option Electrotechnique Thème COMMANDE D’UN MOTEUR A COURANT CONTINU VIA FPGA Présenté par : DERGHAL Smail Encadreur : Dr. MEHAZZEM Fateh Devant le jury : Président : Dr. KAIKAA Mohamed yazid Examinateurs : Prof. KHEZZAR Abdelmalek Dr. BABAA Fatima Membre de jury : Prof. KERDOUN Djallel Soutenue le 17/06/2015 MINISTERE DE L’ENSEIGNEMENT SUPERIEUR ET DE LA RECHERCHE SCIENTIFIQUE UNIVERSITE DES FRERES MENTOURI CONSTANTINE Faculté des Sciences de la Technologie Département : Electrotechnique تعلي وزارة ال ــلعال م ا ــ ي و البح ــعلم ث ال ـ ي جامع ـ ـــــ ـ ة ا خوة منتوري قسنطين ـــــــ ــ ةوم التكنولوجي كلـيــة عل ا قسمروتقنيلكت ا
This document is posted to help you gain knowledge. Please leave a comment to let me know what you think about it! Share it to your friends and learn new things together.
Transcript
الجمـهوريــة الجزائريــة الديمقراطيــة الشعبيــةREPUBLIQUE ALGERIENNE DEMOCRATIQUE ET POPULAIRE
N° d’ordre : ….
Série : ….
Mémoire
Présenté en vue de l’obtention du
Diplôme de Master en Electrotechnique
Option
Electrotechnique
Thème
COMMANDE D’UN MOTEUR A COURANT
CONTINU VIA FPGA
Présenté par :
DERGHAL Smail
Encadreur :
Dr. MEHAZZEM Fateh
Devant le jury :
Président : Dr. KAIKAA Mohamed yazid
Examinateurs : Prof. KHEZZAR Abdelmalek
Dr. BABAA Fatima
Membre de jury : Prof. KERDOUN Djallel
Soutenue le 17/06/2015
MINISTERE DE L’ENSEIGNEMENT SUPERIEUR
ET DE LA RECHERCHE SCIENTIFIQUE
UNIVERSITE DES FRERES MENTOURI CONSTANTINE
Faculté des Sciences de la Technologie
Département : Electrotechnique
يـث العلمــي و البحــم العالــوزارة التعلي
ةـــــــــقسنطين خوة منتورياإل ةـــــــجامع
اكلـيــة علوم التكنولوجي
االلكتروتقني قسم
CHAPITRE II : Commande Des Moteurs à Courant Continue Via Les Hacheurs
Commande d’un MCC via FPGA 1
Remerciements
CHAPITRE II : Commande Des Moteurs à Courant Continue Via Les Hacheurs
Commande d’un MCC via FPGA 2
Dédicace
CHAPITRE II : Commande Des Moteurs à Courant Continue Via Les Hacheurs
Commande d’un MCC via FPGA 1
SOMMAIRE
Introduction générale
CHAPITRE I : Prototypage rapide sous FPGA - SYSGEN
2. Les FPGA .................................................................................................................................................. 2
3. Le langage de programmation VHDL ....................................................................................................... 5
3.1. Définition du VHDL ........................................................................................................................... 5
3.2. Historique de VHDL .......................................................................................................................... 5
3.3. Structure d'un module VHDL (Unité de conception) ......................................................................... 5
3.4. Notions de base................................................................................................................................... 5
3.6. Les instructions port et generic ........................................................................................................... 7
3.7. Les directions...................................................................................................................................... 7
3.8. Les objets ............................................................................................................................................ 7
3.9. Notation des littéraux ......................................................................................................................... 8
3.10. Les types principaux en synthèse ................................................................................................... 8
3.11. Les bibliothèques ............................................................................................................................ 8
3.12. Les opérations dans VHDL ........................................................................................................... 9
3.13. Les types manipulés par VHDL .................................................................................................. 10
3.14. Les constantes ............................................................................................................................... 10
3.15. Les variables ................................................................................................................................. 10
3.16. Les signaux ................................................................................................................................... 11
3.17. Les commentaire en VHDL .......................................................................................................... 11
3.18. Les processus ............................................................................................................................... 11
3.19. Les principales caractéristiques du langage VHDL ..................................................................... 12
Un langage s'appliquant à plusieurs niveaux de descriptions ................................... 12 3.19.1.
Figure III- 24 : L'allure sur oscilloscope du courant d’induit avec (alpha = 0.3) ................................. 51
Figure III- 25 : L'allure sur oscilloscope du courant d’induit avec (alpha = 0.7) ................................. 51
Figure III- 26 : L'allure sur control desk du courant d’induit avec (alpha = 0.7) ................................. 51
Figure III- 27 : L'allure sur Control Desk du courant d’induit avec (alpha = 0.3) ................................ 51
Figure III- 28 : L'allure de vitesse du MCC (tour/min) _ (alpha = 0.7) ................................................ 52
Figure III- 29 : L'allure de vitesse du MCC (tour/min) _ (alpha = 0.3) ................................................ 52
Figure III- 30a : Signal MLI (PWM) avec (alpha = 0.3) ...................................................................... 53
Figure III- 30b : Signal MLI (PWM) avec (alpha = 0.7) ...................................................................... 53
Figure III- 31 : L'allure du courant d’induit avec (alpha = 0.3) ............................................................ 53
Figure III- 32 : L'allure du courant d’induit avec (alpha = 0.7) ............................................................ 54
Figure III- 33 : L'allure de vitesse du MCC (tour/min) _ (alpha = 0.3) ................................................ 54
Figure III- 34 : L'allure de vitesse du MCC (tour/min) _ (alpha = 0.7) ................................................ 54
CHAPITRE II : Commande Des Moteurs à Courant Continue Via Les Hacheurs
Commande d’un MCC via FPGA 1
Introduction générale
Ce mémoire a été réalisé dans le cadre de la formation Master II, option électrotechnique, au sein
du laboratoire d'électrotechnique de Constantine. L'objectif de ce projet est la commande d’un moteur
à courant continu via une carte FPGA.
Les moteurs et les générateurs (dynamos) à courant continu furent les premières machines
électriques utilisées par les ingénieurs au milieu du 19ième
siècle pour produire de la puissance motrice
particulièrement dans le transport ferroviaire (tramways, TGV), et maintenant restent très utilisés dans
le domaine de l’automobile (ventilateurs, lève-vitre, etc.)
Les FPGAs, Field Programmable Gate Array ou réseau de portes programmables. Ce sont des
circuits intégrés programmables (ou plutôt reconfigurables) plusieurs fois et de plus en plus
dynamiquement! Ils permettent d’émuler un circuit afin de le valider avant la gravure silicium.
Ce mémoire présente notre projet qui consiste à commander un moteur à courant continu par un
signal modulé en largeur d’impulsion (MLI). La commande a été programmée en langage VHDL en
utilisant une carte FPGA (ALTERA Cyclone II).
Ce mémoire est divisé en trois chapitres, organisés comme suit:
Dans le premier chapitre nous avons présentés des notions générales sur les FPGAs, son
langage de programmation VHDL et on a parlé d’un nouveau outil, utilisé pour faciliter la
programmation, c’est le System Generator (SYSGEN).
Dans le deuxième chapitre nous avons présenté une étude théorique du moteur à courant
continu et aussi des convertisseurs continu/continu ou bien les Hacheurs.
Dans le troisième chapitre, nous avons présenté notre application concernant la commande
d’un moteur à courant continu via une carte FPGA. Une description détaillée des parties
matérielles et logicielles de l’application a été donnée, ainsi qu’aux différents résultats
pratiques obtenus par les deux cartes Altera et DSPace. Ces résultats concernent les deux
solutions (Simulink et VHDL-Sysgen) pour générer le signal PWM.
Enfin, dans la dernière partie, nous terminons par une conclusion générale sur cette étude ainsi
que les perspectives envisageables pour un travail futur.
CHAPITRE I : Prototypage rapide sous FPGA - SYSGEN
Commande d’un MCC via FPGA 1
CHAPITRE 1
Prototypage rapide sous FPGA - SYSGEN
CHAPITRE I : Prototypage rapide sous FPGA - SYSGEN
Commande d’un MCC via FPGA 2
1. Introduction
La densité croissante des circuits programmables actuels, notamment des FPGA (Field
Programmable Gate Array), permet le prototypage rapide des circuits numériques à grande
complexité. Aussi, il est possible de tester rapidement la validité de concepts architecturaux nouveaux:
l'implémentation complète d'un processeur sur des circuits FPGA est aujourd'hui à notre portée,
entraînant ainsi plus de possibilités d'évaluation que celles offertes par des simulateurs logiciels.
La part de marché des FPGA dans le marché globale des circuits matériels pour l’électronique
numérique ne cesse d’augmenter. Les évolutions technologiques et architecturales qui ont eu
successivement lieu depuis le début des années 2000 ont fait de ces circuits de réels et rentables
alternatives aux classiques ASIC. Avec ces évolutions c’est tout un nouveau domaine de
l’électronique numérique qui s’est ouvert. Aujourd’hui les FPGA sont utilisés dans tous les domaines,
des systèmes embarqués aux systèmes de communications, ils sont au cœur d’un important champ de
recherche académique et industrielle.
2. Les FPGA[1]
Les FPGA (Field Programamble Gate Array) sont des circuits numériques configurables, dédiés à
l’électronique numériques. A l’état initial ils ne peuvent rien faire mais disposent d’une importante
quantité (dépendant de la technologie utilisée) de ressources matérielles opérationnelles dont on peut
configurer la fonction. Ces ressources sont, principalement, des blocs élémentaires logiques (pour
réaliser des fonctions booléennes), des mémoires RAM, des opérateurs arithmétiques (qui travaillent
en virgule fixe), des ressources de routage interne et des entrées/sorties. Ces ressources configurables
sont reliées par un réseau dense de lignes de routage et de lignes de transport des horloges. Ces lignes
de routage sont aussi configurables.
En plus de ces ressources, un FPGA est composé d’une mémoire interne de configuration. Chaque
point de cette mémoire correspond à la configuration d’un élément d’une des ressources
opérationnelles. Cette mémoire est, dans la plupart des cas, réalisée avec une des trois technologies
suivantes : ANTIFUSIBLE (la plus ancienne, configurable une seule fois), FLASH (non-volatile) ou
SRAM (volatile, la plus utilisée, représente plus de 80 % du marché).
Comme le montre la figure 1, pour réaliser une application avec un FPGA, il faut décrire le circuit
électronique à réaliser avec un langage de description matérielle comme le VHDL (Very High Speed
Integrated Circuit Hardware Description Langage). Puis il faut synthétiser cette description en circuit
électronique. Cette étape et les suivantes peuvent se faire avec des logiciels gratuits, fournis par le
fabricant de circuit. Enfin après une étape de placement et routage qui prend en compte l’architecture
du FPGA, un fichier de configuration appelé bitstream est généré. Celui-ci permet de spécifier au
FPGA lors de la configuration la position des points de la mémoire de configuration.
Parmi les principaux fabricants de FPGA dans le monde on peut citer : Xilinx (N°1 du marché des
FPGA, 53% de part de marché), Altera (N°2 du marché des FPGA, 36 % de part de marché)
CHAPITRE I : Prototypage rapide sous FPGA - SYSGEN
Commande d’un MCC via FPGA 3
2.1. L’architecture [2]
Structurés sous forme de matrices, les FPGA sont composés d’éléments logiques de base, constitués
de portes logiques, présentes physiquement sur le circuit. Ces portes sont reliées par un ensemble
d’interconnexions modifiables : d’où l’aspect programmable du circuit.
Figure I- 1 : Flot classique de conception FPGA.
Figure I- 2 : Structure d’un circuit FPGA
CHAPITRE I : Prototypage rapide sous FPGA - SYSGEN
Commande d’un MCC via FPGA 4
La structure du FPGA est composée :
De cellules d’entrées sorties modifiables qui servent d’interfaces entre les broches du circuit
et le cœur du FPGA pour adapter les signaux suivants :
o Alimentation
o Signaux d’horloge
o Signaux de configuration du FPGA
o Signaux de test
De blocs logiques ou éléments logiques contenant les fonctions logiques combinatoires et
séquentielles.
La partie combinatoire permet de réaliser des fonctions de complexité moyenne avec
des portes classiques ET, OU et NON de deux à une dizaine d’entrées.
La partie séquentielle comporte une ou deux bascules généralement de type D.
Compte tenu du nombre d’éléments logiques et de leur structure, leur association
permet de réaliser tous les types de bascule. L’intérêt est de créer des mémoires
élémentaires à un bit.
De réseaux d’interconnexions : Ces réseaux relient entre eux les blocs logiques et les blocs
d’entrées/sorties.
2.2. Historique [1]
En 1984 la société américaine Xilinx fut précurseur du domaine en lançant le premier circuit
FPGA commercial, le XC2000. Ce composant avait une capacité maximum de 1500 portes logiques.
La technologie utilisée était alors une technologie aluminium à 2µm avec 2 niveaux de métallisation.
Xilinx sera suivi un peu plus tard, et jamais lâché, par son plus sérieux concurrent Altera qui lança en
1992 la famille de FPGA FLEX 8000 dont la capacité maximum atteignait 15000 portes logiques.
Depuis les années 2000 des évolutions majeures ont été apportées. Les technologies utilisées pour
les FPGA sont les mêmes que celles utilisées pour les ASIC(1)
. Par exemple, la technologie cuivre est
mise en œuvre pour la réalisation des métallisations au sein des FPGA. Elle permet une réduction
d’environ 70% des temps de propagation des signaux le long des métallisations par rapport à la
technologie aluminium.
En 2000, les technologies utilisées étaient des technologies CMOS 0,15µm avec 8 niveaux de
métallisation, aujourd’hui la technologie utilisée est la technologie CMOS 40 nm avec plus de 10 ou
12 niveaux de métallisation en cuivre.
En 2000 et 2001 les deux concurrents Xilinx et Altera ont franchi une nouvelle étape au niveau de
la densité d’intégration en sortant respectivement leurs circuits Virtex et Apex-II dont les capacités
maximums avoisinaient les 4 millions de portes logiques équivalentes avec en plus l’introduction de
larges bancs de mémoire embarquée. Aujourd’hui, les fréquences de fonctionnement de ces circuits
sont de l'ordre de quelques centaines de méga Hertz.
1)
Un ASIC est un circuit électronique réalisé sur mesure. Ce sont les circuits les plus performants
mais aussi les plus chers et longs à réaliser.
CHAPITRE I : Prototypage rapide sous FPGA - SYSGEN
Commande d’un MCC via FPGA 5
3. Le langage de programmation VHDL [3][4][5]
3.1. Définition du VHDL [3]
Le VHDL (Very high speed - or scale - integrated circuits Hardware Description Language) est
utilisé pour la modélisation et la synthèse de circuits numériques. La modélisation permet de simuler
le comportement d'un circuit numérique, tandis que la synthèse permet de le programmer (si
nécessaire).
Lors du développement d'un CPLD ou d'un FPGA, la simulation du comportement de ce dernier
est effectuée à l'aide d'un modèle. Celui-ci est déterminé directement par le logiciel programmation
(fourni par un constructeur de CPLD) utilisé, à partir de la description VHDL entrée (simulation
fonctionnelle) et en fonction du composant cible et de ses temps de propagation (simulation
temporelle). Il reste seulement à définir les chronogrammes des signaux d'entrée du composant pour
vérifier que le fonctionnement est bien celui souhaité.
3.2. Historique de VHDL [4]
Le VHDL a été développé dans les années 80 aux USA et est devenu une norme IEEE (n° 1076)
en 1987. Révisée en 1993 pour supprimer quelques ambiguïtés, cette norme est vite devenue un
standard en matière d’outils de description de fonctions logiques. Le VHDL est principalement utilisé
pour concevoir des ASIC, programmer des composants du type PLD, CPLD, FPGA…, et concevoir
des modèles de simulation numérique ou des bancs de test.
3.3. Structure d'un module VHDL (Unité de conception)
L’unité de conception (design unit) est le plus petit module compilable séparément. VHDL offre cinq
types d’unités de conception : la déclaration d’entité, le corps d’architecture, la déclaration de
configuration, la déclaration de paquetage et le corps de paquetage.
AN : Module = Entity + Architecture
3.4. Notions de base [3]
Ce langage ne fait théoriquement pas de distinction entre majuscules et minuscules. Certains outils
de synthèse font cependant une distinction pour quelques cas particuliers (description de l'état haute
impédance ‘Z’ – et non ‘z’ - avec le logiciel Max+plus II par exemple). Pour une meilleure lisibilité
les mots réservés ont été écrits ici en minuscules et en gras, les noms donnés par l’utilisateur en
majuscules.
En VHDL les commentaires sont précédés par « -- » et s’arrêtent au retour à la ligne.
La structure typique d'une description VHDL est donnée ci-après :
CHAPITRE I : Prototypage rapide sous FPGA - SYSGEN
Commande d’un MCC via FPGA 6
-- déclaration des ressources externes.
library NOM_DE_LA_BIBLIOTHEQUE ; use ELEMENT_DE_LA_BIBLIOTHEQUE ;
-- description de l’entité avec des entrées et des sorties, caractérisée par des paramètres
entity NOM_DE_L’ENTITE is generic (PARAMETRES : « type »:=VALEURS_FACULTATIVES ) ; port ( NOM_DES_ENTREES_SORTIES : « direction » « type ») ; end NOM_DE_L’ENTITE ;
-- description de l’architecture à l’intérieure de l’entité ;
-- à une entité peut correspondre plusieurs architectures
architecture NOM_DE_L’ARCHITECTURE of NOM_DE_L’ENTITE is -- déclaration si nécessaire des objets internes
NOM_DES_OBJETS_INTERNES : « type »; -- déclaration si nécessaire des types
type NOM_DES_TYPES is (VALEURS_POSSIBLES) ; -- description du fonctionnement
begin DESCRIPTION ; end NOM_DE_L’ARCHITECTURE ;
Comme on peut le voir, la structure comprend une entité décrivant les entrées sorties, et une
architecture associée à l'entité décrivant le fonctionnement.
les ressources externes
l’entité
l’architecture
les ressources internes de
l’architecture
Figure I- 3 : La structure typique d'une description VHDL
CHAPITRE I : Prototypage rapide sous FPGA - SYSGEN
Commande d’un MCC via FPGA 7
Exemple de programme :
entity ET is port (E1, E2 : in bit; S : out bit ); end ET; architecture ARCH_ET of ET is begin S <= E1 and E2; end ARCH_ET;
A une entité peuvent correspondre plusieurs architectures. De cette manière, il devient possible de
modifier la structure interne d'une description sans modifier la vue externe, cette propriété du VHDL
devenant très intéressante dès lors que plusieurs description sont imbriquées les unes dans les autres.
Les entités et architectures sont des unités de conception, dites respectivement primaires et secondaire.
3.5. Syntaxe
On notera au passage la présence de points virgules à la fin de chaque ligne de déclaration et après
chaque instruction. Lorsqu'une liste d'entrées, de sorties ou de paramètres est énumérée, la séparation
se fait par des virgules.
Comme dans la plupart des langages informatique, il est fortement conseillé de se servir des
tabulations pour améliorer la lisibilité. Les outils de synthèse proposent en général l'utilisation de
couleurs différentes.
3.6. Les instructions port et generic
L'instruction port permet de décrire les entrées et sorties.
Facultative l'instruction generic permet de spécifier certains paramètres de l'entité, comme par
exemple la largeur d'un bus.
3.7. Les directions
Elles permettent de préciser les sens des connexions entrantes ou sortantes de l'entité.
in : entrée
out : sortie
inout : entrée-sortie.
3.8. Les objets
Les objets sont des ressources internes à une unité de conception, qui n'apparaissent pas comme entrée
ou sortie de l'entité. Il existe trois sortes d'objets :
signal : le signal représente une connexion interne, déclaré dans une entité ou une architecture.
Le signal permet de pallier les limitations des directions inout.
variable : la variable est généralement utilisée comme index dans la génération de boucle et n'a
habituellement pas de correspondance avec un signal physique. Elle ne peut être déclarée que dans un
process ou un sous-programme.
CHAPITRE I : Prototypage rapide sous FPGA - SYSGEN
Commande d’un MCC via FPGA 8
constant : permet une meilleure lisibilité du programme. Un composant définit avec une constante de
N bits pourra facilement passer de 8 à 64 bits (grâce à l'instruction generic par exemple).
3.9. Notation des littéraux
- bits et caractères : entre apostrophes ; exemple '0'.
- chaîne de bits et chaîne de caractères : entre guillemets ; exemple "01110".
- nombre décimaux : exemple pour la valeur mille ; 1000, 1_000, 1E3, 1.00E3.
- nombre hexadécimaux : entre guillemets précédés de x ; exemple x"1AFF".
3.10. Les types principaux en synthèse
La notion de type est très importante en VHDL, chaque entrée, sortie, signal, variable ou constante,
est associé à un type.
integer : nombre entier pouvant aller de –231
à 231
(suivant les compilateurs), peut être limité
entre deux extremums par la déclaration :
« integer range MIN to MAX ;»
La déclaration d'un entier sans préciser de valeurs limites équivaut donc à créer un bus de 32 bits à
l'intérieur du composant cible.
bit : deux valeurs possibles : 0 ou 1
bit_vector : un vecteur de bits est un bus déclaré par exemple pour une largeur de N bits par
bit_vector(0 to N) ou bien bit_vector(N downto 0).
boolean : ce type est utilisé pour les conditions (dans une boucle par exemple) et comprend deux
valeurs, true (vrai) ou false (faux).
3.11. Les bibliothèques
Ce sont des répertoires -au sens informatique du terme- où se trouvent des fichiers contenant des
unités de conception, c'est à dire :
- des entités et architectures associée,
- des spécifications de paquetage, ainsi que la description du corps associé,
- des configurations.
Ces ressources n'auront donc pas besoin d'être décrite dans le programme principal. Il suffira d'appeler
la bibliothèque avec la syntaxe :
libraryNOM_DE_LA_BIBLIOTHEQUE ;
Les paquetages : Un paquetage permettra d'utiliser sans avoir à les redécrire essentiellement des
objets (signaux, constantes), des types et sous-types, des sous-programmes et des composants.
L'appel du paquetage se fait après l'appel de la bibliothèque qui le contient. On indique alors le nom
du fichier contenant le paquetage par l'instruction qui suit :
use NOM_DE_LA_BIBLIOTHEQQUE . NOM_DU_PAQUETAGE.all ;
CHAPITRE I : Prototypage rapide sous FPGA - SYSGEN
Commande d’un MCC via FPGA 9
Il existe des paquetages prédéfinis fournis avec les outils de synthèse :
- le paquetage standard qui contient la déclaration de tous les types prédéfinis de base.
- le paquetage std_logic_1164 contenu dans la bibliothèque ieee qui contient entre autre la définition
des types std_logic et std_logic_vector. - le paquetage std_logic_arith (très semblable au paquetage numeric_std) de la bibliothèque ieee qui
permet des conversions de type (entier vers std_logic et inversement).
- les paquetages std_logic_signed et std_logic_unsigned de ieee permettant des opérations
arithmétiques signées ou non sur des types std_logic.
On rappelle qu’un std_logic_vector sera considéré comme codé en binaire naturel si le paquetage
ieee.std_logic_unsigned à été déclaré et comme codé en complément à 2 si le paquetage
ieee.std_logic_signed a été déclaré.
3.12. Les opérations dans VHDL [4]
L'opération d'affectation
<= ---- Affectation
Les opérations arithmétiques :
+ ---- Addition
- ---- Subtraction
* ---- Multiplication
/ ---- Divide
mod / rem ---- Modulus
** ---- Power Operator (i.e. 2**8 returns 256)
Les opérations logiques :
Utilisées pour les objets de types Bit, booléen ou tableau uni dimensionnel de ces types.
NOT ---- Invert a single-bit signal or each bit in a bus
AND ---- AND two single bits or each bit between two buses
OR ---- OR two single bits or each bit between two buses
XOR ---- XOR two single bits or each bit between two buses
XNOR ---- XNOR two single bits or each bit between two buses
Les opérations de comparaison (les opérateurs relationnels) :
NOT ---- Not True
AND ---- Both Inputs True
OR ---- Either Input True
= ---- Inputs Equal ---> sur tous les opérateurs (sauf file)
/= ---- Inputs Not Equal ---> sur tous les opérateurs (sauf file)
< ---- Less-than
Figure I- 4 : les différents portes logiques
CHAPITRE I : Prototypage rapide sous FPGA - SYSGEN
Commande d’un MCC via FPGA 10
<= ---- Less-than or Equal
> ---- Greater-than
>= ---- Greater-than or Equal
3.13. Les types manipulés par VHDL [4]
Un type (type) est caractérisé par un ensemble de valeurs et un ensemble d’opérations. Il existe quatre
classes de types:
Les types scalaires (scalar) : entier, réel, énuméré, physique.
Les types composites (composite) : tableau, enregistrement.
Le type accès (access) : accès (pointeur) à des objets d’un type donné.
Le type fichier (file) : fichier, séquence de valeurs d’un type donné.
Les types prédéfinis sont :
STD_LOGIC --'U','X','0','1','Z','W','L','H','-'
STD_LOGIC_VECTOR --Natural Range of STD_LOGIC
BOOLEAN --True or False
INTEGER --32 or 64 bits
NATURAL --Integers >= 0
POSITIVE --Integers > 0
REAL --Floating-point
BIT --'0','1'
BIT_VECTOR(Natural) --Array of bits
CHARACTER --7-bit ASCII
STRING(POSITIVE) --Array of charachters
TIME --hr, min, sec, ms, us, ns, ps, fs
DELAY_LENGTH --Time >= 0
Exemples de types non prédéfinis :
-- types entiers:
type Byte is range 0 to 255; -- intervalle ascendant
type Bit_Index is range 31 downto 0; -- intervalle descendant
-- types réels:
type Signal_Level is range -15.0 to +15.0; -- intervalle ascendant
type Probability is range 0.0 to 1.0; -- intervalle ascendant
3.14. Les constantes
Une constante (constant) a par définition une valeur fixe définie une fois pour toute:
constant PI: Real := 3.1416;
constant INDEX_MAX: Integer := 10*N; -- N doit être déclaré avant
constant Delay: Delay_Length := 5 ns;
3.15. Les variables
Une variable (variable) est un objet dont la valeur est modifiable par affectation. Une déclaration de
variable définit son nom, son type et éventuellement sa valeur initiale:
variable count: Natural;
-- valeur initiale: count = 0 (= Natural’Left)
variable isHigh: Boolean;
CHAPITRE I : Prototypage rapide sous FPGA - SYSGEN
Un CODEC 24-bit CD-quality avec jacks entrée ligne, sortie ligne et microphone-in
Un CNA VGA (10-bit high-speed triple DACs) avec connecteur VGA-out
Un décodeur TV (NTSC/PAL) avec connecteur TV-in
Un contrôleur 10/100 Ethernet avec connecteur
Un contrôleur USB Hôte/Esclave avec connecteurs USB type A et type B
Un E/R RS-232 avec connecteur 9-broches
Un connecteur PS/2 souris/clavier
Un E/R IrDA
2 connecteurs d’extension 40-broches avec diodes de protection
Figure III- 17: La carte Altera DE2
Figure III- 18 : La carte Altera Cyclone II EP2C35F672C6
CHAPITRE III : Implémentation et résultats
Commande d’un MCC via FPGA 47
4. Partie logicielle
4.1. Génération de la PWM sous Matlab/simulink
4.2. Solution sous FPGA pour Générer PWM
a) Génération PWM avec VHDL [17]
Le code VHDL permettant la génération de la PWM est le suivant :
Partie 1 :
-- PFE COMMANDE D'UN MCC VIA FPGA -- objectif: un signal PWM(MLI)! -------------------------------------- -- clk fpga Altera Cyclone II = 50 MHz -- T=1/clk = 20ns library IEEE; use IEEE.STD_LOGIC_1164.ALL; use IEEE.STD_LOGIC_ARITH.ALL; use IEEE.STD_LOGIC_UNSIGNED.ALL; entity pwm_dc is port ( clk : in std_logic; --l’horloge de la carte FPGA reset : in std_logic; --bouton pour remettre le programme à zéro. btn1 : in std_logic; --bouton pour diminuer le rapport cyclique (alpha) btn2 : in std_logic; --bouton pour augmenter le rapport cyclique (alpha) pwm : out std_logic -- **la commande MLI (PWM)** ); end pwm_dc;
Relay
10
Gain3
2*pi
Gain1
rem(u(1),u(2))
Fcn
K Ts
z-1
boolean
Data Type Conversion
Bad Link
DS1104BIT_OUT_C12
2*pi
2*pi
2
In2
1
In1
Figure III- 20 : Le bloc PWM
1000
fréquence d'hachage
1 cte1
RTI Data
In1
In2
PWM
Figure III- 19 : Modèle simulink pour générer PWM
CHAPITRE III : Implémentation et résultats
Commande d’un MCC via FPGA 48
architecture Behavioral of pwm_dc is constant period : integer:=50000; -- 50000*20ns=1ms /la pré-division de l’horloge /fréq.d’hachage constant alpha_max : integer:=45000; -- 45000*20ns = 0.9 ms constant alpha_min : integer:=5000; -- 5000*20ns = 0.1 ms constant alpha_in : integer:=10; --10*20ns = 0.0002 ms -- Le pas d’augmentation ou de diminution du rapport cyclique signal pwm_reg, pwm_next : std_logic; signal alpha, alpha_next : integer := 0; signal counter, counter_next : integer := 0; --variables d’aides pour le calcul ou pour la mémorisation. signal tick : std_logic; -- un signal sous forme d’impulsion de période 50000*20ns=1ms
Cette première partie du programme contient l’entité où sont déclarées les entrées et sorties du
programme : :
Les entrées :
Clk : l’horloge de la carte ALTÈRA qui est de 20 ns.
Reset : bouton pour remettre le programme à zéro.
btn1, btn2 : boutons pour augmenter et diminuer le rapport cyclique.
pwm : la commande MLI (PWM)
Les variables internes :
period : constante le long du programme pour la pré-division de l’horloge de notre programme.
alpha_max, alpha_min : La valeur maximum et minimum du rapport cyclique et qui restent aussi
constantes le long du programme.
alpha_in : Le pas d’augmentation ou de diminution du rapport cyclique par l’appuie les boutons
appropriés.
pwm_reg, pwm_next, alpha, alpha_next, counter, counter_next : variables d’aides pour le calcul
ou pour la mémorisation.
Tick : un signal sous forme d’impulsion de période 50000*20ns = 1 ms .
Partie 2 :
-- la pré-division de l’horloge pour avoir un signal PWM de période 1ms ------------------------------------------------------------------------------------------------ begin process(clk,reset) begin if (reset='1') then pwm_reg <= '0'; counter <= 0; alpha <= 0; elsif (clk='1' and clk' event) then pwm_reg <= pwm_next; counter <= counter_next; alpha <= alpha_next; end if;
CHAPITRE III : Implémentation et résultats
Commande d’un MCC via FPGA 49
end process; counter_next <= 0 when counter = period else counter+1; tick <= '1' when counter = 0 else '0';
La deuxième partie du programme consiste à la pré-division de l’horloge pour avoir un signal
PWM de période 1ms, au lieu de 20 ns.
Partie 3 :
-- la modification du rapport cyclique (alpha) du signal PWM ---------------------------------------------------------------------------------- process(btn1,btn2,tick,alpha) begin alpha_next <= alpha; if (tick = '1') then if (btn1 = '0') and (alpha > alpha_min) then alpha_next <= alpha - alpha_in; elsif (btn2 = '0') and (alpha < alpha_max) then alpha_next <= alpha + alpha_in; end if; end if; end process; pwm <= pwm_reg; pwm_next <= '1' when counter < alpha else '0'; end Behavioral;
--********** ************* THE END *****************************
La troisième partie du programme est consacrée à la modification du rapport cyclique du signal PWM,
en appuyant sur les boutons btn1,btn2 pour augmenter et diminuer le rapport cyclique.
Figure III- 12 : Schéma RTL du signal PWM
CHAPITRE III : Implémentation et résultats
Commande d’un MCC via FPGA 50
b) Génération PWM avec SYSGEN
Pour déterminer les instants de fermeture et d'ouverture des interrupteurs, on utilise la technique
(MLI), que consiste à comparer le signal de référence (modulante) de forme continu, à un signal
triangulaire (porteuse).
Fréquence d'horloge : elle dépend de type de carte FPGA ; dans notre cas la carte Alera DE2
utilisé :
Fréquence avec prédiviseur (Prescale):On utilise :
Timer (Compteur ): La résolution du timer dépend du timer choisi :
On utilise 8 bits (soit )
Valeur de débordement : fixé en fonction du rapport cyclique souhaité
Exemple : valeur = 192 donc rapport cyclique = (192/256)=0.75=75%
0.7*256
signal de référence
(signal continu)
++
signal de la porteuse
(sawtooth)
comparaison
a
b
a b
Relational
PWM
Out
Gateway Out2
Out
Gateway Out
In
Gateway InSy stem
Generator
Figure III- 22 : Génération PWM avec System generator
Figure III- 23 : Illustration Comment programmer le PWM.
CHAPITRE III : Implémentation et résultats
Commande d’un MCC via FPGA 51
5. Résultats
5.1. Résultats Avec DSPace
Ci-dessous les résultats obtenus concernant la commande du MCC sous l’environnement
Matlab/Simulink/Dspace
a) L’allure des courants d’induit et inducteur avec les rapports cycliques =0.3 et =0.7
Figure III- 24 : L'allure sur oscilloscope du
courant d’induit avec (alpha = 0.3)
Figure III- 25 : L'allure sur oscilloscope du
courant d’induit avec (alpha = 0.7)
0 0.5 1 1.5 2 2.5 3 3.5 4
x 104
-0.5
0
0.5
1
1.5
2
2.5
3
Figure III- 26 : L'allure sur control desk du courant d’induit avec (alpha = 0.7)
0 0.5 1 1.5 2 2.5 3 3.5 4
x 104
-0.5
0
0.5
1
Figure III- 27 : L'allure sur Control Desk du courant d’induit avec (alpha = 0.3)
CHAPITRE III : Implémentation et résultats
Commande d’un MCC via FPGA 52
b) L’allure de la vitesse avec les rapports cycliques =0.3 et =0.7
5.2. Résultat Avec FPGA
Ci-dessous les résultats obtenus concernant la commande du MCC sous l’environnement
QuartusII/FPGA.
a) Allure du signal PWM (MLI)
Tableau III- 1 : les résultats obtenu avec VHDL_FPGA
E (Tension d’alimentation) (V) 60V
Alpha 0.3 0.7
Uch_théorique (V) 85.7 200.0
Uch_mésuré (V) 104 205
0 0.5 1 1.5 2 2.5 3 3.5 4
x 104
800
1000
1200
1400
1600
1800
2000
Figure III- 28 : L'allure de vitesse du MCC (tour/min) _ (alpha = 0.7)
La Vitesse environ 1920 tr/mn
Figure III- 29 : L'allure de vitesse du MCC (tour/min) _ (alpha = 0.3)
La Vitesse environ 980 tr/mn
0 0.5 1 1.5 2 2.5 3 3.5 4
x 104
800
1000
1200
1400
1600
1800
2000
CHAPITRE III : Implémentation et résultats
Commande d’un MCC via FPGA 53
Tension d’alimentation
E = E% × Esource
E = 26% × 230V
E = 60V
Uch quand (Alpha = 0.3) Uch quand (Alpha = 0.7)
b) L’allure des courants d’induit et inducteur avec les rapports cycliques =0.3 et =0.7
Figure III- 30a : Signal MLI (PWM)
avec (alpha = 0.3)
Figure III- 30b : Signal MLI (PWM) avec
(alpha = 0.7)
0 0.2 0.4 0.6 0.8 1 1.2 1.4 1.6 1.8 2
x 104
-0.5
0
0.5
1
1.5
2
2.5
3
Figure III- 31 : L'allure du courant d’induit avec (alpha = 0.3)
CHAPITRE III : Implémentation et résultats
Commande d’un MCC via FPGA 54
c) L’allure de la vitesse avec les rapports cycliques =0.3 et =0.7
0 0.2 0.4 0.6 0.8 1 1.2 1.4 1.6 1.8 2
x 104
-1.5
-1
-0.5
0
0.5
1
1.5
2
2.5
3
3.5
4
Figure III- 32 : L'allure du courant d’induit avec (alpha = 0.7)
0 0.2 0.4 0.6 0.8 1 1.2 1.4 1.6 1.8 2
x 104
800
1000
1200
1400
1600
1800
2000
Figure III- 33 : L'allure de vitesse du MCC (tour/min) _ (alpha = 0.3)
La Vitesse environ 1358 tr/mn
0 0.2 0.4 0.6 0.8 1 1.2 1.4 1.6 1.8 2
x 104
1000
1500
2000
2500
3000
Figure III- 34 : L'allure de vitesse du MCC (tour/min) _ (alpha = 0.7)
La Vitesse environ 2800 tr/mn
CHAPITRE III : Implémentation et résultats
Commande d’un MCC via FPGA 55
5.3. Comparaison
Le tableau III- 2 représente une comparaison sur l’ondulation de courant d’induit Δia entre la carte
Altera Cyclone II et la carte DSPace 1104. Ces valeurs sont prises sur les courbes précédentes (Figure
III-26 & 27) (Figure III-31 & 32)
Ondulation de Courant d’induit Δia (A)
Alpha = 0.3 Alpha = 0.7
Altera Cyclone II 0.4 A 0.4 A
DSPace 1104 0.4 A 0.5 A
Tableau III- 2 : l’ondulation de courant d’induit Δia dans les 02 cartes
On observe que l’ondulation du courant d’induit est presque la même avec les deux cartes,
donc il n’y pas de différence pour la commande d’un MCC que ce soit par la carte Altera ou bien par
la carte DSPace.
Le tableau III- 3 représente une comparaison sur la vitesse de rotation Ω entre celle obtenue par la
carte Altera Cyclone II et celle obtenue par la carte DSPace 1104. Ces valeurs sont prises sur les