impulse

Tracé de réponse impulsionnelle d’un système dynamique et données de réponse impulsionnelle

Syntaxe

[y,tOut] = impulse(sys)

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

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

[y,t,x] = impulse(___)

[y,t,x,ysd] = impulse(___)

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

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

impulse(___)

Description

[y,tOut] = impulse(sys) calcule la réponse impulsionnelle y d’un système dynamique sys. impulse 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] = impulse(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] = impulse(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,t,x] = impulse(___) renvoie également les trajectoires d’état x quand sys est un modèle de représentation d’état.

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

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

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

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

• 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, impulse(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, impulse(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 impulseplot.

Exemples

Réponse impulsionnelle d’un système dynamique

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

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

Pour cet exemple, créez un modèle tf qui représente la fonction de transfert. Vous pouvez également tracer la réponse impulsionnelle 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 impulsionnelle.

impulse(sys)

Le tracé impulse 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 impulsionnelle telles que la réponse maximale et le temps transitoire.

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

Tracez la réponse impulsionnelle 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 impulsionnelle.

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

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

Réponse impulsionnelle à des temps spécifiés

Examinez la réponse impulsionnelle du modèle zéro-pôle-gain suivant.

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

impulse(sys)

Par défaut, impulse choisit un temps de fin qui montre l’état stable vers lequel la réponse s’oriente. Pour observer de plus près la réponse transitoire, limitez le tracé impulsionnel à t = 20 s.

impulse(sys,20)

Vous pouvez également spécifier les temps exacts auxquels vous voulez examiner la réponse impulsionnelle, à 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;
impulse(sys,t)

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

Tracé de réponse impulsionnelle 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 impulsionnelle.

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

impulse(sys)

Le tracé à gauche montre la réponse impulsionnelle du premier canal d’entrée et le tracé à droite montre la réponse impulsionnelle du deuxième canal d’entrée. Quand vous utilisez impulse 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 impulsionnelle.

sys = rss(5,2,3);
impulse(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 la réponse impulsionnelle de plusieurs systèmes

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

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

Par défaut, impulse 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.

 impulse(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 impulseplot.

Réponse impulsionnelle de systèmes dans un tableau de modèles

L’exemple Comparer la réponse impulsionnelle 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 tableau de modèles, impulse 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 impulsionnelles de tous les modèles du tableau.

impulse(sys)

impulse 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 impulsionnelle

Quand vous lui donnez un argument de sortie, impulse 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 à impulse de sélectionner des points temporels à votre place sur la base de la dynamique du système. Par exemple, extrayez la réponse impulsionnelle 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 = impulse(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 impulsionnelle de ce système à 200 points temporels entre t = 0 et t = 20 s.

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

ans = 1×3

   200     1     2

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

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

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

Comparez la réponse impulsionnelle d’un modèle paramétrique identifié à celle d’un modèle non paramétrique (empirique). 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 impulsionnelles pour les comparer.

t = (0:0.1:10)';
[y1, ~, ~, ysd1] = impulse(sys1,t);
[y2, ~, ~, ysd2] = impulse(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 impulsionnelle d’un modèle de séries temporelles identifié

Calculez la réponse impulsionnelle 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é impulsionnel de ce modèle utilise son canal de bruit (non mesuré) comme canal d’entrée auquel le signal impulsionnel 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 impulsionnelle, e(t) est traité comme un canal d’entrée et est nommé e@y1.

Tracez la réponse impulsionnelle.

impulse(sys)

Configurer des options pour la réponse impulsionnelle

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

A = [-0.8429,-0.2134;-0.5162,-1.2139];
B = [0.7254,0.7147;0,-0.2050];
C = [-0.1241,1.4090;1.4897,1.4172];
D = [0.6715,0.7172;-1.2075,0];
sys = ss(A,B,C,D);

Créez un ensemble d’options par défaut et utilisez la notation pointée pour spécifier des valeurs.

respOpt = RespConfig;
respOpt.Bias = [-2,3];
respOpt.Amplitude = [2,-0.5];
respOpt.InitialState = [0.1,-0.1];
respOpt.Delay = 5;

Calculez la réponse impulsionnelle.

t = 0:0.1:20;
impulse(sys,t,respOpt)

Réponse impulsionnelle d’un modèle LPV

Cet exemple montre comment simuler la réponse impulsionnelle d’un modèle LPV. Cet exemple simule la réponse en boucle fermée d’un modèle de balle en lévitation défini dans fcnMaglev.m à une perturbation $\text{du}$.

Vous devez définir la référence sur $h_0$ pour initialiser correctement le système et le maintenir à peu près à $h$ = $h_0$.

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 $h$ = $h_0$ pour dimensionner la perturbation.

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

Tracer la réponse à la modification d’impulsion dans $\text{du}$ et $h_0$.

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);
impulse(CL,t,pFcn,Config)
title("Current Impulse Disturbance and Height Impulse Change")

Calculer la réponse impulsionnelle 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 impulsionnelle du système.

[y,t] = impulse(sys);

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

y

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 ou MIMO ou bien 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, la 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, la 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 tableau de modèles, la fonction trace les réponses de tous les modèles du tableau 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.

Avant R2026a : Spécifiez des valeurs de temps avec la propriété Responses.SourceData.TimeSpec.

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(k,x,u) qui donne les paramètres sous la forme d’une fonction d’un échantillon de temps k, d’un état x et d’une entrée u. impulse ne supporte cette option que pour les modèles LPV en temps discret.

  Cette option est utile quand vous souhaitez simuler des modèles quasi-LPV.

config — Configuration de la réponse

ensemble d’options RespConfig

Configuration du signal impulsionnel appliqué, spécifiée en tant qu’objet RespConfig. Par défaut, impulse applique une entrée au temps t = 0. Utilisez cet argument en entrée pour modifier la configuration de la réponse, par exemple en spécifiant un retard ou un décalage d’entrée. Consultez Configurer des options pour la réponse impulsionnelle 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 impulsionnelle

tableau

Données de réponse impulsionnelle, 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 que d’échantillons de temps et autant de colonnes que de sorties. Par conséquent, la j-ième colonne de y, ou y(:,j), contient la réponse impulsionnelle depuis l’entrée jusqu’à la j-ième sortie.

• Pour les systèmes MIMO, les réponses impulsionnelles 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 impulsionnelle de la j-ième entrée à la i-ème sortie aux temps spécifiés dans t ou tOut.

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

tOut — Temps auxquels la réponse impulsionnelle est calculée

vecteur

Temps auxquels la réponse impulsionnelle est calculée, renvoyés en tant que vecteur. Quand vous ne fournissez pas de vecteur t de temps spécifique, impulse choisit ce vecteur temps sur la base de la dynamique du système. Les temps sont exprimés 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 instant 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 à une impulsion injectée à la k-ième 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 la réponse impulsionnelle

tableau

Écart-type de la réponse impulsionnelle 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 instant 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 signal injecté à la k-ième 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.

Limitations

• La réponse impulsionnelle d’un système continu avec une matrice D non nulle est infinie à t = 0. impulse ignore cette discontinuité et renvoie la valeur de continuité la plus faible Cb à t = 0.

• La commande impulse ne fonctionne pas pour les modèles en temps continu avec des retards internes. Pour ces modèles, utilisez pade pour approximer le retard avant de calculer la réponse impulsionnelle.

• La commande impulse ne supporte pas les simulations le long d’une trajectoire de paramètre implicite pour les modèles LPV en temps continu.

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

• Les tracés créés à l’aide de impulse 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.

  impulse(sys)
  title("first line" + newline + "second line");

Algorithmes

Les modèles LTI en temps continu sont tout d’abord convertis sous forme de représentation d’état. La réponse impulsionnelle d’un modèle de représentation d’état à entrée unique

$$\begin{array}{l}\dot{x}=Ax+bu\\ y=Cx\end{array}$$

est équivalente à la réponse non forcée suivante avec l’état initial b.

$$\begin{array}{cc}\dot{x}=Ax,& x(0)=b\\ y=Cx& \end{array}$$

Pour simuler cette réponse, le système est discrétisé avec un bloqueur d’ordre zéro sur les entrées. Le pas d’échantillonnage est choisi automatiquement en fonction de la dynamique du système, sauf si un vecteur temps t = T0:dt:Tf est indiqué. Par conséquent, dt est utilisé comme pas d’échantillonnage.

Historique des versions

Introduit avant R2006a

R2026a: Support des modèles d’index 2 parcimonieux

À partir de la version R2026a, la fonction impulse supporte les DAE (équations algébriques différentielles) d’index 2 parcimonieuses.

R2025a: Support des systèmes dynamiques à coefficients complexes

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

R2024b: gca renvoie maintenant un objet tracé

Pour les tracés créés à l’aide de impulse, la fonction gca renvoie maintenant un objet tracé impulseplot 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 l’impulsion.

  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 au temps où l’impulsion se produit (t = t₀ + t_d). Cela garantit que ces caractéristiques ne sont pas influencées par le retard.

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

R2023b: Nouvelle syntaxe

Utilisez la nouvelle syntaxe [y,tOut] = impulse(sys,[t0,tFinal]) pour calculer la réponse impulsionnelle au temps t0 à tFinal. Pour les configurations avec un retard td, la fonction applique l’impulsion au temps t = t0 + td.

R2023a: Support de l’instant de début non nul

Vous pouvez maintenant spécifier un instant de début non nul pour la commande impulse 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

Linear System Analyzer | step | initial | lsim | pade | impulseplot