Modélisation et commande d'un robot LEGO segway

31 mai 2017

Résumé : L'objectif de ce TP est de mettre en pratique les notions présentées dans le cours d'automatique
de première année sur un exemple concret : la stabilisation du robot LEGO segway. Il comporte trois parties.
La première partie est dédiée à la modélisation sous forme d'équations d'état non linéaires, à la linéarisation
et à l'analyse du système en boucle ouverte. La deuxième partie est dédiée à la conception d'une commande
par retour d'état pour la stabilisation du robot en position verticale. On parlera de régulation par retour d'état.
L'objectif de la troisième et dernière partie est la conception d'une commande permettant de faire avancer le
robot sur une trajectoire rectiligne. On parlera de boucle d'asservissement.

Table des matières

1 Description générale de la problématique 1
2 Modélisation du Segway 3
2.1 Variables d'état du système . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
2.2 Paramètres du système . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
2.3 Hypothèses de travail . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2.4 Modèle mécanique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

3 Travail à eectuer 4
3.1 Étude locale du système . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
3.2 Stabilisation du robot LEGO en position verticale . . . . . . . . . . . . . . . . . . . . . . . . . . 4
3.2.1 Linéarisation et représentation d'état . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
3.2.2 Stabilisation du système linéaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
3.2.3 Validation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
3.2.4 Analyse de robustesse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
3.3 Déplacement du robot : boucle d'asservissement . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6

A Annexes 6
A.1 Vérication de la mise en forme du système . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
A.2 Implémentation du système non-linéaire et simulation sous Simulink . . . . . . . . . . . . . . . . 6
A.3 Réalisation d'un schéma Simulink pour la simulation d'un système dynamique . . . . . . . . . . . 7
A.4 Linéarisation d'un système non linéaire à partir d'un schéma Simulink . . . . . . . . . . . . . . . 7
A.5 Marge de module et fonction de sensibilité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
A.6 Communication entre Matlab/Simulink et le robot LEGO EV3 . . . . . . . . . . . . . . . . . . . 8
A.7 Systèmes à déphasage non minimal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
A.8 Erreur classique Matlab/Simulink . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10

1 Description générale de la problématique

Le Segway ou gyropode est un véhicule éléctrique qui pourrait dans les années à venir se substituer à certains
moyens de transports actuels tels que le vélo ou même la voiture. Sa particularité est sa capacité à se stabiliser
sans intervention externe. À chaque mouvement, un gyroscope mesure l'accélération de l'angle de basculement,
après une double intégration, la valeur de l'angle est transmise au calculateur qui envoie alors une commande
aux moteurs an de stabiliser le système.

L'objectif ultime du TP est de parvenir à amener le robot segway d'un point initial à un point nal
tout en gardant l'équilibre et en respectant les contraintes de performance du cahier des charges.
Pour cela, trois étapes sont proposées :

1
 l'étude du comportement du robot autour d'un point d'équilibre
 la conception d'une loi de commande an de garantir la stabilité de ce point d'équilibre.
 la conception d'une loi de commande permettant au robot de suivre une consigne le faisant avancer d'un
point de départ à un point d'arrivée tout en maintenant son équilibre.

Figure 1  Principe de fonctionnement du Segway

Dans un premier temps, dénissons le système, ses paramètres et les hypothèses faites pour cette étude.

2
2 Modélisation du Segway

Figure 2  Schéma simplié du Segway

2.1 Variables d'état du système

Variables d'état Signication

θ Angle de la roue par rapport à la verticale dans le référentiel terrestre (rad)
ψ Angle du robot par rapport à la verticale dans le référentiel terrestre (rad)
θ̇ Vitesse angulaire de la roue (rad/s)
ψ̇ Vitesse angulaire du robot (rad/s)

2.2 Paramètres du système

Paramètre Valeur Commentaire
g 9,81 Constante gravitationnelle (m/s2 )
m 0,023 Masse d'une roue (kg)
R 0,027 5 Rayon d'une roue (m)
Jw 9,487 5.10−6 Moment d'inertie d'une roue (kg.m2 )
M 0,568 Masse du corps (kg)
W 0,1 Largeur du corps (m)
D 0,07 Epaiseur du corps (m)
L 0,130 703 Distance entre le centre de gravité et la roue (m)
Jψ 29,11.10−3 Moment de basculement (kg.m2 )
Rm 6,69 Résistance du moteur (Ω)
fm 0,002 2 Coecient de frottement entre le moteur et le corps
Jm 1.10−5 Moment d'inertie du moteur (kg.m2 )
Kb 0,468 Fem du moteur (V.s.rad−1 )
Kt 0,317 Couple du moteur (N.m.A−1 )
n 1 Ecacité de la boite de réduction

3
2.3 Hypothèses de travail
An de simplier l'étude on fait un certain nombre d'hypothèses raisonnables :
• le même couple est appliqué aux deux roues du robot,
• la même tension est appliquée aux deux moteurs. On note v la tension totale appliquée aux moteurs, la
tension gauche et droite sont alors : ul = v/2 et ur = v/2.
• le système est symétrique par rapport au plan parallèle aux roues, passant par le milieu de l'axe liant les
deux roues.
Avec ces hypothèses, on suppose que le robot se déplace en ligne droite. On néglige donc la dérive. Par conséquent,
on se contentera de modéliser la moitié du robot dans l'étude.

2.4 Modèle mécanique

En suivant les hypothèses de travail, le bilan énergétique du système donné par le Principe Fondamental de
la Mécanique donne la dynamique du système :

((2m + M )R2 + 2Jw + 2n2 Jm )θ̈ + (M LR cos(ψ) − 2n2 Jm )ψ̈ − M LRψ̇ 2 sin(ψ) = αsat(v) − 2β θ̇ + 2β ψ̇


(M LR cos(ψ) − 2n2 Jm )θ̈ + (M L2 + Jψ + 2n2 Jm )ψ̈ − M gL sin(ψ) = −αsat(v) + 2β θ̇ − 2β ψ̇

(1)
nKt
où α = , β = fm + α · Kb et v est la tension totale souhaitée pour les moteurs des roues gauche et droite
Rm
et tandis que sat(v) est la tension réellement appliquée aux moteurs (sat(v) = v pour v ∈ [−200, 200], et
sat(v) = 200sign(v) sinon). En cohérence avec nos hypothèses de travail, les tensions ul et ur n'apparaissent
plus de manière indépendante car elles possèdent un rôle symétrique dans les équations. Dans toute l'étude,
nous donnerons la même valeur de commande pour chacune d'entre elles, et n'utiliserons que la
tension totale v .

3 Travail à eectuer
3.1 Étude locale du système
L'objectif étant de maintenir le robot en position verticale, on s'attachera dans un premier temps à com-
prendre le comportement du robot à proximité de cette position. Pour cela, il est demandé de suivre les étapes
suivantes. En choisisant l'état du système  
θ
ψ 
x=  θ̇  ,


ψ̇
où θ et ψ sont décrits dans la Figure 2 et la Section 2.1, et la tension v pour la commande,
a) réécrire le modèle (1) sous la forme
ẋ(t) = f (x(t), v(t)), (2)
pour vérier les équations, suivre les instructions de l'annexe A.1.
b) déterminer tous les points d'équilibre du système,
c) trouver un point d'équilibre (xe , ve ) correspondant au robot LEGO en position verticale tête en haut,
d) réaliser un schéma Simulink pour la simulation du système non linéaire (pour cela suivre l'annexe A.2),
e) simuler le système non linéaire en xant l'état initial égale au point d'équilibre précédent,
f) simuler le système non linéaire en xant l'état initial proche du point d'équilibre précédent, pour une
petite perturbation initiale (10−3 ) sur l'angle ψ . Que peut−on dire de ce point d'équilibre ?

3.2 Stabilisation du robot LEGO en position verticale

3.2.1 Linéarisation et représentation d'état
Les méthodes de commande vues en première année à l'ENSEM supposent que le système à commander est
linéaire. Nous allons donc commencer par remplacer le modèle non linéaire du système par un modèle linéaire
représentatif des petites variations autour du point d'équilibre qui nous intéresse : il s'agit du modèle linéarisé.

4
 a) Utiliser Matlab/Simulink (annexe A.4) pour obtenir la linéarisation du modèle non linéaire sous la forme
d'une représentation d'état :

x̃˙ = Ax̃ + Bṽ


, (3)
ỹ = C x̃ + Dṽ
où x̃, ṽ , ỹ désignent respectivement l'écart entre l'état du système et l'état au point d'équilibre, l'écart
entre la tension totale aux moteurs et la tension totale au point d'équilibre et enn l'écart entre la sortie
du systéme et la valeur de la sortie à l'équilibre. En ce qui concerne la sortie, on suppose qu'on peut
mesurer toutes les variables d'état x.

b) Expliciter les valeurs numériques des matrices A, B , C , et D.

c) En déduire la fonction de transfert entre l'angle θ et la variable de commande v . Que peut−on dire si on
analyse les pôles et les zéros de cette fonction de transfert ?

d) Simuler le système linéaire (voir l'annexe A.3).

3.2.2 Stabilisation du système linéaire

An de stabiliser le robot autour du point d'équilibre, on met en place une régulation par retour d'état
qui sera appliquée au système non linéaire de départ. La conception de cette commande se fait sur le modèle
linéarisé autour du point d'équlibre (xe , ve ) avec v comme variable de commande. Le calcul des gains pour
cette commande par retour d'état se fera dans un script Matlab.
a) étudier la commandabilité du système,
b) réaliser une commande par retour d'état pour répondre au cahier des charges suivant :
 (xe , ve ) est un équilibre stable en boucle fermée,
 boucle fermée assez rapide : tr ' 1s,
 boucle fermée bien amortie : d% < 5%,
 boucle fermée assez robuste - marge de module très proche de 1 (supérieure à 0.99 (voir l'Annexe A.5
pour explication).
On pourra être amené à modier ces valeurs au besoin dans la suite du TP. Dans un premier temps, on
s'attachera à valider uniquement les deux premiers points du cahier des charges.
Indications : Il faudra trouver le nombre de pôles en boucle fermée et ensuite calculer un retour d'état
permettant de placer à la fois deux pôles pour respecter les contraintes de temps de réponse et de dé-
passement (on appelle ces pôles les pôles dominants) et les pôles restants susamment loin de ces pôles
dominants pour respecter les autres points du cahier des charges. On conseille de suivre l'ordre suivant :
a) déterminer le nombre total de pôles à placer
b) calculer les pôles dominants permettant de satisfaire les contraintes de rapidité et d'amortissement,
c) xer les valeurs des autres pôles restants beaucoup plus à gauche,
d) calculer à l'aide de la fonction place de Matlab le gain K permettant le placement de tous les pôles,

3.2.3 Validation
Pour eectuer la validation de l'étape de stabilisation, nous procédons de manière incrémentale, en ajoutant
une diculté à la fois. Ceci permet de comprendre d'où proviennent les erreurs le cas échéant.
 Simulation de la boucle fermée : système linéaire + commande par retour d'état (si le cahier des charges
est respecté passer au point suivant),
 Simulation de la boucle fermée : système non linéaire + commande par retour d'état, avec une condition
initiale proche de l'état d'équilibre. On pourra tester plusieurs conditions initiales pour l'angle ψ de manière
à évaluer la robustesse de la commande.
 Validation de la commande par retour d'état obtenue sur le robot segway LEGO. Pour la communication
entre Matlab/Simulink, on se reportera à l'Annexe A.6

5
3.2.4 Analyse de robustesse
Calculer la marge de module (voir l'annexe A.5 pour le calcul) et vérier si la contrainte de robustesse est
satisfaite. Si cette contrainte est satisfaite on passe à la suite, dans le cas contraire on revient au point c). On
pourra aussi se rapporter à l'annexe A.7.

3.3 Déplacement du robot : boucle d'asservissement

Par la suite nous voulons mettre en marche le robot LEGO tout en gardant son équilibre en position verticale.
Pour ce faire, on considère que la sortie du système est l'angle θ et on réalise une boucle externe d'asservissement
qui a pour but la poursuite d'une trajectoire en angle θ désirée qu'on notera θref (t) = t kθ̇ vref . Le paramètre kθ̇
et la vitesse linéaire de référence vref sont dénis dans le script script_etudiants.m par les variables k_thetadot
et vitesse_avancer. La valeur de vref sera à choisir. Cette boucle externe doit être beaucoup plus lente que la
boucle de stabilisation précédente (' 10 fois). Sans cette contrainte, il y a un risque que la boucle de stabilisation
soit perturbée et ne remplisse pas son rôle.

Cahier des charges :

Stabilité de la boucle fermée, temps de réponse de la boucle d'asservissement beaucoup plus lent que le temps
de réponse de la boucle de régulation par retour d'état et erreur de position nulle en régime permanent.

Méthodologie :
On propose un correcteur de type I de gain KI .
 Dénir la fonction de transfert en boucle fermée du système dans un script matlab.
 Utiliser le programme nd_stabilizing_gain.m pour déterminer la plage de variation du gain KI permet-
tant de stabiliser la boucle fermée. Il vous faudra pour cela déclarer une variable symbolique Ki_sym via
la commande syms Ki_sym real puis dénir le vecteur de coecients par ordre de dégré décroissant du
dénominateur de la fonction de transfert en boucle fermée en fonction de la variable Ki_sym.
 Répéter les étapes de validation de la Section 3.2.3.

A Annexes
A.1 Vérication de la mise en forme du système
An de s'assurer que les équations du chier SysNL.m sont correctes, un chier intitulé TPsegway.p a été
crée. Pour l'exécuter, taper simplement le nom du chier (TPsegway) dans la console matlab. Vous allez obtenir
deux types de messages :
 Si vos équations sont correctes, un message conrmant la véracité de vos équations va apparaître. Suivez
les instructions.
 Si vous avez fait une erreur, l'équation incorrecte sera indiquée.

A.2 Implémentation du système non-linéaire et simulation sous Simulink

Simulink permet d'implémenter un modèle dynamique sous forme de schéma-bloc. Les blocs sont utilisés
pour implémenter notamment les gains, les fonctions de transferts, les oscilloscopes, etc.
Le chier SysNL_etudiants.slx contient le schéma bloc qui vous servira de point de départ pour l'implémen-
tation du système non-linéaire décrivant le comportement du robot LEGO (voir Figure 3).
Le schéma-bloc contient notamment 4 intégrateurs, une saturation, un oscilloscope, une entrée, une sortie et
un bloc MATLAB Function (voir plus bas pour l'explication sur ce dernier bloc). Un double-click sur un bloc du
schéma permet d'accéder à sa dénition ainsi qu'à ses paramètres. Ainsi, les conditions initiales des 4 variables
d'états θ, ψ , θ̇ et ψ̇ sont xées dans les blocs intégrateurs à l'aide des variables theta_0, psi_0, thetadot_0 et
psidot_0. Pour que la simulation puisse s'éxécuter, il vous faudra notamment suivre les deux étapes suivantes ; :
 Les valeurs de ces variables devront être xées dans le script Matlab script_etudiants.m qui vous est
fourni.
 Le script devra être éxécuté de manière à instancier ces variables qui se trouveront alors dans l'espace de
travail (Workspace ) de Matlab, accéssible par le schéma-bloc Simulink.

6
 Figure 3  Schéma-bloc Simulink pour la simulation du système non-linéaire.

Enn, il vous faudra implémenter le système non-linéaire via le bloc MATLAB System et la fonction
SysNL.m. Pour double cliquer sur ce bloc, le script Système non linéaire/Equation non linéaire/MATLAB
System s'ouvre. Il a été pré-rempli notamment avec les paramètres du système. Il vous faut compléter le script
de manière à expliciter les dérivées des 4 variables d'état en fonction des paramètres et des variables d'état
elles-même. Ceci se fera à l'aide de l'équation (1). Pour plus d'information sur ce bloc voir le tutoriel :

https://fr.mathworks.com/help/simulink/slref/matlabsystem.html

Pour simuler le système, cliquer sur le bouton lecture (Run ) dans la barre supérieure de Simulink. Il est
possible de modier la durée de la simulation via le champ de texte à droite du bouton Run. Il sera nécessaire
de modier le solver qui permet l'intégration numérique de l'équation diérentielle. Pour cela aller dans l'onglet
Simulation / Model Conguration Parameters / Solver / Solver options, sélectionner alors Type : Variable-step,
Solver : auto, et dans Additional options, sélectionner Relative tolerance : 10e-9.

A.3 Réalisation d'un schéma Simulink pour la simulation d'un système dynamique
Pour créer et simuler un schéma simulink à partir de zéro, on se basera sur le tutorial suivant :

https://fr.mathworks.com/help/simulink/gs/create-a-simple-model.html?s_cid=learn_doc

Pour spécier les paramètres des gains, double-cliquer sur un bloc dans le schéma simulink, aecter un nom
de variable (par exemple K ). On pourra alors déclarer les valeurs des variables des gains (e.g. K = 2) dans un
script. Pour créer un script, voir le tutorial suivant :

https://fr.mathworks.com/help/matlab/matlab_prog/create-scripts.html

Dans le cas présent, on pourra simplement utiliser le script script_etudiants.m pré-rempli. Une fois le script
lancé, les variables sont créés dans l'espace de travail (workspace ) et pourront alors directement être utilisées
dans le schéma simulink.

A.4 Linéarisation d'un système non linéaire à partir d'un schéma Simulink
On se basera sur le tutorial suivant :

https://fr.mathworks.com/help/slcontrol/ug/linearize-at-trimmed-operating-point.html

7
 Comme expliqué en détails dans le tutorial, premièrement spécier le point d'équilibre (steady state ) au-
tour duquel on souhaite linéariser le modèle, deuxièmement, en cliquant sur Bode, les matrices A, B , C et D
seront automatiquement générées dans la variable linsys1 dans le Linear Analysis Workspace. On pourra alors
faire glisser cette variable dans le MATLAB Workspace, et utiliser la commande save linsys1 dans l'invite de
commande. Dans le script Matlab, on pourra charger cette variable par la commande load linsys1. Il sera alors
possible d'acceder aux diérentes matrices via les variables linsys1.A, linsys1.B, linsys1.C et linsys1.D.

A.5 Marge de module et fonction de sensibilité

La marge de module représente une mesure objective de la robustesse en stabilité. Elle a été introduite
par O.J.M. Smith en 1958 et se calcule par

mM = min |1 + FBO (jω)|.

ω≥0

Précisément la marge de module est la plus petite distance du point critique (−1, 0) au lieu de transfert en
boucle ouverte. C'est donc le rayon du cercle de centre le point critique (−1, 0) et tangent au lieu de transfert
(voir Figure 4).
En pratique en utilisera la fonction de sensibilité
1
S(jω) =
1 + FBO (jω)

La marge de module est alors donnée par mM = M1s où Ms = maxω≥0 |S(jω)|. Pour obtenir Ms on pourra
tracer le diagramme de Bode de la fonction de sensibilité S avec la commande matlab bode(S). Pour dénir la
fonction de transfert S , on utilisera la commande S = tf(Numerator,Denominator). Voir l'aide Matlab de la
fonction tf.

Figure 4  Illustration marge de module

A.6 Communication entre Matlab/Simulink et le robot LEGO EV3

La procédure décrite permet de compiler un schéma simulink qui sera alors directement envoyé au Robot,
prêt à être utilisé.
Prérequis
 La procédure fonctionne uniquement avec la version Matlab 2016b et postérieures pour les robots Lego
Mindstorms EV3. Elle a été testée et fonctionne sur Apple, Windows et Linux.
 Deux add-ons Matlab-Simulink sont nécessaires pour la communication avec le robot. Pour les télécharger :
dans Matlab, onglet Home, dérouler le menu Add-Ons, choisir gets hardware support packages, installer les
packages LEGO MINDSTORMS EV3 Support from MATLAB et LEGO MINDSTORMS EV3 Support
from SIMULINK. Vérier que les packages ont été installés : dans Simulink, icône Library Browser (4
petits carrés de couleurs bleu blanc rouge), vérier que les toolbox Simulink support packages for LEGO
MINDSTORMS EV3 Hardware et Matlab support packages for LEGO MINDSTORMS EV3 Hardware
sont présentes.

8
  Si la procédure d'installation direct ne fonctionne pas, suivre la procédure d'installation manuelle :

http://www.mathworks.com/help/matlab/matlab_env/get-add-ons.html

- Il sera nécessaire d'ouvrir le schéma simulink à nouveau pour prendre en compte les nouveaux packages.
Important : Les PC des salles 201, 204 et 207 de l'ENSEM possède déjà ces packages.
Compilation et chargement d'un schéma simulink dans le robot
 Éteindre le robot
 Brancher le cable USB au robot et au PC
 Allumer le robot
 Ouvrir le schéma simulink
 S'assurer que les variables utilisées pour les gains sont bien dénies dans le workspace (doit être fait au
préalable en lançant un script Matlab .m )
 Dans Simulink : onlget Simulation/Model Conguration Parameters/Hardware Implementation/ Target
Hardware Resources/Host to Target Connection, menu déroulant : Communication type, choisir USB
 Cliquer sur l'icône Deploy to Hardware (trois petites êches pointant vers le bas sur un rectangle avec des
points noirs)
 Si une erreur du type de la Figure 5 se présente, cliquer sur x pour ne plus avoir l'erreur, puis charger à
nouveau d'après l'étape précédente
 Croiser les doigts
 Si le programme a bien été chargé, le robot va exécuter automatiquement le programme.
 Pour se stabiliser, le robot doit être maintenu strictement en position verticale jusqu'à l'arrêt du bip
sonore.
 Pour arrêter le programme, il sut de cliquer sur le bouton en haut à gauche puis sur le bouton central
pour revenir au menu sans éteindre le robot.

Figure 5  Erreur pouvant apparaître lors du premier chargement du schéma simulink vers le robot Segway.
Cliquer sur x pour ne plus avoir l'erreur.

Lancement du programme sur le robot

 Lorsque le programme est chargé sur le robot, il se peut que le robot démarre tout seul, cliquer sur le
bouton en haut à gauche, puis sélectionner la croix pour ne pas éteindre le robot.
 Sélectionner l'onglet dossier en cliquant sur le bouton droit, sélectionner le dossier où se trouve le chier
chargé en cliquant sur le bouton du milieu. Lancer le programme en cliquant dessus.
 Attention, le robot commence par initialiser son angle ψ , il doit être parfaitement à l'équilibre lorsqu'on
le lance, il doit être maintenu à l'équilibre jusqu'à la n du bip.

9
A.7 Systèmes à déphasage non minimal
Une fonction de transfert G(s) = N D(s) où N et D sont deux polynômes premiers entre eux est dit à déphasage
(s)

non minimal si l'un des zéros du numérateur N est instable, i.e., à partie réelle strictement négative.
Cette propriété entraine des dicultés dans la commande de tels systèmes.
Un phénomème pouvant se produire pour ce type de systèmes est une réponse initiale dans la direction
opposée à l'échelon donné en entrée. Ceci est illustré dans la Figure 6. Par analogie, on peut penser à la
température dans la douche : après avoir tourné le robinet, le système va premièrement abaisser la température
avant de la réhausser. Ceci pourrait nous amener à penser qu'on a tourné le robinet dans le mauvais sens alors
qu'il n'en est rien.
Les zéros instables ont aussi pour propriété de diminuer la robustesse du système. De plus, il n'est pas possible
d'utiliser la marge de phase ou de gain pour déterminer la robustesse du système. Pour de tels systèmes, on
utilisera plutôt la notion de marge de module et de fonction de sensibilité.
Voir aussi : Nonminimum-phase zeros, much to do about nothing, Jesse B. Hoagg and Dennis S. Berstein.
IEEE Control Systems Magazine (2007).

-s+1
2
s +2s+1
unstable zero
Step Transfer Fcn
Scope

s+1
simout
2
s +2s+1 stable zero
Step1 Transfer Fcn1 To Workspace

1.5
s+1
G(s) = (s+1)2
1 !s+1
G(s) = (s+1)2

0.5

-0.5
0 5 10
t

Figure 6  Illustration de la réponse à un échellon possible pour un système à déphasage non minimal

A.8 Erreur classique Matlab/Simulink

Erreurs Simulink
 Error in port widths or dimensions
 Vérier que les blocs Gain eectuent bien des multiplications matricielles de type K ∗ u.
 Vérier que les matrices du bloc state-space sont de bonnes tailles.

10