c2d

Conversion de modèle du temps continu au temps discret

Syntaxe

sysd = c2d(sysc,Ts)

sysd = c2d(sysc,Ts,method)

sysd = c2d(sysc,Ts,opts)

[sysd,G] = c2d(___)

Description

sysd = c2d(sysc,Ts) discrétise le modèle de système dynamique en temps continu Modèles de systèmes dynamiques sysc au moyen d’un bloqueur d'ordre zéro sur les entrées et d’un pas d'échantillonnage de Ts.

sysd = c2d(sysc,Ts,method) spécifie la méthode de discrétisation.

sysd = c2d(sysc,Ts,opts) spécifie des options supplémentaires pour la discrétisation.

[sysd,G] = c2d(___), où sysc est un modèle de représentation d’état, qui renvoie une matrice G, qui fait correspondre les conditions initiales continues x₀ et u₀ du modèle de représentation d’état au vecteur d'état initial en temps discret x[0].

Exemples

Discrétiser une fonction de transfert

Discrétisez la fonction de transfert en temps continu suivante :

$$H\left(s\right)=e^{-0.3s}\frac{s-1}{s^2+4s+5}.$$

Ce système présente un retard en entrée de 0,3 s. Discrétisez le système au moyen de l'approximation triangulaire (bloqueur du premier ordre) avec un pas d'échantillonnage Ts = 0,1 s.

H = tf([1 -1],[1 4 5],'InputDelay', 0.3); 
Hd = c2d(H,0.1,'foh');

Comparez les réponses indicielles des systèmes en temps continu et des systèmes discrétisés.

step(H,'-',Hd,'--')

Discrétiser le modèle avec un retard fractionnaire absorbé dans les coefficients

Discrétisez la fonction de transfert retardée suivante avec un bloqueur d'ordre zéro sur l'entrée et un taux d’échantillonnage de 10 Hz.

$$H\left(s\right)=e^{-0.25s}\frac{10}{s^2+3s+10}.$$

h = tf(10,[1 3 10],'IODelay',0.25); 
hd = c2d(h,0.1)

hd =
 
           0.01187 z^2 + 0.06408 z + 0.009721
  z^(-3) * ----------------------------------
                 z^2 - 1.655 z + 0.7408
 
Sample time: 0.1 seconds
Discrete-time transfer function.

Dans cet exemple, le modèle discrétisé hd présente un retard de trois périodes d'échantillonnage. L'algorithme de discrétisation absorbe le retard résiduel de la demi-période dans les coefficients de hd.

Comparez les réponses indicielles des modèles en temps continu et des modèles discrétisés.

step(h,'--',hd,'-')

Discrétiser le modèle avec un retard fractionnaire approximatif

Depuis R2024a

Créez un modèle de représentation d'état en temps continu, avec deux états et un retard en entrée.

sys = ss(tf([1,2],[1,4,2]));
sys.InputDelay = 2.7

sys =
 
  A = 
       x1  x2
   x1  -4  -2
   x2   1   0
 
  B = 
       u1
   x1   2
   x2   0
 
  C = 
        x1   x2
   y1  0.5    1
 
  D = 
       u1
   y1   0
 
  Input delays (seconds): 2.7 
 
Continuous-time state-space model.

Discrétisez le modèle au moyen de la méthode de discrétisation de Tustin et d’un filtre de Thiran, pour modéliser les retards fractionnaires. Pas d’échantillonnage Ts = 1 seconde.

opt = c2dOptions('Method','tustin','ThiranOrder',3);
sysd1 = c2d(sys,1,opt)

sysd1 =
 
  A = 
            x1       x2
   x1  -0.4286  -0.5714
   x2   0.2857   0.7143
 
  B = 
           u1
   x1  0.5714
   x2  0.2857
 
  C = 
           x1      x2
   y1  0.2857  0.7143
 
  D = 
           u1
   y1  0.2857
 
  (values computed with all internal delays set to zero)

  Internal delays (sampling periods): 1  1  1 
 
Sample time: 1 seconds
Discrete-time state-space model.

Par défaut, la fonction modélise les retards supplémentaires comme des retards internes dans le modèle discrétisé. Pour modéliser les retards supplémentaires en tant qu'états dans le modèle discrétisé, définissez l'option DelayModeling de c2dOptions sur 'state'.

opt2 = c2dOptions('Method','tustin','ThiranOrder',3,'DelayModeling','state');
sysd2 = c2d(sys,1,opt2)

sysd2 =
 
  A = 
              x1         x2         x3         x4         x5
   x1    -0.4286    -0.5714   -0.00265    0.06954      2.286
   x2     0.2857     0.7143  -0.001325    0.03477      1.143
   x3          0          0    -0.2432     0.1449    -0.1153
   x4          0          0       0.25          0          0
   x5          0          0          0      0.125          0
 
  B = 
             u1
   x1  0.002058
   x2  0.001029
   x3         8
   x4         0
   x5         0
 
  C = 
              x1         x2         x3         x4         x5
   y1     0.2857     0.7143  -0.001325    0.03477      1.143
 
  D = 
             u1
   y1  0.001029
 
Sample time: 1 seconds
Discrete-time state-space model.

Le modèle discrétisé contient à présent trois états supplémentaires x3, x4 et x5 correspondant à un filtre de Thiran du troisième ordre. Étant donné que le retard divisé par le pas d'échantillonnage est de 2,7, le filtre de Thiran du troisième ordre ('ThiranOrder' = 3) peut approximer l'ensemble du retard.

Discrétiser un modèle identifié

Estimez une fonction de transfert en temps continu et discrétisez-la.

load iddata1
sys1c = tfest(z1,2);
sys1d = c2d(sys1c,0.1,'zoh');

Estimez une fonction de transfert en temps discret du deuxième ordre.

sys2d = tfest(z1,2,'Ts',0.1);

Comparez la réponse du modèle de fonction de transfert en temps continu discrétisé, sys1d, et le modèle en temps discret directement estimé, sys2d.

compare(z1,sys1d,sys2d)

Les deux systèmes sont pour ainsi dire identiques.

Constituer un modèle prédictif

Discrétisez un modèle de représentation d'état identifié pour constituer un prédicteur de sa réponse avec un pas d’avance.

Créez un modèle de représentation d'état identifié en temps continu en utilisant des données d'estimation.

load iddata2
sysc = ssest(z2,4);

Prévoyez la réponse prédite de sysc avec un pas d’avance.

predict(sysc,z2)

Discrétisez le modèle.

sysd = c2d(sysc,0.1,'zoh');

Constituez un modèle prédictif à partir du modèle discrétisé, sysd.

[A,B,C,D,K] = idssdata(sysd);
Predictor = ss(A-K*C,[K B-K*D],C,[0 D],0.1);

Predictor est un modèle à deux entrées qui utilise les signaux de sortie et d'entrée mesurés ([z1.y z1.u]) pour calculer la réponse prédite de sysc avec un pas d’avance.

Simulez le modèle prédictif pour obtenir la même réponse que la commande predict.

lsim(Predictor,[z2.y,z2.u])

La simulation du modèle prédictif permet d’obtenir la même réponse que predict(sysc,z2).

Arguments d'entrée

sysc — Système dynamique en temps continu

modèle de systèmes dynamiques

Modèle en temps continu, spécifié comme étant un modèle de système dynamique tel que tf, ss, ou zpk. sysc ne peut pas être un modèle de données de réponse en fréquence. sysc peut être un système SISO ou MIMO, si ce n’est que la méthode de discrétisation 'matched' ne supporte que les systèmes SISO.

Les méthodes sysc peuvent présenter des retards en entrée/en sortie ou des retards internes. Pour autant, les méthodes 'matched', 'impulse' et 'least-squares' ne prennent pas en charge les modèles de représentation d'état avec des retards internes.

Les systèmes linéaires identifiés suivants ne peuvent pas être discrétisés directement :

• Modèles idgrey dont FunctionType est 'c'. Commencez par effectuer une conversion en modèle idss.

• Modèles idproc. Commencez par effectuer une conversion en modèle idtf ou idpoly.

Ts — Pas d’échantillonnage

scalaire positif

Pas d'échantillonnage spécifié comme un scalaire positif représentant la période d'échantillonnage du système en temps discret obtenu. Ts se trouve dans TimeUnit qui est la propriété sysc.TimeUnit.

method — Méthode de discrétisation

'zoh' (par défaut) | 'foh' | 'impulse' | 'tustin' | 'matched' | 'least-squares' | 'damped'

Méthode de discrétisation spécifiée sous la forme de l’une des valeurs suivantes :

• 'zoh' : bloqueur d'ordre zéro (par défaut). Suppose que les entrées de commande sont une fonction constante par morceaux sur le pas d'échantillonnage Ts.

• 'foh' : approximation triangulaire (bloqueur de premier ordre modifié). Suppose que les entrées de commande sont une fonction linéaire par morceaux sur le pas d'échantillonnage Ts.

• 'impulse' : discrétisation invariante impulsionnelle

• 'tustin' : méthode bilinéaire (Tustin). Pour spécifier cette méthode avec préwarping de fréquence (anciennement méthode 'prewarp'), utilisez l'option PrewarpFrequency de c2dOptions.

• 'matched' : méthode de mise en correspondance zéro-pôle

• 'least-squares' : méthode des moindres carrés

• 'damped' : approximation de Tustin amortie sur la base de la formule TRBDF2 pour les modèles sparss uniquement.

Pour plus d'informations sur les algorithmes de chaque méthode de conversion, voir Continuous-Discrete Conversion Methods.

opts — Options de discrétisation

Objet c2dOptions

Options de discrétisation spécifiées en tant qu’objet c2dOptions. Par exemple, vous pouvez spécifier en tant qu'options le préwarping de fréquence, l'ordre du filtre de Thiran ou la méthode de discrétisation.

Arguments en sortie

sysd — Modèle en temps discret

modèle de systèmes dynamiques

Modèle en temps discret, renvoyé en tant que modèle de système dynamique du même type que le système d'entrée sysc.

Lorsque sysc est un modèle identifié (IDLTI), sysd :

• Comprend les composantes mesurées et de bruit de sysc. La variance des innovations λ du modèle identifié en temps continu sysc, stockée dans sa propriété NoiseVariance, est interprétée comme l'intensité de la densité spectrale du spectre de bruit. La variance du bruit dans sysd est donc λ/Ts.

• Ne comprend pas la covariance estimée des paramètres de sysc. Si vous souhaitez traduire la covariance tout en discrétisant le modèle, utilisez translatecov.

G — Mise en correspondance des conditions initiales continues du modèle de représentation d’état avec le vecteur d'état initial en temps discret

matrice

Mise en correspondance des conditions initiales en temps continu x₀ et u₀ du modèle de représentation d’état sysc vers le vecteur d'état initial en temps discret x[0], renvoyée sous forme de matrice. Mise en correspondance des conditions initiales vers le vecteur d'état initial :

$$x\left[0\right]=G\cdot \left[\begin{array}{c}{x}_0\\ u_0\end{array}\right]$$

Pour les modèles de représentation d’état avec des retards, c2d remplit la matrice G de zéros pour tenir compte des états supplémentaires ajoutés par la discrétisation de ces retards. Voir Continuous-Discrete Conversion Methods pour consulter une discussion autour de la modélisation des retards dans les systèmes discrétisés.

Historique des versions

Introduit avant R2006a

R2024a: Ajout d'états supplémentaires évitée lors de la conversion

La commande c2d n'ajoute plus d'états supplémentaires lors de la modélisation de retards supplémentaires. Par défaut, c2d utilise désormais les retards internes et renvoie le modèle discrétisé avec le même nombre d'états. Cela se traduite par un comportement plus prévisible et cela simplifie la mise en correspondance de l'état initial du temps continu au temps discret.

Pour revenir à l'ancien comportement avant R2024a, créez un jeu d'options au moyen de c2dOptions et définissez DelayModeling sur "state".

R2024a: Prise en charge des modèles mechss

Vous pouvez à présent discrétiser les modèles mechss au moyen de la méthode d'approximation bilinéaire de Tustin. Pour les modèles mechss, la méthode 'tustin' calcule la forme du deuxième ordre de la discrétisation de Tustin. Cela revient à appliquer Tustin à l'équivalent sparss du premier ordre du modèle mechss.

R2024a: Prise en charge des modèles avec décalages et autres améliorations

Vous pouvez à présent utiliser c2d pour discrétiser des modèles avec des décalages, tels que les modèles linéaires à variation de paramètres.

En outre, c2dOptions propose deux nouvelles options

• DelayModeling : permet de spécifier si les retards supplémentaires doivent être modélisés comme des retards internes (par défaut) ou comme des états supplémentaires.

• Consistency : permet d’assurer la cohérence des états et des retards dans les tableaux de représentation d'état. Cette option est utile pour la discrétisation des modèles LPV ou LTV maillés.

Voir aussi

c2dOptions | d2c | d2d | thiran | translatecov (System Identification Toolbox) | Conversion de la fréquence du modèle

Rubriques

• Modèles de systèmes dynamiques
• Discretize a Compensator
• Continuous-Discrete Conversion Methods