Introduction au Contrôle de l’Espace-État

Note

Cet article est tiré de Controls Engineering in FRC par Tyler Veness avec permission.

Du PID au Contrôle à base d’un modèle

Quand nous réglons les contrôleurs PID, nous nous concentrons le réglage des paramètres du contrôleur liés à l’erreur actuel, du passé et du futur. (termes P, I et D) au lieu de nous concentrer aux états du système sous-jacent. Bien que cette approche fonctionne dans beaucoup de situations, c’est une vue incomplète de la réalité du système étudié.

Le contrôle à partir d’un modèle se concentre sur le développement d’un modèle précis du système (mécanisme) que nous essayons de contrôler. Ces modèles aident à affiner les gains choisis pour les commandes de rétroaction basées sur les réponses phyiques du système, au lieu d’avoir un gain proportionnel arbitraire dérivé de tests. Cela nous permet non seulement de prédire comment un système va réagir, mais aussi de tester nos contrôleurs sans avoir un robot physique en notre possession et gagner du temps pendant le débogage des simples bogues .

Note

Le contrôle de l’espace-état utilise abondamment l’algèbre linéaire. Des informations plus approfondies sur l’algèbre linéare dans la théorie de la commande moderne, comprenant une introduction à l’algèbre linéaire ainsi que des ressources, peuvent être trouvées au Chapitre 4 du livre Controls Engineering in FRC.

Si vous avez utilisé les classes feedforward de la WPILib pour SimpleMotorFeedForward ou ses classes soeurs, ou si vous avez utilisé l’outil de caractérisation FRC pour régler des gains PID à votre place, vous êtes déjà familier avec le contrôle à base de modèle! Les gains kv et ka peuvent être utilisé pour décrire comment un moteur (ou un bras, un entraînement) vont réagir à une tension. Nous pouvons mettre ces constantes en notation standard dans l’espace-état en utilisant la classe LinearSystem de WPILib, quelque chose que nous allons faire dans un prochain article.

Vocabulaire

Pour le vocabulaire de base qui sera utilisé tout au long de cet article, consultez le Glossaire.

Introduction à l’algèbre linéaire

Pour une courte et intuitive introduction aux concepts de base de l’algèbre linéaire, nous vous recommandons les chapitres 1 à 4 de la série Essence of Linear Algebra par 3Blue1Brown (Vecteurs, qu’est-ce même?, Combinaisons linéaires, couverture, vecteurs de base, transformations linéaires et matrices, et multiplication de matrices comme composition).

Qu’est-ce que c’est que l’espace-état?

Rappelons que l’espace 2D comprend 2 axes: x et y. Nous représentons des localisations dans cet espace comme une paire de nombres rassemblés pour former un vecteur, et chaque coordonnée est une mesure de la distance à parcourir le long de l’axe correspondant. L’espace-état est un Système de Coordonnées Cartésiennes avec un axe pour chaque variable d’état, et nous représentons les localisations dans cet espace de la même façon qu’on le fait pour l’espace 2D: avec une liste de nombres rassemblés dans un vecteur. Chaque composante du vecteur correspond à un état du système. Cet exemple présente deux exemples de vecteurs d’état dans l’espace-état d’un modèle d’élévateur avec les états \([\text{position}, \text{vélocité}]\):

Two vectors in state space with their corresponding arrows.

Dans cette image, les vecteurs qui représentent les états dans l’espace-état sont des flèches. À partir de maintenant ces vecteurs seront représentés simplement par un point à la pointe du vecteur, mais souvenez-vous que le reste du vecteur est toujours là.

En plus de l’état, les entrées et sorties sont representées aussi comme des vecteurs. Puisque la correspondance des états actuels et les entrées au changement de l’état est un système d’équations, c’est naturel d’écrire cette relation sous forme de matrice. Cette équation matricielle peut être écrite dans notation d’espace-état.

Qu’est-ce que c’est que la notation espace-état?

La notation espace-état est un ensemble d’équations matricielles qui décrit comment un système évoluera dans le temps. Ces équations relient le changement de l’état \(\dot{\mathbf{x}}\), et la sortie \(\mathbf{y}\), à des combinaisons linéaires du vecteur d’état actuel \(\mathbf{x}\) et le vecteur d’entrée \(\mathbf{u}\).

Le contrôle de l’espace-état peut traiter des systèmes en temps continu ou en temps discret. Dans le cas du temps continu, le taux de variation de l’état du système \(\mathbf{\dot{x}}\) est exprimé comme une combinaison linéaire de l’état courant \(\mathbf{x}\) et de l’entrée \(\mathbf{u}\).

En revanche, les systèmes à temps discret expriment l’état du système à notre prochain pas de temps \(\mathbf{x}_{k+1}\) basé sur l’état actuel \(\mathbf{x}_k\) et l’entrée \(\mathbf{u}_k\), où \(k\) est le pas de temps actuel et \(k+1\) est le prochain pas de temps.

Dans les deux formes de temps continu et discret, le vecteur de sortie \(\mathbf{y}\) est exprimé comme une combinaison linéaire de l’état actuel et de l’entrée. Dans de nombreux cas, la sortie est un sous-ensemble de l’état du système et n’a aucune contribution de l’entrée actuelle.

Lors de la modélisation de systèmes, nous dérivons d’abord la représentation en temps continu parce que les équations de mouvement sont naturellement écrites comme le taux de changement de l’état d’un système comme une combinaison linéaire de son état actuel et des entrées. Nous convertissons cette représentation en temps discret sur le robot parce que nous mettons à jour le système par intervalles de temps discrets au lieu de le faire en continu.

Les deux ensembles d’équations suivantes constituent la forme standard de notation espace-état en temps continu et en temps discret :

\[\begin{split}\text{Continuous: } \dot{\mathbf{x}} &= \mathbf{A}\mathbf{x} + \mathbf{B}\mathbf{u} \\ \mathbf{y} &= \mathbf{C}\mathbf{x} + \mathbf{D}\mathbf{u} \\ \nonumber \\ \text{Discrete: } \mathbf{x}_{k+1} &= \mathbf{A}\mathbf{x}_k + \mathbf{B}\mathbf{u}_k \\ \mathbf{y}_k &= \mathbf{C}\mathbf{x}_k + \mathbf{D}\mathbf{u}_k\end{split}\]
\[\begin{split}\begin{array}{llll} \mathbf{A} & \text{system matrix} & \mathbf{x} & \text{state vector} \\ \mathbf{B} & \text{input matrix} & \mathbf{u} & \text{input vector} \\ \mathbf{C} & \text{output matrix} & \mathbf{y} & \text{output vector} \\ \mathbf{D} & \text{feedthrough matrix} & & \\ \end{array}\end{split}\]

Un système d’espace d’état à temps continu peut être converti en un système à temps discret grâce à un processus appelé discrétisation.

Note

Dans la forme à temps discret, l’état du système est maintenu constant entre les mises à jour. Cela signifie que nous ne pouvons réagir aux perturbations aussi rapidement que notre estimation d’état est mise à jour. Mettre à jour notre estimation plus rapidement peut aider à améliorer les performances, jusqu’à un certain point. La classe Notifier de WPILib peut être utilisée si des mises à jour plus rapides que la boucle principale du robot sont souhaitées.

Note

Bien que les matrices en temps continu et en temps discret A, B, C et D d’un système portent les mêmes noms, elles ne sont pas équivalentes. Les matrices à temps continu décrivent le taux de changement de l’état, \(\mathbf{x}\), tandis que les matrices à temps discret décrivent l’état du système au prochain intervalle de temps en fonction de l’état actuel et de l’entrée.

Important

LinearSystem de WPILib prend des matrices système en temps continu et les convertit en interne en forme de temps discret si nécessaire.

Exemple de notation d’espace d’état: volant d’inertie à partir de kV et kA

Rappelez vous que nous pouvons modéliser le mouvement d’un volant d’inertie connecté à un moteur à courant continu à balais avec l’équation \(V = kV \cdot v + kA \cdot a\), où V est la tension de sortie, v est la vitesse angulaire du volant et a est son accélération angulaire. Cette équation peut être réécrite comme suit \(a = \frac{V - kV \cdot v}{kA}\), ou \(a = \frac{-kV}{kA} \cdot v + \frac{1}{kA} \cdot V\). Avez-vous remarqué quelque chose de familier? Cette équation relie l’accélération angulaire du volant d’inertie à sa vitesse angulaire et à la tension appliquée.

Nous pouvons convertir cette équation en notation d’espace d’états. Nous pouvons créer un système avec un état (vitesse), une entrée (tension), et une sortie (vitesse). En rappelant que la première dérivée de la vitesse est l’accélération, nous pouvons écrire notre équation comme suit, en remplaçant la vitesse par \(\mathbf{x}\), l’accélération par \(\mathbf{\dot{x}}\), et la tension \(\mathbf{V}\) par \(\mathbf{u}\):

\[\mathbf{\dot{x}} = \begin{bmatrix}\frac{-kV}{kA}\end{bmatrix} \mathbf{x} + \begin{bmatrix}\frac{1}{kA}\end{bmatrix} \mathbf{u}\]

C’est tout! C’est le modèle d’espace d’état d’un système pour lequel nous avons les constantes kV et kA. Ce même calcul est utilisé dans la caractérisation FRC pour modéliser les volants d’inertie et les systèmes de vitesse de transmission.

Visualisation des réponses de l’espace d’état: portrait de phase

Un portrait de phase peut aider à donner une intuition visuelle pour la réponse d’un système dans l’espace d’états. Les vecteurs sur le graphe ont leurs racines à un moment donné \(\mathbf{x}\) dans l’espace d’états, et pointent dans la direction de \(\mathbf{\dot{x}}\), la direction qui le système évoluera avec le temps. Cet exemple montre un modèle de pendule avec les états d’angle et de vitesse angulaire.

Pour tracer une trajectoire potentielle qu’un système pourrait emprunter à travers l’espace d’états, choisissez un point de départ et suivez les flèches. Dans cet exemple, nous pourrions commencer par \([-2, 0]\). À partir de là, la vitesse augmente à mesure que nous nous balançons verticalement et commence à diminuer jusqu’à ce que nous atteignions l’extrême opposé du balancement. Ce cycle de rotation autour de l’origine se répète indéfiniment.

Pendulum Phase Plot with arrows all around going roughly in a circle.

Notez que près des bords du portrait de phase, l’axe X s’enroule comme une rotation de \(\pi\) radians dans le sens antihoraire et une rotation de \(\pi\) radians dans le sens horaire se terminera au même point.

Pour en savoir plus sur les équations différentielles et les portraits de phase, voir la vidéo sur les équations différentielles de 3Blue1Brown – ils font un excellent travail d’animation de l’espace de phase du pendule vers 15:30 minutes après le début du vidéo.

Visualiser le Feedforward

Ce portrait de phase montre les réponses « en boucle ouverte » du système - c’est-à-dire comment il réagira si nous laissons l’état évoluer naturellement. Si nous voulons, par exemple, équilibrer le pendule horizontal (à \((\frac{\pi}{2}, 0)\) dans l’espace d’états), nous aurions besoin d’appliquer une commande d’entrée pour contrer la tendance en boucle ouverte du pendule à basculer vers le bas. C’est ce que la commande prédictive essaie de faire - faire en sorte que notre portrait de phase ait un équilibre à la position de référence (ou point de consigne) dans l’espace d’états.

En examinant notre portrait de phase d’avant, nous pouvons voir qu’à \((\frac{\pi}{2}, 0)\) dans l’espace d’états, la gravité tire le pendule vers le bas avec un certain couple T, et produit vers le bas une accélération angulaire d’amplitude \(\frac{\tau}{I}\), où I est le moment d’inertie angulaire du pendule. Si nous voulons créer un équilibre à notre référence de \((\frac{\pi}{2}, 0)\), nous aurons besoin d’appliquer une entrée pour compenser la tendance naturelle du système à basculer vers le bas. Le but ici est de résoudre l’équation \(\mathbf{0 = Ax + Bu}\) pour \(\mathbf{u}\). Ci-dessous est montré un portrait de phase où nous appliquons une entrée constante qui s’oppose à la force de gravité à \((\frac{\pi}{2}, 0)\):

Pendulum phase plot with equilibrium at (pi/2, 0).

Commande de rétroaction

Dans le cas d’un moteur à courant continu, avec juste un modèle mathématique et une connaissance de tous les états actuels du système (c’est-à-dire la vitesse angulaire), nous pouvons prédire tous les états futurs compte tenu des futures entrées de tension. Mais si le système est perturbé d’une manière qui n’est pas modélisée par nos équations, comme une charge ou un frottement inattendu, la vitesse angulaire du moteur s’écartera du modèle au fil du temps. Pour lutter contre cela, nous pouvons donner au moteur des commandes correctives à l’aide d’un contrôleur de rétroaction.

Un contrôleur PID est une forme de commande de rétroaction. Le contrôle de l’espace d’états utilise souvent la loi de commande suivante, où \(\mathbf{K}\) est la matrice de gain d’une commande, \(\mathbf{r}\) est l’état de référence, et \(\mathbf{x}\) est l’état actuel dans l’espace d’états. La différence entre ces deux vecteurs, \(\mathbf{r-x}\), correspond à l’erreur.

\[\mathbf{u} = \mathbf{K(r - x)}\]

Cette loi de commande correspond à un contrôleur proportionnel pour chaque état de notre système. Les contrôleurs proportionnels créent des « ressorts » définis par logiciel qui tirent l’état de notre système vers notre état de référence dans l’espace d’états. Dans le cas où le système commandé a des états de position et de vitesse, la loi de commande ci-dessus se comportera comme un contrôleur PD, qui essaie également de ramener l’erreur de position et de vitesse à zéro.

Montrons un exemple de cette loi de commande en action. Nous utiliserons le système de pendule décrit plus haut, où le pendule oscillant encercle l’origine dans l’espace d’états. Le cas où \(\mathbf {K}\) est la matrice nulle (une matrice dont tous les éléments sont des zéros) équivaut à choisir des gains P et D nuls - aucune entrée de commande serait appliquée, et le diagramme de phase serait identique à celui présenté ci-dessus.

Pour ajouter une rétroaction, nous choisissons arbitrairement un \(\mathbf {K}\) de [2, 2], où notre entrée du pendule est une accélération angulaire. Ce K signifie que pour chaque erreur de position de 1 radian, l’accélération angulaire serait de 2 radians par seconde au carré; en d’autres mots, nous accélérons de 2 radians par seconde au carré pour chaque radian par seconde term:d’erreur. Essayez de suivre une flèche en provenance de quelque part dans l’espace d’états vers l’intérieur - quelles que soient les conditions initiales, l’état convergera vers la référence plutôt que de tourner sans fin comme ce serait le cas avec une commande avec rétroaction pure.

Closed loop pendulum phase plot with reference at (pi/2, 0).

Mais comment choisir une matrice de gain K optimale pour notre système? Alors que nous pouvons choisir manuellement les gains et simuler la réponse du système ou l’ajuster sur le robot comme un contrôleur PID, la théorie de commande moderne a une meilleure réponse: le régulateur linéaire-quadratique (LQR).

Le régulateur linéaire-quadratique

Comme la commande basée sur un modèle signifie que nous pouvons prédire les états futurs d’un système étant données une condition initiale et des entrées de commande futures, nous pouvons choisir une matrice de gain math:mathbf {K} mathématiquement optimale. À cette fin, nous devons d’abord définir à quoi correspondrait une « bonne » ou « mauvaise » matrice \(\mathbf{K}\). Pour ce faire, nous additionnons dans le temps le carré de l’erreur et de l’entrée de commande, ceci nous donne un nombre représentant à quel point notre loi de contrôle sera « mauvaise ». Si nous minimisons cette somme, nous arrivons à la loi de commande optimale recherchée.

LQR: Définition

Les régulateurs linéaires-quadratiques fonctionnent en trouvant une loi de commande qui minimise la fonction de coût suivante, qui pondère la somme de l’error et de l’effort de commande au fil du temps, soumis à la dynamique du système linéaire \(\mathbf{\dot{x} = Ax + Bu}\).

\[J = \int\limits_0^\infty \left(\mathbf{x}^T\mathbf{Q}\mathbf{x} + \mathbf{u}^T\mathbf{R}\mathbf{u}\right) dt\]

La loi de commande qui minimise \(\mathbf{J}\) peut être écrite comme suit: \(\mathbf{u = K(r - x)}\), où \(r-x\) est l’erreur.

Note

Les matrices \(\mathbf{Q}\) et \(\mathbf{R}\) d’un modèle n’ont pas besoin de discrétisation, mais les matrices \(\mathbf{K}\) calculées pour les systèmes en temps continu et en temps discret seront différentes.

LQR: réglage

Tout comme les contrôleurs PID peuvent être réglés en ajustant leurs gains, nous voulons également changer la façon dont notre loi de commande équilibre notre erreur et notre entrée. Par exemple, un vaisseau spatial peut vouloir minimiser le carburant qu’il dépense pour atteindre une référence donnée, tandis qu’un bras robotique à grande vitesse peut avoir besoin de réagir rapidement aux perturbations.

Nous pouvons pondérer l’erreur et contrôler l’effort dans notre modèle LQR avec les matrices \(\mathbf{Q}\) et \(\mathbf{R}\). Dans notre fonction de coût (qui décrit la « mauvaise » performance de notre loi de commande), \(\mathbf{Q}\) et \(\mathbf{R}\) pondèrent notre erreur et les entrées de commande l’une par rapport à l’autre. Dans l’exemple de vaisseau spatial ci-dessus, nous pourrions utiliser une matrice \(\mathbf{Q}\) avec des valeurs relativement faibles pour montrer que nous ne voulons pas pénaliser fortement l’erreur, tandis que notre \(\mathbf{R}\) pourrait être élevée pour montrer que dépenser du carburant n’est pas souhaitable.

Avec WPILib, la classe LQR prend un vecteur d’excursions d’état maximum souhaitées et d’efforts de contrôle et les convertit en interne en matrices Q et R complètes avec la règle de Bryson. Nous utilisons souvent des minuscules \(\mathbf{q}\) et \(\mathbf{r}\) pour faire référence à ces vecteurs, et \(\mathbf{Q}\) et \(\mathbf{R}\) pour faire référence aux matrices.

Augmenter la valeur des éléments du vecteur \(\mathbf{q}\) rendrait le modèle LQR moins lourd pour les grosses erreurs, et la loi de commande résultante se comportera de manière plus conservatrice. Cela a un effet similaire à pénaliser plus fortement l’effort de contrôle en diminuant les éléments de \(\mathbf{q}\).

De même, en diminuant les éléments \(\mathbf{q}\), le LQR pénaliserait plus lourdement les grosses erreurs, et la la loi de commande résultante se comportera plus agressivement. Cela a un effet similaire à pénaliser moins fortement l’effort de commande en augmentant les valeurs des éléments de \(\mathbf{q}\).

Par exemple, nous pourrions utiliser les Q et R suivants pour un système d’élévateur avec des états de position et de vitesse.

// Example system -- must be changed to match your robot.
LinearSystem<N2, N1, N1> elevatorSystem = LinearSystemId.identifyPositionSystem(5, 0.5);
LinearQuadraticRegulator<N2, N1, N1> controller = new LinearQuadraticRegulator(elevatorSystem,
    // q's elements
    VecBuilder.fill(0.02, 0.4),
    // r's elements
    VecBuilder.fill(12.0),
    // our dt
    0.020);

LQR: exemple d’application

Appliquons un régulateur linéaire-quadratique à un exemple du monde réel. Supposons que nous ayons un système de vitesse du volant d’inertie déterminé par la technique d’identification du système pour avoir \(kV = 1 \frac{\text{volts}}{\text{radian per second}}\) et \(kA = 1.5 \frac{\text{volts}}{\text{radian per second squared}}\). En utilisant l’exemple de volant d’inertie ci-dessus, nous avons le système linéaire suivant:

\[\mathbf{\dot{x}} = \begin{bmatrix}\frac{-kV}{kA}\end{bmatrix} v + \begin{bmatrix}\frac{1}{kA}\end{bmatrix} V\]

Nous choisissons arbitrairement une excursion d’état désirée (erreur maximale) de \(q = [0.1\ \text{rad/sec}]\), et un \(\mathbf{r}\) de \([12\ \text{volts}]\). Après discrétisation avec un pas de temps de 20ms, on trouve un gain de \(\mathbf{K} = ~81\). Ce gain K agit comme la composante proportionnelle d’une boucle PID sur la vitesse du volant d’inertie.

Let’s adjust \(\mathbf{q}\) and \(\mathbf{r}\). We know that increasing the q elements or decreasing the \(\mathbf{r}\) elements we use to create \(\mathbf{Q}\) and \(\mathbf{R}\) would make our controller more heavily penalize control effort, analogous to trying to driving a car more conservatively to improve fuel economy. In fact, if we increase our error tolerance q from 0.1 to 1.0, our gain matrix \(\mathbf{K}\) drops from ~81 to ~11. Similarly, decreasing our maximum voltage \(r\) to 1.2 from 12.0 produces the same resultant \(\mathbf{K}\).

Le graphique suivant montre la vitesse angulaire du volant d’inertie et la tension appliquée au fil du temps avec deux gains. Nous pouvons voir comment un gain plus élevé permettra au système d’atteindre la référence plus rapidement (à t = 0.8 seconde), tout en maintenant notre moteur saturé à 12V plus longtemps. C’est exactement la même chose que d’augmenter le gain P d’un régulateur PID d’un facteur ~ 8x.

Flywheel velocity and voltage over time.

LQR et compensation de latence de mesure

Souvent, nos capteurs ont un retard associé à leurs mesures. Par exemple, le contrôleur de moteur SPARK MAX sur CAN peut avoir jusqu’à 30 ms de retard associé aux mesures de vitesse.

Ce décalage signifie que notre contrôleur de rétroaction générera des commandes de tension basées sur des estimations d’état du passé. Cela a souvent pour effet d’introduire de l’instabilité et des oscillations dans notre système, comme le montre le graphique ci-dessous.

Cependant, nous pouvons modéliser notre contrôleur pour contrôler où l’état du système est retardé dans le futur. Cela réduira la matrice de gain \(\mathbf{K}\) du modèle LQR, échangeant les performances du contrôleur contre la stabilité. La formule ci-dessous, qui ajuste la matrice de gain pour tenir compte du retard, est également utilisée dans l’outilitaire de caractérisation FRC.

\[\mathbf{K_{compensated}} = \mathbf{K} \cdot \left(\mathbf{A} - \mathbf{BK}\right)^{\text{delay} / dt}\]

Multiplier \(\mathbf{K}\) par \(\mathbf{A} - \mathbf{BK}\) avance essentiellement les gains d’un pas de temps. Dans ce cas, on multiplie par \(\left(\mathbf{A} - \mathbf{BK}\right)^{\text{delay} / dt}\) pour avancer les gains par le retard de la mesure.

Flywheel velocity and voltage with dt=5.0ms and a 10.0ms delay.

Note

Cela peut avoir pour effet de réduire \(\mathbf{K}\) à zéro, désactivant ainsi la commande de rétroaction.

Note

Le contrôleur de moteur SPARK MAX utilise un filtre à réponse impulsionnelle finie ou RIF à 40 prises avec un retard de 19.5 ms, et les trames d’état sont envoyées par défaut tous les 20ms.

Le code ci-dessous montre comment régler le gain K du contrôleur LQR pour les délais d’entrée du capteur:

// Adjust our LQR's controller for 25 ms of sensor input delay. We
// provide the linear system, discretization timestep, and the sensor
// input delay as arguments.
controller.latencyCompensate(elevatorSystem, 0.02, 0.025);

Linéarisation

La linéarisation est un outil utilisé pour approximer les fonctions non linéaires et les systèmes d’espace d’états en faisant usage de systèmes linéaires. Dans l’espace bidimensionnel, les fonctions linéaires sont des lignes droites tandis que les fonctions non linéaires sont courbes. Un exemple courant de fonction non linéaire et de son approximation linéaire correspondante est: \(y=\sin{x}\). Cette fonction peut être approximée par \(y=x\) près de zéro. Cette approximation est précise lorsqu’elle est proche de \(x=0\), mais perd de la précision lorsque nous nous éloignons du point de linéarisation. Par exemple, l’approximation \(\sin{x} \approx x\) est précise à 0.02 près de 0.5 radians de \(y = 0\), mais perd rapidement sa précision au-delà. Dans l’image suivante, nous voyons \(y =\sin{x}\), \(y=x\) et la différence entre l’approximation et la vraie valeur de \(\sin{x}\) à \(x\).

Three plots showing sin(x), x, and sin(x) - x.

Nous pouvons également linéariser des systèmes d’espace d’états en faisant appel à une dynamique non-linéaire. Pour ce faire, choisissons un point \(\mathbf{x}\) dans l’espace d’états et en utilisons-le comme entrée de nos fonctions non linéaires. Comme dans l’exemple ci-dessus, cela fonctionne bien pour les états proches du point sur lequel le système a été linéarisé, mais peut rapidement diverger davantage de cet état.