COMPTE RENDU DU TP MOTEUR CC ARDUINO

COMMANDE D'UN SYSTEME EMBARQUE:

PROGRAMMATION DE CORRECTEURS SUR UNE CARTE
ARDUINO

Réalisé par NGUEGUIM TSAFACK AURIOL & OUATTARA IDRISS & RANNOU ELLIOTT

Table des matières

COMPTE RENDU DU TP MOTEUR CC ARDUINO ............................................................. 0
I. INTRODUCTION ET CONTEXTE .............................................................................. 1
II. PREPARATION ............................................................................................................ 1
1. Modélisation ............................................................................................................ 1
2. Etude de la stabilité, commandabilite et observabilité............................................. 2
III. CARACTERISTIQUE DU ACD0 ET DU DAC0 ...................................................... 3
IV. CORRECTEUR PROPORTIONNEL ......................................................................... 3
V. COMMANDE AVEC OBSERVATEUR ...................................................................... 5
1. Analyse théorique .................................................................................................... 5
2. Simulation ................................................................................................................ 5
3. Expérimentation ....................................................................................................... 6
VI. CORRECTEUR RST .................................................................................................. 7
VII. COMMANDE AVEC ACTION INTEGRALE .......................................................... 8
1. Analyse théorique .................................................................................................... 8
2. Simulation ................................................................................................................ 9
3. Expérimentation ..................................................................................................... 10
4. Expérience du rejet de perturbation ....................................................................... 11
VIII. RST AVEC INTEGRATEUR ............................................................................... 11
 I. INTRODUCTION ET CONTEXTE

Dans ce travail de laboratoire, nous travaillons sur une maquette comportant 2

ensembles : un boitier contenant une carte Arduino et une platine contenant le procédé. Le but
à atteindre est d’implémenter diverses structures de commande à courant continu en utilisant
un microcontrôleur (dans notre cas : ARDUINO) afin d’asservir la position angulaire du moteur
à courant continu à une valeur de référence souhaitée. Nous allons tour à tour mettre en œuvre
un correcteur proportionnel, commande par retour d’état avec observateur, commande RST et
commande par retour d’état avec action intégrale.

II. PREPARATION
1. Modélisation
Les équations différentielles représentant le comportement dynamique du système soumis à
notre étude sont :
𝐿 ∶ 𝑙 ′ 𝑖𝑛𝑑𝑢𝑐𝑡𝑎𝑛𝑐𝑒
𝑑𝑖 𝑖 ∶ 𝑙𝑒 𝑐𝑜𝑢𝑟𝑎𝑛𝑡 𝑑𝑎𝑛𝑠 𝑙′𝑖𝑛𝑑𝑢𝑖𝑡
𝐿 = −𝑅𝑖 − 𝑘𝑣 𝛺 + 𝑈 𝑓 ∶ 𝑙𝑒 𝑐𝑜𝑒𝑓𝑓𝑖𝑐𝑖𝑒𝑛𝑡 𝑑𝑒 𝑓𝑟𝑜𝑡𝑡𝑒𝑚𝑒𝑛𝑡𝑠 𝑓𝑙𝑢𝑖𝑑𝑒𝑠
𝑑𝑡
{ 𝑑𝛺 𝐴𝑣𝑒𝑐
𝐽 = 𝑘𝑐 𝑖 − 𝑓𝛺 − 𝛤𝑠𝑒𝑐 𝛤𝑠𝑒𝑐 ∶ 𝑙𝑒 𝑐𝑜𝑢𝑝𝑙𝑒 𝑑𝑒 𝑓𝑟𝑜𝑡𝑡𝑒𝑚𝑒𝑛𝑡𝑠 𝑠𝑒𝑐𝑠
𝑑𝑡
𝑈 ∶ 𝑙𝑎 𝑡𝑒𝑛𝑠𝑖𝑜𝑛 𝑑é𝑙𝑖𝑣𝑟é𝑒 𝑒𝑛 𝑠𝑜𝑟𝑡𝑖𝑒 𝑑𝑒𝑠 𝑎𝑚𝑝𝑙𝑖𝑓𝑖𝑐𝑎𝑡𝑒𝑢𝑟𝑠
{ 𝛺 ∶ 𝑙𝑎 𝑣𝑖𝑡𝑒𝑠𝑠𝑒 𝑑𝑒 𝑟𝑜𝑡𝑎𝑡𝑖𝑜𝑛 𝑑𝑢 𝑚𝑜𝑡𝑒𝑢𝑟

𝛤𝑠𝑒𝑐 , 𝑓, 𝐿 𝑠𝑜𝑛𝑡 𝑛é𝑔𝑙𝑖𝑔é𝑠, ainsi les équations différentielles deviennent :

0 = −𝑅𝑖 − 𝑘𝑣 𝛺 + 𝑈 (1)
{ 𝑑𝛺
𝐽 = 𝑘𝑐 𝑖 (2)
𝑑𝑡
−𝑘𝑣 1
(1) ⇒ 𝑖 = ∗ 𝛺 + ∗ 𝑈 (3)
𝑅 𝑅
𝑑𝛺 −𝑘𝑐 ∗ 𝑘𝑣 𝑘𝑐
(3) 𝑑𝑎𝑛𝑠 (2) ⇒ = ∗𝛺+ ∗𝑈
𝑑𝑡 𝑅∗𝐽 𝑅∗𝐽
La représentation d’état sous la forme :
𝑥̇ = 𝐴𝑥 + 𝐵𝑢
{
𝑦 = 𝐶𝑥
𝑎𝑣𝑒𝑐 𝑥1 = 𝜃, 𝑥2 = 𝛺, 𝑢 = 𝑈 𝑝𝑜𝑢𝑟 𝑙𝑎 𝑐𝑜𝑚𝑚𝑎𝑛𝑑𝑒 𝑒𝑡 𝑦 = 𝑉𝜃𝑠 pour la sortie

𝟎 𝟏 𝟎 𝑼𝟎
On trouve : 𝑨 = (𝟎 −𝒌𝒗 ∗𝒌𝒄 ) 𝑩 = ( 𝒌𝒄 ) 𝑪=(
𝟐∗𝝅∗𝒏
𝟎)
𝑹∗𝑱 𝑹∗𝑱

𝑅 = 9.2 𝑂ℎ𝑚, 𝑙𝑎 𝑟𝑒𝑠𝑖𝑠𝑡𝑎𝑛𝑐𝑒 𝑑′𝑖𝑛𝑑𝑢𝑖𝑡

𝐽 = 10.8 ∗ 10−7 𝑘𝑔. 𝑚2 , 𝑙 ′ 𝑖𝑛𝑒𝑟𝑡𝑖𝑒 𝑑𝑢 𝑚𝑜𝑡𝑒𝑢𝑟
𝑘𝑣 = 23.5 ∗ 10−3 𝑉⁄𝑟𝑎𝑑. 𝑠 −1 , 𝑐𝑜𝑛𝑠𝑡𝑎𝑛𝑡𝑒 𝑑𝑒 𝑓. 𝑒. 𝑚
𝐴𝑣𝑒𝑐
𝑘𝑐 = 23.5 ∗ 10−3 𝑁𝑚⁄𝐴 , 𝑙𝑎 𝑐𝑜𝑛𝑠𝑡𝑎𝑛𝑡𝑒 𝑑𝑒 𝑐𝑜𝑢𝑝𝑙𝑒
𝑈0 = 20 𝑉
{ 𝑛 = 138, 𝑙𝑒 𝑟𝑒𝑑𝑢𝑐𝑡𝑒𝑢𝑟

𝑥𝑘+1 = 𝐴𝑑 𝑥𝑘 + 𝐵𝑑 𝑢𝑘
La représentation d’état discrète du système s’écrit sous la forme : { 𝑦𝑘 = 𝐶𝑑 𝑥𝑘

Auriol & Idriss & Elliott 1

En appliquant la méthode de Cayley Hamilton et celle de discrétisation, on trouve :
−kv ∗kc ∗𝑇𝑒
−kv ∗kc ∗𝑇𝑒 R ∗ J(𝑒 R∗J − 1) + k v ∗ k c
R ∗ J(1 − 𝑒 R∗J )
1 𝑘𝑣2 ∗ k c
Ad = 𝑒 𝐴𝑇𝑒 = kv ∗ kc Bd = −kv ∗kc ∗𝑇𝑒
Cd = C
−kv ∗kc ∗𝑇𝑒 1−𝑒 R∗J
(0 𝑒 R∗J ) ( kv )

En utilisant la commande c2d de Matlab avec une fréquence d’échantillonnage 𝐹𝑒 = 1000𝐻𝑧

pour calculer les matrices du procédé discrétisé (𝑠𝑦𝑠𝑐𝑜𝑛𝑡𝑖𝑛𝑢 = 𝑠𝑠(𝐴, 𝐵, 𝐶, [ ]); 𝑠𝑦𝑠_𝑑𝑖𝑠𝑐𝑟𝑒𝑡 =
1
𝑐2𝑑(𝑚𝑜𝑑𝑒𝑙, 𝑇𝑒 ); 𝑎𝑣𝑒𝑐 𝑇𝑒 = ), on obtient donc:
𝐹 𝑒

𝟏 𝟎. 𝟎𝟎𝟎𝟗𝟕𝟐𝟕 𝟎. 𝟎𝟎𝟏𝟏𝟔𝟏
𝑨𝒅 = ( ) 𝑩𝒅 = ( ) 𝑪𝒅 = (𝟎. 𝟎𝟐𝟒𝟏𝟏 𝟎)
𝟎 𝟎. 𝟗𝟒𝟓𝟗 𝟐. 𝟑𝟎𝟏

2. Etude de la stabilité, commandabilite et observabilité

Stabilité
Pour pouvoir étudier ce système nous commençons par effectuer une analyse de la stabilité à
travers la position des pôles. L’équation caractéristique est donnée par : det(sI2-A)=0⇒
(𝑠 − 𝜆1 )(𝑠 − 𝜆2 ) = 0 . Les pôles du système sont les valeurs propres de celui-ci et représentées
−𝑘𝑣 ∗𝑘𝑐
par 𝜆1 = 0 𝑒𝑡 𝜆2 = 𝑅∗𝐽 . Vu que 𝜆1 = 0 alors le 𝑺𝒚𝒔𝒕è𝒎𝒆 𝒆𝒏 𝒃𝒐𝒖𝒄𝒍𝒆 𝒐𝒖𝒗𝒆𝒓𝒕𝒆 𝒆𝒔𝒕 𝒊𝒏𝒔𝒕𝒂𝒃𝒍𝒆.

Les zéros du système en boucle ouverte sont donnés par : z/ det[𝐴 − 𝑧𝐼2 𝐵 ] = 0.Or:
𝐶 𝐷
det[𝐴 − 𝑧𝐼𝑛 𝐵
] ≠ 0. Ainsi le système en boucle ouverte ne possède pas de zéros.
𝐶 𝐷

Commandabilité
𝑘𝑐
0
La matrice de commandabilité est donnée par :C = [B AB]= . On a rangC = 2
𝑅∗𝐽
2
𝑘𝑐 −𝑘𝑣 ∗(𝑘𝑐 )
𝑅∗𝐽 2
( (𝑅∗𝐽) )

Le système est commandable et peut à cet effet être commandé par retour d’état.

Observabilité
𝑈0
0
La matrice d’observabilité est : O = [C CA ]= (2∗𝜋∗𝑛 𝑈0
). On a rangO =2
0 2∗𝜋∗𝑛

La mise en œuvre d’un observateur est possible.

Auriol & Idriss & Elliott 2

III. CARACTERISTIQUE DU ACD0 ET DU DAC0
Dans cette partie, il est question de tracer les caractéristiques des convertisseurs ADC et DAC
(valeur en sortie du convertisseur en fonction de la valeur en entrée du convertisseur) et d’écrire
les équations des blocs de conversion en volt et en nombre entier.

Les blocs « Conversion en Volts » et « Conversion en nombre entier » effectue des opérations
inverses. Les équations mathématiques qui régissent ces 2 convertisseurs sont données par :On
calcule la valeur de 𝑙𝑎 𝑐𝑜𝑛𝑠𝑖𝑔𝑛𝑒 𝑐𝑘 𝑒𝑡 𝑑𝑒 𝑙𝑎 𝑠𝑜𝑟𝑡𝑖𝑒 𝑦𝑘 de la même manière car la conversion
10−(−10)
est identique : 𝑐𝑜𝑚𝑚𝑎𝑛𝑑𝑒𝑒𝑛 𝑉𝑜𝑙𝑡 = 𝑐𝑜𝑚𝑚𝑎𝑛𝑑𝑒𝑒𝑛 𝐵𝑖𝑡𝑠 − 10
212 −1

𝟏𝟎
𝒄𝒐𝒎𝒎𝒂𝒏𝒅𝒆𝒆𝒏 𝑽𝒐𝒍𝒕 = (𝒄𝒐𝒎𝒎𝒂𝒏𝒅𝒆𝒆𝒏 𝑩𝒊𝒕𝒔 − 𝟐𝟎𝟒𝟕) ∗
𝟐𝟎𝟒𝟕
Les valeurs correspondant à [-10V, +10V] sont codées sur 4096 bits.

IV. CORRECTEUR PROPORTIONNEL

Dans cette partie il est question de programmer une loi de commande proportionnelle
analogique et discrète et vérifier le suivi de la consigne en position. On a le correcteur
proportionnel suivant 𝑢𝑘 = 𝐾(𝑐𝑘 − 𝑦𝑘 ) . On a d’abord effectué un test avec un gain Kp=5 de
façon analogique puis numérique en vue de s’assurer du bon fonctionnement du procédé et
surtout que le câblage était bien effectué, puis Kp=50.

Pour un gain Kp=5, on constate que la

commande ne sature pas, le système
bouclé est stable mais il y’a une erreur
statique importante.

Auriol & Idriss & Elliott 3

Pour Kp=50, on a effectué un modèle SIMULINK (dont les résultats de simulations sont
présentés sur la courbe de gauche) et la réponse expérimentale (figure de droite). Force est de
constater que les attentes fixées par la simulation sont vérifiées dans l’expérimentation.

Comme observations :

- Le régime permanent est atteint pour une tension crête à crête de 0.2mV. Cependant on
remarque un léger dépassement de 20% lors de la montée. Le pic maximal est atteint
après 70 ms (69,505ms en simulation)
- L’erreur statique est nulle avec une précision de mesure de l’ordre de 10mV.
- On mesure également le temps de réponse à 5% qui est de 620ms.

Ainsi, augmenter le gain proportionnel a annulé l’erreur statique, provoqué un

dépassement et diminué le temps de réponse. On remarque que dans ce dernier cas, la
réponse du système est beaucoup plus bruitée. Toutefois, en effectuant les tests, on s’est
rendu compte que la commande pouvait saturer lorsque la valeur de la consigne était
assez élevée (proche de 1V), ainsi il est nécessaire de mettre en œuvre une commande
optimale permettant la régulation et l’asservissement du système.

Auriol & Idriss & Elliott 4

 V. COMMANDE AVEC OBSERVATEUR
1. Analyse théorique
L’objectif à atteindre dans cette partie est de construire à l’aide de Matlab/Simulink un
observateur d’état estimant l’état complet, puis de simuler, programmer et de tester
expérimentalement la commande par retour d’état estimé.

L’état estimé est régit par : ̂𝑘+1 = 𝐴𝑑 𝑥

𝑥 ̂𝑘 + 𝐵𝑑 𝑢𝑘 + 𝐾𝑑 (𝑦
̂ 𝑘 − 𝐶𝑑 𝑥
̂𝑘 )

On obtient le gain de l’observateur d’état 𝐾𝑑 par la méthode de commande optimale LQR à

4
l’aide de la fonction dlqr : 𝐾𝑑 = 𝑑𝑙𝑞𝑟(𝐴𝑑 ′, 𝐶𝑑 ′, 𝑄0 , 𝑅0 ) avec les pondérations 𝑄0 = (10 0 )
0 103
et 𝑅0 = 0.01. On trouve :

𝑲𝒅 = (𝟒𝟏. 𝟑𝟗𝟖 𝟎. 𝟎𝟑𝟒𝟐)

En ajoutant une commande par retour d’état : 𝑢𝑘 = −𝐹𝑑 𝑥

̂𝑘 + 𝐺𝑑 𝑐𝑘

On obtient le gain 𝑄𝑑 à l’aide de la fonction dlqr avec les pondérations 𝑄 = 10 ∗ 𝐶𝑑 𝑇 𝐶𝑑 et 𝑅 =

1 par la fonction 𝐹𝑑 = 𝑑𝑙𝑞𝑟(𝐴𝑑 , 𝐵𝑑 , 𝑄, 𝑅) ; On obtient donc le gain de la commande LQR
suivant

𝑭𝒅 = (𝟎. 𝟎𝟕𝟔𝟏 𝟎. 𝟎𝟎𝟏𝟑)

1
De plus on calcule le gain de la consigne comme suit : 𝐺𝑑 = 𝐶 ∗𝑖𝑛𝑣 𝐼 −𝐴
= 𝟑. 𝟏𝟓𝟕𝟑
𝑑 ( 2 𝑑 +𝐵𝑑 𝐹𝑑 )∗𝐵𝑑

Afin de réduire des potentielles erreurs lors de l’expérimentation (calcul, arrondi…), nous
avons effectué la programmation Arduino (pour toutes les expériences) avec les valeurs
calculées sur Matlab au format « long » (soit 10 chiffres après la virgule).

2. Simulation
On programme ainsi cette commande par retour d’état sur Matlab/Simulink

La simulation nous donne les courbes ci-après, où celle de gauche présente la commande, la
consigne et la sortie tandis que sur celle de droite on a l’erreur d’estimation. Comme
observation :

Auriol & Idriss & Elliott 5

 - Temps de réponse à 5% de 950ms
- Une erreur statique nulle
- Erreur d’estimation de l’ordre de 10-15 donc quasi nulle

Ainsi la mise en place de la commande par retour d’état avec observateur est satisfaisante.

3. Expérimentation
La programmation sur Arduino de notre commande nous a donné la réponse suivante :

Auriol & Idriss & Elliott 6

 - Le régime permanent est atteint pour une tension crête à crête de 412 mV.
- Erreur statique = 0.5-0.412=88 mV ce qui correspond tout de même à plus de 10% de
l’échelon, et est donc non négligeable.
- Temps de réponse de 720ms

La remarque qu’on peut faire à ce niveau est qu’il y’a une différence entre la simulation et
l’expérimentation bien que la commande ne sature pas: temps de réponse plus bas et présence
d’une erreur statique. Ainsi dans le modèle il y a des éléments qui n’ont pas été pris en compte :
friction lors de la rotation du moteur.

VI. CORRECTEUR RST

L’objectif visé ici est d’implémenter le correcteur précédent sous la forme RST. Le système
obtenu avec une commande par retour d’état estimé est donné par :

𝑢𝑘 = −𝐹𝑑 𝑥̂𝑘 + 𝐺𝑑 𝑦𝑟𝑒𝑓𝑘

{
𝑥𝑘+1 = (𝐴𝑑 − 𝐾𝑑 𝐶𝑑 )̂
̂ 𝑥𝑘 + 𝐵𝑑 𝑢𝑘 + 𝐿𝑑 𝑦
̂𝑘

En remplaçant 𝑢𝑘 dans la seconde équation et en isolant la sortie et l’entrée on obtient les

équations suivantes :
𝑦
𝑢𝑘 = −𝐹𝑑 𝑥
̂𝑘 + [0 𝐺𝑑 ] ∗ [𝑦 𝑘 ]
𝑟𝑒𝑓𝑘
𝑦
̂𝑘+1 = (𝐴𝑑 − 𝐾𝑑 𝐶𝑑 − 𝐵𝑑 𝐹𝑑 )𝑥
𝑥 ̂𝑘 + [𝐾𝑑 𝐵𝑑 𝐺𝑑 ] ∗ [𝑦 𝑘 ]
{ 𝑟𝑒𝑓𝑘

Ce qui nous permet donc d’isoler les matrices (A,B,C,D) du RST et exposer la représentation
d’état de ce système RST suivante : 𝐴𝑅𝑆𝑇 = 𝐴𝑑 − 𝐾𝑑 𝐶𝑑 − 𝐵𝑑 𝐹𝑑 𝐵𝑅𝑆𝑇 = (𝑘𝑑 𝐵𝑑 𝐺𝑑 )
𝐶𝑅𝑆𝑇 = −𝐹𝑑 𝐷𝑅𝑆𝑇 = (0 𝐺𝑑 )
𝑦
Nous cherchons désormais à déterminer la fonction de transfert entre l’entrée (𝑦 𝑘 ) et la sortie
𝑟𝑒𝑓𝑘
𝑅(𝑧) 𝑇(𝑧)
𝑢𝑘 . De plus il faut la mettre sous la forme suivante : 𝑈(𝑧) = − 𝑆(𝑧) ∗ 𝑌(𝑧) + 𝑆(𝑧) ∗ 𝑌𝑟𝑒𝑓(𝑧)

En utilisant MATLAB, on trouve :

𝑹𝒔 = (𝟎 𝟑. 𝟏𝟓𝟏𝟗 − 𝟐. 𝟗𝟖𝟏𝟓)
{ 𝑺𝒔 = (𝟏 − 𝟎. 𝟗𝟒𝟒𝟓 𝟎. 𝟎𝟎𝟏𝟕)
𝑻𝒔 = (𝟑. 𝟏𝟓𝟕𝟑 − 𝟐. 𝟗𝟗𝟐𝟎 𝟎. 𝟎𝟎𝟓𝟏)

Le modèle Simulink est présenté ci-après :

Auriol & Idriss & Elliott 7

La réponse du système nous donne :

En comparant cette simulation avec la commande précédente, on constate qu’on a pratiquement

le même temps de réponse, la dynamique de la sortie reste la même (pas de dépassement), la
commande ne sature pas et présente toujours un pic de 1.6V à la seule différence qu’elle a une
évolution beaucoup plus rapide. Ainsi on peut dire que le correcteur RST mis en œuvre est
valide.

L’expérimentation de ce nouveau modèle nous a offert exactement les mêmes observations

que précédemment.

VII. COMMANDE AVEC ACTION INTEGRALE

L’objectif de cette partie est de mettre en œuvre une commande avec action intégrale sous la
forme de représentation d’état et sous forme RST ceci dans le but d’annuler l’erreur statique
observé avec toutes les commandes mises en œuvre jusqu’à présent.

1. Analyse théorique
Compte tenu du fait que l’adjonction d’une action intégrale n’a pas d’impact sur l’observateur,
alors les paramètres de l’observateur implémenté plus haut demeurent les mêmes, soit :

Auriol & Idriss & Elliott 8

 𝑲𝒅 = (𝟒𝟏. 𝟑𝟗𝟖 𝟎. 𝟎𝟑𝟒𝟐)

L’action intégrale se matérialise par une nouvelle variable d’état 𝑧𝑘+1 = 𝑧𝑘 + 𝑦𝑟𝑒𝑓𝑘 − 𝑦𝑘 . La
commande devient : 𝑢𝑘 = −𝐹𝑑 𝑥
̂𝑘 − 𝐻𝑑 𝑧𝑘 .

̂ ̇
𝑥 𝑥
̂
[ 𝑘+1 ] = 𝐴𝑑𝑒 [ 𝑘 ] + 𝐵𝑑𝑒 𝑢𝑘 + 𝐸𝑑𝑒 𝑦𝑟𝑒𝑓𝑘
𝑧𝑘+1 𝑧𝑘
Le système étendue est de la forme :
𝑥
̂
𝑦 = 𝐶𝑑𝑒 [ 𝑘 ]
{ 𝑧𝑘

𝑨𝒅 𝟎 𝑩 𝟎
Avec : 𝑨𝒅𝒆 = ( ) 𝑩𝒅𝒆 = ( 𝒅 ) 𝑪𝒅𝒆 = (𝑪𝒅 𝟎) 𝑬𝒅𝒆 = ( )
−𝑪𝒅 𝟏 𝟎 𝟏

Cette fois, pour le choix des matrices de pondération Q et R :

Q est choisi toujours diagonale avec les 2 premiers éléments inchangés. Le 3e élément (celui lié
à la variable de l’action intégrale) est prise avec une pondération au moins supérieure à 1à fois
les 2 autres afin de donner plus de poids à cet état.
Le choix de R a un impact sur le caractère énergétique de la commande : plus R est grand moins
la commande est susceptible de saturer mais cela introduit un dépassement plus important et un
temps de réponse plus long.

Ainsi après quelques tests et un compromis sur les spécifications souhaitées, on a pris :
𝑄 0
Qi=( ) et Ri=5.
0 0.05

On obtient le gain 𝐹𝑑_𝑒 à l’aide de la fonction dlqr : 𝐹𝑑_𝑒 = 𝑑𝑙𝑞𝑟(𝐴𝑑_𝑒 , 𝐵𝑑_𝑒 , 𝑄𝑖, 𝑅𝑖) ; Le gain
de la commande par retour d’état représente les 2 premiers éléments de 𝐹𝑑_𝑒 et le 3e élément est
celui li é à l’action intégrale. On trouve :

𝑭𝒅 = (𝟎. 𝟑𝟕𝟖𝟕 𝟎. 𝟎𝟎𝟔) et 𝑯𝒅 = −𝟎. 𝟎𝟗𝟗𝟑

2. Simulation
Le modèle Simulink pour cette nouvelle commande est le suivant :

La simulation de ce modèle nous a donné la réponse suivante :

Auriol & Idriss & Elliott 9

Comme observation :
- Dépassement de 3% (soit un dépassement tout à fait acceptable)
- Absence de saturation de la commande
- Temps de réponse de 470,225ms

3. Expérimentation
Ci-dessous, les courbes expérimentales. La figure de gauche est celle observée à l’oscilloscope
(présentant la consigne et la sortie) et celle de droite obtenu à l’aide du traceur série de
l’Arduino (elle présente la commande en bleu)

Les mêmes observations que pour la simulation peuvent être faites :

- La commande ne sature pas, elle garde exactement la même allure avec un pic de 3V
- Il y’a absence d’erreur statique
- L’asservissement et la régulation sont assurées avec un temps de réponse de 440 ms

Auriol & Idriss & Elliott 10

 4. Expérience du rejet de perturbation
Vu que la particularité de l’action intégrale est le rejet de perturbations, on a introduit une
perturbation en insérant la résistance série du moteur, ceci crée une erreur de modèle. Ci-
dessous la réponse observée :

Ainsi, lorsqu’on introduit des perturbations (ajout de la résistance interne), on observe un

moment pendant lequel le système oscille (sorte de régime transitoire) avant que l’erreur
statique ne s’annule. Le rejet de la perturbation prend plus de temps et le dépassement est plus
important. Malgré tout, la commande RST avec intégrateur rejette bien les perturbations et la
commande n’est jamais saturée.

VIII. RST AVEC INTEGRATEUR

L’objectif visé ici est d’implémenter le correcteur précédent sous la forme RST. Le système
obtenu avec une commande par retour d’état estimé est donné par :
𝑢𝑘 = −𝐹𝑑 𝑥̂𝑘 − 𝐻𝑑 𝑧𝑘
{
𝑥̂𝑘+1 = (𝐴𝑑 − 𝐾𝑑 𝐶𝑑 )𝑥̂𝑘 + 𝐵𝑑 𝑢𝑘 + 𝐿𝑑 𝑦̂𝑘

Auriol & Idriss & Elliott 11

 𝑦
En remplaçant 𝑢𝑘 dans la seconde équation et en prenant comme entrée : [𝑦 𝑘 ], on obtient les
𝑟𝑒𝑓𝑘
équations suivantes :
𝑥̂ 𝐴 − 𝐾𝑑 𝐶𝑑 − 𝐵𝑑 𝐹𝑑 −𝐵𝑑 𝐻𝑑 𝑥̂𝑘 𝐾 0 𝑦𝑘
[ 𝑘+1 ] = ( 𝑑 )[ ] + ( 𝑑 ) ∗ [𝑦 ]
𝑧𝑘+1 𝟎 𝟏 𝑧𝑘 −𝟏 𝟏 𝑟𝑒𝑓𝑘
{ 𝑦𝑘
𝑥̂
𝑢𝑘 = [−𝐹𝑑 − 𝐻𝑑 ] [ 𝑘 ] + [0 0] ∗ [𝑦 ]
𝑧𝑘 𝑟𝑒𝑓𝑘

Ce qui nous permet donc d’isoler les matrices (A,B,C,D) du RST et exposer la représentation
d’état de ce système RST suivante : 𝐴𝑅𝑆𝑇 = (𝐴𝑑 − 𝐾𝑑 𝐶𝑑 − 𝐵𝑑 𝐹𝑑 −𝐵𝑑 𝐻𝑑 ) 𝐵𝑅𝑆𝑇 = (
𝐾𝑑 0
)
𝟎 𝟏 −𝟏 𝟏
𝐶𝑅𝑆𝑇 = [−𝐹𝑑 − 𝐻𝑑 ] 𝐷𝑅𝑆𝑇 = [0 0]

𝑦
Nous cherchons désormais à déterminer la fonction de transfert entre l’entrée (𝑦 𝑘 ) et la sortie
𝑟𝑒𝑓𝑘
𝑅(𝑧) 𝑇(𝑧)
𝑢𝑘 . De plus il faut la mettre sous la forme suivante : 𝑈(𝑧) = − 𝑆(𝑧) ∗ 𝑌(𝑧) + 𝑆(𝑧) ∗ 𝑌𝑟𝑒𝑓(𝑧). Le
code Matlab permettant d’y arriver est présenté ci-dessous :

𝑹𝒔 = (𝟎 𝟏𝟓. 𝟕𝟕𝟔𝟗 − 𝟑𝟎. 𝟔𝟎𝟏𝟕 𝟏𝟒. 𝟖𝟑𝟎𝟏𝟒)

On trouve : { 𝑺𝒔 = (𝟏 − 𝟏. 𝟗𝟑𝟑𝟒 𝟎. 𝟗𝟑𝟓𝟒 − 𝟎. 𝟎𝟎𝟐)
𝑻𝒔 = (𝟎 𝟎. 𝟎𝟗𝟗𝟑 − 𝟎. 𝟎𝟗𝟒𝟏 𝟎. 𝟎𝟎𝟎𝟐)

Le modèle Simulink est présenté ci-après :

On a pu valider cette partie étant donné qu’on obtenait exactement les mêmes résultats
expérimentaux.

Auriol & Idriss & Elliott 12