Vous êtes sur la page 1sur 148

Commande par espace d’état

Luc Jaulin

18 octobre 2007
2 Commande par espace d’état
Table des matières

1 Introduction 13

2 Modélisation des systèmes 17

2.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

2.2 Représentation d’état de quelques systèmes linéaires . . . . . . . . . . . . . . . . . . . . . . . . . . 17

2.2.1 Intégrateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18

2.2.2 Système d’ordre 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18

2.3 Modélisation des systèmes mécaniques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18

2.3.1 Méthodologie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18

2.3.2 Modélisation d’un satellite . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

2.3.3 Modélisation d’un système masses-ressorts . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20

2.3.4 Modélisation d’un pendule simple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

2.3.5 Modélisation d’un pendule inversé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

2.4 Modélisation des véhicules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24

2.4.1 Modélisation d’un monocycle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24

2.4.2 Modélisation d’un char . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26

2.4.3 Modélisation d’une voiture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27

2.4.4 Modélisation d’un voilier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29

2.5 Systèmes hydrauliques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31

2.5.1 Rappel sur la relation de Bernouilli . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31

2.5.2 Ecoulement dans trois bacs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32

2.5.3 Modélisation d’un vérin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33

2.6 Système électrique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35

3
4 Commande par espace d’état

2.6.1 Circuit RLC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35

2.6.2 Moteur à courant continu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36

2.7 Système de Fibonacci . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37

3 Simulation 39

3.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39

3.2 Notion de champ de vecteur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39

3.2.1 Exemple d’une fonction linéaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40

3.2.2 Exemple d’une fonction de type gradient . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41

3.3 Champ de vecteur associé à un système . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42

3.3.1 Système proies-prédateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42

3.3.2 Pendule simple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43

3.4 Représentation graphique des systèmes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44

3.4.1 Motif . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45

3.4.2 Matrice de rotation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46

3.4.3 Coordonnées homogènes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46

3.4.4 Dessin de la voiture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47

3.4.5 Dessin d’un bras manipulateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49

3.5 Simulation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50

3.5.1 Méthode d’Euler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50

3.5.2 Simulation d’un pendule . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51

3.5.3 Simulation d’une voiture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53

3.6 Ajout de l’interactivité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53

4 Systèmes linéaires 57

4.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57

4.2 Solution des équations d’état . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57

4.2.1 Système à temps continu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57

4.2.2 Système à temps discret . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58

4.3 Stabilité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
Table des matières 5

4.3.1 Solution des équations d’état . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59

4.3.2 Critère de stabilité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59

4.3.3 Polynôme caractéristique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60

4.4 Changement de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61

4.4.1 Principe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61

4.4.2 Exemple de changement de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62

4.5 D’une représentation d’état vers une représentation entrées-sorties . . . . . . . . . . . . . . . . . . 62

4.6 D’une représentation entrées-sorties vers une représentation d’état . . . . . . . . . . . . . . . . . . 64

4.6.1 Forme canonique de commande . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65

4.6.2 Forme canonique d’observation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66

4.6.3 Forme modale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67

4.6.4 Forme de Jordan . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69

5 Commande des systèmes linéaires 71

5.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71

5.2 Commandabilité et observabilité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72

5.2.1 Rappel sur les équations linéaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72

5.2.2 Commandabilité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72

5.2.3 Observabilité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74

5.2.4 Décomposition de Kalman . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75

5.3 Commande par retour d’état . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76

5.3.1 Equation de placement de pôles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76

5.3.2 Résolution de l’équation de placement de pôles . . . . . . . . . . . . . . . . . . . . . . . . . 77

5.3.3 Rajout d’un effet intégral . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78

5.4 Commande par retour de sortie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79

5.4.1 Principe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79

5.4.2 Calcul de la matrice de correction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80

5.4.3 Représentation d’état du régulateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81

5.5 Principe de séparation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82

5.5.1 Equation d’état du système bouclé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82


6 Commande par espace d’état

5.5.2 Changement de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83

5.5.3 Polynôme caractéristique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83

5.6 Insertion d’un précompensateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83

6 Commande linéaire des systèmes non linéaires 87

6.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87

6.2 Linéarisation d’un système . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87

6.2.1 Rappel sur la linéarisation d’une fonction . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87

6.2.2 Linéarisation du système autour d’un point . . . . . . . . . . . . . . . . . . . . . . . . . . . 88

6.2.3 Linéarisation du système autour d’un point de fonctionnement . . . . . . . . . . . . . . . . 89

6.2.4 Exemple du système proies-prédateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89

6.2.5 Exemple du pendule simple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90

6.2.6 Exemple du vérin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91

6.3 Stabilisation d’un système non linéaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92

6.3.1 Principe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92

6.3.2 Avec un observateur étendu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94

6.4 Stabilisation du pendule inversé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94

6.5 Stabilisation d’un monocycle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97

6.6 Conduite automatique d’une voiture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98

6.6.1 Fonction d’observation pour le système . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99

6.6.2 Fonction d’observation pour le régulateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101

6.6.3 Bouclage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104

7 Commande non linéaire des systèmes non linéaires 107

7.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107

7.2 Un petit exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107

7.3 Principe de la linéarisation par bouclage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108

7.3.1 Principe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108

7.3.2 Commande d’une chaîne d’intégrateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110

7.4 Régulation des trois bacs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112


Table des matières 7

7.5 Régulation du char . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113

7.6 Régulation de la voiture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114

7.6.1 Voiture décrivant un hexagone . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114

7.6.2 Voiture décrivant un cercle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116

7.7 Régulation du bateau à voile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118

7.7.1 Dérivations successives des variables d’état . . . . . . . . . . . . . . . . . . . . . . . . . . . 118

7.7.2 Linéarisation par bouclage du bateau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119

7.7.3 Régulateur hybride . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121

8 Identification 125

8.1 Fonctions quadratiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125

8.1.1 Définition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125

8.1.2 Dérivée d’une forme quadratique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125

8.1.3 Valeurs propres d’une fonction quadratique . . . . . . . . . . . . . . . . . . . . . . . . . . . 126

8.1.4 Minimisation d’une fonction quadratique . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126

8.2 Méthode des moindres-carrés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127

8.2.1 Introduction à l’estimation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127

8.2.2 Méthode des moindres carrés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127

8.2.3 Exemple de la parabole . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128

8.2.4 Moteur à courant continu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128

8.2.5 Estimation d’une fonction de transfert . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129

8.2.6 Cas non-linéaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130

8.3 Localisation d’un robot . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131

8.4 Moindres-carrés récursifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132

8.4.1 Principe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132

8.4.2 Première simplification . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133

8.4.3 Deuxième simplification . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133

8.5 Filtrage de Kalman . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135

8.5.1 Matrice de covariance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135

8.5.2 Distribution Gaussienne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136


Table des matières 11

8.5.3 Filtre de Kalman . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138

8.6 Application à l’estimation en temps réel d’une fonction de transfert . . . . . . . . . . . . . . . . . . 138

8.6.1 Principe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138

8.6.2 Perspectives : commande adaptative, surveillance . . . . . . . . . . . . . . . . . . . . . . . . 140

8.7 Localisation d’un robot sous-marin dans une piscine . . . . . . . . . . . . . . . . . . . . . . . . . . 141

8.7.1 Présentation du problème . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141

8.7.2 Détection des murs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141

8.7.3 Localisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142

8.7.4 Représentation graphique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144

Bibliographie 146

Glossaire 149

Index 150
12 Commande par espace d’état
Chapitre 1

Introduction

Une très grande classe de systèmes physiques, biologiques, économiques, etc. qui nous entourent peuvent être
décrits par une équation différentielle du type

ẋ(t) = f (x(t), u(t))
(1.1)
y(t) = g(x(t), u(t)),

sous l’hypothèse que le temps t dans lequel évolue le système est continu (c’est-à-dire appartient à R). Le vecteur
u(t) est l’entrée (ou commande) du système. Sa valeur peut être choisie arbitrairement pour tout t. Le vecteur
y(t) est la sortie du système et peut être mesuré avec une certaine précision. Le vecteur x(t) est appelé état du
système. Comme nous l’illustrerons dans la suite, il représente la mémoire du système, c’est-à-dire, l’ensemble des
informations dont le système a besoin pour prédire son propre avenir, pour une entrée u(t) connue. La première
des deux équations de (1.1) s’appelle équation d’évolution. Il s’agit d’une équation différentielle qui permet de
savoir vers où va se diriger l’état x(t) sachant sa valeur à l’instant présent t et la commande u(t) que nous sommes
en train d’exercer. La deuxième équation s’appelle équation d’observation. Elle permet de calculer le vecteur de
sortie y(t), connaissant l’état et la commande à l’instant t. Attention, contrairement à l’équation d’évolution, cette
équation n’est pas une équation différentielle car elle ne fait pas intervenir les dérivées des signaux. Les équations
(1.1) forment la représentation d’état du système.

Il est parfois utile de considérer aussi un temps k discret, où k sera un élément de Z, l’ensemble des entiers relatifs.
En effet, si l’univers que nous considérons est un ordinateur, il est concevable de considérer que le temps k qui
le régit est discret, synchronisé sur l’horloge du microprocesseur. De tels systèmes, dits à temps discret, obéissent
généralement à une équation de récurrence du type

x(k + 1) = f (x(k), u(k))
(1.2)
y(k) = g(x(k), u(k)).

Dans ce cours (qui est fortement inspiré de mon livre [8], paru en 2005), sauf mention particulière, nous allons
uniquement nous intéresser aux systèmes à temps continu (c’est-à-dire de type (1.1)).

Le premier objectif de ce cours est de bien comprendre cette représentation d’état. Pour cela, nous allons considérer
dans le chapitre 2 un grand nombre d’exemples variés et montrer comment naturellement nous arrivons à une
représentation d’état pour modéliser le système qui nous intéresse. Ensuite, nous montrerons au chapitre 3 comment
simuler sur ordinateur un système pour lequel une représentation d’état est connue.

13
14 Commande par espace d’état

Le second objectif de ce cours est de proposer des méthodes pour commander les systèmes décrits par des équa-
tions d’état. C’est-à-dire que nous allons tenter de fabriquer des machines automatiques (où l’homme n’intervient
quasiment pas, sauf pour donner ses ordres, où consignes), appelées régulateurs capables de domestiquer (changer
le comportement dans le sens que l’on souhaite) les systèmes considérés. Pour cela, le régulateur devra calculer
les entrées u(t) à appliquer au système à partir de la connaissance (plus ou moins bruitées) des sorties y(t) et de
la consigne w(t) donnée (voir figure).

Principe de la régulation d’un système

Vu de l’utilisateur, le système, dit système bouclé, d’entrée w(t) et de sortie y(t) aura un comportement convenable.
On dira que l’on a asservi le système.

Dans cet objectif de régulation, nous allons, dans une première phase, nous intéresser uniquement aux systèmes
linéaires, c’est-à-dire que les fonctions f et g sont supposées linéaires. Ainsi, dans le cas du temps continu, (1.1)
s’écrit 
ẋ(t) = Ax(t) + Bu(t),
(1.3)
y(t) = Cx(t) + Du(t),
et dans le cas du temps discret, (1.2) devient

x(k + 1) = Ax(k) + Bu(k),
(1.4)
y(k) = Cx(k) + Du(k).
Les matrices A, B, C, D sont appelées matrices d’évolution, de commande, d’observation et directe. Une analyse
détaillée de ces systèmes sera faite au chapitre 4. Nous expliquerons ensuite, dans le chapitre 5 comment stabiliser
ces systèmes.

Dans une seconde phase, nous montrerons, au chapitre 6, qu’autour de certains points, dits de fonctionnement,
les systèmes non linéaires se comportent comme des systèmes linéaires et qu’il alors possible de les stabiliser par
des méthodes développées pour le cas linéaire. Nous donnerons aussi d’autres types d’approches, moins générales
mais plus adaptées, pour stabiliser des systèmes non linéaires.

Les programmes informatiques utilisés pour tester nos régulateurs et effectuer nos simulations seront tous donnés
pour un environnement S[2]. Ces derniers sont disponibles sur
http ://www.hermes-science.com/jaulin/progscilab.zip.
Rappelons que S est un logiciel de calcul numérique qui intègre les opérations courantes du calcul matriciel
(tout comme M), et offre l’avantage d’être gratuit (contrairement à M). Il peut être téléchargé à
l’adresse
http ://www-rocq.inria.fr /scilab/.
Le calcul formel sera quant à lui effectué sous M
 [1] qui est un logiciel proche de M
 . Notons que
contrairement à M
 , M
 est gratuit et peut être téléchargé sur
http ://www.mupad.com.
Dans le fichier compressé progscilab.zip, vous trouverez les programmes S suivants :
Introduction 15

BacsAsservi.sce, BacsLibres.sce,
BateauHybride, BateauLibre.sce,
BrasManipulateur, CharLibre,
PenduleInverseAsservi.sce, PenduleInverseLibre.sce,
PenduleSimpleChamp.sce, PenduleSimpleLibre.sce,
PenduleSimpleTrajectoire.sce, SegWayAsservi,
SegwayLibre, VerinLibre,
VoitureAsservieCircuit, VoitureAsservieCycle,
VoitureAsservieHexagone.sce, VoitureAsservieNord,
VoitureChampCycle.sce, VoitureLibre.sce,
VoitureLibreCircuit.sce, VoitureLibreNord.sce,
VolterraChamp.sce.

Dans les noms des fichiers, on retrouve le nom du système traité (voiture, pendule, etc), un qualificatif (libre
signifie non asservi) et l’extension sce rattachée aux programmes S.
16 Commande par espace d’état
Chapitre 2

Modélisation des systèmes

2.1 Introduction

Rappelons que de nombreux systèmes peuvent se mettre sous une représentation d’état,

ẋ(t) = f (x(t), u(t))
y(t) = g(x(t), u(t)),

pour les systèmes à temps continus et



x(k + 1) = f (x(k), u(k))
y(k) = g(x(k), u(k)),

pour les systèmes à temps discret. Nous appellerons modélisation l’étape qui consiste à trouver une représentation
d’état, plus ou moins précise, du système qui nous intéresse. En général, apparaissent dans les équations d’états des
paramètres constants (comme la masse ou le moment d’inertie d’un corps, le coefficient du frottement visqueux,
la capacité d’un condensateur, etc). Dans de tels cas, une étape d’identification peut s’avérer nécessaire. Dans ce
cours, nous supposerons que tous les paramètres sont connus et dans le cas contraire, nous invitons le lecteur à
consulter le livre d’Eric Walter et Luc Pronzato [7] pour une panoplie des méthodes d’identification.

Bien sûr, il n’existe pas de méthodologie systématique à appliquer pour modéliser un système. Le but de ce chapitre
est de présenter sur quelques exemples variés comment arriver à une représentation d’état afin de permettre au
lecteur d’acquérir une certaine expérience qui l’aidera à modéliser ses propres systèmes.

2.2 Représentation d’état de quelques systèmes linéaires

Dans ce paragraphe, nous présentons quelques exemples de systèmes linéaires à temps continus, qui, rappelons-le,
peuvent être décrits par les équations d’état

ẋ(t) = Ax(t) + Bu(t),
y(t) = Cx(t) + Du(t).

17
18 Commande par espace d’état

2.2.1 Intégrateur

L’intégrateur est un système linéaire décrit par l’équation différentielle ẏ = u. Une représentation d’état possible
pour ce système est

ẋ(t) = u(t)
y(t) = x(t).

Les matrices associées à ce système sont A = (0), B = (1), C = (1) et D = (0) . Elles sont toutes de dimension
1 × 1.

2.2.2 Système d’ordre 2

Soit le système d’entrée u et de sortie y décrit par l’équation différentielle suivante

ÿ + a1 ẏ + a0 y = bu.

Puisque,
   
ẏ ẏ
= ,
ÿ −a1 ẏ − a0 y + bu
y = y,

en posant x = (y, ẏ), cette équation différentielle peut s’écrire sous la forme
   
ẋ1 x2
= ,
ẋ2 −a1 x2 − a0 x1 + bu
y = x1 ,

ou encore, sous une forme standard faisant apparaître les matrices d’état A, B, C et D :
   
0 1 0
ẋ = x+ u
−a0 −a1 b
 
y = 1 0 x.

2.3 Modélisation des systèmes mécaniques

2.3.1 Méthodologie

Le principe fondamental de la dynamique permet de trouver simplement les équations d’état de systèmes méca-
niques (ou robots). Les calculs engendrés sont relativement lourds pour les systèmes complexes et l’utilisation du
logiciel de calcul formel (M
 par exemple) peut s’avérer utile. La méthode sera illustrée à travers plusieurs
exemples.

Pour obtenir les équations d’état d’un système mécanique composé de plusieurs sous-systèmes S1 , S2 , . . . , Sm ,
supposés rigides, on procède en trois étapes.
Modélisation des systèmes 19

1. Obtention des équations différentielles. Il faut appliquer pour chaque sous-système Sk , de masse m et de
matrice d’inertie J, les relations 
f = ma
 i i
i M fi = Jω̇
où les fi sont les forces agissant sur le sous-système Sk , Mfi représente le moment engendré par la force fi sur
Sk , par rapport à son centre de gravité. Le vecteur a représente l’accélération tangentielle de Sk et le vecteur
ω̇ représente l’accélération angulaire de Sk . Après décomposition de ces 2 m équations vectorielles suivant
leurs composantes, on obtient 6 m équations différentielles scalaires dont certaines peuvent être dégénérées
(c’est-à-dire du type 0 = 0).
2. Suppression des composantes des forces intérieures. Dans les équations différentielles interviennent des forces,
dites de liaisons, qui sont intérieures au système mécanique global, bien qu’extérieures à chaque sous-système
qui le compose. Elles représentent l’action d’un sous-système Sk sur un autre sous-système Sℓ . D’après le
principe d’action-réaction, l’existence d’une telle force, notons la f k,ℓ , implique l’existence d’une autre force
f ℓ,k , représentant l’action de Sℓ sur Sk , telle que f ℓ,k = −f k,ℓ . Par une manipulation formelle des équations
différentielles et en prenant en compte les équations dues au principe d’action-réaction, il est possible de se
débarrasser des composantes fx , fy et fz de ces forces intérieures. Le nombre des équations différentielles
résultantes doit se réduire au nombre n de degré de liberté q1 , . . . , qn du système.
3. Obtention des équations d’état. Il nous faut alors isoler les dérivées secondes q̈1 , . . . , q̈n de l’ensemble des n
équations différentielles de façon à obtenir une relation vectorielle du type
q̈ = f (q, q̇, u) ,
où u est le vecteur des forces extérieures et ne dérivant pas d’un potentiel (c’est-à-dire, celles que nous
appliquons au système). Les équations d’état s’écrivent alors
   
d q q̇
= .
dt q̇ f (q, q̇, u)
Le lecteur intéressé par plus de détails sur la modélisation des systèmes mécaniques pourra consulter [5] et
[13]. Nous allons maintenant illustrer la méthodologie présentée sur divers exemples.

2.3.2 Modélisation d’un satellite

Considérons le satellite, représenté sur la figure ci dessous, et repéré par ses coordonnées (x1 , x2 ). Ce satellite est
en orbite autour de la terre.

Satellite en orbite autour de la terre


20 Commande par espace d’état

La loi de gravitation universelle de Newton affirme que la terre exerce une force d’attraction f sur le satellite
donnée par  
Mm Mm √ 1 x1
f = −G x2 +x2 u = − G x2 +x2 . 2 2
1 2 1 2 x1 +x2 x2
 
x1
= −G √ Mm 3 ,
x21 +x22 x2

où M est la masse de la terre, m est celle du satellite, G = 6.67 × 10−11 Nm2 kg−2 est la constante de gravitation
de Newton et u est le vecteur unitaire pointant vers le satellite. D’après la seconde loi de Newton (c’est-à-dire le
principe fondamental de la dynamique),  
dv ẍ1
f =m =m ,
dt ẍ2

où v est le vecteur vitesse du satellite. Ainsi


   
ẍ1 M x1
= −G  3 .
ẍ2 x2 + x2 x2
1 2

Puisque 
ẋ1 = x3
ẋ2 = x4 ,

les équations d’état s’écrivent 



 ẋ1 = x3


 ẋ
 2 = x4
GMx1
ẋ3 = − √ 2 23

 x1 +x2



 ẋ4 = − √GMx
2
2
2
3.
x1 +x2

2.3.3 Modélisation d’un système masses-ressorts

(a) système au repos, (b) système dans un état quelconque

On considère le système d’entrée f et de sortie z1 de la figure ci-dessus (f : force appliquée sur le deuxième
chariot, zi écart du iième chariot par rapport à sa position d’équilibre, ki raideur du iième ressort, α coefficient
de frottement visqueux). Prenons pour vecteur d’état

x = (z1 , ż1 , z2 , ż2 )T .


Modélisation des systèmes 21

Le principe fondamentale de la dynamique appliqué au chariot 2 puis au chariot 1 donne



f − αż2 − k2 (z2 − z1 ) = m2 z̈2 ,
−k1 z1 − αż1 + k2 (z2 − z1 ) = m1 z̈1 .

Nous avons donc la représentation d’état suivante


    

 0 1 0 0 0

  k +k k2   

 ẋ = 
 − m11 2
− mα1 m1 0   0 
  x + f
 0 0 0 1   0 

 k2 k2 α 1

 m 0 −m −m2 m2


2 2
 z1 = 1 0 0 0 x

qui est celle d’un système linéaire.

2.3.4 Modélisation d’un pendule simple

On considère le pendule de la figure ci dessous. L’entrée de ce système est le couple c exercé sur le pendule. La
sortie est y(t), la distance entre la masse m et l’axe vertical. Cherchons les équations d’état de ce système.

Pendule simple

D’après le principe fondamental de la dynamique,

−ℓmg sin q + c = J q̈,

où ℓ est la longueur du pendule. Or, pour notre exemple, J = mℓ2 , donc

mℓ2 q̈ + ℓmg sin q = c.

Comme indiqué au point 3 du paragraphe 2.3.1 de la page 18, nous devons prendre pour vecteur d’état x = (q, q̇).
Les équations d’état du système s’écrivent alors :
   
d q q̇
dt = −ℓmg sin q+c ,
q̇ mℓ2
(2.1)
y = ℓ sin q.

Remarque 2.3.1 L’énergie mécanique du pendule est donnée par


1 2 2
Em = mℓ q̇ + mgℓ (1 − cos q).
2     
énergie potentielle
énergie cinétique
22 Commande par espace d’état

Lorsque le couple c est nul, on a


dEm 1 2
dt = 2 mℓ (2q̇q̈)+ mgℓq̇ sin q
sin q
= mℓ2 q̇ −ℓmg
mℓ2
+ mgℓq̇ sin q = 0.
L’énergie mécanique du pendule reste donc bien constante, ce qui est cohérent avec le fait que le pendule sans
frottement est un système conservatif.

2.3.5 Modélisation d’un pendule inversé

Pendule inversé

On considère le système, appelé pendule inversé, formé d’un pendule posé en équilibre instable sur un chariot
roulant, comme représenté sur la figure. La quantité u est la force exercée sur le chariot de masse M, x indique
la position du chariot, θ est l’angle entre le pendule et la verticale et R  est la force exercée par le chariot sur le
pendule. A l’extrémité B du pendule est fixée une masse m. On négligera la masse de la tige du pendule. Enfin,
 = θ̇k est le vecteur de rotation associé à la tige.
A est le point d’articulation entre la tige et le chariot et Ω

Pour obtenir les équations d’état de ce système, nous allons à nouveau suivre la procédure présentée au paragraphe
2.3.1 de la page 18. Le principe fondamental de la dynamique appliqué sur le chariot et le pendule nous donne
(u − Rx )i = M ẍi (chariot en translation)
Rxi + Ryj − mgj = mv̇B (pendule en translation) (2.2)
Rx ℓ cos θ + Ry ℓ sin θ = 0θ̈. (pendule en rotation)
où vB est le vecteur vitesse du point B. Pour la troisième équation, le moment d’inertie du pendule a été posé
nul. Puisque
−−→
OB = (x−ℓ sin θ)i + ℓ cos θj,
nous avons  
vB = ẋ−ℓθ̇ cos θ i − ℓθ̇ sin θj.
Donc, l’accélération du point B est donnée par
 2
  2

v̇B = ẍ−ℓθ̈ cos θ + ℓθ̇ sin θ i − ℓθ̈ sin θ + ℓθ̇ cos θ j.

Après décomposition scalaire des équations de la dynamique (2.2), on obtient




 M ẍ =  u − Rx ,  (i)

 2
 Rx = m ẍ − ℓθ̈ cos θ + ℓθ̇ sin θ , (ii)
 2


 R y − mg = −m ℓθ̈ sin θ + ℓθ̇ cos θ , (iii)



Rx cos θ + Ry sin θ = 0. (iv)
Modélisation des systèmes 23

Ces quatre équations décrivent respectivement (i) le chariot en translation, (ii) le pendule en translation suivant
i, (iii) le pendule en translation suivant j et (iv) le pendule en rotation. On vérifie bien que le nombre de degré de
liberté (ici x et θ) additionné au nombre de composantes des forces intérieures (ici Rx et Ry ) est égal au nombre
d’équations. Sous forme matricielle, ces équations s’écrivent

    
M 0 1 0 ẍ u
 −m mℓ cos θ 1 0  θ̈   2
mℓθ̇ sin θ 
    
  = .
 0 mℓ sin θ 0 1  Rx   mg − mℓθ̇ 2 cos θ 
0 0 cos θ sin θ Ry 0

Donc

 −1  
    M 0 1 0 u
ẍ 1 0 0 0  −m mℓ cos θ 1 0   2
mℓθ̇ sin θ 
   
= .  . .
θ̈ 0 1 0 0  0 mℓ sin θ 0 1   mg − mℓθ̇ 2 cos θ 
0 0 cos θ sin θ 0

Ce calcul se fait aisément grâce à M


 par les instructions suivantes

B :=matrix([u,m*l*w^2*sin(a),m*g-m*l*w^2*cos(a),0])
P :=matrix([[1,0,0,0],[0,1,0,0]])
A :=matrix([[M,0,1,0],[-m,m*l*cos(a),1,0],
[0,m*l*sin(a),0,1],[0,0,cos(a),sin(a)]])
normal(P/A*B)

L’instruction normal(P/A*B) renvoie la matrice PA−1 B avec des coefficients réduits au même dénominateur.
M
 nous donne

   2   
−m sin θ(ℓθ̇ −g cos θ) ℓ
ẍ M+m sin2 θ ℓ(M+m sin2 θ)
= 2 +
cos θ u.
θ̈ sin θ((M+m)g−mℓθ̇ cos θ)
2 ℓ(M+m sin2 θ)
ℓ(M+m sin θ)

Les équations d’état s’écrivent donc

     
x ẋ 0
   θ̇   
 θ     0 
d
dt   = 

2
−m sin θ(ℓθ̇ −g cos θ) +
  ℓ  u.
 (2.3)
 ẋ   M+m sin2 θ   ℓ(M+m sin2 θ) 
2 cos θ
θ̇ sin θ((M+m)g−mℓθ̇ cos θ)
ℓ(M+m sin2 θ)
ℓ(M+m sin2 θ)
24 Commande par espace d’état

2.4 Modélisation des véhicules

2.4.1 Modélisation d’un monocycle

Le Segway possède deux roues et un seul


essieu

Le Segway représenté sur la figure est un véhicule à deux roues pour un seul essieu. Il est stable car il est régulé.
Dans une phase de modélisation, nous allons bien sûr supposer que l’engin n’est pas régulé. Son comportement
en boucle ouverte est très proche du monocycle planaire représenté sur la figure ci-dessous. Sur cette figure, u
représente le couple exercé entre le corps et la roue.

Monocycle constitué d’une roue et d’une tige liées par une liaison pivot

La liaison entre ces deux éléments est une liaison pivot. Nous noterons B le centre de gravité du corps et A celui
−→
de la roue. C est un point fixé sur le disque. Notons α l’angle entre le vecteur AC et l’horizontale et θ l’angle entre
le corps du monocycle et la verticale. Ce système possède deux degrés de liberté α et θ. D’après les explications
 
données au paragraphe 2.3.1 de la page 18, l’état de notre monocycle est donné par le vecteur x = α, θ, α̇, θ̇ .
Les paramètres de notre système sont

— pour le disque : sa masse M, son rayon a, son moment d’inertie JM ,


— pour le pendule : sa masse m, son moment d’inertie Jp , la distance ℓ entre son centre de gravité et le centre du
disque.
Modélisation des systèmes 25

Afin de trouver les équations d’état, nous appliquons le principe fondamental de la dynamique sur chaque sous-
système, à savoir la roue et le corps. Nous avons :


 −Rx + Fx = −Maα̈ (roue en translation)

 Fx a + u = JM α̈ (roue en rotation)
(2.4)

 Rxi + Ryj − mgj = mv̇B (corps en translation)


Rx ℓ cos θ + Ry ℓ sin θ − u = Jp θ̈ (corps en rotation),
où vB , le vecteur vitesse du point B. Puisque
−−→
OB = (−aα−ℓ sin θ)i + (ℓ cos θ + a) j,

par dérivation, nous obtenons  


vB = −aα̇−ℓθ̇ cos θ i − ℓθ̇ sin θj.
ou encore    
2 2
v̇B = −aα̈−ℓθ̈ cos θ + ℓθ̇ sin θ i − ℓθ̈ sin θ + ℓθ̇ cos θ j.
Après décomposition scalaire, des équations de la dynamique (2.4), on obtient


 −Rx + Fx = −Maα̈



 Fx a + u = JM α̈

2
Rx = m(−aα̈−ℓθ̈ cos θ + ℓθ̇ sin θ)

 2

 Ry − mg = −m(ℓθ̈ sin θ + ℓθ̇ cos θ)


 R ℓ cos θ + R ℓ sin θ − u = J θ̈
x y p

On vérifie bien que le nombre de degré de liberté (ici α et θ) additionné au nombre de composantes des forces
intérieures (ici Rx , Ry et Fx ) est égal au nombre d’équations. Sous forme matricielle, ces équations s’écrivent
    
Ma 0 −1 0 1 α̈ 0
 J −a     u

 M 0 0 0   θ̈   
     2 
.
 ma mℓ cos θ 1 0 0   Rx  =  mℓθ̇ sin θ 
   
 0 mℓ sin θ 0 1 0   Ry   mg − mℓθ̇ cos θ 
2

0 −Jp ℓ cos θ ℓ sin θ 0 Fx u
Donc
 −1  
Ma 0 −1 0 1 0
       
 JM 0 0 0 −a   u 
ẍ 1 0 0 0 0    2 
= . ma mℓ cos θ 1 0 0  . mℓθ̇ sin θ .
θ̈ 0 1 0 0 0   
 0 mℓ sin θ 0 1 0   2 
 mg − mℓθ̇ cos θ 
0 −Jp ℓ cos θ ℓ sin θ 0 u
Ce calcul se fait grâce à M
 par les instructions suivantes
B :=matrix([0,u,m*l*w^2*sin(T),m*g-m*l*w^2*cos(T),u])
P :=matrix([[1,0,0,0],[0,1,0,0]])
A :=matrix([[M*a,0,-1,0,1],[JM,0,0,0,-a],
[m*a,m*l*cos(T),1,0,0],[0,m*l*sin(T),0,1,0],
[0,-Jp,l*cos(T),l*sin(T),0]])
N0 :=normal(P/A*B),
N1 :=subs(N0,sin(T)^2=1-cos(T)^2)
N2 :=normal(N1)
26 Commande par espace d’état

M
 nous donne   2

 µ3 µ2 θ̇ −µg cos θ sin θ+(µ2 +µ3 cos θ)u
 α̇ = 2 2
 µ1 µ2 −µ
 3 cos θ
2

 θ̇ = µ1 µg −µ23 θ̇ cos θ sin θ−(µ1 +µ3 cos θ)u
µ1 µ2 −µ23 cos2 θ
avec
µ1 = JM + a2 (m + M) , µ2 = Jp + mℓ2 ,
µ3 = aml, µg = glm.
Les équations d’état s’écrivent donc
 
  α̇
α  θ̇ 
   
d  θ    2
 
 = µ3 µ2 θ̇ −µg cos θ sin θ+(µ2 +µ3 cos θ)u . (2.5)
dt  α̇  
  µ1 µ2 −µ 2 2
 3 cos θ


θ̇  2 2
µ1 µg −µ3 θ̇ cos θ sin θ−(µ1 +µ3 cos θ)u

µ1 µ2 −µ23 cos2 θ

2.4.2 Modélisation d’un char

Fauteuil roulant (ou char), vu de dessus

Le char (ou le fauteuil roulant) de la figure comprend deux chenilles (ou roues) parallèles motrices dont les
accélérations (qui forment les entrées u1 et u2 du système) sont commandées par deux moteurs indépendants.
Dans le cas où le fauteuil roulant est considéré, la stabilité du système est assurée par une ou deux roues folles,
non représentées sur la figure. Les variables d’état sont constituées par les coordonnées x, y du centre de l’essieu,
de l’orientation θ du char, et des vitesses
 v1 et v2 du centre de chacune des roues motrices. Remarquons que le
vecteur d’état ne peut être choisi égal à x, y, θ, ẋ, ẏ, θ̇ , ce qui pourtant nous aurait semblé naturel au regard de
la théorie lagrangienne brièvement rappelée au paragraphe 2.3.1. En, effet, si tel était notre choix, certains états
n’auraient aucune signification physique. Par exemple l’état
 
x = 0, y = 0, θ = 0, ẋ = 1, ẏ = 1, θ̇ = 0

n’a pas de sens car le char n’est pas autorisé à déraper. Ce phénomène est dû à l’existence des roues qui entraîne
des contraintes entre les variables d’état naturelles. Ici, nous avons nécessairement la contrainte de dite de non
holonomie :
ẏ = ẋ tan θ.
Les systèmes mécaniques pour lesquels il existe de telles contraintes d’égalités sur les variables d’état naturelles
(par variable d’état naturelles, nous entendons le vecteur (q, q̇) où q est le vecteur des degrés de liberté de notre
Modélisation des systèmes 27

système) sont dit non holonomes. Lorsqu’une telle situation arrive, il convient d’utiliser ces contraintes afin de
réduire le nombre de variables d’état et ceci, jusqu’à ce qu’aucune contrainte de non holonomie ne subsiste. Ici,
nous choisissons pour vecteur d’état (x, y, θ, v1 , v2 ). Ce choix se comprend aisément dans le sens où ces variables
nous permettent de dessiner le char (x, y, θ) et la connaissance de v1 ,v2 nous permet de calculer les variables ẋ, ẏ, θ̇.
De plus, tout choix arbitraire du vecteur (x, y, θ, v1 , v2 ) correspond à une situation physiquement possible. Les
équations d’état du système s’obtiennent directement sans aucun calcul.

Elles s’écrivent
   v1 +v2

ẋ 2 cos θ
 ẏ   v1 +v2
sin θ 
   2 
   v2 −v1 
 θ̇ = ℓ .
   
 v̇1   Ru1 
v̇2 Ru2

2.4.3 Modélisation d’une voiture

Voiture se déplaçant sur un plan (vue de dessus)

Le conducteur de la voiture représentée sur la figure à gauche possède deux commandes : l’accélération des
roues avant (supposées motrices) et la vitesse de rotation du volant. Le frein apparaît ici comme une accélération
négative. Nous noterons δ l’angle entre les roues avant et l’axe de la voiture, θ l’angle que fait la voiture par rapport
à l’horizontale et (x, y) les coordonnées du milieu de l’essieu arrière. En raisonnant comme dans le paragraphe
2.4.2, il est clair que les variables d’état de notre système sont constituées par

— les coordonnées de position, c’est-à-dire, toute la connaissance nécessaire pour dessiner la voiture, à savoir les
coordonnées x, y du centre de l’essieu arrière, l’orientation θ de la voiture, et l’angle δ des roues avant ;
— et la coordonnée cinématique v représentant la vitesse du milieu de l’essieu avant (en effet, la seule connaissance
de cette quantité et des coordonnées de position permet de retrouver toutes les vitesses de tous les autres
éléments de la voiture).

Obtention des équations d’état [12]. Supposons pour simplifier que les deux roues avant tournent à la même
vitesse v. Comme illustré sur la figure à droite, tout de passe comme s’il existait seulement deux roues virtuelles
situées au centre des essieux. Considérons un observateur fixe par rapport au sol. D’après la règle de composition
des vitesses, nous avons
−−→ →
vA = vM + AM ∧ −
ω,
28 Commande par espace d’état

où −

ω est le vecteur de rotation instantanée de la voiture. Dans le repère de la voiture, cette équation s’écrit :
       
v cos δ vM −L 0
       
 v sin δ  =  0  +  0  ∧  0  ,
0 0 0 θ̇

où L est la distance entre les trains avant et arrière. Soit


     
v cos δ vM 0
= + .
v sin δ 0 Lθ̇

Ainsi,
v sin δ
θ̇ = ,
L
et 
ẋ = vM cos θ = v cos δ cos θ
ẏ = vM sin θ = v cos δ sin θ.
L’équation d’évolution de la voiture s’écrit donc
   
ẋ v cos δ cos θ
 ẏ   v cos δ sin θ 
   
   v sin δ 
 θ̇  =  L . (2.6)
   
 v̇   u1 
δ̇ u2
Nous reverrons cette voiture au paragraphe 6.6 page 98 et au paragraphe 7.6 page 114 pour tenter de la réguler.

Rajoutons une remorque à cette voiture dont le point d’attache est le milieu de l’essieu arrière de la voiture. Les
équations régissant la remorque peuvent être obtenues directement à partir de celles de la voiture.

Une voiture suivie d’une remorque

En s’aidant de la figure, on obtient, pour la remorque les équations suivantes


   
ẋr vr cos δ r cos θr
   
 ẏr  =  vr cos δ r sin θr 
vr sin δ r
θ̇r Lr
avec
 
vr = ẋ2 + ẏ 2 = (v cos δ cos θ)2 + (v cos δ sin θ)2 = v cos δ,
δ r = θ − θr .
Modélisation des systèmes 29

Le paramètre Lr représente la distance entre le point d’attache et le milieu de l’essieu de la remorque. Or seule
θr doit être rajoutée comme variable d’état à celles de la voiture. En effet, il est clair que xr , yr , vr , δ r , ẋr , ẏr , . . .
peuvent être obtenues analytiquement à partir des seules connaissances de l’état de la voiture et de l’angle θr .
Ainsi, les équations d’état du système voiture-remorque sont données par
   
ẋ v cos δ cos θ
 ẏ   v cos δ sin θ 

    
 θ̇   v sin δ 
  
  =  v cos δ sin(θ−θr ) 
L
.
 θ̇r   
   Lr

 v̇   u1 
δ̇ u2

2.4.4 Modélisation d’un voilier

Bateau à voile que l’on cherche à modéliser

La figure représente le voilier que nous voulons modéliser. Le vecteur d’état x, de dimension 7, est composé

— des coordonnées de position, c’est-à-dire les coordonnées x, y du centre de gravité G du bateau (la dérive se
trouve en G), l’orientation θ, et les angles δ v et δ g de la voile et du gouvernail,
— et des coordonnées cinématiques v et ω représentant respectivement la vitesse du centre de gravité G et la
vitesse angulaire du bateau autour de G.

Les entrées u1 et u2 du système sont les dérivées des angles δ v et δ g . Les paramètres (supposés connus et constants)
sont

— V la vitesse du vent,
— rg la distance du gouvernail à G,
30 Commande par espace d’état

— rv la distance du mât à G,
— αg la portance du gouvernail (si le gouvernail se trouve perpendiculaire à la marche du bateau, l’eau exerce une
force de αg v Newton sur le gouvernail),
— αv la portance de la voile (si la voile se trouve immobile, perpendiculaire au vent, ce dernier exerce une force
de αv V Newton),
— αf le coefficient de frottement du bateau sur l’eau dans le sens de la marche (l’eau exerce sur le bateau une
force opposée au sens de la marche égale à αf v),
— αθ le coefficient angulaire de frottement (l’eau exerce sur le bateau un couple de frottement égal à −αθ ω ; étant
donné la forme du bateau, plutôt profilé pour garder un cap, αθ sera grand devant αf ),
— J le moment d’inertie du bateau,
— ℓ la distance entre le centre de poussée de la voile et le mât,
— β le coefficient de dérive (lorsque la voile du bateau est relâchée, le bateau tend à dériver, dans le sens du vent,
à une vitesse égale à βV ).

Cherchons à obtenir des équations d’état pour notre système, c’est-à-dire, une équation différentielle de la forme

ẋ = f (x, u),

où x = (x, y, θ, δ v , δg , v, ω)T et u = (u1 , u2 )T . Pour cela, nous allons utiliser le principe fondamental de la dy-
namique [14] en translation (afin d’obtenir une expression de l’accélération tangentielle v̇) puis en rotation (afin
d’obtenir une expression de l’accélération angulaire ω̇).

Accélération tangentielle v̇ : Le vent exerce sur la voile une force orthogonale à celle-ci et d’intensité égale à

fv = αv (V cos (θ + δ v ) − v sin δv ) .

Quant à l’eau, elle exerce sur le gouvernail une force égale à

fg = αg v sin δ g ,

orthogonale à celui-ci. La force de frottement qu’elle exerce sur le bateau est supposée visqueuse, c’est-à-dire
d’intensité proportionnelle à la vitesse. L’équation fondamentale de la dynamique, projetée suivant l’axe du bateau
donne
mv̇ = sin δ v fv − sin δ g fg − αf v.

L’accélération radiale peut être considérée comme nulle si nous supposons que la dérive est parfaite.

L’accélération angulaire ω̇ : Parmi les forces qui agissent sur la rotation du bateau, on trouve les forces fv et fg
exercées par la voile et le gouvernail, mais aussi une force de frottement angulaire que nous supposons visqueuse.
L’équation fondamentale de la dynamique nous donne

J ω̇ = dv fv − dg fg − αθ ω,

où 
dv = ℓ − rv cos δ v
dg = rg cos δ g .

Les équations d’état du bateau s’écrivent donc


Modélisation des systèmes 31



 ẋ = v cos θ, (i)



 ẏ = v sin θ − βV, (ii)



 θ̇ = ω, (iii)





 δ̇ v = u1 , (iv)
δ̇ g = u2 , (v) (2.7)

 fv sin δ v −fg sin δ g −αf v

 v̇ = , (vi)

 m

 ω̇ = (ℓ−rv cos δ v )fv −rg cos δ g fg −αθ ω
, (vii)

 J



 fv = αv (V cos (θ + δv ) − v sin δ v ) , (viii)

 fg = αg v sin δ g . (ix)

Notons que les deux dernières équations ne sont pas différentielles mais algébriques. Afin de coller complètement
avec une équation d’état comme définie par l’équation (1.1) de la page 13, il conviendrait de faire disparaître ces
deux équations ainsi que les deux forces internes fv et fg apparaissant dans les équations (vi) et (vii). Nous allons
toutefois les garder afin de conserver des équations relativement simples et de pouvoir visualiser ces forces lors de
nos simulations. Nous reviendrons plus tard à cet exemple du bateau à voile pour sa régulation.

2.5 Systèmes hydrauliques

2.5.1 Rappel sur la relation de Bernouilli

On considère 2 bacs disposés comme sur la figure.

Système hydraulique formé de deux bacs remplis d’eau reliés par un canal

Dans le bac de gauche, l’eau s’écoule sans frottement en direction du bac de droite. Dans le bac de gauche, l’eau
s’écoule de façon fluide, contrairement au bac de droite, où des turbulences existent. Ce sont ces turbulences qui
absorbent l’énergie cinétique de l’eau et la transforme en chaleur. Sans ces turbulences, nous aurions un éternel
mouvement de va et vient de l’eau entre les deux bacs. Dans le but d’appliquer la relation de Bernouilli dans le
bac de gauche, considérons un tube de courant, c’est à dire, une tube virtuel (voir figure) à l’intérieur duquel l’eau
possède un mouvement fluide et ne traverse pas les parois. La relation de Bernouilli nous dit que dans ce tube, en
32 Commande par espace d’état

tout point,
v2
P +ρ + ρgz = constante,
2
où P est la pression au point considéré, z son altitude, v la vitesse de l’eau en ce point. Le coefficient ρ est la
masse volumique de l’eau et g est la constante de gravitation. D’après la relation de Bernouilli, nous avons
2
vD v2
PD + ρ + ρgzD = PA + ρ A + ρgzA ,
2 2
c’est-à-dire
2
vD
PD = PA + ρg (zA − zD ) − ρ . (2.8)
2
De plus, nous pouvons supposer que C est loin de la zone de turbulence et que l’eau ne bouge pas. Ainsi, nous
avons, d’après Bernouilli
PC + ρgzC = PB + ρgzB ,

c’est-à-dire
PC = PB + ρg (zB − zC ) . (2.9)

Or, dans cette zone de turbulence, l’eau se trouve ralentie, mais nous pouvons supposer que la pression de varie
pas, c’est-à-dire, PC = PD . Ainsi, d’après (2.8) et (2.9), nous avons
2
vD
PB + ρg (zB − zC ) = PA + ρg (zA − zD ) − ρ .
2
Comme PA = PB = Patm , et que zC = zD , cette équation se traduit par
2
vD
ρg (zA − zB ) = ρ ,
2
ou encore

vD = 2g (zA − zB ).

Dans le cas ou le niveau du bac droit est supérieur à celui du bac gauche, une étude similaire nous donne

vD = − 2g (zB − zA ).

Le signe moins de l’expression indique que le courant circule maintenant du bac droit vers le bac gauche. Donc,
la relation générale pour la vitesse de l’eau dans le canal est

vD = sign (zA − zB ) 2g|zA − zB |.

Si a est la section du canal, le débit d’eau du bac droit vers le bac gauche est

QD = a.sign (zA − zB ) 2g|zA − zB |. (2.10)

2.5.2 Ecoulement dans trois bacs

Considérons maintenant le système comprenant trois bacs et représenté sur la figure.


Modélisation des systèmes 33

Système constitué de trois bacs contenant de l’eau et reliés par deux canaux

L’eau des bacs 1 et 3 peut se déverser vers le bac 2, mais aussi vers l’extérieur se trouvant à pression atmosphérique.
Les débits associés sont, d’après la relation (2.10), donnés par


Q1ext = a. 2gh1 ,

Q3ext = a. 2gh3 .

De même le débit d’un bac i vers un bac j est donné par


Qij = a.sign (hi − hj ) 2g|hi − hj |.

Les variables d’état de ce système qui peuvent être considérées sont les hauteurs dans les bacs. Pour simplifier,
nous supposerons que la surface des bacs sont toutes égales à 1 m2 , ainsi, le volume d’eau dans un bac se confond
avec la hauteur. Les équations d’état sont obtenues en écrivant que la variation du volume d’eau dans un bac est
égale à la somme des débits entrants moins la somme des débits sortants, c’est-à-dire,

ḣ1 = −Q1ext − Q12 + u1 ,


ḣ2 = Q12 − Q23 ,
ḣ3 = −Q3ext + Q23 + u2 ,

ou encore
√ 
ḣ1 = −a. 2gh1 − a.sign (h1 − h2 ) 2g|h1 − h2 | + u1
 
ḣ2 = a.sign (h1 − h2 ) 2g|h1 − h2 |
− a.sign (h2 − h3 ) 2g|h2 − h3 |

ḣ3 = −a. 2gh3 + a.sign (h2 − h3 ) 2g|h2 − h3 | + u2 .

Nous reprendrons cet exemple pour effectuer sa régulation au paragraphe 7.4 page 112.

2.5.3 Modélisation d’un vérin

On considère le vérin pneumatique avec ressort de rappel représenté sur la figure. Un tel vérin est souvent qualifié
de simple effet car l’air sous pression n’existe que dans une des deux chambres.
34 Commande par espace d’état

Vérin simple effet

Ce type de vérin est d’usage courant en robotique pour bouger les éléments mécaniques. Les paramètres de ce
système sont la raideur du ressort k, la surface du piston a et la masse m en bout de piston (les masses de tous
les autres objets sont négligées). On suppose que tout se passe à température constante T0 . Nous prendrons pour
vecteur d’état x = (z, ż, p) où z est la position du vérin, ż sa vitesse et p la pression dans la chambre. Pour
simplifier, nous supposerons que le vide règne dans la chambre du ressort et que lorsque pour z = 0 (le vérin est
en butée gauche) le ressort se trouve en position d’équilibre. L’entrée du système est le débit volumique u d’air
vers la chambre du vérin. Nous avons donc  
V
u= ṅ, (2.11)
n
où n est le nombre de moles de gaz dans la chambre et V est le volume de la chambre. Pour bien comprendre la
relation (2.11), il suffit de considérer le petit volume d’air δV qui s’apprête à entrer dans la chambre entre l’instant
t et t + δt. la loi des gaz parfait appliquée au petit volume et à la chambre, tous les deux à la même pression, nous
donne
p.δV = δn.R.T0 et p.V = n.R.T0 .
δn n V
D’où δV = V, c’est-à-dire δV = n δn. Donc
   
δV V δn V
u = = ṅ,
δt n δt n

qui se trouve être la relation (2.11). Attention, ici, nous avons approximé δn
δt par ṅ car δn correspond bien à un
accroissement de n. En revanche, nous n’aurions pas pu écrire V̇ = δVδt car δV ne correspond pas nécessairement à
un accroissement du volume V . On peut par exemple concevoir un δV positif alors que le volume V diminue. Le
principe fondamental de la dynamique nous donne pa − kz = mz̈. Donc, les deux premières équations d’état sont

ż = ż,
z̈ = ap−kz
m .

La loi des gaz parfaits (pV = nRT ) est donnée par pza = nRT . En différenciant, on obtient
 
a (ṗz + pż) = R ṅT + nṪ .

En supposant l’évolution isotherme, cette relation se traduit par


(2.11) nu
a (ṗz + pż) = RṅT = R T = pu.
V
En isolant ṗ, on obtient la troisième équation d’état pour notre système, à savoir
p u 
ṗ = − ż .
z a
Modélisation des systèmes 35

Les équations d’état du système sont donc




 ż = ż
ap−kz
z̈ = m

 ṗ = 
p u 
z a − ż

ou bien, puisque x = (z, ż, p) ,




 ẋ1 = x2
ax3 −kx1
ẋ2 = m
 ẋ = − x3 x − u  .

3 x1 2 a

2.6 Système électrique

2.6.1 Circuit RLC

Le système de la figure ci-dessous a pour entrée la tension u(t) et pour sortie la tension y(t). Cherchons à modéliser
ce système.

Circuit électrique à modéliser

Equations différentielles qui régissent le système

Soit i1 le courant électrique dans la résistance R1 (de haut en bas). D’après les lois des mailles et des nœuds, on a


 u(t) − v(t) − R1 i1 (t) = 0 (loi des mailles)
di
L dt + R2 i(t) − R1 i1 (t) = 0 (loi des mailles)

 i(t) + i1 (t) − C dv
dt = 0 (loi des nœuds).

Equations d’état pour ce système

Intuitivement on peut comprendre que la mémoire du système correspond à la charge du condensateur et au


flux électomagnétique dans la bobine. En effet, si ces quantités sont connues à l’instant t = 0, pour une entrée
connue, le futur du système est déterminé de façon unique. Ainsi des variables d’état possibles sont données par
les quantités i(t) (proportionnelle au flux) et v(t) (proportionnelle à la charge). On obtient les équations d’état en
di
cherchant à se débarrasser de i1 dans les équations précédentes et en isolant dt et dv
dt . Bien sûr, une équation doit
disparaître. On obtient

dv 1 1 1
dt = − CR1 v(t) + C i(t) + CR1 u(t)
di
dt = − L1 v(t) − RL2 i(t) + L1 u(t).
36 Commande par espace d’état

Or, la sortie est donnée par y(t) = R2 i(t). Finalement, nous arrivons à la représentation d’état d’un système
linéaire donnée par
       
1 1 1
d v(t) − CR1 C v(t) CR1
= + u(t)
dt i(t) − L1 − RL2 i(t) 1
L
 
  v(t)
y(t) = 0 R2 .
i(t)

2.6.2 Moteur à courant continu

Un moteur à courant continu peut être décrit par la figure suivante, où u est la tension d’alimentation du moteur,
i est le courant absorbé par le moteur, R est la résistance de l’induit, L est l’inductance de l’induit, e est la force
électromotrice, ρ est le coefficient de frottement dans le moteur, ω est la vitesse angulaire du moteur et Tr est le
couple exercé par le moteur sur la charge.

Moteur à courant continu

Les équations qui régissent le système sont données par


di
u = Ri + L dt + e (partie électrique)
J ω̇ = T − ρω − Tr (partie mécanique).

Or les équations d’une machine à courant continu sont e = KΦω et T = KΦi. Donc

u = Ri + L di
dt + KΦω
J ω̇ = KΦi − ρω − Tr .

Dans le cas d’un moteur à excitation indépendante, ou à aimants permanents, Φ est constant. On alors les équations
d’état linéaires suivantes 
di R KΦ u
dt = − L i − L ω + L
ρ Tr
ω̇ = KΦ J i− Jω − J

où les entrées sont u et Tr et les variables d’état sont i et ω. Ces équations peuvent s’écrire sous forme matricielle
       
d i −R L − KΦ
L i 1
L 0 u
= + .
dt ω KΦ
J − Jρ ω 0 − J1 Tr

Dans le cas d’un moteur à excitation série, le flux Φ est proportionnel à i, c’est-à-dire Φ = ki. On obtient les
équations d’état suivantes 
di R Kk u
dt = − L i − L iω + L
ρ Tr
ω̇ = Kk 2
J i − Jω − J
Modélisation des systèmes 37

qui sont devenues non-linéaires. De tels moteurs sont utilisés lorsque l’on souhaite un fort couple au démarrage,
comme par exemple pour démarrer les moteurs à explosion.

Lorsque le moteur fonctionne, le couple Tr devient imposé. La table suivante donne quelques caractéristiques
mécaniques, en régime permanent, du couple (Tr , ω).

Tr = C te moteur utilisé pour le levage


Tr = αω locomotive, mixeur, pompe
Tr = ωα machine outil (tour, fraiseuse)
Tr = αω 2 ventilateur, voiture rapide.

En fonctionnement, un moteur est donc un système qui ne possède plus qu’une seule entrée qui est la tension
d’induit u(t).

2.7 Système de Fibonacci

Bien que dans ce cours, nous ayons décidé de nous limiter aux systèmes à temps continu, nous allons, dans ce
paragraphe, modéliser un exemple de système à temps discret. Ceci permettra d’illustrer que la méthodologie
utilisée pour les systèmes à temps continus peut s’étendre aisément au cas discret.

Il s’agit d’étudier l’évolution du nombre y(k) de couples de lapins dans un élevage en fonction de l’année k. L’année
0, il y a un seulement un couple de lapins nouveau-nés dans l’élevage (donc y(0) = 1). Les lapins ne deviennent
fertiles que un an après leur naissance. Donc à l’année 1, il y a toujours un seul couple de lapins, mais ce couple
est fertile (donc y(1) = 1). Un couple fertile donne naissance chaque année à un autre couple de lapins. Donc à
l’année 2, il y a un couple de lapin fertile et un couple de nouveaux-nés. Cette évolution peut être décrite par le
tableau suivante, où N signifie nouveau né et A signifie adulte.

k=0 k=1 k=2 k=3 k=4


N A A A A
N A A
N A
N
N

Appelons x1 (k) le nombre de couples nouveaux-nés, x2 (k) le nombre de couples fertiles et y(k) le nombre total de
couples. Les équations d’état sont données par


 x1 (k + 1) = x2 (k)
x2 (k + 1) = x1 (k) + x2 (k)

 y(k) = x1 (k) + x2 (k),

avec x1 (0) = 1 et x2 (0) = 0 pour conditions initiales. Ce système est appelé système de Fibonacci. Cherchons
maintenant à trouver la relation de récurrence associée à ce système. Il nous faut pour cela exprimer y(k), y(k+1) et
38 Commande par espace d’état

y(k + 2) en fonction de x1 (k) et x2 (k). Le calcul résultant est le suivant

y(k) = x1 (k) + x2 (k),


y(k + 1) = x1 (k + 1) + x2 (k + 1) = x1 (k) + 2x2 (k)
y(k + 2) = x1 (k + 2) + x2 (k + 2) = x1 (k + 1) + 2x2 (k + 1)
= 2x1 (k) + 3x2 (k)

C’est-à-dire    
y(k) 1 1  
    x1 (k)
 y(k + 1)  =  1 2  .
x2 (k)
y(k + 2) 2 3
En éliminant x1 (k) et x2 (k) de ce système de trois d’équations linéaires, on obtient plus qu’une seule équation
donnée par
y(k + 2) − y(k + 1) − y(k) = 0.
Les conditions initiales sont y(0) = y(1) = 1. C’est généralement sous cette forme qu’est décrit le système de
Fibonacci.
Chapitre 3

Simulation

3.1 Introduction

Dans ce chapitre, nous allons montrer comment effectuer une simulation sur ordinateur d’un système non linéaire
décrit par ses équations d’état

ẋ(t) = f (x(t), u(t)),
y(t) = g(x(t), u(t)).

Cette étape est importante pour tester le comportement d’un système (régulé ou non). De plus, les techniques que
nous présenterons aux chapitres 5 et 6 nous permettront d’obtenir des équations d’état pour les régulateurs que
nous concevrons. L’ordinateur pourra nous être utile pour réaliser nos régulateurs et devra pour cela simuler ces
derniers.

Avant de présenter la méthode de simulation, nous introduirons dans les paragraphes 3.2 et 3.3 la notion de
champ de vecteur. Cette notion nous permettra de mieux comprendre la méthode de simulation qui sera présentée
au paragraphe 3.5 ainsi que certains comportements pouvant apparaître dans les systèmes non linéaires. Au
paragraphe 3.4, nous donnerons quelques notions de graphisme nécessaires à la représentation graphique de nos
systèmes. L’intérêt de l’interactivité dans les programmes de simulation ainsi que la façon de l’implémenter seront
présentés au paragraphe 3.6.

3.2 Notion de champ de vecteur

Dans ce paragraphe, nous allons présenter la notion de champ de vecteur et montrer en quoi elle est utile pour
mieux comprendre les différents comportements des systèmes. Nous invitons le lecteur à consulter l’ouvrage de
Lamnabhi-Lagarrigue [10] pour plus détails à ce sujet.

Nous appellerons champ de vecteur une fonction continue f de Rn vers Rn . Lorsque n = 2, une représentation
graphique de la fonction f peut être imaginée. Nous allons maintenant traiter deux exemples afin d’illustrer la
notion de champ de vecteur. Le premier traite le cas d’une fonction linéaire et nous permettra de donner une
interprétation graphique de la notion de vecteur propre. Pour le deuxième exemple, la fonction f représente le
gradient d’une fonction à valeur dans R.

39
40 Commande par espace d’état

Programme ChampLineaire.sce
1 a=0.5
2 x1=-2 :a :2 ; x2=-2 :a :2 ;
3 deff(’z=f1(u,v)’,’z=u+v’) ;
4 deff(’z=f2(u,v)’,’z=u-v’) ;
5 y1=feval(x1,x2,f1) ; y2=feval(x1,x2,f2) ;
6 champ(x1,x2,y1,y2) ;

Tableau 3.1: Programme pour tracer un champ de vecteur

3.2.1 Exemple d’une fonction linéaire

Considérons la fonction
2 R2 
R  → 
f: x1 x1 + x2
→ .
x2 x1 − x2
Une illustration graphique de cette fonction est donnée par la figure ci-dessous. Pour obtenir cette figure, nous
avons pris un ensemble de vecteurs de l’ensemble de départ, suivant un maillage. Puis, pour chacun des vecteurs
du maillage x, nous avons dessiné son vecteur image f (x) en lui donnant pour origine le vecteur x.

Champ de vecteur associé à une application linéaire

Le programme S qui nous a permis de faire ce dessin est donné par le tableau 3.1. Au pas 2, on définit le
maillage pour x1 et x2 , a représente la précision du maillage. Aux pas 3 et 4, on définit les fonctions coordonnées
f1 (u, v) = u + v et f2 (u, v) = u − v de notre fonction f . Ici, u et v sont des variables muettes. Le pas 5 effectue
l’évaluation de f sur tout le maillage. Enfin le pas 6 trace le champ de vecteur.

Essayons maintenant d’interpréter le champ de vecteurs représenté sur la figure. La matrice de notre application
linéaire est donnée par  
1 1
A= .
1 −1
Simulation 41

√ √
Ses valeurs propres sont 2 et − 2 et les vecteurs propres associés sont

   
0.9239 −0.3827
v1 = et v2 = .
0.3827 0.9239

Pour obtenir ce résultat sous S, il faut d’abord saisir la matrice en faisant A=[1 1 ;1 -1]. Puis on exécute
l’instruction [D,V]=bdiag(A). La matrice D contient la matrice diagonale (et donc les valeurs propres de A) alors
que V est la matrice de passage dont les colonnes sont les vecteurs propres. Notons que le vecteur x représenté
sur la figure n’est pas un vecteur propre car x et f (x) ne sont pas colinéaires. En revanche, tous les vecteurs
appartenant aux sous-espaces propres (représentés en pointillé sur la figure) sont des vecteurs propres. Le long du
sous-espace propre associé à la valeur propre négative, les vecteurs du champ tendent à pointer vers 0 alors que
ces vecteurs pointent vers l’infini le long du sous-espace propre associé à la valeur propre positive.

3.2.2 Exemple d’une fonction de type gradient

Considérons la fonction

2
R  → R
f: x1  
→ x1 exp −x21 − x22 .
x2

Son gradient est donné par

   
∂f
∂x1 (1 − 2x21 ) exp(−x21 − x22 )
∂f = .
∂x2 −2x1 x2 exp(−x21 − x22 )

Le champ de vecteur associé est donné par la figure ci-dessous. Notons que le gradient s’annule en deux points,
représentés par les petits disques noirs de la figure. Celui de droite correspond au maximum de la fonction f (le
maximum se trouve là où convergent les flèches) alors que celui de gauche correspond au minimum (là où les
flèches divergent). Notons que si nous simulons le système

   
ẋ1 (1 − 2x21 ) exp(−x21 − x22 )
= ,
ẋ2 −2x1 x2 exp(−x21 − x22 )

−−→
nous avons une forte chance de converger vers le maximum de la fonction f. Simuler le système ẋ = grad f(x),
dans le but de trouver le maximum de f correspond à la méthode du gradient.
42 Commande par espace d’état

Champ de vecteur associé au gradient une fonction scalaire f , représenté dans le plan (x1 , x2 )

3.3 Champ de vecteur associé à un système

Considérons un système autonome (c’est-à-dire sans entrée) dont l’évolution est donnée par l’équation ẋ(t) =
f (x(t)). Lorsque f est une fonction de R2 vers R2 , nous pouvons obtenir une représentation graphique de f en
traçant le champ de vecteur associé à f . Le graphique nous permettra alors de mieux comprendre le comportement
de notre système. A titre d’illustration nous allons considérer deux exemples : le système proies-prédateurs et le
pendule simple.

3.3.1 Système proies-prédateurs

Le système proies-prédateurs aussi appelé système de Lotka-Volterra est donné par



ẋ1 (t) = (1 − αx2 (t)) x1 (t)
,
ẋ2 (t) = (−1 + βx1 (t)) x2 (t)

où α = 0.01 et β = 0.02. Les variables d’état x1 (t) et x2 (t) représentent la taille des populations des proies et
des prédateurs. Le terme quadratique représente des interactions entre les deux espèces. Notons que la population
des proies augmente de façon exponentielle lorsque qu’il n’y a pas de prédateur. De même, la population des
prédateurs décroît lorsqu’il n’y a pas de proie. Pour tracer le champ de vecteur associé à la fonction d’évolution
 
(1 − αx2 (t)) x1 (t)
f (x) = ,
(−1 + βx1 (t)) x2 (t)

sur le pavé [0, 100] × [0, 200], on tape le programme du tableau 3.2 et on obtient la figure ci-dessous. Cette figure
illustre le comportement du système. En effet, l’évolution du vecteur d’état du système se fait dans le sens des
flèches (car ẋ = f (x)). Ainsi, nous pouvons comprendre que l’évolution de système est périodique et que l’état
parcourt une courbe quasi-circulaire (dont le centre est (50, 100)) dans le sens direct trigonométrique. Le point
(50, 100) semble être un point d’équilibre pour notre système. Vérifions-le par calcul. Les points d’équilibre se
Simulation 43

Programme ChampVolterra.sce
a=10 ; x1=0 :a :100 ; x2=0 :a :200 ;
deff(’z=f1(u,v)’,’z=(1-0.01*v)*u’) ;
deff(’z=f2(u,v)’,’z=(-1+0.02*u)*v’) ;
y1=feval(x1,x2,f1) ; y2=feval(x1,x2,f2) ;
champ(x1,x2,y1,y2) ;

Tableau 3.2: Programme Scilab pour tracer le champ de vecteur associé au système proies-prédateurs

trouvent là où le champ de vecteur s’annule. Il y en a deux, représentés par les petits disques noirs sur la figure.
Ils satisfont l’équation f (x) = 0, c’est-à-dire

(1 − αx̄2 )x̄1 = 0,
(−1 + β x̄1 )x̄2 = 0.
Le premier point d’équilibre est    
x̄1 0
=
x̄2 0
qui correspond à une situation où aucune des deux espèces n’existe. Le deuxième est donné par
     
1
x̄1 β 50
= 1 = ,
x̄2 α
100
qui correspond à une situation d’équilibre écologique.

Champ de vecteur associé au système de Lotka-Volterra, dans le plan (x1 , x2 )

La notion de point d’équilibre sera revue de façon plus approfondie dans le paragraphe 6.2 de la page 87.

3.3.2 Pendule simple

Considérons le pendule simple modélisé au chapitre précédent au paragraphe 2.3.4 page 21. On suppose ici que
le couple d’entrée est nul. Avec S, traçons le champ de vecteur associé à la fonction d’évolution f (x), pour
44 Commande par espace d’état

Programme ChampPendule.sce
a=0.4 ; x1=-7 :a :7 ; x2=-4 :a :4 ;
L=2 ;g=9.81 ;m=1 ;
deff(’y1=f1(x1,x2)’,’y1=x2’) ;
deff(’y2=f2(x1,x2)’,’y2=-g*sin(x1)’) ;
y1=feval(x1,x2,f1) ; y2=feval(x1,x2,f2) ;
champ(x1,x2,y1,y2) ;

Tableau 3.3: Programme pour tracer le champ de vecteur associé au pendule

u = 0, m = 1, g = 9.81 et L = 1. Le programme ChampPendule.sce, qui effectue cette tâche, est donné sur le
tableau 3.3.

Ce programme génère la figure ci-dessous.

Champ de vecteur associé au pendule simple dans le plan (θ, θ̇)

Les petits disques noirs représentent les points d’équilibre. Le premier, le troisième et le dernier correspondent à la
situation où le pendule est en bas, en équilibre stable. Le deuxième et le quatrième correspondent à la situation où
le pendule est en haut, en équilibre instable. Autour d’un point d’équilibre stable, le vecteur d’état tend à tourner
autour de ce point, formant ainsi un cycle. Si on initialise le pendule en haut de la figure (par exemple en (−7, 3)),
ce qui correspond à une situation où θ̇ est élevé, la variable θ tendra à croître indéfiniment. Cela correspond à
une situation où le pendule tourne toujours dans le sens direct trigonométrique autour de son axe et sans jamais
s’arrêter.

3.4 Représentation graphique des systèmes

Dans ce paragraphe, nous donnons quelques notions nécessaires à la représentation graphique des systèmes lors
des simulations.
Simulation 45

3.4.1 Motif

Un motif est une matrice à deux ou trois lignes (suivant que l’objet est dans le plan ou l’espace) et n colonnes
qui représentent les n sommets d’un polygone indéformable, censé représenter l’objet. Il est important que l’union
de tous les segments formés par deux points consécutifs du motif forme toutes les arêtes du polygone que l’on
souhaite représenter.

Exemple 3.4.1 Le motif M du châssis (voir figure ci-dessous) de la voiture (avec les roues arrières) est donné
par  
−1 4 5 5 4 −1 −1 0 0 −1 1 0 0 −1 1 0 0 3 3 3
(3.1)
−2 −2 −1 1 2 2 −2 −2 −3 −3 −3 −3 3 3 3 3 2 2 3 −3
Il est clair que sur le dessin de la voiture en mouvement, les roues avant peuvent bouger par rapport au châssis,
mais aussi l’une par rapport à l’autre. Elles ne peuvent donc être incorporées au motif du châssis. Pour le dessin
de la voiture, nous devrons donc utiliser 3 motifs : celui du châssis, celui de la roue avant gauche et celui de la
roue avant droit. Sous S, le motif M (ici en deux dimensions) peut être dessiné par l’instruction
xpoly(M(1, :),M(2, :)).
Sous S, M(i, :) renvoie la i ième ligne de la matrice M.

Dessin de la voiture que nous cherchons à simuler

Exemple 3.4.2 Le motif


 
0 1 1 0 0 0 1 1 0 0 0 0 1 1 1 1
 
M= 0 0 0 0 0 1 1 1 1 1 1 0 0 1 1 0  (3.2)
0 0 1 1 0 0 0 1 1 0 1 1 1 1 0 0
est associé au cube unité [0, 1]3 de R3 . Notons que ce motif dispose de 16 colonnes, alors qu’on aurait pu s’attendre
à 13 colonnes (en effet, le cube possède 12 arêtes). Cela vient du fait que pour dessiner dans l’espace toutes les
arêtes d’un cube, sans lever le stylo, nous devons nécessairement passer par un minimum de 16 sommets du cube.

Il est parfois utile de concevoir un modeleur afin de faciliter l’élaboration de nos motifs. Voici un exemple simple
de modeleur
M=[ ] ;isoview(-10,10,-10,10) ;
for k=1 :10,
M=[M,round(locate(1))] ;
xpoly(M(1, :),M(2, :)) ;
endfunction
46 Commande par espace d’état

La fonction locate(1) retourne les coordonnées du point de la fenêtre graphique cliqué à la souris. Après 10 clics,
la programme s’arrête. La matrice M contient alors les coordonnées des 10 points cliqués.

3.4.2 Matrice de rotation

Rappelons que la jième colonne de la matrice d’une application linéaire de Rn → Rn représente l’image du jième
vecteur ej de la base canonique. Ainsi, l’expression d’une matrice de rotation d’angle θ dans le plan R2 est bien
évidemment donnée (voir figure ci-dessous) par
 
cos θ − sin θ
R= . (3.3)
sin θ cos θ

En ce qui concerne les rotations dans l’espace R3 , il est important de préciser l’axe de rotation. Nous pouvons
distinguer 3 rotations principales : la rotation d’angle θ autour de l’axe Ox, celle autour de Oy et celle autour de
Oz. Les matrices associées sont respectivement données par

Rotation d’angle θ

     
1 0 0 cos θ 0 sin θ cos θ − sin θ 0
     
Rx =  0 cos θ − sin θ  , Ry =  0 1 0  et Rz =  sin θ cos θ 0  . (3.4)
0 sin θ cos θ − sin θ 0 cos θ 0 0 1

3.4.3 Coordonnées homogènes

Le dessin d’objets bidimensionnels ou tridimensionnels sur un écran nécessite une suite de transformations affines
(rotations, translations, homothéties) de la forme

Rn → Rn
fi :
x → Ai x + bi

avec n = 2 ou 3. Or, la manipulation de compositions de fonctions affines est moins aisée que celle d’applications
linéaires. L’idée la transformation en coordonnées homogènes est de transformer un système d’équations affines
en système d’équations linéaires. Remarquons tout d’abord qu’une équation affine du type y = Ax + b peut se
récrire     
y A b x
= .
1 0 1 1
Simulation 47

Nous définirons donc la transformation homogène d’un vecteur comme suit


 
x
x → xh = .
1

Ainsi, une équation du type


y = A3 (A2 (A1 x + b1 ) + b2 ) + b3 ,
où intervient la composition de 3 transformations affines pourra se récrire
   
A3 b3 A2 b2 A1 b1
yh = xh .
0 1 0 1 0 1

En nous aidant des matrices de la formule (3.4), nous pouvons écrire une fonction S pour générer une matrice
homogène de rotation de R3 autour du iième axe de la base canonique.

function R=Rot(a,i)
R=eye(4,4) ;
J=modulo([i,i+1],3)+[1,1] ;
R(J,J)=[cos(a) -sin(a) ;sin(a) cos(a)] ;
endfunction

La fonction eye génère une matrice identité de dimension 4 × 4. La fonction modulo(a,b) renvoie le reste de la
division euclidienne de a par b (puisque ici a est un vecteur, ce calcul se fait composante par composante). Le
vecteur J correspond aux indices de la matrice à modifier. Par exemple, si i = 1, alors J= [2, 3], si i = 2, alors
J= [3, 1], et si i = 3, alors J= [1, 2].

Une fonction pour générer une matrice homogène de translation d’un vecteur v dans R3 est donnée ci-dessous

function T=Trans(v)
T=eye(4,4) ;
T(1 :3,4)=v ;
endfunction

3.4.4 Dessin de la voiture

Pour dessiner le châssis de la voiture, il nous faut tout d’abord prendre le motif de la voiture (voir équation (3.1))
et le rendre homogène, en lui rajoutant une ligne de 1. Le motif M ainsi obtenu est donné par
 
−1 4 5 5 4 −1 −1 0 0 −1 1 0 0 −1 1 0 0 3 3 3
 
 −2 −2 −1 1 2 2 −2 −2 −3 −3 −3 −3 3 3 3 3 2 2 3 −3 
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1

Ensuite, il nous faut lui faire subir une rotation d’angle θ et une translation de vecteur (x, y). Pour il suffit de
multiplier M à gauche par la matrice  
cos θ − sin θ x
 
R =  sin θ cos θ y  .
0 0 1
48 Commande par espace d’état

1 function draw_voiture(x)
2 M=[-1,4,5,5,4,-1,-1,-1,0,0,-1,
3 1,0,0,-1,1,0,0,3,3,3 ;
4 -2,-2,-1,1,2,2,-2,-2,-2,-3,-3,
5 -3,-3,3,3,3,3,2,2,3,-3 ;
6 ones(1 :21)] ;
7 Rav=[-1 1 ;0 0 ;1 1] ;
8 R=[cos(x(3)),-sin(x(3)),x(1) ;
9 sin(x(3)),cos(x(3)),x(2) ;0,0,1] ;
10 M=R*M ;
11 Ravd=R*[cos(x(5)),-sin(x(5)),3 ;
12 sin(x(5)),cos(x(5)),3 ;0 0 1]*Rav ;
13 Ravg=R*[cos(x(5)),-sin(x(5)) 3 ;
14 sin(x(5)),cos(x(5)) -3 ;0 0 1]*Rav ;
15 xbasc() ;xset(’thickness’,2) ;
16 isoview(-20,40,-10,30) ;
17 xpoly(M(1, :),M(2, :)) ;
18 xpoly(Ravd(1, :),Ravd(2, :)) ;
19 xpoly(Ravg(1, :),Ravg(2, :)) ;
20 endfunction ;

Tableau 3.4: Fonction de dessin d’une voiture

Pour dessiner la roue avant gauche, on définit son motif (en coordonnées homogènes)

 
−1 1
 
M =  0 0 .
1 1

On lui affecte une rotation d’angle δ suivie d’une translation de (3, 3), puis à nouveau une rotation de θ suivi
d’une translation de (x, y). La matrice de transformation résultante est

  
cos θ − sin θ x cos δ − sin δ 3
  
 sin θ cos θ y   sin δ cos δ 3  .
0 0 1 0 0 1

Une matrice similaire peut être obtenue pour la roue avant droite. Sur ces principes, une fonction S qui
dessine la voiture dans un état donné peut être conçue. La fonction draw_voiture du tableau 3.4 en donne un
exemple. Les lignes 2 à 6 définissent le motif du châssis de la voiture et des roues arrières. La ligne 7 définit le
motif d’une roue avant.
Simulation 49

3.4.5 Dessin d’un bras manipulateur

Robot manipulateur à trois degrés de liberté

Le robot manipulateur représenté sur la figure est composé de trois bras en série. Le premier, de longueur 3, peut
pivoter en l’origine autour de l’axe Oz. Le second, de longueur 2, placé au bout du premier peut lui aussi pivoter
autour de l’axe Oz. Quant au troisième, de longueur 1, placé au bout du second, il peut pivoter autour de l’axe
formé par le second bras. Ce robot admet 3 degrés de liberté x = (α1 , α2 , α3 ), où les αi représentent les angles
formés par chacun des bras. Le motif de base choisi pour la représentation de chacun des bras est le cube unité.
Chacun des bras est supposé être un parallélépipède d’épaisseur 0.3. Afin de prendre la forme du bras, le motif
doit subir une affinité, représentée par une matrice diagonale. Ensuite, il doit subir une suite de rotations et de
translations afin de le positionner correctement.

Le tableau 3.5 représente la suite des transformations à faire subir au motif afin de représenter chaque bras.
Comme indiqué sur ce tableau, le bras 2 doit subir, au final, toutes les transformations faites au bras 1 et le bras
3 doit subir toutes celles faites au bras 2. Le tableau 3.6 donne le programme S qui simule un déplacement
de ce bras.

Bras 1 Bras 2 Bras 3


Diag(3, 0.3, 0.3) Diag(2, 0.3, 0.3) Diag(1, 0.3, 0.3)
Rotz (α1 ) Rotz (α2 ) Rotx (α3 )
Rotx (0.5) Trans(3, 0, 0) Trans(2, 0, 0)
Rotz (α1 ) Rotz (α2 )
Rotx (0.5) Trans(3, 0, 0)
Rotz (α1 )
Rotx (0.5)

Tableau 3.5: Tableau des transformations à effectuer pour chacun des bras
50 Commande par espace d’état

Programme BrasManipulateur.sce
function draw(x)
M=[0 1 1 0 0 0 1 1 0 0 0 0 1 1 1 1 ;
0 0 0 0 0 1 1 1 1 1 1 0 0 1 1 0;
0 0 1 1 0 0 0 1 1 0 1 1 1 1 0 0;
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1] ;
M=[1 0 0 0 ;0 1 0 -0.5 ; 0 0 1 -0.5 ;0 0 0 1]*M ;
M1=diag([3,0.3,0.3,1])*M ; R1=Rot(0.5,1)*Rot(x(1),3) ;
M2=diag([2,0.3,0.3,1])*M ; R2=Rot(x(2),3) ;
M3=diag([1,0.3,0.3,1])*M ; R3=Rot(x(3),1) ;
T2=Trans([3 ;0 ;0]) ; T3=Trans([2 ;0 ;0]) ;
M1=R1*M1 ; M2=R1*T2*R2*M2 ; M3=R1*T2*R2*T3*R3*M3 ;
xbasc() ;xset(’thickness’,2) ;
isoview(-4,4,-3,3) ;
xpoly(M1(1, :),M1(3, :)) ;
xpoly(M2(1, :),M2(3, :)) ;
xpoly(M3(1, :),M3(3, :))
endfunction ;
x=[0 ;1 ;0] ;w=[3 ;-1 ;7] ; dt=0.001
for k=1 :10000, x=x+dt*w ; draw(x) ;end ;

Tableau 3.6: Programme de simulation d’un bras manipulateur

3.5 Simulation

Dans ce paragraphe, nous allons présenter la méthode d’Euler pour effectuer une simulation sur ordinateur d’un
système non linéaire décrit par ses équations d’état

ẋ(t) = f (x(t), u(t)),
(3.5)
y(t) = g(x(t), u(t)).

Cette méthode est assez approximative, mais reste simple à comprendre et suffit pour décrire les comportements
de la plupart des systèmes. Après avoir brièvement présenté cette méthode, nous traiterons la simulation d’un
pendule simple puis d’une voiture.

3.5.1 Méthode d’Euler

Soit dt, un nombre très petit devant les constantes de temps du système et qui correspond à la période d’échan-
tillonnage de la méthode (par exemple dt = 0.01). L’équation d’évolution de l’équation (3.5) s’approxime par
x(t+dt)−x(t)
dt ≃ f (x(t), u(t)),

c’est-à-dire
x (t + dt) ≃ x (t) + f(x(t), u(t)).dt.
Cette équation peut être interprétée comme une formule de Taylor à l’ordre 1. On en déduit l’algorithme de
simulation (dit méthode d’Euler) du tableau 3.7. L’échantillonneur produit une interruption périodique toutes
Simulation 51

Algorithme E  (in : x0 )
1 x := x0 ; t := 0; dt = 0.01;
2 répéter
3 saisir u à l’entrée de l’ordinateur ;
4 y := g(x, u);
5 sortir y;
6 x := x + f(x, u).dt;
7 attendre une interruption de l’échantillonneur ;
8 t = t + dt;
9 éternellement.

Tableau 3.7: Algorithme de simulation par la méthode d’Euler

les dt secondes. Ainsi, si l’ordinateur est suffisamment rapide, la simulation se déroule à la même vitesse que
notre système physique. On parlera alors de simulation temps réel . Dans certaines circonstances, ce qui nous
intéresse est d’obtenir le résultat de la simulation le plus rapidement possible (par exemple pour prédire comment
va se comporter un système dans le futur). Dans ce cas, il n’est pas nécessaire de ralentir l’ordinateur pour le
synchroniser avec notre temps physique.

On appelle erreur locale la quantité

et = ||x(t + dt) − x̂(t + dt)|| sachant que x(t) = x̂(t).

où x(t+dt) est la solution exacte de l’équation différentielle ẋ = f (x, u) et x̂(t+dt) est la valeur estimée du vecteur
d’état, pour le schéma d’intégration utilisisé. Pour la méthode d’Euler, on peut montrer que et est d’ordre 1, c’est-
à-dire et = o(dt). Il existe des méthodes d’intégration plus efficaces où l’erreur locale est d’ordre 2 où plus. C’est le
cas de la méthode de Runge Kutta à l’ordre 2, qui consiste à remplacer la récurence x̂(t+dt):= x̂(t)+f (x̂(t), u(t)).dt
par   
1 3 2.dt 2.dt
x̂(t + dt) = x̂(t) + dt. .f (x̂(t), u(t) + .f x̂(t) + .f (x̂(t), u(t)), u(t + ) .
4 4 3 3
L’erreur locale et est ici d’ordre 2 et la méthode d’intégration est par conséquent beaucoup plus précise.

3.5.2 Simulation d’un pendule

On considère à nouveau le pendule de longueur ℓ de masse négligeable et portant une masse m à son extrémité
(voir paragraphe 2.3.4 page 21). Rappelons, que, en son axe, on peut exercer un couple u et que sa représentation
d’état est donnée par    
ẋ1 x2
= .
ẋ2 − gℓ sin x1 + mℓ
u
2

Le programme S PenduleSimpleLibre.sce du tableau 3.8 simule ce pendule par la méthode d’Euler. Ce
programme, qui débute en ligne 8, est composé des fonctions draw_pendule(x), qui dessine le pendule, et de la
fonction d’évolution f(x,u). Le pas 8 initialise les constantes et le vecteur initial. La boucle 9-12 lance la méthode
d’Euler.

La figure ci-dessous représente la trajectoire du pendule dans l’espace d’état pour la condition initiale θ = 1 et
θ̇ = 0. Sur cet exemple, le pendule, qui ne possède aucun frottement, devrait normalement effectuer un cycle. Or,
52 Commande par espace d’état

Programme PenduleSimpleLibre.sce
1 function draw_pendule(x)
2 xbasc() ;isoview(-4,4,-3,3) ;
3 xpoly([0,L*sin(x(1))],[0 -L*cos(x(1))])
4 endfunction ;
5 function v=f(x,u)
6 v=[x(2) ; -g/L*sin(x(1))+u/(m*L^2)] ;
7 endfunction ;
8 L=2 ;g=9.81 ;m=1 ;u=0 ;dt=0.006 ;x=[1 ;0] ;
9 for k=1 :1500,
10 draw_pendule(x) ;
11 x=x+f(x,u)*dt ;
12 end ;

Tableau 3.8: Simulation d’un pendule simple

la méthode d’Euler donne à chaque pas un peu d’énergie au pendule, ce qui explique sa trajectoire qui tend à
diverger. Cela vient du fait que le champ, bien que tangent à la trajectoire du système, tend à sortir vers l’extérieur
celle-ci. Le programme PenduleSimpleTrajectoire.sce, qui nous a permis de dessiner la figure ci-dessous, illustre
ce phénomène. Il apparaît clairement que la méthode d’Euler ne doit pas être utilisée pour simuler des systèmes
conservatifs (comme le système planétaire), qui n’ont pas de frottements et tendent à effectuer des cycles. En
revanche, pour les systèmes dissipatifs (avec frottements), une méthode d’Euler s’avère souvent suffisante pour
décrire correctement le comportement du système. Pour notre pendule, la méthode d’Euler tend à donner de
l’énergie au pendule, qui, après une dizaine d’oscillations, se met à effectuer des révolutions complètes autour de
son axe, dans le sens indirect trigonométrique.

Trajectoire du pendule dans l’espace d’état


Simulation 53

Programme VoitureLibre.sce
1 function v=f(x,u)
2 v=[x(4)*cos(x(5))*cos(x(3)) ;
3 x(4)*cos(x(5))*sin(x(3)) ;
4 x(4)*sin(x(5))/3 ; u(1) ;u(2) ] ;
5 endfunction ;
6 x=[0 ;0 ;0 ;7 ;0] ;u=[0 ;0.2] ;dt=0.02 ;
7 for k=1 :3000,
8 draw_voiture(x) ; x1=x+f(x,u)*dt ; x=x1 ;
9 end ;

Tableau 3.9: Programme de simulation d’une voiture

3.5.3 Simulation d’une voiture

Considérons à nouveau la voiture modélisée au paragraphe 2.4.3 de la page 27. Nous allons ici tenter de la simuler
et visualiser graphiquement son mouvement. Rappelons que les équations d’état de cette voiture sont données par
   
ẋ v cos δ cos θ
 ẏ   v cos δ sin θ 
   
   v sin δ 
 θ̇  =  L .
   
 v̇   u1 
δ̇ u2

A un vecteur d’état donné x = (x, y, θ, v, δ)T correspond une configuration possible pour la voiture. Le programme
complet de la simulation de la voiture est donné par le tableau 3.9. En plus de la fonction draw_voiture qui dessine
la voiture, il appelle la fonction d’évolution du système. L’état initial de la voiture est (0 0 0 7 0)T , ce qui signifie
qu’à l’instant 0, la voiture est centrée à l’origine, avec un angle nul, sa vitesse est de 7 ms−1 et les roues avant sont
parallèles à l’axe de la voiture. La commande vectorielle u(t) reste constante et égale à (0 0.2)T . Ce qui signifie que
la voiture n’accélère pas (car u1 = 0) et que le volant tourne à une vitesse constante de 0.2 rad.s−1 (car u2 = 0.2).

3.6 Ajout de l’interactivité

Au moment de tester le programme de simulation, il est fondamental de pouvoir agir sur le programme de façon à
déceler des réactions anormales du système, à comprendre mieux son comportement, à détecter d’éventuelles er-
reurs de programmation. Dans ce but, nous pouvons autoriser l’utilisateur à créer des événements (par exemple en
appuyant sur une touche du clavier, ou en bougeant la souris) qui seront interprétées par le programme grâce à un
gestionnaire d’événement (eventhandler ). Le gestionnaire d’événement tourne en parallèle avec le programme prin-
cipal. Il attend qu’un événement se produise et s’exécute dès que cela arrive. Le programme (VoitureLibre.sce)
listé et commenté ci-dessous simule une voiture avec gestion d’événement. Ce programme contient trois fonctions
et un programme principal. Lorsque l’utilisateur appuie sur une touche, la fonction my_eventhandler s’exécute
immédiatement. Cette dernière modifie une variable globale (u, sortie ou ech) en permettant ainsi à l’utilisateur
d’agir sur le programme. Afin de se rapprocher d’un comportement temps réel de notre voiture, nous chronomé-
trons, à l’aide d’un timer qui compte en microsecondes, le temps de calcul d’un parcours de la boucle while. La
valeur de ce temps de calcul est alors affectée à la variable dt.
54 Commande par espace d’état

//---------------------------------------------

function my_eventhandler(win,x,y,a)
//variable partagees avec le programme principal
global u sortie ech;
xinfo(’Volant:w,x; Acceleration:p,l; Zoom:z,Z; Fin:F’)
if ascii(a)==’l’ then u=[-500,0]; end //freinage
if ascii(a)==’p’ then u=[ 500,0]; end //acceleration
if ascii(a)==’w’ then u=[0,20]; end //a gauche
if ascii(a)==’x’ then u=[0,-20]; end //a droite
if ascii(a)==’z’ then ech=ech*0.95; end //zoom in
if ascii(a)==’Z’ then ech=ech/0.95; end //zoom out
if ascii(a)==’F’ then sortie=%T; end //fin
endfunction

//---------------------------------------------

function draw_voiture(x)
//Chassis
M=[-1 4 5 5 4 -1 -1 -1 0 0 -1 1 0 0 -1 1 0 0 3 3 3;
-2 -2 -1 1 2 2 -2 -2 -2 -3 -3 -3 -3 3 3 3 3 2 2 3 -3;
ones(1:21)] ;
Rav=[-1 1;0 0;1 1]; //motif d’une roue avant
R=[cos(x(3)),-sin(x(3)),x(1);
sin(x(3)), cos(x(3)),x(2);
0 0 1] ;
M=R*M;
Ravd=R*[cos(x(5)),-sin(x(5)) 3;
sin(x(5)),cos(x(5)) 3 ;
0 0 1]*Rav; // roue avant droite
Ravg=R*[cos(x(5)),-sin(x(5)) 3;
sin(x(5)),cos(x(5)) -3;
0 0 1]*Rav; // roue avant gauche
xbasc(); // efface l’ecran
xset(’thickness’,2); // regle l’epaisseur du stylo//
isoview(-ech,ech,-ech,ech); // regle les echelles
xpoly(M(1,:),M(2,:));
xpoly(Ravd(1,:),Ravd(2,:))
xpoly(Ravg(1,:),Ravg(2,:))
endfunction;

//---------------------------------------------

function Dx=f(x,u) //fonction d’evolution


Dx=[x(4)*cos(x(5))*cos(x(3));
Simulation 55

x(4)*cos(x(5))*sin(x(3));
x(4)*sin(x(5))/3;
u(1);
u(2) ];
endfunction;

//---------------------------------------------
//debut du programme principal
//---------------------------------------------

global u sortie ech; // partagees avec my_eventhandler


x=[0;0;0;7;0]; // etat initial
ech=60; // echelle
dt=0.002; // dt initial
u=[0;0];
sortie=%F; // variable qui faut vrai (%T) si on veut sortir
//active le gestionnaire d’evenement ’my_eventhandler’
seteventhandler(’my_eventhandler’);
while sortie==%F,
pvm_set_timer(); //initialise le chronometre
draw_voiture(x);
x=x+f(x,u)*dt; //methode d’Euler
u=[0;0];
//converti en seconde la valeur du chronometre
dt=pvm_get_timer()/1000000;
end;
seteventhandler(’ ’) //supprime le gestionnaire d’evenement
xdel(); //ferme la fenetre graphique
//---------------------------------------------
56 Commande par espace d’état
Chapitre 4

Systèmes linéaires

4.1 Introduction

Dans ce chapitre, nous allons étudier les systèmes linéaires (voir page 14, formule (1.3) et (1.4)). Les notions
présentées seront fondamentales pour la bonne compréhension des chapitres qui suivent et plus particulièrement
pour la conception de régulateurs linéaires présentée au chapitre 5. Les systèmes linéaires sont, rappelons-le, de la
forme 
ẋ(t) = Ax(t) + Bu(t)
(4.1)
y(t) = Cx(t) + Du(t),
pour les systèmes à temps continu et

x(k + 1) = Ax(k) + Bu(k)
(4.2)
y(k) = Cx(k) + Du(k),

pour les systèmes à temps discret. Nous allons tout d’abord donner une solution analytique pour ces équations
d’état au paragraphe 4.2. Ces solutions seront utilisées au paragraphe 4.2 pour établir des critères de stabilité.
Ensuite, au paragraphe 4.4, nous montrerons que la représentation d’état d’un système linéaire n’est pas unique
et comment il est possible de passer d’une représentation d’état à une autre. Enfin aux paragraphes 4.5 et 4.6,
nous expliciterons les liens forts qui existent entre la représentation entrées-sorties (utilisant la notion de matrice
de transfert) et la représentation d’état.

4.2 Solution des équations d’état

Dans ce paragraphe, nous allons chercher à calculer sous forme analytique la solution des équations d’état. Rap-
pelons que ces dernières sont composées de l’équation différentielle (4.1), dans le cas continu, ou de l’équation de
récurrence (4.2) dans le cas discret.

4.2.1 Système à temps continu

Rappel sur les exponentielles de matrices. Afin de résoudre notre équation différentielle, nous allons utiliser
la notion d’exponentielle de matrice, que nous allons brièvement rappeler. L’exponentielle d’une matrice carrée M

57
58 Commande par espace d’état

de dimension n se définit par son développement en séries entière :


1 ∞
1 1
e M
= In + M + M2 + M3 + · · · = Mi ,
2! 3! i!
i=0

où In est la matrice identité de dimension n. Il est clair que eM est de la même dimension que M. Voici quelques-
unes des propriétés importantes concernant les exponentielles de matrices. Si 0n est la matrice nulle de dimension
n × n et si M et N sont deux matrices n × n, alors
e0n = In ,
eM .eN = eM+N , (si les matrices commutent)
d
 Mt 
dt e = MeMt .

Théorème 4.2.1 Notons x(t0 ), l’état à l’instant initial t0 . Pour le système linéaire à temps continu (4.1), l’état
à l’instant t est donné par  t
A(t−t0 )
x(t) = e x(t0 ) + eA(t−τ ) Bu(τ )dτ , (4.3)
t0
et la sortie s’exprime par
 t
A(t−t0 )
y(t) = Ce x(t0 ) + CeA(t−τ ) Bu(τ )dτ + Du(t).
t0

t
La fonction CeA(t−t0 ) x(t0 ) est appelée solution homogène, libre ou transitoire. La fonction t0 CeA(t−τ ) Bu(τ )dτ +
Du(t) est appelée solution forcée.

Preuve. Posons z(t) = e−At x(t). On a donc x(t) = eAt z(t) et donc, par dérivation ẋ(t) = AeAt z(t) + eAt ż(t).
L’équation d’évolution ẋ(t) = Ax(t) + Bu(t), se transforme en
AeAt z(t) + eAt ż(t) = AeAt z(t) + Bu(t),
soit, après simplication
ż(t) = e−At Bu(t).
Après intégration, nous obtenons  t
z(t) = z (t0 ) + e−Aτ Bu(τ )dτ ,
t0
où t0 est arbitraire. Donc  
t
x(t) = eAt z (t0 ) + t0 e−Aτ Bu(τ )dτ
t
= eAt z (t0 ) + t0 eAt e−Aτ Bu(τ )dτ
t
= eAt e−At0 x(t0 ) + t0 eA(t−τ ) Bu(τ )dτ
t
= eA(t−t0 ) x(t0 ) + t0 eA(t−τ ) Bu(τ )dτ .
Pour obtenir la sortie, il suffit de noter que y(t) = Cx(t) + Du(t). 

4.2.2 Système à temps discret

Théorème 4.2.2 Notons x(k0 ) l’état à l’instant initial k0 . Pour le système linéaire à temps discret (4.2), l’état
à l’instant k est donné par
k−1

x(k) = Ak−k0 x(k0 ) + Ak−ℓ Bu(ℓ), (4.4)
ℓ=k0
Systèmes linéaires 59

et donc la sortie s’exprime par

k−1

k−k0
y(k) = CA x(k0 ) + CAk−ℓ Bu(ℓ) + Du(k).
ℓ=k0

k
De même que dans le cas continu, la fonction CA(k−k0 ) x(t0 ) est la solution homogène ℓ=k0 CA(k−ℓ) Bu(ℓ)+Du(k)
est la solution forcée.

Preuve. La preuve peut se faire aisément par récurrence. Tout d’abord, si k = k0 , la relation (4.4) est vérifiée.
Vérifions que si elle est vérifié pour k elle l’est aussi pour k + 1. On a

x(k + 1) = A.x(k) + Bu(k)


(4.4)
  
= A Ak−k0 x(k0 ) + k−1ℓ=k0 Ak−ℓ Bu(ℓ) + Bu(k)

= Ak+1−k0 x(k0 ) + k−1
ℓ=k0 A
k+1−ℓ Bu(ℓ) + Bu(k)

= Ak+1−k0 x(k0 ) + kℓ=k0 Ak+1−ℓ Bu(ℓ).

La relation est donc aussi valide pour k + 1. Pour obtenir la sortie, il suffit de noter que y(k) = Cx(t) + Du(t). 

4.3 Stabilité

4.3.1 Solution des équations d’état

Supposons que l’instant initial soit nul (c’est-à-dire t0 = 0 et k0 = 0). L’état d’un système linéaire s’exprime par
(voir équation (4.3))
 t
At
x(t) = e x(0) + eA(t−τ ) Bu(τ )dτ , (4.5)
0

pour les systèmes à temps continu et par (voir équation (4.4))

k−1

k
x(k) = A x(0) + Ak−ℓ Bu(ℓ), (4.6)
ℓ=0

pour les systèmes à temps discret. Un système linéaire est stable (appelé aussi asymptotiquement stable dans la
littérature) si, au bout d’un temps suffisamment long, l’état ne dépend plus des conditions initiales et ceci, quelles
que soient ces dernières. Cela revient à dire que

limt→∞ eAt = 0n si le système à temps continu,


(4.7)
limk→∞ Ak = 0n si le système à temps discret.

4.3.2 Critère de stabilité

Nous allons maintenant cherchez à proposer un critère de stabilité ne dépendant que de la matrice A. Pour cela,
on rappelle tout d’abord le théorème de correspondance des valeurs propres. Ensuite, nous donnerons le critère
de stabilité.
60 Commande par espace d’état

Théorème 4.3.1 Si f est un polynôme (ou plus généralement une série entière) et si A est une matrice de Rn×n .
Les vecteurs propres de A sont aussi des vecteurs propres pour f(A). De plus si les valeurs propres de A sont
{λ1 , . . . , λn } alors celles de f(A) sont {f (λ1 ) , . . . , f (λn )} .

Preuve. Soit x un vecteur propre de A de valeur propre λ. Nous allons montrer par induction que x est aussi
un vecteur propre de f(A) de valeur propre f (λ). Tout d’abord, cette propriété est vraie si f(A) = Ai . En effet,
puisque
Ai .x = A.A. . . . ..A.x = λi .x.
nous avons bien la propriété f(A).x = f(λ).x. Supposons que cette propriété soit vraie pour deux polynômes f1
et f2 , nous allons maintenant montrer qu’elle l’est aussi pour f1 + f2 et αf1 . Puisque qu’elle est vraie pour f1 et
f2 , on a
f1 (A).x = f1 (λ).x
f2 (A).x = f2 (λ).x
et donc
(f1 (A) + f2 (A)) .x = f1 (A).x + f2 (A).x = f1 (λ).x + f2 (λ).x = (f1 (λ) + f2 (λ)) .x,
(α.f1 (A)) .x = α. (f1 (A).x) = α.f1 (λ).x = (α.f1 (λ)) .x.
Par récurrence, nous pouvons en déduire que la propriété est vraie pour toutes les fonctions f (A) qui peuvent
être générées à partir des Ai par compositions d’additions et de multiplications par un scalaire, c’est-à-dire pour
les fonctions f qui sont des polynômes.

Théorème 4.3.2 Un système linéaire à temps continu est stable si et seulement si toutes les valeurs propres de
sa matrice d’évolution A sont à parties réelles strictement négatives. Un système linéaire à temps discret est stable
si et seulement si toutes les valeurs propres de A sont strictement dans le cercle unité.

 1 i
Preuve. Commençons par le cas du temps continu. Si on prend f(A) = eAt = ∞ i=0 i! (At) , le théorème 4.3.1
(que nous supposrons s’appliquer même pour des polynômes de degré infini, c’est-à-dire, des séries entières), nous
dit que les valeurs propres de eAt sont de la forme eλi t . La stabilité du système qui se traduit par la condition
limt→∞ eAt = 0n (voir (4.7)) se produit si toutes les valeurs propres eλi t de la matrice eAt convergent vers zéro,
c’est-à-dire les λi sont à parties réelles strictement négatives.
Dans le cas discret, il nous faut prendre f(A) = Ak . On aura stabilité si limk→∞ Ak = 0n , c’est-à-dire si toutes les
valeurs propres λki de la matrice Ak convergent vers zéro, c’est-à-dire si toutes les λi sont de module strictement
inférieur à un.

4.3.3 Polynôme caractéristique

Que ce soit pour les systèmes à temps continu (4.1) ou à temps discret (4.2), la position des valeurs propres de A
est d’une importance capitale pour l’étude de la stabilité d’un système linéaire. Le polynôme caractéristique d’un
système linéaire est défini comme étant le polynôme caractéristique de la matrice A qui est donné par la formule
P (s) = det (sIn − A) .
Ses racines sont les valeurs propres de A. En effet, si s est une racine de P (s), alors det (sIn − A) = 0, c’est-à-dire
qu’il existe un vecteur v non nul tel que (sIn − A) v = 0. Ce qui signifie que sv − Av = 0 ou encore Av =sv.
Donc s est une valeur propre de A. Un corollaire du théorème 4.3.2 est donc le suivant.
Systèmes linéaires 61

Corollaire 4.3.1 Un système linéaire à temps continu est stable si et seulement si toutes les racines de son
polynôme caractéristique sont à parties réelles négatives. Un système linéaire à temps discret est stable si et
seulement si toutes les racines de son polynôme caractéristique sont dans le cercle unité.

4.4 Changement de base

4.4.1 Principe

Considérons le système linéaire à temps continu donné par ses équations d’état

ẋ = Ax + Bu
(4.8)
y = Cx + Du.

Tous les développements qui vont suivre s’appliquent de la même façon au cas des systèmes linéaires à temps
discret. Posons v = P−1 x, où P est une matrice de passage (c’est-à-dire carrée et inversible). Remplaçons x par
Pv. On obtient 
Pv̇ = APv + Bu
y = CPv + Du,

c’est-à-dire 
v̇ = P−1 APv + P−1 Bu
y = CPv + Du.

Si on pose
Ā = P−1 AP, B̄ = P−1 B, C̄ = CP et D̄ = D, (4.9)

le système s’écrit

v̇ = Āv + B̄u
(4.10)
y = C̄v + D̄u

qui est bien une représentation d’état. Ainsi, un système linéaire possède autant de représentations d’état qu’il
existe de matrices de passage. Bien sûr certaines représentations sont préférables suivant l’application visée. Le
paragraphe 4.5, qui suit, décrit certaines formes remarquables.

Remarque 4.4.1 Si nous disposons de deux représentations d’état données par (4.8) et (4.10), censées représenter
un même système, la matrice de passage qui relie ces deux représentations peut être obtenue en résolvant le système
linéaire
PĀ = AP,
PB̄ = B,
C̄ = CP,

où les n2 inconnues sont les coefficients pij de la matrice de passage P. Puisque ce système est linéaire en les
coefficients pij , sa résolution est aisée. Si aucune solution n’est obtenue, il est clair que les deux représentations
ne sont pas équivalentes.
62 Commande par espace d’état

4.4.2 Exemple de changement de base

Considérons un système avec une entrée. Ainsi, la matrice B deviendra un vecteur b. Prenons pour matrice de
changement de base  
P = b | Ab | A2 b | . . . | An−1 b , (4.11)
qui sera supposée inversible. Notons que si ei désigne le vecteur ne contenant que des zéros, sauf un 1 à la position
i, on a Pei = Ai−1 b, soit
ei = P−1 .Ai−1 b. (4.12)
Ainsi,
(4.9) (4.12)
b̄ = P−1 b = e1 .
Pour l’obtention de Ā, nous écrivons,
 
Ā = ā1 | ā2 | ā3 | . . . | ān−1 | ān
(4.9)
= P−1 AP
(4.11)
 
2 3 n−1 n
= P−1 Ab | P−1 A b | P−1 A b | . . . | P−1 A b | P−1 A b
(4.12)  n 
= e2 | e3 | e4 | . . . | en | P−1 A b ,

où les āi désignent les iièmes colonnes de A. Or, le théorème de Cayley-Hamilton nous dit que

An + an−1 An−1 + · · · + a1 A + a0 I = 0.

Ainsi, en isolant An , en multipliant à gauche par P−1 et à droite par b, on obtient


 
P−1 An b = P−1 −an−1  A n−1 b + · · · − a Ab − a b
  1 0

−a0 −a0
(4.11) −1    
= P .P  . . .  =  . . .  .
−an−1 −an−1

En conclusion, après changement de base, nous obtenons une équation d’évolution du type
    

 0 0 0 −a0 1

    
  1 0 0 −a1   0 
v̇ =  ..  v+  .  u.
    . 

  0 . 0 ...   . 

 0 0 1 −an−1 0

La matrice d’évolution, est appelée matrice compagne . Une telle matrice possède une sous-diagonale composée
de un, et, sur sa dernière colonne, fait apparaître les coefficients du polynôme caractéristique.

4.5 D’une représentation d’état vers une représentation entrées-sorties

Le but de ce paragraphe est de montrer comment obtenir les équations différentielles entrée-sortie (c’est-à-dire
que l’état n’intervient pas) d’un système linéaire donné par ses équations d’état :

ẋ = Ax + Bu
y = Cx + Du.
Systèmes linéaires 63

La transformée de Laplace de la représentation d’état est donnée par



sx̂ = Ax̂ + Bû,
(4.13)
ŷ = Cx̂ + Dû.

d
La variable de Laplace est ici notée s. Elle représente l’opérateur de dérivation dt . La première équation de (4.13)
peut se récrire sx̂ − Ax̂ = Bû, c’est-à-dire sIx̂ − Ax̂ = Bû, où I est la matrice identité. D’où, en factorisant,
(sI − A) x̂ = Bû (attention, une écriture du type sx̂ − Ax̂ = (s−A) x̂ n’est pas autorisée car s est un scalaire
alors que A est une matrice). Ainsi, (4.13) est équivalent à

x̂ = (sI − A)−1 Bû,
ŷ = Cx̂ + Dû.

Donc
 
ŷ = C(sI − A)−1 B + D û. (4.14)
La matrice
G(s) = C(sI − A)−1 B + D (4.15)
est appelée matrice de transfert. Il s’agit d’une matrice de fonctions de transfert (c’est-à-dire de fonctions ra-
tionnelles en s) dont tous les dénominateurs sont des diviseurs du polynôme caractéristique PA (s) de A. En
d
multipliant de chaque côté par PA (s) et en remplaçant s par dt on obtient un système d’équations différentielles
entrées-sorties pour notre système. L’état x n’y apparaît plus.

Exemple 4.5.1 On considère le système linéaire à temps continu décrit par sa représentation d’état :
    

 1 3 1

 ẋ(t) =

2 0
x(t) +
1
u(t),
   

 1 2 2

 y(t) =

1 0
x(t) +
0
u(t).

Sa matrice de transfert G(s) est donnée par

(4.15)
G(s) = C(sI − A)−1 B + D
  −1    
1 2 s − 1 −3 1 2
= +
1 0 −2 s 1 0 (4.16)
 2 
2s +s−7
= s2 −s−6 .
s+3
s2 −s−6

Ce calcul peut être effectué directement sous S en tapant les lignes suivantes :

s=poly(0,’s’)
A=[13,20] ; B=[1,1] ; C=[12 ;10] ;
D=[2 ;0] ; I=eye(2,2)
G=C*(s*I-A)^(-1)*B+D

La première de ces lignes a pour but de créer le polynôme P (s) = s qui a pour unique racine 0. La fonction
eye(2, 2) génère une matrice identité de dimension 2 × 2. Remarquons que S est ici capable d’effectuer un
64 Commande par espace d’état

peu de calcul symbolique (la variable s est ici un symbole). Mais les capacités de S dans ce domaine ne vont
pas beaucoup plus loin. Ainsi, d’après (4.16), la relation ŷ = G(s)û s’écrit
 
 2  2s2 + s − 7
s − s − 6 ŷ = û.
s+3

d
Soit, en substituant s par dt ,

ÿ1 − ẏ1 − 6y1 = 2ü + u̇ − 7
ÿ2 − ẏ2 − 6y2 = u̇ + 3u.

Exemple 4.5.2 Considérons à nouveau le système linéaire formé deux masses reliées par un ressort introduit au
paragraphe 2.3.3 de la page 20. A partir de sa représentation d’état, la relation (4.14) nous dit que sa matrice de
transfert est
   −1  
s 0 0 0 0 1 0 0 0
   0 s 0 0   − k1 +k2 − mα1 k2
0   0 
   m1 m1   
1 0 0 0  −   .
 0 0 s 0   0 0 0 1   0 
k2 k2 1
0 0 0 s m2 0 −m 2
− mα2 m2

La matrice de transfert est donc une fonction de transfert. Pour ce calcul, S ne peut rien faire. En revanche,
il peut être effectué aisément par M
 grâce aux instructions suivantes

M :=Dom : :Matrix() ;
A :=matrix([[0,1,0,0],[-(k1+k2)/m1,-a/m1,k2/m1,0],
[0,0,0,1],[k2/m2,0,-k2/m2,-a/m2]]) ;
B :=matrix([0,0,0,1/m2]) ;
C :=matrix([1,0,0,0]) ;C :=M : :transpose(C) ;
Id :=matrix([[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,1]]) ;
G :=C*(s*Id-A)^(-1)*B ;

Nous obtenons
1
  .
m1 m2 4 m1 +m2 3 α2 k1 +k2
k2 s + α k2 s + m1 + k2 + k2 m2 s2 + α 2k2k+k
2
1
s + k1

L’équation différentielle entrée sortie est donc


 
m1 m2 d4 y 3
2 d y α2
k2 dt4 + α m1k+m
2 dt 3 + m1 + k2 + k1 +k2
k2 m2 ÿ
+α 2k2k+k
2
1
ẏ + k1 y = u.

4.6 D’une représentation entrées-sorties vers une représentation d’état

Dans ce paragraphe, nous montrons, dans le cas des systèmes linéaires monovariables (c’est-à-dire avec une seule
entrée et une seule sortie), comment obtenir une représentation d’état à partir d’une équation différentielle. Plu-
sieurs méthodes sont proposées aboutissant chacune à une forme différente.
Systèmes linéaires 65

4.6.1 Forme canonique de commande

On considère le système linéaire d’ordre 3 (bien que tout le raisonnement puisse être effectué pour un ordre
quelconque) avec une seule entrée et une seule sortie, décrit par l’équation différentielle suivante :

d3 y d2 y d2 u du
3
+ a2 2 + a1 ẏ + a0 y = b2 2 + b1 + b0 u. (4.17)
dt dt dt dt
La fonction de transfert de notre système est
b2 s2 + b1 s + b0
G(s) = .
s3 + a2 s2 + a1 s + a0
Ce qui signifie que, ŷ(s) = G(s)û(s), où ŷ et û représentent les transformées de Laplace des signaux y(t) et u(t).
On a
  1
ŷ(s) = b2 s2 + b1 s + b0 3 2
û(s),
s + a2 s + a1 s + a0
qui peut se mettre sous la forme 
1
x̂1 (s) = .û(s)
 s3 +a
2
2
2 s +a1 s+a0
ŷ(s) = b2 s + b1 s + b0 x̂1 (s).
C’est-à-dire, 
s3 x̂1 = û − a2 s2 x̂1 − a1 sx̂1 − a0 x̂1
(4.18)
ŷ = b2 s2 x̂1 + b1 sx̂1 + b0 x̂1 .
Cherchons à dessiner le câblage associé à ces deux équations. Le seul opérateur différentiel que l’on s’autorise
est l’intégrateur, de fonction de transfert 1s . On construit d’abord une chaîne de 3 intégrateurs afin de fabriquer
s3 x̂1 , s2 x̂1 et sx̂1 . Puis, on câble les deux équations (4.18). On obtient le câblage de la figure ci dessous.

Forme canonique de commande pour un système d’ordre 3

Les variables d’état de ce câblage sont les valeurs x1 , x2 , x3 mémorisées par chacun des intégrateurs (les addi-
tionneurs et les amplificateurs ne mémorisent rien). En lisant le schéma, on peut directement écrire les équations
d’état de ce système        

 ẋ1 0 1 0 x 1 0

       

  ẋ2  =  0 0 1   x2  +  0  u


 ẋ3 −a0 −a1 −a2
 x3 
1
(4.19)

   x1

  

 y = b0 b1 b2  x2  .


 x3
66 Commande par espace d’état

Rappelons que ce raisonnement peut s’appliquer afin de trouver la représentation d’état pour tout système linéaire
monovariable d’ordre n quelconque. Cette forme particulière pour la représentation d’état, qui fait apparaître dans
les matrices les coefficients de la fonction de transfert est appelée forme canonique de commande.

Remarque 4.6.1 Pour obtenir la forme canonique de commande équivalente à un système linéaire monovariable
donné, il nous faut calculer sa fonction de transfert (voir paragraphe 4.5) sous sa forme développée. Ensuite, nous
écrivons directement sa forme canonique de commande en nous influençant par exemple de la formule (4.19). La
matrice de passage peut, elle-aussi, être obtenue aisément en résolvant un système d’équations linéaires comme
expliqué en remarque 4.4.1 page 61.

4.6.2 Forme canonique d’observation

Considérons à nouveau le système décrit par l’équation

d3 y d2 y d2 u du
3
+ a2 2
+ a1 ẏ + a0 y = b2 2
+ b1 + b0 u.
dt dt dt dt

Dans le domaine de Laplace, cette équation différentielle devient

s3 ŷ + a2 s2 ŷ + a1 sŷ + a0 ŷ = b2 s2 û + b1 sû + b0 û.

En divisant de chaque côté par s3 et en isolant ŷ, nous obtenons

a2 a1 a0 b2 b1 b0
ŷ = − ŷ − 2 ŷ − 3 ŷ + û + 2 û + 3 û,
s s s s s s

c’est-à-dire   !
1 1 1
ŷ = (b2 û − a2 ŷ) + (b1 û − a1 ŷ) + (b0 û − a0 ŷ) .
s s s
De l’équation précédente, on déduit immédiatement le câblage de la figure ci dessous. Remarquons que ce schéma
ressemble étrangement à celui de la figure précédente, censé représenté le même système. On passe de l’un à
l’autre en changeant le sens des flèches, en remplaçant les additionneurs par des soudures et les soudures par des
additionneurs.

Forme canonique d’observation pour un système d’ordre 3


Systèmes linéaires 67

De ce schéma, nous pouvons directement en déduire


les équations d’état du système :
        

 ẋ1 0 0 −a0 x1 b0

        

 ẋ
 2  =  1 0−a1   x2  +  b1  u


 ẋ3 0 1 −a2  x3  b2

   x1

  

 y = 0 0 1  x2  .


 x3

Cette forme particulière pour la représentation d’état s’appelle forme canonique d’observation. Notons que la
transformation A → AT , B → CT , C → BT , nous donne la forme canonique de commande (4.19).

Cherchons à expliquer maintenant pourquoi cette transformation, qui nous fait passer de la forme canonique de
commande à celle d’observation et vice-versa, ne change pas le système. Pour cela,
 considérons le système Σ dont les
matrices d’état sont (A, B, C, D) et le système Σ′ dont les matrices d’état sont A′ = AT , B′ = CT , C′ = BT , D′ = DT
La matrice de transfert associée à Σ est
(4.15)
G(s) = C(sI − A)−1 B + D.

Celle associée à Σ′ est


(4.15)  −1 T
G′ (s) = C′ (sI − A′ )−1 B′ +D′ = BT sI − AT C + DT
  T  T
= BT (sI − A)−1 CT + DT = C(sI − A)−1 B + DT
 T
= C(sI − A)−1 B + D = GT (s).

Or G(s) est un scalaire et donc G(s) = GT (s). Ainsi, la transformation A → AT , B → CT , C → BT , D → DT ne


change pas la fonction de transfert du système si ce dernier possède une seule entrée et une seule sortie.

4.6.3 Forme modale

Système linéaire sous forme modale


68 Commande par espace d’état

Un système linéaire monovariable est sous forme modale s’il s’écrit sous la forme :

    

 λ 0 · · · 0 1

 1
 

  0 λ2 0 
···   1 

 ẋ = 
 x +  
 ..  u
 ··· ··· ··· ···   .  (4.20)



 0 ··· 0 λn 1

  

 y = c1 c2 · · · cn x + d u.

Son câblage est donné par la figure ci-dessus. La fonction de transfert du système est donnée par

G(s) = C(sI − A)−1 B + d


 
 −1 1
  s − λ1 0 ...  1 
 ..   
= c1 · · · cn  0 . 0   +d
 ··· 
... 0 s − λn 1
  
1
s−λ10 ··· 0 1
 
  0 1
s−λ2 0 ···  1  
= c1 · · · cn  .

 ···  +d
 ··· ··· .. ···  
0 ··· 0 1 1
s−λn
c1 c2 cn
= + + ··· + + d.
s − λ1 s − λ2 s − λn

Notons que son polynôme caractéristique donné par det(sI − A), c’est-à-dire

 
s − λ1 0 ··· 0
 0 s − λ2 0 ··· 
 
det   = (s − λ1 ) (s − λ2 ) . . . (s − λn )
 ··· ··· ··· ··· 
0 ··· 0 s − λn

possède pour racines les λi . Ce sont aussi les valeurs propres de A.

Remarque 4.6.2 Si nous disposons d’un système linéaire monovariable donné par sa représentation d’état et si
nous souhaitons obtenir sa forme modale, il nous faudra calculer sa fonction de transfert (voir paragraphe 4.5)
et la décomposer en éléments simples. Si tous ces éléments simples sont de première espèce (c’est-à-dire que la
c1 c2 cn
fonction de transfert a la forme s−λ 1
+ s−λ 2
+· · · + s−λ n
+d) il est possible de mettre le système sous forme modale
(attention, fréquemment, cela n’est pas possible). On peut écrire directement cette forme modale en s’influençant
par exemple de la formule (4.20). La matrice de passage P peut être obtenue aisément en résolvant un système
linéaire comme expliqué en remarque 4.4.1. Notons enfin que cette matrice P a pour colonnes les vecteurs propres
de la matrice d’évolution A.
Systèmes linéaires 69

4.6.4 Forme de Jordan

Le système décrit par les équations d’état


   
−2 1 0 0 0 0
 0 −2 1 0 0   0 
   
   
ẋ =  0 0 −2 0 0 x +  1 u
   
 0 0 0 −3 1   0 
0 0 0 0 −3 1
 
y = −2 −1 3 −4 7 x + 2u

est sous forme de Jordan car sa matrice d’évolution A est une matrice de Jordan. C’est-à-dire qu’elle est diagonale
par bloc et que chaque bloc (ici il y en a deux) possède des zéros partout, sauf sur sa diagonale, qui contient des
éléments tous égaux et sur sa sur-diagonale qui ne contient que des uns. De plus, la matrice de commande ne
possède, pour élément non nuls, que des uns (autant que de blocs), positionnés au niveau de la dernière ligne de
chaque bloc. Un câblage pour ce système est donné sur la figure ci-dessous.

Système sous sa forme de Jordan

Sa fonction de transfert est donc donnée par


3 1 2 7 4
G(s) = 2 + − 2
− 3
+ − .
s + 2 (s + 2) (s + 2) s + 3 (s + 3)2
Pour mettre un système linéaire sous sa forme Jordan (si cela est possible), on peut procéder comme expliqué en
remarque 4.6.2.

Exemple. Considérons le système décrit par les équations d’état suivantes


    
 1 1

 4 − 2 − 2 1

 ẋ =    
 4 1 −1  x +  2  u
 4 −2 2

 4


 y = 2 1 1 x.

On cherche à obtenir une représentation plus simple, c’est-à-dire, avec plus de zéros et plus de uns, afin de limiter
de nombre d’ampli-op nécéssaires à la réalisation du circuit. La décomposition sous forme de jordan de la matrice
70 Commande par espace d’état

d’évolution est  −1     


1 1 1 4 − 12 − 12 1 1 1 2 1 0
      
 2 1 2   4 1 −1  2 1 2  =  0 2 0 .
2 1 0 4 −2 2 2 1 0 0 0 3
         
P−1 A P Ā

Ainsi, la nouvelle représentation d’état est


    

 2 1 0 2


 ẋ =  0 2
  
0 x +  0 u


  0 0 3 −1

 y = 6 4 4 x.
Chapitre 5

Commande des systèmes linéaires

5.1 Introduction

Dans ce chapitre, nous allons étudier la conception de régulateurs pour les systèmes donnés par des équations
d’état linéaires. Nous montrerons dans le chapitre suivant qu’autour de points bien particuliers de l’espace d’état,
dit points de fonctionnement, de nombreux systèmes non linéaires se comportent comme de véritables systèmes
linéaires. Les techniques développées dans ce chapitre seront alors utilisées pour la commande de systèmes non
linéaires.

Considérons donc le système linéaire suivant



ẋ = Ax + Bu
(5.1)
y = Cx.

Notons m, n, p les dimensions respectives des vecteurs u, x et y. Rappelons que A est appelée matrice d’évolution,
B est la matrice de commande et C est la matrice d’observation.

Remarque 5.1.1 Nous avons ici supposé, dans un but de simplification que la matrice directe D intervenant
dans l’équation d’observation (voir 1.3 page 14) était nulle. C’est souvent le cas en pratique. Si une telle matrice
directe existe, on peut facilement s’en débarrasser. En effet, considérons le système

ẋ = Ax + Bu
y = Cx + Du,

et réalisons la nouvelle sortie z = y − Du comme indiqué sur la figure. On obtient un nouveau système dont les
équations d’état sont

ẋ = Ax + Bu
z = Cx.

On retombe dans la situation décrite par l’équation (5.1).

71
72 Commande par espace d’état

Câblage permettant de supprimer la matrice


directe D dans les équations d’état

Après avoir défini les notions fondamentales de commandabilité et d’observabilité dans les paragraphes 5.2.2 et
5.2.3, nous proposerons deux approches pour la conception de régulateurs. Tout d’abord, dans le paragraphe
5.3, nous allons supposer que l’état x est accessible à la mesure. Bien que cette hypothèse ne soit généralement
pas vérifiée, elle nous permettra d’établir les principes de la méthode par placement de pôles. Dans une deuxième
phase, nous ne supposerons plus que l’état est accessible. Il nous faudra alors développer des estimateurs d’état, au
paragraphe 5.4, capables d’estimer le vecteur état afin de pouvoir utiliser les outils développés lors de la première
phase.

Le lecteur pourra consulter l’ouvrage de Philippe de Larminat [4] pour avoir une vision large de l’ensemble des
méthodes utilisées pour la commande des systèmes linéaires. Un cours complet et pédagogique accompagné de
nombreux exercices peut être trouvé dans les livres de Maurice Rivoire et Jean-Louis Ferrier [6].

5.2 Commandabilité et observabilité

5.2.1 Rappel sur les équations linéaires

Ce petit rappel nous sera utile pour comprendre certains éléments de ce paragraphe comme par exemple les preuves
des critères de commandabilité et d’observabilité. Le système linéaire

Ax = b

où la matrice A et de rang plein admet

— une et une seule solution, donnée par x = A−1 b, si la matrice est carrée ;
— une infinité de solutions, si la matrice est rectangulaire horizontale (plus de colonnes que de lignes) ;
— au plus une solution, si la matrice est rectangulaire verticale (plus de lignes que de colonnes). Si cette dernière
 −1 T
existe, elle est donnée par x = AT A A b.

5.2.2 Commandabilité

Il existe de multiples définitions équivalentes pour la commandabilité des systèmes linéaires. Une définition simple
pour la commandabilité est la suivante.

Définition 5.2.1 Le système linéaire (5.1) est dit commandable si pour tout couple de vecteur d’état (x0 , x1 ),
on peut trouver un temps t1 et une commande u(t), t ∈ [0, t1 ], tel que le système, initialisé en x0 , atteigne l’état
x1 , à l’instant t1 .
Commande des systèmes linéaires 73

Théorème 5.2.1 (critère de commandabilité) Le système linéaire 5.1 est commandable si et seulement si
 
rang B | AB | A2 B | . . . | An−1 B = n,

c’est-à-dire que la matrice Γcom , dite de commandabilité, obtenue en juxtaposant les unes à côté des autres les n
matrices B, AB, . . . , An−1 B, est de rang plein.

La définition et le théorème sont aussi valables pour les systèmes linéaires à temps discret.

Exemple 5.2.1 Considérons le système


   
1 1 0 0 0
   
ẋ(t) =  0 1 0  x(t) +  1 0  u(t).
0 0 1 1 0

La matrice de commandabilité est donnée par


 
0 0 1 0 2 0
 
Γcom =  1 0 1 0 1 0 .
1 0 1 0 1 0

Le rang de Γcom est égal à 2 (les deux dernières lignes sont identiques) : le système est donc non commandable.
En revanche, pour une matrice de commande donnée par
 
0 0
 
B = 1 0 ,
1 1

la matrice de commandabilité devient


 
0 0 1 0 2 0
 
Γcom =  1 0 1 0 1 0 .
1 1 1 1 1 1

Le rang de Γcom est égal à trois car on peut engendrer les trois vecteurs e1 = (1 0 0)T , e2 = (0 1 0)T , e3 = (0 0 1)T
par combinaisons linéaires des vecteurs colonnes vi de C1 . En effet, e1 = v3 − v2 , e2 = v1 − v2 et e3 = v2 . Ainsi,
le système est commandable.

Preuve du critère de commandabilité. Nous allons nous limiter à donner une preuve pour les systèmes
linéaires à temps discret x(k + 1) = Ax(k) + Bu(k), la démonstration dans le cas continu n’étant pas aussi
simple. Pour cela, nous allons montrer que l’on peut imposer arbitrairement x(k + n) en jouant sur les entrées
u(k), . . . , u(k + n − 1) et ceci quel que soit x(k). Si x(k + n) peut être choisi comme on le désire, il semble clair
qu’il est possible de se diriger dans l’espace d’état, et donc que le système est commandable. Nous avons

x(k + 1) = Ax(k) + Bu(k)


x(k + 2) = Ax(k + 1) + Bu(k + 1) = A2 x(k)+ABu(k) + Bu(k + 1)
x(k + 3) = Ax(k + 2) + Bu(k + 2) = A3 x(k)+A2 Bu(k) + ABu(k + 1) + Bu(k + 2)
..
.
x(k + n) = An x(k)+An−1 Bu(k) + An−2 Bu(k + 1) + · · · + ABu(k + n − 2) + Bu(k + n − 1).
74 Commande par espace d’état

Ainsi,
 
u(k + n − 1)
 u(k + n − 2) 
 
  .. 
x(k + n) = A x(k)+ B | AB | . . . | A B 
n n−1
. 
  



Γco m  u(k + 1) 
u(k)
= An x(k) + Γcom v,
où Γcom est la matrice de commandabilité de dimension n × mp et v le vecteur de dimension mp des entrées (et
des entrées futures) que l’on cherche. Afin d’imposer x(k + n) arbitrairement, il nous faut résoudre le système de
n équations linéaires
Γcom v = x(k + n) − An .x(k)
à mp inconnues. Si Γcom est rang plein (c’est-à-dire que ses vecteurs colonnes forment une famille génératrice de
Rn ) il existe toujours au moins une solution v pour ce système. 

5.2.3 Observabilité

Une définition simple pour l’observabilité d’un système linéaire est la suivante.

Définition 5.2.2 Le système linéaire 5.1 est dit observable si la connaissance de y(t) et de u(t) pour t ∈ R nous
permet de déterminer de façon unique l’état x(t), pour tout t.

Une multitude d’autres définitions équivalentes auraient pu être données.

Théorème 5.2.2 (critère d’observabilité) Le système linéaire 5.1 est observable si


 
C
 
 CA 
rang 
 .. =n

 . 
CAn−1
c’est-à-dire que la matrice, dite d’ observabilité Γobs , obtenue en mettant les une en dessous des autres les n
matrices C, CA, . . . , CAn−1 , est de rang plein.

Ce théorème est aussi valable pour les systèmes linéaires à temps discret.

Preuve du critère d’observabilité. Pour donner une idée de la preuve de ce critère, nous allons montrer que
la connaissance des n − 1 premières dérivées des sorties et des n − 2 dérivées des entrées nous permet de retrouver
le vecteur d’état. Pour cela, dérivons n − 1 fois l’équation d’observation. Nous obtenons
y = Cx
ẏ = CAx + CBu
ÿ = CA2 x + CABu + CBu̇
..
.
y(n−1) = CAn−1 x + CAn−2 Bu + CAn−3 Bu̇ + · · · + CABu(n−3) + CBu(n−2) .
Commande des systèmes linéaires 75

Soit, sous forme matricielle


      
y C 0 0 0 0 u
 ẏ   CA   CB 0 0 0   u̇ 
      
      
 ÿ  =  CA2 x +  CAB CB 0  ü .
      
 ..   ..   .. .. ..   .. 
 .   .   . . .  . 
y (n−1) CAn−1 CAn−2 B ··· CAB CB u(n−2)

Cette équation peut s’écrire sous la forme


z = Γobs x + Φv,

où z est le vecteur de toutes les sorties et de leurs dérivées, v le vecteur de toutes les entrées et leurs dérivées,
Γobs la matrice d’observabilité et Φ la matrice restante. Le système qu’il nous faut résoudre pour retrouver l’état
x est donné par
Γobs x = z − Φv.

Cette équation admet au plus une solution si Γobs est de rang plein. L’absence de solution signifierait que v et z
sont incompatibles avec les équations de notre système, ce qui est incompatible avec nos hypothèses. Cette solution
est donnée par
 −1 T
x = ΓTobs Γobs Γobs . (z − Φv) .
 −1 T
La matrice ΓTobs Γobs Γobs s’appelle l’inverse généralisée de la matrice Γobs . Elle n’existe que si Γobs est de rang
plein.

5.2.4 Décomposition de Kalman

La décomposition de Kalman va nous permettre de mieux comprendre comment interviennent les problèmes de
commandabilité et d’observabilité dans les systèmes linéaires.

Un système linéaire peut toujours se décomposer en 4 sous-systèmes S1 , S2 , S3 , S4 où S1 est commandable et obser-


vable, S2 est non commandable et observable, S3 est commandable et non observable et S4 n’est ni commandable
ni observable. Les dépendances entre les sous-systèmes peuvent être résumées par la figure ci-dessous.

Principe de la décomposition de Kalman ;


C : commandable, O : observable, C̄ : non-commandable, Ō : non observable

Notons que sur la figure, il n’existe aucun chemin (en respectant le sens des flèches) qui mène de l’entrée u vers
un système non commandable. De même, il n’existe aucun chemin qui mène d’un système non observable vers
y. Le schéma de la figure ci-dessous montre, sous une forme développée la décomposition en 4 sous-systèmes Si ,
76 Commande par espace d’état

chacun étant associé au sous-vecteur d’état xi . D’après ce schéma, nous pouvons en déduire qu’un système linéaire
à temps continu peut toujours se mettre (après un changement de base adéquat) sous la forme suivante :
    

 A11 A12 0 0 B1

  0 A


 ẋ(t) =  22 0 0  
 0 
 
  x(t) +   u(t)
 A31 A32 A33 A34   B3 



 0 A42
 0 A44 0


 y(t) = C1 C2 0 0 x(t) + (D) u(t)

où les Aij , Bi , Cj et D sont des matrices.

Détail de la décomposition de Kalman pour les systèmes linéaires

5.3 Commande par retour d’état

5.3.1 Equation de placement de pôles

On considère le système supposé commandable ẋ = Ax + Bu et on cherche un régulateur pour ce système de la


forme u = w − Kx, où w est la nouvelle entrée. Cela suppose que x soit accessible, ce qui n’est normalement pas
le cas. Nous verrons dans le paragraphe 5.4, qui suit, comment se débarrasser de cette hypothèse gênante. Les
Commande des systèmes linéaires 77

équations d’état du système bouclé s’écrivent :

ẋ = Ax + B(w − Kx) = (A − BK)x + Bw.

Il est légitime de vouloir choisir la matrice de régulation K de façon à imposer les pôles du système bouclé. Ce
problème est équivalent à imposer le polynôme caractéristique du système. Soit Pcom (s) le polynôme désiré, que
l’on supposera bien sûr de degré n. Il nous faut résoudre l’équation polynomiale

det(sI − A + BK) = Pcom (s) (5.2)

dite de placement de pôles. Cette équation peut se traduire en n équations scalaires. Rappelons en effet que deux
polynômes de degré n et unitaires sn + an−1 s + · · · + a0 et sn + bn−1 s + · · · + b0 sont égaux si et seulement si leurs
coefficients sont tous égaux, c’est-à-dire si an−1 = bn−1 , . . . , a0 = b0 . Notre système de n équations possède m.n
inconnues qui sont les coefficients kij , i ∈ {1, . . . , m}, j ∈ {1, . . . , n}. En fait, une seule matrice solution K nous
suffit. On peut donc fixer (m − 1) éléments de K afin qu’il ne nous reste plus que n inconnues. Mais le système
obtenu n’est pas toujours linéaire. L’instruction ppol de S permet de résoudre l’équation (5.2).

Tout est simple lorsque le système possède une seule entrée. En effet, l’équation polynomiale (5.2) se traduit
forcément par un système de n équations linéaires à n inconnues qui admet une et une seule solution (car le
système est commandable).

Dans le cas où le système possède m entrées, on peut choisir K de la forme

K = K̃ + B̃K1

où les matrices K̃(m × n) et B̃(m × 1) sont choisies arbitrairement de façon à conserver la commandabilité et,
par exemple, à solliciter les entrées les moins coûteuses. La quantité K1 = (k1 , . . . , kn ) est la matrice 1 × n à
déterminer. Le système polynômial (5.2) se traduit alors par un système linéaire.

5.3.2 Résolution de l’équation de placement de pôles

Nous allons ici illustrer la résolution de l’équation polynomiale (5.2), lorsque le système n’admet qu’une seule
entrée. Les méthodes proposées ici nécessitent des calculs assez fastidieux. Un logiciel de calcul formel comme
M
 peut s’avérer bien utile. Considérons par exemple le système
   
1 4 −1 2
   
ẋ =  6 −1 3  x +  3  u,
2 2 −5 −1

que l’on cherche à stabiliser ce système par un retour d’état de la forme

u = w − Kx,

avec  
K= k1 k2 k3 .
Cherchons K de façon à ce que ce polynôme caractéristique Pcom (s) du système en boucle fermée ait pour racines
−1, −1 − 2i, −1 + 2i, c’est-à-dire,

Pcom (s) = (s + 1)(s + 1 + 2i)(s + 1 − 2i)


= s3 + 3s2 + 7s + 5.
78 Commande par espace d’état

L’équation de placement de pôles (5.2) s’écrit


      
s 0 0 1 4 −1 2  
      
det  0 s 0  −  6 −1 3  +  3  k1 k2 k3 
0 0 s 2 2 −5 −1
3 2
= s + 3s + 7s + 5,
c’est-à-dire  
s − 1 + 2k1 −4 + 2k2 1 + 2k3
 
det  −6 + 3k1 s + 1 + 3k2 −3 + 3k3  = s3 + 3s2 + 7s + 5
−2 − k1 −2 − k2 s + 5 − k3
ou encore
s3 + (2k1 + 3k2 − k3 + 5) s2 + (25k1 + 21k2 + 10k3 − 29) s
+41k1 + 72k2 + 71k3 − 129 = s3 + 3s2 + 7s + 5.
On obtient le système linéaire suivant
      
2 3 −1 k1 5 3
      
 25 21 10   k2  +  −29  =  7  .
41 72 71 k3 −129 5
Ainsi,
   −1      
k1 2 3 −1 3 5 1.4227
         
 k2  =  25 21 10   7  −  −29  =  −0.94158  .
k3 41 72 71 5 −129 2.0206
Soit  
K= 1.4227 −0.94158 2.0206 .
Nous aurions obtenir directement ce résultat en utilisant l’instruction ppol (pole placement) de S en tapant

A = [1, 4, −1; 6, −1, 3; 2, 2, −5];


B = [2; 3; −1];
K = ppol(A, B, [−1, −1 − 2 ∗ %i, −1 + 2 ∗ %i]);

5.3.3 Rajout d’un effet intégral

On considère le système ẋ = Ax + Bu + p où p est un vecteur de perturbation inconnu et constant, censé


représenter une perturbation extérieure qui n’a pu être prise en compte dans la modélisation (vent, pente du
terrain, poids des personnes dans un ascenseur, . . . ). Un régulateur par retour d’état avec effet intégral est de la
forme  t
u = −Ki (w − xc ) dt − Kx,
0
où w est la consigne et xc est un vecteur de même dimension que u représentant les variables d’état consignées
(c’est-à-dire celles que l’on souhaite commander directement par l’intermédaire de w). Cette notion de variables
consignées sera revue plus en détail au paragraphe 5.6. Le vecteur xc est relié à l’état x par la relation xc = Ex,
où E est une matrice connue. Le système en boucle fermé peut donc s’écrire par les équations suivantes


 ẋ = Ax + Bu + p
ż = w − Ex

 u = −K z − Kx.
i
Commande des systèmes linéaires 79

Les équations d’état du système bouclé s’écrivent donc



ẋ = (A − BK) x − BKi z + p
ż = w − Ex
ou, sous forme matricielle :
       
ẋ A − BK −BKi x p
= + .
ż −E 0 z w
Puisque      
A − BK −BKi A 0 B  
= − K Ki ,
−E 0 −E 0 0
le choix de K et Ki se fera par placement de pôles par l’intermédiaire de la fonction ppol de S. Pour une
consigne w et une perturbation p constantes, en régime permanent, nous avons :

0 = (A − BK) x − BKi z + p
0 = w − Ex
c’est-à-dire
w = Ex = xc
p = − (A − BK) x + BKi z
Ainsi, la condition de consigne est respectée (xc = w) et nous sommes capables de retrouver la perturbation
(p = −Ax + BKx + BKi z). Au final, les équations d’état du régulateur par retour d’état avec effet intégral sont

ż = −Ex + w
u = −Ki z − Kx.

5.4 Commande par retour de sortie

5.4.1 Principe

Principe d’un régulateur par retour de sortie


80 Commande par espace d’état

Dans ce paragraphe, nous cherchons toujours à stabiliser le système



ẋ = Ax + Bu
y = Cx
mais cette fois-ci, l’état x du système n’est plus supposé accessible à la mesure. Seules la consigne w et la sortie du
système y peuvent être utilisées par le régulateur. Nous allons chercher à estimer l’état afin de pouvoir calculer la
commande u. Pour cela, on intègre à notre régulateur un simulateur de notre système. L’erreur εy entre la sortie
du simulateur ŷ et la sortie du système y nous permet de venir corriger, par l’intermédiaire d’une matrice de
correction L, l’évolution de l’état estimé x̂. Le simulateur corrigé s’appelle observateur . Son seul rôle est de nous
donner une bonne estimation du vecteur d’état x(t) afin que l’on puisse appliquer une technique de retour d’état.
Le schéma de principe du régulateur par retour de sortie est donné sur la figure. Les inconnues du régulateur
sont les matrices K et L. Pour le calcul K nous pouvons utiliser la méthode par placement de pôles décrite
précédemment, qui consiste à résoudre det(sI − A + BK) = Pcom (s), où Pcom (s) est le polynôme caractéristique
de degré n choisi pour la dynamique de commande. Il nous reste maintenant à trouver la matrice de correction L.

5.4.2 Calcul de la matrice de correction

Afin de calculer L, extrayons du système régulé de la figure, le sous-système d’entrée u (voir figure ci-dessous).

Principe de l’observateur

Les équations d’état qui décrivent ce système sont



ẋ = Ax + Bu
d (5.3)
dt x̂ = Ax̂ + Bu − L(Cx̂ − Cx)

où le vecteur d’état est (x, x̂). Créons, uniquement par la pensée, la quantité εx = x̂ − x, comme représentée sur
la figure et prenons comme nouveau vecteur d’état : (x, εx ). En soustrayant les deux équations d’évolution dans
(5.3), nous obtenons :
d
(x̂ − x) = Ax̂ + Bu − L(Cx̂ − Cx) − Ax − Bu = A (x̂ − x) −LC(x̂ − x).
dt
Commande des systèmes linéaires 81

Ainsi, les nouvelles équations d’état s’écrivent



ẋ = Ax + Bu
ε̇x = Aεx − LCεx

c’est-à-dire, sous forme matricielle


       
ẋ A 0 x B
= + u (5.4)
ε̇x 0 A − LC εx 0

Les pôles de ce système correspondent aux valeurs propres de A et à celles de A − LC. La structure de l’équation
(5.4) nous montre que εx est un sous-vecteur d’état non commandable. Il obéit à l’équation différentielle

ε̇x = (A − LC) εx (5.5)

sur laquelle la commande u n’intervient pas. L’erreur d’estimation εx sur l’état tends vers zéro si toutes les valeurs
propres de A − LC sont à parties réelles négatives. Imposer la dynamique de l’erreur (c’est-à-dire, sa rapidité de
convergence) revient à résoudre
det (sI − A + LC) = Pobs (s),
où Pobs (s) est choisi comme on le désire, de façon à avoir les pôles requis. Puisque le déterminant d’une matrice
est égal à celui de sa transposée, cette équation est équivalente à
 
det sI − AT +CT LT = Pobs (s).

On obtient une équation de type placement de pôles (voir équation (5.2) page 77). La même méthode que celle
exposée à la section 5.3 page 76 peut donc s’appliquer pour trouver LT et donc L. On pourra donc utiliser la
fonction ppol de S.

5.4.3 Représentation d’état du régulateur

Rappelons que le régulateur possède pour vecteur d’état x̂ et pour entrées la consigne w et la sortie du système
à réguler y. La sortie du régulateur est la commande u. La représentation d’état du régulateur s’exprime par

d
dt x̂ = Ax̂ + B(w − Kx̂) − L(Cx̂ − y)
u = w − Kx̂,

ou sous forme simplifiée 


d
dt x̂ = (A − BK − LC) x̂ + Bw + Ly
u = −Kx̂ + w.
Sous forme matricielle, cette équation s’écrit :
  
   w

 d
 dt x̂ = (A − BK − LC) x̂ + B L

y
 
   w



 u = −Kx̂ + I 0 .
y

Ce sont les équations qu’il nous faut câbler ou programmer pour réguler notre système. La méthode pour fabriquer
un régulateur par retour de sortie. est récapitulée sur le tableau 5.1, où pcom et pobs sont les vecteurs des pôles
désirés pour le régulateur et pour l’observateur.
82 Commande par espace d’état

Algorithme R  KL(in : A, B, C, pcom , pobs ; out : R)


1 K :=

(A, B, pcom ) ;
 T
2 L := 

 AT , CT , pobs ;  
   w

 d
 dt x̂ = (A − BK − LC) x̂ +
 B L
y
,
3 R :=  
   w


 u =
 −K x̂ + I 0
y
.

Tableau 5.1: Calcul d’un régulateur par retour de sortie

Exemple. Considérons le système décrit par l’équation d’état suivante



ẋ = 3x + 2u
y = 4x

et cherchons un régulateur par retour de sortie qui place tous les pôles en −1. Pour trouver K et L il nous faut
résoudre
det (s − 3 + 2K) = s + 1
det (s − 3 + L.4) = s + 1
On obtient donc K = 2 et L = 1. Le régulateur recherché est donc donné par

d
R := dt x̂ = −3x̂ + 2w + y
u = −2x̂ + w

Le système bouclé est décrit par les équations d’évolution suivantes



ẋ = 3x − 4x̂ + 2w
d
dt x̂ = 4x − 5x̂ + 2w.

On peut alors vérifier que les pôles de ce système sont bien ceux qui nous avions placés (à savoir −1 et −1). Ce
phénomène est expliqué dans le paragraphe suivant.

5.5 Principe de séparation

Les pôles pcom placés pour la conception du régulateur par retour d’état et ceux pobs placés pour l’observateur
sont-ils bien les pôles du système en boucle fermée ? Le but de ce paragraphe est de répondre (positivement) à
cette question.

5.5.1 Equation d’état du système bouclé

Les équations d’évolution associées au système bouclé d’entrée w et de sortie y sont données par

ẋ = Ax + B (w − Kx̂)
dx̂ (5.6)
dt = (A − BK − LC) x̂ + LCx + Bw.
Commande des systèmes linéaires 83

Insistons sur le fait que le système bouclé possède pour vecteur d’état ceux du système, rangés dans x, et ceux du
régulateur rangés dans x̂. Son vecteur d’état est donc donné par (xT x̂T )T . Sous forme matricielle, (5.6) s’écrit
      
d x A −BK x B
= + w
dt x̂ LC A − BK − LC x̂ B

5.5.2 Changement de base

Posons εx = x̂ − x. Puisque     
x I 0 x
=
εx −I I x̂
ou de façon équivalente     
x I 0 x
= ,
x̂ I I εx
un autre vecteur d’état possible pour le système bouclé est (x, εx ). Les équations d’état deviennent après change-
ment de base
         
ẋ I 0 A −BK I 0 x I 0 B
= + w
ε̇x −I I LC A − BK − LC I I εx −I I B
ou encore       
ẋ A − BK −BK x B
= + w (5.7)
ε̇x 0 A − LC εx 0

Notons que l’entrée w ne peut pas agir sur εx , ce qui est compatible avec le fait que εx n’est toujours pas
(voir équation 5.5) un sous-vecteur commandable (le fait de boucler le système ne peut, bien sûr, pas rendre
commandable une variable d’état non commandable).

5.5.3 Polynôme caractéristique

Le polynôme caractéristique du système bouclé est


    
A − BK −BK sI − A + BK BK
P (s) = det sI− = det
0 A − LC 0 sI − A + LC
= det (sI − A + BK) . det (sI − A + LC) = Pcom (s).Pobs (s).

Donc les pôles du système bouclé sont constitués des pôles placés pour la commande et des pôles placés pour
l’observation. C’est le principe de séparation.

5.6 Insertion d’un précompensateur

L’algorithme présenté sur le tableau 5.1 page 82 pour synthétiser un régulateur nous assure que si le vecteur de
consigne w est nul, l’état du système x va converger vers 0 avec une dynamique déterminée par les pôles placés.
Lorsque w n’est plus nul, l’état converge vers une valeur qui n’est plus forcément nulle. Un précompensateur est
une matrice carrée H, que l’on place juste après le vecteur de consigne, comme sur la figure.
84 Commande par espace d’état

Insertion d’un précompensateur

Ce précompensateur ne change pas les pôles du système bouclé. Il permet de mettre en correspondance certaines
composantes de la consigne avec certaines variables d’état préalablement choisies. Les équations d’évolution du
système bouclé (voir équation (5.7) où w a été remplacé par Hw) sont
      
d x A − BK −BK x BH
dt = + w.
εx 0 A − LC εx 0

Si w(t) est une constante w̄, une fois atteint le point d’équilibre, nous avons

    
A − BK BK x̄ BH
0 = + w̄.
0 A − LC ε̄x 0
Puisque (A − LC) est inversible (car tous les pôles placés pour l’observateur sont strictement stables), ε̄x est
nécessairement nul. L’équation précédente devient

(A − BK) x̄ + BHw̄ = 0.

Puisque A − BK est aussi inversible (car tous les pôles placés pour la commande sont strictement stables), nous
avons
x̄ = − (A − BK)−1 BHw̄. (5.8)
On appelle variables consignées, xc un ensemble de m variables d’état (où m = dim(w) = dim (u)) pour lesquelles
on souhaiterait que, pour w = w̄ constant, xc converge vers x̄c = w̄. Supposons que ces variables puissent être
obtenues par une combinaison linéaire des composantes de x par une relation du type

xc = Ex,

où E est une matrice m × n, dite de consigne. A l’équilibre, nous avons,


(5.8)
x̄c = Ex̄ = − E (A − BK)−1 BHw̄.

Ainsi  −1
x̄c = w̄ ⇔ −E (A − BK)−1 BH = I ⇔ H = − E (A − BK)−1 B .
Commande des systèmes linéaires 85

L’insertion d’un précompensateur permet donc d’assigner à chacune des consignes, constituant w, une variable
d’état particulière. Les variables ainsi consignées peuvent être alors commandées indépendamment les unes des
autres. L’algorithme du tableau 5.2 récapitule la méthode permettant de calculer un régulateur par retour de
sortie avec précompensateur. La fonction S associée est donnée par le tableau 5.3.

Algorithme R  KLH(in : A, B, C, E, pcom , pobs ; out : R)


1 K :=

(A, B, pcom ) ;
 T
2 L :=

 AT , CT , pobs ;
 −1
3 H := − E (A − BK)−1 B ;
  
   w

 d
 dt x̂ = (A − BK − LC) x̂ +
 BH L
y
4 R :=  
   w


 u =
 −K x̂ + H 0
y
.

Tableau 5.2: Algorithme de calcul d’un régulateur par retour de sortie avec précompensateur

function [Ar,Br,Cr,Dr]=RegulKLH(A,B,C,E,pcom,pobs) ;
K=ppol(A,B,pcom)
L=ppol(A’,C’,pobs)’
H=-inv(E*inv(A-B*K)*B)
Ar=A-B*K-L*C
Br=[B*H L]
Cr=-K
Dr=[H,zeros(C*B)]
endfunction ;

Tableau 5.3: Fonction Scilab permettant de construire un régulateur pour un système linéaire
86 Commande par espace d’état
Chapitre 6

Commande linéaire des systèmes non


linéaires

6.1 Introduction

Au chapitre 5, nous avons montré comment concevoir des régulateurs pour les systèmes linéaires. Or, en pratique,
les systèmes sont rarement linéaires. En revanche si leur vecteur d’état reste localisé dans une zone de petite taille
de l’espace d’état, le système peut être assimilé à un système linéaire et les techniques développées au chapitre
5 peuvent alors être utilisées. Dans le paragraphe 6.2, nous allons tout d’abord montrer comment linéariser un
système non linéaire autour d’un point donné de l’espace d’état. Ensuite, au paragraphe 6.3, nous montrerons
comment stabiliser les systèmes non linéaires par les régulateurs proposés au chapitre précédent. Quelques exemples
illustratifs seront alors traités en détail aux paragraphes 6.4, 6.5 et 6.6.

6.2 Linéarisation d’un système

6.2.1 Rappel sur la linéarisation d’une fonction

Soit f : Rn → Rp une fonction différentiable. Au voisinage d’un point x̄ ∈ Rn le développement de Taylor de f au


premier ordre autour de x̄ nous donne
df
f (x) ≃ f (x̄) + (x̄) (x − x̄) , (6.1)
dx
avec  
∂f1 ∂f1 ∂f1
∂x1 (x̄) ∂x2 (x̄) . . . ∂xn (x̄)
 ∂f2 ∂f2 ∂f2 
df  ∂x1 (x̄) ∂x2 (x̄) . . . ∂xn (x̄) 
(x̄) = 
 .. .. .. .

dx  . . . 
∂fp ∂fp ∂fp
∂x1 (x̄) ∂x2 (x̄) . . . ∂xn (x̄)
Cette matrice est appelée matrice jacobienne. Considérons par exemple la fonction
   
x1 x21 x2
f = .
x2 x21 + x22

87
88 Commande par espace d’état

La matrice jacobienne de f en x est


   
∂f1 ∂f1
df ∂x1 (x) ∂x2 (x) 2x1 x2 x21
(x) = ∂f2 ∂f2 = .
dx ∂x1 (x) ∂x2 (x) 2x1 2x2

Autour du point x̄ = (1, 2), on a, d’après (6.1),


        
x1 2 4 1 x1 − 1 −4 + 4x1 + x2
f ≃ + = .
x2 5 2 4 x2 − 2 −5 + 2x1 + 4x2

Le calcul de matrice jacobienne est facilité par le calcul formel. M


 peut ainsi d’obtenir cette matrice par les
instructions suivantes :
export(linalg)
J :=jacobian([x1^2*x2,x1^2+x2^2],[x1,x2])
J0 :=subs(J(x1,x2),x1=1,x2=2)
où J et J0 représentent respectivement les matrices
   
df 2x1 x2 x21 df 4 1
(x) = et (x̄) = .
dx 2x1 2x2 dx 2 4

6.2.2 Linéarisation du système autour d’un point

Considérons le système décrit par ses équations d’état



ẋ = f (x, u)
S:
y = g(x, u),

où x est de dimension n, u est de dimension m et y est de dimension p. Posons


   
x f(x, u)
z= et h(x, u) = .
u g(x, u)

La fonction h (x, u) sera appelée la fonction d’évolution/observation. Autour du point z̄ = (x̄, ū), nous avons
dh
h(z) ≃ h(z̄) + (z̄) (z − z̄) ,
dz
avec  
∂h1 ∂h1
∂z1 (z̄) ∂z2 (z̄) . . .
dh  ∂h2
(z̄) ∂h2
(z̄) . . . 
(z̄) =  ∂z1 ∂z2 .
dz .. ..
. .
Cette matrice jacobienne peut se mettre sous la forme
 
dh A B
(z̄) = ,
dz C D

où A, B, C, D sont respectivement de dimension n × n, n × m, p × n et p × m. Notons que cette définition pour les


matrices A, B, C, D est équivalente à la suivante, plus classique :
∂f ∂f
A= ∂x (x̄, ū) , B = ∂u (x̄, ū) ,
∂g ∂g
C= ∂x (x̄, ū) , D = ∂u (x̄, ū) .
Commande linéaire des systèmes non linéaires 89

Ainsi, autour du point z̄ = (x̄, ū), nous avons


 
f (x, u)
= h(x, u)
g(x, u)
 
dh x − x̄
≃ h(x̄, ū) + (z̄)
dz u − ū
    
f (x̄, ū) A B x − x̄
= + .
g(x̄, ū) C D u − ū

Autour du point (x̄, ū), le comportement de S s’approxime donc par les équations d’état suivantes :

ẋ = f (x̄, ū) + A (x − x̄) + B (u − ū)
y = g(x̄, ū) + C (x − x̄) + D (u − ū) .

Il s’agit d’un système affine (car sa fonction d’évolution/observation est affine) qui est appelé système tangent à
S au point (x̄, ū).

6.2.3 Linéarisation du système autour d’un point de fonctionnement

Un point (x̄, ū) est un point de fonctionnement (aussi appelé point de polarisation) si f (x̄, ū) = 0. Si ū = 0, on
parle de point d’équilibre. Remarquons tout d’abord que si x = x̄ et si u = ū, alors ẋ = 0, c’est-à-dire que le
système n’évolue plus si on maintient la commande u = ū et s’il est dans l’état x̄. Dans ce cas, la sortie y a pour
valeur y = ȳ = g(x̄, ū). Autour du point de fonctionnement (x̄, ū), le système S admet pour système tangent :

ẋ = A (x − x̄) + B (u − ū)
y = ȳ + C (x − x̄) + D (u − ū) .

Posons u" = u − ū, x


" = x − x̄ et y
" = y − ȳ. Ces vecteurs sont appelés les variations de u, x et y. Pour des petites
variations u
", x
", y
", on a

d
" = A"
dt x x + B"u
" = C"
y x + D"u.

Le système ainsi formé est appelé système linéarisé de S autour du point de fonctionnement (x̄, ū).

6.2.4 Exemple du système proies-prédateurs

Considérons à nouveau le système proies-prédateurs de Lotka-Volterra, déjà vu au paragraphe 3.3.1 page 42, et
donné par

ẋ1 = (1 − αx2 ) x1
S:
ẋ2 = (−1 + βx1 ) x2 .

Rappelons que
   
1
x̄1 β
= 1 .
x̄2 α
90 Commande par espace d’état

est un point d’équilibre. Autour de ce dernier,

df
f (x) ≃ f (x̄) + (x̄) (x − x̄)
 dx  
1 − αx̄2 −αx̄1 x1 − x̄1
=
β x̄2 −1 + β x̄1 x2 − x̄2
  
0 − αβ x1 − β1
= β .
α 0 x2 − α1

Le système linéarisé s’obtient en posant x


"1 = x1 − x̄1 et x
"2 = x2 − x̄2 . Il est donné par
 
d 0 − αβ
"=
x β ".
x
dt α 0

Les valeurs propres s’obtiennent en calculant les racines du polynôme caractéristique. Puisque
 
α
s
det β
β = s2 + 1,
−α s

les valeurs propres sont ±i. Elles correspondent à un système oscillant. Sous M
 le calcul précédent se traduit
par :
export(linalg)
J :=jacobian([(1-a*x2)*x1,(-1+b*x1)*x2],[x1,x2])
J0 :=subs(J(x1,x2),x1=1/b,x2=1/a)
charpoly(J0,s)
où charpoly(J0,s) calcule le polynôme caractéristique de la matrice J0.

6.2.5 Exemple du pendule simple

On rappelle (voir page 21) que les équations d’état d’un pendule simple sont données par
    

 ẋ1 x2
= f (x, u) = −ℓmg sin x1 +u
ẋ2 mℓ2


y = g(x, u) = ℓ sin x1 .

Puisque la matrice jacobienne de h(x, u), la fonction évolution/observation, est


 
0 1 0
dh  1 
(x, u) =  −g cos

x1
0 mℓ 2 ,
d(x,u)
ℓ cos x1 0 0

au point (x̄ = (0, 0),ū = 0), le système linéarisé est décrit par les équations d’état suivantes :
    

 0 1 0
 ẋ = x+ u
− gℓ 0 1
mℓ 2
  

 y = ℓ 0 x.
Commande linéaire des systèmes non linéaires 91

Sous M
 , ce calcul peut être effectué grâce aux instructions suivantes :

export(linalg)
J :=jacobian([x2,(-l*m*g*sin(x1)+u)/(m*l^2),l*sin(x1)]
,[x1,x2,u])
J0 :=subs(J(x1,x2,u),x1=0,x2=0,u=0)
simplify(J0)

6.2.6 Exemple du vérin

On considère à nouveau le vérin modélisé au paragraphe 2.5.3 de la page 33. Ses équations d’état sont données
par 

 ẋ1 = x2
ax3 −kx1
S: ẋ2 = m
 ẋ = − x3 x − u  .

3 x1 2 a

Supposons que x1 > 0 et calculons l’ensemble des points de fonctionnement (x̄, ū) possibles pour S. La condition
ẋ = 0 donne 

 x2 = 0
ax3 − kx1 = 0
 x x − u 

= 0
1 2 a
soit 

 x2 = 0
ax3 − kx1 = 0

 u = 0
Les points de fonctionnement sont donc de la forme
 
k
(x̄, ū) = x̄1 , 0, x̄1 , 0 .
a

Différencions maintenant S autour du point de fonctionnement (x̄, ū) afin d’en obtenir une approximation affine.
Sous M
 , on tape

export(linalg)
J :=jacobian([x2,(a*x3-k*x1)/m,-(x3/x1)*(x2-u/a)]
,[x1,x2,x3,u])
J0 :=subs(J(x1,x2,x3,u),x1=x1bar,x2=0,x3=k*x1bar/a,u=0)
simplify(J0)

on obtient  
0 1 0 0
df  k a 
(x̄, ū) =  − m 0 m 0 .
d(x,u)
0 − ka 0 k
a2
Le système linéarisé s’exprime donc par
   
0 1 0 0
 k a   
ẋ =  − m 0 m  (x − x̄) +  0  u.
0 − ka 0 k
a2
92 Commande par espace d’état

On remarque que les coefficients des matrices A et B ne dépendent pas de x̄. Ceci est assez rare, et signifie que le
comportement d’une commande linéaire ne dépendra pas du point de fonctionnement choisi. Notons que l’absence
de matrice C et D dans le système linéarisé est une conséquence du fait que le système non linéaire considéré soit
autonome (c’est-à-dire sans sortie).

6.3 Stabilisation d’un système non linéaire

6.3.1 Principe

Considérons le système décrit par ses équations d’état



ẋ = f (x, u)
S: (6.2)
y = g(x),

dont (x̄, ū) constitue un point de fonctionnement. Soit xc = Ex le sous-vecteur des variables consignées. Rappelons
qu’autour du point de fonctionnement, S se comporte comme le système affine suivant

ẋ = A (x − x̄) + B (u − ū)
y = ȳ + C (x − x̄)

où A, B, C sont obtenues par le calcul de la matrice jacobienne de la fonction évolution/observation au point


(x̄, ū). Puisque le vecteur x
" = x − x̄ est aussi un vecteur d’état pour ce système, ce dernier se comporte, autour
de son point de fonctionnement, comme le système suivant

d
" = A"
dt x x + B (u − ū)
y = ȳ + C" x.

Afin que notre système se comporte comme un système linéaire (et non affine), construisons les variables u
" = u− ū
et y
" = y − ȳ, comme représenté sur la figure ci-dessous.

Transformation d’un système affine (au voisinage


du point de fonctionnement) en un système linéaire

Vu de l’extérieur, et pour de petites entrées, le système en gris se comporte comme le système linéaire d’équations

d
" = A"
dt x x + B" u
"
y = C" x,

qui est en fait le système linéarisé du système non linéaire (6.2). Nous pouvons alors construire un régulateur RL
pour ce système linéaire grâce à l’algorithme R  KLH(A, B, C, E, pcom , pobs ) de la page 85.
Commande linéaire des systèmes non linéaires 93

" entrée dans RL est constante, nous avons E"


Nous savons que, lorsque la consigne w x = w.
" Or, nous voudrions que
l’entrée du régulateur w que nous fabriquons satisfasse w = Ex. Nous allons donc fabriquer un précompensateur
pour construire w" à partir de w de telle façon que w = Ex à l’équilibre. On a

" = E"
w x = E (x − x̄) = w − w̄,

où w̄ = Ex̄. Le régulateur ainsi obtenu est représenté sur la figure ci-dessous, dans le cadre épais.

Stabilisation d’un système non-linéaire autour


d’un point de fonctionnement par un régulateur linéaire

Ce régulateur stabilise et découple notre système non linéaire autour de son point de fonctionnement. Un récapi-
tulatif de la méthode pour calculer un régulateur pour un système non linéaire est donné par le tableau 6.1. Cet
algorithme nous renvoie notre régulateur d’entrées y, w et de sortie u sous la forme de ses équations d’état.

Algorithme R  NL (in : f , g, E, pcom , pobs , x̄, ū ; out : R)


1 Vérifier que f (x̄, ū) = 0;
2 ȳ := g (x̄) ; w̄ := Ex̄;
3 A := ∂x∂f ∂f
(x̄, ū) ; B := ∂u (x̄, ū) ; C := ∂g
∂x (x̄, ū) ;
4 K :=

(A, B, pcom ) ;
  T
5 L :=

 AT , CT , pobs ;
 −1
−1
6 H := − E (A − BK) B ;

d
7 R := dt x̂ = (A − BK − LC) x̂ + BH (w − w̄) + L (y − ȳ)
u = ū − Kx̂ + H (w − w̄)

Tableau 6.1: Méthodologie à suivre pour la conception d’un régulateur linéaire pour un système non-linéaire

Exemple 6.3.1 Considérons le système non linéaire donné par les équations d’état

ẋ = 2x2 + u
S:
y = 3x,

que l’on cherche à stabiliser autour de l’état x̄ = 2. L’intérêt de cet exemple est que les vecteurs d’état, d’entrée
et de sortie sont tous des scalaires. Ainsi, toutes les matrices sont aussi scalaires et les calculs peuvent se faire à
la main. Afin d’avoir f (x̄, ū) = 0, il nous faut 2x̄2 + u = 0, soit ū = −8. Si nous voulons qu’à l’équilibre y = w,
94 Commande par espace d’état

il faudra prendre E = 3. Si de plus nous voulons que tous les pôles du système bouclé soient égaux à −1, il faudra
pcom = pobs = −1. La linéarisation autour de (x̄, ū) nous donne A = 8, B = 1 et C = 3. Pour K et L, il faut
résoudre les deux équations polynomiales

det (sI − A + BK) = s+1
 T T T

det sI − A + C L = s+1

c’est-à-dire s − 8 + K = s + 1 et s − 8 + 3L = s + 1. Donc K = 9 et L = 3. De plus ȳ = 6, w̄ = 3x̄ = 6.


 −1
H = − 3 (8 − 9)−1 = 1/3. Donc le régulateur s’écrit

d
R: dt x̂ = −10x̂ + (w − 6) /3 + 3 (y − 6)
u = −8 − 9x̂ + (w − 6) /3.

6.3.2 Avec un observateur étendu

Rappelons (voir paragraphe 5.4 de la page 79) que dans le régulateur renvoyé par l’algorithme R  NL du
tableau 6.1, se cache un simulateur du système linéarisé de notre système non linéaire S à réguler. Il est possible
de remplacer ce simulateur par un simulateur non linéaire ayant les mêmes équations que S lui-même. Le régulateur
généré par l’algorithme précédent peut s’écrire

d
R: dt x̂ = Ax̂ + B (−Kx̂ + H (w − w̄)) −L (Cx̂ + ȳ) + Ly
u = ū − Kx̂ + H (w − w̄) .

Or,
Ax̂ + B (−Kx̂ + H (w − w̄)) // voir équation d’évolution de R
= Ax̂ + B (u − ū) // équation d’observation de R
= f (x̄, ū) + Ax̂ + B (u − ū) // puisque f (x̄, ū) = 0
≃ f (x̂ + x̄, u) // Taylor d’ordre 1 en (x̄, ū).
= f (x̂ + x̄, ū − Kx̂ + H (w − w̄)) // équation d’observation de R
et
Cx̂ + ȳ // voir équation d’évolution de R
= g(x̄) + Cx̂ // puisque ȳ = g (x̄)
≃ g(x̂ + x̄) // Taylor à l’ordre 1 autour du point x̄.
Nous pouvons donc remplacer le régulateur R par le suivant

d
Re := dt x̂ = f (x̂ + x̄, ū − Kx̂ + H (w − w̄)) − L (g(x̂ + x̄) + y)
u = ū − Kx̂ + H (w − w̄) ,

qui intègre non pas un simulateur du système linéarisé, mais un simulateur du système non linéaire (les matrices
A, B, C n’apparaissent plus dans ce régulateur). L’observateur du régulateur ainsi obtenu est plus proche de la
réalité et se trompe donc moins. On obtient ainsi un régulateur plus performant.

6.4 Stabilisation du pendule inversé

On considère à nouveau le système modélisé au paragraphe 2.3.5 de la page 22. Rappelons que l’entrée u est la
force exercée sur le chariot de masse M, x est la position du chariot et θ est l’angle entre le pendule et la verticale.
Commande linéaire des systèmes non linéaires 95

 
En prenant pour vecteur d’état x = x, θ, ẋ, θ̇ , et en supposant que seule la position du chariot x est mesurée,
les équations d’état sont données par :
    

 ẋ1
x3

  
   x4
  ẋ2  = 




   m sin x2 (g cos x2 −ℓx24 )+u 
 ẋ3   M+m sin2x


 2
2
sin x2 ((M+m)g−mℓx4 cos x2 )+cos x2 u

 ẋ4

 ℓ(M+m sin2 x2 )

y = x1

(voir (2.3) page 23). Afin de linéariser ce système, il nous faut calculer la matrice jacobienne de la fonction
évolution/observation h(x, u) puis l’évaluer au point de fonctionnement x̄ = (0, 0, 0, 0) et ū = 0. Nous obtenons
la matrice  
0 0 1 0 0
 0 0 0 1 0 
dh  
 mg 1 
(x̄,ū) =  0 M 0 0 M 
d (x,u)  
 0 (M+m)g
Mℓ 0 0 Mℓ 1 

1 0 0 0 0
qui nous amène au système linéarisé suivant :
    

 0 0 1 0 0

    0 

 ẋ =  0 0 0 1   
 mg x +  1 u
 0 M 0 0   M 

 (M+m)g 1

 0 0 0

 Mℓ Mℓ
y = (1 0 0 0) x.

Tous ces calculs peuvent être obtenus par M


 grâce aux instructions suivantes

export(linalg)
J :=jacobian(
[x3, x4,
(m*sin(x2)*(g*cos(x2)-l*x4^2)+u)
/(M+m*sin(x2)^2),
(sin(x2)*((M+m)*g-m*l*x4^2*cos(x2))+cos(x2)*u)
/(l*(M+m*sin(x2)^2)),
x1],[x1,x2,x3,x4,u])
J0 :=subs(J(x1,x2,x3,x4,u),x1=0,x2=0,x3=0,x4=0,u=0)
J1 :=simplify(J0)

Il est aisé de vérifier que le système linéarisé de notre pendule inversé est observable et commandable pour
les valeurs nominales des paramètres. L’algorithme R  KLH de la page 85 peut donc être poursuivi afin
d’obtenir notre régulateur. Un programme de la simulation du pendule inversé régulé est donné dans le fichier
PenduleInverseAsservi.sce. Une version complète et commenté de ce programme est donnée ci-dessous. Le
programme est composé de trois fonctions et du programme principal.

//------------------------------------------------------
// fonction qui dessine le pendule inverse
function draw(x,couleur);
96 Commande par espace d’état

xbasc(); //efface l’ecran


isoview(-2,3,-1,2); //regle les echelles
//dessin du pendule
xpoly([ x(1), x(1)-l*sin(x(2))], [0, l*cos(x(2))]);
//dessin du chariot
xpoly([x(1)-.5,x(1)+.5,x(1)+.5,x(1)-.5,x(1)-.5],
[0,0,-.25,-.25,0]);
endfunction
//------------------------------------------------------
//fonction pour le calcul du regulateur
function [Ar,Br,Cr,Dr]=RegulKLH(A,B,C,E,pcom,pobs);
K=ppol(A,B,pcom); //matrice pour la regulation
L=ppol(A’,C’,pobs)’; //matrice pour l’observation
H=-inv(E*inv(A-B*K)*B); //matrice de pre-compensation
Ar=A-B*K-L*C;Br=[B*H L]; //matrices d’etat pour
Cr=-K;Dr=[H,zeros(B’*C’)] //le regulateur
endfunction
//------------------------------------------------------
//fonction d’evolution du pendule inverse
function v=f(x,u)
v=[x(3);
x(4);
(m*sin(x(2))*(g*cos(x(2))-l*x(4)^2)+u)
/(M+m*sin(x(2))^2);
(sin(x(2))*((M+m)*g-m*l*x(4)^2*cos(x(2)))+u*cos(x(2)))
/(l*(M+m*sin(x(2))^2))];
endfunction;
//------------------------------------------------------
//debut du programme principal
rand(’normal’); //mode gaussien pour le generateur aleatoire
m=1;M=5;l=1;g=9.81; //initialisation des parametres
dt=0.005; //pas d’echantillonnage
//calcul des matrices d’etat du systeme linearise
//necessaires uniquement pour la conception du regulateur
A=[0 0 1 0;0 0 0 1;0 m*g/M 0 0;0 (M+m)*g/(l*M) 0 0];
B=[0;0;1/M;1/(l*M)];
C=[1 0 0 0];
E=[1 0 0 0]; //matrice de consigne
[Ar,Br,Cr,Dr]=RegulKLH(A,B,C,E,[-2 -2 -2 -2],[-2 -2 -2 -2])
x=[0;0.02;0;0]; //etat initial pour le systeme
xr=[0;0;0;0]; //etat initial pour le regulateur
for k=1:10000
w=2*sign(sin(k*0.001)); //la consigne change par a-coup
y=C*x+0.003*rand(); //la sortie est bruitee
u=Cr*xr+Dr*[w;y]; //calcul de la commande
Commande linéaire des systèmes non linéaires 97

xr=xr+(Ar*xr+Br*[w;y])*dt; //evolution du regulateur


x=x+f(x,u)*dt; //evolution de l’etat
draw(x); //dessine le pendule inverse
end
//------------------------------------------------------

6.5 Stabilisation d’un monocycle

On rappelle (voir équation (2.5) page 26) que les équations d’état du monocycle sont de la forme
  
   x3

 ẋ1

  x4 

  ẋ2   
    
  =  µ3 (µ2 x24 −µg cos x2 ) sin x2 +(µ2 +µ3 cos x2 )u 
 ẋ3   2
µ1 µ2 −µ3 cos x22 

  µ µ −µ2 x2 cos 

 ẋ4 ( 1 g 3 4 x2 ) sin x2 −(µ1 +µ 3 cos x2 )u

 µ1 µ2 −µ23 cos2 x2


y = x1

où µ1 , µ2 , µ3 , µg sont des constantes. Nous avons rajouté l’équation d’observation y = x1 afin de supposer une
situation où seul l’angle de la roue α est mesuré. Linéarisons avec M
 ce système autour du point de fonc-
tionnement ū = 0, x̄ = 0 :

export(linalg)
J :=jacobian( [
x3, x4,
(m3*(m2*x4^2-mg*cos(x2))*sin(x2)+(m2+m3*cos(x2))*u)
/(m1*m2-m3^2*cos(x2)^2),
((m1*mg-m3^2*x4^2*cos(x2))*sin(x2)-(m1+m3*cos(x2))*u)
/(m1*m2-m3^2*cos(x2)^2),
x1],
[x1,x2,x3,x4,u])
J0 :=subs(J(x1,x2,x3,x4,u),x1=0,x2=0,x3=0,x4=0,u=0)
J1 :=simplify(J0)

On obtient  
0 0 1 0 0
 0 0 0 1 0 
 
dh  µ µg µ2 +µ3 
(x̄,ū) =  0 − µ µ3 −µ2 0 0 µ1 µ2 −µ23

d (x,u)  1 2 3 
 0 µ1 µg
0 0 − µµµ1 +µ3 
 µ1 µ2 −µ23 1 2 −µ3
2 
1 0 0 0 0
au point (x̄ = (0, 0), ū = 0). Le système linéarisé est décrit par les équations d’état suivantes :
    

 0 0 1 0 0

    

  0 0 0 1   0 

 ẋ =    
 0 − µ3 µg 2 0 0  x +  µ2 +µ3 2  u
 µ µ
1 2 −µ3   1 2 3 
µ µ −µ
 µ1 µg


 0 µ µ 2 0 0 − µµµ1 +µ 3
2

  1 2 −µ3  1 2 −µ3

 y = 1 0 0 0 x
98 Commande par espace d’état

L’exécution complète de l’algorithme R  NL du tableau 6.1 page 93 nous génère ainsi notre régulateur. Un pro-
gramme complet de la simulation du Segway stabilisé par ce régulateur est donné par le fichier SegwayAsservi.sce.

6.6 Conduite automatique d’une voiture

La commande des systèmes non holonomes (comme les robots à roues) est loin d’être facile car souvent il arrive
que le système considéré soit commandable alors que son linéarisé ne l’est pas. Prenons le cas d’une voiture à
l’arrêt, il est possible de bouger le véhicule latéralement par une suite de manœuvres semblables à celles effectuées
lorsqu’on essaie de garer sa voiture alors la place laissée libre est à peine suffisante. Pourtant, cette même suite
de manœuvres effectuées sur le linéarisé de la voiture n’engendrera aucun mouvement latéral. Une autre difficulté
que nous allons rencontrer dans ce paragraphe est que parfois, on ne souhaite pas stabiliser le système autour d’un
point de fonctionnement mais lui donner un mouvement précis. C’est le cas pour la conduite automatique : aller
plein nord avec une vitesse de 50 km.h−1 ne correspond pas à un point de fonctionnement pour la voiture car sa
variable d’état y n’est pas constante (elle augmente à une vitesse 50 km.h−1 et tend donc vers l’infini).

A travers ce paragraphe, nous allons montrer comment utiliser les techniques linéaires pour arriver à concevoir
un régulateur pour la conduite automatique. Nous aurons besoin pour cela d’imaginer un monde idéal pour le
régulateur où le modèle associé admet un point de fonctionnement qui correspond au comportement voulu pour
notre système réel.

Voiture se déplaçant le long d’une route

Dans ce paragraphe, nous allons traiter le cas d’une voiture (celle modélisée au paragraphe 2.4.3 page 27) qui
roule sur une route inconnue. La voiture est équipée

— d’un télémètre mesurant la distance latérale d entre le milieu de l’essieu arrière de la voiture et le bord de la
route (voir figure),
— d’un capteur de vitesse qui mesure la vitesse v des roues avant,
— et d’un capteur d’angle qui mesure l’angle δ du volant (pour simplifier, nous allons supposer que δ correspond
aussi à l’angle que forment les roues avant avec l’axe de la voiture).

On souhaite que la voiture se déplace à vitesse constante le long de cette route. Bien sûr, il est hors de question
de mettre dans la connaissance du régulateur la forme de la route car elle est inconnue. De plus, les variables de
position et d’orientation de la voiture ne sont pas mesurées (c’est-à-dire qu’on ne dispose ni de boussole, ni de
capteur GPS). Or ces quantités sont souvent inutiles pour atteindre l’objectif fixé, à savoir suivre la route. En
effet, ne sommes nous pas, nous-mêmes, capables de conduire une voiture sur une route sans avoir la carte des
environs, sans savoir où nous sommes et où est le nord ? Ce qui nous intéresse lorsque nous conduisons une voiture,
Commande linéaire des systèmes non linéaires 99

c’est la position relative de la voiture par rapport à la route. Le monde idéal pour le régulateur est évoqué par la
figure.

Modèle imaginé par le régulateur : la voiture se déplace laté-


ralement, comme sur un jeu vidéo, et le bord de la route reste
fixe

Il doit être tel que le modèle utilisé par le régulateur possède des variables d’état décrivant cette position relative
de la voiture par rapport à la route et que la constance des variables d’état de ce modèle corresponde à une
situation réelle où la voiture suit la route à une vitesse constante.

Tout d’abord, dans le paragraphe 6.6.1, nous allons donner la fonction d’observation de notre voiture roulant sur
un circuit en forme de polygone (voir figure).

Système réel : voiture tournant autour d’un polygone

Ensuite, nous imaginerons dans le paragraphe 6.6.2 un monde idéal pour le régulateur. Au paragraphe 6.6.3 nous
implémenterons le régulateur ainsi conçu sur une voiture tournant autour d’un circuit.

6.6.1 Fonction d’observation pour le système

Rappelons que la fonction d’évolution de notre voiture est déjà connue (voir formule (2.6) page 28). Pour l’ex-
pression de la fonction d’observation, nous avons besoin de calculer la distance renvoyée par le télémètre et qui
correspond à la distance entre le milieu de l’essieu arrière et le polygone formé par le circuit. Pour cela, le théorème
suivant nous sera utile.

 →
Théorème 6.6.1 Soient m, a, b trois points de R2 et −

u un vecteur. La demi-droite E m,−
u de sommet m et
100 Commande par espace d’état

de vecteur directeur −

u intersecte le segment [ab] si et seulement si
    
det a − m, −→
u . det b − m, − →u ≤0

→ (6.3)
det(a − m, b − a). det( u , b − a) ≥ 0.

Dans ce cas, la distance du point m au segment [ab] suivant le vecteur −



u est donnée par

det(a − m, b − a)
d= .
det(−

u , b − a)

Remarque 6.6.1 Pour comprendre la preuve qui suit, il est important de se rappeler la signification du signe
du déterminant de deux vecteurs − →u et −→
v de R2 . On a (i) det(− →
u,−→v ) > 0 si −
→v est sur la gauche de − →
u , (ii)

→ −
→ −
→ −
→ −
→ −
→ −
→ −

det( u , v ) < 0 si v est sur la droite de u et (iii) det( u , v ) = 0 si u et v son colinéaires. Ainsi, par exemple,
sur la figure ci-dessous à gauche, det(a − m, −→u ) > 0 et det(b − m, − →u ) < 0. Rappelons aussi que le déterminant
est une forme multilinéaire, c’est-à-dire que

det(au + bv, cx + dy) = a det(u, cx + dy) + b det(v, cx + dy)


= ac det(u, x) + bc det(v, x)
+ad det(u, y) + bd det(v, y).

 →
Preuve : La droite D m,− u qui passe par le point m et de vecteur directeur − →
u coupe le plan en 2 demi-plans :

→ −

ceux qui satisfont det(z − m, u ) ≥ 0 et ceux qui satisfont det(z − m, u ) ≤ 0. Elle coupe donc le segment [ab] si
   
a et b sont dans des demi-plans différents (voir figure), c’est-à-dire si det a − m, −

u . det b − m, −→
u ≤ 0.

La droite D (m, ũ) coupe le segment [ab]

 →
Dans la situation de gauche, la demi-droite E m,− u de sommet m et de vecteur directeur − →
u coupe le segment
[ab] . Cela n’est pas le cas sur la sous-figure de droite. Cette condition n’est donc pas suffisante pour affirmer que
 →      →
E m,− u coupera [ab] . Supposons que det a − m, − →
u .det b − m, − →
u ≤ 0, c’est-à-dire que la droite D m,− u
 − →  −

coupe le segment [ab] . Les points de la demi-droite E m, u satisfont tous z = m + α u , α ≥ 0. Comme l’illustre
la figure ci-dessous, m sur trouve sur le segment [ab] lorsque les vecteurs m + α− →
u −a et b − a sont colinéaires
(voir figure), c’est-à-dire (voir remarque 6.6.1, (iii)) que lorsque α satisfait det(m + α−

u −a, b − a) = 0.
Commande linéaire des systèmes non linéaires 101

m se trouve sur le segment [ab] lorsque


les vecteurs m + α−
→u −a et b − a sont colinéaires

Du fait de la multilinéarité du déterminant, cette équation se réécrit

det(m − a, b − a) + α det(−

u , b − a) = 0.

En isolant α, on obtient
det(a − m, b − a)
α= .
det(−

u , b − a)
Si α ≥ 0, alors α représente la distance d parcourue par le faisceau partant de m dans la direction − →
u avant de
rencontrer le segment. Si α < 0, cela signifie que le faisceau ne rencontrera jamais le segment car ce dernier est
du mauvais côté. La condition α ≥ 0 correspond à la deuxième inégalité de la condition (6.3). 

La fonction d’observation pour notre système, donnée par le programme S du tableau 6.2, est une consé-
quence directe de ce théorème. Rappelons que cette fonction nous renvoie la distance d mesurée par le télémètre, la
vitesse v des roues avant et l’angle du volant δ. La ligne 2 calcule le vecteur u qui indique la direction du télémètre
laser et le point m, d’où part le laser. La distance d renvoyée doit être la plus petite (voir ligne 7) parmi toutes
les distances susceptibles (voir lignes 5 et 6) d’être renvoyées par chacun des segments. Dans ce programme, Aj et
Bj représentent des matrices contenant les points extrêmes aj et bj des sommets du jième segment. Notons enfin
que cette fonction ne sera pas utilisée par le régulateur, mais uniquement afin de simuler notre système réel. En
effet, notre régulateur ne connaît pas la forme du polygone autour duquel la voiture est censée tourner : il pense
que la voiture est en train de longer un mur droit et infini. Sa fonction d’observation est donnée au paragraphe
suivant.

6.6.2 Fonction d’observation pour le régulateur

Afin de concevoir le modèle pour notre régulateur, intéressons nous à la position relative de la voiture par rapport
au bord de la route. Nous allons pour cela supposer que notre voiture roule à une distance x̄ du bord. Ce modèle
doit posséder les mêmes entrées et sorties que le système réel, à savoir deux entrées (l’accélération des roues avant
v̇ et la vitesse angulaire du volant δ̇) et trois sorties (la distance d du milieu de l’essieu arrière au bord de la
route, la vitesse v des roues avant et l’angle δ du volant). Du fait que seule la position relative de la voiture nous
intéresse, notre modèle ne doit posséder que quatre variables d’états : x, θ, v, δ, comme représenté sur la figure.
Attention, la signification de la variable x a légèrement changé par rapport au contexte du paragraphe 2.4.3 page
102 Commande par espace d’état

1 function y=g(x)
2 u=[sin(x(3)) ;-cos(x(3))] ; m=[x(1) ;x(2)] ; d=%inf ;
3 for j=1 :size(Aj,2)
4 a=Aj( :,j) ; b=Bj( :,j) ;
5 if (det([a-m u])*det([b-m u]) <= 0)&
6 (det([a-m b-a])*det([u b-a])>=0)
7 d=min(det([a-m b-a])/det([u b-a]),d) ;
8 end
9 end
10 y=[d ;x(4) ;x(5)] ;
11 endfunction

Tableau 6.2: Fonction d’observation de la voiture tournant autour d’un polygone

27. En s’aidant de la modélisation faite au paragraphe 2.4.3, on obtient pour notre modèle, les équations d’état
suivantes     

 ẋ −v cos δ cos θ

  θ̇   v sin δ 

    

   =  L 

  v̇   u 
 1
δ̇  u2 

 x



  sin θ


 y =  v ,


 δ
où L est la distance entre les essieux avant et arrière. Choisissons pour point de fonctionnement

x̄ = (5, π/2, 7, 0) et ū = (0, 0)

qui correspond à une vitesse de 7 ms−1 et une distance de 5 m entre le milieu de l’essieu arrière et le bord de la
route. La matrice jacobienne de la fonction d’évolution-observation


 R6 →  R7 



   −v cos δ cos θ

 x  

  v sin δ


  θ   L 
    u 

h:  v    1 
   →   u2 

  δ  

    x 

  
  u1 
  sin θ


  v 

 u 2
δ

est donnée par  


0 v cos δ sin θ − cos δ cos θ v sin δ cos θ 0 0
 sin δ 
 0 0 L v cos
L
δ
0 0 
 
 0 0 0 0 1 0 
 
 0 0 0 0 0 1 .
 
 1 x
− sin2 θ cos θ 0 0 0 0 
 sin θ 
 
 0 0 1 0 0 0 
0 0 0 1 0 0
Commande linéaire des systèmes non linéaires 103

Cette matrice a été obtenue par M


 grâce aux instructions suivantes.

export(linalg)
J :=jacobian([
-v*cos(delta)*cos(theta),
v*sin(delta)/L,
u1, u2, x/sin(theta), v, delta],
[x,theta,v,delta,u1,u2])
Son évaluation autour du point de fonctionnement et pour L = 3 est obtenue par

J0 :=subs(J(x,theta,v,delta,u1,u2),
x=5,theta=PI/2,v=7,delta=0,u1=0,u2=0)
J1 :=subs(J0(L),L=3)
J2 :=simplify(J1)
M
 obtient  
0 7 0 0 0 0
 7 
 0 0 0 3 0 0 
   
 0 0 0 0 1 0 
dh   A B
(x̄, ū) = 
 0 0 0 0 0 1 =
 .
d (x̄, ū)   C D
 1 0 0 0 0 0 
 
 0 0 1 0 0 0 
0 0 0 1 0 0
Donc les matrices du système linéarisé sont
   
0 7 0 0 0 0
 0 0 0 7   0 0 
 3   
A= , B =  ,
 0 0 0 0   1 0 
 0 0 0 0   0 1 
1 0 0 0 0 0
   
C= 0 0 1 0 , D =  0 0 .
0 0 0 1 0 0
Prenons pour variables consignées x et v, ce qui signifie que nous voulons nos consignes w1 et w2 correspondent
à la distance au bord de la route et la vitesse de la voiture. La matrice de consigne est donc
 
1 0 0 0
E= .
0 0 1 0

En choisissant pour pôles


pcom = pobs = (−2; −2; −2; −2) ,
l’algorithme R  KLH(in : A, B, C, E, pcom , pobs ) du tableau 5.2 page 85 nous génère le régulateur suivant :
      

 −4 7 0 0 0 0 4 0 0   20

  −0.6   0 0 0.6 0 2.3  w  2.9 

  0 0 0     
 d
 dt x̂ =   x̂ +   −  
  0 0 −4 0   0 2 0 2 0  y  28 


  −0.5 −5.1 0 −8   0.5 0 0 0 2  2.4



 0 0 −2 0 0 2 5
 u=

−0.49 −5.14 0 −6
x̂ +
0.48 0
w−
7
.
104 Commande par espace d’état

Une simulation du comportement de ce régulateur sur ce modèle de voiture simplifié (où un seul mur droit existe)
est donnée par le fichier VoitureNordAsservie.sce.

6.6.3 Bouclage

Le régulateur que nous venons juste de proposer a été conçu pour un modèle idéalisé de notre voiture, mais qui ne
correspond pas exactement à notre système réel. Rappelons que notre voiture est un système d’ordre 5 alors que
sa version idéalisée utilisée par le régulateur est d’ordre 4. Or, ces deux systèmes admettent les mêmes entrées (u1
et u2 ) et les mêmes sorties (d, v, δ). Il est donc possible de brancher le régulateur conçu pour notre système idéal
sur le système réel. Il nous reste à espérer que le comportement engendré pour notre système sera convenable.

Le programme de simulation de notre commande est proche de celui du tableau 3.9, page 53. La même fonction
d’évolution f est utilisée. En ce qui concerne la fonction draw, il nous faut rajouter le dessin du faisceau lancé par
le télémètre ainsi que le dessin du circuit. Cela correspond aux instructions suivantes :

Aj=[-10 -10 0 10 20 32 35 30 20 0 ;
-5 5 15 20 20 15 10 0 -3 -6 ] ;
Bj=[Aj( :,2 :$),Aj( :,1)] ;
xfpoly(Aj(1, :),Aj(2, :)) ;
xpoly([x(1),x(1)+sin(x(3))*d],
[x(2),x(2)-cos(x(3))*d]) ;

Le programme de simulation de la voiture sur circuit est donné par le tableau 6.3. En lançant ce programme, on
s’aperçoit que la voiture tourne correctement autour du circuit, mais que lorsqu’elle franchit un sommet anguleux
du polygone, elle est déstabilisée pendant une petite seconde. Ceci est dû au fait que le régulateur (pensant que
la route est droite à l’infini) est surpris par ce changement brutal de direction. Ces changements de direction dans
la route sont considérés par le régulateur comme des perturbations.
Commande linéaire des systèmes non linéaires 105

Programme VoitureAsservieCircuit.sce
A=[0 7 0 0 ;0 0 0 7/3 ;0 0 0 0 ;0 0 0 0] ;
B=[0 0 ;0 0 ;1 0 ;0 1] ;
C=[1 0 0 0 ;0 0 1 0 ;0 0 0 1] ;
E=[1 0 0 0 ;0 0 1 0] ;
K=ppol(A,B,-2*[1,1,1,1]) ;
L=(ppol(A’,C’,-2*[1,1,1,1]))’ ;
H=-inv(E*inv(A-B*K)*B) ;
Ar=A-B*K-L*C ;Br=[B*H L] ;Cr=-K ;
ubar=[0 ;0] ;xbar=[5 ;1.57 ;7 ;0] ;wbar=E*xbar ;
ybar=[xbar(1)/sin(xbar(2)) ;xbar(3) ;xbar(4)] ;
xr=[0 ;0 ;0 ;0] ;w=[5 ;7] ;
x=[-15 ;0 ;%pi/2 ;7 ;0.1] ;dt=0.07 ;
for k=1 :500,
u=ubar+Cr*xr+H*(w-wbar) ;y=g(x) ;
x1=x+f(x,u)*dt ;
xr1=xr+(Ar*xr+Br*[w-wbar ;y-ybar])*dt ;
x=x1 ; xr=xr1 ;
end ;

Tableau 6.3: Simulation de la voiture conduite automatiquement


106 Commande par espace d’état
Chapitre 7

Commande non linéaire des systèmes non


linéaires

7.1 Introduction

Au chapitre 6, nous avons montré comment concevoir des régulateurs pour les systèmes non linéaires, lorsque le
vecteur d’état reste localisé dans une zone de petite taille de l’espace d’état. L’idée était de linéariser le système
non linéaire à réguler et d’utiliser les techniques développées au chapitre 5 pour la régulation des systèmes linéaires.
Dans ce chapitre, nous allons chercher à proposer des régulateurs non linéaires afin de contraindre le vecteur d’état
à rester dans une petite zone de l’espace d’état. Contrairement à l’approche linéaire qui offre une méthodologie
générale mais limitée au voisinage d’un point de l’espace d’état, les approches non linéaires ne s’appliquent qu’à
des classes limitées de systèmes, mais elles permettent d’étendre la plage de bon fonctionnement du système.

Il n’existe en effet pas de méthode générale pour stabiliser globalement les systèmes non linéaires. En revanche, il
existe une multitude de méthodes qui s’appliquent à des cas particuliers. Le but de ce chapitre est d’en présenter
une assez représentative des méthodes existantes. Il s’agit de la méthode de linéarisation par bouclage. Après l’avoir
introduite par un petit exemple au paragraphe 7.2 et présenté son principe au paragraphe 7.3, nous appliquerons
cette méthode à la régulation (par retour d’état) du problème des 3 bacs modélisé au paragraphe 2.5.2 de la page
32, à la commande de la voiture modélisée au paragraphe 2.4.3 de la page 27, puis à la commande du bateau à
voile modélisé au paragraphe 2.4.4 page 29.

7.2 Un petit exemple

Considérons le système que l’on cherche à réguler :



ẋ = x3 + xu
(7.1)
y = exp(x).

On souhaiterait que sa sortie y soit égale à une consigne supposée constante v. En dérivant la sortie y nous
obtenons
ẏ = ẋ exp (x) = x3 exp (x) + x exp (x) u.

107
108 Commande par espace d’état

Posons
1  3 
u= −x exp (x) + v , (7.2)
x exp (x)
où v correspond à la nouvelle entrée (ou consigne). Le bouclage (7.2) transforme le système (7.1) en un simple
intégrateur décrit par l’équation différentielle
SL : ẏ = v.
Le bouclage (7.2) s’appelle bouclage linéarisant car il transforme le système non linéaire en un système linéaire. Le
système ainsi obtenu peut être stabilisé par des techniques linéaires classiques. Nous choisirons ici une commande
PI (proportionnelle et intégrale) de la forme
t
v = αP (w − y) + αI 0 (w (τ ) − y (τ )) dτ

où w est la consigne. Les équations d’état de cette commande PI est donnée par

ż = w − y
v = αI z + αP (w − y) .

où z est la variable d’état associée à l’intégrateur. Donc les équations d’état d’un régulateur par retour d’état RNL
pour notre système non linéaire (7.1) sont données par

ż = w − exp(x)
RNL : 1
 3 
u = x exp(x) −x exp (x) + αI z + αP (w − exp(x)) .

Ce bouclage est illustré par la figure.

Commande d’un système non-linéaire par


la méthode de linéarisation par bouclage

7.3 Principe de la linéarisation par bouclage

7.3.1 Principe

Nous cherchons à généraliser ici la méthode décrite au paragraphe précédent. Une approche plus détaillée pourra
être trouvée dans le livre d’Andréa-Novel [3]. Considérons le système non linéaire décrit par

ẋ = f (x) + b(x)u
y = c(x)

dont le nombre d’entrées et de le nombre de sorties sont tous les deux égaux à m. L’idée de la linéarisation par
bouclage, est de boucler le système par une commande du type u = r(x, v), où v est la nouvelle entrée, aussi
Commande non linéaire des systèmes non linéaires 109

de dimension m. Cette opération nécessite que l’état soit complètement accessible. Si cela n’est pas le cas, on se
doit de fabriquer un observateur, mais dans un contexte non linéaire, cela est une opération très difficile. Puisque
ici l’état est supposé accessible, y ne doit pas vraiment être considérée comme une sortie, mais plutôt comme le
vecteur des variables consignées.

Pour effectuer ce bouclage, il nous faut exprimer les dérivées successives de chacun des yi en fonction de l’état et
de l’entrée. On s’arrête de dériver yi , dès que les entrées commencent à intervenir dans l’expression de la dérivée.
Nous disposons ainsi d’une équation du type
 
(k )
y1 1
 . 
 ..  = A (x) u + b (x) , (7.3)
 
(k )
ym m

où ki désigne le nombre de fois qu’il nous faut dériver yi pour y voir apparaître une entrée (voir les exemples
dans les paragraphes qui suivent pour une meilleure compréhension). Sous l’hypothèse que la matrice A(x) soit
inversible, le bouclage suivant
u = A−1 (x) (v − b (x)) ,

où v est notre nouvelle entrée (voir figure ci-dessous), forme un système linéaire SL de m entrées à m sorties décrit
par les équations différentielles

 (k1 )
 y1
 = v1
SL : .
. ..
 . = .

 y (km ) = v .
m m

Le système non-linéaire, une fois bouclé,


devient linéaire et découplé ;
il devient donc facile à commander

Ce système est linéaire et complètement découplé (c’est-à-dire que chaque entrée vi agit sur une et une seule
sortie yi ). Il est donc très facile à commander par les techniques classiques de commande par retour de sortie (voir
paragraphe 5.4 page 79). Ici, comme le système à commander est constitué de chaînes d’intégrateurs découplés,
nous utiliserons m régulateurs de types PID (proportionnel intégral et dérivées) dont nous rappellerons les principes
au paragraphe 7.3.2. Notons que pour utiliser de tels régulateurs, il est nécessaire de disposer des dérivées des
sorties. La remarque suivante explique comment les obtenir dans notre contexte de linéarisation par bouclage.
110 Commande par espace d’état

Remarque 7.3.1 En analysant bien le cheminement pour obtenir l’équation (7.3), on se rend compte que la j ième
(j)
dérivée de la iième sortie yi s’exprime sous la forme
(j)
yi = b̂ij (x) si j < ki
(j)
yi = âT
ij (x).u + b̂ij (x) si j = ki
(j)
yi = âij (x, u, u̇, ü, . . . ) si j > ki

Le coefficient ki s’appelle le degré relatif de la iième sortie. Si on mesure l’état du système x et son entrée u, on
(j)
peut donc disposer de toutes les dérivées successives des sorties yi , tant que j reste inférieur ou égal à ki . En
effet, en raison des bruits hautes fréquences apparaissant dans les signaux, on ne peut pas disposer de la dérivée
des signaux par l’utilisation de dérivateurs de façon fiable. Nous avons donc une fonction analytique

Rm → R(k1 +1)...(km +1)


∆: (k ) (k )
(x, u) → ∆(x, u) = (y1 , ẏ1 , . . . , y1 1 , y2 , ẏ2 , . . . , ym m ).

qui nous permet de disposer de toutes les dérivées des sorties (jusqu’à leur degré relatif), et ceci sans avoir à
utiliser de dérivateurs de signaux. Une autre approche pour obtenir les dérivées des sorties aurait été de construire
un observateur d’état (voir paragraphe 5.4 page 79).

Exemple 7.3.1 Considérons le système décrit par



ẋ = xu + x3
y= 2x.

Nous avons
y = 2x
ẏ = 2ẋ = 2xu + 2x3
ÿ = 2ẋu + 2xu̇ + 6ẋx2 = 2(xu + x3 )u + 2xu̇ + 6(xu + x3 )x2 .
Nous avons donc un degré relatif k = 1 pour la sortie y. On peut donc disposer de ẏ sans avoir à utiliser de
dérivateurs de signaux. Cela n’est pas le cas pour ÿ car disposer de u avec une bonne précision ne signifie pas que
l’on dispose de u̇. Ici,
∆(x, u) = (2x, 2xu + 2x3 ).

7.3.2 Commande d’une chaîne d’intégrateurs

On considère le système d’entrée u et de sortie y décrit par l’équation différentielle

y (n) = u.

Régulateur proportionnel et dérivées. On se propose tout d’abord de stabiliser ce système par un régulateur
proportionnel et dérivées du type
 
u = α0 (w − y) + α1 (ẇ − ẏ) − · · · + αn−1 w(n−1) − y (n−1) + w(n) .

où w est la consigne souhaitée pour y. Notons que w n’est pas ici supposée constante, mais peut dépendre du
temps. Le fait que ce régulateur nécessite les dérivées de y n’est pas un problème dans le cadre défini par la
linéarisation par bouclage. En effet, toutes ces dérivées peuvent être écrite comme fonction analytique de l’état
Commande non linéaire des systèmes non linéaires 111

x du système et de l’entrée u (voir remarque 7.3.1). En ce qui concerne la consigne w(t), elle est choisie par
l’utilisateur et une expression analytique de w(t) peut être supposée connue (par exemple w(t) = sin(t)). Ainsi,
le calcul des dérivées de w se fait de façon formelle et aucune sensibilité de l’opérateur dérivation par rapport au
bruit n’est à craindre.

Le système bouclé est décrit par l’équation différentielle


 
y (n) = u = α0 (w − y) + α1 (ẇ − ẏ) − · · · + αn−1 w(n−1) − y (n−1) + w(n) .

Si on définit l’erreur e entre la consigne w et la sortie y par e = w − y, cette équation devient

e(n) + αn−1 e(n−1) + · · · + α1 ė + α0 e = 0.

Cette équation différentielle est appelée dynamique de l’erreur. Son polynôme caractéristique est donné par

P (s) = sn + αn−1 sn−1 + · · · + α1 s + α0 , (7.4)

peut donc être choisi arbitrairement parmi les polynômes de degré n. Bien sûr, on choisira un polynôme dont les
racines sont toutes à parties réelles négatives, afin d’assurer la stabilité du système. Par exemple, si n = 3 et si on
souhaite que tous les pôles soient égaux à −1, on posera

s3 + α2 s2 + α1 s + α0 = (s + 1)3 = s3 + 3s2 + 3s + 1,

d’où
α2 = 3, α1 = 3, α0 = 1.
Le régulateur PI alors obtenu est donné par
...
u = (w − y) + 3 (ẇ − ẏ) + 3 (ẅ − ÿ) + w. (7.5)

Régulateur proportionnel intégral et dérivées : Afin de compenser les perturbations constantes, nous pou-
vons décider de rajouter un terme intégral. Nous obtenons une commande de type PID de la forme
 t
u = α−1 (w(τ ) − y(τ )) dτ (7.6)
τ =0
 
+α0 (w − y) + α1 (ẇ − ẏ) − · · · + αn−1 w(n−1) − y (n−1) + w(n) .

Le système bouclé est décrit par l’équation différentielle


 t
y(n) = α−1 (w(τ ) − y(τ )) dτ
τ =0
 
+α0 (w − y) + α1 (ẇ − ẏ) − · · · + αn−1 w(n−1) − y (n−1) + w(n) ,

d’où, en dérivant une fois,


e(n+1) + αn−1 e(n) + · · · + α1 ë + α0 ė + α−1 e = 0.
Le gain statique est toujours égal à 1 et le polynôme caractéristique

P (s) = sn+1 + αn−1 sn + · · · + α1 s2 + α0 s + α−1

peut être choisi arbitrairement, comme pour la commande proportionnelle et dérivées.

Pour une étude plus complète des régulateurs de type PID, le lecteur est encouragé à consulter le livre de Landau
[11].
112 Commande par espace d’état

7.4 Régulation des trois bacs

Afin d’illustrer le principe de la linéarisation par bouclage, reprenons à nouveau le système composé de trois bacs
modélisé au paragraphe 2.5.2 page 32. Les équations d’état obtenues pour ce système sont


 ḣ1 = −α (h1 ) − α (h1 − h2 ) + u1



 ḣ2 = α (h1 − h2 ) − α (h2 − h3 )
ḣ3 = −α (h3 ) + α (h2 − h3 ) + u2 . (7.7)



 y1 = h1


y2 = h3

où α(h) = a.sign (h) 2g|h|. Nous avons ici choisi pour sorties les hauteurs dans le premier et le troisième bacs.
Les dérivées des sorties y1 et y2 s’expriment par

ẏ1 = ḣ1 = −α (h1 ) − α (h1 − h2 ) + u1


ẏ2 = ḣ3 = −α (h3 ) + α (h2 − h3 ) + u2
ou, sous forme vectorielle,
     
ẏ1 1 0 −α (h1 ) − α (h1 − h2 )
= u+ .
ẏ2 0 1 −α (h3 ) + α (h2 − h3 )
     
A(x) b(x)

Le bouclage suivant  
−α (h1 ) − α (h1 − h2 )
u = A−1 (x) (v − b (x)) = v − (7.8)
−α (h3 ) + α (h2 − h3 )
où v est notre nouvelle entrée, rend notre système linéaire. Plus précisément ce dernier a la forme

ẏ1 = v1
SL : (7.9)
ẏ2 = v2 .

Cherchons maintenant à réguler le système linéaire (7.9) par un régulateur composé de deux régulateurs PI
(proportionnel et intégrale) de la forme
 t
v1 (t) = α0 (w1 (t) − y1 (t)) + α−1 0 (w1 (τ ) − y1 (τ )) dτ + ẇ1
RL : t
v2 (t) = β 0 (w2 (t) − y2 (t)) + β −1 0 (w2 (τ ) − y2 (τ )) dτ + ẇ2

où w1 et w2 sont les nouvelles consignes pour y1 et y2 . Si on souhaite avoir pour pôles uniquement des −1, il faut
(voir équation (??)) que 
s2 + α0 s + α−1 = (s + 1)2 = s2 + 2s + 1
s2 + β 0 s + β −1 = (s + 1)2 = s2 + 2s + 1,
soit
α−1 = β −1 = 1, α0 = β 0 = 2.
Les équations d’état pour le régulateur RL sont donc


 ż = w1 − y1
 1
 ż2 = w2 − y2
RL :

 v 1 = z1 + 2 (w1 − y1 ) + ẇ1


v2 = z2 + 2 (w2 − y2 ) + ẇ2 .
Commande non linéaire des systèmes non linéaires 113

En prenant en compte l’équation (7.8), nous obtenons que les équations d’état d’un régulateur par retour d’état
RNL pour notre système non linéaire (7.7) sont données par


 ż1 = w1 − h1

 ż
2 = w2 − h3
RNL :

 u1 = z1 + 2 (w1 − h1 ) + ẇ1 + α (h1 ) + α (h1 − h2 )


u2 = z2 + 2 (w2 − h3 ) + ẇ2 + α (h3 ) − α (h2 − h3 ) .

Le programme bacsasservi.sce effectue une simulation de cette commande, avec le graphisme.

7.5 Régulation du char

On rappelle que les équations d’état du char (voir paragraphe 2.4.2 page 26) sont données par
   vg +vd 
ẋ 2 cos θ
 ẏ   vg +vd
sin θ 
   2 
   vd −vg 
 θ̇ = ℓ .
   
 v̇g   Ru1 
v̇d Ru2

Prenons pour sortie


y1 = θ
vg +vd
y2 = 2 ,
où y2 représente la vitesse du milieu de l’essieu. Dérivons successivement y1 et y2 jusqu’à faire apparaître les
entrées u1 ou u2 . On obtient :
vd − vg
ẏ1 = θ̇ = (on dérive encore une fois)

R
ÿ1 = θ̈ = (u2 − u1 )

R
ẏ2 = (u2 + u1 ) ,
2
soit     
ÿ1 − Rℓ R
ℓ u1
= R R .
ẏ2 2 2 u2
  
A(x)

Si on effectue le bouclage
      
u1 v1 1 −ℓ 2 v1
= A−1 (x) = ,
u2 v2 2R ℓ 2 v2

où v = (v1 , v2 ) est le vecteur des nouvelles entrées, on obtient le système


   
ÿ1 v1
SL : =
ẏ2 v2
114 Commande par espace d’état

qui peut lui aussi être commandé par un deuxième bouclage. Choisissons une commande proportionnelle et dérivée
de façon à avoir uniquement des pôles égaux à −1 :
  
v −v
v1 = (w1 − y1 ) + 2 (ẇ1 − ẏ1 ) + ẅ1 = w1 − θ + 2 ẇ1 − d ℓ g + ẅ1
vg +vd
v2 = w2 − y2 + ẇ2 = w2 − 2 + ẇ2 .
Si on souhaite que le char suive une trajectoire en forme de cercle de la forme

xd = w1 = cos t
yd = w2 = sin t

il nous faudra choisir   


vd −vg
v1 = −θ + 2 − sin t − ℓ
vg +vd
v2 = sin t − 2 + cos t.
Finalement la commande à donner au char est donnée par
      
v −v
u1 1 −ℓ 2 −θ + 2 − sin t − d ℓ g
= v +v
.
u2 2R ℓ 2 sin t − g d + cos t 2

7.6 Régulation de la voiture

On rappelle que l’équation d’évolution de la voiture (voir page 28) est donnée par
   
ẋ v cos δ cos θ
 ẏ   v cos δ sin θ 
   
   v sin δ 
 θ̇  = L .
   
 v̇   u1 
δ̇ u2
Le but de ce paragraphe est de faire décrire à notre voiture diverses trajectoires en utilisant le principe de la
linéarisation par bouclage.

7.6.1 Voiture décrivant un hexagone

Choisissons pour sortie le vecteur y = (v, θ)T . La dérivée des sorties y1 et y2 s’exprime par

ẏ1 = v̇ = u1 ,
v sin δ
ẏ2 = θ̇ = .
L
Comme la dérivée ẏ2 de y2 ne fait pas apparaître l’entrée, on la redérive une nouvelle fois :
sin δ v δ̇ cos δ sin δ v cos δ
ÿ2 = v̇ + = u1 + u2 .
L L L L
Les expressions pour ẏ1 et ÿ2 peuvent se réécrire sous forme matricielle
    
ẏ1 1 0 u1
= sin δ v cos δ .
ÿ2 L L u2
  
A(x)
Commande non linéaire des systèmes non linéaires 115

En imposant le bouclage
u = A−1 (x) v,

où v est la nouvelle entrée, notre système bouclé se récrit,


   
ẏ1 v1
SL : = ,
ÿ2 v2

et devient donc linéaire et découplé. Nous avons donc affaire à deux systèmes monovariables découplés. Le premier,
d’ordre 1, peut être stabilisé par une commande proportionnelle. Pour le second, du deuxième ordre, une commande
de type proportionnelle et dérivée) est adaptée. Si w = (w1 , w2 )T représente la consigne pour y, cette commande
s’exprime par

v1 = α0 (w1 − y1 ) + ẇ1
RL :
v2 = β 0 (w2 − y2 ) + β 1 (ẇ2 − ẏ2 ) + ẅ2 .

Si on souhaite avoir pour pôles que des −1, il faut (voir équation (7.4))

s + α0 = s + 1
s + β 1 s + β 0 = (s + 1)2 = s2 + 2s + 1,
2

soit
α0 = β 0 = 1, β 1 = 2.

Donc les équations d’un régulateur par retour d’état RNL pour notre système non linéaire sont données par
  
1 0 α0 (w1 − v) + ẇ1
u=   (7.10)
− tan
v
δ L
v cos δ β 0 (w2 − θ) + β 1 ẇ2 − v sin
L
δ
+ ẅ2

Notons que ce régulateur n’admet aucune variable d’état. Il s’agit donc d’un régulateur statique.

Remarque 7.6.1 Remarquons que


v cos δ
det (A(x)) =
L
ce qui signifie qu’il existe des singularités pour lesquelles la commande u n’est pas définie. Un traitement adapté
doit être prévu lorsque de telles singularités sont rencontrées par le système.

Afin de faire parcourir à notre voiture un hexagone en marche arrière, à une vitesse de −2ms−1 , nous prendrons
pour consigne

w1 (t) = −2
π
w2 (t) = E (t/10) .
4

Le programme associé a été appelé VoitureHexagone.sce. L’exécution de ce programme rend compte du bon
comportement de notre commande.
116 Commande par espace d’état

7.6.2 Voiture décrivant un cercle

Nous voulons maintenant faire tourner la voiture autour d’un cercle de rayon r0 et à la vitesse v0 . Le nouveau
vecteur de consigne devient c = (r0 , v0 ). Pour cela, choisissons dans le plan (x, y) un champ de vecteur h donné
par
2 R2
R  →   
h: x v x tan−1 (ρ(r − x2 + y 2 )) + v y
r 0 0
→ √ 21 2  .
y x +y vr y tan−1 (ρ(r0 − x2 + y 2 )) − v0 x
Ce champ est représenté sur la figure ci-dessous pour r0 = 5; v0 = 3; vr = 12; ρ = 0.1.

Champ de vecteur désiré pour la voiture ;


ce champ admet pour cycle limite un cercle de rayon r0

Le programme qui trace ce champ a été appelé VoitureChampCycle.sce. Le système associé à ce champ (c’est-
à-dire qu’il est décrit par l’équation différentielle ż = h(z)) admet un cycle limite qui est un cercle de rayon r0 .
Sur ce cercle, nous avons ||ż|| = v0 . Les quantités vr et ρ indiquent respectivement avec quelle vitesse l’état z se
rapproche du cercle limite lorsque ce dernier est loin ou proche du disque. Afin de faire suivre aux coordonnées
(x, y) de la voiture, cette dynamique, il semble naturel d’imposer
   
ẋ x
=h = h (c, x, y) .
ẏ y

La notation h (c, x, y) nous rappelle la dépendance du champ en c = (r0 , v0 ) . Or,


     
ẋ v cos δ cos θ w1 cos w2
= ≃
ẏ v cos δ sin θ w1 sin w2

car w1 est une consigne pour la vitesse de la voiture et w2 pour son cap. Pour choisir w nous devons donc tenter
de résoudre  
w1 cos w2
= h (c, x, y) .
w1 sin w2
Commande non linéaire des systèmes non linéaires 117

Ainsi, nous obtenons

w1 = h (c, x, y) et w2 = argθ (h (c, x, y)) ,

où arg retourne l’angle entre −π + θ et π + θ du vecteur h(c, x, y). Ainsi, d’après la formule (7.10), les équations
de notre régulateur sont

  
1 0 α0 (h (c, x, y) − v)
u= .
− tan
v
δ L
v cos δ β 0 (argθ (h (c, x, y)) − θ) − β 1 v sin
L
δ

Ici, nous avons pris ẇ2 = 0 alors que w2 est loin d’être constante. Pour plus de précision, il faudrait la calculer et
mettre son expression dans celle de la commande u. Le régulateur obtenu est à nouveau un régulateur statique
(c’est-à-dire, sans état). Si nous appliquons cette commande, sur la voiture, nous nous apercevons que la voiture
tourne effectivement autour d’un cercle, mais qu’il existe un large biais. Plus précisément, le rayon du cercle
parcouru et la vitesse de la voiture sur ce cercle sont différents de ceux rentrés dans la consigne c et que cette
différence n’est pas négligeable. Ce phénomène est principalement dû au fait la consigne a été supposée constante
alors qu’elle ne l’est pas. Afin de supprimer simplement ce biais, nous pouvons rajouter un effet intégrateur. En
choisissant un coefficient de 15 pour l’intégrateur, les équations d’état obtenues pour le régulateur sont

   

 x2 + y 2
 = c−
 ż

v
  #  # 

 1 0 #h c + z , x, y # − v
   5 
 u =

− tan δ L
argθ h c + z5 , x, y − θ − 2 v sin δ .
v v cos δ L

La figure représente l’effet obtenu. Le programme associé a été appelé VoitureCycle.sce.

Voiture convergeant vers un cercle limite


118 Commande par espace d’état

7.7 Régulation du bateau à voile

Reconsidérons à nouveau le bateau à voile modélisé au paragraphe 2.4.4 de la page 29. Rappelons que les équations
d’état du bateau à voile sont données par


 ẋ = v cos θ,



 ẏ = v sin θ − βV,



 θ̇ = ω,



 δ̇ v = u1 ,

δ̇ g = u2 , (7.11)

 1

 v̇ = (fv sin δ v − fg sin δg − αf v) ,

 m

 ω̇ = 1
((ℓ − rv cos δ v ) fv − rg cos δ g fg − αθ ω) ,

 J

 fv = αv (V cos (θ + δ v ) − v sin δ v ) ,



fg = αg v sin δ g .

Nous allons ici chercher à stabiliser les valeurs de x et y autour de certaines valeurs désirées xd et yd . Notons tout
d’abord qu’il n’est pas possible d’obtenir une stabilisation exacte si V = 0, même dans le cas idéal, car on ne
peut annuler simultanément ẋ,ẏ, ẍ, ÿ. On peut le montrer formellement, bien que cette opération soit loin d’être
triviale, même avec l’aide d’un logiciel de calcul formel comme M
 [1]. On peut aussi prouver l’absence de point
d’équilibre grâce à un solveur numérique utilisant le calcul par intervalles [9]. Puisqu’une stabilisation exacte ne
peut être envisagée, nous allons tenter une stabilisation approximative de x et y autour des valeurs de consigne.

Afin de bien comprendre l’approche choisie, considérons la situation d’un moniteur de bateau à voile, dans son
Zodiac, dictant à distance à un apprenti (qui apprend à manœuvrer le bateau) comment amener le bateau sur
une cible (xd , yd ). Le moniteur donnera à l’apprenti des consignes du type «prend la direction de la pointe», ou
bien «relâche un peu la voile» et l’apprenti cherchera à suivre ces consignes. On fait alors apparaître deux types
de régulation.

— la régulation de bas niveau, faite par l’apprenti qui consiste à tirer sur l’écoute de la voile et manœuvrer le
gouvernail dans le but de respecter les consignes du moniteur ;
— la régulation de haut niveau faite par le moniteur, qui consiste à générer une suite de consignes (sur le cap et
sur l’ouverture de la voile) dans le but d’arriver à l’objectif choisi, à savoir atteindre la cible.

Dans une première étape, pour réaliser la commande de bas niveau, nous allons utiliser une méthode de linéarisation
par bouclage statique qui nous permettra de stabiliser le cap du bateau ainsi que l’ouverture de la voile. Dans une
deuxième étape, pour la régulation de haut niveau, nous proposerons un second régulateur à états discrets qui
nous permettra de maintenir le bateau dans une zone autour du point (xd , yd ).

7.7.1 Dérivations successives des variables d’état

Rappelons que pour appliquer une méthode de linéarisation par bouclage, il nous faut tout d’abord dériver les
variables d’état, une ou plusieurs fois par rapport au temps t, et ceci jusqu’à faire apparaître les entrées u1 ou u2 .

Dans les quantités exprimées par les équations (7.11), seules δ̇ v et δ̇ g sont liées algébriquement à u. Les autres
quantités sont reliées à u, mais indirectement (c’est-à-dire différentiellement). Rangeons-les dans la liste L des
variables dépendant algébriquement de u. On a donc L = {δ̇ v , δ̇ g }. Il nous faut dériver uniquement celles qui ne
Commande non linéaire des systèmes non linéaires 119

dépendent pas algébriquement de u, c’est-à-dire, ẋ, ẏ, θ̇, v̇ et ω̇. On obtient




 ẍ = v̇ cos θ − vθ̇ sin θ,



 ÿ = v̇ sin θ + vθ̇ cos θ,



 θ̈ = ω̇,
f˙v sin δ v +fv u1 cos δ v −f˙g sin δ g −fg u2 cos δ g −αf v̇ (7.12)

 v̈ = m ,

 u1 rv sin δ v fv +(ℓ−rv cos δv )f˙v

 ω̈ =

 J

 rg (u2 sin δg fg −cos δ g f˙g )−αθ ω̇
+ J .
avec 
 f˙v =
 −αv V (ω + u1 ) sin (θ + δ v )
−αv v̇ sin δv − αv vu1 cos δ v

 f˙ =
g αg (v̇ sin δ g + vu2 cos δg ) .
Notons que, puisque les grandeurs v̇, θ̇, ω̇ sont des fonctions analytiques de l’état (voir (7.11)), on peut considérer
que nous avons ici une expression analytique de ẍ, ÿ, θ̈, v̈, ω̈ en fonction de l’état et des entrées. Rangeons dans L
les quantités qui dépendent algébriquement de u, c’est-à-dire v̈ et ω̈, d’où L = {δ̇ v , δ̇g , v̈, ω̈, f˙v , f˙g }. Et dérivons à
nouveau celles qui ne dépendent pas algébriquement de u, c’est-à-dire ẍ, ÿ et θ̈. On obtient
 ... 2

 x = v̈ cos θ − 2v̇θ̇ sin θ − vθ̈ sin θ − v θ̇ cos θ
... 2
y = v̈ sin θ + 2v̇θ̇ cos θ + vθ̈ cos θ − v θ̇ sin θ (7.13)

 ...
θ = ω̈.
Puisque toutes ces quantités dépendent algébriquement de u, on s’arrête ici de dériver. Notons à nouveau, que les
équations (7.13) peuvent s’interpréter (via les équations (7.12) et (7.11)) comme des expressions analytiques des
... ... ...
grandeurs x , y , θ en fonction de l’état et des entrées.

7.7.2 Linéarisation par bouclage du bateau

Rappelons que les sorties (ce sont en fait des variables consignées) choisies sont l’ouverture de la voile y1 = δv et
le cap y2 = θ. Nous avons
      
ẏ1 δ̇ v 1 0 u1
... = ... = rv rg
y2 θ J fv sin δ v J fg sin δ g u2
  
A1 (x)
    
0 0 f˙v 0
+ + .

J − rv
J cos δ v − rJg cos δ g f˙g − αJθ ω̇
     
A2 (x) b1 (x)

Or
    
f˙v −αv (V sin (θ + δ v ) + v cos δv ) 0 u1
=
f˙g 0 αg v cos δg u2
  
A3 (x)
 
−αv (V ω sin (θ + δv ) + v̇ sin δ v )
+ .
αg v̇ sin δ g
  
b2 (x)
120 Commande par espace d’état

Ainsi, on a une relation de la forme


 
ẏ1
... = A1 u + A2 (A3 u + b2 ) + b1
y2
= (A1 +A2 A3 ) u + A2 b2 + b1 = Au + b.
...
Pour imposer (ẏ1 , y 2 ) à une certaine consigne v = (v1 , v2 ) , il nous faut prendre

u = A−1 (x) (v − b(x)) .

Le système ainsi bouclé est régi par les équations différentielles



ẏ = v1 ,
SL : ...1 (7.14)
y 2 = v2 .

qui sont linéaires et découplées. Le système linéarisé est d’ordre 4 au lieu de 7. Nous avons donc perdu le contrôle
sur 3 variables qui se trouvent être x, y et v. La perte de contrôle sur x et y était prévisible (on veut que le bateau
avance et il est naturel que cela corresponde à une instabilité pour ces deux variables x et y). Quant à la perte
de contrôle sur v, elle est sans conséquence car la dynamique associée est stable. Comment en effet concevoir que
le bateau puisse maintenir un cap et une ouverture de voile fixes, sans que sa vitesse ne converge vers une valeur
finie ?

Déterminons maintenant les singularités de notre bouclage linéarisant. On montre aisément que
rg  
det (A(x)) = fg sin δ g − vαg cos2 δ g ,
J
est nul si
 
v 2 sin2 δ g − 1 = 0,
c’est-à-dire si
π π
v = 0 ou bien δ g =+k . (7.15)
4 2
Une telle configuration correspond à une singularité qu’il faudra tenter d’éviter.

Nous avons affaire à deux systèmes monovariables découplés. Notons w = (w1 , w2 )T la consigne pour y. Nous
noterons parfois w = (δ̂ v , θ̂) pour rappeler que w1 et w2 sont les consignes correspondant à l’angle d’ouverture
de la voile et au cap. Choisissons le régulateur donné de type PID (en fait, il faudrait dire PID2, car la dérivée
deuxième est utilisée) donné par


 v1 = α0 (w1 − y1 ) + ẇ1 ,
RL : v2 = β 0 (w2 − y2 ) + β 1 (ẇ2 − ẏ2 )

 ...
+β 2 (ẅ2 − ÿ2 ) + w 2 .

Si on souhaite avoir pour pôles uniquement des −1, (voir équation (??)) il nous faut

s + α0 = s + 1,
s + β 2 s + β 1 s + β 0 = (s + 1)3 = s3 + 3s2 + 3s + 1,
3 2

soit
α0 = β 0 = 1, β 1 = 3, β 2 = 3.
Commande non linéaire des systèmes non linéaires 121

En supposant la consigne w constante, les équations d’état du régulateur par retour d’état pour notre système
non linéaire sont données par
  
w 1 − δ v
u = A−1 (x) − b(x) . (7.16)
w2 − θ − 3θ̇ − 3θ̈

Or θ̇ et θ̈ sont des fonctions analytiques de l’état x. En effet, d’après les équations (7.11) et (7.12), on a

θ̇ = ω,
(ℓ−rv cos δ v )fv −rg cos δg fg −αθ ω
θ̈ = J .
L’équation (7.16) peut donc se récrire sous la forme
 
u = r (x, w) = r x,δ̂ v , θ̂ .

Ce régulateur est statique car il n’admet aucune variable d’état.

7.7.3 Régulateur hybride


 
Le régulateur r x,δ̂v , θ̂ développé dans la section précédente permet de stabiliser notre bateau pour un cap θ̂ et
une ouverture de voile δ̂ v désirés. Or, ce qui nous intéresse est de stabiliser le bateau autour d’une zone centrée en
un point de coordonnées (xd , yd ). En manœuvrant le gouvernail et l’angle d’ouverture de la voile, il est possible
de rester autour du point désiré.
 
Nous allons ici proposer un automate capable de générer les consignes w = δ̂ v , θ̂ pour notre régulateur afin
que notre bateau se trouve comme attiré par le point (xd , yd ) . Contrairement aux autres approches de régulation
classiques, l’élaboration de cet automate sera guidée par une connaissance empirique du pilotage d’un voilier, plus
que par une prise en compte des équations d’états du système.

Ainsi, nous allons considérer quatre caps privilégiés (à 2kπ près) donnés par
7π 5π π 5π
θ̂1 = , θ̂ 2 = , θ̂3 = et θ̂ 4 = ,
4 4 6 6
comme illustré par la figure. A chacun de ces caps désirés, nous associons un état discret q ∈ {1, 2, 3, 4}.

Quatre caps privilégiés générés par l’automate


122 Commande par espace d’état

Les caps θ̂ 1 et θ̂2 correspondent à une situation de vent arrière alors que θ̂3 et θ̂ 4 correspondent à une situation
de remonté au vent. Le passage d’un cap désiré à l’autre se fait suivant la position relative du bateau par rapport
au point désiré. Par exemple, si q = 3 et que x − xd > a (où a est une constante de tolérance positive), alors, q
prend la valeur 4 (qui fera décroître x). L’automate qui réalise ces changements d’état apparaît dans le bloc du
bas de la figure ci-dessous.

Schéma du régulateur qui maintient notre bateau


dans une zone désirée de l’océan

 
Afin d’éviter le passage brutal d’un cap désiré à l’autre, ce qui risque de déstabiliser notre commande r x,δ̂ v , θ̂
(qui suppose une consigne constante), il convient d’imposer un changement en douceur, c’est le rôle des systèmes
du premier ordre situés dans les cases de l’automate qui effectuent un filtrage des hautes fréquences. La fonction
 
  θ̂ − θ̂i
arg θ̂, θ̂i = θ̂i + 2π.round ,

renvoie l’angle égal à θ̂i (à 2kπ près), qui est le plus proche de θ̂. Son rôle est d’éviter les sauts brutaux dans la
génération de θ̂ et le phénomène de déroulement, qui tend à faire tourner inutilement les éléments (voile et bateau)
afin de respecter scrupuleusement les égalités entre les angles alors qu’une égalité à 2π-près suffit. La sortie de
notre automate est le cap désiré θ̂, il nous reste alors à trouver l’ouverture de la voile δ̂ v à demander à notre
régulateur. L’angle d’ouverture de la voile ne servant qu’à la propulsion du bateau, il est concevable de la rendre
fonction du cap. Une fonction assez naturelle est celle donnée par la figure ci-dessous.
Commande non linéaire des systèmes non linéaires 123

 
Fonction d’ouverture ϕ θ̂ choisie

Son expression est donnée par  


θ 1 π θ
δ̂ v = ϕ (θ) = π.floor + + −
2π 4 4 2
où floor est la fonction qui renvoie la partie entière d’un réel. Notons que lorsque nous demandons au bateau
d’aller face au vent (θ̂ ≃ π/2 + kπ), l’angle d’ouverture demandé δ̂ v sera nul (ϕ(θ̂) ≃ 0) alors qu’en vent arrière
(θ̂ ≃ −π/2 + 2kπ), la voile sera grand ouverte (ϕ(θ̂) ≃ π/2 + kπ). Le schéma complet du régulateur ainsi conçu est
représenté en pointillé sur la figure ci-dessous. Le système bouclé est admet pour entrées xd et yd et le régulateur
se charge d’amener le bateau autour du point désiré et de l’y maintenir.

La figure ci-dessous illustre le fait que pour toute condition initiale, le bateau régulé semble converger vers un
cycle limite unique, centré sur le point de consigne.

Trajectoire du bateau à voile régulé pour deux conditions initiales différentes


124 Commande par espace d’état
Chapitre 8

Identification

8.1 Fonctions quadratiques

8.1.1 Définition

Une fonction quadratique f : Rn → R est une fonction de la forme

f(x) = xT Qx + Lx + b

où Q est une matrice symétrique. Cette définition est équivalente à dire que f(x) est une combinaison linéaire
d’une constante b, des xi , de leur carré x2i et des produits croisés xi xj où i = j. Par exemple, si f (x1 , x2 ) =
2x21 − 6x1 x2 + x22 − 2x1 + x2 + 1, on a
    
2 −3 x1 x1
f(x) = (x1 x2 ) + (−2 1) +1 (8.1)
−3 1 x2 x2

Nous allons montrer dans la suite que la fonction dérivée de f au point x est une fonction affine. Pour notre
exemple, la dérivée de f au point x est donnée par
 
df ∂f ∂f
(x) = (x) (x)
dx ∂x1 ∂x2
∂f ∂f
avec ∂x1 (x) = 4x1 − 6x2 − 2 et ∂x2 (x) = −6x1 + 2x2 + 1, c’est-à-dire

df
(x) = (4x1 − 6x2 − 2 ; −6x1 + 2x2 + 1) .
dx
Il s’agit d’une fonction affine en x. La fonction, x → xT Qx qui compose f(x) ne comporte que des termes en xi xj
et en x2i . Une telle fonction est appelée forme quadratique.

8.1.2 Dérivée d’une forme quadratique

Considérons la forme quadratique


f(x) = xT Qx.

125
126 Commande par espace d’état

Le développement de Taylor à l’ordre 1 de f au point x au voisinage de x, nous donne :


df
f (x+δx) =f(x)+ (x)δx + o (||δx||) (8.2)
dx
df
où o (||δx||) signifie "négligeable devant ||δx||", lorsque δx est infiniment petit. Bien sur, ici, dx (x) sera représentée
par une matrice 1 × n car, tout comme la fonction qu’on linéarise, elle va de Rn vers R. Or,
f (x+δx) = (x + δx)T Q (x + δx)
= xT Qx + xT Qδx + (δx)T Qx + (δx)T Q (δx) (8.3)
= xT Qx + 2xT Q (δx) + o (||δx||)
car Q est symétrique et δxT Qδx = o (||δx||). Par unicité du développement de Taylor, et d’après les formules (8.2)
et (8.3), nous avons  
df ∂f ∂f
(x) = (x), . . . , (x) = 2xT Q.
dx ∂x1 ∂xn
Par exemple, la dérivée de la fonction quadratique (8.1) est donnée par
 
2 −3
2 (x1 x2 ) + (−2 1) = (4x1 − 6x2 − 2 ; −6x1 + 2x2 + 1) .
−3 1

8.1.3 Valeurs propres d’une fonction quadratique

Ce sont les valeurs propres de Q. Les valeurs propres sont toutes réelles et les vecteurs propres sont tous deux à
deux orthogonaux. Les courbes de niveaux d’une fonction quadratique f(x) = α sont de la forme

xT Qx + Lx = α − b
et sont appelées quadriques. Ce sont des ellipsoïdes si toutes les valeurs propres sont de même signe ou des
hyperboloïdes si elles ont des signes distincts. Si toutes les valeurs de Q sont positive, on dit que la forme
quadratique xT Qx est positive. Si elle sont toutes non-nulles, on dit que la forme quadratique est définie. Si elles
sont toutes strictement positives, on dira que la forme quadratique est définie positive. La fonction quadratique f
admet un et un seul minimum si et seulement si sa forme quadratique associée est définie positive.

8.1.4 Minimisation d’une fonction quadratique

Si f(x) = xT Qx + Lx + b admet un et un seul minimiseur x∗ si Q est définie positive. Dans ce cas,


df ∗
(x ) = 0
dx
Donc
2x∗T Q + L = 0,
c’est-à-dire
1
x∗ = − Q−1 LT .
2
Son minimum est donné par
     
∗ 1 −1 T T 1 −1 T 1 −1 T
f(x ) = − Q L Q − Q L +L − Q L +b
2 2 2
1 1 1
= LQ−1 LT − LQ−1 LT + b = − LQ−1 LT + b.
4 2 4
Commande non linéaire des systèmes non linéaires 127

Par exemple, pour la fonction (8.1), le minimiseur est donné par


 −1    
1
1 2 −3 −2
x∗ = − = 14 .
2 −3 1 1 − 27
et son minimum est  −1  
1  2 −3 −2 11
f(x∗ ) = − −2 1 +1= .
4 −3 1 1 14

8.2 Méthode des moindres-carrés

8.2.1 Introduction à l’estimation

Estimer, c’est obtenir un ordre de grandeur sur certaines quantités d’un système à partir de mesures d’autres
quantités de ce même système. Le problème d’estimation que nous allons considérer dans ce chapitre est le
suivant. Soit un système sur lequel on a effectué des mesures y = (y1 , . . . , yp ) et un modèle M(p) dépendant d’un
vecteur de paramètres p. Il nous faut estimer p tel que les sorties ym (p) générées par M(p) ressemblent le plus
possible à y.

8.2.2 Méthode des moindres carrés

Supposons que le vecteur des sorties puisse se mettre sous la forme

ym (p) = Mp.

Le modèle est alors qualifié de linéaire par rapport aux paramètres. Nous voudrions avoir

ym (p) = y

mais cela n’est généralement pas possible à cause de la présence du bruit et du fait que le nombre de mesures est
généralement supérieur au nombre de paramètres (c’est-à-dire dim(y) > dim(p)). Nous allons donc chercher le
meilleur p, c’est-à-dire, celui qui minimise le critère, dit des moindres-carrés,

j(p) = ||ym (p) − y||2 .

Nous avons

j(p) = ||ym (p) − y||2 = ||Mp − y||2


 
= (Mp − y)T (Mp − y) = pT MT −yT (Mp − y)
= pT MT Mp − pT MT y − yT Mp + yT y
= pT MT Mp − 2yT Mp + yT y.
 T
Or MT M est symétrique (car MT M = MT M). On a donc une fonction quadratique. De plus, MT M a toutes
ses valeurs propres positives ou nulle. Le minimiseur p̂ s’obtient résolvant
dj
dp (p̂) = 0 ⇔ 2p̂T MT M − 2yT M = 0 ⇔ p̂T MT M = yT M
 −1 T
⇔ MT Mp̂ = MT y ⇔ p̂ = MT M M y.
 −1 T
La matrice MT M M s’appelle inverse généralisée de la matrice rectangulaire M.
128 Commande par espace d’état

8.2.3 Exemple de la parabole

On cherche à trouver une parabole p1 t2 + p2 t + p3 qui passe par n points donnés dans le tableau suivant

t −3 −1 0 2 3 6
y 17 3 1 5 11 46
√ ∗
Pour obtenir ces mesures, nous avons pris p∗1 = 2, p2 = −1, p∗3 = 1, pour en déduire les mesures non bruitées

y∗ = (16.72; 3.41; 1; 4.65; 10.73; 45.91)T .

Ensuite, nous avons tronqué à l’entier le plus proche. La ligne d’instruction sous S est donnée par

t=[-3 ;-1 ;0 ;2 ;3 ;6],y1=sqrt(2)*t^2-t+1,y=round(y1)

Le vecteur des mesures est donc y = (17 3 1 5 11 46)T et le vecteur des paramètres est p = (p1 p2 p3 )T . La sortie
modèle est    
ym,1 (p) = 9p1 − 3p2 + p3 9 −3 1
 ym,2 (p) = p1 − p2 + p3   1 −1 1   
    p
 y (p) = 0p − 0p + p   0 0 
1 
1
 m,3 1 2 3   
ym (p) =  =   p2 
 ym,4 (p) = 4p1 + 2p2 + p3   4 2 1 
    p3
 ym,5 (p) = 9p1 + 3p2 + p3   9 3 1 
ym,6 (p) = 36p1 + 6p2 + p3 36 6 1
Le vecteur estimé au sens des moindres-carrés est
 
1.41
 −1 T  
p̂ = MT M M y =  −0.98 
1.06

Les mesures filtrées sont

ŷ = ym (p̂) = Mp̂ = (16.76 ; 3.46 ; 1.06 ; 4.76 ; 10.84 ; 46.11)T .

8.2.4 Moteur à courant continu

La vitesse angulaire Ω d’un moteur à courant continu en régime permanent dépend linéairement de la tension
d’alimentation U et du couple résistant Tr :

Ω = p1 U + p2 Tr .

On effectue une série d’expériences sur un moteur particulier. On mesure :

U (V) 40 100 100 130 150 150


Tr (Nm) 0 0 20 20 10 30
Ω(tr/ min) 490 1210 1090 1410 1730 1630

On a
ym (p) = M.p
Commande non linéaire des systèmes non linéaires 129

avec    
40 0 490
 100 0   1210 
     
 100 20  p1  1090 
   
M = , p = et y =  .
 130 20  p2  1410 
   
 150 10   1730 
150 30 1630
Donc  
 −1 T 11.98
p̂ = MT M M y= .
−6.02
Nous pouvons alors en déduire la vitesse angulaire du moteur pour d’autres valeurs de U et Tr . Par exemple pour
U = 200 V et Tr = 10 Nm, on a
 
    11.98
Ω̂ = U Tr p̂ = 200 10 = 2335tr/ min
−6.02

8.2.5 Estimation d’une fonction de transfert

On considère le système décrit par les équations de récurrence

y(k) + a1 y(k − 1) + a0 y(k − 2) = b1 u(k − 1) + b0 u(k − 2). (8.4)

Sur ce système, on effectue des mesures plus ou moins bruitées de l’entrée u(k) et la sortie y(k) pour k variant de
0 à 7. On obtient
k 0 1 2 3 4 5 6 7
u(k) 1 −1 1 −1 1 −1 1 −1
y(k) 0 −1 −2 3 7 11 16 36
A partir ces mesures, on cherche à estimer le vecteur des paramètres

p = (a1 , a0 , b1 , b0 )T .

Les équations de récurrence (8.4) pour k = 2 jusqu’à 7 sont

y(2) = −a1 y(1) − a0 y(0) + b1 u(1) + b0 u(0)


y(3) = −a1 y(2) − a0 y(1) + b1 u(2) + b0 u(1)
..
.
y(7) = −a1 y(6) − a0 y(5) + b1 u(6) + b0 u(5)

Donc la matrice M est donnée par


     T 
−y(1) −y(0) u(1) u(0) 1 0 −1 1 m2
 −y(2) −y(1) u(2) u(1)   2 1 1 −1   mT 
     3 
   −1 1   
 −y(3) −y(2) u(3) u(2)   −3 2   mT 
M = =  =  4T 
 −y(4) −y(3) u(4) u(3)   −7 −3 1 −1   m5 
     
 −y(5) −y(4) u(5) u(4)   −11 −7 −1 1   mT 6

−y(6) −y(5) u(6) u(5) −16 −11 1 −1 mT
7
130 Commande par espace d’état

Le vecteur
m(k) = (−y(k − 1), −y(k − 2), u(k − 1), u(k − 2))T

contient l’information reliant la kième mesure à l’inconnue p. Il est appelé régresseur. Comme ces k équations ne
sont pas tout-à-fait satisfaites car les u(i) et les y(i) ne sont connus que de façon approximative, on cherche à
trouver le vecteur p̂ qui minimise le critère
2
j(p)  ||Mp − y||

avec
 
−2  
   3  a1
y(2)  
 7   a0 
 ..     
y= . =  et p =  .
 11   b1 
y(7)  
 16  b0
36
 −1 T
Nous devrions avoir p̂ = MT M M y Or ici, la matrice M est de rang 3. En effet, du fait de la forme
particulière du signal u(k), les deux dernières colonnes de M sont dépendantes. Dans notre cas, nous ne pouvons
donc pas identifier p. Cette situation demeure toutefois atypique.

8.2.6 Cas non-linéaire

Si y est le vecteur des mesures et si ym (p) est la sortie générée par le modèle, alors l’estimée au sens des moindres
carrés est défini par
p̂ = arg minn ||ym (p) − y||2 .
p∈R

Lorsque ym (p) est linéaire par rapport à p, c’est-à-dire ym (p) = Mp alors le vecteur des paramètres p̂ estimé au
 −1  −1
sens des moindres-carrés est p̂ = MT M My et le vecteur des mesures filtrées est ŷ = M MT M My. En
général, et même lorsque ym (p) est non-linéaire, on peut faire l’interprétation géométrique suivante :

— le vecteur des mesures filtrées ŷ représente la projection de y sur l’ensemble ym (Rn ) .


— le vecteur estimé au sens des moindres carrés p̂ représente l’image inverse par ym (.) du vecteur des mesures
filtrées y.

Lorsque ym (p) est non-linéaire, on peut utiliser un algorithme d’optimisation local pour espérer obtenir p̂. La
table ci-dessous en propose une version simple, qui est censé converger vers un optimum local du critère j(p) =
||ym (p) − y||2 . La quantité δp représente un petit vecteur tiré aléatoirement dans Rn .
Commande non linéaire des systèmes non linéaires 131

input p
1 j + = j(p);
2 q = p + δp;
3 if j (q) < j + {p = q; j + = j(q)} ;
4 goto 2.

8.3 Localisation d’un robot

On considère le robot de la figure ci-dessous. Ce robot possède 8 capteurs capables de lui donner les distances des
premiers obstacles suivant les directions d’angles kπ 4 , k ∈ {0, . . . , 7}. Les obstacles sont supposés être n segments
de droites [ai bi ] , i = 1, . . . , n, où les ai et bi , exprimés dans le repère de la pièce sont connus du robot. Les 8
distances sont rangées dans le vecteur des mesures y. Proposons nous de retrouver la position et l’orientation du
robot à partir du vecteur des distances mesurées y.

Pour cela, il nous faut, tout d’abord, développer un simulateur ym (p) qui nous génère nos 8 distances à partir de la
connaissance de p. Ce simulateur peut être représenté par un algorithme ayant pour entrée le vecteur p = (x, y, θ)T
et pour sortie le vecteur formé des 8 distances fournies par les capteurs. Dans la suite, les coordonnées du centre
m du robot seront notées (x, y) et ũ sera un vecteur unitaire représentant la direction du faisceau. Pour le kième
capteur, l’expression du vecteur directeur ũ du faisceau lancé par le capteur est

   
cos kπ + θ
ũ =  4  , k ∈ {0, . . . , 7}.
sin kπ
4 +θ
132 Commande par espace d’état

En s’inspirant de l’algorithme de calcul de distance élaboré au paragraphe 6.6.1 de la page 99, nous obtenons le
simulateur ym (p) donné par la table ci-dessous

input : (x, y, θ)
for i = 1 to 8    
(i−1)π
ũ = cos 4 + θ ; sin (i−1)π
4 + θ ; ℓi = ∞;
T
m = (x y) ;
for j = 1 to n
if det (aj −m, ũ) . det (bj −m, ũ) ≥ 0 then next j ;
det(m−aj −m,bj −aj ) (8.5)
α := det(ũ,bj −aj )
if α < 0 then next j ;
ℓi := min (ℓi , α) ;
next j
next i;
return (ℓ1 , . . . , ℓ8 ) ;

A l’aide d’une méthode de type Monté-Carlo, on peut retrouver p̂, l’optimiseur au sens des moindres-carrés, à
partir de y.

8.4 Moindres-carrés récursifs

8.4.1 Principe

On considère k équations linéaires en p ∈ Rn de la forme mT


i p = y(i). Nous supposerons que k ≥ n, où n est la
dimension de p. On a
    


 mT0p = y(0) mT 0 y(0)

 mT p    
1 = y(1)  mT 1   y(1) 
.. .. .. ⇔
 .. p = 
  ..  ⇔ Mk p = yk
 (8.6)

 . . .  .   . 


 mT p = y(k − 1) mT y(k − 1)
k−1 k−1

Le point p̂k qui minimise le critère

k−1
  T 2
j(p)  ||Mk p − yk ||2 = mi p−y(i)
i=0

est donné par


p̂k = (MT −1 T
k Mk ) Mk yk

La suite du problème consiste à trouver des équations récursives pour p̂k , c’est-à-dire des équations d’état de la
forme

x (k + 1) = f (x (k) , mk , y (k))
p̂k = g(x (k))
Commande non linéaire des systèmes non linéaires 133

Posons ∆k = MT T
k Mk et vk = Mk yk . Nous avons
  
   M

 T k
= MT T
 ∆k+1 =
 Mk mk T k Mk + mk mk

 m
 k 
  y
k


 vk+1 = MT k mk = MTk yk + mk y(k)

 y(k)


p̂k = ∆−1k vk

On peut donc exprimer ∆k+1 , vk+1 en fonction de ∆k et vk et mk et y(k). Ainsi, les équations d’état pour générer
les p̂k sont données par 

 (i) ∆k+1 = ∆k + mk mT k
(ii) vk+1 = vk + mk .y(k) (8.7)

 (iii) p̂
k = ∆−1
k vk .

Le vecteur d’état x (k) contient les coefficients de la matrice ∆k et ceux du vecteur vk . Les entrées de ce système
sont mk et y(k).

8.4.2 Première simplification

Nous allons maintenant chercher à obtenir l’équation de la forme


 
p̂k+1 = p̂k + kk y(k) − mT
k p̂k

où apparaissent
la prédiction ŷ(k) = mT
k p̂k
l’erreur de prédiction e(k) = y(k) − mT
k p̂k
 −1
le gain de correction ou gain de Kalman kk = ∆k + mk mT k mk
Pour cela, on procède comme suit :
(8.7,iii)
p̂k+1 = ∆−1
k+1 vk+1
(8.7,ii,iii)
= ∆−1k+1 (∆k p̂k + mk y(k))
−1
= p̂k + ∆k+1 ((∆k − ∆k+1 ) p̂k + mk y(k))
(8.7,i)  T

= p̂k + ∆−1
k+1 . −mk mk p̂k + mk y(k)
(8.7,i)  −1  
= p̂k + ∆k + mk mT k mk y(k) − mTk p̂k .

Les équations d’état pour notre estimateur s’écrivent alors



∆k+1 = ∆k + mk mT k
 −1  
p̂k+1 = p̂k + ∆k + mk mT k mk y(k) − mT
k p̂k

8.4.3 Deuxième simplification

L’estimateur donné ci-dessus nécessite à chaque étape l’inversion de la matrice ∆k + mk mT


k . Dans le but d’éviter
une telle inversion, effectuons le changement de variable

Γk  ∆−1
k
134 Commande par espace d’état

et utilisons le lemme d’inversion matriciel..

Lemme d’inversion matricielle : Si A est une matrice carrée n × n et inversible, B est une matrice colonne
n × 1 et C une matrice ligne 1 × n,
 −1
(A + BC)−1 = A−1 − A−1 B 1 + CA−1 B CA−1 .

Démonstration : La démonstration de ce lemme résulte du calcul suivant


  −1 
A−1 − A−1 B 1 + CA−1 B CA−1 (A + BC)
 −1  −1
= A−1 A + A−1 BC − A−1 B 1 + CA−1 B CA−1 A − A−1 B 1 + CA−1 B CA−1 BC
 −1  −1
= I + A−1 BC − A−1 B 1 + CA−1 B C − A−1 B 1 + CA−1 B CA−1 BC
  −1  −1 
= I + A−1 B 1− 1 + CA−1 B − 1 + CA−1 B CA−1 B C
  −1  
= I + A−1 B 1− 1 + CA−1 B 1 − CA−1 B C
= I + A−1 B (1 − 1) C = I

Appliquons le lemme d’inversion matricielle pour calculer l’inverse de ∆k+1 = ∆k +mk mT


k . Prenons A = ∆k , B = mk
T
et C = mk . On obtient
 −1  −1 T −1
∆−1
k+1 = ∆k + mk mT
k = ∆−1 −1 T −1
k − ∆k mk 1 + mk ∆k mk mk ∆k
∆−1 T −1
k mk mk ∆k
= ∆−1
k −
1 + mT −1
k ∆k mk

soit 
 Γk+1 = Γk − Γk mk mT
k Γk
1+m TΓ m
 k k k   
 p̂k+1 = Γk mk mT Γ
p̂k + Γk − 1+mT Γ kmk mk y(k) − mT
k p̂k .
k k k

En remarquant que
 
Γk mk mT
k Γk Γk mk
Γk − mk = ,
1 + mT Γ m
k k k 1 + mTk Γk mk

on en déduit que 
 Γk+1 = Γk − Γk mk mTk Γk
1+mT
k Γk mk  
 p̂k+1 = p̂k + ΓkTmk y(k) − mT p̂
k k
1+m Γ m k k k

Ce sont des équations d’état où les entrées est y(k) et mk et la sortie est p̂k . Remarquons que, tout comme ∆k
la matrice Γk est symétrique.

Initialisation : Dans un contexte statistique gaussien, Γk représente l’inverse de la matrice de covariance associée
à l’estimé p̂k . Elle caractérise donc l’incertitude. Pour ne donner qu’une vague idée de ce qu’elle représente,
associons au couple (p̂k , Γk ) l’ellipsoïde E d’équation

(p − p̂k )T Γ−1
k (p − p̂k ) ≤ 1.

Cette ellipsoïde, est centré en p̂k et est d’autant plus grand que les valeurs propres de Γk sont grandes. Cette
ellipsoïde contient p̂k avec une très forte probabilité. A l’initialisation, si nous n’avons aucune idée de la valeur de
Commande non linéaire des systèmes non linéaires 135

p∗ , il semble assez logique de poser


 
1
ε 0 0
 1 
T
 0 ε 
p̂0 = (0, 0, . . . , 0) et Γ0 = 
 ..

 0 . 0 

1
0 ε

où ε est très proche de zéro (par exemple 0.001). Ce qui revient à supposer que p∗ est dans une sphère centrée en
zéro et de rayon très grand ( 1ε ).

Remarque (facteur d’oubli) : Pour donner plus d’importance aux dernières mesures et ainsi prendre en compte
une légère évolution de p∗ dans le temps, on multiplie chacune des équations mi p = yi par λk−i , où λ est un
coefficient d’oubli légèrement inférieur à 1 (par exemple 0.99). Ainsi, les équations de récurence (8.7) deviennent
 
λk mT0
  ...
 
 k  2
∆k+1 = k
λ m0 · · · λmk−1 mk    = λk−i
mi mT
T  i
 λmk−1  i=0
mTk
k−1 
 2
= λ2 λ(k−1)−i mi mT i + mk mT 2
k = λ ∆k + mk mk
T

i=0
 
λk y(0)
 
  ..  k  2
. 
vk+1 = k
λ m0 · · · λmk−1 mk 
=
 λk−i
mi y(i)
 λy(k − 1)  i=0
y(k)
k−1 
 
= λ2 λ(k−1)−i mi y(i) + mk y(k) = λ2 vk + mk y(k).
i=1

Ainsi, l’estimateur devient :


  T

 Γk+1 = λ−2 Γk − Γ2k mkTmk Γk
 λ +mk Γk mk  
 p̂k+1 = p̂k + λ−2 Γk mk
y(k) − mT p̂
k
T
1+m Γ m k k k
k

8.5 Filtrage de Kalman

8.5.1 Matrice de covariance

Soit x un vecteur aléatoire, on définit la matrice de covariance Γ de x, la matrice dont les éléments sont

γ ij = E ((xi − x̄i ) (xj − x̄j )) .

Par exemple, traçons sous S un nuage de point gaussien de matrice de covariance égale à l’identité. Cela se
fait par la suite d’instruction suivante :

rand(’normal’),x1=rand(10000,1) ;x2=rand(10000,1) ;plot2d(x1,x2,-1)


136 Commande par espace d’état

Reconstruisons la matrice de covariance grâce à l’instruction :

Gamma=[mean(x1.*x1), mean(x1.*x2) ;mean(x2.*x1), mean(x2.*x2)]

On obtient effectivement une matrice proche de l’identité. Fabriquons maintenant une nouveau vecteur aléatoire
y à l’aide de x à l’aide de l’instruction suivante :

y1=x1+2*x2 ;y2=2*x2+3*x1 ;plot2d(y1,y2,-1)

Le nuage est donné par la figure ci-dessous.

8.5.2 Distribution Gaussienne

La distribution de probabilité d’un vecteur aléatoire gaussien x est entièrement caractérisée par son espérance x̄
et sa matrice de covariance Γx :
 
−n − 12 1 T −1
px (x) = (2π) det(Γx ) exp − (x − x̄) Γx (x − x̄) .
2 (8.8)
2
Commande non linéaire des systèmes non linéaires 137

Le caractère gaussien d’une variable aléatoire se conserve par toute transformation linéaire. Considérons, par
exemple, le vecteur y = Ax, où A est une matrice carrée inversible. Un élément de volume dx se transforme, par
l’application linéaire associée à la matrice A, en un élément de volume dy = | det(A)|dx. On a

px (x)dx = py (y)dx.| det(A)|.

Donc
 
px (A−1 y) (8.8) 1 −n − 1 1  −1 −1
T −1  −1 −1

py (y) = = (2π) 2 det(Γx ) 2 exp − A y − A ȳ Γx A y − A ȳ
| det(A)| | det(A)| 2

Or
 −1 T  −1   −1
A y − A−1 ȳ Γ−1
x A y − A−1 ȳ = (y − ȳ)T AΓx AT (y − ȳ)

et
1
det(Γx )− 2 1 1 1  − 1
= | det(A)|− 2 . det(Γx )− 2 .| det(AT )|− 2 = det AΓx AT 2
| det(A)|

donc
 
−n T − 12 1 T 
T −1
py (y) = (2π) 2 det(AΓx A ) exp − (y − ȳ) AΓx A (y − ȳ)
2

Ainsi, y est aussi une variable aléatoire gaussienne. Son espérance est ȳ = Ax̄ et sa matrice de covariance est
Γy = A.Γx .AT .

Cette propriété se généralise même lorsque A est rectangulaire, de rang quelconque. Soient x1 et x2 sont deux
vecteurs aléatoires gaussiens indépendants, d’espérances x̄1 et x̄2 et de matrices de covariance Γx1 et Γx2 . Le
   
T T est aussi gaussien d’espérance x̄ = x̄T , x̄T T et de matrice de covariance
vecteur x = xT 1 , x2 1 2

 
Γx1 0
Γx = .
0 Γx2

Le vecteur aléatoire  
  x1
y = A1 x1 + A2 x2 = A1 A2
x2

satisfait
 
  x̄1
ȳ = A1 A2 = A1 x̄1 + A2 x̄2 .
x̄2

et
  
  Γx1 0 AT
Γy = A1 A2 1
= A1 Γx1 AT T
1 + A2 Γx2 A2 .
0 Γx2 AT
2

Les opérations linéaires sur les vecteurs aléatoires gaussiens sont donc relativement aisées, du fait que la gaussianité
se conserve par transformation linéaire. Elles se font par calcul direct sur les espérances et sur les matrices de
covariance, qui suffisent à caractériser la distribution gaussienne considérée. Ces opérations se retrouvent dans le
filtre de Kalman auquel nous allons nous intéressés.
138 Commande par espace d’état

8.5.3 Filtre de Kalman

Considérons le système linéaire dépendant du temps



x(k + 1) = A(k)x(k) + B(k)u(k) + v(k)
y(k) = C(k)x(k) + z(k).
Le filtre de Kalman est le système décrit par la représentation d’état suivante :

x̂(k + 1) = A(k) (x̂(k) + K(k). (y(k) − C(k)x̂(k))) + B(k)u(k)
Γx (k + 1) = A(k). (Γx (k) − K(k)C(k)Γx (k)) .AT (k) + Γv (k)
avec
 −1
K(k) = Γx (k).CT (k). Γz (k) + C(k)Γx (k)CT (k) .
Le vecteur x̂(k) représente une estimée pour le vecteur x(k). Les matrices Γx (k),Γv (k), Γz (k) sont respectivement
les matrices de covariance sur l’erreur d’estimation x̂(k) − x(k), sur le bruit d’état v(k) et sur le bruit de mesure
z(k). La matrice K(k) est appelée gain de Kalman.

Initialisation du filtre : En général, nous n’avons aucune idée de la valeur de x(0). Ainsi, il semble assez logique
de poser  
1
0 0
 ε 1 
T
 0 ε 

x̂(0) = (0, 0, . . . , 0) et Γx (0) =  
..
 0 . 0 

1
0 ε
où ε est très proche de zéro (par exemple 0.001). Ce qui revient à supposer que x(0) est dans une sphère centrée
en zéro et de rayon très grand ( 1ε ).

Cas stationnaire : En stationnaire, on a Γx = Γx (k) = Γx (k + 1), d’où


   −1  
Γx = A Γx − Γx CT Γz + CΓx CT CΓx AT + Γv
L’équation ci-dessus est une équation de Ricatti que l’on peut résoudre une fois pour toute en lançant l’itération
   −1  
Γx (k + 1) = A Γx (k) − Γx (k)CT Γz + CΓx (k)CT CΓx (k) AT + Γv
jusqu’à atteindre l’équilibre. Ainsi, dans le cas stationnaire, on peut faire l’économie du calcul en temps réel de
Γx (k).

Lien avec les moindres-carrés sans oubli : Remarquons que si A(k) = I, B = 0, x̂ = p̂, C(k) = mT
k,
Γv (k) = 0 et Γz (k) = 1 on retrouve les moindres-carrés récursifs sans oublis :
     
 p̂(k + 1) = p̂(k) + Γx (k)mk 1 + mT Γx (k)mk −1 y(k) − mT p̂(k)
k k
   
 Γx (k + 1) = Γx (k) − Γx (k)mk 1 + mT Γx (k)mk −1 mT Γx (k) + Γv (k)
k k

8.6 Application à l’estimation en temps réel d’une fonction de transfert

8.6.1 Principe

Soit un système d’entrée u(k) et de sortie y(k) d’ordre 3 décrit par l’équation de récurrence
y(k) + a1 y(k − 1) + a2 y(k − 2) + a3 y(k − 3) = b1 u(k − 1) + b2 u(k − 2) + b3 u(k − 3).
Commande non linéaire des systèmes non linéaires 139

On cherche à estimer en temps réel les coefficients de la fonction de transfert du système, sachant que ceux-ci
évoluent doucement dans le temps (voir figure ci-dessous).

Supposons que le vecteur p = (a1 , a2 , a3 , b1 , b2 , b3 )T obéisse à l’équation d’évolution

p(k + 1) = p(k) + v(k)

où v(k) est un bruit blanc de matrice de covariance Γv (souvent, on la prend diagonale). On peut construire un
observateur de Kalman basé sur le système

p(k + 1) = p(k) + v(k)
y(k) = C(k)p(k) + z(k)

avec
C(k) = (−y(k − 1), −y(k − 2), −y(k − 3), u(k − 1), u(k − 2), u(k − 3))
et où z(k) est le bruit de mesure de variance Γz . Ce filtre est donné par

p̂(k + 1) = p̂(k) + K(k) (y(k) − C(k)p̂(k))
Γx (k + 1) = Γx (k) − K(k)C(k)Γx (k) + Γv

avec
 −1 Γx (k)CT (k)
K(k) = Γx (k).CT (k). Γz + C(k)Γx (k)CT (k) = .
Γz + C(k)Γx (k)CT (k)
 
puisque Γz + C(k)Γx (k)CT (k) est un scalaire. Il ne nous reste qu’à trouver une relation récursive qui nous
génère les C(k). Puisque

C(k + 1) = (−y(k), −y(k − 1), −y(k − 2), u(k), u(k − 1), u(k − 2))

des équations récursives pour générer les C(k) sont donc données par
 
0 1 0 0 0 0
 0 0 1 0 0 0 
   
 0 0 0 0 0 0  0 0 0 1 0 0
 
C(k + 1) = C(k)   + (u(k) y(k))
 0 0 0 0 0 0  −1 0 0 0 0 0
 
 0 0 0 0 1 0 
0 0 0 0 0 1
140 Commande par espace d’état

que nous noterons


C(k + 1) = C(k)N + (u(k) y(k)) M

Les équations d’état d’un identificateur basé sur le filtre de Kalman sont donc :

 Γx (k)CT (k)
 p̂(k + 1) = p̂(k) + Γz +C(k)Γx (k)CT (k) (y(k) − C(k)p̂(k))

Γx (k)CT (k)
 Γx (k + 1) = Γx (k) − Γz +C(k)Γ T
x (k)C (k)
C(k)Γx (k) + Γv

 C(k + 1) = C(k)N + (u(k) y(k)) M

où les entrées sont u(k) et y(k) et la sortie est p̂(k).

8.6.2 Perspectives : commande adaptative, surveillance

Nous proposons dans cette section deux applications possibles de l’estimateur de fonction de transfert.

Commande adaptative : Considérons un système d’ordre connu mais de fonction de tranfert inconnu. Le schéma
décrit sur la figure ci-dessous propose un régulateur permettant de donner au système le comportement désiré.
L’estimateur de fonction de transfert utilise les moindres-carrés récursifs pour estimer la fonction de transfert
du processus. Ensuite, le module utilise cette la fonction de transfert estimée pour calculer un régulateur (par
exemple par la méthode du placement de pôle). Il vient alors modifier les équations d’état du système du régulateur
classique.

Surveillance :
Commande non linéaire des systèmes non linéaires 141

8.7 Localisation d’un robot sous-marin dans une piscine

8.7.1 Présentation du problème

On considère un robot sous marin (dont les équations d’état ne sont pas nécessairement connues) se déplaçant
dans une piscine rectangulaire de demie longueur Ry et de demie largeur Ry . Un sonar positionné juste en dessous
du robot tourne avec une vitesse angulaire constante. Le but de ce paragraphe est de proposer l’utilisation d’un
filtre de Kalman pour localiser le robot. La profondeur z s’obtient facilement avec un capteur de pression et nous
supposerons donc cette grandeur connue. Le robot est supposé être lesté de telle façon que les angles de roulis et de
tangage puissent être considérés comme nuls. L’angle de cap θ est mesuré par une boussole. Dans notre contexte, se
localiser signifie donc estimer les coordonnées (x, y) du robot. L’origine du repère sera pris au centre de la piscine.
Pour cette localisation, nous supposons que nous mesurons l’angle α du sonar relativement au corps du robot,
l’angle θ par une boussole et les accélérations tangentielles aT et normales aN par l’intermédiaire d’accéléromètres.
Le sonar nous renvoie toutes les 0.1s la longueur ℓ du faiseau sonar. La figure qui suit représente la longueur ℓ(t)
du faiseau sonar, obtenue par simulation, lorsque le sonar effectue sept tours sur lui-même, alors que le robot se
déplace.

8.7.2 Détection des murs

A partir du signal récupéré par le sonar, et dont la figure ci-dessus donne une allure dans une situation sans
bruit, nous allons devoir détecter les minimums locaux, qui correspondent à la situation où le sonar pointe per-
pendiculairement à un des quatre murs de la piscine. Lorsque le sonar pointe sur un mur, la distance ℓ renvoyée
satisfait
a = ℓ. cos β, (8.9)

où β est l’angle entre la normale au mur et la faiseau sonar et a est la distance entre le sonar et le mur. Nous allons
supposer que le robot est immobile et que seul le sonar tourne (cela revient à supposer que les vitesses tangentielle
142 Commande par espace d’état

v et angulaires θ̇ du robot sont négligeables devant la vitesse de rotation α̇ du sonar). Considérons tout d’abord,
la situation où à l’instant t, le sonar est normal au mur. Si τ est un réel positif suffisamment petit, c’est-à-dire tel
que à l’instant t − τ le sonar pointe toujours sur le même mur, nous devrions avoir, d’après la relation (8.9),
a = ℓ(t − τ ). cos (−α̇τ )
Rappelons que la vitesse de rotation du sonar α̇ est supposée connue et constante. Prenons τ = kδ, k ∈ {0, 1, 2, . . . , N−
1}, où δ est la durée séparant deux pings du sonar et N est un entier tel que, à l’instant t − Nδ, le sonar pointe
nécessairement sur le mur qui se trouve orthogonal au faiseau sonar à l’instant t. Posons
ãk = ℓ(t − kδ). cos (−kδ α̇) .
La quantité ãk devrait correspondre à la distance a entre le robot et le mur pointé. Mais du fait de la présence
d’un bruit de mesure, il est préférable d’obtenir une estimation â de la distance a par une moyenne :
N−1
1 
â = ãk .
N
k=0
Nous pouvons vérifier le fait que le sonar pointe bien perpendiculairement à un mur en vérifiant que la variance
des ãk est faible, c’est-à-dire que
N−1
1 
(ãk − â)2 < ε,
N
k=1
où ε est un seuil fixé proche de 0. Il s’agit du test de la variance.

Or, en pratique il y a beaucoup de données aberrantes. Il nous faut donc modifier notre méthode. Une approche
plus robuste que celle présentée précédemment, consiste à calculer la médiane plutot que la moyenne. Pour cela, il
faut trier les ãk par ordre croissant. Ensuite, on prend le milieu ā de la liste et on supprime de la liste les éléments
de cette liste qui sont les plus éloignés de ā. On en supprime par exemple une moitié. Il sont facile à trouver car
ils se trouvent soit en début, soit en fin de liste. On fait alors la moyenne des éléments restant pour obtenir â. On
fait alors de test de la variance sur les éléments restant pour vérifier que le sonar est normal à un mur. Notons
que si le robot dispose d’une boussole fiable, le test de la variance devient inutile. En effet, la boussole nous donne
θ et l’angle α est connu, ce qui nous permet de savoir si le sonar pointe ou non suivant la normale à un mur et
aussi de quel mur il s’agit.

8.7.3 Localisation

Nous supposons maintenant que nous ayons recueillies (soit par simulation, soit par une expérience réelle) pour
chaque t ∈ [0, tmax ], les accélérations (aT , aN ), l’angle de cap θ et l’angle du sonar α. Nous allons maintenant
chercher à nous localiser et à estimer notre vitesse à l’aide d’un filtre de Kalman. Nous allons modéliser les
relations différentielles entre les mesures par les équations d’état suivantes


 ẋ = vx

 ẏ = v
y
(8.10)
 v̇x = aT . cos θ − aN sin θ



v̇y = aT . sin θ + aN cos θ
où vx = ẋ, vy = ẏ. Pour les deux dernières équations il suffit de remarquer que l’accélération absolue est obtenue
à partie de l’accélération mesuré (aT , aN ) par les accéléromètres par une simple rotation d’angle θ :
    
ẍ cos θ − sin θ aT
= .
ÿ sin θ cos θ aN
Commande non linéaire des systèmes non linéaires 143

Afin de pouvoir utiliser un filtre de Kalman il nous faut tout d’abord discrétiser le temps. Remarquons que lorsque
α + θ est un multiple de π2 , le faiseau sonar est orienté face à un des quatres murs de la piscine (car cette dernière
est supposée rectangulaire). Dans un tel cas, la longueur mesurée peut nous permettre de calculer soit x soit y.
Pour notre problème, le temps k discret s’incrémente chaque fois que le faiseau sonar pointe face à un mur de
la piscine, c’est-à-dire que k = E( α+θπ/2 ), où E désigne la partie entière d’un nombre réel. Une discrétisation par
Euler de (8.10) se traduit par


 x(k + 1) = x(k) + vx (k) ∗ T (k)

 y(k + 1) = y(k) + v (k) ∗ T (k)
y
 vx (k + 1) = vx (k) + (aT (k) cos θ(k) − aN (k) sin θ(k)) ∗ T (k)



vy (k + 1) = vy (k) + (aT (k) sin θ(k) + aN (k) cos θ(k)) ∗ T (k)

où T (k) est le temps réel qui s’est écoulé entre deux incrémentations successives de k. Sous forme matricielle, ces
équations d’état deviennent
   
1 0 T (k) 0 0 0
 0 1 0 T (k)   0 0 
   
x(k + 1) =   x(k) +   u(k)
 0 0 1 0   −T (k) sin θ(k) T (k) cos θ(k)  (8.11)
0 0 0 1 T (k) cos θ(k) T (k) sin θ(k)
r(k) = C(k).x(k),
avec

x(k) = (x(k), y(k), vx (k), vy (k)) et


u(k) = (aN (k), aT (k)) .

En ce qui concerne l’équation de mesure, il nous faut distinguer quatre cas

— Cas 0, mur droit (θ(k) + α(k) = 2kπ). Dans ce cas, nous avons une mesure sur x : r(k) = x(k) ≃ Rx − d(k),
où d(k) est la distance retournée par le sonar. Ainsi, la matrice d’observation sera
 
C(k) = 1 0 0 0 .

— Cas 1, mur fond (θ(k) + α(k) = 2kπ + π2 ). Dans ce cas, nous avons une mesure sur y : r(k) = y(k) ≃ Ry − d(k)
et donc  
C(k) = 0 1 0 0 .

— Cas 2, mur gauche (θ(k)+α(k) = 2kπ +π). Nous avons à nouveau une mesure sur x : r(k) = x(k) ≃ −Rx +d(k).
La matrice d’observation sera  
C(k) = 1 0 0 0 .

— Cas 3, mur devant (θ(k) + α(k) = 2kπ + 2 ).
Nous avons une mesure sur y : r(k) = y(k) ≃ −Ry + d(k). Ainsi
 
C(k) = 0 1 0 0 .

Si nous connaissons θ + α, pour savoir dans quel cas i nous sommes, il faut résoudre

∃k ∈ N, θ(k) + α(k) = 2kπ +
2
c’est-à-dire
2
∃k ∈ N, (θ(k) + α(k)) = i + 4k
π
144 Commande par espace d’état

Donc, pour avoir le cas i le plus probable, on calcule l’entier le plus proche de la quantité π2 (θ(k) + α(k)), et on
regarde le reste de la division euclidienne de cet entier par 4. Sous S, cela se fait pas le calcul suivant

i=modulo(round((thetak+alphak)*2/%pi),4)
Notons que le système (8.11) n’a pas pour but de reproduire le comportement dynamique du système au niveau
de la commande, mais plutôt de permettre l’utilisation d’un filtre de Kalman, dans le but d’estimer la position et
la vitesse du robot. Pour cela, nous nous sommes arrangés pour avoir un système discret décrit par des équations
d’état linéaires. On a donc bien un système de la forme

x(k + 1) = A(k)x(k) + B(k)u(k) + v(k)
r(k) = C(k)x(k) + z(k).

Nous venons de rajouter deux signaux de bruit v et z qui seront supposés blancs, de matrice de covariance Γv et
Γz (notons que ici, Γz est un scalaire). Ces deux matrices ont pour but de modéliser les incertitudes de modèle et
les bruits de mesure. Le filtre de Kalman est donc décrit par :

x̂(k + 1) = A(k). (x̂(k) + K(k) (r(k) − C(k)x̂(k))) + B(k)u(k)
Γx (k + 1) = A(k) (Γx (k) − K(k)C(k)Γx (k)) AT (k) + Γv (k),
avec
 −1
K(k) = Γx (k).CT (k). Γz (k) + C(k).Γx (k).CT (k) .

8.7.4 Représentation graphique

Pour chaque k, le filtre de Kalman nous donne un couple (x̂, Γ), qui peut s’interpréter comme un ellipsoïde de R4
contenant l’ensemble des x = (x, y, vx , vy ) compatibles avec nos mesures. Cet ellipsoïde est donné par

(x − x̂)T Γ−1 (x − x̂) ≤ 1.

En pratique, on ne trace qu’une représentation bi-dimensionnelle de cet ellipsoïde. Dans notre exemple, on pourra
se limiter aux composantes de x correspondant au sous-vecteur w = (x, y) qui a une signification claire dans
l’espace de travail du robot. Ainsi, nous considérerons la matrice de covariance Q, sous matrice de Γ, donnée par
 
γ 11 γ 12
Q= .
γ 21 γ 22

On s’intéresse alors à l’ellipse


(w − w̄)T .Q. (w − w̄) ≤ 1.
Comme la matrice Q est symétrique définie positive, elle admet une racine carrée, c’est-à-dire, une matrice
1 1 1
symétrique Q 2 telle que Q 2 .Q 2 = Q. Ainsi, l’inégalité définissant l’ellipsoïde s’écrit
1 1
(w − w̄)T Q− 2 Q− 2 (w − w̄) ≤ 1

ou encore
1
||Q− 2 (w − w̄) ||2 ≤ 1.
1
En posant s = Q− 2 (w − w̄), cette inégalité devient ||s||2 ≤ 1. L’ellipsoïde en w peut être considérée comme
1
l’image par l’application affine w(s) = w̄ + Q 2 s du disque unité. Pour tracer sa frontière, il suffit de rentrer les
instructions S suivantes
Commande non linéaire des systèmes non linéaires 145

s=0 :0.01 :2*%pi ;


w=w_hat*ones(s)+sqrtm(Q)*[cos(s) ;sin(s)] ;
xpoly(w(1, :),w(2, :)) ;

La figure qui suit représente le robot à un intant t, le faiseau sonar associé et une suite d’ellipsoïdes de confiance
engendrés par le filtre de Kalman. Le grand cercle représente l’ellipsoïde de confiance initiale.

Remarque. Soit b une distribution gaussienne centrée en zéro. On s’intéresse à la probabilité que b appartienne
à la sphère de rayon α, c’est-à-dire,
 
P bT b ≤ α2
La variable aléatoire z = bT b suit une loi du χ2 . Sa densité de probabilité est donnée par
 n  
√ n1 z 2 −1 exp − z2 si z ≥ 0
fn (z) = 2 Γ(n/2)
0 sinon
où  ∞
Γ(a) = e−t ta−1 dt = (x − 1)!
0
est la fonction d’Euler. Par exemple, si on veut que cette probabilité soit égale à 0.95, et pour n = 2, à l’aide d’une
table du χ2 , nous pouvons voir qu’il nous faut prendre α2 = 6. Si maintenant, on considère un vecteur gaussien
de matrice de covariance Γ et d’espérance x̄. On s’intéresse à l’ellipsoïde de confiance
(x − x̄)T .Γ−1 . (x − x̄) ≤ α2
c’est-à-dire
1
||Γ− 2 (x − x̄) ||2 ≤ α2 .
1
Le vecteur b =Γ− 2 (x − x̄) est un vecteur blanc gaussien, donc
 
P (x − x̄)T .Γ−1 . (x − x̄) ≤ α2 = P (||b||2 ≤ α2 ).
Pour n = 2, on obtient on obtient que l’ellipsoïde de confiance qui contient x avec une probabilité de 0.95 est
donnée par
(x − x̄)T .Γ−1 . (x − x̄) ≤ 6.
146 Commande par espace d’état
Bibliographie

[1] Mupad, www.mupad.com/.


[2] Scilab, www-rocq.inria.fr/scilab/scilab.html.
[3] B. d’Andréa Novel. Commande non-linéaire des robots. Hermès, Paris, France, 1988.
[4] P. de Larminat. Automatique, commande des systèmes linéaires. Hermès, Paris, France, traité des nouvelles
technologies edition, 1993.
[5] W. Khalil et E. Dombre. Modélisation, identification et commande des robots, Collection Robotique. Hermès,
Paris, 1999.
[6] M. Rivoire et J.L. Ferrier. Cours et exercices d’automatique, Tomes 1, 2 et 3. Eyrolles, Paris, France, 1989.
[7] E. Walter et L. Pronzato. Identification de modèles paramétriques à partir de données expérimentales. Masson,
Paris, France, 1994.
[8] L. Jaulin. Représentation d’état pour la modélisation et la commande des systèmes (Coll. Automatique de
base). Hermès, London, 2005.
[9] L. Jaulin, M. Kieffer, O. Didrit, E. Walter. Applied Interval Analysis, with Examples in Parameter and State
Estimation, Robust Control and Robotics. Springer-Verlag, London, 2001.
[10] F. Lamnabhi-Lagarrigue. Analyse des systèmes non-linéaires. Hermès, Paris, France, 1994.
[11] I. D. Landau. Identification et commande des systèmes. Hermès, Paris, France, 1993.
[12] J.P. Laumond. La robotique mobile. Hermès, Paris, France, 2001.
[13] J. P. Merlet. Les robots parallèles. Hermès, Paris, France, 1990.
[14] D.A. Wells. Lagrangian Mechanics. Schaum’s outlines, London, 1967.

147
148 Commande par espace d’état
Glossaire

Glossaire S (pour le calcul numérique)

bdiag(A) : renvoie une matrice diagonale contenant les valeurs propres de A et une matrice dont les colonnes sont
les vecteurs propres de A.
champ(x1,x2,y1,y2) : trace le champ de vecteur (y1,y2) sur la grille formée par les vecteurs x1 et x2.
deff(’y=f(x1,x2)’,’y=x1+sin(x2)’) : définit une fonction f à l’aide d’une chaîne de caractère.
eye(n,n) : génère une matrice identité de dimension n × n.
feval(x1,x2,f) : évalue la fonction f sur la grille formée par les vecteurs x1 et x2. Le résultat renvoyé est une
matrice.
isoview(xmin,xmax,ymin,ymax) : définit les échelles sur la fenêtre graphique.
modulo(a,b) : renvoie le reste de la division euclidienne de l’entier a par l’entier b.
ones(v) : renvoie une matrice de même dimension que v qui ne contient que des 1.
pvm_set_timer() : initialise le chronomètre.
pvm_get_timer() : renvoie la valeur du chronomètre en microsecondes.
poly([a1,a2,...],’s’) : renvoie le polynôme (s − a1 )(s − a2 ) . . .
round(a) : renvoie l’entier le plus proche du nombre réel a.
seteventhandler() : active ou désactive le gestionnaire d’événements.
xbasc() : efface et initialise la fenêtre graphique.
xdel() : supprime la fenêtre graphique.
xfpoly(x,y) : trace un polygone, tout comme xpoly, mais cette fois, le polygone est plein.
xpoly(x,y) : trace, sur la fenêtre graphique, un polygone dont les abscisses et ordonnées sont rangées dans les
vecteur x et y.
xset(’thickness’,a) : configure l’épaisseur a du stylo, lors du dessin graphique.
zeros(v) : renvoie une matrice de même dimension que v qui ne contient que des 0.

Glossaire M
 (pour le calcul formel)

charpoly(M,s) : Calcule le polynôme caractéristique de la matrice carrée M.


export(linalg) : rend active la bibliothèque d’algèbre linéaire linalg.
jacobian([x*y,x^2+y^2],[x,y]) : renvoie la matrice jacobienne de la fonction f(x, y) = (xy, x2 + y2 ).
normal(E) : réduit au même dénominateur une expression constituée de plusieurs fractions.
simplify(E) : renvoie une version simplifiée de l’expression E.
subs(E(x,y),x=1,y=2) : substitue dans l’expression E, la variable x par 1 et la variable y par 2.

149
Index

équation d’évolution, 13 fauteuil roulant, 26, 113


équation d’observation, 13 filtre de Kalman, 138
état, 13 fonction de transfert, 63
forme canonique d’observation, 67
asservissement, 14 forme canonique de commande, 66
automatique, 14 forme de Jordan, 69
forme modale, 67
bacs, 31
bateau à voile, 118 gain de Kalman, 138
Bernouilli, 31 gestionnaire d’événement, 53
bouclage linéarisant, 108 glossaire Mupad, 149
bras manipulateur, 49 glossaire Scilab, 149
calcul formel, 14 holonome, 27
calcul numérique, 14
champ de vecteur, 39 intégrateur, 18
changement de base, 61 interactivité, 53
char, 26, 113 inverse généralisée, 75, 127
commandabilité, 72
commande, 13, 14 linéarisation, 87
commande non linéaire, 87, 107 linéarisation par bouclage, 107
commande par retour d’état, 76 linéarité par rapport aux paramètres, 127
commande par retour de sortie, 79
méthode d’Euler, 50
commande proportionnelle et dérivée, 110, 115
méthode du gradient, 41
commande proportionnelle et intégrale, 112
Maple, 14
conduite automatique, 98
Matlab, 14
configuration, 53
matrice compagne, 62
consigne, 14
matrice d’évolution, 14, 71
coordonnées homogènes, 46
matrice d’observabilité, 74
critère d’observabilité, 74
matrice d’observation, 14, 71
critère de commandabilité, 73
matrice de commandabilité, 73
cycle, 44
matrice de commande, 14, 71
décomposition de Kalman, 75 matrice de consigne, 84
déterminant, 100 matrice de passage, 61
matrice de rotation, 46
entrée, 13 matrice de transfert, 63
estimateur d’état, 72 matrice directe, 14
eventhandler, 53 matrice jacobienne, 87
exponentielle de matrice, 57 modélisation, 13, 17

150
Index 151

modeleur, 45 système monovariable, 64


moindres carrés, 127 système proies-prédateurs, 42, 89
moindres carrés récursifs, 132 système tangent, 89
monocycle, 24 systèmes électriques, 35
motif, 45 systèmes hydrauliques, 31
Mupad, 14 systèmes mécaniques, 18

observabilité, 74 temps continu, 13


observateur, 80 temps discret, 13
observateur étendu, 94 temps réel, 51
transformée de Laplace, 63
pendule inversé, 22, 94
pendule simple, 21 vérin, 33, 91
pendulechamp.sce, 44 variables consignées, 84
pendulesimu.sce, 51 variations, 89
penduletrajectoire.sce, 52 vecteur propre, 40
placement de pôles, 72, 76 voilier, 29
point d’équilibre, 42, 89 voiture, 27, 53, 98
point de fonctionnement, 14, 71, 89
point de polarisation, 89
polynôme caractéristique, 60, 90
précompensateur, 83
principe de séparation, 82
principe fondamental de la dynamique, 18

régulateur, 14
régulateur statique, 115, 121
représentation d’état, 13, 17
robot manipulateur, 49
robots à roues, 24, 98

satellite, 19
Scilab, 14
simulation, 13, 39, 50
solution des équations d’état, 57
solution forcée, 58, 59
solution homogène, 58, 59
solution libre, 58
solution transitoire, 58
sortie, 13
stabilité, 59
système à temps discret, 37
système bouclé, 14
système de Fibonacci, 37
système de Lotka-Volterra, 42, 89
système linéaire, 17, 57
système linéarisé, 89