Matlab Simulink

École Polytechnique de Montréal
Département de Génie Mécanique
LABORATOIRES
MEC4540 - Mécatronique et Robotique
Laboratoire No.0 : Introduction à MATLAB et SIMULINK

Laboratoire No.1 : Électronique
Laboratoire No.2 : Échantillonnage
Laboratoire No.3 : Lévitation Magnétique
Laboratoire No.4 : Contrôle d’un système de Torsion
Laboratoire No.5 : Chariot
Responsable du cours: E.K. Boukas

< boukas@meca.polymtl.ca >
2
TABLE DES MATIÈRES 3
Table des matières
1 Introduction à Matlab et Simulink 9

1.1 But de ce laboratoire . . . . . . . . . . . . . . . . . . . . . . . 9
1.1.1 SIMULINK pour l’ingénieur mécanique . . . . . . . . 9
1.1.2 Des exemples? . . . . . . . . . . . . . . . . . . . . . . 9
1.2 Modélisation de systèmes sous SIMULINK . . . . . . . . . . . 10
1.2.1 Équation de la fusée . . . . . . . . . . . . . . . . . . . 10
1.2.2 Équation du contrôleur . . . . . . . . . . . . . . . . . 10
1.3 Modélisation du sous-système fusée . . . . . . . . . . . . . . . 11
1.4 Modélisation du sous-système contrôleur . . . . . . . . . . . . 13
1.5 Simulation de la fusée à 1 degré de liberté . . . . . . . . . . . 15
1.6 Analyse de système sous SIMULINK . . . . . . . . . . . . . . 16
1.7 Design de correcteurs sous MATLAB . . . . . . . . . . . . . . 17
1.8 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
2 Électronique 21
2.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.1.1 Amplificateur operationnel . . . . . . . . . . . . . . . . 21
2.1.2 Inverseur . . . . . . . . . . . . . . . . . . . . . . . . . 22
2.1.3 Suiveur . . . . . . . . . . . . . . . . . . . . . . . . . . 23
2.1.4 Sommateur . . . . . . . . . . . . . . . . . . . . . . . . 24
2.1.5 Soustracteur . . . . . . . . . . . . . . . . . . . . . . . 25
2.1.6 Comparateur . . . . . . . . . . . . . . . . . . . . . . . 26
2.2 But du laboratoire . . . . . . . . . . . . . . . . . . . . . . . . 26
2.3 Travail à faire . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
2.3.1 Travail théorique . . . . . . . . . . . . . . . . . . . . . 28
2.3.2 Travail pratique . . . . . . . . . . . . . . . . . . . . . . 30
2.4 Rapport . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
4 TABLE DES MATIÈRES
3 Échantillonnage 31
3.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
3.2 Partie théorique . . . . . . . . . . . . . . . . . . . . . . . . . . 31
3.3 Partie expérimentale . . . . . . . . . . . . . . . . . . . . . . . 37
3.4 Rapport . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
4 Lévitation magnétique 39
4.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
4.2 Étude du système en continu . . . . . . . . . . . . . . . . . . 40
4.2.1 Modélisation . . . . . . . . . . . . . . . . . . . . . . . 40
4.3 Étude du système en discret . . . . . . . . . . . . . . . . . . . 45
4.4 Programmation sous ECP Executive Programm . . . . . . . . 46
4.4.1 Section de définition . . . . . . . . . . . . . . . . . . . 46
4.4.2 Section d’initialisation des variables . . . . . . . . . . 46
4.4.3 Section du contrôleur . . . . . . . . . . . . . . . . . . . 47
4.5 Précautions d’emploi de la maquette . . . . . . . . . . . . . . 50
4.6 Rapport . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
5 Contrôle d’un système de torsion 51

5.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
5.2 But du laboratoire . . . . . . . . . . . . . . . . . . . . . . . . 51
5.3 Identification du système . . . . . . . . . . . . . . . . . . . . . 52
5.3.1 Équations du système . . . . . . . . . . . . . . . . . . 52
5.3.2 Identification de la fonction de transfert . . . . . . . . 54
5.4 Contrôleur PID . . . . . . . . . . . . . . . . . . . . . . . . . . 56
6 Chaîne linéaire de chariots 59

6.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
6.2 Présentation du système . . . . . . . . . . . . . . . . . . . . . 59
6.3 Contrôleur temps-réel . . . . . . . . . . . . . . . . . . . . . . 60
6.3.1 Input/Output Electronics . . . . . . . . . . . . . . . . 61
6.3.2 DSP Based Controller/Data Acquisition Board . . . . 61
6.4 Schéma du système en boucle ouverte et fermée . . . . . . . . 61
6.5 Modélisation . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
6.5.1 Équations caractéristiques . . . . . . . . . . . . . . . . 62
6.5.2 Modèle d’état . . . . . . . . . . . . . . . . . . . . . . . 62
6.5.3 Identification . . . . . . . . . . . . . . . . . . . . . . . 63
6.6 Conception d’un contrôleur par placement de pôles . . . . . . 64
6.7 Commande optimale . . . . . . . . . . . . . . . . . . . . . . . 65
6.7.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . 65
TABLE DES MATIÈRES 5
6.8 Rapport . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
A Contrôle par microcontrôleur 73

A.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
A.2 Description du microcontrôleur . . . . . . . . . . . . . . . . . 73
A.3 Description du montage . . . . . . . . . . . . . . . . . . . . . 74
A.4 Travail à faire . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
A.4.1 Avant le laboratoire . . . . . . . . . . . . . . . . . . . 75
A.4.2 Au laboratoire . . . . . . . . . . . . . . . . . . . . . . 75
A.5 Explication du programme . . . . . . . . . . . . . . . . . . . . 76
A.6 Exemple de programme . . . . . . . . . . . . . . . . . . . . . 78
6 TABLE DES MATIÈRES
TABLE DES FIGURES 7
Table des figures
1.1 Fenêtre MATLAB . . . . . . . . . . . . . . . . . . . . . . . . 11

1.2 Bouton Simulink . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.3 Navigateur Simulink . . . . . . . . . . . . . . . . . . . . . . . 12
1.4 Sous-système de la fusée . . . . . . . . . . . . . . . . . . . . . 12
1.5 Sous-système développé de la fusée . . . . . . . . . . . . . . . 14
1.6 Sous-système contrôleur-fusée . . . . . . . . . . . . . . . . . . 14
1.7 Contrôleur PID . . . . . . . . . . . . . . . . . . . . . . . . . . 15
1.8 Schéma complet . . . . . . . . . . . . . . . . . . . . . . . . . . 16
1.9 Système dynamique . . . . . . . . . . . . . . . . . . . . . . . 17
1.10 Outil SISO de conception . . . . . . . . . . . . . . . . . . . . 18
1.11 Outil SISO de conception . . . . . . . . . . . . . . . . . . . . 19
2.1 Schéma de représentation d’amplificateur opérationnel . . . . 22

2.2 Amplificateur inverseur . . . . . . . . . . . . . . . . . . . . . . 23
2.3 Amplificateur non inverseur . . . . . . . . . . . . . . . . . . . 24
2.4 Amplificateur sommateur . . . . . . . . . . . . . . . . . . . . 25
2.5 Amplificateur soustracteur . . . . . . . . . . . . . . . . . . . . 25
2.6 Amplificateur comparateur . . . . . . . . . . . . . . . . . . . . 27
2.7 Circuit de contrôle de l’allumage d’une LED en fonction de la
luminosité du laboratoire . . . . . . . . . . . . . . . . . . . . . 27
2.8 Circuit d’interface du détecteur de lumière . . . . . . . . . . . 28
2.9 Circuit soustrayant la tension de l’état sombre . . . . . . . . . 29
2.10 Circuit Comparateur . . . . . . . . . . . . . . . . . . . . . . . 29
2.11 Circuit complet . . . . . . . . . . . . . . . . . . . . . . . . . . 30
4.1 Système de lévitation magnétique . . . . . . . . . . . . . . . . 40

4.2 Modélisation des rondelles et des bobines . . . . . . . . . . . . 41
6.1 Photographie de la maquette . . . . . . . . . . . . . . . . . . 59

6.2 Photographie du système . . . . . . . . . . . . . . . . . . . . 60
8 TABLE DES FIGURES
6.3 Position des convertisseurs A/N et N/A . . . . . . . . . . . . 61

6.4 Système simplifié . . . . . . . . . . . . . . . . . . . . . . . . . 62
5 Représentation sous Matlab d’un modèle d’état en boucle ou-
verte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
6 Représentation sous Matlab d’un modèle d’état en boucle fermée 71
A.1 Montage pour le contrôle d’un moteur DC . . . . . . . . . . . 77

A.2 schéma de la boucle de contrôle . . . . . . . . . . . . . . . . . 77
A.3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
9
Chapitre 1
Introduction à Matlab et
Simulink
1.1 But de ce laboratoire

Ce laboratoire a pour but de familiariser l’étudiant avec l’utilisation du
logiciel MATLAB et SIMULINK dans un cadre appliqué aux systèmes dy-
namiques en général et à la mécatronique plus particulièrement.
1.1.1 SIMULINK pour l’ingénieur mécanique

Dans le cadre actuel, les techniques de modélisation et de simulation se
doivent de faire partie des connaissances de chaque ingénieur. Pour plusieurs
compagnies des domaines aussi variés que l’automobile et l’aéronautique, SI-
MULINK (ou autres outils de modélisation de systèmes comparables comme
MATRIXx et VTB) servent à la conception des futures générations de pro-
duits. Ce sont ces outils qui permettent aux entreprises de développer leur
produit plus rapidement et plus efficacement en évitant le processus coûteux
du prototypage physique. Les maquettes virtuelles permettent de valider,
d’appliquer puis de discriminer rapidement les concepts mis de l’avant.
1.1.2 Des exemples ?

Ford se sert de ces outils pour la simulation de ses nouveaux moteurs,
General Motors pour ses transmissions automobiles et ses véhicules hybrides
et Toyota et Nissan pour simuler l’interaction entre le conducteur, le véhicule
10 CHAPITRE 1. INTRODUCTION À MATLAB ET SIMULINK
et la route.
Embraer et Bombardier se servent également de ces logiciels pour simuler

la dynamique de leurs avions dans une vaste gamme de conditions atmosphé-
riques avant même la réalisation d’un premier prototype concret.
1.2 Modélisation de systèmes sous SIMULINK

À titre d’exemple et d’exercice, nous allons traiter ici d’un problème sim-
plifié (à l’extrême). Il s’agit d’une fusée à un seul degré de liberté. Ceci peut
être considéré comme une fusée placée sur un rail vertical sans frottement.
Le problème se simplifie à une masse accélérée par une force. Nous allons
construire le diagramme de ce système et le placer en boucle fermée pour le
contrôler à l’aide d’un correcteur PID.
1.2.1 Équation de la fusée

Pour trouver l’équation régissant le comportement de notre fusée à un
seul degré de liberté, nous commençons par l’équation de ce bon vieux New-
ton (comme toute bonne histoire de mécanique !).
X
F = ma
Dans notre cas simplissime,
P (t) + mg = ma(t)
où P(t) est la poussée du réacteur (en N) et où la masse de la fusée est

constante (on a un supercarburant top secret) à 10 tonnes (10 000 kg).
Pour obtenir l’altitude de notre fusée, il suffit donc de réorganiser le tout
et d’intégrer deux fois
P (t) + mg
ZZ
y(t) = dxdy
m
1.2.2 Équation du contrôleur

Du cours d’analyse et commande de systèmes dynamiques (MEC3300),
on devrait à tout le moins se rappeler la forme d’un PID. Sinon, il serait bon
1.3. MODÉLISATION DU SOUS-SYSTÈME FUSÉE 11
de consulter la page 136 du manuel Systèmes Asservis.
de(t)
Z
P (t) = kp e(t) + ki e(t) + kd
dt
où e(t) est la différence entre l’altitude désirée et l’altitude réelle (l’erreur

d’altitude).
1.3 Modélisation du sous-système fusée

Tout d’abord, il faut démarrer MATLAB. On obtient la fenêtre de la
figure (A.1).
Fig. 1.1 – Fenêtre MATLAB
Maintenant, en cliquant sur le bouton de SIMULINK représenté à la

figure (1.2), on obtient la fenêtre de la figure (A.2).
Fig. 1.2 – Bouton Simulink
On utilise la barre des outils pour créer un nouveau modèle vierge dont
l’extension sera du type (.mdl).
Ensuite, il faut ajouter un nouveau sous-système pour la fusée Simulink
Library Browser → Simulink → Subsystems → Subsystem (figure A.3).
Fig. 1.3 – Navigateur Simulink
Fig. 1.4 – Sous-système de la fusée

1.4. MODÉLISATION DU SOUS-SYSTÈME CONTRÔLEUR 13
Ce sous-système aura comme entrée la poussée et comme sortie l’altitude.

Les blocks dont vous aurez besoin sont les suivants :
Simulink Library Browser → Simulink → Sources → Constant (pour la masse)

Simulink Library Browser → Simulink → Math → Gain (pour la gravité)
Simulink Library Browser → Simulink → Math → Sum (somme des forces)
Simulink Library Browser → Simulink → Math → Product (pour la division)
Simulink Library Browser → Simulink → Continuous → Integrator (intégrateur)
Simulink Library Browser → Simulink → Sinks → Display (pour visualiser)
Il faut double-cliquer sur un icône pour changer ses paramètres (valeur

ou configuration). Pour le produit, entrer un number of inputs de "*/" pour
obtenir une division. Il serait aussi bon d’appliquer une borne inférieure à
l’altitude pour ne pas que notre fusée rentre dans le sol. Une fois terminé,
notre sous-système de fusée devrait ressembler à la figure (1.5).
1.4 Modélisation du sous-système contrôleur

Pour le contrôleur, il faut ajouter un nouveau sous-système au modèle
Simulink Library Browser → Simulink → Subsystems → Subsystem
Ce sous-système aura comme entrée l’erreur d’altitude et comme sortie

la poussée requise. Les blocks dont vous aurez besoin sont les suivants :
Simulink Library Browser → Simulink → Math → Gain (pour les gains)

Simulink Library Browser → Simulink → Math → Sum (somme des commandes)
Simulink Library Browser → Simulink → Continuous → Integrator (intégrateur)
Simulink Library Browser → Simulink → Continuous → Derivative (dérivateur)
Une fois le contrôleur terminé, nous devrions obtenir quelque chose de

similaire à ceci:
Fig. 1.5 – Sous-système développé de la fusée
Fig. 1.6 – Sous-système contrôleur-fusée

1.5. SIMULATION DE LA FUSÉE À 1 DEGRÉ DE LIBERTÉ 15
Fig. 1.7 – Contrôleur PID
Les gains suggérés pour le correcteur sont à titre indicatif.
1.5 Simulation de la fusée à 1 degré de liberté
Maintenant que nos deux sous-systèmes sont complets, nous pouvons les
relier pour simuler le comportement de notre fusée.
Il nous faudra utiliser ces blocks pour compléter le diagramme:
Simulink Library Browser → Simulink → Math → Sum (pour l’erreur)

Simulink Library Browser → Simulink → Sinks → Scope (pour l’altitude)
À vous maintenant de manipuler les gains du correcteur ou les propriétés

du système (ce n’est pas tous les jours que l’on peut changer la constante
gravitationnelle !!!).
Fig. 1.8 – Schéma complet
1.6 Analyse de système sous SIMULINK

Évidemment, la modélisation n’a d’utilité que si le système que l’on crée
peut être analysé et caractérisé par la suite. Une fois un modèle complété,
nous disposons aussi des outils qui nous permettent de faire ce travail d’ana-
lyse. Dans l’exemple précédent, nous avons utilisé un modèle simple et un
correcteur dont les constantes ont été fixées par essai et erreur. Dans le cas
de systèmes plus complexes, il est utile et même crucial de pouvoir connaître
le comportement de notre système dans certaines conditions.
Bien qu’un système extrêmement complexe ait pu être utilisé, nous nous
contenterons ici d’un système du deuxième ordre avec un zéro à l’origine.
Il nous faudra utiliser ces blocks pour compléter le diagramme:
Simulink Library Browser → Simulink → Continuous → Transfer Fcn

Simulink Library Browser → Control System Toolbox → Input Point (entrée)
Simulink Library Browser → Control System Toolbox → Output Point (sortie)
Pour l’analyse:
1. Modèle → Tools → Linear Analysis.

1.7. DESIGN DE CORRECTEURS SOUS MATLAB 17
Fig. 1.9 – Système dynamique
2. LTI Viewer → Simulink → Get Linearized Model.

3. Dans le menu contextuel, choisir le graphique désiré ("Plot type") ou
les caractéristiques recherchées ("Characteristics").
1.7 Design de correcteurs sous MATLAB

Une fois notre système caractérisé (dans le cas précédent, nous avions déjà
la fonction de transfert, mais généralement, c’est ce que nous chercherons à
trouver), nous voulons le contrôler en boucle fermée de façon à obtenir un
comportement précis. Reprenons notre modèle précédent et tâchons de le
contrôler pour obtenir ce que l’on désire.
Tout d’abord, il faut définir notre système sous MATLAB en créant une
nouvelle fonction de transfert.
G = tf([1], [1 1 1]);
Ensuite, nous démarrons l’utilitaire sisotool
sisotool
1. SISO Design Tool → File → Import

2. Import System Data → Import From → SISO Model → "G" → "→
G"
3. Import System Data → "Ok"
Fig. 1.10 – Outil SISO de conception
Imaginons maintenant que nous cherchons à obtenir les caractéristiques

suivantes de notre système une fois en boucle fermée:
Dépassement maximal de 5% → ζ = 0.707.
Temps de réponse de l’ordre de 3 secondes → τ = 1.0.
ce qui veut dire que nous cherchons à placer les pôles complexes en
−1.0 ± 1.0. Dans ce cas, il suffit d’insérer un zéro en −1.0 avec un gain
égal à 1.0. Le correcteur qui nous donne ceci est un PD avec kp = 1.0 et
1.7. DESIGN DE CORRECTEURS SOUS MATLAB 19
kd = 1.0.
Pour ajouter le zéro, allez dans :
– → Edit → Root Locus

– → Add Pole/zero → Real zero
– → pointer avec la main sur -1.
Fig. 1.11 – Outil SISO de conception

1.8 Conclusion
Nous avons présenté ici un survol des possibilités que proposent MAT-
LAB et SIMULINK dans le cadre de la conception, du design et de la simu-
lation de systèmes dynamiques. Ces outils sont utiles et leur utilisation lors
des laboratoires à venir est suggérée.
21
Chapitre 2
Électronique
2.1 Introduction
L’amplificateur opérationnel est une composante active très importante
en électronique. Notre objectif dans cette séance de laboratoire est de fami-
liariser les étudiants du cours mécatronique à un certain nombre de circuits
électroniques à base d’amplificateurs opérationnels et de certaines compo-
santes passives telles que les résistances et les capacités par exemple.
La séance de laboratoire est composée d’une partie théorique et d’une
partie pratique. La première partie a pour objectif de familiariser les étu-
diants avec les calculs des circuits à base d’amplificateurs opérationnels. La
seconde partie consiste à familiariser les étudiants à étudier un circuit élec-
tronique à base d’amplificateurs opérationnels.
2.1.1 Amplificateur operationnel

L’amplificateur opérationnel est un amplificateur électronique différentiel
à deux entrées, l’une dite inverseur V− et l’autre non inverseur V+ , et une
sortie. La représentation schématique souvent utilisée est illustrée à la figure
2.1.
En désignant par Avd le gain en tension différentiel et par Avmc le gain
en tension de mode commun, la tension de sortie est donnée par l’expression
suivante :

V+ + V−
Vs = Avd (V+ − V− ) + Avmc (2.1)
2
En pratique les gains Avd et Avmc dépendent de la fréquence. Dans ce
laboratoire, on va supposer que l’amplificateur opérationnel est idéal et dans
22 CHAPITRE 2. ÉLECTRONIQUE
PP
PP
PP
PP
PP
V− s
PP
PP
Zemc
s
PP
PP
PPP
P
Avd (V+ − V− ) Zs
s s sS
PP
Zed ∼ PP

s
V+ s Zemc

Fig. 2.1 – Schéma de représentation d’amplificateur opérationnel
ce cas les choses se simplifient et on a :

Remarque 2.1 – le gain en tension différentiel est infini, c’est-à-dire
Avd = ∞;
– le gain en tension de mode commun est nul, c’est-à-dire Avmc = 0;
– l’impédance d’entrée est infinie;
– l’impédance de sortie est faible, de l’ordre de quelques ohms.
Dans cette section, nous allons étudier un certain nombre de circuits
électroniques à base d’amplificateurs opérationnels. Parmi ces circuits, on
trouve l’inverseur, le sommateur, le comparateur, etc.
2.1.2 Inverseur
L’amplicateur inverseur est le montage de base à amplificateur opéra-
tionnel. Le schéma d’un tel circuit est illustrée à la figure 2.2.
En se référant à la figure 2.2 et en considérant le fait que l’amplificateur
opérationnel est parfait, on a :
V+ = V− (2.2)
D’un autre côté,
V e = R1 i (2.3)
et
Vs = −R2 i (2.4)
2.1. INTRODUCTION 23
R2
-i
R1 H
b -i s H
− HH
6 HH

s b
+ 6
Ve Vs

Fig. 2.2 – Amplificateur inverseur
En divisant ces deux dernières équations, on obtient :

Vs R2
Av = =− (2.5)
Ve R1
Ainsi, la tension de sortie de ce circuit inverseur est donnée par l’expres-
sion suivante :
R2
Vs = − Ve (2.6)
R1
Le gain du cicrcuit ne dépend que des résistances externes R1 et R2 . Pour
obtenir un grand gain on peut augmenter R2 et diminuer R1 . Mais le fait de
prendre une resistance R1 faible diminue l’impédance d’entrée, ce qui n’est
pas désirable. D’un autre côté, le choix de R2 grand (de l’ordre de quelques
MegaOhms) cause des problèmes. Un compromis est alors à faire et on se
limitera à des résistances de quelques centaines d’Ohms.
2.1.3 Suiveur
Avant de parler de l’amplificateur suiveur, traitons l’amplificateur non-
inverseur. Le schéma électronique d’un tel circuit est illustré à la figure 2.3
où cette fois-ci la grandeur d’entrée est connectée à la borne non-inversante.
En se référant à cette figure et en considérant le fait que l’amplificateur est
idéal, on obtient :
Ve = V+ = V− (2.7)
D’un autre côté, on a :

R1
Ve = Vs (2.8)
R1 + R2
R2
R1 HH
s − HH
HH s b

+ 6
Vs
b

6
Ve
Remarque 2.2
Fig. 2.3 – Amplificateur non inverseur
Ce qui donne :
Vs R2
Av = =1+ (2.9)
Ve R1
Maintenant, le circuit suiveur est obtenu de l’amplificateur non-inverseur
en choisissant une resistante R1 infinie (très grande) et une résistante R2
nulle (faible valeur). Dans ce cas, on a :
Vs
Av = =1 (2.10)
Ve
2.1.4 Sommateur
Le schéma électronique d’un amplificateur sommateur à trois tensions,
Ve1 , Ve2 et Ve3 est illustré à la figure 2.4. L’emploi d’un amplificateur idéal
implique :
Ve1 = R1 i1 (2.11)
Ve2 = R2 i2 (2.12)
Ve3 = R3 i3 (2.13)
D’un autre côté, la loi des noeuds nous donne :
i = i1 + i2 + i3 (2.14)
Enfin, la tension de sortie, Vs est liée au courant i par la relation suivante :
Vs = −Ri (2.15)
2.1. INTRODUCTION 25
i R3
Ve3 b - 3
i R2 R
Ve2 b - 2 s-i
i R1 HH
Ve1 b - 1 s − HH
HH s b

+ 6
Vs

Fig. 2.4 – Amplificateur sommateur
En combinant maintenant ces relations, on obtient la relation suivante

entre la sortie Vs et les tensions d’entrées Ve1 , Ve2 et Ve3 :

R R R
Vs = − Ve1 + Ve2 + Ve3 (2.16)
R1 R2 R3
2.1.5 Soustracteur
Le schéma de base d’un amplificateur comparateur est illustré à la figure
2.5.
R4
-
R3 H
H
Ve2 b - s − HH
HH s b
R1
Ve1 b- + 6
Vs

R2
Fig. 2.5 – Amplificateur soustracteur

En effet, en considérant le fait que l’amplificateur est idéal on obtient :
V+ = V− (2.17)
R2
V+ = Ve1 (2.18)
R1 + R2
D’un autre côté, en utilisant le théorème de supperposition on obtient :
R3 R3
V− = Ve2 + Vs (2.19)
R3 + R4 R3 + R4
Compte tenu de ces dernières équations on obtient :
R4
1+ R3 R4
Vs = R1
Ve1 − Ve2 (2.20)
1+ R2
R3
En choisissant des résistances R1 , R2 , R3 et R4 qui satisfont la relation

suivante :
R2 R4
k= = (2.21)
R1 R3
on obtient :
Vs = k (Ve1 − Ve2 ) (2.22)
2.1.6 Comparateur
Le schéma de base d’un amplificateur comparateur est illustré à la figure
2.6.
Son fonctionnement est donné par les équations suivantes :
(
+Vsat , si Vref < Ve
Vs =
−Vsat , si Vref > Ve
où Vsat est la tension de saturation du comparateur.
2.2 But du laboratoire

Le but de ce laboratoire est de familiariser les étudiants avec les montages
électroniques à base d’amplificateurs opérationnels. La séance de laboratoire
est divisée en deux parties. La première partie est consacré au calcul théo-
rique et la seconde partie traite de l’expérimentation.
2.2. BUT DU LABORATOIRE 27
H
H
b + HH
6 HH b

Ve b − 6
Vs
Vref 6
Fig. 2.6 – Amplificateur comparateur
Le circuit étudié dans ce laboratoire est composé de trois circuits de base

montés en série pour accomplir la tâche pour laquelle le circuit est conçu.
En fait, notre circuit va être conçu pour allumer une LED en fonction de
l’intensité de la lumière du laboratoire qui va être détectée par une cellule
détectrice de luminosité. Le schéma complet de ce circuit est illustré à la
figure 2.7. Les calculs des différentes composantes de ce circuit vont être éla-
borés dans la partie théorique.
- display
9V +9V
+9V
6
AA 6
r
RF
R1 A R4 R7
AAU R3 = 2kΩ
r H r H
− HH r Vb0 r r H + HH Vbcomp
+
− HH r b −
RT R2 = 1kΩ + V1
R5
R6

LEDA *

Amplificateur # 2 A
Amplificateur # 1 and offset substractor
Comparateur
Fig. 2.7 – Circuit de contrôle de l’allumage d’une LED en fonction de la

luminosité du laboratoire
2.3 Travail à faire

2.3.1 Travail théorique
L’objectif dans cette partie est de calculer les différents composants de
notre circuit de détection de la lumière.
Circuit d’interface du détecteur de lumière
Le détecteur de lumière est caractérisé par une résistance RT dont la valeur

varie en sens opposé de la variation de la lumière. Plus la lumière est intense,
plus la résistance de ce capteur est faible. La courbe caractéristique d’un tel
composant est illustrée à la figure 2.8. Une résistance de 1KΩ a été ajoutée
en série de RT pour éviter qu’un grand courant ne circule dans la résistance
RT quand la luminosité augmente.
– Calculer la tension de sortie Vo en fonction de la tension Vcc et des
résistances R1 , RT et RF ;
– La résistance RF est calculée en utilisant le fait que la variation de
tension de sortie de ce circuit doit varier de 2.5V lorsqu’on passe du
sombre à éclairé. On suppose que RT = 1KΩ quand le laboratoire est
éclairé et RT = 10KΩ quand le laboratoire est sombre.−V0
V0 Light 6
AA RF 6
A
AAU 2.5V
r
R1 = 1kΩ H ?
V0 Dark
− HH r Vb0
+

s
Vcc = 9V RT Intensity
-
RT (kΩ)
10 1
Fig. 2.8 – Circuit d’interface du détecteur de lumière
Circuit soustracteur et amplificateur
Étant donné que la tension de sortie Vo n’est pas nulle lorsque le laboratoire
est sombre, le circuit de la figure 2.9 est utilisé pour soustraire la tension Vo
correspondante à l’état sombre du laboratoire. En plus de cette fonction, le
circuit permet un gain de 2.
– Calculer la valeur de la résistance R4 pour assurer une tension à la
2.3. TRAVAIL À FAIRE 29
9V
6 Vdisplay
6
R3 = 2kΩ 5V
R4
b r r H
− HH b 0V s - Intensity
R2 = 1kΩ + V1

RT (kΩ)
10 1
Fig. 2.9 – Circuit soustrayant la tension de l’état sombre
sortie de ce circuit lorsque la tension d’entrée est la tension correspon-

dante à l’état sombre du laboratoire.
La valeur calculée va alors permettre à la sortie de varier entre 0V et 5V .

Circuit comparateur
Le rôle de ce circuit comparateur est d’allumer et de fermer la LED. Le

schéma électronique de ce circuit comparateur est illustré à la figure 2.10.
+9V
R7
Vcc = 9V
2V r vp H
+ HH Vbcomp
b
Vdisplay vn −

−Vcc = −9V R5
R6

LEDA *

A
Fig. 2.10 – Circuit Comparateur
– Calculer la valeur de la résistance R5 qui assure que le courant passant

dans la LED lorsqu’elle est allumée est de l’ordre de 20mA.
– Trouver les valeurs de R6 et R7 lorsque le diviseur de tension assure

une tension de 2V à partir de 9V .
2.3.2 Travail pratique

Dans cette partie, on vous demande de réaliser le circuit électronique de
la figure 2.11 en utilisant les valeurs indiquées.
- display
9V +9V
+9V
6
AA 6
r
RF ?
= 1kΩ
R1 = 1kΩ A R4 = 50kΩ R7
AAU - R3 = 2kΩ
+9V +9V
r H
− HH r Vb0
+9V r2VH
r r H + HH Vbcomp
+
− HH r b −
RT R2 = 1kΩ +
−9V V1 -9V R5
-9V
R6
Stage 1 Stage 2

LEDA *

A
Stage 3
Fig. 2.11 – Circuit complet
– monter les composantes électroniques du circuit de la figure 2.11;

– remplir le tableau suivant :
Détecteur laboratoire éclairé laboratoire sombre

Résistance en (KΩ)
2.4 Rapport
Le rapport doit contenir la partie théorique et la partie pratique de la
séance du laboratoire. Tous les calculs doivent y figurer et tous les détails
bien exposés.
Les étudiants peuvent utiliser le traitement de texte de leur choix mais
doivent impérativement bien soigner la présentation.
31
Chapitre 3
Échantillonnage
3.1 Introduction
Avec la réduction des coûts des ordinateurs, le traitement numérique qui
était autrefois limité est devenu une solution accessible à tous. En automa-
tique par exemple, l’utilisation des microprocesseurs pour le calcul des lois
de commande a remplacé la solution analogique basée sur l’électronique qui a
longtemps dominée la discipline. La solution numérique a plusieurs avantages
comparée à la solution analogique. Ainsi, si un jour on découvre un nouvel
algorithme performant, il suffit tout simplement d’écrire le programme cor-
respondant en utilisant le langage de programmation de notre choix. Après
compilation, le code exécutable obtenu peut être utilisé à la place du pré-
cédent sans changement majeur. Par contre en analogique, on doit changer
toute la carte électronique par une nouvelle qui doit être concue de manière
à accomplir la tâche du nouvel algorithme de commande.
Notre objectif dans ce laboratoire est de vous montrer les points béné-
fiques du traitement numérique et de vous montrer à travers un exemple
les conditions qu’il faut respecter lors des manipulations des systèmes de
commande.
Matlab et Simulink sont utilisés lors de cette séance pour faire les calculs.
Il faut noter que tout autre logiciel peut aussi être utilisé.
3.2 Partie théorique

En pratique, presque tous les signaux sont sous forme analogique et pour
les traiter par ordinateur on doit les convertir en échantillons, c’est-à-dire les
échantillonner.
32 CHAPITRE 3. ÉCHANTILLONNAGE
Le processus d’échantillonnage d’un signal quelconque consiste à rempla-

cer celui-ci par une suite de ses valeurs prises à des instants bien définis.
Le passage de la forme analogique à la forme numérique ou digitale ne
se fait pas n’importe comment et on doit en tout temps respecter certaines
conditions particulières qui guarantissent que le signal numérique ou digital
obtenu par le processus d’échantillonnage préserve les informations perti-
nentes du signal original.
Le théorème de Shannon donne de telles conditions et son énoncé est le
suivant :
Théorème 3.1 Un signal analogique y(t) dont la transformée de Fourier
est nulle à l’extérieur de l’intervalle [−ω0 ,ω0 ] est parfaitement défini par ses
valeurs échantillonnées {y(kT )} si la pulsation d’échantillonnage satisfait
l’inégalité:
ωe > 2ω0 (3.1)
où ωe = 2πf = 2π 1
T est la pulsation d’échantillonnage; T et f = T étant
respectivement la période d’échantillonnage et la fréquence d’échantillonnage.
La relation fournissant y(t) est alors donnée par:
sin we (t−kT )
∞
X
2
y(t) = y(kT ) we (t−kT )
(3.2)
k=∞ 2
Mathématiquement, l’échantillonnage parfait peut être représenté par la

séquence d’impulsions unitaires modulées par la fonction y(t) aux instants
d’échantillonnage t = T,2T, . . . kT . En dénotant par δ(t) l’impulsion unitaire
à t = 0 on a:
∞
X
?
y (t) = y(kT )δ(t − kT ) (3.3)
k=0
En utilisant la transformée de Laplace on a:

∞
X
Y ? (s) = y(kT )e−kT s (3.4)
k=0
À noter que l’on a utilisé le théorème du retard i.e : L [δ(t − kT )] = e−kT s .

Pour mener à bien les calculs des signaux numériques, on a introduit une
transformation qui est reférée dans la litérature comme étant la transforma-
tion en Z et dont la définition est donnée par:
3.2. PARTIE THÉORIQUE 33
Définition 3.1 La transformée en Z est définie à partir de l’expression de

la transformée de Laplace précédente en remplacant est par z (variable com-
plexe) et en écrivant Y ? (s) comme Y (z). Par conséquent la transformée en
Z est définie comme étant :
Y (z) = Z [Y ? (s)] = [Y ? (s)]z=est

∞
X
= y(kT )z −k (3.5)
k=0
Pour illustrer comment utiliser cette définition, essayons de voir comment

on calcul par exemple la transformée en calZ d’un signal en forme de rampe
unitaire, c’est-à-dire:
(
kT si k ≥ 0,
y(kT ) = (3.6)
0 autrement.
Ainsi, en appliquant la définition précédente on a:

∞
X
Y (z) = kT z −k = T z −1 + 2T z −2 + . . . + kT z −k + . . . (3.7)
k=0
ce qui donne:
Tz
Y (z) = (3.8)
z − 1)2
Les différentes propriétés de la transformée en Z sont résumées ci-dessous:
1. linéarité:
Z [a1 y1 (t) ± a2 y2 (t)] = a1 Y1 (z) ± a2 Y2 (z) (3.9)
2. translation dans le temps:
Z [y(t ± kT )] = z ±k Y (z) (3.10)
3. théorème de la valeur initiale:
lim y(t) = lim Y (z) (3.11)

t→0 z→∞
3. théorème de la valeur finale:

z−1
lim y(t) = lim Y (z) (3.12)
t→∞ z→1 z
En pratique, les spécifications des systèmes de commande sont données

dans le domaine analogique et on est souvent tenté de procéder par un design
dans le domaine continu au lieu du numérique puis convertir les résultats en
numérique en utilisant certaines techniques d’intégration très connues dans
le domaine.
Ces techniques sont:
– méthode # 1: méthode d’intégration rectangulaire arrière;
– méthode # 2: méthode d’intégration rectangulaire avant;
– méthode # 3: méthode d’intégration trapézoidale;
– méthode # 4: méthode de matching pôle/zéro.
Pour se fixer les idées sur ces méthodes, considérons l’exemple suivant et
essayons de voir comment ces méthodes s’appliquent. Soit :
a
G(s) = (3.13)
s+a
avec a une constante réelle donnée. On suppose que le système a une entrée
u(t) et une sortie y(t).
En se basant sur le concept de fonction de transfert, on peut écrire l’ex-
pression suivante:
sY (s) + aY (s) = aU (s). (3.14)
En utilisant maintenant la transformée de Laplace inverse et en considé-

rant que les conditions initiales sont nulles, on obtient:
dy(t)
+ ay(t) = au(t) (3.15)
dt
En choisissant une période déchantillonnage T qui satisfait la condition
du théorème de Shannon, on peut calculer les valeurs de la sortie y(t) aux
différents instants kT , k = 1,2, . . . en utilisant l’expression suivante:
Z KT
y(kT ) = y((k − 1)T ) + [−ay(t) + au(t)] dt (3.16)
(k−1)T
avec u(t) donnée.
Pour calculer cette intégrale, on peut utiliser plusieurs méthode. Parmi

ces méthodes on note les suivantes :
3.2. PARTIE THÉORIQUE 35
Méthode # 1 :
La première méthode que l’on peut utiliser est celle qui consiste à consi-
dérer que l’intégrant reste constant dans tout l’intervalle [(k − 1)T,kT ]
et prend la valeur à l’instant (k − 1)T . Compte tenu de ceci, on a:
y(kT ) = y((k − 1)T ) + T [−ay((k − 1)T ) + au((k − 1)T )](3.17)

,
avec y(0) donnée et k = 1,2,3, . . . , (3.18)
En utilisant maintenant les propriétés de la transformée en Z, on ob-

tient:
Y (z) a
G(z) = = z−1 (3.19)
U (z) T +a
En comparant les expressions de G(s) et de G(z) on conclut que l’ap-

proximation peut être obtenue en posant:
z−1
s= (3.20)
T
Méthode # 2 :
La seconde méthode que l’on peut utiliser est celle qui consiste à consi-
dérer que l’intégrant reste constant dans tout l’intervalle [(k − 1)T,kT ]
et prend la valeur à l’instant kT . Compte tenu de ceci, on a:
y(kT ) = y((k − 1)T ) + T [−ay(kT ) + au(kT )] ,k = 1,2,3, . . . , (3.21)
avec y(0) donnée.

tient:
Y (z) a
G(z) = = z−1 (3.22)
U (z) Tz+a

z−1
s= (3.23)
Tz
Méthode # 3 :
En se référant aux méthodes précédentes d’intégration, on peut remar-

quer que la première sous-estime l’intégrant, alors que la seconde le
sur-estime. Une autre alternative consiste à moyenner ces deux mé-
thodes. La troisième méthode que l’on peut utiliser consiste à considé-
rer que l’intégrant reste constant dans tout l’intervalle [(k − 1)T,kT ]
et prend la valeur moyenne des valeurs prises aux instants (k − 1)T et
kT . Compte tenu de ceci, on a:
T
y(kT ) = y((k − 1)T ) + [−ay((k − 1)T ) − ay(kT )
2
+au((k − 1)T ) + au(kT )] ,k = 1,2,3, . . . , (3.24)
avec y(0) donnée.

tient:
Y (z) a
G(z) = = 2 z−1 (3.25)
U (z) T z+1 +a

2 z−1
s= (3.26)
T z+1
Méthode # 4 :
La quatrième méthode que l’on peut utiliser pour obtenir une représen-
tation discrète est celle qui consiste à remplacer les pôles et les zéros du
plan-s en ceux du plan-z en utilisant la transformée en Z. Le gain de la
fonction de transfert G(z) est ensuite ajusté de manière à correspondre
au gain de la fonction G(s). Les règles suivantes sont à respecter pour
obtenir la fonction de transfert G(z):
– calculer tous les pôles, z, de G(z) en utilisant la relation suivante:
z = esT (3.27)
ainsi, si la fonction de transfert G(s) a un pôle à s = −a son

correspond dans G(z) est donné par z = e−aT .
– calculer tous les zéros, z, de G(z) en utilisant la relation suivante:
z = esT (3.28)
3.3. PARTIE EXPÉRIMENTALE 37
ainsi, si la focntion de transfert G(s) a un zéro à s = −a son

correspond dans G(z) est donné par z = e−aT .
– ajouter autant de termes (z + 1) au numérateur de G(z) que de
zéros de G(s) placés à l’infini pour obtenir le degré du numérateur
de G(z) égal à celui du dénominateur de G(z).
– ajuster le gain de G(z) en utilisant la relation suivante :
G(s)|s=0 = G(z)|z=1 (3.29)
Exemple :
Pour illustrer cette quatrième méthode, considérons la fonction de
transfert suivante :
50
G(s) (3.30)
(s + 5)(s + 10)
1
En choisissant T = 15 , on obtient :
– pôles: la fonction de transfert a deux pôles: −5 et −10 et ceux
de G(z) sont respectivement z1 = e−5T = 0.715 et z2 = e−10T =
0.513.
– zéros: la fonction de transfert G(s) a deux zéros à l’infini et par
conséquent G(z) a deux zéros à −1.
– l’expression de G(z) est alors donnée par:
(z + 1)2
G(z) = K (3.31)
(z − 0.715)(z − 0.513)
Le gain est obtenu par la relation suivante:
(s + 1)2

50
=K (3.32)
(s + 5)(s + 10) s=0 (z − 0.715)(z − 0.513) z=1
Ce qui donne K = 0.035.
3.3 Partie expérimentale

Dans cette partie on se propose d’étudier l’impact de la méthode de dis-
crétisation sur la précision et aussi de l’effet de la période d’échantillonnage
T sur la solution.
Pour cela, on vous demande de considérer le système dynamique dont la
fonction de transfert est donnée par l’expression suivante :
10
G(s) = (3.33)
(s + 1)(s + 2)(s + 5)
Pour ce système:
A. choisissez la période d’échantillonnage soit par calcul, soit par essai et

erreur;
B. Pour ce choix de T et pour une entrée en forme d’échelon unitaire, on

vous demande
1. d’utiliser la méthode # 1 pour obtenir la solution, y(kT );
5. de comparer les résultats des différentes méthodes et de se pro-
noncer sur la précsion de ces méthodes;
C. avec la même entrée en forme d’échelon unitaire, utilisez le théorème

de la valeur finale pour chaque méthode et comparez le résultat obtenu
avec avec celui trouvé par résolution. Conclure.
D. étudiez l’impact de la période d’échantillonnage sur la solution en fai-

sant référence au théorème de Shannon.
3.4 Rapport
séance du laboratoire. Tous les calculs et tous les détails doivent y être bien
exposés.
Vous pouvez utiliser le traitement de texte de votre choix mais la

présentation doit être très bien soignée . Des points sont consacrés à
la présentation.
39
Chapitre 4
Lévitation magnétique
4.1 Introduction
Les ingénieurs sont toujours attirés par les technologies économiques. Parmi
ces technologies, on retrouve la lévitation magnétique dont l’effet bénéfique
est sans égal pour nos futurs moyens de transport car elle permet d’éliminer
tout contact et par conséquent assurer une grande économie énergétique.
Au Japon par exemple, un métro a été conçu sur ce modèle. Le gros
avantage est le rendement énergétique d’une telle technique. En effet, le
métro "volant" au dessus de la voie ne perd pratiquement aucune énergie
par frottement. De plus, vu que le métro lévite, le confort des passagers est
assuré. Pour assurer cette lévitation, plusieurs problèmes doivent être
résolus, entre autres, il faut trouver le moyen de générer la force
magnétique nécessaire pour léviter le corps en question, le faire déplacer et
trouver le moyen de l’arrêter quand c’est nécessaire.
L’objectif de notre laboratoire est de vous familiariser avec cette
technologie qui est très utilisée dans le milieu industriel et principalement
vous mettre en contact avec les problèmes courants qu’un ingénieur doit
résoudre lors du design de ces systèmes.
Comme système sur lequel on va appliquer ces concepts, on a choisi le
montage développé par la compagnie Educational Control Products et qui
s’intitule Magnetic Levitation System.
Comme par le passé, notre séance de laboratoire est composée d’une
analyse théorique et d’une expérimentation sur le montage choisi. Notre
objectif est de concevoir le correcteur approprié pour répondre à un cahier
de charges donné. L’étude va être faite dans les domaines continu et discret.
40 CHAPITRE 4. LÉVITATION MAGNÉTIQUE
4.2 Étude du système en continu

4.2.1 Modélisation
Le système étudié dans cette séance de laboratoire est illustré à la figure
2.1.
Fig. 4.1 – Système de lévitation magnétique
Il est composé principalement de deux composantes essentielles qui sont la

rondelle et les bobines. La rondelle est aimantée en permanence par un
aimant permanent. Elle a deux faces, une face nord et une face sud. Cette
rondelle est constituée d’une partie en plastique autour de laquelle un
morceau de métal est collé. Le rôle des bobines est de créer le champ
magnétique nécessaire pour faire déplacer verticalement la rondelle. Le
champ en question est le résultat du courant que l’on contrôle dans les
deux bobines. Le mouvement de la rondelle est le résultat des interactions
du champ magnétique de la rondelle avec ceux des deux bobines. Il faut
noter que deux pôles (nord ou sud) de même nature s’attirent et lorsqu’ils
sont de nature opposée ils se repoussent.
Le champ magnétique créé par la bobine est donné par la formule de
Biot-Savard: −
→ →
−
→ µ I dl ∧ −r
dB = −
→ 3
(4.1)
4π r
4.2. ÉTUDE DU SYSTÈME EN CONTINU 41
−
→ −
→ → −
où d B , µ, I, dl , −
r,→
r , ∧ désignent respectivement le champ magnétique
élémentaire (en tesla), la perméabilité (en Henry/m), le courant appliqué
(en ampères), longueur élémentaire du fil (en m), vecteur entre le point de
→ −
− →
calcul de d B et dl (en m) et le produit vectoriel usuel.
En notant que les lignes de champ partent du pôle nord vers le pôle sud, il
en résulte que pour des questions de symétrie, le champ magnétique est
bien sûr l’axe de la bobine proche de celle-ci et est calculable en tout point
en connaissant la perméabilité (µ) et en intégrant sur tout le fil. Au fur et à
mesure qu’on s’éloigne de la bobine en hauteur, des composantes radiales
du champ magnétique apparaissent.
La lévitation de la rondelle est obtenue par l’interaction du champ
magnétique de celle-ci et celui créé par la ou les bobines, qui créent la force
nécessaire pour soulever la rondelle (voir Fig. 4.2).
Fig. 4.2 – Modélisation des rondelles et des bobines
La modélisation de notre système n’est pas chose facile du fait que le

modèle que l’on obtient est non linéaire de nature. Pour que l’on puisse
l’utiliser, on doit obligatoirement le linéariser autour d’une position
d’équilibre donnée. La position de 2 cm de la rondelle par rapport à la
bobine du bas est choisie dans ce laboratoire. Il faut noter que la fonction
de transfert que l’on va obtenir n’est valable que pour cette position et il en
est de même pour le correcteur choisi.
Étant donné que la modélisation mathématique du système est écartée
voyons maintenant comment on peut déterminer un modèle mathématique

à notre système par voie expérimentale. Comme on a décidé
précédemment, le point d’opération de notre système est choisi au voisinage
de la position 2cm de la rondelle du bas par rapport à la bobine du bas.
Il faut aussi noter que le capteur au laser de position a une valeur d’offset
que nous devons déterminer avant d’aller plus loin. Pour faire ceci,
démarrons notre système. La procédure du démarrage de notre système se
fait de la manière suivante:
– lancer le programme E2Usr32 ;
– allumer le générateur;
– aller dans File/Load Settings;
– charger la configuration default.cfg que vous trouverez dans
C:/Program Files/ECPSystems/MV;
– aller dans Setup/Setup Sensor Calibration;
– indiquer que vous voulez Calibrate Sensor et Apply Thermal
Compensation;
Question 4.2.1 Quelle est la valeur (en counts) du capteur 1 à 0cm et à

2cm?
Passons maintenant à la détermination de la fonction de transfert que l’on

doit attribuer à notre système au point d’opération choisi. En notant par
y1 (t) la position de la rondelle (valeur du capteur 1 en counts) et par u1 (t)
la commande (en counts), on estime que la fonction de transfert peut être
approximée par l’expression suivante:
Y1 (s) 1156(0.1s + 1)
G(s) = = 2 (4.2)
U1 (s) s + 7.82s + 289
Question 4.2.2 Programmer sous Simulink cette fonction de transfert (ne

pas oublier d’inclure l’offset du capteur dans votre schéma Simulink).
Question 4.2.3 Quelle doit être la commande u1 pour que la rondelle

lévite à 2cm? Faire un test avec Simulink.
Passons à la détermination expérimentale de la fonction de transfert que

l’on doit donner à notre système au voisinage de 2 cm. Pour cela, nous
allons écrire un petit algorithme afin de faire fonctionner le système en
boucle ouverte. Ceci peut être fait de la manière suivante:
– Sous E2Usr32, aller dans Setup/Control Algorithm;
4.2. ÉTUDE DU SYSTÈME EN CONTINU 43
– Cliquer sur Edit Algorithm et taper le texte suivant:

begin
control_effort1=cmd1_pos
end
Ce petit algorithme signifie que l’on appliquera directement la
commande cmd1_pos à l’entrée u1 (dans le cas du logiciel elle est
notée control_effort1 );
– Sauvegarder l’algorithme dans C:/Temp sous le nom de votre choix;
– Valider l’algorithme avec Implement Algorithm
– Aller dans Command/Trajectory 1, choisir Step et cliquer sur
Unidirectional Moves;
– Cliquer sur Setup;
– Le premier paramètre est la valeur du créneau par conséquent,
rentrer la valeur trouvée au cours de la question précédente 4.2.3;
– Le deuxième est la demi-période du créneau. On prendra 1000 (1s),
ce qui est largement suffisant pour atteindre une trajectoire stable;
– Le troisième est le nombre de périodes simulées. On prendra 1;
– Cliquer sur OK ;
– Aller ensuite dans Data/Setup Data Acquisition et ne garder
dans la fenêtre de gauche que Commanded Position 1, Sensor
Position 1 et Variable Q10 ;
– Valider ce choix;
– Pour simuler, aller dans Command/Execute;
– Aller dans Plotting/Setup Plot. Ne garder sur l’axe de gauche
que Commanded Position 1 et sur l’axe de droite sensor 1 Position;
– Afficher le résultat (plot data).
Question 4.2.4 Comparer les réponses obtenues. Au besoin, modifier les

paramètres de la fonction de transfert afin d’obtenir un meilleur résultat.
Passons maintenant à l’analyse en utilisant le modèle d’état. En notant par

x, u et y respectivement le vecteur d’état, le vecteur de commande et le
vecteur de sortie, le modèle d’état s’écrit:
ẋ = Ax + Bu

(4.3)
y = Cx + Du
avec A, B, C et D des matrices constantes données.

Notre objectif maintenant est de mettre notre modèle en forme de fonction

de transfert déterminé précédemment sous forme de modèle d’état. Pour
cela, on vous demande
poser y = y1 (t), x1 (t) = w(t), x2 (t) = ẇ(t) et
de
x1 (t)
u = u1 (t) (x = ).
x2 (t)
Aussi, pour parvenir, il faut noter que la fonction de transfert
(s) Y1 (s)
G(s) = N D(s) = U1 (s) , peut s’écrire de la manière suivante en introduisant
une variable intermédiare W (s):
Y1 (s) Y1 (s) W (s)

G(s) = = (4.4)
U1 (s) W (s) U (s)
Pour obtenir le modèle d’état on vous suggère de décomposer l’expression

de la fonction de transfert comme suit:
( W (s)
1
U (s) = D(s)
Y1 (s) (4.5)
W (s) = N (s)
Question 4.2.5 Écrire la fonction de transfert (4.2) sous forme de deux

équations différentielles et ainsi déterminer les matrices A, B, C et D.
Question 4.2.6 Faire une simulation sous Simulink et vérifier votre

résultat.
Passons maintenant au design du correcteur qui doit assurer les

spécifications du cahier des charges que le système en boucle fermée doit
satisfaire et qui se résume à:
– pas d’erreur en régime stationnaire;
– dépassement de 5%;
– temps de réponse de 0.05s à 5% .
Question 4.2.7 Quels sont les pôles de ce système?
Question 4.2.8 À partir de la fonction de transfert (4.2), quel est le type

de correcteur le plus approprié (PI ou PD) qui assure les spécifications
(4.2.1)? Donner une réponse qualitative et justifiez la après par le calcul.
Question 4.2.9 Calculer les paramètres de votre correcteur PI ou PD afin

de satisfaire les spécifications (utiliser la méthode des lieux des racines (voir
le livre de Boukas)).
Question 4.2.10 Faire une simulation sous Simulink.

4.3. ÉTUDE DU SYSTÈME EN DISCRET 45
Remarque 4.1 Pour la simulation et la validation de vos résultats sous

Simulink, il faut tenir compte de l’offset du capteur. C’est pourquoi on vous
conseille de soustraire cet offset à la commande et ensuite l’ajouter après la
boucle de retour.
D’une manière similaire, on vous demande de concevoir un correcter par

retour d’état de la forme u(t) = −Kx(t) (K = [K1 ,K2 ]. Le calcul de ce
correcteur peut se faire en égalisant les deux équations caractéristiques du
système, celle du système désirée obtenue à partir des spécifications et celle
de notre système en boucle fermée, c’est-à-dire: det [sI − A + BK].
Question 4.2.11 Concevoir le correcteur par retour d’état et simuler le

système en boucle fermée. Ce correcteur est-il capable de répondre aux
spécifications fixées? Si non, est-ce que vous pouvez dire comment vous
pouvez satisfaire toutes ces spécifications? Comment le correcteur par retour
d’état se compare-t-il à celui conçu en utilisant la fonction de transfert?
4.3 Étude du système en discret

Au cours de la section précédente, on a étudié le système en continu. Au
cours de cette section, nous allons nous attarder sur l’étude du même
système en discret. Pour cela, nous devrions commencer par discrétiser
notre modèle (fonction de transfert et modèle d’état).
En fixant la période d’échantillonnage à T = 0,001768, on vous demande de
déterminer:
1. la fonction de transfert G(z);
2. le modèle discret correspondant sous la forme suivante:

xk+1 = F xk + Guk
(4.6)
yk = Hxk + Duk

x1 (kT )
où xk = x((k + 1)T ) et xk =
x2 (kT )
– simuler les deux modèles comme vous l’avez fait précédemment et
comparer les résultats avec ceux obtenus dans le cas continu;
– concevoir les correcteurs qui répondent aux spécifications fixées pour
les deux modèles.
4.4 Programmation sous ECP Executive

Programm
La structure d’un algorithme sous ECP comprend trois parties:
– La section de définition.
– La section d’initialisation des variables.
– La section du contrôleur en temps réel.
La section du contrôleur commence toujours par begin et fini par end. On
notera que contrairement au C ou à un programme sous Matlab, il n’y a
pas de ; ou de : à la fin de chaque ligne de code. Le signe ; est réservé pour
les commentaires. La zone de commentaire s’étend de ; à la fin de la ligne.
4.4.1 Section de définition

ECP comprend 100 variables internes notées q1 à q100. Ce sont des
nombres flottants de 48 bits. La structure de définition est:
#def ine nom qi
Par exemple:
#def ine gain q1
assigne à la variable q1 le nom gain.
Il est important de noter que bien que ces variables sont internes, certaines
sont visibles. Ainsi q10, q11, q12 et q13 peuvent être récupérées et tracées.
On ajoute à ces 100 variables internes, 6 variables globales:
– cmd1_pos : consigne sur la position du palet 1.
– cmd2_pos : consigne sur la position du palet 2.
– sensor1_pos : position du palet 1 (vue d’en bas).
– sensor2_pos : position du palet 2 (vue d’en haut).
– control_effort1 : commande sur la bobine 1.
– control_effort2 : commande sur la bobine 2.
On peut utiliser ces variables directement sans passer par des variables
internes qi. Cependant toute manipulation de ces variables doivent se faire
par l’intermédiaire des variables internes.
4.4.2 Section d’initialisation des variables

Après avoir défini des noms pour les variables internes, on peut initialiser
ces variables. Ceci se fait avec:
nom=valeur initiale.
Par exemple:
4.4. PROGRAMMATION SOUS ECP EXECUTIVE PROGRAMM 47
#define gain q1
gain=0.2
On note que l’on a pas de signe de ponctuation à la fin de la ligne de code.
4.4.3 Section du contrôleur

Cette section commence toujours par begin et se termine toujours par end.
Cette section est exécutée toutes les périodes d’échantillonnage fixé par
Sample Period.
Énonçons tout d’abord l’ensemble des opérateurs utilisables.
Opérateur Arithmétique
Les quatre opérateurs standards (+, -, *, / ) sont compris par le

programme. On ajoute à celui-ci l’opérateur % signifiant modulo qui rend
le reste de la division des deux opérateurs. Par exemple, 15%6 donnera 3.
Fonctions
La syntaxe pour l’utilisation d’une fonction est:

nom_fonction(variable)
Les fonctions utilisables sont:
– sin : donne le sinus (∈ [−1,1]) d’un angle en radians.
– cos : donne le cosinus (∈ [−1,1]) d’un angle en radians.
– tan : donne la tangente (∈ [−1,1]) d’un angle en radians.
– asin : donne l’inverse du sinus (∈ [− π2 , π2 ]) d’un nombre ∈ [−1,1].
– acos : donne l’inverse du cosinus (∈ [− π2 , π2 ]) d’un nombre ∈ [−1,1].
– atan : donne l’inverse de la tangente (∈ [− π2 , π2 ]) d’un nombre ∈ <.
– ln : donne le logarithme naturel pour un nombre ∈ (0, + ∞).
– sqrt : donne la racine carrée (∈ (0, + ∞)) d’un nombre ∈ (0, + ∞).
– exp : donne l’exponentielle d’un nombre.
– abs : donne la valeur absolue (∈ (0, + ∞)) d’un nombre.
– int : donne la partie entière d’un nombre.
Opérateur d’assignation
L’opérateur d’assignation est =.

Opérateurs de comparaison
Nous avons 6 opérateurs de comparaison:
– = : égal à.
– != : pas égal à.
– > : plus grand que.
– !> : pas plus grand que, ou plus petit ou égal à.
– < : plus petit que.
– !< : pas plus petit que, ou plus grand ou égal à.
On note que les opérateurs <= et >= ne sont pas utilisés et remplacés
par !> et <!.
Opérateur de condition
La seule expression utilisable est:

if (condition)
endif
On peut y ajouter else pour donner une alternative si la condition n’est pas
validée.
Exemple d’un programme
Soit le programme suivant:

4.4. PROGRAMMATION SOUS ECP EXECUTIVE PROGRAMM 49
; Section de Définition
#define kpf q1
#define k1 q2
#define k2 q3
#define k3 q4
#define k4 q5
#define past_pos1 q6
#define past_pos2 q7
#define dead_band q8
; Section d’Initialisation des variables

past_pos1=0
past_pos2=0
kpf=0.93
k1=0.78
k2=3.14
k3=0.156
k4=7.58
dead_band=100
; Section du contrôleur
begin
if ((abs(sensor1_pos) !> dead_band)
k1=k1+0.5
else
k1=0.78
endif
control_effort1=kpf*cmd1_pos-k1*sensor1_pos-k3*sensor2_pos
-k3*(sensor1_pos-past_pos1)-k4*(enc2_pos-past_pos2)
past_pos1=sensor1_pos
past_pos2=sensor2_pos
end
Ce programme définit un contrôleur. On remarque que puisqu’il est en

discret, des termes comme (sensor1_pos-past_pos1) sont en fait des
dérivées en continue (à un facteur près). Tout d’abord on choisi un k1
suivant que sensor1_pos se trouve dans ou à l’extérieur d’une zone morte,
dead_band. Ensuite on calcule la commande, control_effort1 et enfin on
garde en mémoire les positions des différents capteurs afin de calculer les
dérivées en discret.
4.5 Précautions d’emploi de la maquette

Étant donné qu’il faut beaucoup d’énergie pour faire léviter la rondelle, il
est fortement conseillé de ne pas laisser le système en lévitation plus de
deux minutes. En effet, les bobines chauffent trop et cela risque
d’endommager le système.
Afin que la rondelle puisse léviter, il faut que le pôle nord (face N de la
rondelle) soit sur le dessus.
4.6 Rapport
exposés.
On suggère que les étudiants utilisent le traitement de texte de leur choix
mais la présentation doit être très bien soignée . Des points sont
consacrés à la présentation.
51
Chapitre 5
Contrôle d’un système de

torsion
5.1 Introduction
Le problème de la commande d’un système à axe flexible est classique et
très présent en pratique. La robotique en est un bon exemple. En effet, en
pratique, il est bien souvent utile d’utiliser des tiges entre l’arbre de sortie
du moteur et l’outil. Ces tiges n’étant jamais complètement rigides,
introduisent des perturbations linéaires ou non. L’utilisation de la
robotique dans l’industrie a bien sûr augmenté la productivité mais a aussi
permis d’effectuer des tâches trop précises pour un homme. Si nous prenons
l’exemple d’un atelier de soudure dans une entreprise de cartes
électroniques, le robot devra être capable de souder en des points précis,
très rapidement. Peu de place est donnée à l’erreur quant à la position de la
soudure (Qu’adviendrait ma carte mère si un point de soudure se trouvait
sur le processeur?). Ce système, moteur + pince + appareillage de soudure,
peut être modélisé par la maquette de la page de garde. En effet le moteur
est en bas, la pince est représentée par le disque du milieu et l’appareillage
de soudure par le disque du haut, le tout relié par des tiges flexibles.
5.2 But du laboratoire

Le but de ce laboratoire est d’étudier la commande des systèmes flexibles
et en particulier identifier un tel système et concevoir un contrôleur
proportionnel intégral et dérivée PID afin d’asservir en position ce système.
Pour ce faire, l’étude se décompose en deux parties. Tout d’abord, nous
52 CHAPITRE 5. CONTRÔLE D’UN SYSTÈME DE TORSION
allons identifier ce système. Cette identification se fera en deux parties,

tout d’abord théoriquement à l’aide des équations de la mécanique et
ensuite par l’expérimentation à l’aide du logiciel intégré à la maquette,
ECP Executive Software, et du logiciel Matlab afin de vérifier les résultats.
Enfin, nous serons en mesure de concevoir un contrôleur PID satisfaisant à
des spécifications données ultérieurement.
5.3 Identification du système

5.3.1 Équations du système
Nous allons déterminer les équations régissant le système lorsque la roue
supérieure est bloquée. Cela nous donne le schéma suivant :
On note θ1 et θ2 les angles des deux roues libres par rapport à leur origine.
Les tiges entre les roues sont supposées être des ressorts parfaits de torsion
de coefficients k1 et k2 . Les roues sont caractérisées par leur inertie J1 et J2
et un coefficient de frottement visqueux, c1 et c2 . Enfin, on applique au
niveau du moteur, la roue 1, un couple moteur T (t). Toutes ces hypothèses
se résument au travers du schéma suivant :
Question 5.3.1 D’après cette modélisation quel est à votre avis l’ordre des
5.3. IDENTIFICATION DU SYSTÈME 53
θ1 (s) θ2 (s)
fonctions de transfert T (s) et T (s) ?
Afin d’étudier cette configuration, nous décomposons la modélisation en

deux sous-systèmes :
Question 5.3.2 Montrer que :
θ1 (s) J2 s2 + c2 s + (k1 + k2 )
=
T (s) J1 J2 s4 + (c1 J2 + J1 c2 )s3 + (J1 (k1 + k2 ) + J2 k1 + c1 c2 )s2 + (c1 (k1 + k2 ) + c2 k1 )s + k1 k2
θ2 (s) k1
=
T (s) J1 J2 s + (c1 J2 + J1 c2 )s + (J1 (k1 + k2 ) + J2 k1 + c1 c2 )s2 + (c1 (k1 + k2 ) + c2 k1 )s + k1 k2
4 3
Nous remarquons que ce système est compliqué à étudier car il est d’ordre
4. Nous allons le simplifier en étudiant cette fois-ci la configuration
suivante :
Cette configuration s’obtient en bloquant la deuxième et la troisième roues.

On garde le frottement visqueux c1.
Question 5.3.3 Quelle est la fonction de transfert de ce système? La

mettre sous sa forme normalisée.
Vous devriez obtenir une fonction de la forme :

θ(s) Kω 2
=
T (s) s2 + 2ζωn s + ω 2
Question 5.3.4 Quelle est la réponse en temporelle pour un échelon de

T (t) = 1 pour t > 0 en boucle ouverte?
On remarque que cette réponse temporelle est le produit d’une

exponentielle décroissante et d’un sinus.
Question 5.3.5 Faire un dessin de la réponse obtenue. Comment, à partir

de cette réponse, peut-on déterminer les coefficients K, ζ et ω ? Regarder en
√ πζ
2
particulier le premier dépassement D. Il devrait être égal à d = 100e 1−ζ .
5.3.2 Identification de la fonction de transfert

Préparation du matériel
– Positionner 2 masses sur la roue du bas.
– Bloquer la roue du haut et la roue du milieu.
– Allumer l’ordinateur et lancer le programme ECP Executive Program
en cliquant sur l’icône appropriée.
5.3. IDENTIFICATION DU SYSTÈME 55
– Allumer la plate-forme d’essai.

– Cliquer sur Command/Trajectory.
– Choisir Step.
– Cliquer sur Setup.
– Choisir Open Loop Step.
– Modifier Step Size(Volts) : 1, Dwell Time (msec) : 4000, Number of
reps : 1.
– Sortir en cliquant sur OK (2 fois).
– Cliquer sur Data/Setup Data Aquisition.
– Cliquer sur Encoder 2 Position et sur Delete Item.
– Faire de même avec Encoder 3 Position.
– Il ne doit rester que Command Position et Encoder 1 Position.
– Cliquer sur Setup/Control Algorithm
– Choisir Discrete Time et baisser τr à 0.000884.
– Cliquer sur Implement Algorithm.
– Sortir avec OK.
Expérimentation
On est prêt maintenant pour lancer une simulation. Ce que l’on souhaite
identifier est la trajectoire de θ1 (t). Pour ce faire, on procèdera comme suit :
– Entrer dans Plotting/Setup Plot.

– Cliquer sur Encoder 3 Position à gauche et Remove Item.
– Cliquer sur Encoder 1 Position et sur Add to Left Axis.
– Sortir par OK.
– Cliquer sur Command/Execute.
– Vérifier que l’on a bien Open Loop Step (si ce n’est pas le cas
recommencer depuis le début).
– La case Normal Data Sampling devrait être cochée.
– Si un problème se passe durant la simulation, ne pas hésiter à tout
arrêter avec la case Abort Control de la fenêtre principale.
– Lancer la simulation par Run.
– Une fois la simulation terminée, cliquer sur Ok.
– Pour visionner les résultats, retourner sur Plotting/Setup Plot/Plot
Data.
Question 5.3.6 Le résultat concorde-t-il à ce que vous pensiez?

On va maintenant enregistrer les résultats afin de les utiliser sous Matlab.

– Cliquer sur Data/Export Raw Data.
– Enregister votre fichier dans BO.m.
– Ouvrir le fichier BO.m à part.
– Modifier la première ligne en l’effaçant et en ajoutant juste avant le
crochet ( [ ), donneesBO=.
– Lancer Matlab et modifier le Directory Path afin de se mettre dans le
bon dossier.
Détermination des coefficients et validation par Matlab

La trajectoire de θ1 (t) est la troisième colonne de BO.m. Pour l’afficher
sous Matlab, on lance BO.m. Une multitude de données doivent apparaître.
Maintenant taper plot(donnesBO( :,2),donnesBO( :,3)). Imprimer la courbe.
Question 5.3.7 À partir des résultats obtenus par simulation, quelles sont
les valeurs retenues pour K, ζ et ω ?
Sur Simulink, faire le schéma de ce système et le simuler avec les

coefficients obtenus.
Question 5.3.8 Superposer les courbes obtenues par Simulink et par la

simulation. Est-ce la même chose? Modifier les coefficients pour
s’approcher au plus près.
Pour superposer les deux courbes, on peut procéder ainsi :

– Enregistrer les données Simulink dans un fichier (boîte To File). Les
paramètres à modifier sont la destination (ex : simulationBO) et le
nom de la variable (ex : simulBO).
– Dans ce cas, on lance le fichier simulation BO et on tape
plot(donnesBO( :,2),donnesBO( :,3),simulBO(1, :),simulBO(2, :)).
Question 5.3.9 A-t-on eu raison d’approximer ce système par un second

ordre? D’où viennent les différences?
5.4 Contrôleur PID

Nous allons maintenant boucler le système et introduire un correcteur PID.
On choisit un correcteur PID de la forme C(s) = kp + kd s + ksi . Pour ce
faire nous adoptons la méthode de Ziegler-Nichols. Cette méthode bien
5.4. CONTRÔLEUR PID 57
θref (t) +- m- - système

θ(t)
-
correcteur
−
6
qu’assez imprécise permet de concevoir un contrôleur PID très rapidement.

On procédera comme suit :
– Cliquer sur Command/Trajectory.
– Choisir Step.
– Cliquer sur Setup.
– Choisir Closed Loop Step.
– Modifier Step Size(Counts) : 300, Dwell Time (msec) : 4000, Number
of reps : 1,(on asservit le système à la valeur 300).
– Sortir en cliquant sur OK (2 fois).
– Cliquer sur Setup/Control Algorithm
– Choisir Continuous Time.
– Cliquer sur PID.
– Cliquer sur Setup Algorithm.
– Mettre les coefficients ki et kd à 0.
– Mettre kp à une valeur quelconque basse (par exemple 0.1).
– Cliquer sur Implement Algorithm.
– Sortir avec OK.
– Cliquer sur Command/Execute.
– Vérifier que l’on a bien Closed Loop Step (si ce n’est pas le cas
recommencer depuis le début).
– La case Normal Data Sampling devrait être cochée.
– Lancer la simulation par Run.
– Une fois la simulation terminée, cliquer sur Ok.
– Pour visionner les résultats, retourner sur Plotting/Setup Plot/Plot
Data.
Si vous voyez déjà apparaître des oscillations, abaisser le kp , si par contre le
système ne bouge pas, monter le. Ne pas oublier de cliquer sur Implement
Algorithm pour que le système prenne en compte vos modifications.
Dès l’apparition d’oscillations,

– Noter la valeur Km de kp.
– Relever la période T0 des oscillations.

– Régler enfin le correcteur avec

 kp = 0.6Km

2k
ki = T0p
 k = kp T0

d 8
– Vérifier que ce contrôleur fonctionne bien.

– Faire varier ces différents coefficients afin d’affiner le résultat.
Question 5.4.1 Quelles sont les valeurs retenues pour les paramètres du
correcteur? Expliquer l’influence de chacun de ceux-ci.
Question 5.4.2 Conclure sur l’utilité de ce laboratoire.
Note : comme par le passé, il est suggéré de rédiger votre rapport dans la
même ligne de pensée que les laboratoires précédents. On doit soigner la
présentation et présenter une analyse théorique et expérimentale et une
conclusion.
59
Chapitre 6
Chaîne linéaire de chariots
6.1 Introduction
Ce laboratoire traite de la modélisation et de la commande d’un système
multivariable. Dans une première partie, nous allons voir une brève
présentation du système. Cela nous amènera à proposer une modélisation
sous forme de modèle d’état. Par la suite, deux types de commande par
retour d’état seront étudiés: par placement de pôle, la plus classique mais
aussi la plus incertaine quand au résultat, et la commande optimale.
Il est important de bien comprendre les annexes avant de commencer.
6.2 Présentation du système

La photo (fig.6.1) présente le système de notre étude. Cette maquette est
Fig. 6.1 – Photographie de la maquette

60 CHAPITRE 6. CHAÎNE LINÉAIRE DE CHARIOTS
un produit de la compagnie Educational control Products. Il s’agit du

modèle 210, Rectilinear Control System. Pour plus de références voir le site
internet de l’entreprise: www.ecpsystems.com.
Il est composé de trois chariots reliés par des ressorts. Ce système est
actionné par un moteur en tête. De plus, on remarque la présence d’un
piston en bout de chaîne qui modélise un frottement fluide. Cependant
chaque chariot à déjà un frottement qui lui est propre dû aux frictions avec
leurs rails.
Enfin on note que différents capteurs de position permettre de connaître la
position de chacun des chariots.
6.3 Contrôleur temps-réel
Le contrôle en temps réel est une des particularités de cette maquette. Il

est vrai qu’il est possible de programmer en "temps réel" sous différents
systèmes d’exploitation tels que DOS ou Windows. Cependant bien souvent
les périodes d’échantillonnage ne sont pas précises. Afin de s’affranchir de
ce problème tout en conservant une interface amicale sous Windows, le
système est composé de différents sous-ensembles (voir photo fig.(6.2)).
Fig. 6.2 – Photographie du système

6.4. SCHÉMA DU SYSTÈME EN BOUCLE OUVERTE ET FERMÉE 61
6.3.1 Input/Output Electronics

Cette boîte contient l’amplificateur de puissance couplé à l’ordinateur par
une isolation galvanique optique. Ainsi cela nous permet une immunité aux
bruits externes.
6.3.2 DSP Based Controller/Data Acquisition Board

Cette carte située dans l’ordinateur permet l’execution du contrôle en
temps réel, la génération de trajectoires et l’acquisition de données. C’est
celle-ci qui gère le passage du discret au continu.
6.4 Schéma du système en boucle ouverte et

fermée
Comme nous l’avons dit, le logiciel permet de contrôler la maquette en
temps réelle aussi bien en discret qu’en continue. Cependant si l’on travaille
en continue, il faut prendre en compte les gains des convertisseurs
analogique/numérique (A/N) et numérique/analogique (N/A). Il est donc
important de bien distinguer deux cas de figure: la boucle ouverte et la
boucle fermée. En effet lorsque l’on travaille sur la boucle ouverte (dans la
phase d’identification, par exemple), nous n’avons pas besoin d’un
convertisseur N/A en entrée, ce qui n’est pas le cas pour la boucle fermée.
Afin de fixer les idées, on peut se référer à la figure (6.3).
(a) Boucle ouverte
(b) Boucle fermée
Fig. 6.3 – Position des convertisseurs A/N et N/A
Les valeurs de ces différents convertissseurs seront données par la suite.

6.5 Modélisation
6.5.1 Équations caractéristiques
Nous pouvons modéliser le système par la figure (6.4). Nous ne prendrons
Fig. 6.4 – Système simplifié
pas en compte le frottement fluide c, nous l’introduirons par la suite pour

modéliser une perturbation. Cependant chaque chariot a un coefficient
propre de frottement fluide faible. Nous les noterons ci .
Nous enlèverons le quatrième ressort k4 afin de simplifier le problème.
Ainsi, on obtient les équations suivantes:

 F (t) = m1 ẍ1 + c1 ẋ1 + (k1 + k2 )x1 − k2 x2
0 = m2 ẍ2 + c2 ẋ2 + (k2 + k3 )x2 − k2 x1 − k3 x3 (6.1)
0 = m3 ẍ3 + c3 ẋ3 + k3 x3 − k3 x2

6.5.2 Modèle d’état

A partir des équations (6.1), nous pouvons construire le modèle d’état:
ẋ = Ax + BF (t)
(6.2)
Y = Cx
avec:
 
0 1 0 0 0 0 0
 
− k1 +k2 −mc1 k2
0 0 0   m1 
 m1 1 m1   1
 0 0 0 1 0 0  0
A =  k2  ,B = 
 0 ,
 
− k2m+k c2 k3

 m2 0 2
3
−m 2 m2 0   
 0

0 0 0 0 1

 0
k3 k3 c3 0
0 0 m3 0 −m3
−m 3
6.5. MODÉLISATION 63
   
C1 0 0 0 0 0 x1
 0 C2 0 0 0 0   ẋ1 
   
0 0 C 0 0 0
3  et X =  x2 
  
C=
0
 0 0 C4 0 0 

 ẋ2 
 
0 0 0 0 C5 0   x3 
0 0 0 0 0 C6 ẋ3
Dans notre cas, tous les Ci = 1, c’est-à-dire que l’on mesure toutes les
sorties Xi . Par conséquent, Y sera de dimension 6. Cette simplification
nous évite de vérifier l’observabilité du système car à partir de Y , le vecteur
X, l’état, est parfaitement connu (et pour cause, Y = X). Cependant cela
n’est pas toujours le cas: par exemple, nous aurions pu avoir uniquement
C5 = 1 et les autres à 0. Dans ce cas, le problème est de savoir si à partir
de cette seule donnée, nous pouvons estimer le vecteur X afin de faire une
commande par retour d’état.
Question 6.5.1 Est-ce que nous aurions pu reconstruire X avec seulement
la valeur de x3 ? (voir les valeurs numériques pour A dans la partie
suivante)
6.5.3 Identification
L’identification de ce système est assez complexe. L’idée initiale est de
découpler les trois chariots et ainsi déterminer les paramètres
caractéristiques séparément. Cependant après plusieurs tests, on se rend
compte que les valeurs trouvées ne concordent plus avec la réalité lorsque le
système est couplé. Certaines caractéristiques sont cependant immuables.
La masse des chariots (mi ) et les raideurs (ki ) ne changeant pas, on
demeure imprécis sur les coefficients de frottements (ci ). Par conséquent, le
mieux est de déterminer, dans un premier temps, les masses, les raideurs et
une approximation des coefficients de frottement pour ensuite ajuster ces
mesures en couplant le tout.
Les valeurs numériques trouvées pour ce système sont:
m1 = 1.77 kg k1 = 350 N/m c1 = 20.1 N/(m/s)

m2 = 1.59 kg k2 = 1000 N/m c2 = 8.2 N/(m/s)
m3 = 1.59 kg k3 = 1000 N/m c3 = 8.2 N/(m/s)
De plus un gain de 2400000 est introduit au niveau de la sortie. Ceci est dû

aux capteurs de positions qui fonctionnent dans leurs unités (counts).
L’entrée, u est exprimée en volts.
Ceci nous donne:

   
0 1 0 0 0 0 0
−762.7 −4.6 565 0 0 0  1355900
   
 0 0 0 1 0 0   0 
A=  628.9
 et B =  
 0 −1257.9 −5.2 628.9 0 


 0  
 0 0 0 0 0 1   0 
0 0 628.9 0 −628.9 −12.6 0
Question 6.5.2 Quelles sont les valeurs propres du système? Le système

est-il stable?
Nous alllons imposer une commande en créneau d’amplitude 0.3 et de

période 2.4s.
Question 6.5.3 Faire une simulation sous Simulink
Question 6.5.4 Faire une expérimentation sur la maquette et comparer les

résultats
6.6 Conception d’un contrôleur par placement de

pôles
Avant toute chose, si l’on souhaite imposer des pôles à notre système, il
faut vérifier que cela est possible.
Question 6.6.1 Comment faire? Vérifier le.
Lire l’annexe 3.
1
Lorsque l’on boucle, on note la présence d’un gain de 110 au niveau du
comparateur. Nous prendrons donc maintenant B comme étant:
t
B = 0 12326 0 0 0 0
Nous cherchons à asservir la position de x3 à 3000. Pour cela, nous plaçons

les pôles à:−9.6 ± 43i, −24 ± 26i, −22 et −92.5.
Question 6.6.2 Quelle est la matrice K permettant d’obtenir ces pôles
(utiliser la fonction place de Matlab)? A quoi est alors égal kp .
Question 6.6.3 Faire une simulation sous Simulink.
Question 6.6.4 Si ça marche alors effectuer un test sur la maquette et

comparer les résultats.
6.7. COMMANDE OPTIMALE 65
Bien souvent, il est difficile de trouver quels sont les pôles permettant une
bonne réponse en boucle fermée. Si ceux-ci ont une partie réelle trop
négative, le système sera rapide mais la commande risque d’être trop forte.
Il faut savoir qu’il n’y a pas de méthode générale pour déterminer les pôles
efficacement surtout lorsque l’on en a 6. La prochaine méthode, la
commande optimale, permet de s’en sortir facilement.
6.7 Commande optimale

6.7.1 Introduction
La commande optimale permet de ne pas avoir à fixer des pôles à priori
sans trop savoir comment la commande se comporte. Le but recherché est
de minimiser une fonction de coût qui serait dépendante de l’erreur et de
l’intensité de la commande. Ainsi à un instant donné, t, on posera le coût:
j(X(t),u(t)) = X(t)t QX(t) + u(t)t Ru(t)
On notera que:
– X(t) est en fait l’erreur par rapport à la référence (plus on est proche
de la référence, moins cela nous coûte cher),
– X(t)t signifie la transposée de X(t),
– u(t)t = u(t) dans notre cas car on n’a qu’une seule commande,
– Q est une matrice de dimensions n × n et R de dimensions 1 × 1,
– j(X(t),u(t)) est toujours positif.
On cherche donc à minimiser ce coût sur tout le temps de la simulation. Ce
coût s’exprime alors:
+∞
Z
∗
J = min X(t)t QX(t) + u(t)t Ru(t)dt
0
On opte pour un retour d’état du type de l’annexe 3. Le but est alors de
déterminer la matrice K assurant le minimum de la fonction de coût
précédente. On montre que la solution pour K est alors donnée par
l’équation de Ricatti suivante:
6.8 Rapport
exposés.
On suggère que les étudiants utilisent le traitement de texte de leur choix

mais la présentation doit être très bien soignée . Des points sont
consacrés à la présentation.
6.8. RAPPORT 67
Annexe 1: Protocole pour la maquette

Remarques initiales IMPORTANTES
Le logiciel ECP est, comme son nom l’indique, américain suivant les
normes américaines (enfin anglaises). Par conséquent, les nombres réels
sont écrits différemment. Ainsi 2,5 sera écrit 2.5. Non seulement il faudra
vous y faire, mais aussi il faut l’indiquer au système d’exploitation. Pour
s’assurer que l’écriture décimale est bonne, il faut aller dans le Panneau de
configuration et dans les Options régionales. Dans la section Nombres, le
Symbole décimal doit être "." et non ",".
Il est important de toujours allumé le générateur avant l’exécution du
programme et l’éteindre après l’avoir fermé.
Après avoir lancé le programme ECP32, il faut généralement réinitialiser
les capteurs et le système. Pour ce faire, aller dans Utility et cliquer sur
Reset Controller et Zero Position. Faites cette manoeuvre (et en particulier
le Zero Position) après chaque simulation.
Implémenter un contôleur
Dans Setup-Control algorithm, vous avez la possibilité de rentrer plusieurs
types d’algorithmes. Celui que nous allons utiliser est State Feedback
(retour d’état). Pour rentrer les paramètres de K, cliquer sur Setup
algorithm.
Afin d’implémenter l’algorithme dans la machine, il faut absolument cliquer
sur Implement Algorithm avant de quitter la fenêtre Setup Control
Algorithm.
Visualisation des résultats et sauvegarde

Avant de commencer à simuler, il faut déterminer les résultats que vous
voulez voir ou exporter. Dans Data-Setup Data Acquisition, vous pouvez
choisir si vous voulez garder (à gauche) ou ne pas garder (à droite)
certaines des données. Après avoir exécuter une simulation, vous pouver
exporter les données (dans un .m pour Matlab, par exemple) grâce à
Data-Export Raw Data.
Pour l’affichage, le principe est le même. Il faut déterminer à l’avance ce
que vous voulez afficher dans Plotting-Setup Plot. Après avoir exécuter une
simulation, vous pouvez afficher les résultats avec Plotting-Plot Data.
Faites attention que vous n’avez droit d’afficher que 4 courbes; 2 auront leur
ordonnée à droite et 2 à gauche (les deux ne correspondent peut-être pas!).
Entrée une trajectoire et éxécuter

Dans Command-Trajectory, il vous est proposer plusieurs types de
commandes (sinusoïdales, rampe ...). Celle que nous allons utiliser est le
Step. Entrer les paramètres souhaités dans Setup. Enfin ne pas oublier de
préciser si la simulation est en boucle ouverte ou fermée.
Maintenant que tout est bon, vous pouvez cliquer sur Command-Execute
pour lancer une expérimentation.
6.8. RAPPORT 69
Annexe 2: Modèle d’état

Introduction
Le modèle d’état est une manière de voir le système autrement que par une
fonction de transfert. Parfois, on a besoin de commander plusieurs
paramètres à la fois. Par exemple, pour un satellite, on souhaitera le
positionner à un point précis de l’espace en trois dimensions.
Les états sont des quantités significatives du système. Il y en a une infinité
mais bien souvent le problème est de déterminer les bons. Si l’on considère
le système de lévitation magnétique, nous avons choisi deux états: la
position de la rondelle et sa vitesse. Cependant rien ne nous empêchait de
prendre comme état deux combinaisons linéaires non liées de la position et
de la vitesse.
Le but essentiel du modèle d’état est de générer une représentation simple
du système comparable à un système du premier ordre.
Représentation sous forme d’équations et graphique

Dans le cas des systèmes linéaires invariants dans le temps, le modèle
d’état s’écriera:
ẋ = Ax + Bu
(3)
y = Cx + Du
avec:
– A: n × n, matrice d’état,
– B: n × m, matrice de commande,
– C: l × n, matrice d’observation,
– D: l × m, matrice de transfert direct.
On note:
– x: vecteur d’état de dimension n,

– y: vecteur de sortie de dimension l,
– u: vecteur de commande de dimension m.
Généralement D = 0.
On représente ce système sous Matlab par la figure suivante :
Fig. 5 – Représentation sous Matlab d’un modèle d’état en boucle ouverte

6.8. RAPPORT 71
Annexe 3: Le retour d’état

Bouclage
Afin d’asservir le système en boucle fermée, on utilise un retour de gain K.
K est une matrice de dimension m × n. Dans notre cas m = 1. Nous
n’avons en effet qu’une seule commande.
Le système bouclé donne: On envoie en entrée une référence Ref . Cette
Fig. 6 – Représentation sous Matlab d’un modèle d’état en boucle fermée
référence est une référence pour l’état, x, et non pour la sortie, y.

On obtient alors u = Ref − Kx. Par conséquent la dimension de Ref
est la même que la dimension de Kx. Ceci nous donne:
ẋ = (A − BK)x + BRef (4)
Cette equation est du premier ordre. Il est vrai que c’est sous forme
matricielle mais les impératifs sont les mêmes. En effet dans le cas à une
dimension, on souhaite régler A − BK < 0. Dans le cas matriciel c’est la
même chose avec les valeurs propres de A − BK. Celles-ci doivent être à
partie réelle négative.
Comportement à l’infini
En régime permanent l’équation (4) donne:
0 = (A − BK)x + BRef
La matrice (A − BK) est inversible car ses valeurs propres ont au moins une
partie réelle non nulle. Donc en notant x∞ le régime permanent, on trouve:
x∞ = −(A − BK)−1 BRef (5)
Ce qui donne pour y∞ = −C(A − BK)−1 BRef .

À part dans le cas extrême où −C(A − BK)−1 B = 1 (avec les bonnes

dimensions pour les matrices!) , nous n’aurons jamais y∞ = Ref .
Le plus facile est alors de multiplier la référence par
kp = −(C(A − BK)−1 B)−1 avant le comparateur.
73
Annexe A
Contrôle en vitesse d’un

moteur par microcontrôleur
A.1 Introduction
Ce laboratoire a pour objectifs de permettre aux étudiants un premier
contact avec l’utilisation d’un microcontrôleur. Dans ce cas-ci, il s’agit de
contrôler en vitesse un petit moteur électrique à l’aide d’un microcontrôleur
Atmega163 dont le programme est écrit en langage assembleur. De nos
jours, de nombreuses applications utilisent des microcontrôleurs locaux qui
assument des tâches spécifiques. En effet, afin d’éviter de surcharger le
processeur principal, il est courant aujourd’hui de vouloir décentraliser le
contrôle d’une application en confiant à des microcontrôleurs locaux le soin
d’exécuter certaines tâches en parallèle avec d’autres microcontrôleurs. La
compréhension de la base du fonctionnement de ces microcontrôleurs est
d’une grande utilité pour l’ingénieur en mécatronique. Dans ce laboratoire,
l’étudiant va découvrir les différentes possibilités que peuvent offrir les
microcontrôleurs modernes et comment s’en servir pour bâtir une
application simple. Il devra comprendre les principes de base de
l’utilisation des différents registres afin de compléter un petit programme
écrit en assembleur qui lui permettra de contrôler en vitesse un petit
moteur électrique.
A.2 Description du microcontrôleur

Le microcontrôleur utilisé, le Atmega163, possède une architecture RISC ce
qui signigie qu’il possède un jeu d’instructions réduits bien que dans ce
74 ANNEXE A. CONTRÔLE PAR MICROCONTRÔLEUR
cas-ci, il en possède environ une centaine. Par ailleurs, ce type

d’architecture est à même de permettre une plus grande vitesse de
fonctionnement. Le Atmega163 est un microcontrôleur 8 bits et il possède
16K bytes de mémoire flash. C’est un type de mémoire programmable
électriquement en quelques secondes et qui peut s’effacer tout aussi
rapidement. Il possède aussi 512 bytes de mémoire EEPROM et 1024 bytes
de SRAM. Il possède une horloge interne fonctionnant à une fréquence de
3,69MHz mais il peut aussi fonctionner à partir d’un cristal externe
pouvant osciller jusqu’à 8MHz. Ils possèdent de nombreuses
caractéristiques très utile comme des sorties PWM, un convertisseur
analogique-numérique, trois minuteurs (timers) pour ne nommer que celles
que nous utiliserons. Pour plus de détails, vous pouvez consulter le
document complet, disponible sur internet, décrivant en détail toutes les
caractéristiques inhérentes au Atmega163. Ce document sera également
disponible lors de la séance de laboratoire.
A.3 Description du montage

Le montage (figure A.2) comprend la plaquette de développement Atmel
sur lequel on retrouve une série de boutons-poussoir et une série de LEDs.
Ceux-ci sont directement reliés aux ports du microcontrôleur. La plaquette
est également reliée au moteur par l’intermédiaire de deux circuits
analogiques. Afin de contrôler le moteur, nous devons pouvoir lui envoyer
un signal variable et faire des lectures sur son positionnement à intervalles
réguliers. Pour atteindre cet objectif, deux circuits sont montés entre le
microcontrôleur et le moteur. Le premier circuit consiste en un
amplificateur suiveur car le voltage maximum que peut produire le
microcontrôleur est de 5 volts et il ne pourrait assurément pas fournir le
courant nécessaire à la rotation du moteur. Le signal variable est produit
par une sortie fonctionnant en mode PWM tel que vu en classe. Par
ailleurs, l’autre circuit permet de déterminer la position autour de son axe
du moteur. En effet, celui-ci est relié à un potentiomètre rotatif. Lorsque le
moteur tourne, il fait tourner le potentiomètre. La lecture du voltage aux
bornes de celui-ci va ainsi varier entre 8.5 et 3.5 volts selon l’orientation du
moteur. L’installation d’un amplificateur opérationnel dans un circuit
soustracteur permet d’obtenir une sortie variant entre 0 et 5 volts, voltages
qui sont les limites que le microcontrôleur peut lire. La lecture des valeurs
de voltage aux bornes du potentiomètre sont fournies par l’entrée du
convertisseur analogique numérique.
A.4. TRAVAIL À FAIRE 75
Le schéma de la boucle de contrôle opérée par le microcontrôleur est

montré à la figure reff2.
En vérifiant la position, par l’intermédiaire du voltage lu aux bornes du
potentiomètre, à intervalle régulier, il sera possible de déterminer la vitesse
du moteur et ainsi de corriger la commande à envoyer au moteur.
L’algorithme de contrôle est constitué d’un simple correcteur proportionnel.
La commande envoyée au moteur sera transmise par le PWM en modulant
la fraction de la période du PWM à laquelle celui-ci envoie une sortie
logique à 1. La vitesse désirée pour la rotation du moteur pourra être
indiquée au microcontrôleur en se servant des boutons-poussoirs. Ceux-ci
permettront d’exécuter un choix entre une dizaine de valeurs
préprogrammées.
A.4 Travail à faire

A.4.1 Avant le laboratoire
Un court programme vous est fourni et vous devez l’étudier afin de bien le
comprendre. De plus, n’hésitez pas à consulter le document pdf sur le
Atmega163, en particulier les pages portant sur les timers et le
convertisseur analogique numérique ainsi que le jeu d’instructions. Cela va
vous permettre de vous familiariser avec le langage assembleur et le
microcontrôleur utilisé.
A.4.2 Au laboratoire
Le but du programme que vous devez compléter est de vous permettre de
contrôler la vitesse du moteur. Les boutons vont vous servir à déterminer la
vitesse que vous voulez indiquer au moteur et les LEDs vont vous permettre
de visualiser sommairement l’information que vous envoyez au moteur.
Votre tâche consiste donc à remplir les zones où se trouvent des points
d’interrogation (?) dans le programme que vous recevrez. Dans la plupart
des cas, il s’agit de mettre les bonnes valeurs dans les registres de contrôle
de 8 bits pour que les différents composants du microcontrôleur comme le
convertisseur fonctionne correctement. Les informations pour vous indiquer
comment remplir les endroits incomplets se trouvent en commentaires dans
le programme et vous devrez chercher les réponses dans le document pdf du
microcontrôleur. Voici un exemple: si je veux que le port A fonctionne en
mode écriture, dans le programme je devrai donc écrire PORTA = 0xFF.
PORTA est le registre qui me permet d’indiquer le mode (écriture ou
lecture) que je souhaite pour le port. L’écriture 0xFF représente une

écriture hexadécimale (0x) qui signifie de mettre un 1 à tous les bits de ce
registre. En binaire (0b), je pourrais écrire PORTA = 0b11111111. Vous
avez un exemple d’un programme complet également sur votre ordinateur.
Vous aurez également une petite fonction à écrire. Elle va vous permettre
de jouer avec quelques instructions parmi les plus courantes. Elle ne devrait
pas nécessiter plus de 15 lignes ou 15 commandes.
A.5 Explication du programme
La première partie du programme concerne l’initialisation et la déclaration

de nombreux registres. Beaucoup d’informations très importantes pour le
fonctionnement du programme sont fournies dans cette section et vous avez
donc de nombreux trous à compléter. La deuxième partie est la boucle
principale du programme. Le programme est en attente jusqu’à ce que
l’usager ait appuyé sur un bouton pour soit démarrer une séquence ou pour
effectuer un changement dans la vitesse désirée. Pour effectuer un
changement, l’usager appuie sur le bouton 1. Il appuie ensuite sur le
bouton 2 pour changer la vitesse désirée. Les LEDS vont afficher la vitesse
désirée automatiquement. À noter que les LEDs, tout comme les
boutons-poussoirs, fonctionne en logique inverse. C’est-à-dire qu’une LED
s’allume lorsqu’elle reçoit un 0 binaire et qu’un 0 est envoyé au
microcontrôleur lorsque vous appuyez sur un bouton. C’est cette section
que vous devrez écrire. C’est-à-dire que lorsque l’usager appuie sur un
bouton, il doit pouvoir changer la valeur contenue dans le registre Valeur
en appuyant sur le bouton 2 et procéder en boucle jusqu’à ce qu’il réappuie
sur le bouton 1 qui le renverra en attente de démarrage d’une séquence.
Lorsque l’usager démarre une séquence, il appuie sur le bouton 0 et le
programme va alors envoyer une commande au moteur et faire le contrôle
requis. Pour arrêter la séquence, l’usager appuie simplement sur le bouton
3 qui ramène le programme au début de la boucle principale. La dernière
section du programme représente les interruptions. Ce sont des séquences
qui sont appelées lorsque le microcontrôleur détecte des interruptions dans
son programme. Les deux qui seront permises dans le programme sont le
débordement du timer et la fin de la conversion analogique numérique.
A.5. EXPLICATION DU PROGRAMME 77
Fig. A.1 – Montage pour le contrôle d’un moteur DC
sélection de circuit
la vitesse soustracteur
boutons convertisseur
Plaquette Atmel et
microcontrôleur
poussoirs A/N
Potentiomètre
Processeur
Moteur DC
sortie
LEDs
PWM
Affichage de la vitesse choisie
Fig. A.2 – schéma de la boucle de contrôle

+12V
2kΩ
17kΩ
2kΩ
−
−
+3.5V +
+ sortie
7kΩ
2kΩ 2kΩ
−
Entrée
+
potentiomètre
Fig. A.3
A.6 Exemple de programme

Ce programme très court permet de contrôler l’affichage des lumières à un
carregour routier. À chaque ligne de code, tout ce qui suit un (;) est un
commentaire dans le programme.
;******************************************************
;Exemple 28 juillet 2004
;Laboratoire de Mécatronique MEC4540
;Écrit par Pierre-Yves Mailhot
;******************************************************
;Ce programme contrôle les lumières à un carrefour routier virtuel.
;Il contrôle l’allumage des lumières rouge, jaune et verte de ce
;carrefour. Le boulevard Taschereau croise le chemin St-Jean dans ce
;carrefour virtuel. Le boulevard Taschereau étant plus passant, la lumière
;verte sera allumée plus longtemps que pour le chemin St-Jean. En changeant
;la valeur des minuteurs (timers) et l’alimention des lumières, nous
;obtenons un contrôle de lumières routières virtuelles.
;carrefour.asm
.include"m163def.inc"
.def Temp =r16 ;Registre temporaire à plusieurs utilités
.def save =r17 ;Registre de sauvegarde pour interruptions
.def secon =r18 ;Registre pour connaître le nombre de secondes écoulées
A.6. EXEMPLE DE PROGRAMME 79
.org 0x00 ;Début du code, positionnement des sauts d’interruptions

rjmp RESET ;à cause de l’activation des interruptions
.org 0x0C
rjmp INTER ;lorsque l’interruption OutputCompareA s’enclenche,
;renvoi à la fonction INTER
RESET:
ldi Temp,high(RAMEND) ;Initialisation de la pile
out SPH,Temp
ldi Temp,low(RAMEND)
out SPL,Temp
ser Temp ;Mettre des 1 dans tous les bits du registre Temp
out DDRB,Temp ;Définition du port A en sortie
;Sur les 8 sorties du port A, 6 seront utilisées de la manière suivante:
; Sortie 0 (PA0) lumière verte pour Taschereau (dure 35 secondes)
; Sortie 1 (PA1) lumière jaune pour Taschereau (dure 5 secondes)
; Sortie 2 (PA2) lumière rouge pour Taschereau (dure 20 secondes)
; Sortie 4 (PA4) lumière verte pour St-Jean (dure 15 secondes)
; Sortie 5 (PA5) lumière jaune pour St-Jean (dure 5 secondes)
; Sortie 6 (PA6) lumière rouge pour St-Jean (dure 40 secondes)
;Initialement, la lumière est verte pour Taschereau et rouge pour St-Jean.
;Le circuit est en logique inverse donc il faut envoyer des 0 aux LEDS pour
;qu’elles s’allument.
ldi Temp,0xBE ;Écriture dans le registre Temp de la valeur correspondante aux
;lumières qui doivent être allumées
out PORTB,Temp ;Envoi de 0 aux lumières correspondantes
;séquence d’initialisation des interruptions
clr secon ;Mise à zéro du registre qui compte le nombre de secondes écoulées
ldi Temp,0x80
out SREG,Temp ;Rend actif les interruptions
ldi Temp,0x10
out TIMSK,Temp ;Rend actif le Timer/counter1 output compareA match interrupt
;L’interruption se produit à environ chaque seconde. En effet, le programme
;roule avec un crystal interne oscillant à 3,69MHz. Comme il y a un prescaler
;de 1024, le timer incrémente de 1 à chaque fois que le crystal a oscillé 1024 fois.
;En mettant la valeur hexadécimale 0E14, qui correspond à
;3363 dans le système décimal, le timer B provoque une interruption à chaque
;(1024*3604)/3690000=1.00013 seconde. Lorsque l’interruption se produit, le programme
;s’arrête et se dirige vers la séquence indiquée par le pointeur correspondant à
;l’interruption déclarée. Dans notre cas, nous avons rjmp INTER au début du programme
;et ce segment de code se situe en fin de programme.
;Au retour de l’interruption, le programme continue à l’endroit où il était avant
;l’interruption.
ldi Temp,0x0E ;Définition pour le timer/counter de sa valeur de comparaison A

out OCR1AH,Temp ;À chaque interruption il se sera écoulé une seconde
ldi Temp,0x14
out OCR1AL,Temp
clr Temp ;Mise à zéro du compteur 1
out TCNT1H,Temp
out TCNT1L,Temp
ldi Temp,0x0D ;Démarrer le compteur 1 avec prescaler de 1024 et reset au compare
out TCCR1B,Temp
ldi Temp,0x23 ;Mettre 35 dans Temp (nombre de secondes écoulées)
MAIN: ;Boucle principale

cp Temp,secon ;Avons-nous 35 secondes d’écoulées?
breq Tasch_jaune ;Si oui, il faut passer à Taschereau jaune
rjmp MAIN ;Si non, on tourne en rond
MAIN1:
breq St_Jean_vert ;Si oui, il faut passer à St-Jean vert
rjmp MAIN1 ;Si non, on tourne en rond
MAIN2:
breq St_Jean_jaune ;Si oui, il faut passer à St-Jean jaune
MAIN3:
breq Tasch_vert ;Si oui, il faut passer à Taschereau vert
Tasch_vert: ;Lumière verte pour Taschereau et rouge pour St-Jean
ldi Temp,0xBE ;Écriture des bonnes valeurs pour les lumières dans Temp
out PORTB,Temp ;Changement dans l’éclairage des lumières
clr secon ;Mise à zéro du registre de comptage des secondes
ldi Temp,0x23 ;Mettre la référence pour le comptage des secondes (35)
rjmp MAIN ;Retour au début de la boucle principale
Tasch_jaune: ;Lumière jaune pour Taschereau et rouge pour St-Jean
ldi Temp,0xBD ;Écriture des bonnes valeurs pour les lumières dans Temp
rjmp MAIN1 ;Retour au début de la boucle principale
St_Jean_vert: ;Lumière rouge pour Taschereau et verte pour St-Jean
ldi Temp,0xEB ;Écriture des bonnes valeurs pour les lumières dans Temp
ldi Temp,0x0F ;Mettre la référence pour le comptage des secondes (15)
St_Jean_jaune: ;Lumière rouge pour Taschereau et jaune pour St-Jean
ldi Temp,0xDB ;Écriture des bonnes valeurs pour les lumières dans Temp
INTER: ;Fonction d’interruption, elle efface la dernière
;touche connue
in save,SREG ;Préserver le registre de statut (Status Register)
inc secon ;Incrémentation du nombre de secondes écoulées
out SREG,save ;Retourner le registre de statut (Status Register)
reti ;Retour d’interruption

Matlab Simulink

Transféré par

Droits d'auteur :

Formats disponibles

Matlab Simulink

Transféré par

Informations du document

Description originale:

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Matlab Simulink

Transféré par

Droits d'auteur :

Formats disponibles

École Polytechnique de Montréal

Département de Génie Mécanique

Laboratoire No.0 : Introduction à MATLAB et SIMULINK

Responsable du cours: E.K. Boukas

Table des matières

1 Introduction à Matlab et Simulink 9

5 Contrôle d’un système de torsion 51

6 Chaîne linéaire de chariots 59

A Contrôle par microcontrôleur 73

Table des figures

1.1 Fenêtre MATLAB . . . . . . . . . . . . . . . . . . . . . . . . 11

2.1 Schéma de représentation d’amplificateur opérationnel . . . . 22

4.1 Système de lévitation magnétique . . . . . . . . . . . . . . . . 40

6.1 Photographie de la maquette . . . . . . . . . . . . . . . . . . 59

6.3 Position des convertisseurs A/N et N/A . . . . . . . . . . . . 61

A.1 Montage pour le contrôle d’un moteur DC . . . . . . . . . . . 77

1.1 But de ce laboratoire

1.1.1 SIMULINK pour l’ingénieur mécanique

1.1.2 Des exemples ?

Embraer et Bombardier se servent également de ces logiciels pour simuler

1.2 Modélisation de systèmes sous SIMULINK

1.2.1 Équation de la fusée

où P(t) est la poussée du réacteur (en N) et où la masse de la fusée est

1.2.2 Équation du contrôleur

de consulter la page 136 du manuel Systèmes Asservis.

où e(t) est la différence entre l’altitude désirée et l’altitude réelle (l’erreur

1.3 Modélisation du sous-système fusée

Fig. 1.1 – Fenêtre MATLAB

Maintenant, en cliquant sur le bouton de SIMULINK représenté à la

Fig. 1.2 – Bouton Simulink

Fig. 1.3 – Navigateur Simulink

Fig. 1.4 – Sous-système de la fusée

Ce sous-système aura comme entrée la poussée et comme sortie l’altitude.

Simulink Library Browser → Simulink → Sources → Constant (pour la masse)

Il faut double-cliquer sur un icône pour changer ses paramètres (valeur

1.4 Modélisation du sous-système contrôleur

Ce sous-système aura comme entrée l’erreur d’altitude et comme sortie

Simulink Library Browser → Simulink → Math → Gain (pour les gains)

Une fois le contrôleur terminé, nous devrions obtenir quelque chose de

Fig. 1.5 – Sous-système développé de la fusée

Fig. 1.6 – Sous-système contrôleur-fusée

Fig. 1.7 – Contrôleur PID

Les gains suggérés pour le correcteur sont à titre indicatif.

1.5 Simulation de la fusée à 1 degré de liberté

Simulink Library Browser → Simulink → Math → Sum (pour l’erreur)

À vous maintenant de manipuler les gains du correcteur ou les propriétés

Fig. 1.8 – Schéma complet

1.6 Analyse de système sous SIMULINK

Simulink Library Browser → Simulink → Continuous → Transfer Fcn

1. Modèle → Tools → Linear Analysis.

Fig. 1.9 – Système dynamique

2. LTI Viewer → Simulink → Get Linearized Model.

1.7 Design de correcteurs sous MATLAB

Ensuite, nous démarrons l’utilitaire sisotool

1. SISO Design Tool → File → Import

3. Import System Data → "Ok"

Fig. 1.10 – Outil SISO de conception

Imaginons maintenant que nous cherchons à obtenir les caractéristiques