summaryrefslogtreecommitdiff
path: root/docs/src/motion/pid_theory_fr.txt
blob: 48ef1f636f10c1db3029d031b422a59ece51d09d (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
:lang: fr
:toc:

= Réglages d'une boucle PID

[[cha:Regulation-PID]] (((Régulation à PID)))

== Régulation à PID

Un régulateur Proportionnel Intégral Dérivé (PID) est un organe de
contrôle qui permet d'effectuer une régulation en boucle fermée d'un
procédé.

Le régulateur compare une valeur mesurée sur le procédé avec une
valeur de consigne. La différence entre ces deux valeurs (le signal
d'_erreur_) est alors utilisée pour calculer une nouvelle valeur
d'entrée du procédé tendant à réduire au maximum l'écart entre la
mesure et la consigne (signal d'erreur le plus faible possible).

Contrairement aux algorithmes de régulation simples, le contrôle par
PID peut ajuster les sorties du procédé, en fonction de l'amplitude du
signal d'erreur, et en fonction du temps. Il donne des résultats plus
précis et un contrôle plus stable. (Il est montré mathématiquement
qu'une boucle PID donne un contrôle plus stable qu'un contrôle
proportionnel seul et qu'il est plus précis que ce dernier qui laissera
le procédé osciller).

=== Les bases du contrôle en boucle

Intuitivement, une boucle PID essaye d'automatiser ce que fait un
opérateur muni d'un multimètre et d'un potentiomètre de contrôle.
L'opérateur lit la mesure de sortie du procédé, affichée sur le
multimètre et utilise le bouton du potentiomètre pour ajuster l'entrée
du procédé (l'_action_) jusqu'à stabiliser la mesure de la sortie
souhaitée, affichée sur le multimètre.

Un boucle de régulation est composée de trois parties:

1. La mesure, effectuée par un capteur connecté à un procédé, par
exemple un codeur.

2. La décision, prise par les éléments du régulateur.

3. L'action sur le dispositif de sortie, par exemple: un moteur.

Quand le régulateur lit le capteur, il soustrait la valeur lue à la
valeur de la consigne et ainsi, obtient l'«erreur de mesure». Il peut
alors utiliser cette erreur pour calculer une correction à appliquer
sur la variable d'entrée du procédé (l'_action_) de sorte que cette
correction tende à supprimer l'erreur mesurée en sortie de procédé.

Dans une boucle PID, la correction à partir de l'erreur est calculée
de trois façons: P) l'erreur de mesure courante est soustraite
directement (effet proportionnel), I) l'erreur est intégrée pendant un
laps de temps (effet intégral), D) l'erreur est dérivée pendant un laps
de temps (effet dérivé).

Une régulation à PID peut être utilisée dans n'importe quel procédé
pour contrôler une variable mesurable, en manipulant d'autres variables
de ce procédé. Par exemple, elle peut être utilisée pour contrôler:
température, pression, débit, composition chimique, vitesse et autres
variables.

Dans certains systèmes de régulation, les régulateurs sont placés en
série ou en parallèle. Dans ces cas, le régulateur _maître_ produit les
signaux utilisés par les régulateurs _esclaves_. Une situation courante
dans le contrôle des moteurs, la régulation de vitesse, qui peut
demander que la vitesse du moteur soit contrôlée par un régulateur
_esclave_ (souvent intégré dans le variateur de fréquence du moteur)
recevant en entrée une valeur proportionnelle à la vitesse. Cette
entrée de l'_esclave_ est alors fournie par la sortie du régulateur
_maître_, lequel reçoit la variable de consigne.

=== Théorie

Le _PID_ représente les abréviations des trois actions qu'il utilise
pour effectuer ses corrections, ce sont des ajouts d'un signal à un
autre. Tous agissent sur la quantité régulée. Les actions aboutissent
finalement à des _soustractions_ de l'erreur de mesure, parce que le
signal proportionnel est habituellement négatif.

==== Action Proportionnelle

Pour cette action, l'erreur est multipliée par la constante P (pour
Proportionnel) qui est négative, puis ajoutée (soustraction de l'erreur
de mesure) à la quantité régulée. P est valide uniquement sur la bande
dans laquelle le signal de sortie du régulateur est proportionnel à
l'erreur du système. Noter que si l'erreur de mesure est égale à zéro,
la partie proportionnelle de la sortie du régulateur est également à
zéro.

==== Action Intégrale

L'action intégrale fait intervenir la notion de temps. Elle tire
profit du signal d'erreur passé qui est intégré (additionné) pendant un
laps de temps, puis multiplié par la constante I (négative) ce qui en
fait une moyenne, elle est enfin additionnée (soustraction de l'erreur
de mesure) à la quantité régulée. La moyenne de l'erreur de mesure
permet de trouver l'erreur moyenne entre la sortie du régulateur et la
valeur de la consigne. Un système seulement proportionnel oscille en
plus et en moins autour de la consigne du fait qu'en arrivant vers la
consigne, l'erreur est à zéro, il n'enlève alors plus rien est dépasse
la consigne, ou oscille et/ou se stabilise à une valeur trop basse ou
trop élevée. L'addition sur l'entrée d'une proportion négative
(soustraction) de l'erreur de mesure moyennée, permet toujours de
réduire l'écart moyen entre la mesure en sortie et la consigne. Donc
finalement, une boucle PI bien réglée verra sa sortie redescendre
lentement à la valeur de la consigne.

==== Action Dérivée

L'action dérivée utilise aussi la notion de temps. Elle cherche à
anticiper l'erreur future. La dérivée première (la pente de l'erreur)
est calculée pour un laps de temps et multipliée par la constante
(négative) D, puis elle est additionnée (soustraction de l'erreur de
mesure) à la quantité régulée. L'action dérivée de la régulation fourni
une réponse aux perturbations agissant sur le système. Plus important
est le terme dérivé, plus rapide sera la réponse en sortie à une
perturbation sur l'entrée.

Plus techniquement, une boucle PID peut être caractérisée comme un
filtre appliqué sur un système complexe d'un domaine fréquentiel. C'est
utilisé pour calculer si le système atteindra une valeur stable. Si les
valeurs sont choisies incorrectement, le procédé entrera en oscillation
et sa sortie n'atteindra jamais la consigne.

=== Réglage d'une boucle

Régler une boucle de régulation consiste à agir sur les paramètres des
différentes actions (gain du proportionnel, gain de l'intégral, gain de
la dérivée) sur des valeurs optimales pour obtenir la réponse désirée
sur la sortie du procédé. Le comportement des procédés varient selon
les applications lors d'un changement de consigne. Certains procédés ne
permettent aucun dépassement de la consigne. D'autres doivent minimiser
l'énergie nécessaire pour atteindre un nouveau point de consigne.
Généralement la stabilité de la réponse est requise, le procédé ne doit
pas osciller quels que soient les conditions du procédé et le point de
consigne.

Régler une boucle est rendu plus compliqué si le temps de réponse du
procédé est long; il peut prendre plusieurs minutes, voir plusieurs
heures pour qu'une modification de consigne produise un effet stable.
Certains procédés ne sont pas linéaires et les paramètres qui
fonctionnent bien à pleine charge ne marchent plus lors du démarrage
hors charge du procédé. Cette section décrit quelques méthodes
manuelles traditionnelles pour régler ces boucles.

Il existe plusieurs méthodes pour régler une boucle PID. Le choix de
la méthode dépendra en grande partie de la possibilité ou non de mettre
la boucle «hors production» pour la mise au point ainsi que de la
vitesse de réponse du système. Si le système peut être mis hors
production, la meilleure méthode de réglage consiste souvent à
soumettre le système à un changement de consigne, à mesurer la réponse
en fonction du temps et à l'aide de cette réponse à déterminer les
paramètres de la régulation.

==== Méthode simple

Si le système doit rester en production, une méthode de réglage
consiste à mettre les valeurs I et D à  zéro. Augmenter ensuite le gain
P jusqu'à ce que la sortie de la boucle oscille. Puis, augmenter le
gain I jusqu'à ce que cesse l'oscillation. Enfin, augmenter le gain D
jusqu'à  ce que la boucle soit suffisamment rapide pour atteindre
rapidement sa consigne. Le réglage d'une boucle PID rapide provoque
habituellement un léger dépassement de consigne pour avoir une montée
plus rapide, mais certains systèmes ne le permettent pas.

[width="90%", options="header"]
|==========================================================
|Paramètre | Temps de montée | Dépassement | Temps de réglage | S.S. Error
|P         | Augmente        | Augmente    | Chang. faible    | Diminue
|I         | Diminue         | Augmente    | Augmente         | Eliminate
|D         | Chang. faible   | Diminue     | Diminue          | Chang. faible
|==========================================================

Effets de l'augmentation des paramètres

==== Méthode de Ziegler-Nichols

Une autre méthode de réglage est la méthode dite de "Ziegler-Nichols",
introduite par John G. Ziegler et Nathaniel B. Nichols. Elle commence
comme la méthode précédente: réglage des gains I et D à zéro et
accroissement du gain P jusqu'à ce que la sortie du procédé commence à
osciller. Noter alors le gain critique (K~c~) et la période d'oscillation 
de la sortie (P~c~). Ajuster alors
les termes P, I et D de la boucle comme sur la table ci-dessous:

[width="90%", options="header"]
|====================================================================
|Type de régulation | P           | I        | D
|P                  | .5K~c~      |          | 
|PI                 | .45K~c~     | P~c~/1.2 | 
|PID                | .6K~c~      | P~c~/2   | P~c~/8
|====================================================================