Discrétisation pour systèmes numériques temps réel

1. Contexte : Automatique numérique

En automatique numérique, un système continu doit être implémenté sur un calculateur qui fonctionne par échantillonnage :

On mesure les grandeurs à des instants discrets : \(t_k = k \cdot T_e\)
On calcule la commande avec les valeurs actuelles et passées
On ne connaît pas les valeurs futures

Objectif : Transformer une équation différentielle en équation de récurrence calculable en temps réel.

2. Méthode d'Euler explicite (temps réel)

Principe

Pour une équation différentielle :

\[\frac{dx}{dt} = f(t, x, u)\]

On approxime la dérivée par :

\[\frac{dx}{dt}\bigg|_{t=t_k} \approx \frac{x_{k+1} - x_k}{T_e}\]

Ce qui donne l'équation de récurrence :

\[\boxed{x_{k+1} = x_k + T_e \cdot f(t_k, x_k, u_k)}\]

✅ Calculable en temps réel : on utilise uniquement \(x_k\) et \(u_k\) (valeurs connues)

Exemple pratique : Filtre RC

Équation différentielle d'un filtre passe-bas :

\[RC\frac{dv_s}{dt} + v_s = v_e\]

Avec \(\tau = RC\), on isole la dérivée :

\[\frac{dv_s}{dt} = \frac{1}{\tau}(v_e - v_s)\]

Application d'Euler explicite :

\[v_{s,k+1} = v_{s,k} + \frac{T_e}{\tau}(v_{e,k} - v_{s,k})\]

\[\boxed{v_{s,k+1} = v_{s,k}\left(1 - \frac{T_e}{\tau}\right) + \frac{T_e}{\tau}v_{e,k}}\]

Implémentation C/Python :

// C
float vs_k = 0;  // État initial
float Te = 0.001;  // 1ms
float tau = 0.1;   // 100ms

// Boucle temps réel
vs_k = vs_k * (1 - Te/tau) + (Te/tau) * ve_k;

# Python
vs_k = 0
Te = 0.001
tau = 0.1

# Boucle temps réel
vs_k = vs_k * (1 - Te/tau) + (Te/tau) * ve_k

Condition de stabilité

Analyse du pôle :

Le système discrétisé a pour pôle :

\[p = 1 - \frac{T_e}{\tau}\]

Un système discret est stable si tous ses pôles sont à l'intérieur du cercle unité :

\[|p| < 1\]

Application :

\[\left|1 - \frac{T_e}{\tau}\right| < 1\]

Cela donne deux conditions :

\(1 - \frac{T_e}{\tau} < 1 \Rightarrow T_e > 0\) ✅ (toujours vrai)
\(1 - \frac{T_e}{\tau} > -1 \Rightarrow \frac{T_e}{\tau} < 2\)

Condition de stabilité :

\[\boxed{T_e < 2\tau}\]

Interprétation physique :

Si \(T_e \geq 2\tau\) : - Le pôle devient \(p \leq -1\) - Le système oscille et diverge - La discrétisation introduit une instabilité numérique qui n'existe pas dans le système continu !

Exemple : Si \(\tau = 0.1s\) et \(T_e = 0.25s\) : \(\(p = 1 - \frac{0.25}{0.1} = -1.5\)\) \(\(|p| = 1.5 > 1\)\) ❌ Instable !

En pratique : - Pour la stabilité : \(T_e < 2\tau\) - Pour la précision : \(T_e \leq \frac{\tau}{10}\)

3. Transformée en Z

Définition

La transformée en Z permet d'analyser les systèmes discrets comme Laplace pour les systèmes continus.

Pour un signal discret \(x[k]\) :

\[X(z) = \sum_{k=0}^{\infty} x[k] \cdot z^{-k}\]

Propriétés essentielles

Domaine temporel	Domaine en Z
\(x[k-1]\)	\(z^{-1}X(z)\)
\(x[k+1]\)	\(zX(z) - zx[0]\)

De l'équation de récurrence à la fonction de transfert

Reprenons l'équation du filtre RC :

\[v_{s,k+1} = a \cdot v_{s,k} + b \cdot v_{e,k}\]

avec \(a = 1 - \frac{T_e}{\tau}\) et \(b = \frac{T_e}{\tau}\)

Transformée en Z :

\[zV_s(z) = aV_s(z) + bV_e(z)\]

\[V_s(z)(z - a) = bV_e(z)\]

Fonction de transfert :

\[H(z) = \frac{V_s(z)}{V_e(z)} = \frac{b}{z - a}\]

Sous forme normalisée (division par \(z\)) :

\[\boxed{H(z) = \frac{b \cdot z^{-1}}{1 - a \cdot z^{-1}}}\]

Analyse de stabilité

Le système est stable si le pôle \(p = a\) est à l'intérieur du cercle unité :

\[|a| < 1 \Rightarrow \left|1 - \frac{T_e}{\tau}\right| < 1\]

Ce qui donne : \(0 < T_e < 2\tau\)

4. De la fonction de transfert à l'équation de récurrence

Méthode

Soit une fonction de transfert :

\[H(z) = \frac{b_0 + b_1z^{-1}}{1 + a_1z^{-1}}\]

Étape 1 : Multiplier par le dénominateur

\[Y(z)(1 + a_1z^{-1}) = U(z)(b_0 + b_1z^{-1})\]

Étape 2 : Développer

\[Y(z) + a_1z^{-1}Y(z) = b_0U(z) + b_1z^{-1}U(z)\]

Étape 3 : Transformée inverse (utiliser \(z^{-1}Y(z) \leftrightarrow y[k-1]\))

\[\boxed{y_k = -a_1 y_{k-1} + b_0 u_k + b_1 u_{k-1}}\]

✅ Implémentable en temps réel : on utilise \(y_{k-1}\), \(u_k\) et \(u_{k-1}\) (valeurs connues)

5. Exemple complet : Correcteur PI

Équation continue

\[u(t) = K_p \cdot e(t) + K_i \int_0^t e(\tau) d\tau\]

Discrétisation

L'intégrale est approximée par la somme :

\[\int_0^{t_k} e(\tau) d\tau \approx T_e \sum_{i=0}^{k} e_i\]

Équation de récurrence :

\[u_k = K_p \cdot e_k + K_i \cdot T_e \cdot S_k\]

avec \(S_k = S_{k-1} + e_k\) (somme cumulée)

Implémentation :

float Kp = 1.0, Ki = 0.5, Te = 0.001;
float S = 0;  // Somme cumulée

// Boucle temps réel
float e_k = consigne - mesure;
S = S + e_k;
float u_k = Kp * e_k + Ki * Te * S;

Fonction de transfert en Z

\[H(z) = K_p + K_i T_e \frac{z}{z-1}\]

\[H(z) = \frac{K_p(z-1) + K_i T_e \cdot z}{z-1}\]

\[\boxed{H(z) = \frac{(K_p + K_i T_e)z - K_p}{z - 1}}\]

6. Méthodes alternatives (aperçu)

Tustin (trapèzes)

Meilleure approximation que Euler, mais plus complexe :

\[\frac{dx}{dt} \approx \frac{x_{k+1} - x_k}{T_e} = \frac{f(x_k, u_k) + f(x_{k+1}, u_{k+1})}{2}\]

Nécessite de résoudre une équation (moins direct).

Runge-Kutta d'ordre 2 (RK2)

Plus précis qu'Euler, utilisable en temps réel :

\[k_1 = f(x_k, u_k)\]

\[k_2 = f\left(x_k + \frac{T_e}{2}k_1, u_k\right)\]

\[x_{k+1} = x_k + T_e \cdot k_2\]

Coût : 2 évaluations de la fonction au lieu d'1.

7. Résumé pratique

Pour l'implémentation temps réel

Partir de l'équation différentielle
Appliquer Euler explicite : \(\frac{dx}{dt} \approx \frac{x_{k+1} - x_k}{T_e}\)
Obtenir l'équation de récurrence : \(x_{k+1} = f(x_k, u_k)\)
Vérifier la stabilité : \(T_e < 2\tau\)
Implémenter en C/Python/etc.

Pour l'analyse

Partir de l'équation de récurrence
Appliquer la transformée en Z
Obtenir \(H(z)\)
Analyser : pôles, stabilité, réponse fréquentielle

Choix de \(T_e\)

Stabilité : \(T_e < 2\tau\)
Précision : \(T_e \leq \frac{\tau}{10}\)
Shannon : \(T_e \leq \frac{1}{2f_{max}}\)

En pratique : prendre le plus contraignant.

8. Applications

Filtrage numérique (anti-repliement, passe-bas, etc.)
Correcteurs PID numériques
Observateurs d'état
Commande de moteurs
Régulation de température
Traitement du signal en temps réel