Espase D'etat

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

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

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

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

Système électrique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

35

2.3

2.4

2.5

2.6

3

4

Commande par espace d’état

2.7

2.6.1

Circuit RLC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

35

2.6.2

Moteur à courant continu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

36

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

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

42

3.3.1

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

42

3.3.2

Pendule simple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

43

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

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

Ajout de l’interactivité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

53

3.3

3.4

3.5

3.6

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

Stabilité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

59

4.3

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

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

4.4

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

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

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

Principe de séparation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

82

5.5.1

82

5.3

5.4

5.5

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

6

Commande par espace d’état

5.6

5.5.2

Changement de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

83

5.5.3

Polynôme caractéristique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

83

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

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

6.3

. . . . . . . . . . . . . . . . . . . . . . . . . . . . .

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.4

7.3.1

Principe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108

7.3.2

Commande d’une chaîne d’intégrateurs

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110

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.7

7.6.1

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

7.6.2

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

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 8.1

8.2

125

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

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.5

8.4.1

Principe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132

8.4.2

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

8.4.3

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

Filtrage de Kalman . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135 8.5.1

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

8.5.2

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

Table des matières

8.5.3 8.6

8.7

11

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

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

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


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

(1.1)

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)) y(k) = g(x(k), u(k)).

(1.2)

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 équations 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 linéaires, c’est-à-dire que les fonctions f et g sont s’écrit
x(t) ˙ y(t)

une première phase, nous intéresser uniquement aux systèmes supposées linéaires. Ainsi, dans le cas du temps continu, (1.1) = Ax(t) + Bu(t), = Cx(t) + Du(t),

et dans le cas du temps discret, (1.2) devient
x(k + 1) = Ax(k) + Bu(k), y(k) = Cx(k) + Du(k).

(1.3)

(1.4)

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

BacsAsservi.sce, BateauHybride, BrasManipulateur, PenduleInverseAsservi.sce, PenduleSimpleChamp.sce, PenduleSimpleTrajectoire.sce, SegwayLibre, VoitureAsservieCircuit, VoitureAsservieHexagone.sce, VoitureChampCycle.sce, VoitureLibreCircuit.sce, VolterraChamp.sce.

15

BacsLibres.sce, BateauLibre.sce, CharLibre, PenduleInverseLibre.sce, PenduleSimpleLibre.sce, SegWayAsservi, VerinLibre, VoitureAsservieCycle, VoitureAsservieNord, VoitureLibre.sce, VoitureLibreNord.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,


x(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


x(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 y˙ = u. Une représentation d’état possible pour ce système est
x(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 y¨ + a1 y˙ + a0 y = bu. Puisque,



y˙ y¨ y



=



=

y˙ −a1 y˙ − a0 y + bu y,



,

en posant x = (y, y), ˙ cette équation différentielle peut s’écrire sous la forme 

x˙ 1 x˙ 2 y



= =



x2 −a1 x2 − a0 x1 + bu x1 ,



,

ou encore, sous une forme standard faisant apparaître les matrices d’état A, B, C et D : 

0 1 x˙ = −a0 −a1   y = 1 0 x.

2.3 2.3.1



x+



0 b



u

Modélisation des systèmes mécaniques Méthodologie

Le principe fondamental de la dynamique permet de trouver simplement les équations d’état de systèmes mécaniques (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 M ˙ fi = Jω i 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   x1 Mm Mm √ 1 f = −G x2 +x2 u = − G x2 +x2 . 2 2 x1 +x2 1 2 1 2 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 x ¨1 =m f =m , dt x ¨2 où v est le vecteur vitesse du satellite. Ainsi     M x1 x ¨1 = −G  . 3 x ¨2 x2 x2 + x2 1

Puisque




les équations d’état s’écrivent

2.3.3

  x˙ 1     x  ˙2 x˙ 3       x˙ 4

2

x˙ 1 = x3 x˙ 2 = x4 , = = =

x3 x4 GMx1 − √ 2 23 x1 +x2

2 = − √GMx 3. 2 2

x1 +x2

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 , z˙1 , z2 , z˙2 )T .

Modélisation des systèmes

21

Le principe fondamentale de la dynamique appliqué au chariot 2 puis au chariot 1 donne
f − αz˙2 − k2 (z2 − z1 ) = m2 z¨2 , −k1 z1 − αz˙1 + k2 (z2 − z1 ) = m1 z¨1 . Nous avons donc la représentation d’état suivante   0 1      k +k 1 2  − mα1 − m1   x˙ =    0 0  k2  0  m  2    z1 = 1 0

0 k2 m1

0 k2 −m 2 0

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

2.3.4

0 0 1 α − m2

0





     x +   x

0 0 0 1 m2



  f 

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 :     q q ˙ d = , −ℓmg sin q+c dt (2.1) q˙ mℓ2 y = ℓ sin q. Remarque 2.3.1 L’énergie mécanique du pendule est donnée par Em =

1 2 2 mℓ q˙ 2  

énergie cinétique

+ mgℓ (1 − cos q).    énergie potentielle

22

Commande par espace d’état

Lorsque le couple c est nul, on a dEm dt

1 2 ˙q )+ mgℓq˙ sin q 2 mℓ (2q¨ −ℓmg sin q 2 = mℓ q˙ 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  est la force exercée par le chariot sur le la position du chariot, θ est l’angle entre le pendule et la verticale et R 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 = Mx ¨i (chariot en translation) Rxi + Ryj − mgj = mv˙ B (pendule en translation) ¨ Rx ℓ cos θ + Ry ℓ sin θ = 0θ. (pendule en rotation)

(2.2)

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 = x−ℓ ˙ θ˙ cos θ i − ℓθ˙ sin θj.

Donc, l’accélération du point B est donnée par     2 2 v˙ B = x ¨−ℓ¨θ cos θ + ℓθ˙ sin θ i − ℓ¨θ sin θ + ℓθ˙ cos θ j.

Après décomposition scalaire des équations de la dynamique (2.2), on obtient  Mx ¨ = u − Rx , (i)      2  ¨ ˙  Rx = m x ¨ − ℓθ cos θ + ℓθ sin θ , (ii)   ¨θ sin θ + ℓθ˙ 2 cos θ , (iii)  − mg = −m ℓ R  y    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 −m mℓ cos θ 1 0 0 mℓ sin θ 0 1 0 0 cos θ sin θ

    

x ¨ ¨θ Rx Ry





u

2   mℓθ˙ sin θ   =   mg − mℓθ˙ 2 cos θ 0



  . 

Donc 

x ¨ ¨θ



=



1 0 0 0 0 1 0 0





  . 

M 0 1 0 −m mℓ cos θ 1 0 0 mℓ sin θ 0 1 0 0 cos θ sin θ

−1     

u

2  mℓθ˙ sin θ  .  mg − mℓθ˙ 2 cos θ 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 

x ¨ ¨θ





=

2 −m sin θ(ℓθ˙ −g cos θ) M+m sin2 θ 2 sin θ((M+m)g−mℓθ˙ cos θ) 2 ℓ(M+m sin θ)



+



ℓ ℓ(M+m sin2 θ) cos θ ℓ(M+m sin2 θ)



u.

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

d dt

    

x θ x˙ θ˙





     =    

x˙ θ˙ ˙2

−m sin θ(ℓθ −g cos θ) M+m sin2 θ 2 sin θ((M+m)g−mℓθ˙ cos θ) ℓ(M+m sin2 θ)





    +    

0 0 ℓ ℓ(M+m sin2 θ) cos θ ℓ(M+m sin2 θ)



   u.  

(2.3)

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

Afin de trouver les équations d’état, nous appliquons le système, à savoir la roue et le corps. Nous avons :   −Rx + Fx =    Fx a + u =  Rxi + Ryj − mgj =    Rx ℓ cos θ + Ry ℓ sin θ − u =

25

principe fondamental de la dynamique sur chaque sous−Ma¨ α (roue en translation) JM α ¨ (roue en rotation) mv˙ B (corps en translation) Jp ¨θ (corps en rotation),

(2.4)

où vB , le vecteur vitesse du point B. Puisque −−→ OB = (−aα−ℓ sin θ)i + (ℓ cos θ + a) j, par dérivation, nous obtenons ou encore

  vB = −aα−ℓ ˙ θ˙ cos θ i − ℓθ˙ sin θj.

    2 2 α−ℓ¨θ cos θ + ℓθ˙ sin θ i − ℓ¨θ sin θ + ℓθ˙ cos θ j. v˙ B = −a¨

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      0 Ma 0 −1 0 1 α ¨     J  u  0 0 0 −a    ¨θ    M  2      . ˙ mℓθ sin θ 1 0 0   Rx  =   ma mℓ cos θ      2  0 mℓ sin θ 0 1 0   Ry   mg − mℓθ˙ cos θ   0 −Jp ℓ cos θ ℓ sin θ 0 Fx u Donc



x ¨ ¨θ



=





   1 0 0 0 0  .  0 1 0 0 0 

−1  0 Ma 0 −1 0 1   u  0 0 0 −a  JM  2   ˙ ma mℓ cos θ 1 0 0  . mℓθ sin θ  2  0 mℓ sin θ 0 1 0   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

avec

   α˙ =   θ˙ =


 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 θ

µ1 = JM + a2 (m + M) , µ3 = aml,

µ2 = Jp + mℓ2 , µg = glm.

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





 α    d  θ    = dt  α˙     θ˙

2.4.2

α˙ θ˙ 


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

µ1 µ2 −µ23 cos2 θ



   .   

(2.5)

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, θ, 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, x˙ = 1, y˙ = 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 : y˙ = x˙ 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 x, ˙ y, ˙ θ. 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       

2.4.3

x˙ y˙ θ˙ v˙ 1 v˙ 2





      =    

v1 +v2 cos θ 2 v1 +v2 sin θ 2 v2 −v1 ℓ

Ru1 Ru2



   .  

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 :         −L 0 v cos δ vM          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




x˙ = vM cos θ = v cos δ cos θ y˙ = vM sin θ = v cos δ sin θ.

L’équation d’évolution de la voiture s’écrit donc    v cos δ cos θ x˙  y˙   v cos δ sin θ     ˙   v sin δ  θ = L     v˙   u1 δ˙ u2



   .  

(2.6)

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     vr cos δ r cos θr x˙ r      y˙r  =  vr cos δ r sin θr  vr sin δ r θ˙ r Lr

avec

vr =

  x˙ 2 + y˙ 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 , x˙ r , y˙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 θ x˙   y˙   v cos δ sin θ        θ˙   v sin δ     L  ˙  =  v cos δ sin(θ−θr )  .  θ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 x˙ = 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 dynamique [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ù




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

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

Modélisation des systèmes

                                

x˙ y˙ θ˙ δ˙ v δ˙ g v˙ ω˙ fv fg

= v cos θ, (i) = v sin θ − βV, (ii) = ω, (iii) = u1 , (iv) = u2 , (v) fv sin δ v −fg sin δ g −αf v , (vi) = m (ℓ−rv cos δ v )fv −rg cos δ g fg −αθ ω = , (vii) J = αv (V cos (θ + δv ) − v sin δ v ) , (viii) = αg v sin δ g . (ix)

31

(2.7)

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 2.5.1

Systèmes hydrauliques 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, P +ρ

v2 + ρ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 PD + ρ

2 vD v2 + ρgzD = PA + ρ A + ρgzA , 2 2

c’est-à-dire PD = PA + ρg (zA − zD ) − ρ

2 vD . 2

(2.8)

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 PB + ρg (zB − zC ) = PA + ρg (zA − zD ) − ρ

2 vD . 2

Comme PA = PB = Patm , et que zC = zD , cette équation se traduit par ρg (zA − zB ) = ρ ou encore vD =

2 vD , 2

 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 )

2.5.2

 2g|zA − zB |.

Ecoulement dans trois bacs

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

(2.10)

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, h˙ 1 = −Q1ext − Q12 + u1 , h˙ 2 = Q12 − Q23 , h˙ 3 = −Q3ext + Q23 + u2 , ou encore  √ (h1 − h2 ) 2g|h1 − h2 | + u1 h˙ 1 = −a. 2gh1 − a.sign   h˙ 2 = a.sign (h1 − h2 ) 2g|h1 − h2 | − a.sign (h2 − h3 ) 2g|h2 − h3 | √ h˙ 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, z, ˙ p) où z est la position du vérin, z˙ 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 n, ˙ (2.11) u= 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 . D’où

δn δV

=

n V,

c’est-à-dire δV =

V n δn.

Donc δV u
= δt



V n



δn = δt



V n



n, ˙

qui se trouve être la relation (2.11). Attention, ici, nous avons approximé δn ˙ car δn correspond bien à un δt par n car δV ne correspond pas nécessairement à accroissement de n. En revanche, nous n’aurions pas pu écrire V˙ = δV δt 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 = m¨ z . Donc, les deux premières équations d’état sont
z˙ = z, ˙ ap−kz z¨ = m . La loi des gaz parfaits (pV = nRT ) est donnée par pza = nRT . En différenciant, on obtient   a (pz ˙ + pz) ˙ = R nT ˙ + nT˙ . En supposant l’évolution isotherme, cette relation se traduit par a (pz ˙ + pz) ˙ = RnT ˙

(2.11)

= R

nu T = pu. V

En isolant p, ˙ on obtient la troisième équation d’état pour notre système, à savoir  p u − z˙ . p˙ = z a

Modélisation des systèmes

35

Les équations d’état du système sont donc    z˙ = z¨ =   p˙ =

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

2.6 2.6.1

z˙ ap−kz m   p u z a − z˙

  x2  x˙ 1 = ax3 −kx1 x˙ 2 = m   x˙ = − x3 x − u  . 3 2 x1 a

Système électrique 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 = 0 (loi des nœuds). dt

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 − L1 v(t) − RL2 i(t) + L1 u(t). dt =

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 − v(t) v(t) d CR1 C CR1 = + u(t) 1 dt i(t) i(t) − L1 − RL2 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         KΦ 1 d i −R − i 0 u L L L = + . KΦ dt ω − Jρ ω 0 − J1 Tr J 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 2 ω˙ = Kk 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 Tr Tr Tr

= C te = αω = ωα = αω 2

moteur utilisé pour le levage locomotive, mixeur, pompe machine outil (tour, fraiseuse) 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 N

k=1 A

k=2 A N

k=3 A A N

k=4 A A 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   x2 (k)  x1 (k + 1) = 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
x(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

1 2 3 4 5 6

Programme ChampLineaire.sce a=0.5 x1=-2 :a :2 ; x2=-2 :a :2 ; deff(’z=f1(u,v)’,’z=u+v’) ; deff(’z=f2(u,v)’,’z=u-v’) ; y1=feval(x1,x2,f1) ; y2=feval(x1,x2,f2) ; 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

Ses valeurs propres sont

41

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

v1 =



0.9239 0.3827



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 ∂f ∂x2



=



(1 − 2x21 ) exp(−x21 − x22 ) −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 

x˙ 1 x˙ 2



=



(1 − 2x21 ) exp(−x21 − x22 ) −2x1 x2 exp(−x21 − x22 )



,

−−→ nous avons une forte chance de converger vers le maximum de la fonction f. Simuler le système x˙ = 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 x(t) ˙ = 2 2 f (x(t)). Lorsque f est une fonction de R vers R , 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
x˙ 1 (t) = (1 − αx2 (t)) x1 (t) , x˙ 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 x˙ = 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 − α¯ x2 )¯ x1 = 0, (−1 + β x ¯1 )¯ x2 = 0. Le premier point d’équilibre est



x ¯1 x ¯2



=



0 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

3.4.1

45

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  0 0 1 1 0 0 0 1 1 0 1 1 1 1 0 0

(3.2)

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  . 0 sin θ cos θ − sin θ 0 cos θ 0 0 1

3.4.3

(3.4)

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 fi :

Rn → Rn 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 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

function draw_voiture(x) 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] ; 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 ; Ravg=R*[cos(x(5)),-sin(x(5)) 3 ; sin(x(5)),cos(x(5)) -3 ;0 0 1]*Rav ; xbasc() ;xset(’thickness’,2) ; isoview(-20,40,-10,30) ; xpoly(M(1, :),M(2, :)) ; xpoly(Ravd(1, :),Ravd(2, :)) ; xpoly(Ravg(1, :),Ravg(2, :)) ; 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

3.4.5

49

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 Diag(3, 0.3, 0.3) Rotz (α1 ) Rotx (0.5)

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

Bras 3 Diag(1, 0.3, 0.3) Rotx (α3 ) Trans(2, 0, 0) Rotz (α2 ) 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
x(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’échantillonnage 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 x˙ = 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     x˙ 1 x2 = . u x˙ 2 − gℓ sin x1 + mℓ 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

1 2 3 4 5 6 7 8 9 10 11 12

Programme PenduleSimpleLibre.sce function draw_pendule(x) xbasc() ;isoview(-4,4,-3,3) ; xpoly([0,L*sin(x(1))],[0 -L*cos(x(1))]) endfunction ; function v=f(x,u) v=[x(2) ; -g/L*sin(x(1))+u/(m*L^2)] ; endfunction ; L=2 ;g=9.81 ;m=1 ;u=0 ;dt=0.006 ;x=[1 ;0] ; for k=1 :1500, draw_pendule(x) ; x=x+f(x,u)*dt ; 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

1 2 3 4 5 6 7 8 9

53

Programme VoitureLibre.sce function v=f(x,u) v=[x(4)*cos(x(5))*cos(x(3)) ; x(4)*cos(x(5))*sin(x(3)) ; x(4)*sin(x(5))/3 ; u(1) ;u(2) ] ; endfunction ; x=[0 ;0 ;0 ;7 ;0] ;u=[0 ;0.2] ;dt=0.02 ; for k=1 :3000, draw_voiture(x) ; x1=x+f(x,u)*dt ; x=x1 ; 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     x˙ v cos δ cos θ  y˙   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 erreurs 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 principal. 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

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 //---------------------------------------------

55

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
x(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) y(k) = Cx(k) + Du(k),

(4.2)

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. Rappelons 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 : ∞

M

e

1 1 1 = 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 quelquesunes 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)  Mt  d = MeMt . dt e

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

y(t) = Ce

A(t−t0 )

x(t0 ) +



t

CeA(t−τ ) Bu(τ )dτ + Du(t).

t0

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

t

t0

CeA(t−τ ) Bu(τ )dτ +

˙ = AeAt z(t) + eAt z˙ (t). Preuve. Posons z(t) = e−At x(t). On a donc x(t) = eAt z(t) et donc, par dérivation x(t) L’équation d’évolution x(t) ˙ = Ax(t) + Bu(t), se transforme en AeAt z(t) + eAt z˙ (t) = AeAt z(t) + Bu(t), soit, après simplication z˙ (t) = e−At Bu(t). Après intégration, nous obtenons z(t) = z (t0 ) +



t

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  Ak−ℓ Bu(ℓ), (4.4) x(k) = Ak−k0 x(k0 ) + ℓ=k0

Systèmes linéaires

59

et donc la sortie s’exprime par k−k0

y(k) = CA

x(k0 ) +

k−1 

CAk−ℓ Bu(ℓ) + Du(k).

ℓ=k0

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

k

ℓ=k0

CA(k−ℓ) Bu(ℓ)+Du(k)

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) = (4.4)

=

= =

A.x(k) + Bu(k)    k−ℓ Bu(ℓ) + Bu(k) A Ak−k0 x(k0 ) + k−1 A ℓ=k0  k+1−ℓ Bu(ℓ) + Bu(k) Ak+1−k0 x(k0 ) + k−1 ℓ=k0 A  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 4.3.1

Stabilité 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

x(k) = A x(0) +

k−1 

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, limk→∞ Ak = 0n si le système à temps discret.

4.3.2

(4.7)

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é.  i 1 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 4.4.1

Changement de base Principe

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


x˙ = Ax + Bu y = Cx + Du.

(4.8)

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, A le système s’écrit




¯ + Bu ¯ v˙ = Av ¯ ¯ y = Cv + Du

(4.9)

(4.10)

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 ¯ = AP, PA ¯ PB = B, ¯ = CP, C 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

4.4.2

Commande par espace d’état

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   (4.11) P = b | Ab | A2 b | . . . | An−1 b ,

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.12) ¯ (4.9) b = P−1 b = e1 .

¯ nous écrivons, Pour l’obtention de A,   ¯ = a A ¯1 | ¯ a2 | ¯ a3 | . . . | ¯ an−1 | ¯ an (4.9)

= P−1 AP   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 , (4.11)

où les ¯ ai 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   n−1 b + · · · − a Ab − a b P−1 An b = P−1 −an−1 A 1 0     −a0 −a0 (4.11) −1     = P .P  . . .  =  . . .  . −an−1 −an−1 En conclusion, après changement de base,       v˙ =     

nous  0   1    0 0

obtenons une équation d’évolution du type    0 0 −a0 1    0 0 −a1   0   v+  .  u. ..   .  . 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 :
x˙ = Ax + Bu y = Cx + Du.

Systèmes linéaires

La transformée de Laplace de la représentation d’état est donnée par
sˆ x = Aˆ x + Bˆ u, y ˆ = Cˆ x + Dˆ u.

63

(4.13)

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 sˆ x − Aˆ x = Bˆ u, c’est-à-dire sIˆ x − Aˆ x = Bˆ u, où I est la matrice identité. D’où, en factorisant, (sI − A) x ˆ = Bˆ u (attention, une écriture du type sˆ x − Aˆ x = (s−A) x ˆ n’est pas autorisée car s est un scalaire alors que A est une matrice). Ainsi, (4.13) est équivalent à
u, x ˆ = (sI − A)−1 Bˆ y ˆ = Cˆ x + Dˆ u.

Donc

  y ˆ = C(sI − A)−1 B + D u ˆ.

La matrice

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

(4.14) (4.15)

est appelée matrice de transfert. Il s’agit d’une matrice de fonctions de transfert (c’est-à-dire de fonctions rationnelles 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    1   ˙ =   x(t) 2   1     y(t) = 1

à temps continu décrit par sa représentation d’état :    3 1 x(t) + u(t), 0 1    2 2 x(t) + u(t). 0 0

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

(4.15)

=

= =

C(sI − A)−1 B + D   −1     1 2 s − 1 −3 1 2 + 1 0 −2 s 1 0  2  2s +s−7 s2 −s−6 s+3 s2 −s−6

(4.16)

.

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 y ˆ = G(s)ˆ u s’écrit   2 ˆ= s −s−6 y Soit, en substituant s par

d dt ,






2s2 + s − 7 s+3



u ˆ.

y¨1 − y˙1 − 6y1 = 2¨ u + u˙ − 7 y¨2 − y˙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 0 0 0



    

s 0 0 0

0 s 0 0

0 0 s 0

0 0 0 s





0

  − k1 +k2   m1 −   0 k2 m2

1 − mα1 0 0

0

0 0 1 − mα2

k2 m1

0 k2 −m 2

−1     

   

0 0 0 1 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  m1 m2 4 m1 +m2 3 s + α s + m1 + k2 k2

1 α2 k2

+

k1 +k2 k2 m2

L’équation différentielle entrée sortie est donc m1 m2 d4 y k2 dt4

 3 2 d y + α m1k+m + m1 + 3 dt 2 1 +α 2k2k+k y˙ 2

4.6

α2 k2

+ k1 y

+



1 s2 + α 2k2k+k s + k1 2

k1 +k2 k2 m2



.

y¨ = u.

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. Plusieurs méthodes sont proposées aboutissant chacune à une forme différente.

Systèmes linéaires

4.6.1

65

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 + a2 2 + a1 y˙ + a0 y = b2 2 + b1 + b0 u. 3 dt dt dt dt

(4.17)

La fonction de transfert de notre système est G(s) =

b2 s2 + b1 s + b0 . s3 + a2 s2 + a1 s + a0

Ce qui signifie que, yˆ(s) = G(s)ˆ u(s), où yˆ et u ˆ représentent les transformées de Laplace des signaux y(t) et u(t). On a   1 yˆ(s) = b2 s2 + b1 s + b0 u ˆ(s), 3 2 s + a2 s + a1 s + a0 qui peut se mettre sous la forme
1 x ˆ1 (s) = .ˆ u(s) 2 2 s +a1 s+a0  s3 +a 2 yˆ(s) = b2 s + b1 s + b0 x ˆ1 (s). C’est-à-dire,




s3 x ˆ1 = u ˆ − a2 s2 x ˆ1 − a1 sˆ x1 − a0 x ˆ1 2 yˆ = b2 s x ˆ1 + b1 sˆ x1 + b0 x ˆ1 .

(4.18)

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 sˆ x1 . 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 additionneurs et les amplificateurs ne mémorisent rien). En lisant le schéma, on peut directement écrire les équations d’état de ce système          x ˙ 0 1 0 x 0 1 1            0 1   x2  +  0  u   x˙ 2  =  0    x˙ 3 −a0 −a1 −a2 1  x3  (4.19)     x1      y = b1 b2  x2  . b0     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 + a + a y ˙ + a y = b + b1 + b0 u. 2 1 0 2 3 2 2 dt dt dt dt Dans le domaine de Laplace, cette équation différentielle devient s3 yˆ + a2 s2 yˆ + a1 sˆ y + a0 yˆ = b2 s2 u ˆ + b1 sˆ u + b0 u ˆ. En divisant de chaque côté par s3 et en isolant yˆ, nous obtenons yˆ = − c’est-à-dire 1 yˆ = s

a2 a1 a0 b2 b1 b0 yˆ − 2 yˆ − 3 yˆ + u ˆ + 2u ˆ + 3u ˆ, s s s s s s

  ! 1 1 (b2 u ˆ − a2 yˆ) + (b1 u ˆ − a1 yˆ) + (b0 u ˆ − a0 yˆ) . 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

De ce schéma, nous pouvons                   

67

directement en déduire    0 0 x˙ 1    = x ˙ 1 0   2  x˙ 3 0 1 y

=

les équations d’état du système :      −a0 x1 b0      −a1   x2  +  b1  u −a2 b2  x3  x1     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 G′ (s)

(4.15)

= = =

 −1 T 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 :       1  0 · · · 0 λ 1          1  0 λ2 0 ···    x˙ =   x +    ..  u  ··· ··· ··· ···   .    0 ··· 0 λn  1        y = d u. c1 c2 · · · cn x +

(4.20)

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    s − λ1  = c1 · · · cn  0 ...  1 s−λ1

0 ...  ..  . 0 0 s − λn

0 ···  1  0  0 s−λ2 = c1 · · · cn  .  .. ···  ··· 0 ··· 0 c1 c2 cn = + + ··· + + d. s − λ1 s − λ2 s − λn

 1  1     +d  ···  1   1   1    +d  ···    1

−1

0 ···

···

1 s−λn



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

  det  

s − λ1 0 ··· 0

0 s − λ2 ··· ···

··· 0 ··· 0

0 ··· ··· s − λn



   = (s − λ1 ) (s − λ2 ) . . . (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−λ + s−λ +· · · + s−λ +d) il est possible de mettre le système sous forme modale n 1 2 (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

4.6.4

69

Forme de Jordan

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

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

0 0 1 0 1



   u  

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 G(s) = 2 +

3 1 2 7 4 − − + − . 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 − − 1  2 2       x˙ =   4 1 −1  x +  2  u 4    4 −2 2    y = x. 2 1 1

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  4 − 12 − 12 1 1 1     2 1 2   4 1 −1 4 −2 2 2 1 0     P−1

A

Ainsi, la nouvelle représentation d’état est    2 1     x˙ =   0 2    0 0    y = 6 4



   1 1 1 2 1 0      2 1 2  =  0 2 0 . 2 1 0 0 0 3       P

   0 2    0 x +  0 u 3 −1

4

x.

¯ A

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


x˙ = Ax + Bu y = Cx.

(5.1)

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


x˙ = 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
x˙ = 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 5.2.1

Commandabilité et observabilité 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     x(t) ˙ =  0 1 0  x(t) +  1 0  u(t). 0 0 1 1 0

La matrice de commandabilité est donnée par Γcom



 0 0 1 0 2 0   =  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

Γcom



 0 0 1 0 2 0   =  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, 

    n n−1 x(k + n) = A x(k)+ B | AB | . . . | A B       Γco m

u(k + n − 1) u(k + n − 2) .. . 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  =n rang  ..   .   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 y˙ = CAx + CBu y ¨ = 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

Soit, sous forme matricielle    C y   CA  y˙        =  CA2  y ¨    .. ..       . . (n−1) y CAn−1

Cette équation peut s’écrire sous la forme





      x +       

0 CB CAB .. .

0 0 CB

CAn−2 B

···

0 0 0 .. .

 0  0      ..   . 

CAB CB

u u˙ u ¨ .. . u(n−2)

75



   .   

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 = ΓT Γobs . (z − Φv) . obs Γobs  −1 T Γobs s’appelle l’inverse généralisée de la matrice Γobs . Elle n’existe que si Γobs est de rang La matrice ΓT obs Γobs 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 observable, 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 ; ¯ : non-commandable, O ¯ : non observable C : commandable, O : observable, C 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   0   0 0       22  x(t) ˙ =   x(t) +   u(t)  A31 A32 A33 A34   B3    0 A42 0 A44 0       y(t) = x(t) + (D) u(t) C1 C2 0 0

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 5.3.1

Commande par retour d’état Equation de placement de pôles

On considère le système supposé commandable x˙ = 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 : x˙ = 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 ˜ + BK ˜ 1 K=K ˜ ˜ 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     2 1 4 −1     x˙ =  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,

Soit

  −1       2 3 −1 3 5 1.4227 k1            k2  =  25 21 10   7  −  −29  =  −0.94158  . 41 72 71 5 −129 2.0206 k3 

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 x˙ = 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

0

(w − xc ) dt − Kx,

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    x˙ = Ax + Bu + p z˙ = 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
x˙ = (A − BK) x − BKi z + p z˙ = w − Ex ou, sous forme matricielle :  Puisque



x˙ z˙



=



A − BK −BKi −E 0

A − BK −BKi −E 0



=



 

x z







B 0

A 0 −E 0

−

+ 





p w



K Ki

.



,

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
z˙ = −Ex + w u = −Ki z − Kx.

5.4 5.4.1

Commande par retour de sortie 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
x˙ = 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 y ˆ 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
x˙ = Ax + Bu d ˆ = Aˆ x + Bu − L(Cˆ x − Cx) dt x

(5.3)

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) = Aˆ x + Bu − L(Cˆ x − Cx) − Ax − Bu = A (ˆ x − x) −LC(ˆ x − x). dt

Commande des systèmes linéaires

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


81

x˙ = Ax + Bu ε˙ x = Aεx − LCεx

c’est-à-dire, sous forme matricielle         x˙ A 0 x B = + u ε˙ x 0 A − LC εx 0

(5.4)

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 ˆ = Aˆ x + B(w − Kˆ x) − L(Cˆ x − y) dt x u = w − Kˆ x, ou sous forme simplifiée




d ˆ dt x

u

= (A − BK − LC) x ˆ + Bw + Ly = −Kˆ x + w.

Sous forme matricielle, cette équation s’écrit :      w   d  ˆ = (A − BK − LC) x ˆ+ B L   dt x y     w    u = −Kˆ x + . 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  ˆ = (A − BK − LC) x ˆ + , B L   dt x y   3 R :=   w    −K x ˆ + . I 0   u = 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
x˙ = 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 ˆ = −3ˆ x + 2w + y dt x R := u = −2ˆ x+w

Le système bouclé est décrit par les équations d’évolution suivantes
x˙ = 3x − 4ˆ x + 2w d ˆ = 4x − 5ˆ x + 2w. dt x 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
x˙ = Ax + B (w − Kˆ x) dˆ x = (A − BK − LC) x ˆ + LCx + Bw. dt

(5.6)

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 ˆT )T . Sous forme matricielle, (5.6) s’écrit régulateur rangés dans x ˆ. Son vecteur d’état est donc donné par (xT x        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

ou de façon équivalente



x εx





x x ˆ



=



I 0 −I I

=



I 0 I I





x x ˆ

x εx





,

un autre vecteur d’état possible pour le système bouclé est (x, εx ). Les équations d’état deviennent après changement de base           I 0 A −BK I 0 x I 0 B x˙ = + w −I I LC A − BK − LC I I εx −I I B ε˙ x ou encore



x˙ ε˙ x



=



A − BK −BK 0 A − LC



x εx



+



B 0



w

(5.7)

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        x A − BK −BK x BH d = + w. dt εx 0 A − LC εx 0 Si w(t) est une constante w, ¯ une fois atteint le point d’équilibre, nous avons

0 =



A − BK BK 0 A − LC



x ¯ ¯ εx



+



BH 0



w. ¯

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 = E¯ x = − E (A − BK)−1 BHw. ¯ Ainsi

 −1 ¯ ⇔ −E (A − BK)−1 BH = I ⇔ H = − E (A − BK)−1 B . x ¯c = w

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  ˆ = (A − BK − LC) x ˆ + BH L   dt x y   4 R :=    w   −K x ˆ + . H 0   u = 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 6.2.1

Linéarisation d’un système 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 f (x) ≃ f (¯ x) + avec



  df (¯ x) =   dx 

df (¯ x) (x − x ¯) , dx

∂f1 ∂x1 ∂f2 ∂x1

(¯ x) (¯ x) .. .

∂f1 ∂x2 ∂f2 ∂x2

(¯ x) . . . (¯ x) . . . .. .

∂fp ∂x1

(¯ x)

∂fp ∂x2

(¯ x) . . .

 (¯ x)  (¯ x)  . ..  .  ∂fp (¯ x ) ∂xn ∂f1 ∂xn ∂f2 ∂xn

Cette matrice est appelée matrice jacobienne. Considérons par exemple la fonction     x1 x21 x2 f = . x2 x21 + x22 87

(6.1)

88

Commande par espace d’état

La matrice jacobienne de f en x est df (x) = dx



∂f1 ∂x1 ∂f2 ∂x1

(x) (x)

∂f1 ∂x2 ∂f2 ∂x2

(x) (x)



=



2x1 x2 x21 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 df 2x1 x2 x21 4 1 (x) = et (¯ x) = . dx dx 2x1 2x2 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
x˙ = 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, u ¯), nous avons h(z) ≃ h(¯ z) + avec



dh  (¯ z) =  dz

∂h1 ∂z1 ∂h2 ∂z1

dh (¯ z) (z − ¯ z) , dz

(¯ z) (¯ z)

.. .

∂h1 ∂z2 ∂h2 ∂z2

.. .

Cette matrice jacobienne peut se mettre sous la forme dh (¯ z) = dz



 (¯ z) . . . (¯ z) . . .  .

A B 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 : A= C=

∂f ∂x ∂g ∂x

(¯ x, u ¯) , B = (¯ x, u ¯) , D =

∂f ∂u ∂g ∂u

(¯ x, u ¯) , (¯ x, u ¯) .

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

89

Ainsi, autour du point ¯ z = (¯ x, u ¯), nous avons 

f (x, u) g(x, u)



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

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


x˙ = f (¯ x, u ¯) + A (x − x ¯) + B (u − u ¯) y = g(¯ x, u ¯ ) + C (x − x ¯) + D (u − 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, u ¯ ).

6.2.3

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

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


x˙ = A (x − x ¯) + B (u − u ¯) y = y ¯ + C (x − x ¯) + D (u − u ¯) .

" =u−u " = x−x " = y−y Posons u ¯, x ¯ et y ¯. Ces vecteurs sont appelés les variations de u, x et y. Pour des petites ", x ", y ", on a variations u
d " = A" x + B" u dt x " = C" y x + D" u. Le système ainsi formé est appelé système linéarisé de S autour du point de fonctionnement (¯ x, u ¯).

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
x˙ 1 = (1 − αx2 ) x1 S: x˙ 2 = (−1 + βx1 ) x2 . Rappelons que



x ¯1 x ¯2



=



1 β 1 α



.

90

Commande par espace d’état

est un point d’équilibre. Autour de ce dernier, df (¯ x) (x − x ¯) f (x) ≃ f (¯ x) + dx    x1 − x 1 − α¯ x2 −α¯ x1 ¯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   0 − αβ d "= ". x x β dt 0 α

Les valeurs propres s’obtiennent en calculant les racines du polynôme caractéristique. Puisque   α s β = s2 + 1, det β −α 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       x ˙ x 2 1  = f (x, u) = −ℓmg sin x1 +u x˙ 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  x1 1  (x, u) =  −g cos 0 mℓ 2 , ℓ d(x,u) ℓ cos x1 0 0

au point (¯ x = (0, 0),¯ u = 0), le système linéarisé est décrit par les équations d’état suivantes :       0 0 1   x˙ = x+ u 1 − gℓ 0 2 mℓ      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   x2  x˙ 1 = ax3 −kx1 S: x˙ 2 = m   x˙ = − x3 x − u  . 3 2 x1 a Supposons que x1 > 0 et calculons l’ensemble des points de x˙ = 0 donne   x2  ax3 − kx1   x x − u  1 2 a soit

fonctionnement (¯ x, u ¯) possibles pour S. La condition = 0 = 0 = 0

  

x2 = 0 ax3 − kx1 = 0   u = 0

Les points de fonctionnement sont donc de la forme

  k (¯ x, u ¯) = x ¯1 , 0, x ¯1 , 0 . a Différencions maintenant S autour du point de fonctionnement (¯ x, u ¯) 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 df  k (¯ x, u ¯) =  − m d(x,u) 0

Le système linéarisé s’exprime donc par 

0  k x˙ =  − m 0

1 0 − ka

0 a m

0



1 0 − ka

 0  0 .

0 a m

k a2

0 

 0    ¯) +  0  u.  (x − x 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 6.3.1

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

Considérons le système décrit par ses équations d’état
x˙ = f (x, u) S: y = g(x),

(6.2)

dont (¯ x, u ¯) 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
x˙ = A (x − x ¯) + B (u − u ¯) y = 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−x (¯ x, u ¯). Puisque le vecteur 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" x + B (u − u ¯) dt x y = y ¯ + C" x. " = u− u Afin que notre système se comporte comme un système linéaire (et non affine), construisons les variables u ¯ " =y−y et 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" x + B" u dt x " 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

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

où w ¯ = E¯ x. 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écapitulatif 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 ¯, u ¯ ; out : R) 1 Vérifier que f (¯ x, u ¯) = 0; 2 y ¯ := g (¯ x) ; w ¯ := E¯ x; ∂f ∂f 3 A := ∂x (¯ x, u ¯ ) ; B := ∂u (¯ x, u ¯) ; C := ∂g x, u ¯) ; ∂x (¯ 4 K :=

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

 AT , CT , pobs ;  −1 −1 6 H := − E (A − BK) B ;
d ˆ = (A − BK − LC) x ˆ + BH (w − w) ¯ + L (y − y ¯) dt x 7 R := u = u ¯ − Kˆ x + 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
x˙ = 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 à ¯ = −8. Si nous voulons qu’à l’équilibre y = w, la main. Afin d’avoir f (¯ x, u ¯) = 0, il nous faut 2¯ x2 + u = 0, soit u

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 x, u ¯) nous donne A = 8, B = 1 et C = 3. Pour K et L, il faut pcom = pobs = −1. La linéarisation autour de (¯ résoudre les deux équations polynomiales
det (sI − A + BK) = s+1   T T T = s+1 det sI − A + C L

c’est-à-dire s − 8 + K = s + 1 et s − 8 + 3L = s + 1. Donc K = 9 et L = 3. De plus y¯ = 6, w ¯ = 3¯ x = 6.  −1 −1 H = − 3 (8 − 9) = 1/3. Donc le régulateur s’écrit R:

6.3.2




d ˆ dt x

u

= −10ˆ x + (w − 6) /3 + 3 (y − 6) = −8 − 9ˆ x + (w − 6) /3.

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 ˆ = Aˆ x + B (−Kˆ x + H (w − w)) ¯ −L (Cˆ x+y ¯) + Ly dt x R: u = u ¯ − Kˆ x + H (w − w) ¯ . Or,

et

Aˆ x + B (−Kˆ x + H (w − w)) ¯ = Aˆ x + B (u − u ¯) = f (¯ x, u ¯) + Aˆ x + B (u − u ¯) ≃ f (ˆ x+x ¯, u) = f (ˆ x+x ¯, u ¯ − Kˆ x + H (w − w)) ¯

// // // // //

voir équation d’évolution de R équation d’observation de R puisque f (¯ x, u ¯) = 0 Taylor d’ordre 1 en (¯ x, u ¯). équation d’observation de R

Cˆ x+y ¯ // voir équation d’évolution de R = g(¯ x) + Cˆ x // puisque y ¯ = 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 ˆ = f (ˆ x+x ¯, u ¯ − Kˆ x + H (w − w)) ¯ − L (g(ˆ x+x ¯) + y) dt x Re := u = u ¯ − Kˆ x + 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, θ, x, ˙ θ˙ , et en supposant que seule la position du chariot x est mesurée, les équations d’état sont données par :      x3  x ˙  1        x4     x˙ 2  =    m sin x2 (g cos x2 −ℓx24 )+u      x˙ 3  2x M+m sin   2  2  sin x2 ((M+m)g−mℓx4 cos x2 )+cos x2 u  x ˙ 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 u ¯ = 0. Nous obtenons la matrice   0 0 1 0 0  0 0 0 1 0    dh  mg 1  0 0 (¯ x,¯ u) =  0 M M    d (x,u) 1   0 (M+m)g 0 0 Mℓ Mℓ 1 0 0 0 0

qui nous amène au système linéarisé suivant :   0 0       0  x˙ =  0  mg  0 M  (M+m)g   0  Mℓ   y = (1 0 0 0)

1 0 0 0 x.

0 1 0 0





 0   0     x +  1 u   M  1 Mℓ

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 x˙ 1   x4   x˙ 2      =  µ3 (µ2 x24 −µg cos x2 ) sin x2 +(µ2 +µ3 cos x2 )u  2   2 x˙ 3  µ1 µ2 −µ3 cos x2   µ µ −µ2 x2 cos x sin x −(µ +µ cos x )u ( ) 2 2 2 1 g 1 3 3 4 x˙ 4 µ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 fonctionnement u ¯ = 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 0 0 µ µg 0 − µ µ3 −µ 2

   dh (¯ x,¯ u) =   d (x,u)  0  1

1 2 µ1 µg

µ1 µ2 −µ23

0

1 0 0 1 0 0

3

0 0 0 0

0 0 µ2 +µ3 µ1 µ2 −µ23 3 − µµµ1 +µ 2 1 2 −µ3

0

       

au point (¯ x = (0, 0), u ¯ = 0). Le système linéarisé est décrit par les équations d’état suivantes :       0 0 0 1 0         0 0 1     0 0      x˙ =    0 − µ3 µg 2 0 0  x +  µ2 +µ3 2  u µ µ −µ µ µ −µ   1 2 3   1 2 3 µ1 µg  3  0 0 − µµµ1 +µ 0  2 2  µ µ −µ 1 2 1 2 −µ3 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 programme 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’expression 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.  → → u un vecteur. La demi-droite E m,− u de sommet m et Théorème 6.6.1 Soient m, a, b trois points de R2 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 − → det(a − m, b − a). det( u , b − a) ≥ 0.

(6.3)

→ Dans ce cas, la distance du point m au segment [ab] suivant le vecteur − u est donnée par d=

det(a − m, b − a) . → 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, u ˜) 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 ˙ et trois sorties (la distance d du milieu de l’essieu arrière au bord de la v˙ et la vitesse angulaire du volant δ) 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 2 3 4 5 6 7 8 9 10 11

function y=g(x) u=[sin(x(3)) ;-cos(x(3))] ; m=[x(1) ;x(2)] ; d=%inf ; for j=1 :size(Aj,2) a=Aj( :,j) ; b=Bj( :,j) ; if (det([a-m u])*det([b-m u]) <= 0)& (det([a-m b-a])*det([u b-a])>=0) d=min(det([a-m b-a])/det([u b-a]),d) ; end end y=[d ;x(4) ;x(5)] ; 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       x˙ −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 u ¯ = (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 1     h:  v     u2   →      δ     x       sin θ    u1      v     u  2 δ est donnée par

           

0 0 0 0 1 sin θ

0 0

v cos δ sin θ − cos δ cos θ v sin δ cos θ sin δ δ 0 v cos L L 0 0 0 0 0 0 x − sin2 θ cos θ 0 0 0 1 0 0 0 1

0 0 1 0 0 0 0

0 0 0 1 0 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



     dh (¯ x, u ¯) =   d (¯ x, u ¯)    

Donc les matrices du système linéarisé sont    A= 



 C=

0 0 0 0 1 0 0

7 0 0 0 0 0 0

0 0 0 0 1 0 0

7 0 0 0 0 0 0

0 0 0 0 0 1 0

0 0 0 0 0 1 0

0



0 0 7 3 0 0 1 0 0 0 0 0 0 1 0

0 0 0 1 0 0 0



       A B = .  C D     

    , B =   0  0   0   0 , D =  1 7 3

0 0 1 0 0 0 0

0 0 0 1 0 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  x ˆ = x ˆ + −  dt         0  0 2 0 2 0  y  28  0 −4 0  2.4    −0.5 −5.1 0 −8   0.5 0 0 0 2     0 0 −2 0 0 2 5   x ˆ+ w− .   u= −0.49 −5.14 0 −6 0.48 0 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

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

105

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 :
x˙ = x3 + xu y = exp(x).

(7.1)

On souhaiterait que sa sortie y soit égale à une consigne supposée constante v. En dérivant la sortie y nous obtenons y˙ = x˙ exp (x) = x3 exp (x) + x exp (x) u. 107

108

Commande par espace d’état

Posons u=

 3  1 −x exp (x) + v , x exp (x)

(7.2)

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 : y˙ = 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
z˙ = 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
z˙ = w − exp(x)  3  RNL : 1 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 7.3.1

Principe de la linéarisation par bouclage 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
x˙ = 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) ,  ..   (k ) ym m

(7.3)

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 )  = v1   y1 . .. . 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`eme (j) dérivée de la ii`eme sortie yi s’exprime sous la forme (j)

yi

(j)

yi

(j)

yi

= ˆbij (x) si j < ki ˆ = ˆ aT ij (x).u + bij (x) si j = ki = ˆ aij (x, u, u, ˙ u ¨, . . . ) si j > ki

Le coefficient ki s’appelle le degré relatif de la ii`eme 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 , y˙1 , . . . , y1 1 , y2 , y˙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
x˙ = xu + x3 y= 2x. Nous avons y = 2x y˙ = 2x˙ = 2xu + 2x3 y¨ = 2xu ˙ + 2xu˙ + 6xx ˙ 2 = 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 y˙ sans avoir à utiliser de dérivateurs de signaux. Cela n’est pas le cas pour y¨ 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   ˙ − · · · + αn−1 w(n−1) − y (n−1) + w(n) . u = α0 (w − y) + α1 (w˙ − y)

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 (w˙ − y) ˙ − · · · + α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 e˙ + α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 (w˙ − y) ˙ + 3 (w ¨ − y¨) + w.

(7.5)

Régulateur proportionnel intégral et dérivées : Afin de compenser les perturbations constantes, nous pouvons 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 (w˙ − y) ˙ − · · · + α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

d’où, en dérivant une fois,

  +α0 (w − y) + α1 (w˙ − y) ˙ − · · · + αn−1 w(n−1) − y (n−1) + w(n) , e(n+1) + αn−1 e(n) + · · · + α1 e¨ + α0 e˙ + α−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  h˙ 1 = −α (h1 ) − α (h1 − h2 ) + u1       h˙ 2 = α (h1 − h2 ) − α (h2 − h3 ) (7.7) h˙ 3 = −α (h3 ) + α (h2 − h3 ) + u2 .    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 y˙ 1 = h˙ 1 = −α (h1 ) − α (h1 − h2 ) + u1 y˙ 2 = h˙ 3 = −α (h3 ) + α (h2 − h3 ) + u2 ou, sous forme vectorielle, 

y˙1 y˙2





   1 0 −α (h1 ) − α (h1 − h2 ) u+ . = 0 1 −α (h3 ) + α (h2 − h3 )       A(x)

Le bouclage suivant

b(x)

u = A−1 (x) (v − b (x)) = v −



−α (h1 ) − α (h1 − h2 ) −α (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
y˙1 = v1 SL : y˙2 = v2 .

(7.8)

(7.9)

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τ + w˙ 1 t RL : v2 (t) = β 0 (w2 (t) − y2 (t)) + β −1 0 (w2 (τ ) − y2 (τ )) dτ + w˙ 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   z˙   1  z˙2 RL :  v 1    v2

donc = = = =

w1 − y1 w2 − y2 z1 + 2 (w1 − y1 ) + w˙ 1 z2 + 2 (w2 − y2 ) + w˙ 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

RNL

  z˙1    z˙ 2 :  u1    u2

= = = =

w1 − h1 w2 − h3 z1 + 2 (w1 − h1 ) + w˙ 1 + α (h1 ) + α (h1 − h2 ) z2 + 2 (w2 − h3 ) + w˙ 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       

x˙ y˙ θ˙ v˙ g v˙ d





      =    

vg +vd cos θ 2 vg +vd sin θ 2 vd −vg ℓ

Ru1 Ru2



   .  

Prenons pour sortie y1 = y2 =

θ vg +vd 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 y˙1 = θ˙ = (on dérive encore une fois) ℓ R y¨1 = ¨θ = (u2 − u1 ) ℓ R y˙2 = (u2 + u1 ) , 2 soit



y¨1 y˙2



=

u1 u2



= A−1 (x)

− Rℓ R 2



Si on effectue le bouclage 







R ℓ R 2



A(x)

v1 v2



1 = 2R





u1 u2



−ℓ 2 ℓ 2

.



où v = (v1 , v2 ) est le vecteur des nouvelles entrées, on obtient le système SL :



y¨1 y˙2



=



v1 v2



v1 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 ¨1 = w1 − θ + 2 w˙ 1 − d ℓ g + w ¨1 v1 = (w1 − y1 ) + 2 (w˙ 1 − y˙1 ) + w v2 =

w2 − y2 + w˙ 2

=

w2 −

vg +vd 2

+ w˙ 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




 v1 = −θ + 2 − sin t − v2 =

sin t −

vg +vd 2

vd −vg ℓ

+ cos t.



Finalement la commande à donner au char est donnée par        v −v −θ + 2 − sin t − d ℓ g 1 u1 −ℓ 2 . = v +v 2R u2 ℓ 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     x˙ v cos δ cos θ  y˙   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 y˙ 1 = v˙ = u1 , v sin δ y˙ 2 = θ˙ = . L Comme la dérivée y˙2 de y2 ne fait pas apparaître l’entrée, on la redérive une nouvelle fois : y¨2 = v˙

sin δ v δ˙ cos δ sin δ v cos δ + = u1 + u2 . L L L L

Les expressions pour y˙1 et y¨2 peuvent se réécrire sous forme matricielle      y˙ 1 1 0 u1 = . sin δ v cos δ y¨2 u2 L L    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, SL :



y˙1 y¨2



=



v1 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 ) + w˙ 1 RL : v2 = β 0 (w2 − y2 ) + β 1 (w˙ 2 − y˙ 2 ) + w ¨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 u=



1

0

δ − tan v

L v cos δ



α0 (w1 − v) + w˙ 1   δ β 0 (w2 − θ) + β 1 w˙ 2 − v sin +w ¨2 L



(7.10)

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 det (A(x)) =

v cos δ 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

7.6.2

Commande par espace d’état

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  →   −1 (ρ(r − 2 + y 2 )) + v y h: x tan x x v r 0 0  . → √ 21 2 x +y 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 z˙ = h(z)) admet un cycle limite qui est un cercle de rayon r0 . Sur ce cercle, nous avons ||˙z|| = 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˙ x =h = h (c, x, y) . y˙ y La notation h (c, x, y) nous rappelle la dépendance du champ en c = (r0 , v0 ) . Or,       x˙ v cos δ cos θ w1 cos w2 = ≃ y˙ 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

u=



1

0

δ − tan v

L v cos δ



α0 (h (c, x, y) − v) δ β 0 (argθ (h (c, x, y)) − θ) − β 1 v sin L



.

Ici, nous avons pris w˙ 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       z˙

   x2 + y 2 = c− v    #  # #h c + z , x, y # − v  1 0  5     .  L δ δ  u = − tan 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                               

x˙ y˙ θ˙ δ˙ v δ˙ g v˙ ω˙ fv fg

= = = = = = = = =

1 J

v cos θ, v sin θ − βV, ω, u1 , u2 , 1 (f sin δ − fg sin δg − αf v) , v v m ((ℓ − rv cos δ v ) fv − rg cos δ g fg − αθ ω) , αv (V cos (θ + δ v ) − v sin δ v ) , αg v sin δ g .

(7.11)

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 x, ˙ y, ˙ x ¨, y¨. 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

dépendent pas algébriquement de u,   x ¨     y¨     ¨θ 

˙ v˙ et ω. c’est-à-dire, x, ˙ y, ˙ θ, ˙ On obtient v˙ cos θ − vθ˙ sin θ, v˙ sin θ + vθ˙ cos θ, ω, ˙

= = =

v¨ =      ω ¨ =     

avec

119

(7.12)

f˙v sin δ v +fv u1 cos δ v −f˙g sin δ g −fg u2 cos δ g −αf v˙ , m u1 rv sin δ v fv +(ℓ−rv cos δv )f˙v J rg (u2 sin δg fg −cos δ g f˙g )−αθ ω˙ + . J

   f˙v =

−αv V (ω + u1 ) sin (θ + δ v ) −αv v˙ sin δv − αv vu1 cos δ v αg (v˙ sin δ g + vu2 cos δg ) .

  f˙ = g

˙ ω˙ sont des fonctions analytiques de l’état (voir (7.11)), on peut considérer Notons que, puisque les grandeurs v, ˙ θ, que nous avons ici une expression analytique de x ¨, y¨, ¨θ, 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 x ¨, y¨ et ¨θ. On obtient  ... 2   x = v¨ cos θ − 2v˙ θ˙ sin θ − v¨θ sin θ − v θ˙ cos θ ... 2 (7.13) y = v¨ sin θ + 2v˙ θ˙ cos θ + v¨θ cos θ − v θ˙ sin θ  ...  θ = ω ¨. 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        y˙1 δ˙ v 1 0 u1 ... ... = = rg rv y2 θ u2 J fv sin δ v J fg sin δ g    

+

Or





f˙v f˙g



A1 (x)

0

ℓ J

−

rv J

cos δ v − rJg 

0 cos δ g

A2 (x)

 

f˙v f˙g





+



0



. − αJθ ω˙    b1 (x)

  −αv (V sin (θ + δ v ) + v cos δv ) 0 u1 = 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   y˙1 ... = A1 u + A2 (A3 u + b2 ) + b1 y2 = (A1 +A2 A3 ) u + A2 b2 + b1 = Au + b. ... Pour imposer (y˙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
y˙ = v1 , SL : ...1 y 2 = v2 .

(7.14)

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 det (A(x)) = est nul si

 rg  fg sin δ g − vαg cos2 δ g , J

  v 2 sin2 δ g − 1 = 0,

c’est-à-dire si

π π +k . 4 2 Une telle configuration correspond à une singularité qu’il faudra tenter d’éviter. v = 0 ou bien δ g =

(7.15)

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 ) + w˙ 1 , RL : v2 = β 0 (w2 − y2 ) + β 1 (w˙ 2 − y˙2 )  ...  +β 2 (w ¨2 − y¨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 ˆθ1 = 7π , ˆθ 2 = 5π , ˆθ3 = π et ˆθ 4 = 5π , 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   arg ˆθ, ˆθi = ˆθi + 2π.round



ˆθ − ˆθi 2π



,

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 ˆδ v = ϕ (θ) = π.floor



θ 1 + 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 avec

∂f ∂x1 (x)

= 4x1 − 6x2 − 2 et

∂f ∂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 : f (x+δx) =f(x)+

df (x)δx + o (||δx||) dx

(8.2)

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) = xT Qx + 2xT Q (δx) + o (||δx||)

(8.3)

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   ∂f df ∂f (x), . . . , (x) = 2xT Q. (x) = 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 2 −3 14 = . x∗ = − 2 1 − 27 −3 1 et son minimum est

8.2 8.2.1

 1 f(x∗ ) = − −2 1 4



2 −3 −3 1

−1 

−2 1



+1=

11 . 14

Méthode des moindres-carrés 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 ⇔ 2ˆ pT MT M − 2yT M = 0 ⇔ ⇔

MT Mˆ p = MT y

p ˆ T MT M = yT M  −1 T ⇔ p ˆ = MT M M y.

−1 T  M s’appelle inverse généralisée de la matrice rectangulaire M. La matrice MT M

128

8.2.3

Commande par espace d’état

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 y

−3 17

Pour obtenir ces mesures, nous avons pris p∗1 =

−1 3

0 1

2 5

3 11

6 46

√ ∗ 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 1  y (p) = 0p − 0p + p   0 0  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



Les mesures filtrées sont

 1.41  −1 T   p ˆ = MT M M y =  −0.98  1.06

y ˆ = ym (ˆ p) = Mˆ p = (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) Tr (Nm) Ω(tr/ min)

40 0 490

100 0 1210

100 20 1090

On a ym (p) = M.p

130 20 1410

150 10 1730

150 30 1630

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

avec



    M =   

Donc

40 100 100 130 150 150

0 0 20 20 10 30



     p1  , p =  p2  

 −1 T p ˆ = MT M M y=





    et y =     11.98 −6.02



490 1210 1090 1410 1730 1630

129



    .   

.

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). Sur ce système, on effectue des mesures 0 à 7. On obtient k u(k) y(k)

(8.4)

plus ou moins bruitées de l’entrée u(k) et la sortie y(k) pour k variant de 0 1 0

1 −1 −1

2 1 −2

3 −1 3

4 1 7

5 −1 11

6 1 16

7 −1 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 

    M =   

−y(1) −y(2) −y(3) −y(4) −y(5) −y(6)

−y(0) −y(1) −y(2) −y(3) −y(4) −y(5)

u(1) u(2) u(3) u(4) u(5) u(6)

u(0) u(1) u(2) u(3) u(4) u(5)





        =      

  T m2 1 0 −1 1  mT 2 1 1 −1    3  −3 2 −1 1    mT  =  4T −7 −3 1 −1   m5   −11 −7 −1 1   mT 6 mT −16 −11 1 −1 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 j(p)
||Mp − y|| avec



   y(2)   ..   y= . =   y(7)  

−2 3 7 11 16 36

2



        et p =     

a1 a0 b1 b0



  . 

 −1 T M y Or ici, la matrice M est de rang 3. En effet, du fait de la forme Nous devrions avoir p ˆ = MT M 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  T −1  T −1 sens des moindres-carrés est p ˆ= M M My et le vecteur des mesures filtrées est y ˆ=M M 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 y ˆ 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

input 1 2 3 4

8.3

131

p j + = j(p); q = p + δp; if j (q) < j + {p = q; j + = j(q)} ; goto 2.

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 u ˜ sera un vecteur unitaire représentant la direction du faisceau. Pour le kième capteur, l’expression du vecteur directeur u ˜ du faisceau lancé par le capteur est

u ˜=



   + θ cos kπ  4  , sin kπ 4 +θ

k ∈ {0, . . . , 7}.

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  u ˜ = cos

(i−1)π 4 T

   + θ ; sin (i−1)π + θ ; ℓi = ∞; 4

m = (x y) ; for j = 1 to n if det (aj −m, u ˜) . det (bj −m, u ˜) ≥ 0 then next j ; det(m−aj −m,bj −aj ) α := det(˜ u,bj −aj )

(8.5)

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 8.4.1

Moindres-carrés récursifs 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   mT  0p    mT p 1 ..  .     mT p k−1

= = .. .

y(0) y(1) .. .

= y(k − 1)



  ⇔  

mT 0 mT 1 .. . mT k−1





    p =     

y(0) y(1) .. . y(k − 1)



   ⇔ Mk p = yk  

(8.6)

Le point p ˆk qui minimise le critère j(p)
||Mk p − yk ||2 =

k−1   T 2 mi p−y(i) i=0

est donné par −1 T p ˆk = (MT 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

T Posons ∆k = MT k Mk et vk = Mk yk . Nous avons      M  k  T T  = MT Mk mk  ∆k+1 = k Mk + mk mk T  m    k    y k  vk+1 = = MT mk MT  k yk + mk y(k) k  y(k)     p ˆk = ∆−1 k vk

On peut donc exprimer ∆k+1 , vk+1 en fonction de ∆k les p ˆ k sont données par    (i) ∆k+1 (ii) vk+1   (iii) p ˆk

et vk et mk et y(k). Ainsi, les équations d’état pour générer = ∆k + mk mT k = vk + mk .y(k) = ∆−1 k vk .

(8.7)

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   ˆ k + kk y(k) − mT ˆk p ˆk+1 = p kp

où apparaissent

la prédiction l’erreur de prédiction le gain de correction ou gain de Kalman Pour cela, on procède comme suit : p ˆk+1

ˆk yˆ(k) = mT kp e(k) = y(k) − mT ˆk kp −1  kk = ∆k + mk mT mk k

(8.7,iii)

=

∆−1 k+1 vk+1

(8.7,ii,iii)

∆−1 ˆk + mk y(k)) k+1 (∆k p −1 p ˆk + ∆k+1 ((∆k − ∆k+1 ) p ˆk + mk y(k))   −1 p ˆk + ∆k+1 . −mk mT ˆk + mk y(k) kp  −1   p ˆk + ∆k + mk mT mk y(k) − mT ˆk . k kp

= =

(8.7,i)

=

(8.7,i)

=

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 mk y(k) − mT ˆk k kp

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 CA−1 . (A + BC)−1 = A−1 − A−1 B 1 + CA−1 B

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 k+1 =

−1  −1 T −1  −1 T −1 ∆k + mk mT = ∆−1 mk ∆k k k − ∆k mk 1 + mk ∆k mk

= ∆−1 k − soit

En remarquant que

on en déduit que

T −1 ∆−1 k mk mk ∆k −1 1 + mT k ∆k mk

  Γk+1 = Γk −  p ˆk+1 =

Γk mk mT k Γk TΓ m 1+m k k  k  Γk mk mT Γ p ˆ k + Γk − 1+mT Γ kmk mk k k k

  ˆk . y(k) − mT kp

  Γk mk mT Γk mk k Γk Γk − mk = , 1 + mT Γ m 1 + mT k k k k Γk mk

  Γk+1 = Γk − Γk mk mTk Γk 1+mT k Γk mk   Γk mk  p ˆk+1 = p ˆk + 1+m y(k) − mT ˆk TΓ m kp k

k

k

ˆ k . Remarquons que, tout comme ∆k Ce sont des équations d’état où les entrées est y(k) et mk et la sortie est p 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 (ˆ pk , Γk ) l’ellipsoïde E d’équation (p − p ˆ k )T Γ−1 ˆk ) ≤ 1. k (p − p 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

p ˆ0 = (0, 0, . . . , 0)

T



1 ε

  0 et Γ0 =    0

0 1 ε



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 mT 0   k   2   ...  k−i k   ∆k+1 = = λ mi mT λ m0 · · · λmk−1 mk  i  T  λmk−1  i=0 mT k k−1  2  2 T + mk mT λ(k−1)−i mi mT = λ2 i k = λ ∆k + mk mk i=0

vk+1 =



= λ2

k

λ m0 · · ·

λmk−1



λk y(0)    .. . mk    λy(k − 1) y(k)



  k  2  k−i = λ mi y(i)   i=0

k−1    λ(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   Γk mk  p ˆk+1 = p ˆk + λ−2 1+m y(k) − mT ˆk TΓ m kp k

8.5

Filtrage de Kalman

8.5.1

Matrice de covariance

k

k

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 :   1 −n T −1 − 12 2 ¯) Γx (x − x ¯) . (8.8) px (x) = (2π) det(Γx ) exp − (x − x 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   T −1  −1  1 px (A−1 y) (8.8) 1 1  −1 −n − −1 −1 py (y) = = (2π) 2 det(Γx ) 2 exp − A y − A y ¯ Γx A y − A y ¯ | det(A)| | det(A)| 2 Or

et

 −1  −1  −1 T  A y − A−1 y A y − A−1 y ¯ Γ−1 ¯ = (y − y ¯)T AΓx AT (y − y ¯) x 1

donc

 − 1 1 1 1 det(Γx )− 2 = | det(A)|− 2 . det(Γx )− 2 .| det(AT )|− 2 = det AΓx AT 2 | det(A)| −n 2

py (y) = (2π)

T − 12

det(AΓx A )

   1 T T −1 exp − (y − y ¯) AΓx A (y − y ¯) 2

Ainsi, y est aussi une variable aléatoire gaussienne. Son espérance est y ¯ = A¯ x et sa matrice de covariance est T Γy = A.Γx .A . Cette propriété se généralise même lorsque A est rectangulaire, de rang quelconque. Soient x1 et x2 sont deux ¯ et de matrices de covariance Γx1 et Γx2 . Le vecteurs aléatoires gaussiens indépendants, d’espérances x ¯1 et x   T T 2T  T T est aussi gaussien d’espérance x vecteur x = xT , x ¯ = x ¯ , x ¯ et de matrice de covariance 1 2 1 2 Γx =



Γx1 0 0 Γx2



.

Le vecteur aléatoire y = A1 x1 + A2 x2 = satisfait y ¯=



et Γy =



A1 A2



A1 A2





Γx1 0 0 Γx2





x ¯1 x ¯2



A1 A2 





x1 x2



= A1 x ¯ 1 + A2 x ¯2 .

AT 1 AT 2



T = A1 Γx1 AT 1 + A2 Γx2 A2 .

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

8.5.3

Commande par espace d’état

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  0 ε  T   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  CΓx AT + Γv Γx = A Γx − Γx CT Γz + CΓx CT

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 :    −1     p ˆ (k + 1) = p ˆ (k) + Γx (k)mk 1 + mT Γ (k)m y(k) − mT ˆ (k) x k k kp      Γx (k + 1) = Γx (k) − Γx (k)mk 1 + mT Γx (k)mk −1 mT Γx (k) + Γv (k) k k

8.6 8.6.1

Application à l’estimation en temps réel d’une fonction de transfert 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 K(k) = Γx (k).CT (k). Γz + C(k)Γx (k)CT (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 

    C(k + 1) = C(k)    

0 0 0 0 0 0

1 0 0 0 0 0

0 1 0 0 0 0

0 0 0 0 0 0

0 0 0 0 1 0

0 0 0 0 0 1



     0 0 0 1 0 0   + (u(k) y(k))  −1 0 0 0 0 0  

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)  (y(k) − C(k)ˆ p(k)) ˆ(k + 1) = p ˆ(k) + Γz +C(k)Γ  T  p x (k)C (k) Γx (k)CT (k) Γx (k + 1) = Γx (k) − Γz +C(k)Γx (k)CT (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

8.7 8.7.1

141

Localisation d’un robot sous-marin dans une piscine 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 perpendiculairement à 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 a ˜k = ℓ(t − kδ). cos (−kδ α) ˙ . La quantité a ˜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 a ˆ de la distance a par une moyenne : a ˆ=

N−1 1  a ˜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 a ˜k est faible, c’est-à-dire que N−1 1  (˜ ak − a ˆ)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 a ˜k par ordre croissant. Ensuite, on prend le milieu a ¯ de la liste et on supprime de la liste les éléments de cette liste qui sont les plus éloignés de a ¯. 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 a ˆ. 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   x˙ = vx    y˙ = v y (8.10)  v˙ x = aT . cos θ − aN sin θ    v˙ y = aT . sin θ + aN cos θ

où vx = x, ˙ vy = y. ˙ 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 θ :      x ¨ cos θ − sin θ aT = . aN y¨ sin θ cos θ

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) (8.11)  0 0  −T (k) sin θ(k) T (k) cos θ(k)  1 0  T (k) cos θ(k) T (k) sin θ(k) 0 0 0 1 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π +

3π 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π + c’est-à-dire ∃k ∈ N,

iπ 2

2 (θ(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

8.7.4

 −1 K(k) = Γx (k).CT (k). Γz (k) + C(k).Γx (k).CT (k) .

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 ˆ) ≤ 1. (x − x ˆ)T Γ−1 (x − x 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

1

||Q− 2 (w − w) ¯ ||2 ≤ 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 2 Γ(n/2) fn (z) = 0 sinon où Γ(a) =



∞

0

e−t ta−1 dt = (x − 1)!

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

1

||Γ− 2 (x − x ¯) ||2 ≤ α2 .

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 ¯) ≤ 6. (x − x ¯)T .Γ−1 . (x − x

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 équation d’observation, 13 état, 13 asservissement, 14 automatique, 14 bacs, 31 bateau à voile, 118 Bernouilli, 31 bouclage linéarisant, 108 bras manipulateur, 49 calcul formel, 14 calcul numérique, 14 champ de vecteur, 39 changement de base, 61 char, 26, 113 commandabilité, 72 commande, 13, 14 commande non linéaire, 87, 107 commande par retour d’état, 76 commande par retour de sortie, 79 commande proportionnelle et dérivée, 110, 115 commande proportionnelle et intégrale, 112 conduite automatique, 98 configuration, 53 consigne, 14 coordonnées homogènes, 46 critère d’observabilité, 74 critère de commandabilité, 73 cycle, 44 décomposition de Kalman, 75 déterminant, 100 entrée, 13 estimateur d’état, 72 eventhandler, 53 exponentielle de matrice, 57

fauteuil roulant, 26, 113 filtre de Kalman, 138 fonction de transfert, 63 forme canonique d’observation, 67 forme canonique de commande, 66 forme de Jordan, 69 forme modale, 67 gain de Kalman, 138 gestionnaire d’événement, 53 glossaire Mupad, 149 glossaire Scilab, 149 holonome, 27 intégrateur, 18 interactivité, 53 inverse généralisée, 75, 127 linéarisation, 87 linéarisation par bouclage, 107 linéarité par rapport aux paramètres, 127 méthode d’Euler, 50 méthode du gradient, 41 Maple, 14 Matlab, 14 matrice compagne, 62 matrice d’évolution, 14, 71 matrice d’observabilité, 74 matrice d’observation, 14, 71 matrice de commandabilité, 73 matrice de commande, 14, 71 matrice de consigne, 84 matrice de passage, 61 matrice de rotation, 46 matrice de transfert, 63 matrice directe, 14 matrice jacobienne, 87 modélisation, 13, 17 150

Index

modeleur, 45 moindres carrés, 127 moindres carrés récursifs, 132 monocycle, 24 motif, 45 Mupad, 14

système monovariable, 64 système proies-prédateurs, 42, 89 système tangent, 89 systèmes électriques, 35 systèmes hydrauliques, 31 systèmes mécaniques, 18

observabilité, 74 observateur, 80 observateur étendu, 94

temps continu, 13 temps discret, 13 temps réel, 51 transformée de Laplace, 63

pendule inversé, 22, 94 pendule simple, 21 pendulechamp.sce, 44 pendulesimu.sce, 51 penduletrajectoire.sce, 52 placement de pôles, 72, 76 point d’équilibre, 42, 89 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

vérin, 33, 91 variables consignées, 84 variations, 89 vecteur propre, 40 voilier, 29 voiture, 27, 53, 98

151