step

Réponse indicielle d’un système dynamique

Syntaxe

[y,tOut] = step(sys)

[y,tOut] = step(sys,t)

[y,tOut] = step(sys,t,p)

[y,tOut,x] = step(___)

[y,tOut,x,ysd] = step(___)

[y,tOut,x,~,pOut] = step(sys,t,p)

[y,tOut] = step(___,config)

step(___)

Description

step calcule la réponse indicielle à un changement de pas de la valeur d’entrée de U à U + dU après les unités de temps t_d.

Ici,

• t₀ est l’instant de début de la simulation.

• t_d est le retard de pas.

• U est la valeur d’entrée ou le biais de référence.

• dU est l’amplitude de pas.

Par défaut, la fonction applique step pour t₀ = 0, U = 0, dU = 1 et t_d = 0. Mais vous pouvez configurer ces valeurs au moyen de RespConfig. Vous pouvez également spécifier l’état initial x(t₀). Quand vous ne spécifiez pas l’état initial, step considère que le système est initialement au repos avec niveau d’entrée U.

[y,tOut] = step(sys) calcule la réponse indicielle y d’un système dynamique sys. step détermine automatiquement les pas de temps et la durée de la simulation sur la base de la dynamique du système.

[y,tOut] = step(sys,t) simule la réponse pour les pas de temps spécifiés par t. Pour définir les pas de temps, vous pouvez spécifier :

• L’instant de simulation finale au moyen d’une valeur scalaire.

• Les instants de simulation initiale et finale au moyen d’un vecteur à deux éléments. (depuis R2023b)

• Tous les pas de temps au moyen d’un vecteur.

[y,tOut] = step(sys,t,p) spécifie la trajectoire de paramètre p pour les modèles linéaires aux paramètres variables (LPV). (depuis R2023a)

[y,tOut,x] = step(___) renvoie également les trajectoires d’état x, quand sys est un modèle de représentation d’état, tel qu’un modèle ss ou idss.

[y,tOut,x,ysd] = step(___) renvoie l’écart-type de la réponse indicielle pour les modèles identifiés. Cette syntaxe nécessite le logiciel System Identification Toolbox™.

[y,tOut,x,~,pOut] = step(sys,t,p) renvoie les trajectoires de paramètre pour les modèles LPV. (depuis R2023a)

[y,tOut] = step(___,config) spécifie des options supplémentaires pour le calcul de la réponse indicielle, telles que l’amplitude de pas ou le décalage d’entrée. Utilisez RespConfig pour créer config.

step(___) trace la réponse indicielle de sys avec les options de tracé par défaut pour toutes les combinaisons d’arguments d’entrée précédentes. Pour découvrir d’autres options de personnalisation du tracé, utilisez stepplot.

• Pour regrouper les réponses de plusieurs systèmes dynamiques sur le même tracé, vous pouvez spécifier sys sous la forme d’une liste de modèles séparés par des virgules. Par exemple, step(sys1,sys2,sys3) regroupe les réponses de trois modèles sur le même tracé.

• Pour spécifier une couleur, un style de trait et un marqueur pour chaque système dans le tracé, spécifiez une valeur LineSpec pour chaque système. Par exemple, step(sys1,LineSpec1,sys2,LineSpec2) trace deux modèles et spécifie leur style de tracé. Pour plus d'informations sur la spécification d’une valeur LineSpec, consultez stepplot.

Exemples

Réponse indicielle d’un système dynamique

Tracez la réponse indicielle d’un système en temps continu représenté par la fonction de transfert suivante :

$$\mathrm{sys}\left(\mathit{s}\right)=\frac{4}{{\mathit{s}}^2+2\mathit{s}+10}.$$

Pour cet exemple, créez un modèle tf qui représente la fonction de transfert. Vous pouvez également tracer la réponse indicielle d’autres types de modèles de systèmes dynamiques, tels que les modèles zéro-pôle-gain (zpk) ou de représentation d’état (ss).

sys = tf(4,[1 2 10]);

Tracez la réponse indicielle.

step(sys)

Le tracé step inclut automatiquement une ligne horizontale en pointillés qui indique la réponse d’état stationnaire. Dans une fenêtre figure MATLAB®, vous pouvez faire un clic droit sur le tracé pour voir d’autres caractéristiques de réponse indicielle telles que la réponse maximale et le temps de stabilisation. Pour plus d’informations sur ces caractéristiques, consultez stepinfo.

Réponse indicielle d’un système en temps discret

Tracez la réponse indicielle d’un système en temps discret. Le système possède un pas d’échantillonnage de 0,2 s et est représenté par les matrices de représentation d’état suivantes :

A = [1.6 -0.7;
      1  0];
B = [0.5; 0];
C = [0.1 0.1];
D = 0;

Créez le modèle de représentation d’état et tracez sa réponse indicielle.

sys = ss(A,B,C,D,0.2);
step(sys)

La réponse indicielle montre la discrétisation du modèle, en affichant la réponse calculée toutes les 0,2 seconde.

Réponse indicielle à des heures spécifiées

Examinez la réponse indicielle de la fonction de transfert suivante :

sys = zpk(-1,[-0.2+3j,-0.2-3j],1) * tf([1 1],[1 0.05]) 

sys =
 
            (s+1)^2
  ----------------------------
  (s+0.05) (s^2 + 0.4s + 9.04)
 
Continuous-time zero/pole/gain model.
Model Properties

step(sys)

Par défaut, step choisit un temps de fin qui montre l’état stable vers lequel la réponse s’oriente. Cependant, ce système possède des transitoires rapides, qui sont masqués sur cette échelle de temps. Pour observer de plus près la réponse transitoire, limitez le tracé indiciel à t = 15 s.

step(sys,15)

Vous pouvez également spécifier les temps exacts auxquels vous voulez examiner la réponse indicielle, à condition qu’ils soient séparés par un intervalle constant. Par exemple, examinez la réponse à partir de la fin du transitoire jusqu’à ce que le système atteigne l’état stable.

t = 20:0.2:120;
step(sys,t)

Même si ce tracé commence à t = 20, step applique toujours l’entrée indicielle à t = 0.

Tracé de réponse indicielle de systèmes MIMO

Considérons le modèle de représentation d’état de second ordre suivant :

$$\begin{array}{l}\left[\begin{array}{c}{\underset{}{\overset{\dot{}}{x}}}_1\\ {\underset{}{\overset{\dot{}}{x}}}_2\end{array}\right]=\left[\begin{array}{cc}-0.5572& -0.7814\\ 0.7814& 0\end{array}\right]\left[\begin{array}{c}{x}_1\\ x_2\end{array}\right]+\left[\begin{array}{cc}1& -1\\ 0& 2\end{array}\right]\left[\begin{array}{c}{u}_1\\ u_2\end{array}\right]\\ y=\left[\begin{array}{cc}1.9691& 6.4493\end{array}\right]\left[\begin{array}{c}{x}_1\\ x_2\end{array}\right]\end{array}$$

A = [-0.5572,-0.7814;0.7814,0];
B = [1,-1;0,2];
C = [1.9691,6.4493];
sys = ss(A,B,C,0);

Ce modèle a deux entrées et une sortie, il a donc deux canaux : de la première entrée à la sortie et de la deuxième entrée à la sortie. Chaque canal a sa propre réponse indicielle.

Quand vous utilisez step, il calcule les réponses de tous les canaux.

step(sys)

Le tracé à gauche montre la réponse indicielle du premier canal d’entrée et le tracé à droite montre la réponse indicielle du deuxième canal d’entrée. Quand vous utilisez step pour tracer les réponses d’un modèle MIMO, il génère un tableau de tracés représentant tous les canaux E/S du modèle. Par exemple, créez un modèle de représentation d’état aléatoire composé de cinq états, trois entrées et deux sorties, et tracez sa réponse indicielle.

sys = rss(5,2,3);
step(sys)

Dans une fenêtre figure MATLAB, vous pouvez restreindre le tracé à un sous-ensemble de canaux en faisant un clic droit sur le tracé et en sélectionnant I/O Selector (Sélecteur E/S).

Comparer les réponses de plusieurs systèmes

step vous permet de tracer les réponses de plusieurs systèmes dynamiques sur le même axe. Par exemple, comparez la réponse en boucle fermée d’un système avec un contrôleur PI et un contrôleur PID. Créez une fonction de transfert du système et réglez les contrôleurs.

H = tf(4,[1 2 10]);
C1 = pidtune(H,'PI');
C2 = pidtune(H,'PID');

Formez les systèmes en boucle fermée et tracez leur réponse indicielle.

sys1 = feedback(H*C1,1);
sys2 = feedback(H*C2,1);
step(sys1,sys2)
legend('PI','PID','Location','SouthEast')

Par défaut, step choisit des couleurs différentes pour chaque système que vous tracez. Vous pouvez spécifier des couleurs et des styles de ligne avec l’argument d’entrée LineSpec.

 step(sys1,'r--',sys2,'b')
 legend('PI','PID','Location','SouthEast')

Le premier argument LineSpec 'r--' spécifie une ligne rouge en pointillés pour la réponse du contrôleur PI. Le deuxième argument LineSpec, 'b' spécifie une ligne bleue continue pour la réponse du contrôleur PID. La légende montre les couleurs et styles de ligne spécifiés. Pour découvrir d’autres options de personnalisation du tracé, utilisez stepplot.

Réponse indicielle de systèmes dans un réseau de modèles

L’exemple « Comparer les réponses de plusieurs systèmes » montre comment tracer les réponses de plusieurs systèmes individuels sur un axe unique. Quand il y a plusieurs systèmes dynamiques organisés dans un réseau de modèles, step trace toutes leurs réponses en même temps.

Créez un tableau de modèles. Pour cet exemple, utilisez un tableau unidimensionnel des fonctions de transfert de second ordre ayant différentes fréquences naturelles. D’abord, préallouez de la mémoire pour le tableau de modèles. La commande suivante crée une ligne de 1 par 5 de fonctions de transfert SISO de zéro gain. Les deux premières dimensions représentent les sorties et les entrées du modèle. Les autres dimensions sont les dimensions du tableau.

 sys = tf(zeros(1,1,1,5));

Remplissez le tableau.

w0 = 1.5:1:5.5;    % natural frequencies
zeta = 0.5;        % damping constant
for i = 1:length(w0)
   sys(:,:,1,i) = tf(w0(i)^2,[1 2*zeta*w0(i) w0(i)^2]);
end

(Pour plus d’informations sur les tableaux de modèles et comment les créer, consultez Model Arrays.) Tracez les réponses indicielles de tous les modèles du tableau.

step(sys)

step utilise le même style de ligne pour les réponses de toutes les entrées du tableau. Une façon de distinguer les entrées entre elles est d’utiliser la propriété SamplingGrid des modèles de systèmes dynamiques pour associer chaque entrée du tableau à la valeur w0 correspondante.

sys.SamplingGrid = struct('frequency',w0);

Désormais, quand vous tracez les réponses dans une fenêtre figure MATLAB, vous pouvez cliquer sur une trace pour voir la valeur de fréquence à laquelle elle correspond.

Données de réponse indicielle

Quand vous lui donnez un argument de sortie, step renvoie un tableau de données de réponse. Pour un système SISO, les données de réponse sont renvoyées en tant que vecteur colonne de longueur égale au nombre de points temporels auxquels la réponse est échantillonnée. Vous pouvez fournir le vecteur t de points temporels ou vous pouvez permettre à step de sélectionner des points temporels à votre place sur la base de la dynamique du système. Par exemple, extrayez la réponse indicielle d’un système SISO à 101 points temporels entre t = 0 et t = 5 s.

sys = tf(4,[1 2 10]);
t = 0:0.05:5;
y = step(sys,t);
size(y)

ans = 1×2

   101     1

Pour un système MIMO, les données de réponse sont renvoyées en tant que tableau de dimensions N par Ny par Nu, où Ny et Nu sont le nombre de sorties et d’entrées du système dynamique. Par exemple, considérons le modèle de représentation d’état suivant, représentant un système à deux entrées et une sortie.

A = [-0.5572,-0.7814;0.7814,0];
B = [1,-1;0,2];
C = [1.9691,6.4493];
sys = ss(A,B,C,0);

Extrayez la réponse indicielle de ce système à 200 points temporels entre t = 0 et t = 20 s.

t = linspace(0,20,200);
y = step(sys,t);
size(y)

ans = 1×3

   200     1     2

y(:,i,j) est un vecteur colonne qui contient la réponse indicielle de la je entrée à la ie sortie aux heures t. Par exemple, extrayez la réponse indicielle de la deuxième entrée à la sortie.

y12 = y(:,1,2);
plot(t,y12)

Tracé de réponse indicielle de boucle de rétroaction avec retard

Créez une boucle de rétroaction avec retard et tracez sa réponse indicielle.

s = tf('s');
G = exp(-s) * (0.8*s^2+s+2)/(s^2+s);
sys = feedback(ss(G),1);
step(sys)

La réponse indicielle du système affichée est chaotique. La réponse indicielle de systèmes comportant des retards internes peut présenter un comportement étrange, comme des sauts récurrents. Un tel comportement est une caractéristique du système, pas une anomalie logicielle.

Réponse à une entrée indicielle personnalisée

Par défaut, step applique un signal d’entrée qui passe de 0 à 1 à t = 0. Pour personnaliser l’amplitude et le biais, utilisez RespConfig. Par exemple, calculez la réponse d’un modèle de représentation d’état SISO à un signal qui passe de 1 à -1 à t = 0.

A = [1.6 -0.7;
      1  0];
B = [0.5; 0];
C = [0.1 0.1];
D = 0;
sys = ss(A,B,C,D,0.2);

opt = RespConfig;
opt.Bias = 1;
opt.Amplitude = -2;

step(sys,opt)

Pour les réponses aux signaux d’entrée arbitraires, utilisez lsim.

Réponses indicielles de modèles identifiés avec régions de confiance

Comparez la réponse indicielle d’un modèle paramétrique identifié à celle d’un modèle (empirique) non paramétrique. Affichez également leurs 3 régions de confiance $$\sigma$$.

Chargez les données.

load iddata1 z1

Estimez un modèle paramétrique.

sys1 = ssest(z1,4);

Estimez un modèle non paramétrique.

sys2 = impulseest(z1);

Tracez les réponses indicielles afin de comparer.

t = (0:0.1:10)';
[y1, ~, ~, ysd1] = step(sys1,t);
[y2, ~, ~, ysd2] = step(sys2,t);
plot(t, y1, 'b', t, y1+3*ysd1, 'b:', t, y1-3*ysd1, 'b:')
hold on
plot(t, y2, 'g', t, y2+3*ysd2, 'g:', t, y2-3*ysd2, 'g:')

Réponse indicielle d’un modèle de séries temporelles identifié

Calculez la réponse indicielle d’un modèle de séries temporelles identifié.

Un modèle de séries temporelles, également appelé modèle de signal, est un modèle sans signaux d’entrée mesurés. Le tracé indiciel de ce modèle utilise son canal de bruit (non mesuré) comme canal d’entrée auquel le signal indiciel est appliqué.

Chargez les données.

load iddata9;

Estimez un modèle de séries temporelles.

sys = ar(z9, 4);

sys est un modèle du type A y(t) = e(t), où e(t) représente le canal de bruit. Pour le calcul de la réponse indicielle, e(t) est traité comme un canal d’entrée et est nommé e@y1.

Tracez la réponse indicielle.

step(sys)

Valider la linéarisation d’un modèle ARX non linéaire identifié

Validez la linéarisation d’un modèle ARX non linéaire en comparant les réponses indicielles de faible amplitude des modèles linéaires et non linéaires.

Chargez les données.

load iddata2 z2;

Estimez un modèle ARX non linéaire.

nlsys = nlarx(z2,[4 3 10],idTreePartition,'custom',...
    {'sin(y1(t-2)*u1(t))+y1(t-2)*u1(t)+u1(t).*u1(t-13)',...
    'y1(t-5)*y1(t-5)*y1(t-1)'},'nlr',[1:5, 7 9]);

Déterminez un point de fonctionnement d’équilibre pour nlsys correspondant à une valeur d’entrée d’état stationnaire de 1.

u0 = 1;
[X,~,r] = findop(nlsys, 'steady', 1);
y0 = r.SignalLevels.Output;

Obtenez une approximation linéaire de nlsys à ce point de fonctionnement.

sys = linearize(nlsys,u0,X);

Validez l’utilité de sys en comparant sa réponse indicielle de faible amplitude à celle de nlsys.

Le système non linéaire nlsys fonctionne à un niveau d’équilibre dicté par (u0,y0). Introduisez une perturbation en échelon de taille 0,1 autour de cet état stationnaire et calculez la réponse correspondante.

opt = RespConfig;
opt.InputOffset = u0;
opt.Amplitude = 0.1;
t = (0:0.1:10)';
ynl = step(nlsys, t, opt);

Le système linéaire sys exprime la relation entre les perturbations en entrée et la perturbation correspondante en sortie. Il n’a pas conscience des valeurs d’équilibre du système non linéaire.

Tracez la réponse indicielle du système linéaire.

opt = RespConfig;
opt.Amplitude = 0.1;
yl = step(sys, t, opt);

Ajoutez le décalage de l’état stationnaire, y0, à la réponse du système linéaire et tracez les réponses.

plot(t, ynl, t, yl+y0)
legend('Nonlinear', 'Linear with offset')

Réponse indicielle d’un modèle LPV

Calculez et tracez la réponse indicielle d’un modèle (lpvss) LPV. Cet exemple simule la réponse indicielle en boucle fermée d’un modèle de balle en lévitation, défini dans fcnMaglev.m sur une perturbation $\mathit{du}$.

Créez le modèle et discrétisez-le.

hmin = 0.05; 
hmax = 0.25;
h0 = (hmin+hmax)/2;
Ts = 0.01;
Glpv = lpvss("h",@fcnMaglev,0,0,h0);
Glpvd = c2d(Glpv,Ts,"tustin"); 

Échantillonnez le modèle LPV pour trois valeurs de hauteur et réglez un contrôleur PID.

hpid = linspace(hmin,hmax,3);
[Ga,Goffset] = sample(Glpvd,[],hpid);
wc = 50;
Ka = pidtune(Ga,"pidf",wc);
Ka.Tf = 0.01;

Créez le contrôleur PID à gains séquencés.

Ka.SamplingGrid = struct("h",hpid);
Koffset = struct("y",{Goffset.u});
Clpv = ssInterpolant(ss(Ka),Koffset);

Créez le modèle en boucle fermée.

CL = feedback(Glpvd*[1,Clpv],1,2,1);
CL.InputName = {'du';'href'};
CL.OutputName = "h";

Faites de l’état stationnaire l’actuel pour $\mathit{h}$ = ${\mathit{h}}_0$ pour calculer une taille appropriée pour la perturbation en échelon à l’entrée du système physique.

[~,~,~,~,~,~,~,u0] = Glpv.DataFunction(0,h0);

Calculez et tracez la réponse à la perturbation d’entrée et au changement de pas pour référence. Définissez les signaux d’entrée de base $\mathit{du}$ = 0 et $\mathit{h}$ = ${\mathit{h}}_0$ pour spécifier la condition d’état stationnaire de départ.

t = 0:Ts:2;
pFcn = @(k,x,u) x(1);
Config = RespConfig( ...
    Bias=[0;h0], ...
    Amplitude=0.2*[u0;h0]*Ts, ...
    Delay=0.5, ...
    InitialParameter=h0);
step(CL,t,pFcn,Config)
title("Current Step Disturbance and Height Step Change")

Calculer la réponse indicielle d’un modèle à coefficients complexes

Créez un modèle de représentation d’état à coefficients complexes.

A = [-2-2i -2;1 0];
B = [2;0];
C = [0 0.5+2.5i];
D = 0;
sys = ss(A,B,C,D);

Calculez la réponse indicielle du système.

[y,t] = step(sys);

Les données de réponse obtenues contiennent des valeurs de sortie complexes.

y

y = 369×1 complex

   0.0000 + 0.0000i
   0.0018 + 0.0075i
   0.0079 + 0.0286i
   0.0191 + 0.0612i
   0.0360 + 0.1033i
   0.0588 + 0.1531i
   0.0874 + 0.2089i
   0.1215 + 0.2690i
   0.1609 + 0.3320i
   0.2048 + 0.3969i
   0.2528 + 0.4624i
   0.3041 + 0.5279i
   0.3580 + 0.5925i
   0.4138 + 0.6558i
   0.4708 + 0.7173i
      ⋮

Arguments d'entrée

sys — Système dynamique

modèle de systèmes dynamiques | tableau de modèles

Système dynamique spécifié en tant que modèle de système dynamique SISO or MIMO ou en tant que tableau de modèles de systèmes dynamiques. Vous pouvez utiliser ces types de systèmes dynamiques :

• Modèles LTI numériques en temps continu ou discret, tels que les modèles tf, zpk ou ss.

• Modèles LTI généralisés ou incertains tels que les modèles genss ou uss. (Pour pouvoir utiliser les modèles incertains, le software Robust Control Toolbox™ est nécessaire.)

  • Pour les blocs de design de contrôle réglables, la fonction évalue le modèle à sa valeur actuelle à la fois pour tracer et renvoyer les données de réponse.

  • Pour les blocs de design de systèmes de contrôle incertains, la fonction trace la valeur nominale et des échantillons aléatoires du modèle. Quand vous utilisez des arguments de sortie, la fonction renvoie des données de réponse pour le modèle nominal uniquement.

• Modèles parcimonieux de représentation d’état tels que les modèles sparss et mechss.

• Modèles LTI identifiés, tels que idtf, idss ou idproc. Pour ces modèles, la fonction peut également tracer des intervalles de confiance et renvoyer des écarts-types de la réponse en fréquence. Consultez Réponses indicielles de modèles identifiés avec régions de confiance. (Pour pouvoir utiliser les modèles identifiés, le software System Identification Toolbox est nécessaire)

• Modèles linéaires variant dans le temps (ltvss) et modèles linéaires aux paramètres variables (lpvss).

Cette fonction ne supporte pas les modèles de données de réponse en fréquence tels que les modèles frd, genfrd ou idfrd.

Si sys est un réseau de modèles, la fonction trace les réponses de tous les modèles du réseau sur les mêmes axes. Consultez Réponse indicielle de systèmes dans un réseau de modèles.

t — Pas de temps

scalaire positif | vecteur à deux éléments | vecteur | []

Pas de temps auxquels calculer la réponse, spécifiés en tant qu’une de ces valeurs :

• Scalaire positif tFinal— Calcule la réponse de t = 0 à t = tFinal.

• Vecteur à deux éléments [t0 tFinal]— Calcule la réponse de t = t0 à t = tFinal. (depuis R2023b)

• Vecteur Ti:dt:Tf— Calcule la réponse pour les points temporels spécifiés dans t.

  • Pour les systèmes en temps continu, dt est le pas d’échantillonnage d’une approximation discrète au système continu.

  • Pour les systèmes en temps discret avec un pas d’échantillonnage spécifié, dt doit correspondre à la propriété de pas d’échantillonnage Ts de sys.

  • Pour les systèmes en temps discret avec un pas d’échantillonnage non spécifié (Ts = -1), dt doit être de 1.

• [] — Sélectionne automatiquement les valeurs de temps sur la base de la dynamique du système.

Quand vous spécifiez une plage temporelle au moyen de tFinal ou de [t0 tFinal] :

• Pour les systèmes en temps continu, la fonction détermine automatiquement la taille du pas de temps et le nombre de points sur la base de la dynamique du système.

• Pour les systèmes en temps discret avec un pas d’échantillonnage spécifié, la fonction utilise le pas d’échantillonnage de sys comme taille de pas.

• Pour les systèmes en temps discret avec un pas d’échantillonnage non spécifié (Ts = -1), la fonction interprète tFinal comme le nombre de périodes d’échantillonnage à simuler avec un pas d’échantillonnage de 1 seconde.

Exprimez t au moyen des unités temporelles définies dans la propriété TimeUnit de sys.

Si vous spécifiez un retard de pas td au moyen de config, la fonction applique le pas à t = t0+td.

p — Trajectoire de paramètre d’un modèle LPV

matrice | handle de fonction

Trajectoire de paramètre du modèle LPV, spécifiée en tant que matrice ou handle de fonction.

• Pour les trajectoires exogènes et explicites, spécifiez p en tant que matrice de dimensions N par Np, où N est le nombre d’échantillons de temps et Np est le nombre de paramètres.

  Par conséquent, le vecteur ligne p(i,:) contient les valeurs de paramètres au ie pas de temps.

• Pour les trajectoires endogènes ou implicites, spécifiez p en tant que handle de fonction du type p = F(t,x,u) en temps continu et p = F(k,x,u) en temps discret qui donne les paramètres sous la forme d’une fonction de temps t ou d’un échantillon de temps k, état x et entrée u.

  Cette option est utile quand vous souhaitez simuler des modèles quasi-LPV. Pour un exemple, voir Réponse indicielle d’un modèle LPV.

config — Configuration de la réponse

Objet RespConfig

Configuration du signal appliqué, spécifié en tant qu’objet RespConfig. Par défaut, step applique une entrée qui passe de 0 à 1 à l’heure t = 0. Utilisez cet argument d’entrée pour changer la configuration de l’entrée indicielle. Consultez Réponse à une entrée indicielle personnalisée pour voir un exemple.

Pour les modèles lpvss et ltvss avec décalages (x₀(t),u₀(t)), vous pouvez utiliser RespConfig pour définir l’entrée relative à u₀(t,p) et initialiser la simulation avec l’état x₀(t,p).

Arguments en sortie

y — Données de réponse indicielle

tableau

Données de réponse indicielle, renvoyées en tant que tableau.

• Pour les systèmes SISO, y est un vecteur colonne de même longueur que t (s’il est fourni) ou tOut (si vous ne fournissez pas t).

• Pour les systèmes à entrée unique et à sorties multiples, y est une matrice avec autant de lignes qu’il y a d’échantillons de temps et autant de colonnes qu’il y a de sorties. Par conséquent, la je colonne de y, ou y(:,j), contient la réponse indicielle depuis l’entrée jusqu’à la je sortie.

• Pour les systèmes MIMO, les réponses indicielles de chaque canal d’entrée sont empilées sur la troisième dimension de y. Les dimensions de y sont donc N par Ny par Nu, où :

  • N est le nombre d’échantillons de temps.

  • Ny est le nombre de sorties du système.

  • Nu est le nombre d’entrées du système.

  Par conséquent, y(:,i,j) est un vecteur colonne qui contient la réponse indicielle de la je entrée à la ie sortie aux heures spécifiées dans t ou tOut.

• Pour les systèmes à coefficients complexes, y est un tableau de valeurs complexes. (depuis R2025a)

tOut — Heures auxquelles la réponse indicielle est calculée

vecteur

Heures auxquelles la réponse indicielle est calculée, renvoyées en tant que vecteur. Quand vous ne fournissez pas de vecteur t d’heures spécifique, step choisit ce vecteur temps sur la base de la dynamique du système. Les heures sont exprimées en unités de temps de sys.

x — Trajectoires d’état

tableau

Trajectoires d’état, renvoyées en tant que tableau. Quand sys est un modèle de représentation d’état, x contient l’évolution des états de sys à chaque heure de t ou de tOut. Les dimensions de x sont N par Nx par Nu, où :

• N est le nombre d’échantillons de temps.

• Nx est le nombre d’états.

• Nu est le nombre d’entrées du système.

Par conséquent, l’évolution des états en réponse à un pas injecté à la ke entrée est donnée par le tableau x(:,:,k). Le vecteur ligne x(i,:,k) contient les valeurs d’état au ie pas de temps.

Pour les systèmes à coefficients complexes, x est un tableau de valeurs complexes. (depuis R2025a)

ysd — Écart-type de réponse indicielle

tableau

Écart-type de la réponse indicielle d’un modèle identifié, renvoyé en tant que tableau de mêmes dimensions que y. Si sys ne contient pas d’informations de covariance des paramètres, alors ysd est vide.

pOut — Trajectoires de paramètres

tableau

Trajectoires de paramètres, renvoyées en tant que tableau. Quand sys est un modèle linéaire aux paramètres variables, pOut contient l’évolution des paramètres de sys à chaque heure de t ou de tOut. Les dimensions de pOut sont N par Np par Nu, où :

• N est le nombre d’échantillons de temps.

• Np est le nombre de paramètres.

• Nu est le nombre d’entrées du système.

Par conséquent, l’évolution des paramètres en réponse à un pas injecté à la ke entrée est donnée par le tableau pOut(:,:,k). Le vecteur ligne pOut(i,:,k) contient les valeurs de paramètres au ie pas de temps.

Conseils

• Pour simuler les réponses du système aux signaux d’entrée arbitraires, utilisez lsim.

• Lorsque vous avez besoin d’options supplémentaires de personnalisation du tracé, utilisez plutôt stepplot.

• Les tracés créés à l’aide de step ne supportent pas les titres ou étiquettes multilignes spécifiés en tant que tableaux de chaînes de caractères ou cell arrays de vecteurs de caractères. Pour spécifier des titres et étiquettes multilignes, utilisez une chaîne de caractères unique avec un caractère newline.

  step(sys,u,t)
  title("first line" + newline + "second line");

Algorithmes

Pour obtenir des échantillons de modèles en temps continu sans retards internes, step convertit ces modèles en modèles de représentation d’état et les discrétise au moyen d’un bloqueur d’ordre zéro sur les entrées. step choisit le pas d’échantillonnage pour cette discrétisation automatiquement, sur la base de la dynamique du système, sauf quand vous fournissez le vecteur temps d’entrée t sous la forme t = T0:dt:Tf. Dans ce cas, step utilise dt comme pas d’échantillonnage. Les pas de temps de simulation obtenus tOut sont échantillonnés uniformément avec l’espacement dt.

Pour les systèmes ayant des retards internes, le logiciel Control System Toolbox™ utilise des solveurs à pas variable. Par conséquent, les pas de temps tOut ne sont pas échantillonnés uniformément.

Références

[1] L.F. Shampine and P. Gahinet, "Delay-differential-algebraic equations in control theory," Applied Numerical Mathematics, Vol. 56, Issues 3–4, pp. 574–588.

Historique des versions

Introduit avant R2006a

R2025a: Prise en charge des systèmes dynamiques à coefficients complexes

À partir de R2025a, la fonction step supporte les systèmes dynamiques à coefficients complexes.

R2024b: gca renvoie maintenant un objet tracé

Pour les tracés créés à l’aide de step, la fonction gca renvoie maintenant un objet tracé stepplot plutôt qu’un objet axes au sein du tracé.

R2023b: Changements de calcul des caractéristiques de réponse

Le calcul de certaines caractéristiques de réponse a changé lors de l’utilisation d’une configuration non définie par défaut créée au moyen de RespConfig.

• La caractéristique Peak Response montre maintenant l’écart maximal de la valeur de sortie initiale. C’est-à-dire la valeur de crête de |y(t) – y_init| quand t ≥ t₀ + t_d, où y_init est la valeur de sortie juste avant que le pas ne change.

  Par conséquent, dans le conseil sur les données Peak Response, Peak amplitude est renommé Peak deviation.

• Le temps de stabilisation et le temps transitoire sont maintenant calculés par rapport à l’heure où le changement de pas se produit (t = t₀ + t_d). Cela garantit que ces caractéristiques ne sont pas influencées par un retard de pas.

En général, le logiciel calcule les caractéristiques de réponse à partir de l’instant de changement de pas, avec la valeur de sortie initiale y_init en tant que valeur juste avant le changement de pas.

R2023b: Nouvelle syntaxe

Utilisez la nouvelle syntaxe [y,tOut] = step(sys,[t0,tFinal]) pour calculer la réponse indicielle de l’instant t0 à tFinal. Pour les configurations avec un retard td, la fonction applique le pas à l’instant t = t0 + td.

R2023a: Prise en charge de l’instant de début non nul

Vous pouvez maintenant spécifier un instant de début non nul pour la commande step en utilisant une entrée en vecteur temps du type Ti:dt:Tf. Auparavant, la commande appliquait toujours l’entrée à t = 0, indépendamment de Ti.

Voir aussi

Fonctions

• impulse | RespConfig | initial | lsim | stepplot

Applications

• Linear System Analyzer

Sites web externes

• Analyse de la fonction de transfert des systèmes dynamiques (ressources d’enseignement MathWorks)