La Transform Ee en Z: Plan Def Plan Def Plan Def

La transformée en Z
Pourquoi ?
Outil important pour résoudre et raisonner sur les équations récurrentes linéaires
stationnaires,
Permet d’abord de comprendre des outils de conception tels que Simulink, Scicos, voire
Lustre-Scade
– Définition
– Equations récurrentes
– Fonctions puissance
– Exemples
– Théorèmes des valeurs initiales et finales
– Signaux et systèmes
– Systèmes rationnels en Z
– Z, Laplace et Euler
– Stabilité en Z
– Programmation
plan def
Définition
A toute suite x, on associe

∞
X
Zx(z) = x(n)z −n
0
(sous réserve d’existence)

Pourquoi ? ? ?
plan equ
Equations récurrentes
Parce que cela permet de transformer des équations récurrentes en équations algébriques
ordinaires sur lesquelles on peut « calculer normalement »
grâce à deux propriétés :
1. Linéarité :
Z(αx + βy) = αZx + βZy
2. Les décalages d’indices sont transformés en produits :

Soit x+ (n) = x(n + 1)
On a :
Z(x+ )(z) = z(Zx(z) − x(0))
plan exp
Démonstration
∞
X ∞
X
x+ (n)z −n = x(n + 1)z −n
0 0
∞
X ∞
X
x+ (n)z −n = z x(n + 1)z −(n+1)
0 0
∞
X ∞
X
x+ (n)z −n = z x(n)z −n
0 1
∞ ∞
!
X X
x+ (n)z −n = z x(n)z −n − x(0)
0 0
plan exp
Exemple
Equation récurrente de premier ordre, linéaire, à coefficients constants
y + = ay + bx
Z(y + )(z) = z(Zy(z) − y(0)) = aZy(z) + bZx(z)
(z − a)Zy(z) = bZx(z) + zy(0)
1
Zy(z) = (bZx(z) + zy(0))
z−a
L’équation récurrente a été « résolue » et la solution est une fraction rationnelle
plan exp
Fonctions puissance
Les fonctions puissance

Posons
Gk (n) = Cnk an−k
où on admet que
n < k ⇒ Cnk = 0
On a alors
z
ZGk (z) =
(z − a)k+1
plan exe
Démonstration
Par induction : k = 0
∞
X
n −n 1 z
a z = a =
0
1− z z−a
a
pourvu que | | < 1
z
plan exe
Démonstration
k+1
On veut calculer
∞
X
Cnk+1 an−k−1 z −n
k+1
On remarque que
∂ n−k
a = (n − k)an−k−1
∂a
et que
n−k k
Cnk+1 = Cn
k+1
Donc
∞ ∞
X 1 ∂ X k n−k −n
Cnk+1 an−k−1 z −n = Cn a z
k + 1 ∂a
k+1 k
plan exe
Démonstration
k+1
Donc
∞ ∞
X 1 ∂ X k n−k −n
Cnk+1 an−k−1 z −n = Cn a z
k + 1 ∂a
k+1 k
On applique l’hypothèse de récurrence

∞
X 1 ∂ z
Cnk+1 an−k−1 z −n =
k + 1 ∂a (z − a)k+1
k+1
Or
∂ z z
= (k + 1)
∂a (z − a)k+1 (z − a)k+2
Donc
∞
X z
Cnk+1 an−k−1 z −n =
0
(z − a)k+2
plan exe
Exemples de signaux
Un échelon : u(n) = 1
C’est le cas k = 0, a = 1
z
Zu(z) =
z−1
Une rampe : r(n) = n C’est le cas k = 1, a = 1

z
Zr(z) =
(z − 1)2
plan etat
Exemple de systèmes
Fibonnacci :
f (n + 2) = f (n + 1) + f (n), f (0) = f (1) = 1
On peut le réecrire :
f ++ (n) = f + (n) + f (n), f (0) = f (1) = 1
Zf ++ (z) = z(Zf + (z) − 1)
Zf + (z) = z(Zf (z) − 1)
z(z(Zf (z) − 1) − 1) = z(Zf (z) − 1) + Zf (z)
plan etat
Exemple de systèmes
Fibonnacci :
z(z(Zf (z) − 1) − 1) = z(Zf (z) − 1) + Zf (z)
On « résoud »
z 2 Zf (z) − z 2 − z = zZf (z) − z + Zf (z)
(z 2 − z − 1)Zf (z) = z 2
z2
Zf (z) = 2
z −z−1
plan etat
Résolution
Chercher les pôles (racines du dénominateur)
solution de l’équation du 2ème degré
z2 − z − 1 = 0
√ √
1+ 5 1− 5
z0 = z1 =
2 2
C’est le fameux nombre d’or aux propriétés magiques
plan etat
Résolution
Décomposition des fractions rationnelles en éléments simples :
z2 zA zB
= +
(z − z0 )(z − z1 ) z − z0 z − z1
On multiplie par z − z0
z(z − z0 ) A(z − z0 ) B(z − z0 )

= +
(z − z0 )(z − z1 ) z − z0 z − z1
z B(z − z0 )
=A+
(z − z1 ) z − z1
On fait z = z0
z0
=A
(z0 − z1 )
plan etat
Résolution
Décomposition des fractions rationnelles en éléments simples :
z2 zA zB
= +
(z − z0 )(z − z1 ) z − z0 z − z1
On multiplie par z − z1
z(z − z1 ) A(z − z1 ) B(z − z1 )

= +
(z − z0 )(z − z1 ) z − z0 z − z1
z A(z − z1 )
= +B
(z − z0 ) z − z0
On fait z = z1
z1
=B
(z1 − z0 )
plan etat
Résolution
z2
Zf (z) = 2
z −z−1
√ √
1+ 5 1− 5
z0 = z1 =
2 2
z0 z z1 z
Zf (z) = +
z0 − z1 z − z0 z1 − z0 z − z1
√ !n+1 √ !n+1
 
1 1+ 5 1− 5
f (n) = √  − 
5 2 2
Que c’est beau ! ! !
plan etat
Autres propriétés
Théorème de la valeur initiale :
x(0) = lim Zx(z)

z→∞
si les limites existent
Théorème de la valeur finale :
lim x(n) = lim (z − 1)Zx(z)

n→∞ z→1
si les limites existent
plan sys
Démonstration
Théorème de la valeur initial :
X
Zx(z) = x(0) + x(n)z −n
1,∞
Quand z tend vers ∞, z −n , n > 1 tend vers 0
plan sys
Démonstration
Théorème de la valeur initiale :
X X
−(n−1)
(z − 1)Zx(z) = x(n)z − x(n)z −n
0,∞ 0,∞
X X
−n
(z − 1)Zx(z) = x(n + 1)z − x(n)z −n
−1,∞ 0,∞
X X
−n
x(n + 1)z − x(n)z −n = x(N + 1)
−1,N 0,N
plan sys
Applications
Comment connaı̂tre la valeur finale de la réponse à un échelon d’un système de premier
ordre
bz
Zy(z) = Zx(z)
(z − a)
avec
z
Zx(z) =
(z − 1)
sans calculer la solution ?
Par le théorème de la valeur finale, il suffit de faire :
bz z b
lim (z − 1) =
z→1 z−az−1 1−a
plan sys
Systèmes et signaux, convolution
Question : quelle différence entre signaux et systèmes (linéaires stationnaires) ?
presque aucune !
exemple : système du premier ordre
z
Zy(z) = Zx(z)
z−a
Zy(z) = ZS(z)Zx(z)
Avec
z
ZS(z) =
z−a
Tous deux sont représentés par des transformées en Z :
– Comment expliquer cela ?
– Quelle est la vision signal d’un système ?
plan rat
Convolution discrète
Convolution de deux signaux x, y :
∞
X
(x ∗ y)(n) = x(m)y(n − m)
0
Théorème de convolution
Z(x ∗ y)(z) = Zx(z)Zy(z)
A tout signal discret correspond un système dont la sortie s’obtient en convolant l’entrée
avec le signal.
plan rat
Démonstration
!
X X
Z(x ∗ y)(z) = x(m)y(n − m) z −n
n=0,∞ m=0,∞
X X
Z(x ∗ y)(z) = x(m)y(n − m)z −m−(n−m)
n=0,∞ m=0,∞
Posons u = n − m
X X
Z(x ∗ y)(z) = x(m)y(u)z −m z −u
m=0,∞ u=0,∞
X X
−m
Z(x ∗ y)(z) = x(m)z y(u)z −u
m=0,∞ u=0,∞
Z(x ∗ y)(z) = Zx(z)Zy(z)
plan rat
Quel est le signal associé à un système ?
z
ZS(z) =
z−a
On a
ZY (z) = ZS(z)ZX(z)
ZS(z) est la transformée de la réponse du système au signal d’entrée δ de transformée

Zδ(z) = 1
ZS(z) est la fonction de transfert du système
Z −1 ZS(z) est réponse impulsionnelle du système
La sortie du système (linéaire stationnaire) s’obtient en convolant l’entrée avec la

réponse impulsionnelle du système
plan rat
Exemples
Opérateur unité
∞
X
Zδ(z) = δ(n)z −n = 1
0

 1 si n = 0
δ(n) =
 0 sinon
plan rat
Exemples
Intégration discrète
X
y(n) = x(n − m)
m=0,n
X
= s(m)x(n − m)
m=0,n
D’où
s(n) = 1
L’intégration discrète s’obtient en convolant avec l’échelon unité

La fonction de transfert correspondante est
z
Zu(z) =
z−1
plan rat
Diagrammes de blocs
Représentation graphique très populaire :
Réseau de boı̂tes et de fils :
Les boı̂tes sont des opérateurs (systèmes élémentaires) et des systèmes
Les fils sont les signaux qui sont transformés par les boı̂tes.
Exemple :
y+ = x
1
1 1
z
X Y
Unit Delay
plan rat
Des systèmes d’équations aux diagrammes
Un système
x+ = f (x, y, u)
y+ = g(x, y, u)
Construire f , g
x
u xp 1
y x
F
1
u
x
u yp 2
y y
G
plan rat
Un système
x+ = f (x, y, u)
y+ = g(x, y, u)
Retarder
x
1
u xp 1
z
y x
F Unit Delay
1
u
x
1
u yp 2
z
y y
G Unit Delay1
plan rat
Un système
x+ = f (x, y, u)
y+ = g(x, y, u)
Reboucler
x
1
u xp 1
z
y x
F Unit Delay
1
u
x
1
u yp 2
z
y y
G Unit Delay1
plan rat
Systèmes rationnels
N (z)
Forme générale : avec degré N ≤degré D.
D(z)
Pn i
a i z
Y (z) = Pn−1 0 X(z)
i
bi z + z n
0
n−1
X n
X
( bi z i + z n )Y (z) = ai z i X(z)
0 0
n
X n−1
X
z n Y (z) = ai z i X(z) − bi z i Y (z)
0 0
n
X n−1
X
Y (z) = ai z i−n X(z) − bi z i−n Y (z)
0 0
n−1
X
Y (z) = an X(z) + z i−n (ai X(z) − bi Y (z))
0
plan euler
n−1
X
Y (z) = an X(z) + z i−n (ai X(z) − bi Y (z))
0
Posons :
U0 (z) = z −1 (a0 X(z) − b0 Y (z))

...
Ui+1 (z) = z −1 (ai+1 X(z) − bi+1 Y (z) + Ui (z))
...
Y (z) = an X(z) + Un (z)
Il est facile de vérifier algébriquement que ces deux expressions sont égales.
plan euler
U0 (z) = z −1 (a0 X(z) − b0 Y (z))

...
Ui+1 (z) = z −1 (ai+1 X(z) − bi+1 Y (z) + Ui (z))
...
Y (z) = an X(z) + Un (z)
Conclusion : pour simuler un système rationnel d’ordre n, il suffit d’utiliser n retards.
plan euler
Exemple :
1
x
a0 a1 a2
a2 z 2 + a1 z + a0 1 1
1
z 2 + b1 z + b0 z u0 z u1
y
Unit Delay Unit Delay1
b0 b1
plan euler
1
x
a0 a1 a2
1 1
1
z u0 z u1
y
b0 b1
U0 (z) = z −1 (a0 X(z) − b0 Y (z))

U1 (z) = z −1 (a1 X(z) − b1 Y (z) + U0 (z))
Y (z) = a2 X(z) + U1 (z)
Y (z) = a2 X(z) + z −1 (a1 X(z) − b1 Y (z) + z −1 (a0 X(z) − b0 Y (z)))
Y (z) = a2 X(z) + z −1 a1 X(z) + z −2 a0 X(z) − z −1 b1 Y (z) − z −2 b0 Y (z)
z 2 Y (z) = a2 z 2 X(z) + a1 zX(z) + a0 X(z) − b1 zY (z) − b0 Y (z)
plan euler
Z, Laplace,. . .
1
est l’opérateur retard unité
z
Si on choisit un pas d’échantillonnage T on peut donc écrire :
1
= e−sT
z
On a alors l’approximation du premier ordre (développement limité)
e−sT ≈ 1 − sT
Donc, au premier ordre,
1
1 − sT ≈
z
1 z−1
sT ≈ 1− =
z z
z−1
s ≈
zT
plan stab
Z, Laplace, et Euler
z−1
s≈
zT
Et Euler ?
Appliquons à une fonction de transfert H :
z−1
H(s) ≈ H( )
zT
On est passé d’un système continu à un système échantillonné, implantable sur
calculateur
Cela correspond à la méthode d’Euler :
z−1
sx(s) ≈ x(z)
zT
x(n) − x(n − 1)
x0 (t) ≈
T
plan stab
Application
2
bruit
1 erreur commande commande sortie 1

sortie desiree sortie reelle
Pilote Systeme
6.8s + 4 1
P = S=
s + 3.8 s2
10
−10
−1
0 20 40 60 80 100
Time offset: 0
plan stab
Application
Choix de la période :
0.1
On prend T = ≈ 0.025
3.8
Transformation du pilote
0 6.8 z−1 +4
P = z−1zT
zT + 3.8
6.9z − 6.8
P0 =
1.1z − 1
On essaie
plan stab
Application
2
bruit

Pilote Systeme
6.9z − 6.8 1
P = S= 2
1.1z − 1 s
10
−10
−1
0 20 40 60 80 100
Time offset: 0
plan stab
Application
2
bruit

Pilote Systeme
6.9z − 6.8 1
P = S= 2
1.1z − 1 s
On a donc su :
– calculer un pilote continu donnant de bons résultats
– le transformer en pilote numérique qui donne d’aussi bons résultats
plan stab
Stabilité en Z
Un sujet très important, une propriété globale
– Stabilité
– Systèmes rationnels
plan prog
Stabilité
Un système déplacé d’un point d’équilibre reconverge-t-il vers celui-ci ou diverge-t-il ?
Exemple : Un système stable
z
z−0.5
Scope
Pulse Discrete
Generator Transfer Fcn
plan prog
Stabilité
Exemple : Un système stable
1
0.9
0.8
0.7
0.6
0.5
0.4
0.3
0.2
z 0.1
z−0.5 0
Scope
0 1 2 3 4 5 6 7 8 9 10
Pulse Discrete
Time offset: 0
plan prog
Stabilité
Exemple : Un système instable
z
z−2
Scope
Pulse Discrete
plan prog
Stabilité
Exemple : Un système instable
600
500
400
300
200
100
z
z−2 0
0 1 2 3 4 5 6 7 8 9 10
Scope
Pulse Discrete
Time offset: 0
Pourquoi ?
plan prog
Il suffit de regarder les pôles (racines du dénominateur) de la fonction de transfert dans le
plan complexe :
Si les pôles sont tous de module inférieur à 1 le système est dit asymptotiquement stable
en effet la réponse impulsionnelle sera une somme de termes de type
Cnk an−k
avec a en module inférieur à 1. Tous ces termes tendent vers 0 quand n tend vers l’infini.
z
Exemple :
z − 0.5
il y a un seul pôle de valeur absolue 0.5 < 1 : le système est asymptotiquement stable
plan prog
Programmation
Les schémas-bloc discrets (échantillonnés) s’appliquent aussi aux opérations non

linéaires (tests, multiplication entre signaux,...)
Ils sont la base des systèmes de compilation (génération automatique de code) :

– Simulink Real-Time Workshop (Matlab)
– Scicos (Inria)
– Lustre/Scade (Verimag/Esterel-Tecnologies)
plan prog
Développement par modèles
Cette possibilité est à la base de la méthode de développement par modèles

(Model-Based Development)
– Conception et validation sur modèles (Simulink, Scicos)
– Déploiement automatique par compilation
Cette méthode évite la phase de codage manuel, source d’erreur.

Elle garantit que ce qu’on a validé est ce qu’on exécute.
La mise en œuvre de cette méthode place le développement des systèmes
d’automatismes et de traitement de signal à la pointe de l’informatique :
Dans ce domaine, l’informatique est véritablement passée de l’artisanat à l’industrie
plan prog
Compilation
1
x
a0 a1 a2
1 1
1
z u0 z u1
y
b0 b1
U0 (z) = z −1 (a0 X(z) − b0 Y (z))

U1 (z) = z −1 (a1 X(z) − b1 Y (z) + U0 (z))
Y (z) = a2 X(z) + U1 (z)
plan prog
Compilation générique
U0 (z) = z −1 (a0 X(z) − b0 Y (z))

U1 (z) = z −1 (a1 X(z) − b1 Y (z) + U0 (z))
Y (z) = a2 X(z) + U1 (z)
Associer deux variables pour chaque variable d’état

– la valeur avant
– la valeur après
plan prog
U0 (z) = z −1 (a0 X(z) − b0 Y (z))

U1 (z) = z −1 (a1 X(z) − b1 Y (z) + U0 (z))
Y (z) = a2 X(z) + U1 (z)
class deuxième_ordre {
private :
float a0, a1, a2, b0, b1;
float u0, u1 ;
public :
deuxième_ordre(float a0, a1, a2, b0, b1;
float u0, u1) {....}
float compute(float x) {
...
return y;
}}
plan prog
plan prog
U0 (z) = z −1 (a0 X(z) − b0 Y (z))

U1 (z) = z −1 (a1 X(z) − b1 Y (z) + U0 (z))
Y (z) = a2 X(z) + U1 (z)
float compute(float x) {
float y, up0, up1;
y = a2*x + u1 ;
up0 = a0*x - b0*y ;
up1 = a1*x - b1*y + u0;
u0 = up0;
u1 = up1;
return y;
}
}
plan prog
Optimisations
Nombreuses possibilités grâce à la sémantique équationnelle des schémas-bloc.
– éliminer les buffers non utilisés
– supprimer des buffers en réordonnant les équations
– transformer le source grâce à la commutation des z −1
plan prog
Suppression de buffers
float compute(float x) { float compute(float x) {

float y, up0, up1; float y, up0;
y = a2*x + u1 ; y = a2*x + u1 ;
up0 = a0*x - b0*y ; up0 = a0*x - b0*y ;
up1 = a1*x - b1*y + u0; u1 = a1*x - b1*y + u0;
u0 = up0; u0 = up0;
u1 = up1; return y;
return y; }
} }
}
plan prog
Réordonner les instructions
float compute(float x) { float compute(float x) {

float y, up0; float y;
y = a2*x + u1 ; y = a2*x + u1 ;
up0 = a0*x - b0*y ; u1 = a1*x - b1*y + u0;
u1 = a1*x - b1*y + u0; u0 = a0*x - b0*y ;
u0 = up0 ; return y;
return y; }
} }
}
plan prog
Commutation des z −1
Grâce à la propriété :
Si f est une fonction statique (ne comportant pas d’ópérateur z),
zf (x, y) = f (zx, zy)
C’est cette propriété qui nous a permis de réduire le nombre de retards dans le deuxième
ordre.
plan prog

La Transform Ee en Z: Plan Def Plan Def Plan Def

Hochgeladen von

Dokumentinformationen

Originaltitel

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

La Transform Ee en Z: Plan Def Plan Def Plan Def

Hochgeladen von

Copyright:

Verfügbare Formate

La transformée en Z

A toute suite x, on associe

(sous réserve d’existence)

Z(αx + βy) = αZx + βZy

2. Les décalages d’indices sont transformés en produits :

Z(y + )(z) = z(Zy(z) − y(0)) = aZy(z) + bZx(z)

(z − a)Zy(z) = bZx(z) + zy(0)

Les fonctions puissance

où on admet que

On applique l’hypothèse de récurrence

Une rampe : r(n) = n C’est le cas k = 1, a = 1

f (n + 2) = f (n + 1) + f (n), f (0) = f (1) = 1

f ++ (n) = f + (n) + f (n), f (0) = f (1) = 1

Zf ++ (z) = z(Zf + (z) − 1)

Zf + (z) = z(Zf (z) − 1)

z(z(Zf (z) − 1) − 1) = z(Zf (z) − 1) + Zf (z)

z(z(Zf (z) − 1) − 1) = z(Zf (z) − 1) + Zf (z)

z 2 Zf (z) − z 2 − z = zZf (z) − z + Zf (z)

C’est le fameux nombre d’or aux propriétés magiques

z(z − z0 ) A(z − z0 ) B(z − z0 )

z(z − z1 ) A(z − z1 ) B(z − z1 )

Que c’est beau ! ! !

x(0) = lim Zx(z)

si les limites existent

Théorème de la valeur finale :

lim x(n) = lim (z − 1)Zx(z)

si les limites existent

Quand z tend vers ∞, z −n , n > 1 tend vers 0

Par le théorème de la valeur finale, il suffit de faire :

Convolution de deux signaux x, y :

Z(x ∗ y)(z) = Zx(z)Zy(z)

Z(x ∗ y)(z) = Zx(z)Zy(z)

ZS(z) est la transformée de la réponse du système au signal d’entrée δ de transformée

ZS(z) est la fonction de transfert du système

Z −1 ZS(z) est réponse impulsionnelle du système

La sortie du système (linéaire stationnaire) s’obtient en convolant l’entrée avec la

L’intégration discrète s’obtient en convolant avec l’échelon unité

U0 (z) = z −1 (a0 X(z) − b0 Y (z))

U0 (z) = z −1 (a0 X(z) − b0 Y (z))

Conclusion : pour simuler un système rationnel d’ordre n, il suffit d’utiliser n retards.

U0 (z) = z −1 (a0 X(z) − b0 Y (z))

Donc, au premier ordre,

1 erreur commande commande sortie 1

1 erreur commande commande sortie 1

1 erreur commande commande sortie 1

– calculer un pilote continu donnant de bons résultats

– le transformer en pilote numérique qui donne d’aussi bons résultats

Un sujet très important, une propriété globale

en effet la réponse impulsionnelle sera une somme de termes de type

Les schémas-bloc discrets (échantillonnés) s’appliquent aussi aux opérations non

Ils sont la base des systèmes de compilation (génération automatique de code) :

Cette possibilité est à la base de la méthode de développement par modèles

Cette méthode évite la phase de codage manuel, source d’erreur.

U0 (z) = z −1 (a0 X(z) − b0 Y (z))

U0 (z) = z −1 (a0 X(z) − b0 Y (z))

Associer deux variables pour chaque variable d’état

U0 (z) = z −1 (a0 X(z) − b0 Y (z))

U0 (z) = z −1 (a0 X(z) − b0 Y (z))

Nombreuses possibilités grâce à la sémantique équationnelle des schémas-bloc.

– éliminer les buffers non utilisés

– supprimer des buffers en réordonnant les équations

– transformer le source grâce à la commutation des z −1

float compute(float x) { float compute(float x) {