troyesGEII - Contributions de l’utilisateur [fr]

Cours:Elen4 TNS TP eval1

2026-06-02T14:04:15Z

Fredmn :

<accesscontrol>Acces:Prof</accesscontrol>

{| class="wikitable"
|-
|
* Sauf spécification, les traitements pourront se faire indifférement dans Gnuradio, dans Python/Jupyter ou dans les deux.

* Faire valider les solutions de chaque question auprès de l'enseignant.

* La note finale sera ramenée sur 20 points.
|}

{{q| (3 points) 1)}} Construire un signal ''x(n)'' comme une sinuisoïde de fréquence 500Hz et d'amplitude 3, la fréquence d'échantillonnage étant de 32kHz. Tracer son graphe temporel dans Gnuradio.

{{q| (3 points) 2)}} Tracer son graphe temporel dans Python/Jupyter.

{{q| (3 points) 3)}} Ajouter à ''x(n)'' un bruit gaussien d'amplitude 1 puis tracer le graphe temporel de ''x(n)'' et son graphe fréquentiel (module).

{{q| (3 points) 4)}} Proposer un filtre qui permettrait de réduire ce bruit. L'implémenter dans Python/Jupyter ou dans Gnuradio.

{{q| (3 points) 5)}} Construire un signal ''x2(n) = s1(n) + s2(n) + s3(n) + b(n)'', avec
* ''s1(n)'' : sinusoïde de fréquence 500Hz d'amplitude 3
* ''s2(n)'' : sinusoïde de fréquence 3000Hz d'amplitude 3
* ''s3(n)'' : sinusoïde de fréquence 5000Hz, d'amplitude 2
* ''b(n)'' : bruit gaussien d'amplitude 1
{{Todos| Tracer les graphes temporel et fréquentiel de ''x2(n)''.}}

{{q| (3 points) 6)}} On propose d'appliquer un filtre dont voici la fonction de transfert :
{{FxT | H(z) |
0.0032 + 0.0163 z-1 + 0.0327 z-2 + 0.0327 z-3 + 0.0163 z-4 + 0.0032 z-5
|
1 - 2.4744 z-1 + 2.8110 z-2 - 1.7037 z-3 + 0.5444 z-4 - 0.07231 z-5}}
À toutes fins utiles, voici les coefficients du numérateur et du dénominateur, avec plus de précision et sous forme de liste :
{|
|-
| Numérateur || : [0.0032792, 0.016396, 0.032792, 0.032792, 0.016396, 0.0032792]
|-
| Dénominateur || : [1, -2.4744, 2.811, -1.7038, 0.54443, -0.072316]
|}

{{Todos| Montrer expérimentalement que ce filtre est stable.}}

{{q| (3 points) 7)}} Tracer la réponse fréquentielle du filtre et indiquer sa nature et le caractériser.

{{q| (3 points) 8)}} Implémenter ce filtre, en l'appliquant au signal ''x2(n)''. Vérifier le bon comportement du filtre.

{{q| (3 points) 9)}} On souhaite ne conserver que la composante à 3kHz du signal ''x2(n)'', proposer une chaine complète de traitements.

Cours:Elen4 TNS TP TpsReel

2026-06-01T13:03:33Z

Fredmn : /* PID numérique avec un filtre numérique linéaire */

[[Cours:Elen4_TNS|{{Rouge|'''Retour à la page du cours'''}}]]

<center>
'''<big>TP6 - Temps réel : bloc Gnuradio en Python / démodulation / PID Numérique</big>'''
</center>

Le but de ce TP est double :
* réaliser des implémentations temps réel de filtre IIR en créant un bloc Gnuradio qui execute un traitement codé en Python
* et étudier l'implémentation d'un PID numérique sous forme d'un filtre IIR.

Dans les deux cas, un système temps réel sera considéré :
* à intervalles de temps (réguliers ou non), une valeur ''x(n)'' rentre dans le système
* le travail consiste à calculer ''y(n)'' avec l'équation au différences du filtre, à partir de la valeur ''x(n)'' et de ses versions précédentes ''x(n-1)'' et ''x(n-2)'' (et aussi ''y(n-1)'', ''y(n-2)'') qu'il est donc nécessaire de stocker.
* La notion de ''temps réel'' implique que ''y(n)'' doit être calculer avant qu'une nouvelle valeurs de ''x(n)'' ne rentre dans le système.

=== Bloc Gnuradio en Python ===

Nous allons implémenter un filtre IIR dans gnuradio, en écrivant le traitement dans un bloc Python.

==== Filtre moyenneur====

{{q| a)}} Dans un premier temps, prendre connaissance du tutoriel suivant : [https://wiki.gnuradio.org/index.php?title=Creating_Your_First_Block wiki Gnuradio - ''Creating Your First Block'']

{{q| b)}} Nous allons écrire un filtre simple, qui implémente un simple moyenneur :
<source lang="Python">

import numpy as np
from gnuradio import gr

class blk(gr.sync_block):
def __init__(self): # Pas de paramètres
gr.sync_block.__init__(
self,
name="Filtre moyenneur",
in_sig=[np.float32],
out_sig=[np.float32]
)
self.xn1 = 0 # initialisation d'un attribut pour stocker x(n-1)

def work(self, input_items, output_items):
xn = input_items[0][0] # On ne "consomme" qu'un seul échantillon en entrée
yn = (xn + self.xn1) / 2
self.xn1 = xn
output_items[0][0] = yn # On ne produit donc également qu'un seul échantillon en sortie
return 1 # On retourne le nombre de valeurs consomées
</source>

==== Filtre IIR : démodulation ====

En reprenant le signal modulé en amplitude et la fonction de transfert du filtre passe-bas du TP précédent :

* Obtenir l'équation aux différence du filtre, ''ie'' écrire ''y(n)='' en fonction de ''x(n)'', ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.
* Créer un nouveau bloc Python dans le module <code>monModule</code> :
** de type <code>sync</code>
** une entrée en <code>np.float32</code>
** une sortie en <code>np.float32</code>
* Écrire le code permettant d'obtenir ''y(n)'' dans la méthode <code>work()</code> :
** ''x(n)'' est donné par <code>in[0][0]</code>
** il sera nécessaire de stocker dans des '''attributs''' les valeurs de ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.

{{q| a)}} Réaliser cette implémentation du passe-bas et contrôler que la démodulation est identique à celle obtenue au [[Cours:Elen4_TNS_TP_TraitAudioEtDemodulation|TP 5]].

{{q| b)}} Modifier votre code pour implémenter le filtre complet de démodulation.

=== Approximation de PID par filtre numérique linéaire ===

Cette partie sera travaillée dans un notebook Jupyter.

==== Rappels PID ====

* Principe

[[Fichier:PIDprincipe.png|400px]]

[[Fichier:PIDdetail.png|400px]]

* Définition mathématique, la sortie du controleur PID ''u(t)'' est donnée par:

[[Fichier:EqPID.png|400px]]

==== PID numérique "classique" ====

On considère que le temps est discrétisé : ''t = n.''d''t'' où d''t'' est l'intervalle de temps entre deux valeurs.

* En approximant grossièrement l'intégrale et la dérivée [[Fichier:PIDderivative.png|400px]] [[Fichier:PIDintegral.png|400px]]
** La dérivée est calculée par ''D = (e(n)-e(n-1))/''d''t''
** L'intégrale est approximée en cumulant progressivement : ''I = I + e(n).''d''t''
C'est ainsi que vous avez implémenté vos PID jusqu'ici.

Voici un notebook exemple à explorer sur deux modélisations : asservissement de 1) température et de 2) position ''z'' d'un drone : [[Media:TNS TP6 starter.ipynb.zip|TNS_TP6_starter.ipynb.zip]]

{{q | a)}} ''Ki = Kd = 0'' => chercher le meilleur ''Kp'' => erreur statique.

{{q | b)}} ''Kd = 0'' => l'introduction du terme integral permet de corriger cette erreur statique.

{{q | c)}} Le terme dérivatif n'est pas nécessaire pour la température

{{q | d)}} Mais l'est pour asservir la position ''z'' du drone.

==== PID numérique avec un filtre numérique linéaire ====

Nous allons reprendre le PID, par sa fonction de transfert qui exprime un filtre linéaire continu, et construire un filtre linéaire numérique qui l'approxime.

{{q | a)}} Cherchons la fonction de transfert du filtre continu d'un PID.
 En partant de l'équation différentielle
 [[Fichier:EqPID.png|500px]]
 On applique la transformée de Laplace (dérivée => multiplication par ''s'' ; intégrale => division par ''s'') :
 [[Fichier:eqFxTransfertPID.png|130]]
 Le terme dérivatif étant très sensible au bruit, on lui applique généralement un filtre passe bas (''w0/(w0+s)'') :
 [[Fichier:eqFxTransfertPIDetPB.png|130]]

{{q | b)}} Il s'agit maintenant de transformer la variable ''s'' en une variable ''z'' :
* par transformée bilinéaire : ''s = (2/Ts)*(z-1)/(z+1)'' (voir le cours)
* ou par ''backward euler'' (version un peu plus simple) : ''s = (z-1)/(Ts*z)''.

En injectant le changement de variable dans la fonction de transfert ''H(s)'', obtenir la fonction de transfert ''H(z)'' du filtre linéaire numérique correspondant (dans un premier temps avec ''backward Euler'') :
* soit "à la main"
* ou en exploitant [https://www.sympy.org/en/index.html Sympy] (calcul symbolique). Un début :
<source lang="Python">
import sympy
from sympy import symbols, Poly, Eq
Ki, Kd, Kp, N, Ts, z, s = symbols('K_i K_d K_p N T_s z s')

Hs = Kp + (Ki/s) + Kd*s * (N/(N+s))

Hz = Hs.subs(s, (z-1)/(Ts*z))

# ...
</source>
Dans les deux cas, il sera nécessaire d'obtenir ''H(z)'' sous la forme d'une fraction rationnelle.

{{q | c)}} Implémentation du filtre : classe <code>FilterController</code> dont voici le squelette
<source lang="Python">
class FilterController:

def mfilter(self, e):
xn = e
# TODO
return yn

def __init__(self, K_p, K_i, K_d, N, T_s, set_point):
self.set_point = set_point
# A COMPLÉTER

def get_control(self, measurement, dt):
e = self.set_point - measurement
u = self.mfilter(e)
return u
</source>
{{q | d)}} Appliquer ce contrôleur à la simulation d'asservissement de drone et vérifier qu'un comportement proche de celui de la partie précédente (PID numérique "classique") est obtenu.

{{q | e)}} Implémenter le filtre obtenu à l'aide de la transformée bilinéaire.

Cours:Elen4 TNS TP TpsReel

2026-06-01T13:00:58Z

Fredmn : /* PID numérique avec un filtre numérique linéaire */

[[Cours:Elen4_TNS|{{Rouge|'''Retour à la page du cours'''}}]]

<center>
'''<big>TP6 - Temps réel : bloc Gnuradio en Python / démodulation / PID Numérique</big>'''
</center>

Le but de ce TP est double :
* réaliser des implémentations temps réel de filtre IIR en créant un bloc Gnuradio qui execute un traitement codé en Python
* et étudier l'implémentation d'un PID numérique sous forme d'un filtre IIR.

Dans les deux cas, un système temps réel sera considéré :
* à intervalles de temps (réguliers ou non), une valeur ''x(n)'' rentre dans le système
* le travail consiste à calculer ''y(n)'' avec l'équation au différences du filtre, à partir de la valeur ''x(n)'' et de ses versions précédentes ''x(n-1)'' et ''x(n-2)'' (et aussi ''y(n-1)'', ''y(n-2)'') qu'il est donc nécessaire de stocker.
* La notion de ''temps réel'' implique que ''y(n)'' doit être calculer avant qu'une nouvelle valeurs de ''x(n)'' ne rentre dans le système.

=== Bloc Gnuradio en Python ===

Nous allons implémenter un filtre IIR dans gnuradio, en écrivant le traitement dans un bloc Python.

==== Filtre moyenneur====

{{q| a)}} Dans un premier temps, prendre connaissance du tutoriel suivant : [https://wiki.gnuradio.org/index.php?title=Creating_Your_First_Block wiki Gnuradio - ''Creating Your First Block'']

{{q| b)}} Nous allons écrire un filtre simple, qui implémente un simple moyenneur :
<source lang="Python">

import numpy as np
from gnuradio import gr

class blk(gr.sync_block):
def __init__(self): # Pas de paramètres
gr.sync_block.__init__(
self,
name="Filtre moyenneur",
in_sig=[np.float32],
out_sig=[np.float32]
)
self.xn1 = 0 # initialisation d'un attribut pour stocker x(n-1)

def work(self, input_items, output_items):
xn = input_items[0][0] # On ne "consomme" qu'un seul échantillon en entrée
yn = (xn + self.xn1) / 2
self.xn1 = xn
output_items[0][0] = yn # On ne produit donc également qu'un seul échantillon en sortie
return 1 # On retourne le nombre de valeurs consomées
</source>

==== Filtre IIR : démodulation ====

En reprenant le signal modulé en amplitude et la fonction de transfert du filtre passe-bas du TP précédent :

* Obtenir l'équation aux différence du filtre, ''ie'' écrire ''y(n)='' en fonction de ''x(n)'', ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.
* Créer un nouveau bloc Python dans le module <code>monModule</code> :
** de type <code>sync</code>
** une entrée en <code>np.float32</code>
** une sortie en <code>np.float32</code>
* Écrire le code permettant d'obtenir ''y(n)'' dans la méthode <code>work()</code> :
** ''x(n)'' est donné par <code>in[0][0]</code>
** il sera nécessaire de stocker dans des '''attributs''' les valeurs de ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.

{{q| a)}} Réaliser cette implémentation du passe-bas et contrôler que la démodulation est identique à celle obtenue au [[Cours:Elen4_TNS_TP_TraitAudioEtDemodulation|TP 5]].

{{q| b)}} Modifier votre code pour implémenter le filtre complet de démodulation.

=== Approximation de PID par filtre numérique linéaire ===

Cette partie sera travaillée dans un notebook Jupyter.

==== Rappels PID ====

* Principe

[[Fichier:PIDprincipe.png|400px]]

[[Fichier:PIDdetail.png|400px]]

* Définition mathématique, la sortie du controleur PID ''u(t)'' est donnée par:

[[Fichier:EqPID.png|400px]]

==== PID numérique "classique" ====

On considère que le temps est discrétisé : ''t = n.''d''t'' où d''t'' est l'intervalle de temps entre deux valeurs.

* En approximant grossièrement l'intégrale et la dérivée [[Fichier:PIDderivative.png|400px]] [[Fichier:PIDintegral.png|400px]]
** La dérivée est calculée par ''D = (e(n)-e(n-1))/''d''t''
** L'intégrale est approximée en cumulant progressivement : ''I = I + e(n).''d''t''
C'est ainsi que vous avez implémenté vos PID jusqu'ici.

Voici un notebook exemple à explorer sur deux modélisations : asservissement de 1) température et de 2) position ''z'' d'un drone : [[Media:TNS TP6 starter.ipynb.zip|TNS_TP6_starter.ipynb.zip]]

{{q | a)}} ''Ki = Kd = 0'' => chercher le meilleur ''Kp'' => erreur statique.

{{q | b)}} ''Kd = 0'' => l'introduction du terme integral permet de corriger cette erreur statique.

{{q | c)}} Le terme dérivatif n'est pas nécessaire pour la température

{{q | d)}} Mais l'est pour asservir la position ''z'' du drone.

==== PID numérique avec un filtre numérique linéaire ====

Nous allons reprendre le PID, par sa fonction de transfert qui exprime un filtre linéaire continu, et construire un filtre linéaire numérique qui l'approxime.

{{q | a)}} Cherchons la fonction de transfert du filtre continu d'un PID.
 En partant de l'équation différentielle
 [[Fichier:EqPID.png|500px]]
 On applique la transformée de Laplace (dérivée => multiplication par ''s'' ; intégrale => division par ''s'') :
 [[Fichier:eqFxTransfertPID.png|130]]
 Le terme dérivatif étant très sensible au bruit, on lui applique généralement un filtre passe bas (''w0/(w0+s)'') :
 [[Fichier:eqFxTransfertPIDetPB.png|130]]

{{q | b)}} Il s'agit maintenant de transformer la variable ''s'' en une variable ''z'' :
* par transformée bilinéaire : ''s = (2/Ts)*(z-1)/(z+1)'' (voir le cours)
* ou par ''backward euler'' (version un peu plus simple) : ''s = (z-1)/(Ts*z)''.

En injectant le changement de variable dans la fonction de transfert ''H(s)'', obtenir la fonction de transfert ''H(z)'' du filtre linéaire numérique correspondant (dans un premier temps avec ''backward Euler'') :
* soit "à la main"
* ou en exploitant [https://www.sympy.org/en/index.html Sympy] (calcul symbolique). Un début :
<source lang="Python">
import sympy
from sympy import symbols, Poly, Eq
Ki, Kd, Kp, N, Ts, z, s = symbols('K_i K_d K_p N T_s z s')

Hs = Kp + (Ki/s) + Kd*s * (N/(N+s))

Hz = Hs.subs(s, (z-1)/(Ts*z))

# ...
</source>
Dans les deux cas, il sera nécessaire d'obtenir ''H(z)'' sous la forme d'une fraction rationnelle.

{{q | c)}} Implémentation du filtre : classe <code>FilterController</code> dont voici le squelette
<source lang="Python">
class FilterController:

def mfilter(self, e):
xn = e
# TODO
return yn

def __init__(self, K_p, K_i, K_d, N, T_s, set_point):
self.set_point = set_point
# A COMPLÉTER

def get_control(self, measurement, dt):
e = self.set_point - measurement
u = self.mfilter(e)
return u
</source>
{{q | d)}} Appliquer ce contrôleur à la simulation d'asservissement de drone et vérifier qu'un comportement proche de celui de la partie précédente (PID numérique "classique") est obtenu.

Cours:Elen4 TNS TP TpsReel

2026-06-01T13:00:35Z

Fredmn : /* PID numérique avec un filtre numérique linéaire */

[[Cours:Elen4_TNS|{{Rouge|'''Retour à la page du cours'''}}]]

<center>
'''<big>TP6 - Temps réel : bloc Gnuradio en Python / démodulation / PID Numérique</big>'''
</center>

Le but de ce TP est double :
* réaliser des implémentations temps réel de filtre IIR en créant un bloc Gnuradio qui execute un traitement codé en Python
* et étudier l'implémentation d'un PID numérique sous forme d'un filtre IIR.

Dans les deux cas, un système temps réel sera considéré :
* à intervalles de temps (réguliers ou non), une valeur ''x(n)'' rentre dans le système
* le travail consiste à calculer ''y(n)'' avec l'équation au différences du filtre, à partir de la valeur ''x(n)'' et de ses versions précédentes ''x(n-1)'' et ''x(n-2)'' (et aussi ''y(n-1)'', ''y(n-2)'') qu'il est donc nécessaire de stocker.
* La notion de ''temps réel'' implique que ''y(n)'' doit être calculer avant qu'une nouvelle valeurs de ''x(n)'' ne rentre dans le système.

=== Bloc Gnuradio en Python ===

Nous allons implémenter un filtre IIR dans gnuradio, en écrivant le traitement dans un bloc Python.

==== Filtre moyenneur====

{{q| a)}} Dans un premier temps, prendre connaissance du tutoriel suivant : [https://wiki.gnuradio.org/index.php?title=Creating_Your_First_Block wiki Gnuradio - ''Creating Your First Block'']

{{q| b)}} Nous allons écrire un filtre simple, qui implémente un simple moyenneur :
<source lang="Python">

import numpy as np
from gnuradio import gr

class blk(gr.sync_block):
def __init__(self): # Pas de paramètres
gr.sync_block.__init__(
self,
name="Filtre moyenneur",
in_sig=[np.float32],
out_sig=[np.float32]
)
self.xn1 = 0 # initialisation d'un attribut pour stocker x(n-1)

def work(self, input_items, output_items):
xn = input_items[0][0] # On ne "consomme" qu'un seul échantillon en entrée
yn = (xn + self.xn1) / 2
self.xn1 = xn
output_items[0][0] = yn # On ne produit donc également qu'un seul échantillon en sortie
return 1 # On retourne le nombre de valeurs consomées
</source>

==== Filtre IIR : démodulation ====

En reprenant le signal modulé en amplitude et la fonction de transfert du filtre passe-bas du TP précédent :

* Obtenir l'équation aux différence du filtre, ''ie'' écrire ''y(n)='' en fonction de ''x(n)'', ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.
* Créer un nouveau bloc Python dans le module <code>monModule</code> :
** de type <code>sync</code>
** une entrée en <code>np.float32</code>
** une sortie en <code>np.float32</code>
* Écrire le code permettant d'obtenir ''y(n)'' dans la méthode <code>work()</code> :
** ''x(n)'' est donné par <code>in[0][0]</code>
** il sera nécessaire de stocker dans des '''attributs''' les valeurs de ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.

{{q| a)}} Réaliser cette implémentation du passe-bas et contrôler que la démodulation est identique à celle obtenue au [[Cours:Elen4_TNS_TP_TraitAudioEtDemodulation|TP 5]].

{{q| b)}} Modifier votre code pour implémenter le filtre complet de démodulation.

=== Approximation de PID par filtre numérique linéaire ===

Cette partie sera travaillée dans un notebook Jupyter.

==== Rappels PID ====

* Principe

[[Fichier:PIDprincipe.png|400px]]

[[Fichier:PIDdetail.png|400px]]

* Définition mathématique, la sortie du controleur PID ''u(t)'' est donnée par:

[[Fichier:EqPID.png|400px]]

==== PID numérique "classique" ====

On considère que le temps est discrétisé : ''t = n.''d''t'' où d''t'' est l'intervalle de temps entre deux valeurs.

* En approximant grossièrement l'intégrale et la dérivée [[Fichier:PIDderivative.png|400px]] [[Fichier:PIDintegral.png|400px]]
** La dérivée est calculée par ''D = (e(n)-e(n-1))/''d''t''
** L'intégrale est approximée en cumulant progressivement : ''I = I + e(n).''d''t''
C'est ainsi que vous avez implémenté vos PID jusqu'ici.

Voici un notebook exemple à explorer sur deux modélisations : asservissement de 1) température et de 2) position ''z'' d'un drone : [[Media:TNS TP6 starter.ipynb.zip|TNS_TP6_starter.ipynb.zip]]

{{q | a)}} ''Ki = Kd = 0'' => chercher le meilleur ''Kp'' => erreur statique.

{{q | b)}} ''Kd = 0'' => l'introduction du terme integral permet de corriger cette erreur statique.

{{q | c)}} Le terme dérivatif n'est pas nécessaire pour la température

{{q | d)}} Mais l'est pour asservir la position ''z'' du drone.

==== PID numérique avec un filtre numérique linéaire ====

Nous allons reprendre le PID, par sa fonction de transfert qui exprime un filtre linéaire continu, et construire un filtre linéaire numérique qui l'approxime.

{{q | a)}} Cherchons la fonction de transfert du filtre continu d'un PID.
 En partant de l'équation différentielle
 [[Fichier:EqPID.png|500px]]
 On applique la transformée de Laplace (dérivée => multiplication par ''s'' ; intégrale => division par ''s'') :
 [[Fichier:eqFxTransfertPID.png|130]]
 Le terme dérivatif étant très sensible au bruit, on lui applique généralement un filtre passe bas (''w0/(w0+s)'') :
 [[Fichier:eqFxTransfertPIDetPB.png|130]]

{{q | b)}} Il s'agit maintenant de transformer la variable ''s'' en une variable ''z'' :
* par transformée bilinéaire : ''s = (2/Ts)*(z-1)/(z+1)'' (voir le cours)
* ou par ''backward euler'' (version un peu plus simple) : ''s = (z-1)/(Ts*z)''.

En injectant le changement de variable dans la fonction de transfert ''H(s)'', obtenir la fonction de transfert ''H(z)'' du filtre linéaire numérique correspondant (dans un premier temps avec ''backward Euler'') :
* soit "à la main"
* ou en exploitant [https://www.sympy.org/en/index.html Sympy] (calcul symbolique). Un début :
<source lang="Python">
import sympy
from sympy import symbols, Poly, Eq
Ki, Kd, Kp, N, Ts, z, s = symbols('K_i K_d K_p N T_s z s')

Hs = Kp + (Ki/s) + Kd*s * (N/(N+s))

Hz = Hs.subs(s, (z-1)/(Ts*z))

# ...
</source>
Dans les deux cas, il sera nécessaire d'obtenir ''H(z)'' sous la forme d'une fraction rationnelle.

{{q | c)}} Implémentation du filtre : classe <code>FilterController</code> dont voici le squelette
<source lang="Python">
class FilterController:

def mfilter(self, e):
xn = e
# TODO
return yn

def __init__(self, K_p, K_i, K_d, N, T_s, set_point):
self.set_point = set_point
# A COMPLÉTER

def get_control(self, measurement, dt):
e = self.set_point - measurement
u = self.mfilter(e)
return u
</source>
{{q | d)}} Appliquer ce contrôleur à la simulation d'asservissement de drone et vérifier qu'un comportement proche de celui de la partie précédente est obtenu.

Cours:Elen4 TNS TP TpsReel

2026-06-01T13:00:17Z

Fredmn : /* PID numérique avec un filtre numérique linéaire */

[[Cours:Elen4_TNS|{{Rouge|'''Retour à la page du cours'''}}]]

<center>
'''<big>TP6 - Temps réel : bloc Gnuradio en Python / démodulation / PID Numérique</big>'''
</center>

Le but de ce TP est double :
* réaliser des implémentations temps réel de filtre IIR en créant un bloc Gnuradio qui execute un traitement codé en Python
* et étudier l'implémentation d'un PID numérique sous forme d'un filtre IIR.

Dans les deux cas, un système temps réel sera considéré :
* à intervalles de temps (réguliers ou non), une valeur ''x(n)'' rentre dans le système
* le travail consiste à calculer ''y(n)'' avec l'équation au différences du filtre, à partir de la valeur ''x(n)'' et de ses versions précédentes ''x(n-1)'' et ''x(n-2)'' (et aussi ''y(n-1)'', ''y(n-2)'') qu'il est donc nécessaire de stocker.
* La notion de ''temps réel'' implique que ''y(n)'' doit être calculer avant qu'une nouvelle valeurs de ''x(n)'' ne rentre dans le système.

=== Bloc Gnuradio en Python ===

Nous allons implémenter un filtre IIR dans gnuradio, en écrivant le traitement dans un bloc Python.

==== Filtre moyenneur====

{{q| a)}} Dans un premier temps, prendre connaissance du tutoriel suivant : [https://wiki.gnuradio.org/index.php?title=Creating_Your_First_Block wiki Gnuradio - ''Creating Your First Block'']

{{q| b)}} Nous allons écrire un filtre simple, qui implémente un simple moyenneur :
<source lang="Python">

import numpy as np
from gnuradio import gr

class blk(gr.sync_block):
def __init__(self): # Pas de paramètres
gr.sync_block.__init__(
self,
name="Filtre moyenneur",
in_sig=[np.float32],
out_sig=[np.float32]
)
self.xn1 = 0 # initialisation d'un attribut pour stocker x(n-1)

def work(self, input_items, output_items):
xn = input_items[0][0] # On ne "consomme" qu'un seul échantillon en entrée
yn = (xn + self.xn1) / 2
self.xn1 = xn
output_items[0][0] = yn # On ne produit donc également qu'un seul échantillon en sortie
return 1 # On retourne le nombre de valeurs consomées
</source>

==== Filtre IIR : démodulation ====

En reprenant le signal modulé en amplitude et la fonction de transfert du filtre passe-bas du TP précédent :

* Obtenir l'équation aux différence du filtre, ''ie'' écrire ''y(n)='' en fonction de ''x(n)'', ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.
* Créer un nouveau bloc Python dans le module <code>monModule</code> :
** de type <code>sync</code>
** une entrée en <code>np.float32</code>
** une sortie en <code>np.float32</code>
* Écrire le code permettant d'obtenir ''y(n)'' dans la méthode <code>work()</code> :
** ''x(n)'' est donné par <code>in[0][0]</code>
** il sera nécessaire de stocker dans des '''attributs''' les valeurs de ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.

{{q| a)}} Réaliser cette implémentation du passe-bas et contrôler que la démodulation est identique à celle obtenue au [[Cours:Elen4_TNS_TP_TraitAudioEtDemodulation|TP 5]].

{{q| b)}} Modifier votre code pour implémenter le filtre complet de démodulation.

=== Approximation de PID par filtre numérique linéaire ===

Cette partie sera travaillée dans un notebook Jupyter.

==== Rappels PID ====

* Principe

[[Fichier:PIDprincipe.png|400px]]

[[Fichier:PIDdetail.png|400px]]

* Définition mathématique, la sortie du controleur PID ''u(t)'' est donnée par:

[[Fichier:EqPID.png|400px]]

==== PID numérique "classique" ====

On considère que le temps est discrétisé : ''t = n.''d''t'' où d''t'' est l'intervalle de temps entre deux valeurs.

* En approximant grossièrement l'intégrale et la dérivée [[Fichier:PIDderivative.png|400px]] [[Fichier:PIDintegral.png|400px]]
** La dérivée est calculée par ''D = (e(n)-e(n-1))/''d''t''
** L'intégrale est approximée en cumulant progressivement : ''I = I + e(n).''d''t''
C'est ainsi que vous avez implémenté vos PID jusqu'ici.

Voici un notebook exemple à explorer sur deux modélisations : asservissement de 1) température et de 2) position ''z'' d'un drone : [[Media:TNS TP6 starter.ipynb.zip|TNS_TP6_starter.ipynb.zip]]

{{q | a)}} ''Ki = Kd = 0'' => chercher le meilleur ''Kp'' => erreur statique.

{{q | b)}} ''Kd = 0'' => l'introduction du terme integral permet de corriger cette erreur statique.

{{q | c)}} Le terme dérivatif n'est pas nécessaire pour la température

{{q | d)}} Mais l'est pour asservir la position ''z'' du drone.

==== PID numérique avec un filtre numérique linéaire ====

Nous allons reprendre le PID, par sa fonction de transfert qui exprime un filtre linéaire continu, et construire un filtre linéaire numérique qui l'approxime.

{{q | a)}} Cherchons la fonction de transfert du filtre continu d'un PID.
 En partant de l'équation différentielle
 [[Fichier:EqPID.png|500px]]
 On applique la transformée de Laplace (dérivée => multiplication par ''s'' ; intégrale => division par ''s'') :
 [[Fichier:eqFxTransfertPID.png|130]]
 Le terme dérivatif étant très sensible au bruit, on lui applique généralement un filtre passe bas (''w0/(w0+s)'') :
 [[Fichier:eqFxTransfertPIDetPB.png|130]]

{{q | b)}} Il s'agit maintenant de transformer la variable ''s'' en une variable ''z'' :
* par transformée bilinéaire : ''s = (2/Ts)*(z-1)/(z+1)'' (voir le cours)
* ou par ''backward euler'' (version un peu plus simple) : ''s = (z-1)/(Ts*z)''.

En injectant le changement de variable dans la fonction de transfert ''H(s)'', obtenir la fonction de transfert ''H(z)'' du filtre linéaire numérique correspondant (dans un premier temps avec ''backward Euler'') :
* soit "à la main"
* ou en exploitant [https://www.sympy.org/en/index.html Sympy] (calcul symbolique). Un début :
<source lang="Python">
import sympy
from sympy import symbols, Poly, Eq
Ki, Kd, Kp, N, Ts, z, s = symbols('K_i K_d K_p N T_s z s')

Hs = Kp + (Ki/s) + Kd*s * (N/(N+s))

Hz = Hs.subs(s, (z-1)/(Ts*z))
</source>
Dans les deux cas, il sera nécessaire d'obtenir ''H(z)'' sous la forme d'une fraction rationnelle.

{{q | c)}} Implémentation du filtre : classe <code>FilterController</code> dont voici le squelette
<source lang="Python">
class FilterController:

def mfilter(self, e):
xn = e
# TODO
return yn

def __init__(self, K_p, K_i, K_d, N, T_s, set_point):
self.set_point = set_point
# A COMPLÉTER

def get_control(self, measurement, dt):
e = self.set_point - measurement
u = self.mfilter(e)
return u
</source>
{{q | d)}} Appliquer ce contrôleur à la simulation d'asservissement de drone et vérifier qu'un comportement proche de celui de la partie précédente est obtenu.

Cours:Elen4 TNS TP TpsReel

2026-06-01T10:18:16Z

Fredmn :

[[Cours:Elen4_TNS|{{Rouge|'''Retour à la page du cours'''}}]]

<center>
'''<big>TP6 - Temps réel : bloc Gnuradio en Python / démodulation / PID Numérique</big>'''
</center>

Le but de ce TP est double :
* réaliser des implémentations temps réel de filtre IIR en créant un bloc Gnuradio qui execute un traitement codé en Python
* et étudier l'implémentation d'un PID numérique sous forme d'un filtre IIR.

Dans les deux cas, un système temps réel sera considéré :
* à intervalles de temps (réguliers ou non), une valeur ''x(n)'' rentre dans le système
* le travail consiste à calculer ''y(n)'' avec l'équation au différences du filtre, à partir de la valeur ''x(n)'' et de ses versions précédentes ''x(n-1)'' et ''x(n-2)'' (et aussi ''y(n-1)'', ''y(n-2)'') qu'il est donc nécessaire de stocker.
* La notion de ''temps réel'' implique que ''y(n)'' doit être calculer avant qu'une nouvelle valeurs de ''x(n)'' ne rentre dans le système.

=== Bloc Gnuradio en Python ===

Nous allons implémenter un filtre IIR dans gnuradio, en écrivant le traitement dans un bloc Python.

==== Filtre moyenneur====

{{q| a)}} Dans un premier temps, prendre connaissance du tutoriel suivant : [https://wiki.gnuradio.org/index.php?title=Creating_Your_First_Block wiki Gnuradio - ''Creating Your First Block'']

{{q| b)}} Nous allons écrire un filtre simple, qui implémente un simple moyenneur :
<source lang="Python">

import numpy as np
from gnuradio import gr

class blk(gr.sync_block):
def __init__(self): # Pas de paramètres
gr.sync_block.__init__(
self,
name="Filtre moyenneur",
in_sig=[np.float32],
out_sig=[np.float32]
)
self.xn1 = 0 # initialisation d'un attribut pour stocker x(n-1)

def work(self, input_items, output_items):
xn = input_items[0][0] # On ne "consomme" qu'un seul échantillon en entrée
yn = (xn + self.xn1) / 2
self.xn1 = xn
output_items[0][0] = yn # On ne produit donc également qu'un seul échantillon en sortie
return 1 # On retourne le nombre de valeurs consomées
</source>

==== Filtre IIR : démodulation ====

En reprenant le signal modulé en amplitude et la fonction de transfert du filtre passe-bas du TP précédent :

* Obtenir l'équation aux différence du filtre, ''ie'' écrire ''y(n)='' en fonction de ''x(n)'', ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.
* Créer un nouveau bloc Python dans le module <code>monModule</code> :
** de type <code>sync</code>
** une entrée en <code>np.float32</code>
** une sortie en <code>np.float32</code>
* Écrire le code permettant d'obtenir ''y(n)'' dans la méthode <code>work()</code> :
** ''x(n)'' est donné par <code>in[0][0]</code>
** il sera nécessaire de stocker dans des '''attributs''' les valeurs de ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.

{{q| a)}} Réaliser cette implémentation du passe-bas et contrôler que la démodulation est identique à celle obtenue au [[Cours:Elen4_TNS_TP_TraitAudioEtDemodulation|TP 5]].

{{q| b)}} Modifier votre code pour implémenter le filtre complet de démodulation.

=== Approximation de PID par filtre numérique linéaire ===

Cette partie sera travaillée dans un notebook Jupyter.

==== Rappels PID ====

* Principe

[[Fichier:PIDprincipe.png|400px]]

[[Fichier:PIDdetail.png|400px]]

* Définition mathématique, la sortie du controleur PID ''u(t)'' est donnée par:

[[Fichier:EqPID.png|400px]]

==== PID numérique "classique" ====

On considère que le temps est discrétisé : ''t = n.''d''t'' où d''t'' est l'intervalle de temps entre deux valeurs.

* En approximant grossièrement l'intégrale et la dérivée [[Fichier:PIDderivative.png|400px]] [[Fichier:PIDintegral.png|400px]]
** La dérivée est calculée par ''D = (e(n)-e(n-1))/''d''t''
** L'intégrale est approximée en cumulant progressivement : ''I = I + e(n).''d''t''
C'est ainsi que vous avez implémenté vos PID jusqu'ici.

Voici un notebook exemple à explorer sur deux modélisations : asservissement de 1) température et de 2) position ''z'' d'un drone : [[Media:TNS TP6 starter.ipynb.zip|TNS_TP6_starter.ipynb.zip]]

{{q | a)}} ''Ki = Kd = 0'' => chercher le meilleur ''Kp'' => erreur statique.

{{q | b)}} ''Kd = 0'' => l'introduction du terme integral permet de corriger cette erreur statique.

{{q | c)}} Le terme dérivatif n'est pas nécessaire pour la température

{{q | d)}} Mais l'est pour asservir la position ''z'' du drone.

==== PID numérique avec un filtre numérique linéaire ====

* Cherchons la fonction de transfert du filtre continu d'un PID.
 En partant de l'équation différentielle
 [[Fichier:EqPID.png|500px]]
 On applique la transformée de Laplace (dérivée => multiplication par ''s'' ; intégrale => division par ''s'') :
 [[Fichier:eqFxTransfertPID.png|130]]
 Le terme dérivatif étant très sensible au bruit, on lui applique généralement un filtre passe bas (''w0/(w0+s)'') :
 [[Fichier:eqFxTransfertPIDetPB.png|130]]
* Approximation de la fonction de transfert pour obtenir un filtre numérique
** ''backward euler''
** et transformée bilinéaire

* Implémentation du Filtre : classe <code>FilterController</code>
* Application sur l'asservissement d'altitude d'un drone

Cours:Elen4 TNS TP TpsReel

2026-06-01T10:16:51Z

Fredmn : /* PID numérique "classique" */

[[Cours:Elen4_TNS|{{Rouge|'''Retour à la page du cours'''}}]]

<center>
'''<big>TP6 - Temps réel : bloc Gnuradio en Python / démodulation / PID Numérique</big>'''
</center>

Le but de ce TP est double :
* réaliser des implémentations temps réel de filtre IIR en créant un bloc Gnuradio qui execute un traitement codé en Python
* et étudier l'implémentation d'un PID numérique sous forme d'un filtre IIR.

Dans les deux cas, un système temps réel sera considéré :
* à intervalles de temps (réguliers ou non), une valeur ''x(n)'' rentre dans le système
* le travail consiste à calculer ''y(n)'' avec l'équation au différences du filtre, à partir de la valeur ''x(n)'' et de ses versions précédentes ''x(n-1)'' et ''x(n-2)'' (et aussi ''y(n-1)'', ''y(n-2)'') qu'il est donc nécessaire de stocker.
* La notion de ''temps réel'' implique que ''y(n)'' doit être calculer avant qu'une nouvelle valeurs de ''x(n)'' ne rentre dans le système.

=== Bloc Gnuradio en Python ===

Nous allons implémenter un filtre IIR dans gnuradio, en écrivant le traitement dans un bloc Python.

==== Filtre moyenneur====

{{q| a)}} Dans un premier temps, prendre connaissance du tutoriel suivant : [https://wiki.gnuradio.org/index.php?title=Creating_Your_First_Block wiki Gnuradio - ''Creating Your First Block'']

{{q| b)}} Nous allons écrire un filtre simple, qui implémente un simple moyenneur :
<source lang="Python">

import numpy as np
from gnuradio import gr

class blk(gr.sync_block):
def __init__(self): # Pas de paramètres
gr.sync_block.__init__(
self,
name="Filtre moyenneur",
in_sig=[np.float32],
out_sig=[np.float32]
)
self.xn1 = 0 # initialisation d'un attribut pour stocker x(n-1)

def work(self, input_items, output_items):
xn = input_items[0][0] # On ne "consomme" qu'un seul échantillon en entrée
yn = (xn + self.xn1) / 2
self.xn1 = xn
output_items[0][0] = yn # On ne produit donc également qu'un seul échantillon en sortie
return 1 # On retourne le nombre de valeurs consomées
</source>

==== Filtre IIR : démodulation ====

En reprenant le signal modulé en amplitude et la fonction de transfert du filtre passe-bas du TP précédent :

* Obtenir l'équation aux différence du filtre, ''ie'' écrire ''y(n)='' en fonction de ''x(n)'', ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.
* Créer un nouveau bloc Python dans le module <code>monModule</code> :
** de type <code>sync</code>
** une entrée en <code>np.float32</code>
** une sortie en <code>np.float32</code>
* Écrire le code permettant d'obtenir ''y(n)'' dans la méthode <code>work()</code> :
** ''x(n)'' est donné par <code>in[0][0]</code>
** il sera nécessaire de stocker dans des '''attributs''' les valeurs de ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.

{{q| a)}} Réaliser cette implémentation du passe-bas et contrôler que la démodulation est identique à celle obtenue au [[Cours:Elen4_TNS_TP_TraitAudioEtDemodulation|TP 5]].

{{q| b)}} Modifier votre code pour implémenter le filtre complet de démodulation.

=== Approximation de PID par filtre numérique linéaire ===

Cette partie sera travaillée dans un notebook Jupyter.

==== Rappels PID ====

* Principe

[[Fichier:PIDprincipe.png|400px]]

[[Fichier:PIDdetail.png|400px]]

* Définition mathématique, la sortie du controleur PID ''u(t)'' est donnée par:

[[Fichier:EqPID.png|400px]]

==== PID numérique "classique" ====

On considère que le temps est discrétisé : ''t = n.''d''t'' où d''t'' est l'intervalle de temps entre deux valeurs.

* En approximant grossièrement l'intégrale et la dérivée [[Fichier:PIDderivative.png|400px]] [[Fichier:PIDintegral.png|400px]]
** La dérivée est calculée par ''D = (e(n)-e(n-1))/''d''t''
** L'intégrale est approximée en cumulant progressivement : ''I = I + e(n).''d''t''
C'est ainsi que vous avez implémenté vos PID jusqu'ici.

Voici un notebook exemple à explorer sur deux modélisations : asservissement de 1) température et de 2) position ''z'' d'un drone : [[Media:TNS TP6 starter.ipynb.zip|TNS_TP6_starter.ipynb.zip]]

{{q | a)}} ''Ki = Kd = 0'' => chercher le meilleur ''Kp'' => erreur statique.

{{q | b)}} ''Kd = 0'' => l'introduction du terme integral permet de corriger cette erreur statique.

{{q | c)}} Le terme dérivatif n'est pas nécessaire pour la température

{{q | d)}} Mais l'est pour asservir la position ''z'' du drone.

==== PID numérique avec un filtre numérique linéaire ====

* Cherchons la fonction de transfert du filtre continu d'un PID.
 En partant de l'équation différentielle
 [[Fichier:EqPID.png|500px]]
 On applique la transformée de Laplace (dérivée => multiplication par ''s'' ; intégrale => division par ''s'') :
 [[Fichier:eqFxTransfertPID.png|130]]
 Le terme dérivatif étant très sensible au bruit, on lui applique généralement un filtre passe bas (''w0/(w0+s)'') :
 [[Fichier:eqFxTransfertPIDetPB.png|130]]
* Approximation de la fonction de transfert pour obtenir un filtre numérique
** ''backward euler''
** et transformée bilinéaire

* Implémentation du Filtre : classe <code>FilterController</code>
* Application sur l'asservissement d'altitude d'un drone

=== Archive : codage de bloc Gnuradio en C++ ===

Ce guide est inspirée du guide [https://wiki.gnuradio.org/index.php?title=Creating_C%2B%2B_OOT_with_gr-modtool Creating an OOT (C++ block example)] en l'adaptant pour nos besoins :

Nous allons créer un simple bloc qui recopie son entrée (en <code>float</code>) sur sa sortie. Donc le filtre caractérisé par ''y(n)'' = ''x(n)'' ou encore ''H(z)''=1. Il s'agit donc d'une sorte de filtre passe-tout.

'''Suivez bien toutes les étapes, sans aller trop rapidement'''

* Vous pourrez utiliser <code>gedit</code> pour éditer les divers fichiers.

==== Création d'un module externe ====

Dans les lignes qui suivent, le <code>$</code> indique que l'on saisi une commande dans un terminal. Le <code>$</code> n'est pas à saisir.

* Ouvrez un terminal et placez-vous à la racine de votre dossier personnel :
<source>
$ cd $HOME
</source>
* Créez un dossier de travail dédié à gnuradio et déplacez-vous à l'intérieur :
<source>
$ mkdir gnuradio
$ cd gnuradio
</source>
* GNU Radio est livré avec gr_modtool, un utilitaire qui permet de créer des modules externes (OOT). Créons un module <code>monModule</code>
<source>
$ gr_modtool newmod monModule
</source>
* Le dossier <code>gr-monModule</code> est créé et contient tout le code squelette d'un module OOT, mais il n'a pas encore de blocs. Déplacez-vous dans <code>gr-monModule</code> :
<source>
$ cd gr-monModule
</source>
* Vous pouvez afficher le contenu de ce dossier par
<source>
$ ls
</source>

==== Création d'un bloc dans ce module ====

* Ajoutez un nouveau bloc nommé <code>passetout</code> :
<source>
$ gr_modtool add passetout
</source>
* Quelques questions permettent alors de spécifier le type de bloc
<source>
GNU Radio module name identified: passetout
('sink', 'source', 'sync', 'decimator', 'interpolator', 'general', 'tagged_stream', 'hier', 'noblock')
</source>
Saisissez <code>sync</code> comme type de bloc, car le bloc que nous écrivons produira le même nombre d'échantillons en sortie que le nombre d'échantillons consommés depuis l'entrée.
<source>
Enter block type: sync
</source>
* Spécifiez <code>cpp</code> comme langage :
<source>
Language (python/cpp): cpp
Language: C++
Block/code identifier: passetout
</source>
* Spécifiez un nom pour le copyright :
<source>
Please specify the copyright holder: Bibi
</source>
* Il est possible de spécifier des paramètres d'entrée qui peuvent permettre de régler le fonctionnement du bloc. Ce ne sera pas notre cas, ne rien saisir sur cette question :
<source>
Enter valid argument list, including default arguments:
</source>
* De même, on ne donnera pas de code permettant de tester le bon fonctionnement :
<source>
Add Python QA code? [Y/n] n
Add C++ QA code? [Y/n] n
</source>
* Plusieurs fichers sont alors crées :
<source>
Adding file 'lib/passetout_impl.h'...
Adding file 'lib/passetout_impl.cc'...
Adding file 'include/gnuradio/monModule/passetout.h'...
Adding file 'python/monModule/bindings/docstrings/passetout_pydoc_template.h'...
Adding file 'python/monModule/bindings/passetout_python.cc'...
Adding file 'grc/monModule_passetout.block.yml'...
Editing grc/CMakeLists.txt...
</source>

Quelques indications :
* le fichier <code>passetout_impl.h</code> contient l'entête de la classe de notre bloc
* le fichier <code>passetout_impl.cc</code> contient l'implémentation de la classe de notre bloc
* le fichier <code>monModule_passetout.block.yml</code> va contenir des informations faisant le lien entre notre code c++ et le code python utilisé en interne par Gnuradio
* Le tout sera compilé par un <code>Makefile</code> généré par <code>cmake</code>.

==== Fichier <code>passetout_impl.h</code> ====

Le code utile généré est le suivant :
<source lang=cpp>
class passetout_impl : public passetout
{
private:
// Nothing to declare in this block.

public:
passetout_impl();
~passetout_impl();

// Where all the action really happens
int work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items);
};
</source>

Pour se réveiller les neurones sur la POO, qu'est-ce que sont
* <code>passetout_impl()</code>,
* <code>~passetout_impl()</code>,
* <code>private</code>, <code>public</code> ?

Le travail sera réalisé dans la méthode <code>work()</code>, mais nous n'avons pas de modification à apporter dans les déclarations par défaut.

==== Fichier <code>passetout_impl.cc</code> ====

Le code utile généré est le suivant :

{{boîte déroulante/début|titre=passetout_impl.cc}}
<source lang=cpp>
namespace monModule {

#pragma message("set the following appropriately and remove this warning")
using input_type = float;
#pragma message("set the following appropriately and remove this warning")
using output_type = float;
passetout::sptr passetout::make() { return gnuradio::make_block_sptr<passetout_impl>(); }

/*
* The private constructor
*/
passetout_impl::passetout_impl()
: gr::sync_block("passetout",
gr::io_signature::make(
1 /* min inputs */, 1 /* max inputs */, sizeof(input_type)),
gr::io_signature::make(
1 /* min outputs */, 1 /*max outputs */, sizeof(output_type)))
{
}

/*
* Our virtual destructor.
*/
passetout_impl::~passetout_impl() {}

int passetout_impl::work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items)
{
auto in = static_cast<const input_type*>(input_items[0]);
auto out = static_cast<output_type*>(output_items[0]);

#pragma message("Implement the signal processing in your block and remove this warning")
// Do <+signal processing+>

// Tell runtime system how many output items we produced.
return noutput_items;
}

} /* namespace monModule */
</source>
{{boîte déroulante/fin}}

Détaillons :
<source lang=cpp>
#pragma message("set the following appropriately and remove this warning")
using input_type = float;
#pragma message("set the following appropriately and remove this warning")
using output_type = float;
</source>
{{Todos| On spécifie ici le type des données d'entrée et de sortie. Pas de modification à apporter, il suffit de supprimer les deux <code>#pragma</code>}}

<source lang=cpp>
passetout_impl::passetout_impl()
: gr::sync_block("passetout",
gr::io_signature::make(
1 /* min inputs */, 1 /* max inputs */, sizeof(input_type)),
gr::io_signature::make(
1 /* min outputs */, 1 /*max outputs */, sizeof(output_type)))
{
}
</source>

{{Todos| On spécifie ici le nombre d'entrées (1) et le nombre de sorties (1). Pas de modification non plus.}}

{{Todos| Expliquez la syntaxe <code>passetout_impl::passetout_impl() : gr::sync_block(...)"</code> }}

<source lang=cpp>
int passetout_impl::work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items)
{
auto in = static_cast<const input_type*>(input_items[0]);
auto out = static_cast<output_type*>(output_items[0]);

#pragma message("Implement the signal processing in your block and remove this warning")
// Do <+signal processing+>

// Tell runtime system how many output items we produced.
return noutput_items;
}
</source>
Cette méthode <code>work()</code> implémente véritablement le filtrage.
* Les tableaux <code>in</code> et <code>out</code> contiennent respectivement les données en entrée et les données en sortie. Il faut donc calculer <code>out</code> en fonction de <code>in</code>
* Les données d'entrée arrivent par paquets dans un buffer. La variable <code>noutput_items</code> contient le nombre de données disponibles en entrées.
* à la fin de la méthode, on renvoie le nombre de données en sortie que l'on a calculé (entre 1 et <code>noutput_items</code>). Les données d'entrées éventuellement non consommées seront conservées dans le buffer pour le prochain appel de <code>work()</code>
{{Todos| On souhaite ici seulement recopier l'entrée sur la sortie, donc }}
# Enlever la ligne <code>#pragma</code>
# ajouter le code <code> out[0] = in[0];</code> (on recopie le premier échantillon disponible en entrée)
# changer <code>return noutput_items;</code> en <code>return 1;</code> (un seul échantillon a été consommé).

==== Fichier <code>monModule_passetout.block.yml</code> ====

Ce fichier au format YAML (''yet another markup language'') fait le lien entre le code c++ et le code python utilisé en interne par GnuRadio.

{{boîte déroulante/début|titre=monModule_passetout.block.yml}}
<source lang=yaml>
id: monModule_passetout
label: passetout
category: '[monModule]'

templates:
imports: from gnuradio import monModule
make: monModule.passetout()

# Make one 'parameters' list entry for every parameter you want settable from the GUI.
# Keys include:
# * id (makes the value accessible as keyname, e.g. in the make entry)
# * label (label shown in the GUI)
# * dtype (e.g. int, float, complex, byte, short, xxx_vector, ...)
# * default
parameters:
- id: parametername_replace_me
label: FIX ME:
dtype: string
default: You need to fill in your grc/monModule_passetout.block.yaml
#- id: ...
# label: ...
# dtype: ...

# Make one 'inputs' list entry per input and one 'outputs' list entry per output.
# Keys include:
# * label (an identifier for the GUI)
# * domain (optional - stream or message. Default is stream)
# * dtype (e.g. int, float, complex, byte, short, xxx_vector, ...)
# * vlen (optional - data stream vector length. Default is 1)
# * optional (optional - set to 1 for optional inputs. Default is 0)
inputs:
#- label: ...
# domain: ...
# dtype: ...
# vlen: ...
# optional: ...

outputs:
#- label: ...
# domain: ...
# dtype: ...
# vlen: ...
# optional: ...

# 'file_format' specifies the version of the GRC yml format used in the file
# and should usually not be changed.
file_format: 1
</source>
{{boîte déroulante/fin}}

{{Todos| Mettre à jour la section <code>parameters</code> (pas de paramètres, on commente) :}}

<source lang=yaml>
#parameters:
#- id: parametername_replace_me
# label: FIX ME:
# dtype: string
# default: You need to fill in your grc/customModule_testMod.block.yaml
</source>

{{Todos| Mettre à jour la section <code>inputs</code> :}}

<source lang=yaml>
inputs:
- label: in
domain: stream
dtype: float
</source>

{{Todos| Mettre à jour la section <code>output</code> :}}

<source lang=yaml>
outputs:
- label: out
domain: stream
dtype: float
</source>

==== Compilation et installation ====

Voici les étapes :
<source lang=bash>
$ cd CHEMIN-DE-VOTRE-DOSSIER/gr-monModule
$ mkdir build
$ cd build
$ cmake ..
$ make
$ make install
</source>

* <code>cmake ..</code> lance la création des fichiers <code>Makefile</code> qui permettent la compilation et l'installation
* <code>make</code> lance la compilation
* <code>make install</code> lance l'installation (copie des fichiers dans les dossiers gnuradio)

{{Todos| Exécuter chacune de ces lignes, en contrôlant l'absence d'erreur. Dans le cas contraire, contrôler les fichiers <code>.h</code>, <code>.cc</code> et <code>.yaml</code>}}

{{Todos| '''Après ces étapes, et avant de lancer gnuRadio, appeler l'enseignant qui va mettre à jours les bibliothèques partagées.'''}}. Sinon tenter :
<source>
$ export LD_LIBRARY_PATH=/usr/local/lib/x86_64-linux-gnu:$LD_LIBRARY_PATH
$ gnuradio-companion &
</source>

==== Utilisation du bloc et test ====

* Dans Gnuradio, rafraichir la liste des bloc (bouton ''reload'')
* le bloc <code>passetout</code> doit être présent dans la section <code>monModule</code>
* Tester le bon fonctionnement de ce bloc en lui envoyant une sinusoïde que vous devez observer identique à la sortie du bloc. Vérifier avec des graphes.

==== Application : démodulation ====

En reprenant le signal modulé en amplitude et la fonction de transfert du filtre passe-bas du TP précédent :

* Obtenir l'équation aux différence du filtre, ''ie'' écrire ''y(n)='' en fonction de ''x(n)'', ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.
* Créer un nouveau bloc C++ (similaire au passe-tout précédent) dans le module <code>monModule</code> :
** de type <code>sync</code>
** une entrée en <code>float</code>
** une sortie en <code>float</code>
* Écrire le code permettant d'obtenir ''y(n)'' dans la méthode <code>work()</code> :
** ''x(n)'' est donné par <code>in0[0]</code>
** il sera nécessaire d'affecter <code>out0[0]</code> pour produire ''y(n)''.
** il sera nécessaire de stocker dans des '''attributs''' les valeurs de <code>in[0]</code> afin de disposer de ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.
** On rappelle que les attributs doivent être déclarées dans le fichier <code>.h</code> et initialisés dans le constructeur de la classe.

{{Todos| Réaliser cette implémentation du passe-bas et contrôler que la démodulation est identique à celle obtenue au TP précédent}}

{{Todos| Modifier votre code pour implémenter le filtre complet de démodulation}}

Cours:Elen4 TNS TP TpsReel

2026-06-01T10:15:41Z

Fredmn :

[[Cours:Elen4_TNS|{{Rouge|'''Retour à la page du cours'''}}]]

<center>
'''<big>TP6 - Temps réel : bloc Gnuradio en Python / démodulation / PID Numérique</big>'''
</center>

Le but de ce TP est double :
* réaliser des implémentations temps réel de filtre IIR en créant un bloc Gnuradio qui execute un traitement codé en Python
* et étudier l'implémentation d'un PID numérique sous forme d'un filtre IIR.

Dans les deux cas, un système temps réel sera considéré :
* à intervalles de temps (réguliers ou non), une valeur ''x(n)'' rentre dans le système
* le travail consiste à calculer ''y(n)'' avec l'équation au différences du filtre, à partir de la valeur ''x(n)'' et de ses versions précédentes ''x(n-1)'' et ''x(n-2)'' (et aussi ''y(n-1)'', ''y(n-2)'') qu'il est donc nécessaire de stocker.
* La notion de ''temps réel'' implique que ''y(n)'' doit être calculer avant qu'une nouvelle valeurs de ''x(n)'' ne rentre dans le système.

=== Bloc Gnuradio en Python ===

Nous allons implémenter un filtre IIR dans gnuradio, en écrivant le traitement dans un bloc Python.

==== Filtre moyenneur====

{{q| a)}} Dans un premier temps, prendre connaissance du tutoriel suivant : [https://wiki.gnuradio.org/index.php?title=Creating_Your_First_Block wiki Gnuradio - ''Creating Your First Block'']

{{q| b)}} Nous allons écrire un filtre simple, qui implémente un simple moyenneur :
<source lang="Python">

import numpy as np
from gnuradio import gr

class blk(gr.sync_block):
def __init__(self): # Pas de paramètres
gr.sync_block.__init__(
self,
name="Filtre moyenneur",
in_sig=[np.float32],
out_sig=[np.float32]
)
self.xn1 = 0 # initialisation d'un attribut pour stocker x(n-1)

def work(self, input_items, output_items):
xn = input_items[0][0] # On ne "consomme" qu'un seul échantillon en entrée
yn = (xn + self.xn1) / 2
self.xn1 = xn
output_items[0][0] = yn # On ne produit donc également qu'un seul échantillon en sortie
return 1 # On retourne le nombre de valeurs consomées
</source>

==== Filtre IIR : démodulation ====

En reprenant le signal modulé en amplitude et la fonction de transfert du filtre passe-bas du TP précédent :

* Obtenir l'équation aux différence du filtre, ''ie'' écrire ''y(n)='' en fonction de ''x(n)'', ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.
* Créer un nouveau bloc Python dans le module <code>monModule</code> :
** de type <code>sync</code>
** une entrée en <code>np.float32</code>
** une sortie en <code>np.float32</code>
* Écrire le code permettant d'obtenir ''y(n)'' dans la méthode <code>work()</code> :
** ''x(n)'' est donné par <code>in[0][0]</code>
** il sera nécessaire de stocker dans des '''attributs''' les valeurs de ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.

{{q| a)}} Réaliser cette implémentation du passe-bas et contrôler que la démodulation est identique à celle obtenue au [[Cours:Elen4_TNS_TP_TraitAudioEtDemodulation|TP 5]].

{{q| b)}} Modifier votre code pour implémenter le filtre complet de démodulation.

=== Approximation de PID par filtre numérique linéaire ===

Cette partie sera travaillée dans un notebook Jupyter.

==== Rappels PID ====

* Principe

[[Fichier:PIDprincipe.png|400px]]

[[Fichier:PIDdetail.png|400px]]

* Définition mathématique, la sortie du controleur PID ''u(t)'' est donnée par:

[[Fichier:EqPID.png|400px]]

==== PID numérique "classique" ====

On considère que le temps est discrétisé : ''t = n.''d''t'' où d''t'' est l'intervalle de temps entre deux valeurs.

* En approximant grossièrement l'intégrale et la dérivée [[Fichier:PIDderivative.png|400px]] [[Fichier:PIDintegral.png|400px]]
** La dérivée est calculée par ''D = (e(n)-e(n-1))/''d''t''
** L'intégrale est approximée en cumulant progressivement : ''I = I + e(n).''d''t''
C'est ainsi que vous avez implémenté vos PID jusqu'ici.

Voici un notebook exemple à explorer sur deux modélisations : asservissement de 1) température et de 2) position ''z'' d'un drone : [[Media:TNS TP6 starter.ipynb.zip]]

{{q | a)}} ''Ki = Kd = 0'' => chercher le meilleur ''Kp'' => erreur statique.

{{q | b)}} ''Kd = 0'' => l'introduction du terme integral permet de corriger cette erreur statique.

{{q | c)}} Le terme dérivatif n'est pas nécessaire pour la température

{{q | d)}} Mais l'est pour asservir la position ''z'' du drone.

==== PID numérique avec un filtre numérique linéaire ====

* Cherchons la fonction de transfert du filtre continu d'un PID.
 En partant de l'équation différentielle
 [[Fichier:EqPID.png|500px]]
 On applique la transformée de Laplace (dérivée => multiplication par ''s'' ; intégrale => division par ''s'') :
 [[Fichier:eqFxTransfertPID.png|130]]
 Le terme dérivatif étant très sensible au bruit, on lui applique généralement un filtre passe bas (''w0/(w0+s)'') :
 [[Fichier:eqFxTransfertPIDetPB.png|130]]
* Approximation de la fonction de transfert pour obtenir un filtre numérique
** ''backward euler''
** et transformée bilinéaire

* Implémentation du Filtre : classe <code>FilterController</code>
* Application sur l'asservissement d'altitude d'un drone

=== Archive : codage de bloc Gnuradio en C++ ===

Ce guide est inspirée du guide [https://wiki.gnuradio.org/index.php?title=Creating_C%2B%2B_OOT_with_gr-modtool Creating an OOT (C++ block example)] en l'adaptant pour nos besoins :

Nous allons créer un simple bloc qui recopie son entrée (en <code>float</code>) sur sa sortie. Donc le filtre caractérisé par ''y(n)'' = ''x(n)'' ou encore ''H(z)''=1. Il s'agit donc d'une sorte de filtre passe-tout.

'''Suivez bien toutes les étapes, sans aller trop rapidement'''

* Vous pourrez utiliser <code>gedit</code> pour éditer les divers fichiers.

==== Création d'un module externe ====

Dans les lignes qui suivent, le <code>$</code> indique que l'on saisi une commande dans un terminal. Le <code>$</code> n'est pas à saisir.

* Ouvrez un terminal et placez-vous à la racine de votre dossier personnel :
<source>
$ cd $HOME
</source>
* Créez un dossier de travail dédié à gnuradio et déplacez-vous à l'intérieur :
<source>
$ mkdir gnuradio
$ cd gnuradio
</source>
* GNU Radio est livré avec gr_modtool, un utilitaire qui permet de créer des modules externes (OOT). Créons un module <code>monModule</code>
<source>
$ gr_modtool newmod monModule
</source>
* Le dossier <code>gr-monModule</code> est créé et contient tout le code squelette d'un module OOT, mais il n'a pas encore de blocs. Déplacez-vous dans <code>gr-monModule</code> :
<source>
$ cd gr-monModule
</source>
* Vous pouvez afficher le contenu de ce dossier par
<source>
$ ls
</source>

==== Création d'un bloc dans ce module ====

* Ajoutez un nouveau bloc nommé <code>passetout</code> :
<source>
$ gr_modtool add passetout
</source>
* Quelques questions permettent alors de spécifier le type de bloc
<source>
GNU Radio module name identified: passetout
('sink', 'source', 'sync', 'decimator', 'interpolator', 'general', 'tagged_stream', 'hier', 'noblock')
</source>
Saisissez <code>sync</code> comme type de bloc, car le bloc que nous écrivons produira le même nombre d'échantillons en sortie que le nombre d'échantillons consommés depuis l'entrée.
<source>
Enter block type: sync
</source>
* Spécifiez <code>cpp</code> comme langage :
<source>
Language (python/cpp): cpp
Language: C++
Block/code identifier: passetout
</source>
* Spécifiez un nom pour le copyright :
<source>
Please specify the copyright holder: Bibi
</source>
* Il est possible de spécifier des paramètres d'entrée qui peuvent permettre de régler le fonctionnement du bloc. Ce ne sera pas notre cas, ne rien saisir sur cette question :
<source>
Enter valid argument list, including default arguments:
</source>
* De même, on ne donnera pas de code permettant de tester le bon fonctionnement :
<source>
Add Python QA code? [Y/n] n
Add C++ QA code? [Y/n] n
</source>
* Plusieurs fichers sont alors crées :
<source>
Adding file 'lib/passetout_impl.h'...
Adding file 'lib/passetout_impl.cc'...
Adding file 'include/gnuradio/monModule/passetout.h'...
Adding file 'python/monModule/bindings/docstrings/passetout_pydoc_template.h'...
Adding file 'python/monModule/bindings/passetout_python.cc'...
Adding file 'grc/monModule_passetout.block.yml'...
Editing grc/CMakeLists.txt...
</source>

Quelques indications :
* le fichier <code>passetout_impl.h</code> contient l'entête de la classe de notre bloc
* le fichier <code>passetout_impl.cc</code> contient l'implémentation de la classe de notre bloc
* le fichier <code>monModule_passetout.block.yml</code> va contenir des informations faisant le lien entre notre code c++ et le code python utilisé en interne par Gnuradio
* Le tout sera compilé par un <code>Makefile</code> généré par <code>cmake</code>.

==== Fichier <code>passetout_impl.h</code> ====

Le code utile généré est le suivant :
<source lang=cpp>
class passetout_impl : public passetout
{
private:
// Nothing to declare in this block.

public:
passetout_impl();
~passetout_impl();

// Where all the action really happens
int work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items);
};
</source>

Pour se réveiller les neurones sur la POO, qu'est-ce que sont
* <code>passetout_impl()</code>,
* <code>~passetout_impl()</code>,
* <code>private</code>, <code>public</code> ?

Le travail sera réalisé dans la méthode <code>work()</code>, mais nous n'avons pas de modification à apporter dans les déclarations par défaut.

==== Fichier <code>passetout_impl.cc</code> ====

Le code utile généré est le suivant :

{{boîte déroulante/début|titre=passetout_impl.cc}}
<source lang=cpp>
namespace monModule {

#pragma message("set the following appropriately and remove this warning")
using input_type = float;
#pragma message("set the following appropriately and remove this warning")
using output_type = float;
passetout::sptr passetout::make() { return gnuradio::make_block_sptr<passetout_impl>(); }

/*
* The private constructor
*/
passetout_impl::passetout_impl()
: gr::sync_block("passetout",
gr::io_signature::make(
1 /* min inputs */, 1 /* max inputs */, sizeof(input_type)),
gr::io_signature::make(
1 /* min outputs */, 1 /*max outputs */, sizeof(output_type)))
{
}

/*
* Our virtual destructor.
*/
passetout_impl::~passetout_impl() {}

int passetout_impl::work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items)
{
auto in = static_cast<const input_type*>(input_items[0]);
auto out = static_cast<output_type*>(output_items[0]);

#pragma message("Implement the signal processing in your block and remove this warning")
// Do <+signal processing+>

// Tell runtime system how many output items we produced.
return noutput_items;
}

} /* namespace monModule */
</source>
{{boîte déroulante/fin}}

Détaillons :
<source lang=cpp>
#pragma message("set the following appropriately and remove this warning")
using input_type = float;
#pragma message("set the following appropriately and remove this warning")
using output_type = float;
</source>
{{Todos| On spécifie ici le type des données d'entrée et de sortie. Pas de modification à apporter, il suffit de supprimer les deux <code>#pragma</code>}}

<source lang=cpp>
passetout_impl::passetout_impl()
: gr::sync_block("passetout",
gr::io_signature::make(
1 /* min inputs */, 1 /* max inputs */, sizeof(input_type)),
gr::io_signature::make(
1 /* min outputs */, 1 /*max outputs */, sizeof(output_type)))
{
}
</source>

{{Todos| On spécifie ici le nombre d'entrées (1) et le nombre de sorties (1). Pas de modification non plus.}}

{{Todos| Expliquez la syntaxe <code>passetout_impl::passetout_impl() : gr::sync_block(...)"</code> }}

<source lang=cpp>
int passetout_impl::work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items)
{
auto in = static_cast<const input_type*>(input_items[0]);
auto out = static_cast<output_type*>(output_items[0]);

#pragma message("Implement the signal processing in your block and remove this warning")
// Do <+signal processing+>

// Tell runtime system how many output items we produced.
return noutput_items;
}
</source>
Cette méthode <code>work()</code> implémente véritablement le filtrage.
* Les tableaux <code>in</code> et <code>out</code> contiennent respectivement les données en entrée et les données en sortie. Il faut donc calculer <code>out</code> en fonction de <code>in</code>
* Les données d'entrée arrivent par paquets dans un buffer. La variable <code>noutput_items</code> contient le nombre de données disponibles en entrées.
* à la fin de la méthode, on renvoie le nombre de données en sortie que l'on a calculé (entre 1 et <code>noutput_items</code>). Les données d'entrées éventuellement non consommées seront conservées dans le buffer pour le prochain appel de <code>work()</code>
{{Todos| On souhaite ici seulement recopier l'entrée sur la sortie, donc }}
# Enlever la ligne <code>#pragma</code>
# ajouter le code <code> out[0] = in[0];</code> (on recopie le premier échantillon disponible en entrée)
# changer <code>return noutput_items;</code> en <code>return 1;</code> (un seul échantillon a été consommé).

==== Fichier <code>monModule_passetout.block.yml</code> ====

Ce fichier au format YAML (''yet another markup language'') fait le lien entre le code c++ et le code python utilisé en interne par GnuRadio.

{{boîte déroulante/début|titre=monModule_passetout.block.yml}}
<source lang=yaml>
id: monModule_passetout
label: passetout
category: '[monModule]'

templates:
imports: from gnuradio import monModule
make: monModule.passetout()

# Make one 'parameters' list entry for every parameter you want settable from the GUI.
# Keys include:
# * id (makes the value accessible as keyname, e.g. in the make entry)
# * label (label shown in the GUI)
# * dtype (e.g. int, float, complex, byte, short, xxx_vector, ...)
# * default
parameters:
- id: parametername_replace_me
label: FIX ME:
dtype: string
default: You need to fill in your grc/monModule_passetout.block.yaml
#- id: ...
# label: ...
# dtype: ...

# Make one 'inputs' list entry per input and one 'outputs' list entry per output.
# Keys include:
# * label (an identifier for the GUI)
# * domain (optional - stream or message. Default is stream)
# * dtype (e.g. int, float, complex, byte, short, xxx_vector, ...)
# * vlen (optional - data stream vector length. Default is 1)
# * optional (optional - set to 1 for optional inputs. Default is 0)
inputs:
#- label: ...
# domain: ...
# dtype: ...
# vlen: ...
# optional: ...

outputs:
#- label: ...
# domain: ...
# dtype: ...
# vlen: ...
# optional: ...

# 'file_format' specifies the version of the GRC yml format used in the file
# and should usually not be changed.
file_format: 1
</source>
{{boîte déroulante/fin}}

{{Todos| Mettre à jour la section <code>parameters</code> (pas de paramètres, on commente) :}}

<source lang=yaml>
#parameters:
#- id: parametername_replace_me
# label: FIX ME:
# dtype: string
# default: You need to fill in your grc/customModule_testMod.block.yaml
</source>

{{Todos| Mettre à jour la section <code>inputs</code> :}}

<source lang=yaml>
inputs:
- label: in
domain: stream
dtype: float
</source>

{{Todos| Mettre à jour la section <code>output</code> :}}

<source lang=yaml>
outputs:
- label: out
domain: stream
dtype: float
</source>

==== Compilation et installation ====

Voici les étapes :
<source lang=bash>
$ cd CHEMIN-DE-VOTRE-DOSSIER/gr-monModule
$ mkdir build
$ cd build
$ cmake ..
$ make
$ make install
</source>

* <code>cmake ..</code> lance la création des fichiers <code>Makefile</code> qui permettent la compilation et l'installation
* <code>make</code> lance la compilation
* <code>make install</code> lance l'installation (copie des fichiers dans les dossiers gnuradio)

{{Todos| Exécuter chacune de ces lignes, en contrôlant l'absence d'erreur. Dans le cas contraire, contrôler les fichiers <code>.h</code>, <code>.cc</code> et <code>.yaml</code>}}

{{Todos| '''Après ces étapes, et avant de lancer gnuRadio, appeler l'enseignant qui va mettre à jours les bibliothèques partagées.'''}}. Sinon tenter :
<source>
$ export LD_LIBRARY_PATH=/usr/local/lib/x86_64-linux-gnu:$LD_LIBRARY_PATH
$ gnuradio-companion &
</source>

==== Utilisation du bloc et test ====

* Dans Gnuradio, rafraichir la liste des bloc (bouton ''reload'')
* le bloc <code>passetout</code> doit être présent dans la section <code>monModule</code>
* Tester le bon fonctionnement de ce bloc en lui envoyant une sinusoïde que vous devez observer identique à la sortie du bloc. Vérifier avec des graphes.

==== Application : démodulation ====

En reprenant le signal modulé en amplitude et la fonction de transfert du filtre passe-bas du TP précédent :

* Obtenir l'équation aux différence du filtre, ''ie'' écrire ''y(n)='' en fonction de ''x(n)'', ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.
* Créer un nouveau bloc C++ (similaire au passe-tout précédent) dans le module <code>monModule</code> :
** de type <code>sync</code>
** une entrée en <code>float</code>
** une sortie en <code>float</code>
* Écrire le code permettant d'obtenir ''y(n)'' dans la méthode <code>work()</code> :
** ''x(n)'' est donné par <code>in0[0]</code>
** il sera nécessaire d'affecter <code>out0[0]</code> pour produire ''y(n)''.
** il sera nécessaire de stocker dans des '''attributs''' les valeurs de <code>in[0]</code> afin de disposer de ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.
** On rappelle que les attributs doivent être déclarées dans le fichier <code>.h</code> et initialisés dans le constructeur de la classe.

{{Todos| Réaliser cette implémentation du passe-bas et contrôler que la démodulation est identique à celle obtenue au TP précédent}}

{{Todos| Modifier votre code pour implémenter le filtre complet de démodulation}}

Fichier:TNS TP6 starter.ipynb.zip

2026-06-01T10:14:06Z

Fredmn :

Cours:Elen4 TNS TP TpsReel

2026-06-01T10:11:27Z

Fredmn : /* PID numérique "classique" */

[[Cours:Elen4_TNS|{{Rouge|'''Retour à la page du cours'''}}]]

<center>
'''<big>TP6 - Temps réel : bloc Gnuradio en Python / démodulation / PID Numérique</big>'''
</center>

Le but de ce TP est double :
* réaliser des implémentations temps réel de filtre IIR en créant un bloc Gnuradio qui execute un traitement codé en Python
* et étudier l'implémentation d'un PID numérique sous forme d'un filtre IIR.

Dans les deux cas, un système temps réel sera considéré :
* à intervalles de temps (réguliers ou non), une valeur ''x(n)'' rentre dans le système
* le travail consiste à calculer ''y(n)'' avec l'équation au différences du filtre, à partir de la valeur ''x(n)'' et de ses versions précédentes ''x(n-1)'' et ''x(n-2)'' (et aussi ''y(n-1)'', ''y(n-2)'') qu'il est donc nécessaire de stocker.
* La notion de ''temps réel'' implique que ''y(n)'' doit être calculer avant qu'une nouvelle valeurs de ''x(n)'' ne rentre dans le système.

=== Bloc Gnuradio en Python ===

Nous allons implémenter un filtre IIR dans gnuradio, en écrivant le traitement dans un bloc Python.

==== Filtre moyenneur====

{{q| a)}} Dans un premier temps, prendre connaissance du tutoriel suivant : [https://wiki.gnuradio.org/index.php?title=Creating_Your_First_Block wiki Gnuradio - ''Creating Your First Block'']

{{q| b)}} Nous allons écrire un filtre simple, qui implémente un simple moyenneur :
<source lang="Python">

import numpy as np
from gnuradio import gr

class blk(gr.sync_block):
def __init__(self): # Pas de paramètres
gr.sync_block.__init__(
self,
name="Filtre moyenneur",
in_sig=[np.float32],
out_sig=[np.float32]
)
self.xn1 = 0 # initialisation d'un attribut pour stocker x(n-1)

def work(self, input_items, output_items):
xn = input_items[0][0] # On ne "consomme" qu'un seul échantillon en entrée
yn = (xn + self.xn1) / 2
self.xn1 = xn
output_items[0][0] = yn # On ne produit donc également qu'un seul échantillon en sortie
return 1 # On retourne le nombre de valeurs consomées
</source>

==== Filtre IIR : démodulation ====

En reprenant le signal modulé en amplitude et la fonction de transfert du filtre passe-bas du TP précédent :

* Obtenir l'équation aux différence du filtre, ''ie'' écrire ''y(n)='' en fonction de ''x(n)'', ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.
* Créer un nouveau bloc Python dans le module <code>monModule</code> :
** de type <code>sync</code>
** une entrée en <code>np.float32</code>
** une sortie en <code>np.float32</code>
* Écrire le code permettant d'obtenir ''y(n)'' dans la méthode <code>work()</code> :
** ''x(n)'' est donné par <code>in[0][0]</code>
** il sera nécessaire de stocker dans des '''attributs''' les valeurs de ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.

{{q| a)}} Réaliser cette implémentation du passe-bas et contrôler que la démodulation est identique à celle obtenue au [[Cours:Elen4_TNS_TP_TraitAudioEtDemodulation|TP 5]].

{{q| b)}} Modifier votre code pour implémenter le filtre complet de démodulation.

=== Approximation de PID par filtre numérique linéaire ===

Cette partie sera travaillée dans un notebook Jupyter.

==== Rappels PID ====

* Principe

[[Fichier:PIDprincipe.png|400px]]

[[Fichier:PIDdetail.png|400px]]

* Définition mathématique, la sortie du controleur PID ''u(t)'' est donnée par:

[[Fichier:EqPID.png|400px]]

==== PID numérique "classique" ====

On considère que le temps est discrétisé : ''t = n.''d''t'' où d''t'' est l'intervalle de temps entre deux valeurs.

* En approximant grossièrement l'intégrale et la dérivée [[Fichier:PIDderivative.png|400px]] [[Fichier:PIDintegral.png|400px]]
** La dérivée est calculée par ''D = (e(n)-e(n-1))/''d''t''
** L'intégrale est approximée en cumulant progressivement : ''I = I + e(n).''d''t''
C'est ainsi que vous avez implémenté vos PID jusqu'ici.

Voici un notebook exemple à explorer sur deux modélisations : asservissement de 1) température et de 2) position ''z'' d'un drone.

{{q | a)}} ''Ki = Kd = 0'' => chercher le meilleur ''Kp'' => erreur statique.

{{q | b)}} ''Kd = 0'' => l'introduction du terme integral permet de corriger cette erreur statique.

{{q | c)}} Le terme dérivatif n'est pas nécessaire pour la température

{{q | d)}} Mais l'est pour asservir la position ''z'' du drone.

==== PID numérique avec un filtre numérique linéaire ====

* Cherchons la fonction de transfert du filtre continu d'un PID.
 En partant de l'équation différentielle
 [[Fichier:EqPID.png|500px]]
 On applique la transformée de Laplace (dérivée => multiplication par ''s'' ; intégrale => division par ''s'') :
 [[Fichier:eqFxTransfertPID.png|130]]
 Le terme dérivatif étant très sensible au bruit, on lui applique généralement un filtre passe bas (''w0/(w0+s)'') :
 [[Fichier:eqFxTransfertPIDetPB.png|130]]
* Approximation de la fonction de transfert pour obtenir un filtre numérique
** ''backward euler''
** et transformée bilinéaire

* Implémentation du Filtre : classe <code>FilterController</code>
* Application sur l'asservissement d'altitude d'un drone

=== Archive : codage de bloc Gnuradio en C++ ===

Ce guide est inspirée du guide [https://wiki.gnuradio.org/index.php?title=Creating_C%2B%2B_OOT_with_gr-modtool Creating an OOT (C++ block example)] en l'adaptant pour nos besoins :

Nous allons créer un simple bloc qui recopie son entrée (en <code>float</code>) sur sa sortie. Donc le filtre caractérisé par ''y(n)'' = ''x(n)'' ou encore ''H(z)''=1. Il s'agit donc d'une sorte de filtre passe-tout.

'''Suivez bien toutes les étapes, sans aller trop rapidement'''

* Vous pourrez utiliser <code>gedit</code> pour éditer les divers fichiers.

==== Création d'un module externe ====

Dans les lignes qui suivent, le <code>$</code> indique que l'on saisi une commande dans un terminal. Le <code>$</code> n'est pas à saisir.

* Ouvrez un terminal et placez-vous à la racine de votre dossier personnel :
<source>
$ cd $HOME
</source>
* Créez un dossier de travail dédié à gnuradio et déplacez-vous à l'intérieur :
<source>
$ mkdir gnuradio
$ cd gnuradio
</source>
* GNU Radio est livré avec gr_modtool, un utilitaire qui permet de créer des modules externes (OOT). Créons un module <code>monModule</code>
<source>
$ gr_modtool newmod monModule
</source>
* Le dossier <code>gr-monModule</code> est créé et contient tout le code squelette d'un module OOT, mais il n'a pas encore de blocs. Déplacez-vous dans <code>gr-monModule</code> :
<source>
$ cd gr-monModule
</source>
* Vous pouvez afficher le contenu de ce dossier par
<source>
$ ls
</source>

==== Création d'un bloc dans ce module ====

* Ajoutez un nouveau bloc nommé <code>passetout</code> :
<source>
$ gr_modtool add passetout
</source>
* Quelques questions permettent alors de spécifier le type de bloc
<source>
GNU Radio module name identified: passetout
('sink', 'source', 'sync', 'decimator', 'interpolator', 'general', 'tagged_stream', 'hier', 'noblock')
</source>
Saisissez <code>sync</code> comme type de bloc, car le bloc que nous écrivons produira le même nombre d'échantillons en sortie que le nombre d'échantillons consommés depuis l'entrée.
<source>
Enter block type: sync
</source>
* Spécifiez <code>cpp</code> comme langage :
<source>
Language (python/cpp): cpp
Language: C++
Block/code identifier: passetout
</source>
* Spécifiez un nom pour le copyright :
<source>
Please specify the copyright holder: Bibi
</source>
* Il est possible de spécifier des paramètres d'entrée qui peuvent permettre de régler le fonctionnement du bloc. Ce ne sera pas notre cas, ne rien saisir sur cette question :
<source>
Enter valid argument list, including default arguments:
</source>
* De même, on ne donnera pas de code permettant de tester le bon fonctionnement :
<source>
Add Python QA code? [Y/n] n
Add C++ QA code? [Y/n] n
</source>
* Plusieurs fichers sont alors crées :
<source>
Adding file 'lib/passetout_impl.h'...
Adding file 'lib/passetout_impl.cc'...
Adding file 'include/gnuradio/monModule/passetout.h'...
Adding file 'python/monModule/bindings/docstrings/passetout_pydoc_template.h'...
Adding file 'python/monModule/bindings/passetout_python.cc'...
Adding file 'grc/monModule_passetout.block.yml'...
Editing grc/CMakeLists.txt...
</source>

Quelques indications :
* le fichier <code>passetout_impl.h</code> contient l'entête de la classe de notre bloc
* le fichier <code>passetout_impl.cc</code> contient l'implémentation de la classe de notre bloc
* le fichier <code>monModule_passetout.block.yml</code> va contenir des informations faisant le lien entre notre code c++ et le code python utilisé en interne par Gnuradio
* Le tout sera compilé par un <code>Makefile</code> généré par <code>cmake</code>.

==== Fichier <code>passetout_impl.h</code> ====

Le code utile généré est le suivant :
<source lang=cpp>
class passetout_impl : public passetout
{
private:
// Nothing to declare in this block.

public:
passetout_impl();
~passetout_impl();

// Where all the action really happens
int work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items);
};
</source>

Pour se réveiller les neurones sur la POO, qu'est-ce que sont
* <code>passetout_impl()</code>,
* <code>~passetout_impl()</code>,
* <code>private</code>, <code>public</code> ?

Le travail sera réalisé dans la méthode <code>work()</code>, mais nous n'avons pas de modification à apporter dans les déclarations par défaut.

==== Fichier <code>passetout_impl.cc</code> ====

Le code utile généré est le suivant :

{{boîte déroulante/début|titre=passetout_impl.cc}}
<source lang=cpp>
namespace monModule {

#pragma message("set the following appropriately and remove this warning")
using input_type = float;
#pragma message("set the following appropriately and remove this warning")
using output_type = float;
passetout::sptr passetout::make() { return gnuradio::make_block_sptr<passetout_impl>(); }

/*
* The private constructor
*/
passetout_impl::passetout_impl()
: gr::sync_block("passetout",
gr::io_signature::make(
1 /* min inputs */, 1 /* max inputs */, sizeof(input_type)),
gr::io_signature::make(
1 /* min outputs */, 1 /*max outputs */, sizeof(output_type)))
{
}

/*
* Our virtual destructor.
*/
passetout_impl::~passetout_impl() {}

int passetout_impl::work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items)
{
auto in = static_cast<const input_type*>(input_items[0]);
auto out = static_cast<output_type*>(output_items[0]);

#pragma message("Implement the signal processing in your block and remove this warning")
// Do <+signal processing+>

// Tell runtime system how many output items we produced.
return noutput_items;
}

} /* namespace monModule */
</source>
{{boîte déroulante/fin}}

Détaillons :
<source lang=cpp>
#pragma message("set the following appropriately and remove this warning")
using input_type = float;
#pragma message("set the following appropriately and remove this warning")
using output_type = float;
</source>
{{Todos| On spécifie ici le type des données d'entrée et de sortie. Pas de modification à apporter, il suffit de supprimer les deux <code>#pragma</code>}}

<source lang=cpp>
passetout_impl::passetout_impl()
: gr::sync_block("passetout",
gr::io_signature::make(
1 /* min inputs */, 1 /* max inputs */, sizeof(input_type)),
gr::io_signature::make(
1 /* min outputs */, 1 /*max outputs */, sizeof(output_type)))
{
}
</source>

{{Todos| On spécifie ici le nombre d'entrées (1) et le nombre de sorties (1). Pas de modification non plus.}}

{{Todos| Expliquez la syntaxe <code>passetout_impl::passetout_impl() : gr::sync_block(...)"</code> }}

<source lang=cpp>
int passetout_impl::work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items)
{
auto in = static_cast<const input_type*>(input_items[0]);
auto out = static_cast<output_type*>(output_items[0]);

#pragma message("Implement the signal processing in your block and remove this warning")
// Do <+signal processing+>

// Tell runtime system how many output items we produced.
return noutput_items;
}
</source>
Cette méthode <code>work()</code> implémente véritablement le filtrage.
* Les tableaux <code>in</code> et <code>out</code> contiennent respectivement les données en entrée et les données en sortie. Il faut donc calculer <code>out</code> en fonction de <code>in</code>
* Les données d'entrée arrivent par paquets dans un buffer. La variable <code>noutput_items</code> contient le nombre de données disponibles en entrées.
* à la fin de la méthode, on renvoie le nombre de données en sortie que l'on a calculé (entre 1 et <code>noutput_items</code>). Les données d'entrées éventuellement non consommées seront conservées dans le buffer pour le prochain appel de <code>work()</code>
{{Todos| On souhaite ici seulement recopier l'entrée sur la sortie, donc }}
# Enlever la ligne <code>#pragma</code>
# ajouter le code <code> out[0] = in[0];</code> (on recopie le premier échantillon disponible en entrée)
# changer <code>return noutput_items;</code> en <code>return 1;</code> (un seul échantillon a été consommé).

==== Fichier <code>monModule_passetout.block.yml</code> ====

Ce fichier au format YAML (''yet another markup language'') fait le lien entre le code c++ et le code python utilisé en interne par GnuRadio.

{{boîte déroulante/début|titre=monModule_passetout.block.yml}}
<source lang=yaml>
id: monModule_passetout
label: passetout
category: '[monModule]'

templates:
imports: from gnuradio import monModule
make: monModule.passetout()

# Make one 'parameters' list entry for every parameter you want settable from the GUI.
# Keys include:
# * id (makes the value accessible as keyname, e.g. in the make entry)
# * label (label shown in the GUI)
# * dtype (e.g. int, float, complex, byte, short, xxx_vector, ...)
# * default
parameters:
- id: parametername_replace_me
label: FIX ME:
dtype: string
default: You need to fill in your grc/monModule_passetout.block.yaml
#- id: ...
# label: ...
# dtype: ...

# Make one 'inputs' list entry per input and one 'outputs' list entry per output.
# Keys include:
# * label (an identifier for the GUI)
# * domain (optional - stream or message. Default is stream)
# * dtype (e.g. int, float, complex, byte, short, xxx_vector, ...)
# * vlen (optional - data stream vector length. Default is 1)
# * optional (optional - set to 1 for optional inputs. Default is 0)
inputs:
#- label: ...
# domain: ...
# dtype: ...
# vlen: ...
# optional: ...

outputs:
#- label: ...
# domain: ...
# dtype: ...
# vlen: ...
# optional: ...

# 'file_format' specifies the version of the GRC yml format used in the file
# and should usually not be changed.
file_format: 1
</source>
{{boîte déroulante/fin}}

{{Todos| Mettre à jour la section <code>parameters</code> (pas de paramètres, on commente) :}}

<source lang=yaml>
#parameters:
#- id: parametername_replace_me
# label: FIX ME:
# dtype: string
# default: You need to fill in your grc/customModule_testMod.block.yaml
</source>

{{Todos| Mettre à jour la section <code>inputs</code> :}}

<source lang=yaml>
inputs:
- label: in
domain: stream
dtype: float
</source>

{{Todos| Mettre à jour la section <code>output</code> :}}

<source lang=yaml>
outputs:
- label: out
domain: stream
dtype: float
</source>

==== Compilation et installation ====

Voici les étapes :
<source lang=bash>
$ cd CHEMIN-DE-VOTRE-DOSSIER/gr-monModule
$ mkdir build
$ cd build
$ cmake ..
$ make
$ make install
</source>

* <code>cmake ..</code> lance la création des fichiers <code>Makefile</code> qui permettent la compilation et l'installation
* <code>make</code> lance la compilation
* <code>make install</code> lance l'installation (copie des fichiers dans les dossiers gnuradio)

{{Todos| Exécuter chacune de ces lignes, en contrôlant l'absence d'erreur. Dans le cas contraire, contrôler les fichiers <code>.h</code>, <code>.cc</code> et <code>.yaml</code>}}

{{Todos| '''Après ces étapes, et avant de lancer gnuRadio, appeler l'enseignant qui va mettre à jours les bibliothèques partagées.'''}}. Sinon tenter :
<source>
$ export LD_LIBRARY_PATH=/usr/local/lib/x86_64-linux-gnu:$LD_LIBRARY_PATH
$ gnuradio-companion &
</source>

==== Utilisation du bloc et test ====

* Dans Gnuradio, rafraichir la liste des bloc (bouton ''reload'')
* le bloc <code>passetout</code> doit être présent dans la section <code>monModule</code>
* Tester le bon fonctionnement de ce bloc en lui envoyant une sinusoïde que vous devez observer identique à la sortie du bloc. Vérifier avec des graphes.

==== Application : démodulation ====

En reprenant le signal modulé en amplitude et la fonction de transfert du filtre passe-bas du TP précédent :

* Obtenir l'équation aux différence du filtre, ''ie'' écrire ''y(n)='' en fonction de ''x(n)'', ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.
* Créer un nouveau bloc C++ (similaire au passe-tout précédent) dans le module <code>monModule</code> :
** de type <code>sync</code>
** une entrée en <code>float</code>
** une sortie en <code>float</code>
* Écrire le code permettant d'obtenir ''y(n)'' dans la méthode <code>work()</code> :
** ''x(n)'' est donné par <code>in0[0]</code>
** il sera nécessaire d'affecter <code>out0[0]</code> pour produire ''y(n)''.
** il sera nécessaire de stocker dans des '''attributs''' les valeurs de <code>in[0]</code> afin de disposer de ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.
** On rappelle que les attributs doivent être déclarées dans le fichier <code>.h</code> et initialisés dans le constructeur de la classe.

{{Todos| Réaliser cette implémentation du passe-bas et contrôler que la démodulation est identique à celle obtenue au TP précédent}}

{{Todos| Modifier votre code pour implémenter le filtre complet de démodulation}}

Cours:Elen4 TNS TP TpsReel

2026-06-01T10:10:21Z

Fredmn : /* PID numérique par approximation d'un filtre continu */

[[Cours:Elen4_TNS|{{Rouge|'''Retour à la page du cours'''}}]]

<center>
'''<big>TP6 - Temps réel : bloc Gnuradio en Python / démodulation / PID Numérique</big>'''
</center>

Le but de ce TP est double :
* réaliser des implémentations temps réel de filtre IIR en créant un bloc Gnuradio qui execute un traitement codé en Python
* et étudier l'implémentation d'un PID numérique sous forme d'un filtre IIR.

Dans les deux cas, un système temps réel sera considéré :
* à intervalles de temps (réguliers ou non), une valeur ''x(n)'' rentre dans le système
* le travail consiste à calculer ''y(n)'' avec l'équation au différences du filtre, à partir de la valeur ''x(n)'' et de ses versions précédentes ''x(n-1)'' et ''x(n-2)'' (et aussi ''y(n-1)'', ''y(n-2)'') qu'il est donc nécessaire de stocker.
* La notion de ''temps réel'' implique que ''y(n)'' doit être calculer avant qu'une nouvelle valeurs de ''x(n)'' ne rentre dans le système.

=== Bloc Gnuradio en Python ===

Nous allons implémenter un filtre IIR dans gnuradio, en écrivant le traitement dans un bloc Python.

==== Filtre moyenneur====

{{q| a)}} Dans un premier temps, prendre connaissance du tutoriel suivant : [https://wiki.gnuradio.org/index.php?title=Creating_Your_First_Block wiki Gnuradio - ''Creating Your First Block'']

{{q| b)}} Nous allons écrire un filtre simple, qui implémente un simple moyenneur :
<source lang="Python">

import numpy as np
from gnuradio import gr

class blk(gr.sync_block):
def __init__(self): # Pas de paramètres
gr.sync_block.__init__(
self,
name="Filtre moyenneur",
in_sig=[np.float32],
out_sig=[np.float32]
)
self.xn1 = 0 # initialisation d'un attribut pour stocker x(n-1)

def work(self, input_items, output_items):
xn = input_items[0][0] # On ne "consomme" qu'un seul échantillon en entrée
yn = (xn + self.xn1) / 2
self.xn1 = xn
output_items[0][0] = yn # On ne produit donc également qu'un seul échantillon en sortie
return 1 # On retourne le nombre de valeurs consomées
</source>

==== Filtre IIR : démodulation ====

En reprenant le signal modulé en amplitude et la fonction de transfert du filtre passe-bas du TP précédent :

* Obtenir l'équation aux différence du filtre, ''ie'' écrire ''y(n)='' en fonction de ''x(n)'', ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.
* Créer un nouveau bloc Python dans le module <code>monModule</code> :
** de type <code>sync</code>
** une entrée en <code>np.float32</code>
** une sortie en <code>np.float32</code>
* Écrire le code permettant d'obtenir ''y(n)'' dans la méthode <code>work()</code> :
** ''x(n)'' est donné par <code>in[0][0]</code>
** il sera nécessaire de stocker dans des '''attributs''' les valeurs de ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.

{{q| a)}} Réaliser cette implémentation du passe-bas et contrôler que la démodulation est identique à celle obtenue au [[Cours:Elen4_TNS_TP_TraitAudioEtDemodulation|TP 5]].

{{q| b)}} Modifier votre code pour implémenter le filtre complet de démodulation.

=== Approximation de PID par filtre numérique linéaire ===

Cette partie sera travaillée dans un notebook Jupyter.

==== Rappels PID ====

* Principe

[[Fichier:PIDprincipe.png|400px]]

[[Fichier:PIDdetail.png|400px]]

* Définition mathématique, la sortie du controleur PID ''u(t)'' est donnée par:

[[Fichier:EqPID.png|400px]]

==== PID numérique "classique" ====

On considère que le temps est discrétisé : ''t = n.''d''t'' où d''t'' est l'intervalle de temps entre deux valeurs.

* En approximant grossièrement l'intégrale et la dérivée [[Fichier:PIDderivative.png|400px]] [[Fichier:PIDintegral.png|400px]]
** La dérivée est calculée par ''D = (e(n)-e(n-1))/''d''t''
** L'intégrale est approximée en cumulant progressivement : ''I = I + e(n).''d''t''
C'est ainsi que vous avez implémenté vos PID jusqu'ici.

Voici un notebook exemple à explorer sur deux modélisations : asservissement de 1) température et de 2) position ''z'' d'un drone.

{{q | a}} ''Ki = Kd = 0'' => chercher le meilleur ''Kp'' => erreur statique.
{{q | b}} ''Kd = 0'' => l'introduction du terme integral permet de corriger cette erreur statique.
{{q | c}} Le terme dérivatif n'est pas nécessaire pour la température
{{q | d}} Mais l'est pour asservir la position ''z'' du drone.

==== PID numérique avec un filtre numérique linéaire ====

* Cherchons la fonction de transfert du filtre continu d'un PID.
 En partant de l'équation différentielle
 [[Fichier:EqPID.png|500px]]
 On applique la transformée de Laplace (dérivée => multiplication par ''s'' ; intégrale => division par ''s'') :
 [[Fichier:eqFxTransfertPID.png|130]]
 Le terme dérivatif étant très sensible au bruit, on lui applique généralement un filtre passe bas (''w0/(w0+s)'') :
 [[Fichier:eqFxTransfertPIDetPB.png|130]]
* Approximation de la fonction de transfert pour obtenir un filtre numérique
** ''backward euler''
** et transformée bilinéaire

* Implémentation du Filtre : classe <code>FilterController</code>
* Application sur l'asservissement d'altitude d'un drone

=== Archive : codage de bloc Gnuradio en C++ ===

Ce guide est inspirée du guide [https://wiki.gnuradio.org/index.php?title=Creating_C%2B%2B_OOT_with_gr-modtool Creating an OOT (C++ block example)] en l'adaptant pour nos besoins :

Nous allons créer un simple bloc qui recopie son entrée (en <code>float</code>) sur sa sortie. Donc le filtre caractérisé par ''y(n)'' = ''x(n)'' ou encore ''H(z)''=1. Il s'agit donc d'une sorte de filtre passe-tout.

'''Suivez bien toutes les étapes, sans aller trop rapidement'''

* Vous pourrez utiliser <code>gedit</code> pour éditer les divers fichiers.

==== Création d'un module externe ====

Dans les lignes qui suivent, le <code>$</code> indique que l'on saisi une commande dans un terminal. Le <code>$</code> n'est pas à saisir.

* Ouvrez un terminal et placez-vous à la racine de votre dossier personnel :
<source>
$ cd $HOME
</source>
* Créez un dossier de travail dédié à gnuradio et déplacez-vous à l'intérieur :
<source>
$ mkdir gnuradio
$ cd gnuradio
</source>
* GNU Radio est livré avec gr_modtool, un utilitaire qui permet de créer des modules externes (OOT). Créons un module <code>monModule</code>
<source>
$ gr_modtool newmod monModule
</source>
* Le dossier <code>gr-monModule</code> est créé et contient tout le code squelette d'un module OOT, mais il n'a pas encore de blocs. Déplacez-vous dans <code>gr-monModule</code> :
<source>
$ cd gr-monModule
</source>
* Vous pouvez afficher le contenu de ce dossier par
<source>
$ ls
</source>

==== Création d'un bloc dans ce module ====

* Ajoutez un nouveau bloc nommé <code>passetout</code> :
<source>
$ gr_modtool add passetout
</source>
* Quelques questions permettent alors de spécifier le type de bloc
<source>
GNU Radio module name identified: passetout
('sink', 'source', 'sync', 'decimator', 'interpolator', 'general', 'tagged_stream', 'hier', 'noblock')
</source>
Saisissez <code>sync</code> comme type de bloc, car le bloc que nous écrivons produira le même nombre d'échantillons en sortie que le nombre d'échantillons consommés depuis l'entrée.
<source>
Enter block type: sync
</source>
* Spécifiez <code>cpp</code> comme langage :
<source>
Language (python/cpp): cpp
Language: C++
Block/code identifier: passetout
</source>
* Spécifiez un nom pour le copyright :
<source>
Please specify the copyright holder: Bibi
</source>
* Il est possible de spécifier des paramètres d'entrée qui peuvent permettre de régler le fonctionnement du bloc. Ce ne sera pas notre cas, ne rien saisir sur cette question :
<source>
Enter valid argument list, including default arguments:
</source>
* De même, on ne donnera pas de code permettant de tester le bon fonctionnement :
<source>
Add Python QA code? [Y/n] n
Add C++ QA code? [Y/n] n
</source>
* Plusieurs fichers sont alors crées :
<source>
Adding file 'lib/passetout_impl.h'...
Adding file 'lib/passetout_impl.cc'...
Adding file 'include/gnuradio/monModule/passetout.h'...
Adding file 'python/monModule/bindings/docstrings/passetout_pydoc_template.h'...
Adding file 'python/monModule/bindings/passetout_python.cc'...
Adding file 'grc/monModule_passetout.block.yml'...
Editing grc/CMakeLists.txt...
</source>

Quelques indications :
* le fichier <code>passetout_impl.h</code> contient l'entête de la classe de notre bloc
* le fichier <code>passetout_impl.cc</code> contient l'implémentation de la classe de notre bloc
* le fichier <code>monModule_passetout.block.yml</code> va contenir des informations faisant le lien entre notre code c++ et le code python utilisé en interne par Gnuradio
* Le tout sera compilé par un <code>Makefile</code> généré par <code>cmake</code>.

==== Fichier <code>passetout_impl.h</code> ====

Le code utile généré est le suivant :
<source lang=cpp>
class passetout_impl : public passetout
{
private:
// Nothing to declare in this block.

public:
passetout_impl();
~passetout_impl();

// Where all the action really happens
int work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items);
};
</source>

Pour se réveiller les neurones sur la POO, qu'est-ce que sont
* <code>passetout_impl()</code>,
* <code>~passetout_impl()</code>,
* <code>private</code>, <code>public</code> ?

Le travail sera réalisé dans la méthode <code>work()</code>, mais nous n'avons pas de modification à apporter dans les déclarations par défaut.

==== Fichier <code>passetout_impl.cc</code> ====

Le code utile généré est le suivant :

{{boîte déroulante/début|titre=passetout_impl.cc}}
<source lang=cpp>
namespace monModule {

#pragma message("set the following appropriately and remove this warning")
using input_type = float;
#pragma message("set the following appropriately and remove this warning")
using output_type = float;
passetout::sptr passetout::make() { return gnuradio::make_block_sptr<passetout_impl>(); }

/*
* The private constructor
*/
passetout_impl::passetout_impl()
: gr::sync_block("passetout",
gr::io_signature::make(
1 /* min inputs */, 1 /* max inputs */, sizeof(input_type)),
gr::io_signature::make(
1 /* min outputs */, 1 /*max outputs */, sizeof(output_type)))
{
}

/*
* Our virtual destructor.
*/
passetout_impl::~passetout_impl() {}

int passetout_impl::work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items)
{
auto in = static_cast<const input_type*>(input_items[0]);
auto out = static_cast<output_type*>(output_items[0]);

#pragma message("Implement the signal processing in your block and remove this warning")
// Do <+signal processing+>

// Tell runtime system how many output items we produced.
return noutput_items;
}

} /* namespace monModule */
</source>
{{boîte déroulante/fin}}

Détaillons :
<source lang=cpp>
#pragma message("set the following appropriately and remove this warning")
using input_type = float;
#pragma message("set the following appropriately and remove this warning")
using output_type = float;
</source>
{{Todos| On spécifie ici le type des données d'entrée et de sortie. Pas de modification à apporter, il suffit de supprimer les deux <code>#pragma</code>}}

<source lang=cpp>
passetout_impl::passetout_impl()
: gr::sync_block("passetout",
gr::io_signature::make(
1 /* min inputs */, 1 /* max inputs */, sizeof(input_type)),
gr::io_signature::make(
1 /* min outputs */, 1 /*max outputs */, sizeof(output_type)))
{
}
</source>

{{Todos| On spécifie ici le nombre d'entrées (1) et le nombre de sorties (1). Pas de modification non plus.}}

{{Todos| Expliquez la syntaxe <code>passetout_impl::passetout_impl() : gr::sync_block(...)"</code> }}

<source lang=cpp>
int passetout_impl::work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items)
{
auto in = static_cast<const input_type*>(input_items[0]);
auto out = static_cast<output_type*>(output_items[0]);

#pragma message("Implement the signal processing in your block and remove this warning")
// Do <+signal processing+>

// Tell runtime system how many output items we produced.
return noutput_items;
}
</source>
Cette méthode <code>work()</code> implémente véritablement le filtrage.
* Les tableaux <code>in</code> et <code>out</code> contiennent respectivement les données en entrée et les données en sortie. Il faut donc calculer <code>out</code> en fonction de <code>in</code>
* Les données d'entrée arrivent par paquets dans un buffer. La variable <code>noutput_items</code> contient le nombre de données disponibles en entrées.
* à la fin de la méthode, on renvoie le nombre de données en sortie que l'on a calculé (entre 1 et <code>noutput_items</code>). Les données d'entrées éventuellement non consommées seront conservées dans le buffer pour le prochain appel de <code>work()</code>
{{Todos| On souhaite ici seulement recopier l'entrée sur la sortie, donc }}
# Enlever la ligne <code>#pragma</code>
# ajouter le code <code> out[0] = in[0];</code> (on recopie le premier échantillon disponible en entrée)
# changer <code>return noutput_items;</code> en <code>return 1;</code> (un seul échantillon a été consommé).

==== Fichier <code>monModule_passetout.block.yml</code> ====

Ce fichier au format YAML (''yet another markup language'') fait le lien entre le code c++ et le code python utilisé en interne par GnuRadio.

{{boîte déroulante/début|titre=monModule_passetout.block.yml}}
<source lang=yaml>
id: monModule_passetout
label: passetout
category: '[monModule]'

templates:
imports: from gnuradio import monModule
make: monModule.passetout()

# Make one 'parameters' list entry for every parameter you want settable from the GUI.
# Keys include:
# * id (makes the value accessible as keyname, e.g. in the make entry)
# * label (label shown in the GUI)
# * dtype (e.g. int, float, complex, byte, short, xxx_vector, ...)
# * default
parameters:
- id: parametername_replace_me
label: FIX ME:
dtype: string
default: You need to fill in your grc/monModule_passetout.block.yaml
#- id: ...
# label: ...
# dtype: ...

# Make one 'inputs' list entry per input and one 'outputs' list entry per output.
# Keys include:
# * label (an identifier for the GUI)
# * domain (optional - stream or message. Default is stream)
# * dtype (e.g. int, float, complex, byte, short, xxx_vector, ...)
# * vlen (optional - data stream vector length. Default is 1)
# * optional (optional - set to 1 for optional inputs. Default is 0)
inputs:
#- label: ...
# domain: ...
# dtype: ...
# vlen: ...
# optional: ...

outputs:
#- label: ...
# domain: ...
# dtype: ...
# vlen: ...
# optional: ...

# 'file_format' specifies the version of the GRC yml format used in the file
# and should usually not be changed.
file_format: 1
</source>
{{boîte déroulante/fin}}

{{Todos| Mettre à jour la section <code>parameters</code> (pas de paramètres, on commente) :}}

<source lang=yaml>
#parameters:
#- id: parametername_replace_me
# label: FIX ME:
# dtype: string
# default: You need to fill in your grc/customModule_testMod.block.yaml
</source>

{{Todos| Mettre à jour la section <code>inputs</code> :}}

<source lang=yaml>
inputs:
- label: in
domain: stream
dtype: float
</source>

{{Todos| Mettre à jour la section <code>output</code> :}}

<source lang=yaml>
outputs:
- label: out
domain: stream
dtype: float
</source>

==== Compilation et installation ====

Voici les étapes :
<source lang=bash>
$ cd CHEMIN-DE-VOTRE-DOSSIER/gr-monModule
$ mkdir build
$ cd build
$ cmake ..
$ make
$ make install
</source>

* <code>cmake ..</code> lance la création des fichiers <code>Makefile</code> qui permettent la compilation et l'installation
* <code>make</code> lance la compilation
* <code>make install</code> lance l'installation (copie des fichiers dans les dossiers gnuradio)

{{Todos| Exécuter chacune de ces lignes, en contrôlant l'absence d'erreur. Dans le cas contraire, contrôler les fichiers <code>.h</code>, <code>.cc</code> et <code>.yaml</code>}}

{{Todos| '''Après ces étapes, et avant de lancer gnuRadio, appeler l'enseignant qui va mettre à jours les bibliothèques partagées.'''}}. Sinon tenter :
<source>
$ export LD_LIBRARY_PATH=/usr/local/lib/x86_64-linux-gnu:$LD_LIBRARY_PATH
$ gnuradio-companion &
</source>

==== Utilisation du bloc et test ====

* Dans Gnuradio, rafraichir la liste des bloc (bouton ''reload'')
* le bloc <code>passetout</code> doit être présent dans la section <code>monModule</code>
* Tester le bon fonctionnement de ce bloc en lui envoyant une sinusoïde que vous devez observer identique à la sortie du bloc. Vérifier avec des graphes.

==== Application : démodulation ====

En reprenant le signal modulé en amplitude et la fonction de transfert du filtre passe-bas du TP précédent :

* Obtenir l'équation aux différence du filtre, ''ie'' écrire ''y(n)='' en fonction de ''x(n)'', ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.
* Créer un nouveau bloc C++ (similaire au passe-tout précédent) dans le module <code>monModule</code> :
** de type <code>sync</code>
** une entrée en <code>float</code>
** une sortie en <code>float</code>
* Écrire le code permettant d'obtenir ''y(n)'' dans la méthode <code>work()</code> :
** ''x(n)'' est donné par <code>in0[0]</code>
** il sera nécessaire d'affecter <code>out0[0]</code> pour produire ''y(n)''.
** il sera nécessaire de stocker dans des '''attributs''' les valeurs de <code>in[0]</code> afin de disposer de ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.
** On rappelle que les attributs doivent être déclarées dans le fichier <code>.h</code> et initialisés dans le constructeur de la classe.

{{Todos| Réaliser cette implémentation du passe-bas et contrôler que la démodulation est identique à celle obtenue au TP précédent}}

{{Todos| Modifier votre code pour implémenter le filtre complet de démodulation}}

Cours:Elen4 TNS TP TpsReel

2026-06-01T10:09:46Z

Fredmn : /* PID numérique "classique" */

[[Cours:Elen4_TNS|{{Rouge|'''Retour à la page du cours'''}}]]

<center>
'''<big>TP6 - Temps réel : bloc Gnuradio en Python / démodulation / PID Numérique</big>'''
</center>

Le but de ce TP est double :
* réaliser des implémentations temps réel de filtre IIR en créant un bloc Gnuradio qui execute un traitement codé en Python
* et étudier l'implémentation d'un PID numérique sous forme d'un filtre IIR.

Dans les deux cas, un système temps réel sera considéré :
* à intervalles de temps (réguliers ou non), une valeur ''x(n)'' rentre dans le système
* le travail consiste à calculer ''y(n)'' avec l'équation au différences du filtre, à partir de la valeur ''x(n)'' et de ses versions précédentes ''x(n-1)'' et ''x(n-2)'' (et aussi ''y(n-1)'', ''y(n-2)'') qu'il est donc nécessaire de stocker.
* La notion de ''temps réel'' implique que ''y(n)'' doit être calculer avant qu'une nouvelle valeurs de ''x(n)'' ne rentre dans le système.

=== Bloc Gnuradio en Python ===

Nous allons implémenter un filtre IIR dans gnuradio, en écrivant le traitement dans un bloc Python.

==== Filtre moyenneur====

{{q| a)}} Dans un premier temps, prendre connaissance du tutoriel suivant : [https://wiki.gnuradio.org/index.php?title=Creating_Your_First_Block wiki Gnuradio - ''Creating Your First Block'']

{{q| b)}} Nous allons écrire un filtre simple, qui implémente un simple moyenneur :
<source lang="Python">

import numpy as np
from gnuradio import gr

class blk(gr.sync_block):
def __init__(self): # Pas de paramètres
gr.sync_block.__init__(
self,
name="Filtre moyenneur",
in_sig=[np.float32],
out_sig=[np.float32]
)
self.xn1 = 0 # initialisation d'un attribut pour stocker x(n-1)

def work(self, input_items, output_items):
xn = input_items[0][0] # On ne "consomme" qu'un seul échantillon en entrée
yn = (xn + self.xn1) / 2
self.xn1 = xn
output_items[0][0] = yn # On ne produit donc également qu'un seul échantillon en sortie
return 1 # On retourne le nombre de valeurs consomées
</source>

==== Filtre IIR : démodulation ====

En reprenant le signal modulé en amplitude et la fonction de transfert du filtre passe-bas du TP précédent :

* Obtenir l'équation aux différence du filtre, ''ie'' écrire ''y(n)='' en fonction de ''x(n)'', ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.
* Créer un nouveau bloc Python dans le module <code>monModule</code> :
** de type <code>sync</code>
** une entrée en <code>np.float32</code>
** une sortie en <code>np.float32</code>
* Écrire le code permettant d'obtenir ''y(n)'' dans la méthode <code>work()</code> :
** ''x(n)'' est donné par <code>in[0][0]</code>
** il sera nécessaire de stocker dans des '''attributs''' les valeurs de ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.

{{q| a)}} Réaliser cette implémentation du passe-bas et contrôler que la démodulation est identique à celle obtenue au [[Cours:Elen4_TNS_TP_TraitAudioEtDemodulation|TP 5]].

{{q| b)}} Modifier votre code pour implémenter le filtre complet de démodulation.

=== Approximation de PID par filtre numérique linéaire ===

Cette partie sera travaillée dans un notebook Jupyter.

==== Rappels PID ====

* Principe

[[Fichier:PIDprincipe.png|400px]]

[[Fichier:PIDdetail.png|400px]]

* Définition mathématique, la sortie du controleur PID ''u(t)'' est donnée par:

[[Fichier:EqPID.png|400px]]

==== PID numérique "classique" ====

On considère que le temps est discrétisé : ''t = n.''d''t'' où d''t'' est l'intervalle de temps entre deux valeurs.

* En approximant grossièrement l'intégrale et la dérivée [[Fichier:PIDderivative.png|400px]] [[Fichier:PIDintegral.png|400px]]
** La dérivée est calculée par ''D = (e(n)-e(n-1))/''d''t''
** L'intégrale est approximée en cumulant progressivement : ''I = I + e(n).''d''t''
C'est ainsi que vous avez implémenté vos PID jusqu'ici.

Voici un notebook exemple à explorer sur deux modélisations : asservissement de 1) température et de 2) position ''z'' d'un drone.

{{q | a}} ''Ki = Kd = 0'' => chercher le meilleur ''Kp'' => erreur statique.
{{q | b}} ''Kd = 0'' => l'introduction du terme integral permet de corriger cette erreur statique.
{{q | c}} Le terme dérivatif n'est pas nécessaire pour la température
{{q | d}} Mais l'est pour asservir la position ''z'' du drone.

==== PID numérique par approximation d'un filtre continu ====

* Cherchons la fonction de transfert du filtre continu d'un PID.
 En partant de l'équation différentielle
 [[Fichier:EqPID.png|500px]]
 On applique la transformée de Laplace (dérivée => multiplication par ''s'' ; intégrale => division par ''s'') :
 [[Fichier:eqFxTransfertPID.png|130]]
 Le terme dérivatif étant très sensible au bruit, on lui applique généralement un filtre passe bas (''w0/(w0+s)'') :
 [[Fichier:eqFxTransfertPIDetPB.png|130]]
* Approximation de la fonction de transfert pour obtenir un filtre numérique
** ''backward euler''
** et transformée bilinéaire

* Implémentation du Filtre : classe <code>FilterController</code>
* Application sur l'asservissement d'altitude d'un drone

=== Archive : codage de bloc Gnuradio en C++ ===

Ce guide est inspirée du guide [https://wiki.gnuradio.org/index.php?title=Creating_C%2B%2B_OOT_with_gr-modtool Creating an OOT (C++ block example)] en l'adaptant pour nos besoins :

Nous allons créer un simple bloc qui recopie son entrée (en <code>float</code>) sur sa sortie. Donc le filtre caractérisé par ''y(n)'' = ''x(n)'' ou encore ''H(z)''=1. Il s'agit donc d'une sorte de filtre passe-tout.

'''Suivez bien toutes les étapes, sans aller trop rapidement'''

* Vous pourrez utiliser <code>gedit</code> pour éditer les divers fichiers.

==== Création d'un module externe ====

Dans les lignes qui suivent, le <code>$</code> indique que l'on saisi une commande dans un terminal. Le <code>$</code> n'est pas à saisir.

* Ouvrez un terminal et placez-vous à la racine de votre dossier personnel :
<source>
$ cd $HOME
</source>
* Créez un dossier de travail dédié à gnuradio et déplacez-vous à l'intérieur :
<source>
$ mkdir gnuradio
$ cd gnuradio
</source>
* GNU Radio est livré avec gr_modtool, un utilitaire qui permet de créer des modules externes (OOT). Créons un module <code>monModule</code>
<source>
$ gr_modtool newmod monModule
</source>
* Le dossier <code>gr-monModule</code> est créé et contient tout le code squelette d'un module OOT, mais il n'a pas encore de blocs. Déplacez-vous dans <code>gr-monModule</code> :
<source>
$ cd gr-monModule
</source>
* Vous pouvez afficher le contenu de ce dossier par
<source>
$ ls
</source>

==== Création d'un bloc dans ce module ====

* Ajoutez un nouveau bloc nommé <code>passetout</code> :
<source>
$ gr_modtool add passetout
</source>
* Quelques questions permettent alors de spécifier le type de bloc
<source>
GNU Radio module name identified: passetout
('sink', 'source', 'sync', 'decimator', 'interpolator', 'general', 'tagged_stream', 'hier', 'noblock')
</source>
Saisissez <code>sync</code> comme type de bloc, car le bloc que nous écrivons produira le même nombre d'échantillons en sortie que le nombre d'échantillons consommés depuis l'entrée.
<source>
Enter block type: sync
</source>
* Spécifiez <code>cpp</code> comme langage :
<source>
Language (python/cpp): cpp
Language: C++
Block/code identifier: passetout
</source>
* Spécifiez un nom pour le copyright :
<source>
Please specify the copyright holder: Bibi
</source>
* Il est possible de spécifier des paramètres d'entrée qui peuvent permettre de régler le fonctionnement du bloc. Ce ne sera pas notre cas, ne rien saisir sur cette question :
<source>
Enter valid argument list, including default arguments:
</source>
* De même, on ne donnera pas de code permettant de tester le bon fonctionnement :
<source>
Add Python QA code? [Y/n] n
Add C++ QA code? [Y/n] n
</source>
* Plusieurs fichers sont alors crées :
<source>
Adding file 'lib/passetout_impl.h'...
Adding file 'lib/passetout_impl.cc'...
Adding file 'include/gnuradio/monModule/passetout.h'...
Adding file 'python/monModule/bindings/docstrings/passetout_pydoc_template.h'...
Adding file 'python/monModule/bindings/passetout_python.cc'...
Adding file 'grc/monModule_passetout.block.yml'...
Editing grc/CMakeLists.txt...
</source>

Quelques indications :
* le fichier <code>passetout_impl.h</code> contient l'entête de la classe de notre bloc
* le fichier <code>passetout_impl.cc</code> contient l'implémentation de la classe de notre bloc
* le fichier <code>monModule_passetout.block.yml</code> va contenir des informations faisant le lien entre notre code c++ et le code python utilisé en interne par Gnuradio
* Le tout sera compilé par un <code>Makefile</code> généré par <code>cmake</code>.

==== Fichier <code>passetout_impl.h</code> ====

Le code utile généré est le suivant :
<source lang=cpp>
class passetout_impl : public passetout
{
private:
// Nothing to declare in this block.

public:
passetout_impl();
~passetout_impl();

// Where all the action really happens
int work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items);
};
</source>

Pour se réveiller les neurones sur la POO, qu'est-ce que sont
* <code>passetout_impl()</code>,
* <code>~passetout_impl()</code>,
* <code>private</code>, <code>public</code> ?

Le travail sera réalisé dans la méthode <code>work()</code>, mais nous n'avons pas de modification à apporter dans les déclarations par défaut.

==== Fichier <code>passetout_impl.cc</code> ====

Le code utile généré est le suivant :

{{boîte déroulante/début|titre=passetout_impl.cc}}
<source lang=cpp>
namespace monModule {

#pragma message("set the following appropriately and remove this warning")
using input_type = float;
#pragma message("set the following appropriately and remove this warning")
using output_type = float;
passetout::sptr passetout::make() { return gnuradio::make_block_sptr<passetout_impl>(); }

/*
* The private constructor
*/
passetout_impl::passetout_impl()
: gr::sync_block("passetout",
gr::io_signature::make(
1 /* min inputs */, 1 /* max inputs */, sizeof(input_type)),
gr::io_signature::make(
1 /* min outputs */, 1 /*max outputs */, sizeof(output_type)))
{
}

/*
* Our virtual destructor.
*/
passetout_impl::~passetout_impl() {}

int passetout_impl::work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items)
{
auto in = static_cast<const input_type*>(input_items[0]);
auto out = static_cast<output_type*>(output_items[0]);

#pragma message("Implement the signal processing in your block and remove this warning")
// Do <+signal processing+>

// Tell runtime system how many output items we produced.
return noutput_items;
}

} /* namespace monModule */
</source>
{{boîte déroulante/fin}}

Détaillons :
<source lang=cpp>
#pragma message("set the following appropriately and remove this warning")
using input_type = float;
#pragma message("set the following appropriately and remove this warning")
using output_type = float;
</source>
{{Todos| On spécifie ici le type des données d'entrée et de sortie. Pas de modification à apporter, il suffit de supprimer les deux <code>#pragma</code>}}

<source lang=cpp>
passetout_impl::passetout_impl()
: gr::sync_block("passetout",
gr::io_signature::make(
1 /* min inputs */, 1 /* max inputs */, sizeof(input_type)),
gr::io_signature::make(
1 /* min outputs */, 1 /*max outputs */, sizeof(output_type)))
{
}
</source>

{{Todos| On spécifie ici le nombre d'entrées (1) et le nombre de sorties (1). Pas de modification non plus.}}

{{Todos| Expliquez la syntaxe <code>passetout_impl::passetout_impl() : gr::sync_block(...)"</code> }}

<source lang=cpp>
int passetout_impl::work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items)
{
auto in = static_cast<const input_type*>(input_items[0]);
auto out = static_cast<output_type*>(output_items[0]);

#pragma message("Implement the signal processing in your block and remove this warning")
// Do <+signal processing+>

// Tell runtime system how many output items we produced.
return noutput_items;
}
</source>
Cette méthode <code>work()</code> implémente véritablement le filtrage.
* Les tableaux <code>in</code> et <code>out</code> contiennent respectivement les données en entrée et les données en sortie. Il faut donc calculer <code>out</code> en fonction de <code>in</code>
* Les données d'entrée arrivent par paquets dans un buffer. La variable <code>noutput_items</code> contient le nombre de données disponibles en entrées.
* à la fin de la méthode, on renvoie le nombre de données en sortie que l'on a calculé (entre 1 et <code>noutput_items</code>). Les données d'entrées éventuellement non consommées seront conservées dans le buffer pour le prochain appel de <code>work()</code>
{{Todos| On souhaite ici seulement recopier l'entrée sur la sortie, donc }}
# Enlever la ligne <code>#pragma</code>
# ajouter le code <code> out[0] = in[0];</code> (on recopie le premier échantillon disponible en entrée)
# changer <code>return noutput_items;</code> en <code>return 1;</code> (un seul échantillon a été consommé).

==== Fichier <code>monModule_passetout.block.yml</code> ====

Ce fichier au format YAML (''yet another markup language'') fait le lien entre le code c++ et le code python utilisé en interne par GnuRadio.

{{boîte déroulante/début|titre=monModule_passetout.block.yml}}
<source lang=yaml>
id: monModule_passetout
label: passetout
category: '[monModule]'

templates:
imports: from gnuradio import monModule
make: monModule.passetout()

# Make one 'parameters' list entry for every parameter you want settable from the GUI.
# Keys include:
# * id (makes the value accessible as keyname, e.g. in the make entry)
# * label (label shown in the GUI)
# * dtype (e.g. int, float, complex, byte, short, xxx_vector, ...)
# * default
parameters:
- id: parametername_replace_me
label: FIX ME:
dtype: string
default: You need to fill in your grc/monModule_passetout.block.yaml
#- id: ...
# label: ...
# dtype: ...

# Make one 'inputs' list entry per input and one 'outputs' list entry per output.
# Keys include:
# * label (an identifier for the GUI)
# * domain (optional - stream or message. Default is stream)
# * dtype (e.g. int, float, complex, byte, short, xxx_vector, ...)
# * vlen (optional - data stream vector length. Default is 1)
# * optional (optional - set to 1 for optional inputs. Default is 0)
inputs:
#- label: ...
# domain: ...
# dtype: ...
# vlen: ...
# optional: ...

outputs:
#- label: ...
# domain: ...
# dtype: ...
# vlen: ...
# optional: ...

# 'file_format' specifies the version of the GRC yml format used in the file
# and should usually not be changed.
file_format: 1
</source>
{{boîte déroulante/fin}}

{{Todos| Mettre à jour la section <code>parameters</code> (pas de paramètres, on commente) :}}

<source lang=yaml>
#parameters:
#- id: parametername_replace_me
# label: FIX ME:
# dtype: string
# default: You need to fill in your grc/customModule_testMod.block.yaml
</source>

{{Todos| Mettre à jour la section <code>inputs</code> :}}

<source lang=yaml>
inputs:
- label: in
domain: stream
dtype: float
</source>

{{Todos| Mettre à jour la section <code>output</code> :}}

<source lang=yaml>
outputs:
- label: out
domain: stream
dtype: float
</source>

==== Compilation et installation ====

Voici les étapes :
<source lang=bash>
$ cd CHEMIN-DE-VOTRE-DOSSIER/gr-monModule
$ mkdir build
$ cd build
$ cmake ..
$ make
$ make install
</source>

* <code>cmake ..</code> lance la création des fichiers <code>Makefile</code> qui permettent la compilation et l'installation
* <code>make</code> lance la compilation
* <code>make install</code> lance l'installation (copie des fichiers dans les dossiers gnuradio)

{{Todos| Exécuter chacune de ces lignes, en contrôlant l'absence d'erreur. Dans le cas contraire, contrôler les fichiers <code>.h</code>, <code>.cc</code> et <code>.yaml</code>}}

{{Todos| '''Après ces étapes, et avant de lancer gnuRadio, appeler l'enseignant qui va mettre à jours les bibliothèques partagées.'''}}. Sinon tenter :
<source>
$ export LD_LIBRARY_PATH=/usr/local/lib/x86_64-linux-gnu:$LD_LIBRARY_PATH
$ gnuradio-companion &
</source>

==== Utilisation du bloc et test ====

* Dans Gnuradio, rafraichir la liste des bloc (bouton ''reload'')
* le bloc <code>passetout</code> doit être présent dans la section <code>monModule</code>
* Tester le bon fonctionnement de ce bloc en lui envoyant une sinusoïde que vous devez observer identique à la sortie du bloc. Vérifier avec des graphes.

==== Application : démodulation ====

En reprenant le signal modulé en amplitude et la fonction de transfert du filtre passe-bas du TP précédent :

* Obtenir l'équation aux différence du filtre, ''ie'' écrire ''y(n)='' en fonction de ''x(n)'', ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.
* Créer un nouveau bloc C++ (similaire au passe-tout précédent) dans le module <code>monModule</code> :
** de type <code>sync</code>
** une entrée en <code>float</code>
** une sortie en <code>float</code>
* Écrire le code permettant d'obtenir ''y(n)'' dans la méthode <code>work()</code> :
** ''x(n)'' est donné par <code>in0[0]</code>
** il sera nécessaire d'affecter <code>out0[0]</code> pour produire ''y(n)''.
** il sera nécessaire de stocker dans des '''attributs''' les valeurs de <code>in[0]</code> afin de disposer de ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.
** On rappelle que les attributs doivent être déclarées dans le fichier <code>.h</code> et initialisés dans le constructeur de la classe.

{{Todos| Réaliser cette implémentation du passe-bas et contrôler que la démodulation est identique à celle obtenue au TP précédent}}

{{Todos| Modifier votre code pour implémenter le filtre complet de démodulation}}

Cours:Elen4 TNS TP TpsReel

2026-06-01T09:17:41Z

Fredmn : /* Approximation de PID par filtre numérique linéaire */

[[Cours:Elen4_TNS|{{Rouge|'''Retour à la page du cours'''}}]]

<center>
'''<big>TP6 - Temps réel : bloc Gnuradio en Python / démodulation / PID Numérique</big>'''
</center>

Le but de ce TP est double :
* réaliser des implémentations temps réel de filtre IIR en créant un bloc Gnuradio qui execute un traitement codé en Python
* et étudier l'implémentation d'un PID numérique sous forme d'un filtre IIR.

Dans les deux cas, un système temps réel sera considéré :
* à intervalles de temps (réguliers ou non), une valeur ''x(n)'' rentre dans le système
* le travail consiste à calculer ''y(n)'' avec l'équation au différences du filtre, à partir de la valeur ''x(n)'' et de ses versions précédentes ''x(n-1)'' et ''x(n-2)'' (et aussi ''y(n-1)'', ''y(n-2)'') qu'il est donc nécessaire de stocker.
* La notion de ''temps réel'' implique que ''y(n)'' doit être calculer avant qu'une nouvelle valeurs de ''x(n)'' ne rentre dans le système.

=== Bloc Gnuradio en Python ===

Nous allons implémenter un filtre IIR dans gnuradio, en écrivant le traitement dans un bloc Python.

==== Filtre moyenneur====

{{q| a)}} Dans un premier temps, prendre connaissance du tutoriel suivant : [https://wiki.gnuradio.org/index.php?title=Creating_Your_First_Block wiki Gnuradio - ''Creating Your First Block'']

{{q| b)}} Nous allons écrire un filtre simple, qui implémente un simple moyenneur :
<source lang="Python">

import numpy as np
from gnuradio import gr

class blk(gr.sync_block):
def __init__(self): # Pas de paramètres
gr.sync_block.__init__(
self,
name="Filtre moyenneur",
in_sig=[np.float32],
out_sig=[np.float32]
)
self.xn1 = 0 # initialisation d'un attribut pour stocker x(n-1)

def work(self, input_items, output_items):
xn = input_items[0][0] # On ne "consomme" qu'un seul échantillon en entrée
yn = (xn + self.xn1) / 2
self.xn1 = xn
output_items[0][0] = yn # On ne produit donc également qu'un seul échantillon en sortie
return 1 # On retourne le nombre de valeurs consomées
</source>

==== Filtre IIR : démodulation ====

En reprenant le signal modulé en amplitude et la fonction de transfert du filtre passe-bas du TP précédent :

* Obtenir l'équation aux différence du filtre, ''ie'' écrire ''y(n)='' en fonction de ''x(n)'', ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.
* Créer un nouveau bloc Python dans le module <code>monModule</code> :
** de type <code>sync</code>
** une entrée en <code>np.float32</code>
** une sortie en <code>np.float32</code>
* Écrire le code permettant d'obtenir ''y(n)'' dans la méthode <code>work()</code> :
** ''x(n)'' est donné par <code>in[0][0]</code>
** il sera nécessaire de stocker dans des '''attributs''' les valeurs de ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.

{{q| a)}} Réaliser cette implémentation du passe-bas et contrôler que la démodulation est identique à celle obtenue au [[Cours:Elen4_TNS_TP_TraitAudioEtDemodulation|TP 5]].

{{q| b)}} Modifier votre code pour implémenter le filtre complet de démodulation.

=== Approximation de PID par filtre numérique linéaire ===

Cette partie sera travaillée dans un notebook Jupyter.

==== Rappels PID ====

* Principe

[[Fichier:PIDprincipe.png|400px]]

[[Fichier:PIDdetail.png|400px]]

* Définition mathématique, la sortie du controleur PID ''u(t)'' est donnée par:

[[Fichier:EqPID.png|400px]]

==== PID numérique "classique" ====

On considère que le temps est discrétisé : ''t = n.dt'' où ''dt'' est l'intervalle de temps entre deux valeurs.

* En approximant grossièrement l'intégrale et la dérivée [[Fichier:PIDderivative.png|400px]] [[Fichier:PIDintegral.png|400px]]
** La dérivée est calculée par ''D = (e(n)-e(n-1))/dt''
** L'intégrale est approximée en cumulant progressivement : ''I = I + e(n).dt''

* Notebook exemple : asservissement de température
** ''Ki = Kd = 0'' => chercher le meilleur ''Kp'' => erreur de régime permanent
** ''Kd = 0'' => l'introduction du terme integral permet de corriger cette erreur de régime permanent
** Le terme dérivatif n'est pas nécessaire dans cet exemple car la température ne dépend que de la commande ''u(t)''.

==== PID numérique par approximation d'un filtre continu ====

* Cherchons la fonction de transfert du filtre continu d'un PID.
 En partant de l'équation différentielle
 [[Fichier:EqPID.png|500px]]
 On applique la transformée de Laplace (dérivée => multiplication par ''s'' ; intégrale => division par ''s'') :
 [[Fichier:eqFxTransfertPID.png|130]]
 Le terme dérivatif étant très sensible au bruit, on lui applique généralement un filtre passe bas (''w0/(w0+s)'') :
 [[Fichier:eqFxTransfertPIDetPB.png|130]]
* Approximation de la fonction de transfert pour obtenir un filtre numérique
** ''backward euler''
** et transformée bilinéaire

* Implémentation du Filtre : classe <code>FilterController</code>
* Application sur l'asservissement d'altitude d'un drone

=== Archive : codage de bloc Gnuradio en C++ ===

Ce guide est inspirée du guide [https://wiki.gnuradio.org/index.php?title=Creating_C%2B%2B_OOT_with_gr-modtool Creating an OOT (C++ block example)] en l'adaptant pour nos besoins :

Nous allons créer un simple bloc qui recopie son entrée (en <code>float</code>) sur sa sortie. Donc le filtre caractérisé par ''y(n)'' = ''x(n)'' ou encore ''H(z)''=1. Il s'agit donc d'une sorte de filtre passe-tout.

'''Suivez bien toutes les étapes, sans aller trop rapidement'''

* Vous pourrez utiliser <code>gedit</code> pour éditer les divers fichiers.

==== Création d'un module externe ====

Dans les lignes qui suivent, le <code>$</code> indique que l'on saisi une commande dans un terminal. Le <code>$</code> n'est pas à saisir.

* Ouvrez un terminal et placez-vous à la racine de votre dossier personnel :
<source>
$ cd $HOME
</source>
* Créez un dossier de travail dédié à gnuradio et déplacez-vous à l'intérieur :
<source>
$ mkdir gnuradio
$ cd gnuradio
</source>
* GNU Radio est livré avec gr_modtool, un utilitaire qui permet de créer des modules externes (OOT). Créons un module <code>monModule</code>
<source>
$ gr_modtool newmod monModule
</source>
* Le dossier <code>gr-monModule</code> est créé et contient tout le code squelette d'un module OOT, mais il n'a pas encore de blocs. Déplacez-vous dans <code>gr-monModule</code> :
<source>
$ cd gr-monModule
</source>
* Vous pouvez afficher le contenu de ce dossier par
<source>
$ ls
</source>

==== Création d'un bloc dans ce module ====

* Ajoutez un nouveau bloc nommé <code>passetout</code> :
<source>
$ gr_modtool add passetout
</source>
* Quelques questions permettent alors de spécifier le type de bloc
<source>
GNU Radio module name identified: passetout
('sink', 'source', 'sync', 'decimator', 'interpolator', 'general', 'tagged_stream', 'hier', 'noblock')
</source>
Saisissez <code>sync</code> comme type de bloc, car le bloc que nous écrivons produira le même nombre d'échantillons en sortie que le nombre d'échantillons consommés depuis l'entrée.
<source>
Enter block type: sync
</source>
* Spécifiez <code>cpp</code> comme langage :
<source>
Language (python/cpp): cpp
Language: C++
Block/code identifier: passetout
</source>
* Spécifiez un nom pour le copyright :
<source>
Please specify the copyright holder: Bibi
</source>
* Il est possible de spécifier des paramètres d'entrée qui peuvent permettre de régler le fonctionnement du bloc. Ce ne sera pas notre cas, ne rien saisir sur cette question :
<source>
Enter valid argument list, including default arguments:
</source>
* De même, on ne donnera pas de code permettant de tester le bon fonctionnement :
<source>
Add Python QA code? [Y/n] n
Add C++ QA code? [Y/n] n
</source>
* Plusieurs fichers sont alors crées :
<source>
Adding file 'lib/passetout_impl.h'...
Adding file 'lib/passetout_impl.cc'...
Adding file 'include/gnuradio/monModule/passetout.h'...
Adding file 'python/monModule/bindings/docstrings/passetout_pydoc_template.h'...
Adding file 'python/monModule/bindings/passetout_python.cc'...
Adding file 'grc/monModule_passetout.block.yml'...
Editing grc/CMakeLists.txt...
</source>

Quelques indications :
* le fichier <code>passetout_impl.h</code> contient l'entête de la classe de notre bloc
* le fichier <code>passetout_impl.cc</code> contient l'implémentation de la classe de notre bloc
* le fichier <code>monModule_passetout.block.yml</code> va contenir des informations faisant le lien entre notre code c++ et le code python utilisé en interne par Gnuradio
* Le tout sera compilé par un <code>Makefile</code> généré par <code>cmake</code>.

==== Fichier <code>passetout_impl.h</code> ====

Le code utile généré est le suivant :
<source lang=cpp>
class passetout_impl : public passetout
{
private:
// Nothing to declare in this block.

public:
passetout_impl();
~passetout_impl();

// Where all the action really happens
int work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items);
};
</source>

Pour se réveiller les neurones sur la POO, qu'est-ce que sont
* <code>passetout_impl()</code>,
* <code>~passetout_impl()</code>,
* <code>private</code>, <code>public</code> ?

Le travail sera réalisé dans la méthode <code>work()</code>, mais nous n'avons pas de modification à apporter dans les déclarations par défaut.

==== Fichier <code>passetout_impl.cc</code> ====

Le code utile généré est le suivant :

{{boîte déroulante/début|titre=passetout_impl.cc}}
<source lang=cpp>
namespace monModule {

#pragma message("set the following appropriately and remove this warning")
using input_type = float;
#pragma message("set the following appropriately and remove this warning")
using output_type = float;
passetout::sptr passetout::make() { return gnuradio::make_block_sptr<passetout_impl>(); }

/*
* The private constructor
*/
passetout_impl::passetout_impl()
: gr::sync_block("passetout",
gr::io_signature::make(
1 /* min inputs */, 1 /* max inputs */, sizeof(input_type)),
gr::io_signature::make(
1 /* min outputs */, 1 /*max outputs */, sizeof(output_type)))
{
}

/*
* Our virtual destructor.
*/
passetout_impl::~passetout_impl() {}

int passetout_impl::work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items)
{
auto in = static_cast<const input_type*>(input_items[0]);
auto out = static_cast<output_type*>(output_items[0]);

#pragma message("Implement the signal processing in your block and remove this warning")
// Do <+signal processing+>

// Tell runtime system how many output items we produced.
return noutput_items;
}

} /* namespace monModule */
</source>
{{boîte déroulante/fin}}

Détaillons :
<source lang=cpp>
#pragma message("set the following appropriately and remove this warning")
using input_type = float;
#pragma message("set the following appropriately and remove this warning")
using output_type = float;
</source>
{{Todos| On spécifie ici le type des données d'entrée et de sortie. Pas de modification à apporter, il suffit de supprimer les deux <code>#pragma</code>}}

<source lang=cpp>
passetout_impl::passetout_impl()
: gr::sync_block("passetout",
gr::io_signature::make(
1 /* min inputs */, 1 /* max inputs */, sizeof(input_type)),
gr::io_signature::make(
1 /* min outputs */, 1 /*max outputs */, sizeof(output_type)))
{
}
</source>

{{Todos| On spécifie ici le nombre d'entrées (1) et le nombre de sorties (1). Pas de modification non plus.}}

{{Todos| Expliquez la syntaxe <code>passetout_impl::passetout_impl() : gr::sync_block(...)"</code> }}

<source lang=cpp>
int passetout_impl::work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items)
{
auto in = static_cast<const input_type*>(input_items[0]);
auto out = static_cast<output_type*>(output_items[0]);

#pragma message("Implement the signal processing in your block and remove this warning")
// Do <+signal processing+>

// Tell runtime system how many output items we produced.
return noutput_items;
}
</source>
Cette méthode <code>work()</code> implémente véritablement le filtrage.
* Les tableaux <code>in</code> et <code>out</code> contiennent respectivement les données en entrée et les données en sortie. Il faut donc calculer <code>out</code> en fonction de <code>in</code>
* Les données d'entrée arrivent par paquets dans un buffer. La variable <code>noutput_items</code> contient le nombre de données disponibles en entrées.
* à la fin de la méthode, on renvoie le nombre de données en sortie que l'on a calculé (entre 1 et <code>noutput_items</code>). Les données d'entrées éventuellement non consommées seront conservées dans le buffer pour le prochain appel de <code>work()</code>
{{Todos| On souhaite ici seulement recopier l'entrée sur la sortie, donc }}
# Enlever la ligne <code>#pragma</code>
# ajouter le code <code> out[0] = in[0];</code> (on recopie le premier échantillon disponible en entrée)
# changer <code>return noutput_items;</code> en <code>return 1;</code> (un seul échantillon a été consommé).

==== Fichier <code>monModule_passetout.block.yml</code> ====

Ce fichier au format YAML (''yet another markup language'') fait le lien entre le code c++ et le code python utilisé en interne par GnuRadio.

{{boîte déroulante/début|titre=monModule_passetout.block.yml}}
<source lang=yaml>
id: monModule_passetout
label: passetout
category: '[monModule]'

templates:
imports: from gnuradio import monModule
make: monModule.passetout()

# Make one 'parameters' list entry for every parameter you want settable from the GUI.
# Keys include:
# * id (makes the value accessible as keyname, e.g. in the make entry)
# * label (label shown in the GUI)
# * dtype (e.g. int, float, complex, byte, short, xxx_vector, ...)
# * default
parameters:
- id: parametername_replace_me
label: FIX ME:
dtype: string
default: You need to fill in your grc/monModule_passetout.block.yaml
#- id: ...
# label: ...
# dtype: ...

# Make one 'inputs' list entry per input and one 'outputs' list entry per output.
# Keys include:
# * label (an identifier for the GUI)
# * domain (optional - stream or message. Default is stream)
# * dtype (e.g. int, float, complex, byte, short, xxx_vector, ...)
# * vlen (optional - data stream vector length. Default is 1)
# * optional (optional - set to 1 for optional inputs. Default is 0)
inputs:
#- label: ...
# domain: ...
# dtype: ...
# vlen: ...
# optional: ...

outputs:
#- label: ...
# domain: ...
# dtype: ...
# vlen: ...
# optional: ...

# 'file_format' specifies the version of the GRC yml format used in the file
# and should usually not be changed.
file_format: 1
</source>
{{boîte déroulante/fin}}

{{Todos| Mettre à jour la section <code>parameters</code> (pas de paramètres, on commente) :}}

<source lang=yaml>
#parameters:
#- id: parametername_replace_me
# label: FIX ME:
# dtype: string
# default: You need to fill in your grc/customModule_testMod.block.yaml
</source>

{{Todos| Mettre à jour la section <code>inputs</code> :}}

<source lang=yaml>
inputs:
- label: in
domain: stream
dtype: float
</source>

{{Todos| Mettre à jour la section <code>output</code> :}}

<source lang=yaml>
outputs:
- label: out
domain: stream
dtype: float
</source>

==== Compilation et installation ====

Voici les étapes :
<source lang=bash>
$ cd CHEMIN-DE-VOTRE-DOSSIER/gr-monModule
$ mkdir build
$ cd build
$ cmake ..
$ make
$ make install
</source>

* <code>cmake ..</code> lance la création des fichiers <code>Makefile</code> qui permettent la compilation et l'installation
* <code>make</code> lance la compilation
* <code>make install</code> lance l'installation (copie des fichiers dans les dossiers gnuradio)

{{Todos| Exécuter chacune de ces lignes, en contrôlant l'absence d'erreur. Dans le cas contraire, contrôler les fichiers <code>.h</code>, <code>.cc</code> et <code>.yaml</code>}}

{{Todos| '''Après ces étapes, et avant de lancer gnuRadio, appeler l'enseignant qui va mettre à jours les bibliothèques partagées.'''}}. Sinon tenter :
<source>
$ export LD_LIBRARY_PATH=/usr/local/lib/x86_64-linux-gnu:$LD_LIBRARY_PATH
$ gnuradio-companion &
</source>

==== Utilisation du bloc et test ====

* Dans Gnuradio, rafraichir la liste des bloc (bouton ''reload'')
* le bloc <code>passetout</code> doit être présent dans la section <code>monModule</code>
* Tester le bon fonctionnement de ce bloc en lui envoyant une sinusoïde que vous devez observer identique à la sortie du bloc. Vérifier avec des graphes.

==== Application : démodulation ====

En reprenant le signal modulé en amplitude et la fonction de transfert du filtre passe-bas du TP précédent :

* Obtenir l'équation aux différence du filtre, ''ie'' écrire ''y(n)='' en fonction de ''x(n)'', ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.
* Créer un nouveau bloc C++ (similaire au passe-tout précédent) dans le module <code>monModule</code> :
** de type <code>sync</code>
** une entrée en <code>float</code>
** une sortie en <code>float</code>
* Écrire le code permettant d'obtenir ''y(n)'' dans la méthode <code>work()</code> :
** ''x(n)'' est donné par <code>in0[0]</code>
** il sera nécessaire d'affecter <code>out0[0]</code> pour produire ''y(n)''.
** il sera nécessaire de stocker dans des '''attributs''' les valeurs de <code>in[0]</code> afin de disposer de ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.
** On rappelle que les attributs doivent être déclarées dans le fichier <code>.h</code> et initialisés dans le constructeur de la classe.

{{Todos| Réaliser cette implémentation du passe-bas et contrôler que la démodulation est identique à celle obtenue au TP précédent}}

{{Todos| Modifier votre code pour implémenter le filtre complet de démodulation}}

Cours:Elen4 TNS TP TpsReel

2026-06-01T09:17:00Z

Fredmn : /* Filtre IIR : démodulation */

[[Cours:Elen4_TNS|{{Rouge|'''Retour à la page du cours'''}}]]

<center>
'''<big>TP6 - Temps réel : bloc Gnuradio en Python / démodulation / PID Numérique</big>'''
</center>

Le but de ce TP est double :
* réaliser des implémentations temps réel de filtre IIR en créant un bloc Gnuradio qui execute un traitement codé en Python
* et étudier l'implémentation d'un PID numérique sous forme d'un filtre IIR.

Dans les deux cas, un système temps réel sera considéré :
* à intervalles de temps (réguliers ou non), une valeur ''x(n)'' rentre dans le système
* le travail consiste à calculer ''y(n)'' avec l'équation au différences du filtre, à partir de la valeur ''x(n)'' et de ses versions précédentes ''x(n-1)'' et ''x(n-2)'' (et aussi ''y(n-1)'', ''y(n-2)'') qu'il est donc nécessaire de stocker.
* La notion de ''temps réel'' implique que ''y(n)'' doit être calculer avant qu'une nouvelle valeurs de ''x(n)'' ne rentre dans le système.

=== Bloc Gnuradio en Python ===

Nous allons implémenter un filtre IIR dans gnuradio, en écrivant le traitement dans un bloc Python.

==== Filtre moyenneur====

{{q| a)}} Dans un premier temps, prendre connaissance du tutoriel suivant : [https://wiki.gnuradio.org/index.php?title=Creating_Your_First_Block wiki Gnuradio - ''Creating Your First Block'']

{{q| b)}} Nous allons écrire un filtre simple, qui implémente un simple moyenneur :
<source lang="Python">

import numpy as np
from gnuradio import gr

class blk(gr.sync_block):
def __init__(self): # Pas de paramètres
gr.sync_block.__init__(
self,
name="Filtre moyenneur",
in_sig=[np.float32],
out_sig=[np.float32]
)
self.xn1 = 0 # initialisation d'un attribut pour stocker x(n-1)

def work(self, input_items, output_items):
xn = input_items[0][0] # On ne "consomme" qu'un seul échantillon en entrée
yn = (xn + self.xn1) / 2
self.xn1 = xn
output_items[0][0] = yn # On ne produit donc également qu'un seul échantillon en sortie
return 1 # On retourne le nombre de valeurs consomées
</source>

==== Filtre IIR : démodulation ====

En reprenant le signal modulé en amplitude et la fonction de transfert du filtre passe-bas du TP précédent :

* Obtenir l'équation aux différence du filtre, ''ie'' écrire ''y(n)='' en fonction de ''x(n)'', ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.
* Créer un nouveau bloc Python dans le module <code>monModule</code> :
** de type <code>sync</code>
** une entrée en <code>np.float32</code>
** une sortie en <code>np.float32</code>
* Écrire le code permettant d'obtenir ''y(n)'' dans la méthode <code>work()</code> :
** ''x(n)'' est donné par <code>in[0][0]</code>
** il sera nécessaire de stocker dans des '''attributs''' les valeurs de ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.

{{q| a)}} Réaliser cette implémentation du passe-bas et contrôler que la démodulation est identique à celle obtenue au [[Cours:Elen4_TNS_TP_TraitAudioEtDemodulation|TP 5]].

{{q| b)}} Modifier votre code pour implémenter le filtre complet de démodulation.

=== Approximation de PID par filtre numérique linéaire ===

==== Rappels PID ====

* Principe

[[Fichier:PIDprincipe.png|400px]]

[[Fichier:PIDdetail.png|400px]]

* Définition mathématique, la sortie du controleur PID ''u(t)'' est donnée par:

[[Fichier:EqPID.png|400px]]

==== PID numérique "classique" ====

On considère que le temps est discrétisé : ''t = n.dt'' où ''dt'' est l'intervalle de temps entre deux valeurs.

* En approximant grossièrement l'intégrale et la dérivée [[Fichier:PIDderivative.png|400px]] [[Fichier:PIDintegral.png|400px]]
** La dérivée est calculée par ''D = (e(n)-e(n-1))/dt''
** L'intégrale est approximée en cumulant progressivement : ''I = I + e(n).dt''

* Notebook exemple : asservissement de température
** ''Ki = Kd = 0'' => chercher le meilleur ''Kp'' => erreur de régime permanent
** ''Kd = 0'' => l'introduction du terme integral permet de corriger cette erreur de régime permanent
** Le terme dérivatif n'est pas nécessaire dans cet exemple car la température ne dépend que de la commande ''u(t)''.

==== PID numérique par approximation d'un filtre continu ====

* Cherchons la fonction de transfert du filtre continu d'un PID.
 En partant de l'équation différentielle
 [[Fichier:EqPID.png|500px]]
 On applique la transformée de Laplace (dérivée => multiplication par ''s'' ; intégrale => division par ''s'') :
 [[Fichier:eqFxTransfertPID.png|130]]
 Le terme dérivatif étant très sensible au bruit, on lui applique généralement un filtre passe bas (''w0/(w0+s)'') :
 [[Fichier:eqFxTransfertPIDetPB.png|130]]
* Approximation de la fonction de transfert pour obtenir un filtre numérique
** ''backward euler''
** et transformée bilinéaire

* Implémentation du Filtre : classe <code>FilterController</code>
* Application sur l'asservissement d'altitude d'un drone

=== Archive : codage de bloc Gnuradio en C++ ===

Ce guide est inspirée du guide [https://wiki.gnuradio.org/index.php?title=Creating_C%2B%2B_OOT_with_gr-modtool Creating an OOT (C++ block example)] en l'adaptant pour nos besoins :

Nous allons créer un simple bloc qui recopie son entrée (en <code>float</code>) sur sa sortie. Donc le filtre caractérisé par ''y(n)'' = ''x(n)'' ou encore ''H(z)''=1. Il s'agit donc d'une sorte de filtre passe-tout.

'''Suivez bien toutes les étapes, sans aller trop rapidement'''

* Vous pourrez utiliser <code>gedit</code> pour éditer les divers fichiers.

==== Création d'un module externe ====

Dans les lignes qui suivent, le <code>$</code> indique que l'on saisi une commande dans un terminal. Le <code>$</code> n'est pas à saisir.

* Ouvrez un terminal et placez-vous à la racine de votre dossier personnel :
<source>
$ cd $HOME
</source>
* Créez un dossier de travail dédié à gnuradio et déplacez-vous à l'intérieur :
<source>
$ mkdir gnuradio
$ cd gnuradio
</source>
* GNU Radio est livré avec gr_modtool, un utilitaire qui permet de créer des modules externes (OOT). Créons un module <code>monModule</code>
<source>
$ gr_modtool newmod monModule
</source>
* Le dossier <code>gr-monModule</code> est créé et contient tout le code squelette d'un module OOT, mais il n'a pas encore de blocs. Déplacez-vous dans <code>gr-monModule</code> :
<source>
$ cd gr-monModule
</source>
* Vous pouvez afficher le contenu de ce dossier par
<source>
$ ls
</source>

==== Création d'un bloc dans ce module ====

* Ajoutez un nouveau bloc nommé <code>passetout</code> :
<source>
$ gr_modtool add passetout
</source>
* Quelques questions permettent alors de spécifier le type de bloc
<source>
GNU Radio module name identified: passetout
('sink', 'source', 'sync', 'decimator', 'interpolator', 'general', 'tagged_stream', 'hier', 'noblock')
</source>
Saisissez <code>sync</code> comme type de bloc, car le bloc que nous écrivons produira le même nombre d'échantillons en sortie que le nombre d'échantillons consommés depuis l'entrée.
<source>
Enter block type: sync
</source>
* Spécifiez <code>cpp</code> comme langage :
<source>
Language (python/cpp): cpp
Language: C++
Block/code identifier: passetout
</source>
* Spécifiez un nom pour le copyright :
<source>
Please specify the copyright holder: Bibi
</source>
* Il est possible de spécifier des paramètres d'entrée qui peuvent permettre de régler le fonctionnement du bloc. Ce ne sera pas notre cas, ne rien saisir sur cette question :
<source>
Enter valid argument list, including default arguments:
</source>
* De même, on ne donnera pas de code permettant de tester le bon fonctionnement :
<source>
Add Python QA code? [Y/n] n
Add C++ QA code? [Y/n] n
</source>
* Plusieurs fichers sont alors crées :
<source>
Adding file 'lib/passetout_impl.h'...
Adding file 'lib/passetout_impl.cc'...
Adding file 'include/gnuradio/monModule/passetout.h'...
Adding file 'python/monModule/bindings/docstrings/passetout_pydoc_template.h'...
Adding file 'python/monModule/bindings/passetout_python.cc'...
Adding file 'grc/monModule_passetout.block.yml'...
Editing grc/CMakeLists.txt...
</source>

Quelques indications :
* le fichier <code>passetout_impl.h</code> contient l'entête de la classe de notre bloc
* le fichier <code>passetout_impl.cc</code> contient l'implémentation de la classe de notre bloc
* le fichier <code>monModule_passetout.block.yml</code> va contenir des informations faisant le lien entre notre code c++ et le code python utilisé en interne par Gnuradio
* Le tout sera compilé par un <code>Makefile</code> généré par <code>cmake</code>.

==== Fichier <code>passetout_impl.h</code> ====

Le code utile généré est le suivant :
<source lang=cpp>
class passetout_impl : public passetout
{
private:
// Nothing to declare in this block.

public:
passetout_impl();
~passetout_impl();

// Where all the action really happens
int work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items);
};
</source>

Pour se réveiller les neurones sur la POO, qu'est-ce que sont
* <code>passetout_impl()</code>,
* <code>~passetout_impl()</code>,
* <code>private</code>, <code>public</code> ?

Le travail sera réalisé dans la méthode <code>work()</code>, mais nous n'avons pas de modification à apporter dans les déclarations par défaut.

==== Fichier <code>passetout_impl.cc</code> ====

Le code utile généré est le suivant :

{{boîte déroulante/début|titre=passetout_impl.cc}}
<source lang=cpp>
namespace monModule {

#pragma message("set the following appropriately and remove this warning")
using input_type = float;
#pragma message("set the following appropriately and remove this warning")
using output_type = float;
passetout::sptr passetout::make() { return gnuradio::make_block_sptr<passetout_impl>(); }

/*
* The private constructor
*/
passetout_impl::passetout_impl()
: gr::sync_block("passetout",
gr::io_signature::make(
1 /* min inputs */, 1 /* max inputs */, sizeof(input_type)),
gr::io_signature::make(
1 /* min outputs */, 1 /*max outputs */, sizeof(output_type)))
{
}

/*
* Our virtual destructor.
*/
passetout_impl::~passetout_impl() {}

int passetout_impl::work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items)
{
auto in = static_cast<const input_type*>(input_items[0]);
auto out = static_cast<output_type*>(output_items[0]);

#pragma message("Implement the signal processing in your block and remove this warning")
// Do <+signal processing+>

// Tell runtime system how many output items we produced.
return noutput_items;
}

} /* namespace monModule */
</source>
{{boîte déroulante/fin}}

Détaillons :
<source lang=cpp>
#pragma message("set the following appropriately and remove this warning")
using input_type = float;
#pragma message("set the following appropriately and remove this warning")
using output_type = float;
</source>
{{Todos| On spécifie ici le type des données d'entrée et de sortie. Pas de modification à apporter, il suffit de supprimer les deux <code>#pragma</code>}}

<source lang=cpp>
passetout_impl::passetout_impl()
: gr::sync_block("passetout",
gr::io_signature::make(
1 /* min inputs */, 1 /* max inputs */, sizeof(input_type)),
gr::io_signature::make(
1 /* min outputs */, 1 /*max outputs */, sizeof(output_type)))
{
}
</source>

{{Todos| On spécifie ici le nombre d'entrées (1) et le nombre de sorties (1). Pas de modification non plus.}}

{{Todos| Expliquez la syntaxe <code>passetout_impl::passetout_impl() : gr::sync_block(...)"</code> }}

<source lang=cpp>
int passetout_impl::work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items)
{
auto in = static_cast<const input_type*>(input_items[0]);
auto out = static_cast<output_type*>(output_items[0]);

#pragma message("Implement the signal processing in your block and remove this warning")
// Do <+signal processing+>

// Tell runtime system how many output items we produced.
return noutput_items;
}
</source>
Cette méthode <code>work()</code> implémente véritablement le filtrage.
* Les tableaux <code>in</code> et <code>out</code> contiennent respectivement les données en entrée et les données en sortie. Il faut donc calculer <code>out</code> en fonction de <code>in</code>
* Les données d'entrée arrivent par paquets dans un buffer. La variable <code>noutput_items</code> contient le nombre de données disponibles en entrées.
* à la fin de la méthode, on renvoie le nombre de données en sortie que l'on a calculé (entre 1 et <code>noutput_items</code>). Les données d'entrées éventuellement non consommées seront conservées dans le buffer pour le prochain appel de <code>work()</code>
{{Todos| On souhaite ici seulement recopier l'entrée sur la sortie, donc }}
# Enlever la ligne <code>#pragma</code>
# ajouter le code <code> out[0] = in[0];</code> (on recopie le premier échantillon disponible en entrée)
# changer <code>return noutput_items;</code> en <code>return 1;</code> (un seul échantillon a été consommé).

==== Fichier <code>monModule_passetout.block.yml</code> ====

Ce fichier au format YAML (''yet another markup language'') fait le lien entre le code c++ et le code python utilisé en interne par GnuRadio.

{{boîte déroulante/début|titre=monModule_passetout.block.yml}}
<source lang=yaml>
id: monModule_passetout
label: passetout
category: '[monModule]'

templates:
imports: from gnuradio import monModule
make: monModule.passetout()

# Make one 'parameters' list entry for every parameter you want settable from the GUI.
# Keys include:
# * id (makes the value accessible as keyname, e.g. in the make entry)
# * label (label shown in the GUI)
# * dtype (e.g. int, float, complex, byte, short, xxx_vector, ...)
# * default
parameters:
- id: parametername_replace_me
label: FIX ME:
dtype: string
default: You need to fill in your grc/monModule_passetout.block.yaml
#- id: ...
# label: ...
# dtype: ...

# Make one 'inputs' list entry per input and one 'outputs' list entry per output.
# Keys include:
# * label (an identifier for the GUI)
# * domain (optional - stream or message. Default is stream)
# * dtype (e.g. int, float, complex, byte, short, xxx_vector, ...)
# * vlen (optional - data stream vector length. Default is 1)
# * optional (optional - set to 1 for optional inputs. Default is 0)
inputs:
#- label: ...
# domain: ...
# dtype: ...
# vlen: ...
# optional: ...

outputs:
#- label: ...
# domain: ...
# dtype: ...
# vlen: ...
# optional: ...

# 'file_format' specifies the version of the GRC yml format used in the file
# and should usually not be changed.
file_format: 1
</source>
{{boîte déroulante/fin}}

{{Todos| Mettre à jour la section <code>parameters</code> (pas de paramètres, on commente) :}}

<source lang=yaml>
#parameters:
#- id: parametername_replace_me
# label: FIX ME:
# dtype: string
# default: You need to fill in your grc/customModule_testMod.block.yaml
</source>

{{Todos| Mettre à jour la section <code>inputs</code> :}}

<source lang=yaml>
inputs:
- label: in
domain: stream
dtype: float
</source>

{{Todos| Mettre à jour la section <code>output</code> :}}

<source lang=yaml>
outputs:
- label: out
domain: stream
dtype: float
</source>

==== Compilation et installation ====

Voici les étapes :
<source lang=bash>
$ cd CHEMIN-DE-VOTRE-DOSSIER/gr-monModule
$ mkdir build
$ cd build
$ cmake ..
$ make
$ make install
</source>

* <code>cmake ..</code> lance la création des fichiers <code>Makefile</code> qui permettent la compilation et l'installation
* <code>make</code> lance la compilation
* <code>make install</code> lance l'installation (copie des fichiers dans les dossiers gnuradio)

{{Todos| Exécuter chacune de ces lignes, en contrôlant l'absence d'erreur. Dans le cas contraire, contrôler les fichiers <code>.h</code>, <code>.cc</code> et <code>.yaml</code>}}

{{Todos| '''Après ces étapes, et avant de lancer gnuRadio, appeler l'enseignant qui va mettre à jours les bibliothèques partagées.'''}}. Sinon tenter :
<source>
$ export LD_LIBRARY_PATH=/usr/local/lib/x86_64-linux-gnu:$LD_LIBRARY_PATH
$ gnuradio-companion &
</source>

==== Utilisation du bloc et test ====

* Dans Gnuradio, rafraichir la liste des bloc (bouton ''reload'')
* le bloc <code>passetout</code> doit être présent dans la section <code>monModule</code>
* Tester le bon fonctionnement de ce bloc en lui envoyant une sinusoïde que vous devez observer identique à la sortie du bloc. Vérifier avec des graphes.

==== Application : démodulation ====

En reprenant le signal modulé en amplitude et la fonction de transfert du filtre passe-bas du TP précédent :

* Obtenir l'équation aux différence du filtre, ''ie'' écrire ''y(n)='' en fonction de ''x(n)'', ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.
* Créer un nouveau bloc C++ (similaire au passe-tout précédent) dans le module <code>monModule</code> :
** de type <code>sync</code>
** une entrée en <code>float</code>
** une sortie en <code>float</code>
* Écrire le code permettant d'obtenir ''y(n)'' dans la méthode <code>work()</code> :
** ''x(n)'' est donné par <code>in0[0]</code>
** il sera nécessaire d'affecter <code>out0[0]</code> pour produire ''y(n)''.
** il sera nécessaire de stocker dans des '''attributs''' les valeurs de <code>in[0]</code> afin de disposer de ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.
** On rappelle que les attributs doivent être déclarées dans le fichier <code>.h</code> et initialisés dans le constructeur de la classe.

{{Todos| Réaliser cette implémentation du passe-bas et contrôler que la démodulation est identique à celle obtenue au TP précédent}}

{{Todos| Modifier votre code pour implémenter le filtre complet de démodulation}}

Cours:Elen4 TNS TP TpsReel

2026-06-01T09:16:32Z

Fredmn : /* Filtre moyenneur */

[[Cours:Elen4_TNS|{{Rouge|'''Retour à la page du cours'''}}]]

<center>
'''<big>TP6 - Temps réel : bloc Gnuradio en Python / démodulation / PID Numérique</big>'''
</center>

Le but de ce TP est double :
* réaliser des implémentations temps réel de filtre IIR en créant un bloc Gnuradio qui execute un traitement codé en Python
* et étudier l'implémentation d'un PID numérique sous forme d'un filtre IIR.

Dans les deux cas, un système temps réel sera considéré :
* à intervalles de temps (réguliers ou non), une valeur ''x(n)'' rentre dans le système
* le travail consiste à calculer ''y(n)'' avec l'équation au différences du filtre, à partir de la valeur ''x(n)'' et de ses versions précédentes ''x(n-1)'' et ''x(n-2)'' (et aussi ''y(n-1)'', ''y(n-2)'') qu'il est donc nécessaire de stocker.
* La notion de ''temps réel'' implique que ''y(n)'' doit être calculer avant qu'une nouvelle valeurs de ''x(n)'' ne rentre dans le système.

=== Bloc Gnuradio en Python ===

Nous allons implémenter un filtre IIR dans gnuradio, en écrivant le traitement dans un bloc Python.

==== Filtre moyenneur====

{{q| a)}} Dans un premier temps, prendre connaissance du tutoriel suivant : [https://wiki.gnuradio.org/index.php?title=Creating_Your_First_Block wiki Gnuradio - ''Creating Your First Block'']

{{q| b)}} Nous allons écrire un filtre simple, qui implémente un simple moyenneur :
<source lang="Python">

import numpy as np
from gnuradio import gr

class blk(gr.sync_block):
def __init__(self): # Pas de paramètres
gr.sync_block.__init__(
self,
name="Filtre moyenneur",
in_sig=[np.float32],
out_sig=[np.float32]
)
self.xn1 = 0 # initialisation d'un attribut pour stocker x(n-1)

def work(self, input_items, output_items):
xn = input_items[0][0] # On ne "consomme" qu'un seul échantillon en entrée
yn = (xn + self.xn1) / 2
self.xn1 = xn
output_items[0][0] = yn # On ne produit donc également qu'un seul échantillon en sortie
return 1 # On retourne le nombre de valeurs consomées
</source>

==== Filtre IIR : démodulation ====

En reprenant le signal modulé en amplitude et la fonction de transfert du filtre passe-bas du TP précédent :

* Obtenir l'équation aux différence du filtre, ''ie'' écrire ''y(n)='' en fonction de ''x(n)'', ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.
* Créer un nouveau bloc Python dans le module <code>monModule</code> :
** de type <code>sync</code>
** une entrée en <code>np.float32</code>
** une sortie en <code>np.float32</code>
* Écrire le code permettant d'obtenir ''y(n)'' dans la méthode <code>work()</code> :
** ''x(n)'' est donné par <code>in0[0]</code>
** il sera nécessaire de stocker dans des '''attributs''' les valeurs de ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.

{{q| a)}} Réaliser cette implémentation du passe-bas et contrôler que la démodulation est identique à celle obtenue au [[Cours:Elen4_TNS_TP_TraitAudioEtDemodulation|TP 5]].

{{q| b)}} Modifier votre code pour implémenter le filtre complet de démodulation.

=== Approximation de PID par filtre numérique linéaire ===

==== Rappels PID ====

* Principe

[[Fichier:PIDprincipe.png|400px]]

[[Fichier:PIDdetail.png|400px]]

* Définition mathématique, la sortie du controleur PID ''u(t)'' est donnée par:

[[Fichier:EqPID.png|400px]]

==== PID numérique "classique" ====

On considère que le temps est discrétisé : ''t = n.dt'' où ''dt'' est l'intervalle de temps entre deux valeurs.

* En approximant grossièrement l'intégrale et la dérivée [[Fichier:PIDderivative.png|400px]] [[Fichier:PIDintegral.png|400px]]
** La dérivée est calculée par ''D = (e(n)-e(n-1))/dt''
** L'intégrale est approximée en cumulant progressivement : ''I = I + e(n).dt''

* Notebook exemple : asservissement de température
** ''Ki = Kd = 0'' => chercher le meilleur ''Kp'' => erreur de régime permanent
** ''Kd = 0'' => l'introduction du terme integral permet de corriger cette erreur de régime permanent
** Le terme dérivatif n'est pas nécessaire dans cet exemple car la température ne dépend que de la commande ''u(t)''.

==== PID numérique par approximation d'un filtre continu ====

* Cherchons la fonction de transfert du filtre continu d'un PID.
 En partant de l'équation différentielle
 [[Fichier:EqPID.png|500px]]
 On applique la transformée de Laplace (dérivée => multiplication par ''s'' ; intégrale => division par ''s'') :
 [[Fichier:eqFxTransfertPID.png|130]]
 Le terme dérivatif étant très sensible au bruit, on lui applique généralement un filtre passe bas (''w0/(w0+s)'') :
 [[Fichier:eqFxTransfertPIDetPB.png|130]]
* Approximation de la fonction de transfert pour obtenir un filtre numérique
** ''backward euler''
** et transformée bilinéaire

* Implémentation du Filtre : classe <code>FilterController</code>
* Application sur l'asservissement d'altitude d'un drone

=== Archive : codage de bloc Gnuradio en C++ ===

Ce guide est inspirée du guide [https://wiki.gnuradio.org/index.php?title=Creating_C%2B%2B_OOT_with_gr-modtool Creating an OOT (C++ block example)] en l'adaptant pour nos besoins :

Nous allons créer un simple bloc qui recopie son entrée (en <code>float</code>) sur sa sortie. Donc le filtre caractérisé par ''y(n)'' = ''x(n)'' ou encore ''H(z)''=1. Il s'agit donc d'une sorte de filtre passe-tout.

'''Suivez bien toutes les étapes, sans aller trop rapidement'''

* Vous pourrez utiliser <code>gedit</code> pour éditer les divers fichiers.

==== Création d'un module externe ====

Dans les lignes qui suivent, le <code>$</code> indique que l'on saisi une commande dans un terminal. Le <code>$</code> n'est pas à saisir.

* Ouvrez un terminal et placez-vous à la racine de votre dossier personnel :
<source>
$ cd $HOME
</source>
* Créez un dossier de travail dédié à gnuradio et déplacez-vous à l'intérieur :
<source>
$ mkdir gnuradio
$ cd gnuradio
</source>
* GNU Radio est livré avec gr_modtool, un utilitaire qui permet de créer des modules externes (OOT). Créons un module <code>monModule</code>
<source>
$ gr_modtool newmod monModule
</source>
* Le dossier <code>gr-monModule</code> est créé et contient tout le code squelette d'un module OOT, mais il n'a pas encore de blocs. Déplacez-vous dans <code>gr-monModule</code> :
<source>
$ cd gr-monModule
</source>
* Vous pouvez afficher le contenu de ce dossier par
<source>
$ ls
</source>

==== Création d'un bloc dans ce module ====

* Ajoutez un nouveau bloc nommé <code>passetout</code> :
<source>
$ gr_modtool add passetout
</source>
* Quelques questions permettent alors de spécifier le type de bloc
<source>
GNU Radio module name identified: passetout
('sink', 'source', 'sync', 'decimator', 'interpolator', 'general', 'tagged_stream', 'hier', 'noblock')
</source>
Saisissez <code>sync</code> comme type de bloc, car le bloc que nous écrivons produira le même nombre d'échantillons en sortie que le nombre d'échantillons consommés depuis l'entrée.
<source>
Enter block type: sync
</source>
* Spécifiez <code>cpp</code> comme langage :
<source>
Language (python/cpp): cpp
Language: C++
Block/code identifier: passetout
</source>
* Spécifiez un nom pour le copyright :
<source>
Please specify the copyright holder: Bibi
</source>
* Il est possible de spécifier des paramètres d'entrée qui peuvent permettre de régler le fonctionnement du bloc. Ce ne sera pas notre cas, ne rien saisir sur cette question :
<source>
Enter valid argument list, including default arguments:
</source>
* De même, on ne donnera pas de code permettant de tester le bon fonctionnement :
<source>
Add Python QA code? [Y/n] n
Add C++ QA code? [Y/n] n
</source>
* Plusieurs fichers sont alors crées :
<source>
Adding file 'lib/passetout_impl.h'...
Adding file 'lib/passetout_impl.cc'...
Adding file 'include/gnuradio/monModule/passetout.h'...
Adding file 'python/monModule/bindings/docstrings/passetout_pydoc_template.h'...
Adding file 'python/monModule/bindings/passetout_python.cc'...
Adding file 'grc/monModule_passetout.block.yml'...
Editing grc/CMakeLists.txt...
</source>

Quelques indications :
* le fichier <code>passetout_impl.h</code> contient l'entête de la classe de notre bloc
* le fichier <code>passetout_impl.cc</code> contient l'implémentation de la classe de notre bloc
* le fichier <code>monModule_passetout.block.yml</code> va contenir des informations faisant le lien entre notre code c++ et le code python utilisé en interne par Gnuradio
* Le tout sera compilé par un <code>Makefile</code> généré par <code>cmake</code>.

==== Fichier <code>passetout_impl.h</code> ====

Le code utile généré est le suivant :
<source lang=cpp>
class passetout_impl : public passetout
{
private:
// Nothing to declare in this block.

public:
passetout_impl();
~passetout_impl();

// Where all the action really happens
int work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items);
};
</source>

Pour se réveiller les neurones sur la POO, qu'est-ce que sont
* <code>passetout_impl()</code>,
* <code>~passetout_impl()</code>,
* <code>private</code>, <code>public</code> ?

Le travail sera réalisé dans la méthode <code>work()</code>, mais nous n'avons pas de modification à apporter dans les déclarations par défaut.

==== Fichier <code>passetout_impl.cc</code> ====

Le code utile généré est le suivant :

{{boîte déroulante/début|titre=passetout_impl.cc}}
<source lang=cpp>
namespace monModule {

#pragma message("set the following appropriately and remove this warning")
using input_type = float;
#pragma message("set the following appropriately and remove this warning")
using output_type = float;
passetout::sptr passetout::make() { return gnuradio::make_block_sptr<passetout_impl>(); }

/*
* The private constructor
*/
passetout_impl::passetout_impl()
: gr::sync_block("passetout",
gr::io_signature::make(
1 /* min inputs */, 1 /* max inputs */, sizeof(input_type)),
gr::io_signature::make(
1 /* min outputs */, 1 /*max outputs */, sizeof(output_type)))
{
}

/*
* Our virtual destructor.
*/
passetout_impl::~passetout_impl() {}

int passetout_impl::work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items)
{
auto in = static_cast<const input_type*>(input_items[0]);
auto out = static_cast<output_type*>(output_items[0]);

#pragma message("Implement the signal processing in your block and remove this warning")
// Do <+signal processing+>

// Tell runtime system how many output items we produced.
return noutput_items;
}

} /* namespace monModule */
</source>
{{boîte déroulante/fin}}

Détaillons :
<source lang=cpp>
#pragma message("set the following appropriately and remove this warning")
using input_type = float;
#pragma message("set the following appropriately and remove this warning")
using output_type = float;
</source>
{{Todos| On spécifie ici le type des données d'entrée et de sortie. Pas de modification à apporter, il suffit de supprimer les deux <code>#pragma</code>}}

<source lang=cpp>
passetout_impl::passetout_impl()
: gr::sync_block("passetout",
gr::io_signature::make(
1 /* min inputs */, 1 /* max inputs */, sizeof(input_type)),
gr::io_signature::make(
1 /* min outputs */, 1 /*max outputs */, sizeof(output_type)))
{
}
</source>

{{Todos| On spécifie ici le nombre d'entrées (1) et le nombre de sorties (1). Pas de modification non plus.}}

{{Todos| Expliquez la syntaxe <code>passetout_impl::passetout_impl() : gr::sync_block(...)"</code> }}

<source lang=cpp>
int passetout_impl::work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items)
{
auto in = static_cast<const input_type*>(input_items[0]);
auto out = static_cast<output_type*>(output_items[0]);

#pragma message("Implement the signal processing in your block and remove this warning")
// Do <+signal processing+>

// Tell runtime system how many output items we produced.
return noutput_items;
}
</source>
Cette méthode <code>work()</code> implémente véritablement le filtrage.
* Les tableaux <code>in</code> et <code>out</code> contiennent respectivement les données en entrée et les données en sortie. Il faut donc calculer <code>out</code> en fonction de <code>in</code>
* Les données d'entrée arrivent par paquets dans un buffer. La variable <code>noutput_items</code> contient le nombre de données disponibles en entrées.
* à la fin de la méthode, on renvoie le nombre de données en sortie que l'on a calculé (entre 1 et <code>noutput_items</code>). Les données d'entrées éventuellement non consommées seront conservées dans le buffer pour le prochain appel de <code>work()</code>
{{Todos| On souhaite ici seulement recopier l'entrée sur la sortie, donc }}
# Enlever la ligne <code>#pragma</code>
# ajouter le code <code> out[0] = in[0];</code> (on recopie le premier échantillon disponible en entrée)
# changer <code>return noutput_items;</code> en <code>return 1;</code> (un seul échantillon a été consommé).

==== Fichier <code>monModule_passetout.block.yml</code> ====

Ce fichier au format YAML (''yet another markup language'') fait le lien entre le code c++ et le code python utilisé en interne par GnuRadio.

{{boîte déroulante/début|titre=monModule_passetout.block.yml}}
<source lang=yaml>
id: monModule_passetout
label: passetout
category: '[monModule]'

templates:
imports: from gnuradio import monModule
make: monModule.passetout()

# Make one 'parameters' list entry for every parameter you want settable from the GUI.
# Keys include:
# * id (makes the value accessible as keyname, e.g. in the make entry)
# * label (label shown in the GUI)
# * dtype (e.g. int, float, complex, byte, short, xxx_vector, ...)
# * default
parameters:
- id: parametername_replace_me
label: FIX ME:
dtype: string
default: You need to fill in your grc/monModule_passetout.block.yaml
#- id: ...
# label: ...
# dtype: ...

# Make one 'inputs' list entry per input and one 'outputs' list entry per output.
# Keys include:
# * label (an identifier for the GUI)
# * domain (optional - stream or message. Default is stream)
# * dtype (e.g. int, float, complex, byte, short, xxx_vector, ...)
# * vlen (optional - data stream vector length. Default is 1)
# * optional (optional - set to 1 for optional inputs. Default is 0)
inputs:
#- label: ...
# domain: ...
# dtype: ...
# vlen: ...
# optional: ...

outputs:
#- label: ...
# domain: ...
# dtype: ...
# vlen: ...
# optional: ...

# 'file_format' specifies the version of the GRC yml format used in the file
# and should usually not be changed.
file_format: 1
</source>
{{boîte déroulante/fin}}

{{Todos| Mettre à jour la section <code>parameters</code> (pas de paramètres, on commente) :}}

<source lang=yaml>
#parameters:
#- id: parametername_replace_me
# label: FIX ME:
# dtype: string
# default: You need to fill in your grc/customModule_testMod.block.yaml
</source>

{{Todos| Mettre à jour la section <code>inputs</code> :}}

<source lang=yaml>
inputs:
- label: in
domain: stream
dtype: float
</source>

{{Todos| Mettre à jour la section <code>output</code> :}}

<source lang=yaml>
outputs:
- label: out
domain: stream
dtype: float
</source>

==== Compilation et installation ====

Voici les étapes :
<source lang=bash>
$ cd CHEMIN-DE-VOTRE-DOSSIER/gr-monModule
$ mkdir build
$ cd build
$ cmake ..
$ make
$ make install
</source>

* <code>cmake ..</code> lance la création des fichiers <code>Makefile</code> qui permettent la compilation et l'installation
* <code>make</code> lance la compilation
* <code>make install</code> lance l'installation (copie des fichiers dans les dossiers gnuradio)

{{Todos| Exécuter chacune de ces lignes, en contrôlant l'absence d'erreur. Dans le cas contraire, contrôler les fichiers <code>.h</code>, <code>.cc</code> et <code>.yaml</code>}}

{{Todos| '''Après ces étapes, et avant de lancer gnuRadio, appeler l'enseignant qui va mettre à jours les bibliothèques partagées.'''}}. Sinon tenter :
<source>
$ export LD_LIBRARY_PATH=/usr/local/lib/x86_64-linux-gnu:$LD_LIBRARY_PATH
$ gnuradio-companion &
</source>

==== Utilisation du bloc et test ====

* Dans Gnuradio, rafraichir la liste des bloc (bouton ''reload'')
* le bloc <code>passetout</code> doit être présent dans la section <code>monModule</code>
* Tester le bon fonctionnement de ce bloc en lui envoyant une sinusoïde que vous devez observer identique à la sortie du bloc. Vérifier avec des graphes.

==== Application : démodulation ====

En reprenant le signal modulé en amplitude et la fonction de transfert du filtre passe-bas du TP précédent :

* Obtenir l'équation aux différence du filtre, ''ie'' écrire ''y(n)='' en fonction de ''x(n)'', ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.
* Créer un nouveau bloc C++ (similaire au passe-tout précédent) dans le module <code>monModule</code> :
** de type <code>sync</code>
** une entrée en <code>float</code>
** une sortie en <code>float</code>
* Écrire le code permettant d'obtenir ''y(n)'' dans la méthode <code>work()</code> :
** ''x(n)'' est donné par <code>in0[0]</code>
** il sera nécessaire d'affecter <code>out0[0]</code> pour produire ''y(n)''.
** il sera nécessaire de stocker dans des '''attributs''' les valeurs de <code>in[0]</code> afin de disposer de ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.
** On rappelle que les attributs doivent être déclarées dans le fichier <code>.h</code> et initialisés dans le constructeur de la classe.

{{Todos| Réaliser cette implémentation du passe-bas et contrôler que la démodulation est identique à celle obtenue au TP précédent}}

{{Todos| Modifier votre code pour implémenter le filtre complet de démodulation}}

Cours:Elen4 TNS TP TpsReel

2026-06-01T09:15:12Z

Fredmn :

[[Cours:Elen4_TNS|{{Rouge|'''Retour à la page du cours'''}}]]

<center>
'''<big>TP6 - Temps réel : bloc Gnuradio en Python / démodulation / PID Numérique</big>'''
</center>

Le but de ce TP est double :
* réaliser des implémentations temps réel de filtre IIR en créant un bloc Gnuradio qui execute un traitement codé en Python
* et étudier l'implémentation d'un PID numérique sous forme d'un filtre IIR.

Dans les deux cas, un système temps réel sera considéré :
* à intervalles de temps (réguliers ou non), une valeur ''x(n)'' rentre dans le système
* le travail consiste à calculer ''y(n)'' avec l'équation au différences du filtre, à partir de la valeur ''x(n)'' et de ses versions précédentes ''x(n-1)'' et ''x(n-2)'' (et aussi ''y(n-1)'', ''y(n-2)'') qu'il est donc nécessaire de stocker.
* La notion de ''temps réel'' implique que ''y(n)'' doit être calculer avant qu'une nouvelle valeurs de ''x(n)'' ne rentre dans le système.

=== Bloc Gnuradio en Python ===

Nous allons implémenter un filtre IIR dans gnuradio, en écrivant le traitement dans un bloc Python.

==== Filtre moyenneur====

{{q| a)}} Dans un premier temps, prendre connaissance du tutoriel suivant : [https://wiki.gnuradio.org/index.php?title=Creating_Your_First_Block wiki Gnuradio - ''Creating Your First Block'']

{{q| b)}} Nous allons écrire un filtre simple, qui implémente un simple moyenneur :
<source lang="Python">

import numpy as np
from gnuradio import gr

class blk(gr.sync_block):
def __init__(self): # Pas de paramètres
gr.sync_block.__init__(
self,
name="Filtre moyenneur",
in_sig=[np.float32],
out_sig=[np.float32],
)
self.xn1 = 0 # initialisation d'un attribut pour stocker x(n-1)

def work(self, input_items, output_items):
xn = input_items[0][0] # On ne "consomme" qu'un seul échantillon en entrée
yn = (xn + self.xn1) / 2
self.xn1 = xn
output_items[0][0] = yn # On ne produit donc également qu'un seul échantillon en sortie
return 1 # On retourne le nombre de valeurs consomémes
</source>

==== Filtre IIR : démodulation ====

En reprenant le signal modulé en amplitude et la fonction de transfert du filtre passe-bas du TP précédent :

* Obtenir l'équation aux différence du filtre, ''ie'' écrire ''y(n)='' en fonction de ''x(n)'', ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.
* Créer un nouveau bloc Python dans le module <code>monModule</code> :
** de type <code>sync</code>
** une entrée en <code>np.float32</code>
** une sortie en <code>np.float32</code>
* Écrire le code permettant d'obtenir ''y(n)'' dans la méthode <code>work()</code> :
** ''x(n)'' est donné par <code>in0[0]</code>
** il sera nécessaire de stocker dans des '''attributs''' les valeurs de ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.

{{q| a)}} Réaliser cette implémentation du passe-bas et contrôler que la démodulation est identique à celle obtenue au [[Cours:Elen4_TNS_TP_TraitAudioEtDemodulation|TP 5]].

{{q| b)}} Modifier votre code pour implémenter le filtre complet de démodulation.

=== Approximation de PID par filtre numérique linéaire ===

==== Rappels PID ====

* Principe

[[Fichier:PIDprincipe.png|400px]]

[[Fichier:PIDdetail.png|400px]]

* Définition mathématique, la sortie du controleur PID ''u(t)'' est donnée par:

[[Fichier:EqPID.png|400px]]

==== PID numérique "classique" ====

On considère que le temps est discrétisé : ''t = n.dt'' où ''dt'' est l'intervalle de temps entre deux valeurs.

* En approximant grossièrement l'intégrale et la dérivée [[Fichier:PIDderivative.png|400px]] [[Fichier:PIDintegral.png|400px]]
** La dérivée est calculée par ''D = (e(n)-e(n-1))/dt''
** L'intégrale est approximée en cumulant progressivement : ''I = I + e(n).dt''

* Notebook exemple : asservissement de température
** ''Ki = Kd = 0'' => chercher le meilleur ''Kp'' => erreur de régime permanent
** ''Kd = 0'' => l'introduction du terme integral permet de corriger cette erreur de régime permanent
** Le terme dérivatif n'est pas nécessaire dans cet exemple car la température ne dépend que de la commande ''u(t)''.

==== PID numérique par approximation d'un filtre continu ====

* Cherchons la fonction de transfert du filtre continu d'un PID.
 En partant de l'équation différentielle
 [[Fichier:EqPID.png|500px]]
 On applique la transformée de Laplace (dérivée => multiplication par ''s'' ; intégrale => division par ''s'') :
 [[Fichier:eqFxTransfertPID.png|130]]
 Le terme dérivatif étant très sensible au bruit, on lui applique généralement un filtre passe bas (''w0/(w0+s)'') :
 [[Fichier:eqFxTransfertPIDetPB.png|130]]
* Approximation de la fonction de transfert pour obtenir un filtre numérique
** ''backward euler''
** et transformée bilinéaire

* Implémentation du Filtre : classe <code>FilterController</code>
* Application sur l'asservissement d'altitude d'un drone

=== Archive : codage de bloc Gnuradio en C++ ===

Ce guide est inspirée du guide [https://wiki.gnuradio.org/index.php?title=Creating_C%2B%2B_OOT_with_gr-modtool Creating an OOT (C++ block example)] en l'adaptant pour nos besoins :

Nous allons créer un simple bloc qui recopie son entrée (en <code>float</code>) sur sa sortie. Donc le filtre caractérisé par ''y(n)'' = ''x(n)'' ou encore ''H(z)''=1. Il s'agit donc d'une sorte de filtre passe-tout.

'''Suivez bien toutes les étapes, sans aller trop rapidement'''

* Vous pourrez utiliser <code>gedit</code> pour éditer les divers fichiers.

==== Création d'un module externe ====

Dans les lignes qui suivent, le <code>$</code> indique que l'on saisi une commande dans un terminal. Le <code>$</code> n'est pas à saisir.

* Ouvrez un terminal et placez-vous à la racine de votre dossier personnel :
<source>
$ cd $HOME
</source>
* Créez un dossier de travail dédié à gnuradio et déplacez-vous à l'intérieur :
<source>
$ mkdir gnuradio
$ cd gnuradio
</source>
* GNU Radio est livré avec gr_modtool, un utilitaire qui permet de créer des modules externes (OOT). Créons un module <code>monModule</code>
<source>
$ gr_modtool newmod monModule
</source>
* Le dossier <code>gr-monModule</code> est créé et contient tout le code squelette d'un module OOT, mais il n'a pas encore de blocs. Déplacez-vous dans <code>gr-monModule</code> :
<source>
$ cd gr-monModule
</source>
* Vous pouvez afficher le contenu de ce dossier par
<source>
$ ls
</source>

==== Création d'un bloc dans ce module ====

* Ajoutez un nouveau bloc nommé <code>passetout</code> :
<source>
$ gr_modtool add passetout
</source>
* Quelques questions permettent alors de spécifier le type de bloc
<source>
GNU Radio module name identified: passetout
('sink', 'source', 'sync', 'decimator', 'interpolator', 'general', 'tagged_stream', 'hier', 'noblock')
</source>
Saisissez <code>sync</code> comme type de bloc, car le bloc que nous écrivons produira le même nombre d'échantillons en sortie que le nombre d'échantillons consommés depuis l'entrée.
<source>
Enter block type: sync
</source>
* Spécifiez <code>cpp</code> comme langage :
<source>
Language (python/cpp): cpp
Language: C++
Block/code identifier: passetout
</source>
* Spécifiez un nom pour le copyright :
<source>
Please specify the copyright holder: Bibi
</source>
* Il est possible de spécifier des paramètres d'entrée qui peuvent permettre de régler le fonctionnement du bloc. Ce ne sera pas notre cas, ne rien saisir sur cette question :
<source>
Enter valid argument list, including default arguments:
</source>
* De même, on ne donnera pas de code permettant de tester le bon fonctionnement :
<source>
Add Python QA code? [Y/n] n
Add C++ QA code? [Y/n] n
</source>
* Plusieurs fichers sont alors crées :
<source>
Adding file 'lib/passetout_impl.h'...
Adding file 'lib/passetout_impl.cc'...
Adding file 'include/gnuradio/monModule/passetout.h'...
Adding file 'python/monModule/bindings/docstrings/passetout_pydoc_template.h'...
Adding file 'python/monModule/bindings/passetout_python.cc'...
Adding file 'grc/monModule_passetout.block.yml'...
Editing grc/CMakeLists.txt...
</source>

Quelques indications :
* le fichier <code>passetout_impl.h</code> contient l'entête de la classe de notre bloc
* le fichier <code>passetout_impl.cc</code> contient l'implémentation de la classe de notre bloc
* le fichier <code>monModule_passetout.block.yml</code> va contenir des informations faisant le lien entre notre code c++ et le code python utilisé en interne par Gnuradio
* Le tout sera compilé par un <code>Makefile</code> généré par <code>cmake</code>.

==== Fichier <code>passetout_impl.h</code> ====

Le code utile généré est le suivant :
<source lang=cpp>
class passetout_impl : public passetout
{
private:
// Nothing to declare in this block.

public:
passetout_impl();
~passetout_impl();

// Where all the action really happens
int work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items);
};
</source>

Pour se réveiller les neurones sur la POO, qu'est-ce que sont
* <code>passetout_impl()</code>,
* <code>~passetout_impl()</code>,
* <code>private</code>, <code>public</code> ?

Le travail sera réalisé dans la méthode <code>work()</code>, mais nous n'avons pas de modification à apporter dans les déclarations par défaut.

==== Fichier <code>passetout_impl.cc</code> ====

Le code utile généré est le suivant :

{{boîte déroulante/début|titre=passetout_impl.cc}}
<source lang=cpp>
namespace monModule {

#pragma message("set the following appropriately and remove this warning")
using input_type = float;
#pragma message("set the following appropriately and remove this warning")
using output_type = float;
passetout::sptr passetout::make() { return gnuradio::make_block_sptr<passetout_impl>(); }

/*
* The private constructor
*/
passetout_impl::passetout_impl()
: gr::sync_block("passetout",
gr::io_signature::make(
1 /* min inputs */, 1 /* max inputs */, sizeof(input_type)),
gr::io_signature::make(
1 /* min outputs */, 1 /*max outputs */, sizeof(output_type)))
{
}

/*
* Our virtual destructor.
*/
passetout_impl::~passetout_impl() {}

int passetout_impl::work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items)
{
auto in = static_cast<const input_type*>(input_items[0]);
auto out = static_cast<output_type*>(output_items[0]);

#pragma message("Implement the signal processing in your block and remove this warning")
// Do <+signal processing+>

// Tell runtime system how many output items we produced.
return noutput_items;
}

} /* namespace monModule */
</source>
{{boîte déroulante/fin}}

Détaillons :
<source lang=cpp>
#pragma message("set the following appropriately and remove this warning")
using input_type = float;
#pragma message("set the following appropriately and remove this warning")
using output_type = float;
</source>
{{Todos| On spécifie ici le type des données d'entrée et de sortie. Pas de modification à apporter, il suffit de supprimer les deux <code>#pragma</code>}}

<source lang=cpp>
passetout_impl::passetout_impl()
: gr::sync_block("passetout",
gr::io_signature::make(
1 /* min inputs */, 1 /* max inputs */, sizeof(input_type)),
gr::io_signature::make(
1 /* min outputs */, 1 /*max outputs */, sizeof(output_type)))
{
}
</source>

{{Todos| On spécifie ici le nombre d'entrées (1) et le nombre de sorties (1). Pas de modification non plus.}}

{{Todos| Expliquez la syntaxe <code>passetout_impl::passetout_impl() : gr::sync_block(...)"</code> }}

<source lang=cpp>
int passetout_impl::work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items)
{
auto in = static_cast<const input_type*>(input_items[0]);
auto out = static_cast<output_type*>(output_items[0]);

#pragma message("Implement the signal processing in your block and remove this warning")
// Do <+signal processing+>

// Tell runtime system how many output items we produced.
return noutput_items;
}
</source>
Cette méthode <code>work()</code> implémente véritablement le filtrage.
* Les tableaux <code>in</code> et <code>out</code> contiennent respectivement les données en entrée et les données en sortie. Il faut donc calculer <code>out</code> en fonction de <code>in</code>
* Les données d'entrée arrivent par paquets dans un buffer. La variable <code>noutput_items</code> contient le nombre de données disponibles en entrées.
* à la fin de la méthode, on renvoie le nombre de données en sortie que l'on a calculé (entre 1 et <code>noutput_items</code>). Les données d'entrées éventuellement non consommées seront conservées dans le buffer pour le prochain appel de <code>work()</code>
{{Todos| On souhaite ici seulement recopier l'entrée sur la sortie, donc }}
# Enlever la ligne <code>#pragma</code>
# ajouter le code <code> out[0] = in[0];</code> (on recopie le premier échantillon disponible en entrée)
# changer <code>return noutput_items;</code> en <code>return 1;</code> (un seul échantillon a été consommé).

==== Fichier <code>monModule_passetout.block.yml</code> ====

Ce fichier au format YAML (''yet another markup language'') fait le lien entre le code c++ et le code python utilisé en interne par GnuRadio.

{{boîte déroulante/début|titre=monModule_passetout.block.yml}}
<source lang=yaml>
id: monModule_passetout
label: passetout
category: '[monModule]'

templates:
imports: from gnuradio import monModule
make: monModule.passetout()

# Make one 'parameters' list entry for every parameter you want settable from the GUI.
# Keys include:
# * id (makes the value accessible as keyname, e.g. in the make entry)
# * label (label shown in the GUI)
# * dtype (e.g. int, float, complex, byte, short, xxx_vector, ...)
# * default
parameters:
- id: parametername_replace_me
label: FIX ME:
dtype: string
default: You need to fill in your grc/monModule_passetout.block.yaml
#- id: ...
# label: ...
# dtype: ...

# Make one 'inputs' list entry per input and one 'outputs' list entry per output.
# Keys include:
# * label (an identifier for the GUI)
# * domain (optional - stream or message. Default is stream)
# * dtype (e.g. int, float, complex, byte, short, xxx_vector, ...)
# * vlen (optional - data stream vector length. Default is 1)
# * optional (optional - set to 1 for optional inputs. Default is 0)
inputs:
#- label: ...
# domain: ...
# dtype: ...
# vlen: ...
# optional: ...

outputs:
#- label: ...
# domain: ...
# dtype: ...
# vlen: ...
# optional: ...

# 'file_format' specifies the version of the GRC yml format used in the file
# and should usually not be changed.
file_format: 1
</source>
{{boîte déroulante/fin}}

{{Todos| Mettre à jour la section <code>parameters</code> (pas de paramètres, on commente) :}}

<source lang=yaml>
#parameters:
#- id: parametername_replace_me
# label: FIX ME:
# dtype: string
# default: You need to fill in your grc/customModule_testMod.block.yaml
</source>

{{Todos| Mettre à jour la section <code>inputs</code> :}}

<source lang=yaml>
inputs:
- label: in
domain: stream
dtype: float
</source>

{{Todos| Mettre à jour la section <code>output</code> :}}

<source lang=yaml>
outputs:
- label: out
domain: stream
dtype: float
</source>

==== Compilation et installation ====

Voici les étapes :
<source lang=bash>
$ cd CHEMIN-DE-VOTRE-DOSSIER/gr-monModule
$ mkdir build
$ cd build
$ cmake ..
$ make
$ make install
</source>

* <code>cmake ..</code> lance la création des fichiers <code>Makefile</code> qui permettent la compilation et l'installation
* <code>make</code> lance la compilation
* <code>make install</code> lance l'installation (copie des fichiers dans les dossiers gnuradio)

{{Todos| Exécuter chacune de ces lignes, en contrôlant l'absence d'erreur. Dans le cas contraire, contrôler les fichiers <code>.h</code>, <code>.cc</code> et <code>.yaml</code>}}

{{Todos| '''Après ces étapes, et avant de lancer gnuRadio, appeler l'enseignant qui va mettre à jours les bibliothèques partagées.'''}}. Sinon tenter :
<source>
$ export LD_LIBRARY_PATH=/usr/local/lib/x86_64-linux-gnu:$LD_LIBRARY_PATH
$ gnuradio-companion &
</source>

==== Utilisation du bloc et test ====

* Dans Gnuradio, rafraichir la liste des bloc (bouton ''reload'')
* le bloc <code>passetout</code> doit être présent dans la section <code>monModule</code>
* Tester le bon fonctionnement de ce bloc en lui envoyant une sinusoïde que vous devez observer identique à la sortie du bloc. Vérifier avec des graphes.

==== Application : démodulation ====

En reprenant le signal modulé en amplitude et la fonction de transfert du filtre passe-bas du TP précédent :

* Obtenir l'équation aux différence du filtre, ''ie'' écrire ''y(n)='' en fonction de ''x(n)'', ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.
* Créer un nouveau bloc C++ (similaire au passe-tout précédent) dans le module <code>monModule</code> :
** de type <code>sync</code>
** une entrée en <code>float</code>
** une sortie en <code>float</code>
* Écrire le code permettant d'obtenir ''y(n)'' dans la méthode <code>work()</code> :
** ''x(n)'' est donné par <code>in0[0]</code>
** il sera nécessaire d'affecter <code>out0[0]</code> pour produire ''y(n)''.
** il sera nécessaire de stocker dans des '''attributs''' les valeurs de <code>in[0]</code> afin de disposer de ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.
** On rappelle que les attributs doivent être déclarées dans le fichier <code>.h</code> et initialisés dans le constructeur de la classe.

{{Todos| Réaliser cette implémentation du passe-bas et contrôler que la démodulation est identique à celle obtenue au TP précédent}}

{{Todos| Modifier votre code pour implémenter le filtre complet de démodulation}}

Cours:Elen4 TNS TP TpsReel

2026-05-30T08:27:45Z

Fredmn : /* Codage de bloc Gnuradio en Python */

[[Cours:Elen4_TNS|{{Rouge|'''Retour à la page du cours'''}}]]

<center>
'''<big>TP6 - Temps réel : bloc Gnuradio en Python / démodulation / PID Numérique</big>'''
</center>

Le but de ce TP est double :
* réaliser des implémentations temps réel de filtre IIR en créant un bloc Gnuradio qui execute un traitement codé en Python
* et étudier l'implémentation d'un PID numérique sous forme d'un filtre IIR.

Dans les deux cas, un système temps réel sera considéré :
* à intervalles de temps (réguliers ou non), une valeur ''x(n)'' rentre dans le système
* le travail consiste à calculer ''y(n)'' avec l'équation au différences du filtre, à partir de la valeur ''x(n)'' et de ses versions précédentes ''x(n-1)'' et ''x(n-2)'' (et aussi ''y(n-1)'', ''y(n-2)'') qu'il est donc nécessaire de stocker.
* La notion de ''temps réel'' implique que ''y(n)'' doit être calculer avant qu'une nouvelle valeurs de ''x(n)'' ne rentre dans le système.

=== bloc Gnuradio en Python ===

[https://wiki.gnuradio.org/index.php?title=Creating_Your_First_Block wiki Gnuradio - ''Creating Your First Block'']

=== Approximation de PID par filtre numérique linéaire ===

==== Rappels PID ====

* Principe

[[Fichier:PIDprincipe.png|400px]]

[[Fichier:PIDdetail.png|400px]]

* Définition mathématique, la sortie du controleur PID ''u(t)'' est donnée par:

[[Fichier:EqPID.png|400px]]

==== PID numérique "classique" ====

On considère que le temps est discrétisé : ''t = n.dt'' où ''dt'' est l'intervalle de temps entre deux valeurs.

* En approximant grossièrement l'intégrale et la dérivée [[Fichier:PIDderivative.png|400px]] [[Fichier:PIDintegral.png|400px]]
** La dérivée est calculée par ''D = (e(n)-e(n-1))/dt''
** L'intégrale est approximée en cumulant progressivement : ''I = I + e(n).dt''

* Notebook exemple : asservissement de température
** ''Ki = Kd = 0'' => chercher le meilleur ''Kp'' => erreur de régime permanent
** ''Kd = 0'' => l'introduction du terme integral permet de corriger cette erreur de régime permanent
** Le terme dérivatif n'est pas nécessaire dans cet exemple car la température ne dépend que de la commande ''u(t)''.

==== PID numérique par approximation d'un filtre continu ====

* Cherchons la fonction de transfert du filtre continu d'un PID.
 En partant de l'équation différentielle
 [[Fichier:EqPID.png|500px]]
 On applique la transformée de Laplace (dérivée => multiplication par ''s'' ; intégrale => division par ''s'') :
 [[Fichier:eqFxTransfertPID.png|130]]
 Le terme dérivatif étant très sensible au bruit, on lui applique généralement un filtre passe bas (''w0/(w0+s)'') :
 [[Fichier:eqFxTransfertPIDetPB.png|130]]
* Approximation de la fonction de transfert pour obtenir un filtre numérique
** ''backward euler''
** et transformée bilinéaire

* Implémentation du Filtre : classe <code>FilterController</code>
* Application sur l'asservissement d'altitude d'un drone

=== Archive : codage de bloc Gnuradio en C++ ===

Ce guide est inspirée du guide [https://wiki.gnuradio.org/index.php?title=Creating_C%2B%2B_OOT_with_gr-modtool Creating an OOT (C++ block example)] en l'adaptant pour nos besoins :

Nous allons créer un simple bloc qui recopie son entrée (en <code>float</code>) sur sa sortie. Donc le filtre caractérisé par ''y(n)'' = ''x(n)'' ou encore ''H(z)''=1. Il s'agit donc d'une sorte de filtre passe-tout.

'''Suivez bien toutes les étapes, sans aller trop rapidement'''

* Vous pourrez utiliser <code>gedit</code> pour éditer les divers fichiers.

==== Création d'un module externe ====

Dans les lignes qui suivent, le <code>$</code> indique que l'on saisi une commande dans un terminal. Le <code>$</code> n'est pas à saisir.

* Ouvrez un terminal et placez-vous à la racine de votre dossier personnel :
<source>
$ cd $HOME
</source>
* Créez un dossier de travail dédié à gnuradio et déplacez-vous à l'intérieur :
<source>
$ mkdir gnuradio
$ cd gnuradio
</source>
* GNU Radio est livré avec gr_modtool, un utilitaire qui permet de créer des modules externes (OOT). Créons un module <code>monModule</code>
<source>
$ gr_modtool newmod monModule
</source>
* Le dossier <code>gr-monModule</code> est créé et contient tout le code squelette d'un module OOT, mais il n'a pas encore de blocs. Déplacez-vous dans <code>gr-monModule</code> :
<source>
$ cd gr-monModule
</source>
* Vous pouvez afficher le contenu de ce dossier par
<source>
$ ls
</source>

==== Création d'un bloc dans ce module ====

* Ajoutez un nouveau bloc nommé <code>passetout</code> :
<source>
$ gr_modtool add passetout
</source>
* Quelques questions permettent alors de spécifier le type de bloc
<source>
GNU Radio module name identified: passetout
('sink', 'source', 'sync', 'decimator', 'interpolator', 'general', 'tagged_stream', 'hier', 'noblock')
</source>
Saisissez <code>sync</code> comme type de bloc, car le bloc que nous écrivons produira le même nombre d'échantillons en sortie que le nombre d'échantillons consommés depuis l'entrée.
<source>
Enter block type: sync
</source>
* Spécifiez <code>cpp</code> comme langage :
<source>
Language (python/cpp): cpp
Language: C++
Block/code identifier: passetout
</source>
* Spécifiez un nom pour le copyright :
<source>
Please specify the copyright holder: Bibi
</source>
* Il est possible de spécifier des paramètres d'entrée qui peuvent permettre de régler le fonctionnement du bloc. Ce ne sera pas notre cas, ne rien saisir sur cette question :
<source>
Enter valid argument list, including default arguments:
</source>
* De même, on ne donnera pas de code permettant de tester le bon fonctionnement :
<source>
Add Python QA code? [Y/n] n
Add C++ QA code? [Y/n] n
</source>
* Plusieurs fichers sont alors crées :
<source>
Adding file 'lib/passetout_impl.h'...
Adding file 'lib/passetout_impl.cc'...
Adding file 'include/gnuradio/monModule/passetout.h'...
Adding file 'python/monModule/bindings/docstrings/passetout_pydoc_template.h'...
Adding file 'python/monModule/bindings/passetout_python.cc'...
Adding file 'grc/monModule_passetout.block.yml'...
Editing grc/CMakeLists.txt...
</source>

Quelques indications :
* le fichier <code>passetout_impl.h</code> contient l'entête de la classe de notre bloc
* le fichier <code>passetout_impl.cc</code> contient l'implémentation de la classe de notre bloc
* le fichier <code>monModule_passetout.block.yml</code> va contenir des informations faisant le lien entre notre code c++ et le code python utilisé en interne par Gnuradio
* Le tout sera compilé par un <code>Makefile</code> généré par <code>cmake</code>.

==== Fichier <code>passetout_impl.h</code> ====

Le code utile généré est le suivant :
<source lang=cpp>
class passetout_impl : public passetout
{
private:
// Nothing to declare in this block.

public:
passetout_impl();
~passetout_impl();

// Where all the action really happens
int work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items);
};
</source>

Pour se réveiller les neurones sur la POO, qu'est-ce que sont
* <code>passetout_impl()</code>,
* <code>~passetout_impl()</code>,
* <code>private</code>, <code>public</code> ?

Le travail sera réalisé dans la méthode <code>work()</code>, mais nous n'avons pas de modification à apporter dans les déclarations par défaut.

==== Fichier <code>passetout_impl.cc</code> ====

Le code utile généré est le suivant :

{{boîte déroulante/début|titre=passetout_impl.cc}}
<source lang=cpp>
namespace monModule {

#pragma message("set the following appropriately and remove this warning")
using input_type = float;
#pragma message("set the following appropriately and remove this warning")
using output_type = float;
passetout::sptr passetout::make() { return gnuradio::make_block_sptr<passetout_impl>(); }

/*
* The private constructor
*/
passetout_impl::passetout_impl()
: gr::sync_block("passetout",
gr::io_signature::make(
1 /* min inputs */, 1 /* max inputs */, sizeof(input_type)),
gr::io_signature::make(
1 /* min outputs */, 1 /*max outputs */, sizeof(output_type)))
{
}

/*
* Our virtual destructor.
*/
passetout_impl::~passetout_impl() {}

int passetout_impl::work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items)
{
auto in = static_cast<const input_type*>(input_items[0]);
auto out = static_cast<output_type*>(output_items[0]);

#pragma message("Implement the signal processing in your block and remove this warning")
// Do <+signal processing+>

// Tell runtime system how many output items we produced.
return noutput_items;
}

} /* namespace monModule */
</source>
{{boîte déroulante/fin}}

Détaillons :
<source lang=cpp>
#pragma message("set the following appropriately and remove this warning")
using input_type = float;
#pragma message("set the following appropriately and remove this warning")
using output_type = float;
</source>
{{Todos| On spécifie ici le type des données d'entrée et de sortie. Pas de modification à apporter, il suffit de supprimer les deux <code>#pragma</code>}}

<source lang=cpp>
passetout_impl::passetout_impl()
: gr::sync_block("passetout",
gr::io_signature::make(
1 /* min inputs */, 1 /* max inputs */, sizeof(input_type)),
gr::io_signature::make(
1 /* min outputs */, 1 /*max outputs */, sizeof(output_type)))
{
}
</source>

{{Todos| On spécifie ici le nombre d'entrées (1) et le nombre de sorties (1). Pas de modification non plus.}}

{{Todos| Expliquez la syntaxe <code>passetout_impl::passetout_impl() : gr::sync_block(...)"</code> }}

<source lang=cpp>
int passetout_impl::work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items)
{
auto in = static_cast<const input_type*>(input_items[0]);
auto out = static_cast<output_type*>(output_items[0]);

#pragma message("Implement the signal processing in your block and remove this warning")
// Do <+signal processing+>

// Tell runtime system how many output items we produced.
return noutput_items;
}
</source>
Cette méthode <code>work()</code> implémente véritablement le filtrage.
* Les tableaux <code>in</code> et <code>out</code> contiennent respectivement les données en entrée et les données en sortie. Il faut donc calculer <code>out</code> en fonction de <code>in</code>
* Les données d'entrée arrivent par paquets dans un buffer. La variable <code>noutput_items</code> contient le nombre de données disponibles en entrées.
* à la fin de la méthode, on renvoie le nombre de données en sortie que l'on a calculé (entre 1 et <code>noutput_items</code>). Les données d'entrées éventuellement non consommées seront conservées dans le buffer pour le prochain appel de <code>work()</code>
{{Todos| On souhaite ici seulement recopier l'entrée sur la sortie, donc }}
# Enlever la ligne <code>#pragma</code>
# ajouter le code <code> out[0] = in[0];</code> (on recopie le premier échantillon disponible en entrée)
# changer <code>return noutput_items;</code> en <code>return 1;</code> (un seul échantillon a été consommé).

==== Fichier <code>monModule_passetout.block.yml</code> ====

Ce fichier au format YAML (''yet another markup language'') fait le lien entre le code c++ et le code python utilisé en interne par GnuRadio.

{{boîte déroulante/début|titre=monModule_passetout.block.yml}}
<source lang=yaml>
id: monModule_passetout
label: passetout
category: '[monModule]'

templates:
imports: from gnuradio import monModule
make: monModule.passetout()

# Make one 'parameters' list entry for every parameter you want settable from the GUI.
# Keys include:
# * id (makes the value accessible as keyname, e.g. in the make entry)
# * label (label shown in the GUI)
# * dtype (e.g. int, float, complex, byte, short, xxx_vector, ...)
# * default
parameters:
- id: parametername_replace_me
label: FIX ME:
dtype: string
default: You need to fill in your grc/monModule_passetout.block.yaml
#- id: ...
# label: ...
# dtype: ...

# Make one 'inputs' list entry per input and one 'outputs' list entry per output.
# Keys include:
# * label (an identifier for the GUI)
# * domain (optional - stream or message. Default is stream)
# * dtype (e.g. int, float, complex, byte, short, xxx_vector, ...)
# * vlen (optional - data stream vector length. Default is 1)
# * optional (optional - set to 1 for optional inputs. Default is 0)
inputs:
#- label: ...
# domain: ...
# dtype: ...
# vlen: ...
# optional: ...

outputs:
#- label: ...
# domain: ...
# dtype: ...
# vlen: ...
# optional: ...

# 'file_format' specifies the version of the GRC yml format used in the file
# and should usually not be changed.
file_format: 1
</source>
{{boîte déroulante/fin}}

{{Todos| Mettre à jour la section <code>parameters</code> (pas de paramètres, on commente) :}}

<source lang=yaml>
#parameters:
#- id: parametername_replace_me
# label: FIX ME:
# dtype: string
# default: You need to fill in your grc/customModule_testMod.block.yaml
</source>

{{Todos| Mettre à jour la section <code>inputs</code> :}}

<source lang=yaml>
inputs:
- label: in
domain: stream
dtype: float
</source>

{{Todos| Mettre à jour la section <code>output</code> :}}

<source lang=yaml>
outputs:
- label: out
domain: stream
dtype: float
</source>

==== Compilation et installation ====

Voici les étapes :
<source lang=bash>
$ cd CHEMIN-DE-VOTRE-DOSSIER/gr-monModule
$ mkdir build
$ cd build
$ cmake ..
$ make
$ make install
</source>

* <code>cmake ..</code> lance la création des fichiers <code>Makefile</code> qui permettent la compilation et l'installation
* <code>make</code> lance la compilation
* <code>make install</code> lance l'installation (copie des fichiers dans les dossiers gnuradio)

{{Todos| Exécuter chacune de ces lignes, en contrôlant l'absence d'erreur. Dans le cas contraire, contrôler les fichiers <code>.h</code>, <code>.cc</code> et <code>.yaml</code>}}

{{Todos| '''Après ces étapes, et avant de lancer gnuRadio, appeler l'enseignant qui va mettre à jours les bibliothèques partagées.'''}}. Sinon tenter :
<source>
$ export LD_LIBRARY_PATH=/usr/local/lib/x86_64-linux-gnu:$LD_LIBRARY_PATH
$ gnuradio-companion &
</source>

==== Utilisation du bloc et test ====

* Dans Gnuradio, rafraichir la liste des bloc (bouton ''reload'')
* le bloc <code>passetout</code> doit être présent dans la section <code>monModule</code>
* Tester le bon fonctionnement de ce bloc en lui envoyant une sinusoïde que vous devez observer identique à la sortie du bloc. Vérifier avec des graphes.

==== Application : démodulation ====

En reprenant le signal modulé en amplitude et la fonction de transfert du filtre passe-bas du TP précédent :

* Obtenir l'équation aux différence du filtre, ''ie'' écrire ''y(n)='' en fonction de ''x(n)'', ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.
* Créer un nouveau bloc C++ (similaire au passe-tout précédent) dans le module <code>monModule</code> :
** de type <code>sync</code>
** une entrée en <code>float</code>
** une sortie en <code>float</code>
* Écrire le code permettant d'obtenir ''y(n)'' dans la méthode <code>work()</code> :
** ''x(n)'' est donné par <code>in0[0]</code>
** il sera nécessaire d'affecter <code>out0[0]</code> pour produire ''y(n)''.
** il sera nécessaire de stocker dans des '''attributs''' les valeurs de <code>in[0]</code> afin de disposer de ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.
** On rappelle que les attributs doivent être déclarées dans le fichier <code>.h</code> et initialisés dans le constructeur de la classe.

{{Todos| Réaliser cette implémentation du passe-bas et contrôler que la démodulation est identique à celle obtenue au TP précédent}}

{{Todos| Modifier votre code pour implémenter le filtre complet de démodulation}}

Cours:Elen4 TNS TP TpsReel

2026-05-30T08:20:33Z

Fredmn :

[[Cours:Elen4_TNS|{{Rouge|'''Retour à la page du cours'''}}]]

<center>
'''<big>TP6 - Temps réel : bloc Gnuradio en Python / démodulation / PID Numérique</big>'''
</center>

Le but de ce TP est double :
* réaliser des implémentations temps réel de filtre IIR en créant un bloc Gnuradio qui execute un traitement codé en Python
* et étudier l'implémentation d'un PID numérique sous forme d'un filtre IIR.

Dans les deux cas, un système temps réel sera considéré :
* à intervalles de temps (réguliers ou non), une valeur ''x(n)'' rentre dans le système
* le travail consiste à calculer ''y(n)'' avec l'équation au différences du filtre, à partir de la valeur ''x(n)'' et de ses versions précédentes ''x(n-1)'' et ''x(n-2)'' (et aussi ''y(n-1)'', ''y(n-2)'') qu'il est donc nécessaire de stocker.
* La notion de ''temps réel'' implique que ''y(n)'' doit être calculer avant qu'une nouvelle valeurs de ''x(n)'' ne rentre dans le système.

=== Codage de bloc Gnuradio en Python ===

'''EN COURS DE RÉÉCRITURE (C++ vers Python)'''

=== Approximation de PID par filtre numérique linéaire ===

==== Rappels PID ====

* Principe

[[Fichier:PIDprincipe.png|400px]]

[[Fichier:PIDdetail.png|400px]]

* Définition mathématique, la sortie du controleur PID ''u(t)'' est donnée par:

[[Fichier:EqPID.png|400px]]

==== PID numérique "classique" ====

On considère que le temps est discrétisé : ''t = n.dt'' où ''dt'' est l'intervalle de temps entre deux valeurs.

* En approximant grossièrement l'intégrale et la dérivée [[Fichier:PIDderivative.png|400px]] [[Fichier:PIDintegral.png|400px]]
** La dérivée est calculée par ''D = (e(n)-e(n-1))/dt''
** L'intégrale est approximée en cumulant progressivement : ''I = I + e(n).dt''

* Notebook exemple : asservissement de température
** ''Ki = Kd = 0'' => chercher le meilleur ''Kp'' => erreur de régime permanent
** ''Kd = 0'' => l'introduction du terme integral permet de corriger cette erreur de régime permanent
** Le terme dérivatif n'est pas nécessaire dans cet exemple car la température ne dépend que de la commande ''u(t)''.

==== PID numérique par approximation d'un filtre continu ====

* Cherchons la fonction de transfert du filtre continu d'un PID.
 En partant de l'équation différentielle
 [[Fichier:EqPID.png|500px]]
 On applique la transformée de Laplace (dérivée => multiplication par ''s'' ; intégrale => division par ''s'') :
 [[Fichier:eqFxTransfertPID.png|130]]
 Le terme dérivatif étant très sensible au bruit, on lui applique généralement un filtre passe bas (''w0/(w0+s)'') :
 [[Fichier:eqFxTransfertPIDetPB.png|130]]
* Approximation de la fonction de transfert pour obtenir un filtre numérique
** ''backward euler''
** et transformée bilinéaire

* Implémentation du Filtre : classe <code>FilterController</code>
* Application sur l'asservissement d'altitude d'un drone

=== Archive : codage de bloc Gnuradio en C++ ===

Ce guide est inspirée du guide [https://wiki.gnuradio.org/index.php?title=Creating_C%2B%2B_OOT_with_gr-modtool Creating an OOT (C++ block example)] en l'adaptant pour nos besoins :

Nous allons créer un simple bloc qui recopie son entrée (en <code>float</code>) sur sa sortie. Donc le filtre caractérisé par ''y(n)'' = ''x(n)'' ou encore ''H(z)''=1. Il s'agit donc d'une sorte de filtre passe-tout.

'''Suivez bien toutes les étapes, sans aller trop rapidement'''

* Vous pourrez utiliser <code>gedit</code> pour éditer les divers fichiers.

==== Création d'un module externe ====

Dans les lignes qui suivent, le <code>$</code> indique que l'on saisi une commande dans un terminal. Le <code>$</code> n'est pas à saisir.

* Ouvrez un terminal et placez-vous à la racine de votre dossier personnel :
<source>
$ cd $HOME
</source>
* Créez un dossier de travail dédié à gnuradio et déplacez-vous à l'intérieur :
<source>
$ mkdir gnuradio
$ cd gnuradio
</source>
* GNU Radio est livré avec gr_modtool, un utilitaire qui permet de créer des modules externes (OOT). Créons un module <code>monModule</code>
<source>
$ gr_modtool newmod monModule
</source>
* Le dossier <code>gr-monModule</code> est créé et contient tout le code squelette d'un module OOT, mais il n'a pas encore de blocs. Déplacez-vous dans <code>gr-monModule</code> :
<source>
$ cd gr-monModule
</source>
* Vous pouvez afficher le contenu de ce dossier par
<source>
$ ls
</source>

==== Création d'un bloc dans ce module ====

* Ajoutez un nouveau bloc nommé <code>passetout</code> :
<source>
$ gr_modtool add passetout
</source>
* Quelques questions permettent alors de spécifier le type de bloc
<source>
GNU Radio module name identified: passetout
('sink', 'source', 'sync', 'decimator', 'interpolator', 'general', 'tagged_stream', 'hier', 'noblock')
</source>
Saisissez <code>sync</code> comme type de bloc, car le bloc que nous écrivons produira le même nombre d'échantillons en sortie que le nombre d'échantillons consommés depuis l'entrée.
<source>
Enter block type: sync
</source>
* Spécifiez <code>cpp</code> comme langage :
<source>
Language (python/cpp): cpp
Language: C++
Block/code identifier: passetout
</source>
* Spécifiez un nom pour le copyright :
<source>
Please specify the copyright holder: Bibi
</source>
* Il est possible de spécifier des paramètres d'entrée qui peuvent permettre de régler le fonctionnement du bloc. Ce ne sera pas notre cas, ne rien saisir sur cette question :
<source>
Enter valid argument list, including default arguments:
</source>
* De même, on ne donnera pas de code permettant de tester le bon fonctionnement :
<source>
Add Python QA code? [Y/n] n
Add C++ QA code? [Y/n] n
</source>
* Plusieurs fichers sont alors crées :
<source>
Adding file 'lib/passetout_impl.h'...
Adding file 'lib/passetout_impl.cc'...
Adding file 'include/gnuradio/monModule/passetout.h'...
Adding file 'python/monModule/bindings/docstrings/passetout_pydoc_template.h'...
Adding file 'python/monModule/bindings/passetout_python.cc'...
Adding file 'grc/monModule_passetout.block.yml'...
Editing grc/CMakeLists.txt...
</source>

Quelques indications :
* le fichier <code>passetout_impl.h</code> contient l'entête de la classe de notre bloc
* le fichier <code>passetout_impl.cc</code> contient l'implémentation de la classe de notre bloc
* le fichier <code>monModule_passetout.block.yml</code> va contenir des informations faisant le lien entre notre code c++ et le code python utilisé en interne par Gnuradio
* Le tout sera compilé par un <code>Makefile</code> généré par <code>cmake</code>.

==== Fichier <code>passetout_impl.h</code> ====

Le code utile généré est le suivant :
<source lang=cpp>
class passetout_impl : public passetout
{
private:
// Nothing to declare in this block.

public:
passetout_impl();
~passetout_impl();

// Where all the action really happens
int work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items);
};
</source>

Pour se réveiller les neurones sur la POO, qu'est-ce que sont
* <code>passetout_impl()</code>,
* <code>~passetout_impl()</code>,
* <code>private</code>, <code>public</code> ?

Le travail sera réalisé dans la méthode <code>work()</code>, mais nous n'avons pas de modification à apporter dans les déclarations par défaut.

==== Fichier <code>passetout_impl.cc</code> ====

Le code utile généré est le suivant :

{{boîte déroulante/début|titre=passetout_impl.cc}}
<source lang=cpp>
namespace monModule {

#pragma message("set the following appropriately and remove this warning")
using input_type = float;
#pragma message("set the following appropriately and remove this warning")
using output_type = float;
passetout::sptr passetout::make() { return gnuradio::make_block_sptr<passetout_impl>(); }

/*
* The private constructor
*/
passetout_impl::passetout_impl()
: gr::sync_block("passetout",
gr::io_signature::make(
1 /* min inputs */, 1 /* max inputs */, sizeof(input_type)),
gr::io_signature::make(
1 /* min outputs */, 1 /*max outputs */, sizeof(output_type)))
{
}

/*
* Our virtual destructor.
*/
passetout_impl::~passetout_impl() {}

int passetout_impl::work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items)
{
auto in = static_cast<const input_type*>(input_items[0]);
auto out = static_cast<output_type*>(output_items[0]);

#pragma message("Implement the signal processing in your block and remove this warning")
// Do <+signal processing+>

// Tell runtime system how many output items we produced.
return noutput_items;
}

} /* namespace monModule */
</source>
{{boîte déroulante/fin}}

Détaillons :
<source lang=cpp>
#pragma message("set the following appropriately and remove this warning")
using input_type = float;
#pragma message("set the following appropriately and remove this warning")
using output_type = float;
</source>
{{Todos| On spécifie ici le type des données d'entrée et de sortie. Pas de modification à apporter, il suffit de supprimer les deux <code>#pragma</code>}}

<source lang=cpp>
passetout_impl::passetout_impl()
: gr::sync_block("passetout",
gr::io_signature::make(
1 /* min inputs */, 1 /* max inputs */, sizeof(input_type)),
gr::io_signature::make(
1 /* min outputs */, 1 /*max outputs */, sizeof(output_type)))
{
}
</source>

{{Todos| On spécifie ici le nombre d'entrées (1) et le nombre de sorties (1). Pas de modification non plus.}}

{{Todos| Expliquez la syntaxe <code>passetout_impl::passetout_impl() : gr::sync_block(...)"</code> }}

<source lang=cpp>
int passetout_impl::work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items)
{
auto in = static_cast<const input_type*>(input_items[0]);
auto out = static_cast<output_type*>(output_items[0]);

#pragma message("Implement the signal processing in your block and remove this warning")
// Do <+signal processing+>

// Tell runtime system how many output items we produced.
return noutput_items;
}
</source>
Cette méthode <code>work()</code> implémente véritablement le filtrage.
* Les tableaux <code>in</code> et <code>out</code> contiennent respectivement les données en entrée et les données en sortie. Il faut donc calculer <code>out</code> en fonction de <code>in</code>
* Les données d'entrée arrivent par paquets dans un buffer. La variable <code>noutput_items</code> contient le nombre de données disponibles en entrées.
* à la fin de la méthode, on renvoie le nombre de données en sortie que l'on a calculé (entre 1 et <code>noutput_items</code>). Les données d'entrées éventuellement non consommées seront conservées dans le buffer pour le prochain appel de <code>work()</code>
{{Todos| On souhaite ici seulement recopier l'entrée sur la sortie, donc }}
# Enlever la ligne <code>#pragma</code>
# ajouter le code <code> out[0] = in[0];</code> (on recopie le premier échantillon disponible en entrée)
# changer <code>return noutput_items;</code> en <code>return 1;</code> (un seul échantillon a été consommé).

==== Fichier <code>monModule_passetout.block.yml</code> ====

Ce fichier au format YAML (''yet another markup language'') fait le lien entre le code c++ et le code python utilisé en interne par GnuRadio.

{{boîte déroulante/début|titre=monModule_passetout.block.yml}}
<source lang=yaml>
id: monModule_passetout
label: passetout
category: '[monModule]'

templates:
imports: from gnuradio import monModule
make: monModule.passetout()

# Make one 'parameters' list entry for every parameter you want settable from the GUI.
# Keys include:
# * id (makes the value accessible as keyname, e.g. in the make entry)
# * label (label shown in the GUI)
# * dtype (e.g. int, float, complex, byte, short, xxx_vector, ...)
# * default
parameters:
- id: parametername_replace_me
label: FIX ME:
dtype: string
default: You need to fill in your grc/monModule_passetout.block.yaml
#- id: ...
# label: ...
# dtype: ...

# Make one 'inputs' list entry per input and one 'outputs' list entry per output.
# Keys include:
# * label (an identifier for the GUI)
# * domain (optional - stream or message. Default is stream)
# * dtype (e.g. int, float, complex, byte, short, xxx_vector, ...)
# * vlen (optional - data stream vector length. Default is 1)
# * optional (optional - set to 1 for optional inputs. Default is 0)
inputs:
#- label: ...
# domain: ...
# dtype: ...
# vlen: ...
# optional: ...

outputs:
#- label: ...
# domain: ...
# dtype: ...
# vlen: ...
# optional: ...

# 'file_format' specifies the version of the GRC yml format used in the file
# and should usually not be changed.
file_format: 1
</source>
{{boîte déroulante/fin}}

{{Todos| Mettre à jour la section <code>parameters</code> (pas de paramètres, on commente) :}}

<source lang=yaml>
#parameters:
#- id: parametername_replace_me
# label: FIX ME:
# dtype: string
# default: You need to fill in your grc/customModule_testMod.block.yaml
</source>

{{Todos| Mettre à jour la section <code>inputs</code> :}}

<source lang=yaml>
inputs:
- label: in
domain: stream
dtype: float
</source>

{{Todos| Mettre à jour la section <code>output</code> :}}

<source lang=yaml>
outputs:
- label: out
domain: stream
dtype: float
</source>

==== Compilation et installation ====

Voici les étapes :
<source lang=bash>
$ cd CHEMIN-DE-VOTRE-DOSSIER/gr-monModule
$ mkdir build
$ cd build
$ cmake ..
$ make
$ make install
</source>

* <code>cmake ..</code> lance la création des fichiers <code>Makefile</code> qui permettent la compilation et l'installation
* <code>make</code> lance la compilation
* <code>make install</code> lance l'installation (copie des fichiers dans les dossiers gnuradio)

{{Todos| Exécuter chacune de ces lignes, en contrôlant l'absence d'erreur. Dans le cas contraire, contrôler les fichiers <code>.h</code>, <code>.cc</code> et <code>.yaml</code>}}

{{Todos| '''Après ces étapes, et avant de lancer gnuRadio, appeler l'enseignant qui va mettre à jours les bibliothèques partagées.'''}}. Sinon tenter :
<source>
$ export LD_LIBRARY_PATH=/usr/local/lib/x86_64-linux-gnu:$LD_LIBRARY_PATH
$ gnuradio-companion &
</source>

==== Utilisation du bloc et test ====

* Dans Gnuradio, rafraichir la liste des bloc (bouton ''reload'')
* le bloc <code>passetout</code> doit être présent dans la section <code>monModule</code>
* Tester le bon fonctionnement de ce bloc en lui envoyant une sinusoïde que vous devez observer identique à la sortie du bloc. Vérifier avec des graphes.

==== Application : démodulation ====

En reprenant le signal modulé en amplitude et la fonction de transfert du filtre passe-bas du TP précédent :

* Obtenir l'équation aux différence du filtre, ''ie'' écrire ''y(n)='' en fonction de ''x(n)'', ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.
* Créer un nouveau bloc C++ (similaire au passe-tout précédent) dans le module <code>monModule</code> :
** de type <code>sync</code>
** une entrée en <code>float</code>
** une sortie en <code>float</code>
* Écrire le code permettant d'obtenir ''y(n)'' dans la méthode <code>work()</code> :
** ''x(n)'' est donné par <code>in0[0]</code>
** il sera nécessaire d'affecter <code>out0[0]</code> pour produire ''y(n)''.
** il sera nécessaire de stocker dans des '''attributs''' les valeurs de <code>in[0]</code> afin de disposer de ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.
** On rappelle que les attributs doivent être déclarées dans le fichier <code>.h</code> et initialisés dans le constructeur de la classe.

{{Todos| Réaliser cette implémentation du passe-bas et contrôler que la démodulation est identique à celle obtenue au TP précédent}}

{{Todos| Modifier votre code pour implémenter le filtre complet de démodulation}}

Cours:Elen4 TNS TP TpsReel

2026-05-30T08:17:35Z

Fredmn :

[[Cours:Elen4_TNS|{{Rouge|'''Retour à la page du cours'''}}]]

<center>
'''<big>TP6 - Temps réel : bloc Gnuradio en Python / démodulation / PID Numérique</big>'''
</center>

Le but de ce TP est double :
* réaliser des implémentations temps réel de filtre IIR en créant un bloc Gnuradio qui execute un traitement codé en Python
* et étudier l'implémentation d'un PID numérique sous forme d'un filtre IIR.

Dans les deux cas, un système temps réel sera considéré :
* à intervalles de temps (réguliers ou non), une valeur ''x(n)'' rentre dans le système
* le travail consiste à calculer ''y(n)'' avec l'équation au différences du filtre, à partir de la valeur ''x(n)'' et de ses versions précédentes ''x(n-1)'' et ''x(n-2)'' (et aussi ''y(n-1)'', ''y(n-2)'') qu'il est donc nécessaire de stocker.
* La notion de ''temps réel" implique que ''y(n)'' doit pouvoir être calculer avant qu'une nouvelle valeurs de ''x(n)'' ne rentre dans le système.

=== Codage de bloc Gnuradio en Python ===

'''EN COURS DE RÉÉCRITURE (C++ vers Python)'''

Ce guide est inspirée du guide [https://wiki.gnuradio.org/index.php?title=Creating_C%2B%2B_OOT_with_gr-modtool Creating an OOT (C++ block example)] en l'adaptant pour nos besoins :

Nous allons créer un simple bloc qui recopie son entrée (en <code>float</code>) sur sa sortie. Donc le filtre caractérisé par ''y(n)'' = ''x(n)'' ou encore ''H(z)''=1. Il s'agit donc d'une sorte de filtre passe-tout.

'''Suivez bien toutes les étapes, sans aller trop rapidement'''

* Vous pourrez utiliser <code>gedit</code> pour éditer les divers fichiers.

==== Création d'un module externe ====

Dans les lignes qui suivent, le <code>$</code> indique que l'on saisi une commande dans un terminal. Le <code>$</code> n'est pas à saisir.

* Ouvrez un terminal et placez-vous à la racine de votre dossier personnel :
<source>
$ cd $HOME
</source>
* Créez un dossier de travail dédié à gnuradio et déplacez-vous à l'intérieur :
<source>
$ mkdir gnuradio
$ cd gnuradio
</source>
* GNU Radio est livré avec gr_modtool, un utilitaire qui permet de créer des modules externes (OOT). Créons un module <code>monModule</code>
<source>
$ gr_modtool newmod monModule
</source>
* Le dossier <code>gr-monModule</code> est créé et contient tout le code squelette d'un module OOT, mais il n'a pas encore de blocs. Déplacez-vous dans <code>gr-monModule</code> :
<source>
$ cd gr-monModule
</source>
* Vous pouvez afficher le contenu de ce dossier par
<source>
$ ls
</source>

==== Création d'un bloc dans ce module ====

* Ajoutez un nouveau bloc nommé <code>passetout</code> :
<source>
$ gr_modtool add passetout
</source>
* Quelques questions permettent alors de spécifier le type de bloc
<source>
GNU Radio module name identified: passetout
('sink', 'source', 'sync', 'decimator', 'interpolator', 'general', 'tagged_stream', 'hier', 'noblock')
</source>
Saisissez <code>sync</code> comme type de bloc, car le bloc que nous écrivons produira le même nombre d'échantillons en sortie que le nombre d'échantillons consommés depuis l'entrée.
<source>
Enter block type: sync
</source>
* Spécifiez <code>cpp</code> comme langage :
<source>
Language (python/cpp): cpp
Language: C++
Block/code identifier: passetout
</source>
* Spécifiez un nom pour le copyright :
<source>
Please specify the copyright holder: Bibi
</source>
* Il est possible de spécifier des paramètres d'entrée qui peuvent permettre de régler le fonctionnement du bloc. Ce ne sera pas notre cas, ne rien saisir sur cette question :
<source>
Enter valid argument list, including default arguments:
</source>
* De même, on ne donnera pas de code permettant de tester le bon fonctionnement :
<source>
Add Python QA code? [Y/n] n
Add C++ QA code? [Y/n] n
</source>
* Plusieurs fichers sont alors crées :
<source>
Adding file 'lib/passetout_impl.h'...
Adding file 'lib/passetout_impl.cc'...
Adding file 'include/gnuradio/monModule/passetout.h'...
Adding file 'python/monModule/bindings/docstrings/passetout_pydoc_template.h'...
Adding file 'python/monModule/bindings/passetout_python.cc'...
Adding file 'grc/monModule_passetout.block.yml'...
Editing grc/CMakeLists.txt...
</source>

Quelques indications :
* le fichier <code>passetout_impl.h</code> contient l'entête de la classe de notre bloc
* le fichier <code>passetout_impl.cc</code> contient l'implémentation de la classe de notre bloc
* le fichier <code>monModule_passetout.block.yml</code> va contenir des informations faisant le lien entre notre code c++ et le code python utilisé en interne par Gnuradio
* Le tout sera compilé par un <code>Makefile</code> généré par <code>cmake</code>.

==== Fichier <code>passetout_impl.h</code> ====

Le code utile généré est le suivant :
<source lang=cpp>
class passetout_impl : public passetout
{
private:
// Nothing to declare in this block.

public:
passetout_impl();
~passetout_impl();

// Where all the action really happens
int work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items);
};
</source>

Pour se réveiller les neurones sur la POO, qu'est-ce que sont
* <code>passetout_impl()</code>,
* <code>~passetout_impl()</code>,
* <code>private</code>, <code>public</code> ?

Le travail sera réalisé dans la méthode <code>work()</code>, mais nous n'avons pas de modification à apporter dans les déclarations par défaut.

==== Fichier <code>passetout_impl.cc</code> ====

Le code utile généré est le suivant :

{{boîte déroulante/début|titre=passetout_impl.cc}}
<source lang=cpp>
namespace monModule {

#pragma message("set the following appropriately and remove this warning")
using input_type = float;
#pragma message("set the following appropriately and remove this warning")
using output_type = float;
passetout::sptr passetout::make() { return gnuradio::make_block_sptr<passetout_impl>(); }

/*
* The private constructor
*/
passetout_impl::passetout_impl()
: gr::sync_block("passetout",
gr::io_signature::make(
1 /* min inputs */, 1 /* max inputs */, sizeof(input_type)),
gr::io_signature::make(
1 /* min outputs */, 1 /*max outputs */, sizeof(output_type)))
{
}

/*
* Our virtual destructor.
*/
passetout_impl::~passetout_impl() {}

int passetout_impl::work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items)
{
auto in = static_cast<const input_type*>(input_items[0]);
auto out = static_cast<output_type*>(output_items[0]);

#pragma message("Implement the signal processing in your block and remove this warning")
// Do <+signal processing+>

// Tell runtime system how many output items we produced.
return noutput_items;
}

} /* namespace monModule */
</source>
{{boîte déroulante/fin}}

Détaillons :
<source lang=cpp>
#pragma message("set the following appropriately and remove this warning")
using input_type = float;
#pragma message("set the following appropriately and remove this warning")
using output_type = float;
</source>
{{Todos| On spécifie ici le type des données d'entrée et de sortie. Pas de modification à apporter, il suffit de supprimer les deux <code>#pragma</code>}}

<source lang=cpp>
passetout_impl::passetout_impl()
: gr::sync_block("passetout",
gr::io_signature::make(
1 /* min inputs */, 1 /* max inputs */, sizeof(input_type)),
gr::io_signature::make(
1 /* min outputs */, 1 /*max outputs */, sizeof(output_type)))
{
}
</source>

{{Todos| On spécifie ici le nombre d'entrées (1) et le nombre de sorties (1). Pas de modification non plus.}}

{{Todos| Expliquez la syntaxe <code>passetout_impl::passetout_impl() : gr::sync_block(...)"</code> }}

<source lang=cpp>
int passetout_impl::work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items)
{
auto in = static_cast<const input_type*>(input_items[0]);
auto out = static_cast<output_type*>(output_items[0]);

#pragma message("Implement the signal processing in your block and remove this warning")
// Do <+signal processing+>

// Tell runtime system how many output items we produced.
return noutput_items;
}
</source>
Cette méthode <code>work()</code> implémente véritablement le filtrage.
* Les tableaux <code>in</code> et <code>out</code> contiennent respectivement les données en entrée et les données en sortie. Il faut donc calculer <code>out</code> en fonction de <code>in</code>
* Les données d'entrée arrivent par paquets dans un buffer. La variable <code>noutput_items</code> contient le nombre de données disponibles en entrées.
* à la fin de la méthode, on renvoie le nombre de données en sortie que l'on a calculé (entre 1 et <code>noutput_items</code>). Les données d'entrées éventuellement non consommées seront conservées dans le buffer pour le prochain appel de <code>work()</code>
{{Todos| On souhaite ici seulement recopier l'entrée sur la sortie, donc }}
# Enlever la ligne <code>#pragma</code>
# ajouter le code <code> out[0] = in[0];</code> (on recopie le premier échantillon disponible en entrée)
# changer <code>return noutput_items;</code> en <code>return 1;</code> (un seul échantillon a été consommé).

==== Fichier <code>monModule_passetout.block.yml</code> ====

Ce fichier au format YAML (''yet another markup language'') fait le lien entre le code c++ et le code python utilisé en interne par GnuRadio.

{{boîte déroulante/début|titre=monModule_passetout.block.yml}}
<source lang=yaml>
id: monModule_passetout
label: passetout
category: '[monModule]'

templates:
imports: from gnuradio import monModule
make: monModule.passetout()

# Make one 'parameters' list entry for every parameter you want settable from the GUI.
# Keys include:
# * id (makes the value accessible as keyname, e.g. in the make entry)
# * label (label shown in the GUI)
# * dtype (e.g. int, float, complex, byte, short, xxx_vector, ...)
# * default
parameters:
- id: parametername_replace_me
label: FIX ME:
dtype: string
default: You need to fill in your grc/monModule_passetout.block.yaml
#- id: ...
# label: ...
# dtype: ...

# Make one 'inputs' list entry per input and one 'outputs' list entry per output.
# Keys include:
# * label (an identifier for the GUI)
# * domain (optional - stream or message. Default is stream)
# * dtype (e.g. int, float, complex, byte, short, xxx_vector, ...)
# * vlen (optional - data stream vector length. Default is 1)
# * optional (optional - set to 1 for optional inputs. Default is 0)
inputs:
#- label: ...
# domain: ...
# dtype: ...
# vlen: ...
# optional: ...

outputs:
#- label: ...
# domain: ...
# dtype: ...
# vlen: ...
# optional: ...

# 'file_format' specifies the version of the GRC yml format used in the file
# and should usually not be changed.
file_format: 1
</source>
{{boîte déroulante/fin}}

{{Todos| Mettre à jour la section <code>parameters</code> (pas de paramètres, on commente) :}}

<source lang=yaml>
#parameters:
#- id: parametername_replace_me
# label: FIX ME:
# dtype: string
# default: You need to fill in your grc/customModule_testMod.block.yaml
</source>

{{Todos| Mettre à jour la section <code>inputs</code> :}}

<source lang=yaml>
inputs:
- label: in
domain: stream
dtype: float
</source>

{{Todos| Mettre à jour la section <code>output</code> :}}

<source lang=yaml>
outputs:
- label: out
domain: stream
dtype: float
</source>

==== Compilation et installation ====

Voici les étapes :
<source lang=bash>
$ cd CHEMIN-DE-VOTRE-DOSSIER/gr-monModule
$ mkdir build
$ cd build
$ cmake ..
$ make
$ make install
</source>

* <code>cmake ..</code> lance la création des fichiers <code>Makefile</code> qui permettent la compilation et l'installation
* <code>make</code> lance la compilation
* <code>make install</code> lance l'installation (copie des fichiers dans les dossiers gnuradio)

{{Todos| Exécuter chacune de ces lignes, en contrôlant l'absence d'erreur. Dans le cas contraire, contrôler les fichiers <code>.h</code>, <code>.cc</code> et <code>.yaml</code>}}

{{Todos| '''Après ces étapes, et avant de lancer gnuRadio, appeler l'enseignant qui va mettre à jours les bibliothèques partagées.'''}}. Sinon tenter :
<source>
$ export LD_LIBRARY_PATH=/usr/local/lib/x86_64-linux-gnu:$LD_LIBRARY_PATH
$ gnuradio-companion &
</source>

==== Utilisation du bloc et test ====

* Dans Gnuradio, rafraichir la liste des bloc (bouton ''reload'')
* le bloc <code>passetout</code> doit être présent dans la section <code>monModule</code>
* Tester le bon fonctionnement de ce bloc en lui envoyant une sinusoïde que vous devez observer identique à la sortie du bloc. Vérifier avec des graphes.

==== Application : démodulation ====

En reprenant le signal modulé en amplitude et la fonction de transfert du filtre passe-bas du TP précédent :

* Obtenir l'équation aux différence du filtre, ''ie'' écrire ''y(n)='' en fonction de ''x(n)'', ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.
* Créer un nouveau bloc C++ (similaire au passe-tout précédent) dans le module <code>monModule</code> :
** de type <code>sync</code>
** une entrée en <code>float</code>
** une sortie en <code>float</code>
* Écrire le code permettant d'obtenir ''y(n)'' dans la méthode <code>work()</code> :
** ''x(n)'' est donné par <code>in0[0]</code>
** il sera nécessaire d'affecter <code>out0[0]</code> pour produire ''y(n)''.
** il sera nécessaire de stocker dans des '''attributs''' les valeurs de <code>in[0]</code> afin de disposer de ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.
** On rappelle que les attributs doivent être déclarées dans le fichier <code>.h</code> et initialisés dans le constructeur de la classe.

{{Todos| Réaliser cette implémentation du passe-bas et contrôler que la démodulation est identique à celle obtenue au TP précédent}}

{{Todos| Modifier votre code pour implémenter le filtre complet de démodulation}}

=== Approximation de PID par filtre numérique linéaire ===

==== Rappels PID ====

* Principe

[[Fichier:PIDprincipe.png|400px]]

[[Fichier:PIDdetail.png|400px]]

* Définition mathématique, la sortie du controleur PID ''u(t)'' est donnée par:

[[Fichier:EqPID.png|400px]]

==== PID numérique "classique" ====

On considère que le temps est discrétisé : ''t = n.dt'' où ''dt'' est l'intervalle de temps entre deux valeurs.

* En approximant grossièrement l'intégrale et la dérivée [[Fichier:PIDderivative.png|400px]] [[Fichier:PIDintegral.png|400px]]
** La dérivée est calculée par ''D = (e(n)-e(n-1))/dt''
** L'intégrale est approximée en cumulant progressivement : ''I = I + e(n).dt''

* Notebook exemple : asservissement de température
** ''Ki = Kd = 0'' => chercher le meilleur ''Kp'' => erreur de régime permanent
** ''Kd = 0'' => l'introduction du terme integral permet de corriger cette erreur de régime permanent
** Le terme dérivatif n'est pas nécessaire dans cet exemple car la température ne dépend que de la commande ''u(t)''.

==== PID numérique par approximation d'un filtre continu ====

* Cherchons la fonction de transfert du filtre continu d'un PID.
 En partant de l'équation différentielle
 [[Fichier:EqPID.png|500px]]
 On applique la transformée de Laplace (dérivée => multiplication par ''s'' ; intégrale => division par ''s'') :
 [[Fichier:eqFxTransfertPID.png|130]]
 Le terme dérivatif étant très sensible au bruit, on lui applique généralement un filtre passe bas (''w0/(w0+s)'') :
 [[Fichier:eqFxTransfertPIDetPB.png|130]]
* Approximation de la fonction de transfert pour obtenir un filtre numérique
** ''backward euler''
** et transformée bilinéaire

* Implémentation du Filtre : classe <code>FilterController</code>
* Application sur l'asservissement d'altitude d'un drone

Cours:Elen4 TNS TP TpsReel

2026-05-30T08:17:09Z

Fredmn :

[[Cours:Elen4_TNS|{{Rouge|'''Retour à la page du cours'''}}]]

<center>
'''<big>TP6 : Temps réel - Bloc Gnuradio en Python / démodulation / PID Numérique</big>'''
</center>

Le but de ce TP est double :
* réaliser des implémentations temps réel de filtre IIR en créant un bloc Gnuradio qui execute un traitement codé en Python
* et étudier l'implémentation d'un PID numérique sous forme d'un filtre IIR.

Dans les deux cas, un système temps réel sera considéré :
* à intervalles de temps (réguliers ou non), une valeur ''x(n)'' rentre dans le système
* le travail consiste à calculer ''y(n)'' avec l'équation au différences du filtre, à partir de la valeur ''x(n)'' et de ses versions précédentes ''x(n-1)'' et ''x(n-2)'' (et aussi ''y(n-1)'', ''y(n-2)'') qu'il est donc nécessaire de stocker.
* La notion de ''temps réel" implique que ''y(n)'' doit pouvoir être calculer avant qu'une nouvelle valeurs de ''x(n)'' ne rentre dans le système.

=== Codage de bloc Gnuradio en Python ===

'''EN COURS DE RÉÉCRITURE (C++ vers Python)'''

Ce guide est inspirée du guide [https://wiki.gnuradio.org/index.php?title=Creating_C%2B%2B_OOT_with_gr-modtool Creating an OOT (C++ block example)] en l'adaptant pour nos besoins :

Nous allons créer un simple bloc qui recopie son entrée (en <code>float</code>) sur sa sortie. Donc le filtre caractérisé par ''y(n)'' = ''x(n)'' ou encore ''H(z)''=1. Il s'agit donc d'une sorte de filtre passe-tout.

'''Suivez bien toutes les étapes, sans aller trop rapidement'''

* Vous pourrez utiliser <code>gedit</code> pour éditer les divers fichiers.

==== Création d'un module externe ====

Dans les lignes qui suivent, le <code>$</code> indique que l'on saisi une commande dans un terminal. Le <code>$</code> n'est pas à saisir.

* Ouvrez un terminal et placez-vous à la racine de votre dossier personnel :
<source>
$ cd $HOME
</source>
* Créez un dossier de travail dédié à gnuradio et déplacez-vous à l'intérieur :
<source>
$ mkdir gnuradio
$ cd gnuradio
</source>
* GNU Radio est livré avec gr_modtool, un utilitaire qui permet de créer des modules externes (OOT). Créons un module <code>monModule</code>
<source>
$ gr_modtool newmod monModule
</source>
* Le dossier <code>gr-monModule</code> est créé et contient tout le code squelette d'un module OOT, mais il n'a pas encore de blocs. Déplacez-vous dans <code>gr-monModule</code> :
<source>
$ cd gr-monModule
</source>
* Vous pouvez afficher le contenu de ce dossier par
<source>
$ ls
</source>

==== Création d'un bloc dans ce module ====

* Ajoutez un nouveau bloc nommé <code>passetout</code> :
<source>
$ gr_modtool add passetout
</source>
* Quelques questions permettent alors de spécifier le type de bloc
<source>
GNU Radio module name identified: passetout
('sink', 'source', 'sync', 'decimator', 'interpolator', 'general', 'tagged_stream', 'hier', 'noblock')
</source>
Saisissez <code>sync</code> comme type de bloc, car le bloc que nous écrivons produira le même nombre d'échantillons en sortie que le nombre d'échantillons consommés depuis l'entrée.
<source>
Enter block type: sync
</source>
* Spécifiez <code>cpp</code> comme langage :
<source>
Language (python/cpp): cpp
Language: C++
Block/code identifier: passetout
</source>
* Spécifiez un nom pour le copyright :
<source>
Please specify the copyright holder: Bibi
</source>
* Il est possible de spécifier des paramètres d'entrée qui peuvent permettre de régler le fonctionnement du bloc. Ce ne sera pas notre cas, ne rien saisir sur cette question :
<source>
Enter valid argument list, including default arguments:
</source>
* De même, on ne donnera pas de code permettant de tester le bon fonctionnement :
<source>
Add Python QA code? [Y/n] n
Add C++ QA code? [Y/n] n
</source>
* Plusieurs fichers sont alors crées :
<source>
Adding file 'lib/passetout_impl.h'...
Adding file 'lib/passetout_impl.cc'...
Adding file 'include/gnuradio/monModule/passetout.h'...
Adding file 'python/monModule/bindings/docstrings/passetout_pydoc_template.h'...
Adding file 'python/monModule/bindings/passetout_python.cc'...
Adding file 'grc/monModule_passetout.block.yml'...
Editing grc/CMakeLists.txt...
</source>

Quelques indications :
* le fichier <code>passetout_impl.h</code> contient l'entête de la classe de notre bloc
* le fichier <code>passetout_impl.cc</code> contient l'implémentation de la classe de notre bloc
* le fichier <code>monModule_passetout.block.yml</code> va contenir des informations faisant le lien entre notre code c++ et le code python utilisé en interne par Gnuradio
* Le tout sera compilé par un <code>Makefile</code> généré par <code>cmake</code>.

==== Fichier <code>passetout_impl.h</code> ====

Le code utile généré est le suivant :
<source lang=cpp>
class passetout_impl : public passetout
{
private:
// Nothing to declare in this block.

public:
passetout_impl();
~passetout_impl();

// Where all the action really happens
int work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items);
};
</source>

Pour se réveiller les neurones sur la POO, qu'est-ce que sont
* <code>passetout_impl()</code>,
* <code>~passetout_impl()</code>,
* <code>private</code>, <code>public</code> ?

Le travail sera réalisé dans la méthode <code>work()</code>, mais nous n'avons pas de modification à apporter dans les déclarations par défaut.

==== Fichier <code>passetout_impl.cc</code> ====

Le code utile généré est le suivant :

{{boîte déroulante/début|titre=passetout_impl.cc}}
<source lang=cpp>
namespace monModule {

#pragma message("set the following appropriately and remove this warning")
using input_type = float;
#pragma message("set the following appropriately and remove this warning")
using output_type = float;
passetout::sptr passetout::make() { return gnuradio::make_block_sptr<passetout_impl>(); }

/*
* The private constructor
*/
passetout_impl::passetout_impl()
: gr::sync_block("passetout",
gr::io_signature::make(
1 /* min inputs */, 1 /* max inputs */, sizeof(input_type)),
gr::io_signature::make(
1 /* min outputs */, 1 /*max outputs */, sizeof(output_type)))
{
}

/*
* Our virtual destructor.
*/
passetout_impl::~passetout_impl() {}

int passetout_impl::work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items)
{
auto in = static_cast<const input_type*>(input_items[0]);
auto out = static_cast<output_type*>(output_items[0]);

#pragma message("Implement the signal processing in your block and remove this warning")
// Do <+signal processing+>

// Tell runtime system how many output items we produced.
return noutput_items;
}

} /* namespace monModule */
</source>
{{boîte déroulante/fin}}

Détaillons :
<source lang=cpp>
#pragma message("set the following appropriately and remove this warning")
using input_type = float;
#pragma message("set the following appropriately and remove this warning")
using output_type = float;
</source>
{{Todos| On spécifie ici le type des données d'entrée et de sortie. Pas de modification à apporter, il suffit de supprimer les deux <code>#pragma</code>}}

<source lang=cpp>
passetout_impl::passetout_impl()
: gr::sync_block("passetout",
gr::io_signature::make(
1 /* min inputs */, 1 /* max inputs */, sizeof(input_type)),
gr::io_signature::make(
1 /* min outputs */, 1 /*max outputs */, sizeof(output_type)))
{
}
</source>

{{Todos| On spécifie ici le nombre d'entrées (1) et le nombre de sorties (1). Pas de modification non plus.}}

{{Todos| Expliquez la syntaxe <code>passetout_impl::passetout_impl() : gr::sync_block(...)"</code> }}

<source lang=cpp>
int passetout_impl::work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items)
{
auto in = static_cast<const input_type*>(input_items[0]);
auto out = static_cast<output_type*>(output_items[0]);

#pragma message("Implement the signal processing in your block and remove this warning")
// Do <+signal processing+>

// Tell runtime system how many output items we produced.
return noutput_items;
}
</source>
Cette méthode <code>work()</code> implémente véritablement le filtrage.
* Les tableaux <code>in</code> et <code>out</code> contiennent respectivement les données en entrée et les données en sortie. Il faut donc calculer <code>out</code> en fonction de <code>in</code>
* Les données d'entrée arrivent par paquets dans un buffer. La variable <code>noutput_items</code> contient le nombre de données disponibles en entrées.
* à la fin de la méthode, on renvoie le nombre de données en sortie que l'on a calculé (entre 1 et <code>noutput_items</code>). Les données d'entrées éventuellement non consommées seront conservées dans le buffer pour le prochain appel de <code>work()</code>
{{Todos| On souhaite ici seulement recopier l'entrée sur la sortie, donc }}
# Enlever la ligne <code>#pragma</code>
# ajouter le code <code> out[0] = in[0];</code> (on recopie le premier échantillon disponible en entrée)
# changer <code>return noutput_items;</code> en <code>return 1;</code> (un seul échantillon a été consommé).

==== Fichier <code>monModule_passetout.block.yml</code> ====

Ce fichier au format YAML (''yet another markup language'') fait le lien entre le code c++ et le code python utilisé en interne par GnuRadio.

{{boîte déroulante/début|titre=monModule_passetout.block.yml}}
<source lang=yaml>
id: monModule_passetout
label: passetout
category: '[monModule]'

templates:
imports: from gnuradio import monModule
make: monModule.passetout()

# Make one 'parameters' list entry for every parameter you want settable from the GUI.
# Keys include:
# * id (makes the value accessible as keyname, e.g. in the make entry)
# * label (label shown in the GUI)
# * dtype (e.g. int, float, complex, byte, short, xxx_vector, ...)
# * default
parameters:
- id: parametername_replace_me
label: FIX ME:
dtype: string
default: You need to fill in your grc/monModule_passetout.block.yaml
#- id: ...
# label: ...
# dtype: ...

# Make one 'inputs' list entry per input and one 'outputs' list entry per output.
# Keys include:
# * label (an identifier for the GUI)
# * domain (optional - stream or message. Default is stream)
# * dtype (e.g. int, float, complex, byte, short, xxx_vector, ...)
# * vlen (optional - data stream vector length. Default is 1)
# * optional (optional - set to 1 for optional inputs. Default is 0)
inputs:
#- label: ...
# domain: ...
# dtype: ...
# vlen: ...
# optional: ...

outputs:
#- label: ...
# domain: ...
# dtype: ...
# vlen: ...
# optional: ...

# 'file_format' specifies the version of the GRC yml format used in the file
# and should usually not be changed.
file_format: 1
</source>
{{boîte déroulante/fin}}

{{Todos| Mettre à jour la section <code>parameters</code> (pas de paramètres, on commente) :}}

<source lang=yaml>
#parameters:
#- id: parametername_replace_me
# label: FIX ME:
# dtype: string
# default: You need to fill in your grc/customModule_testMod.block.yaml
</source>

{{Todos| Mettre à jour la section <code>inputs</code> :}}

<source lang=yaml>
inputs:
- label: in
domain: stream
dtype: float
</source>

{{Todos| Mettre à jour la section <code>output</code> :}}

<source lang=yaml>
outputs:
- label: out
domain: stream
dtype: float
</source>

==== Compilation et installation ====

Voici les étapes :
<source lang=bash>
$ cd CHEMIN-DE-VOTRE-DOSSIER/gr-monModule
$ mkdir build
$ cd build
$ cmake ..
$ make
$ make install
</source>

* <code>cmake ..</code> lance la création des fichiers <code>Makefile</code> qui permettent la compilation et l'installation
* <code>make</code> lance la compilation
* <code>make install</code> lance l'installation (copie des fichiers dans les dossiers gnuradio)

{{Todos| Exécuter chacune de ces lignes, en contrôlant l'absence d'erreur. Dans le cas contraire, contrôler les fichiers <code>.h</code>, <code>.cc</code> et <code>.yaml</code>}}

{{Todos| '''Après ces étapes, et avant de lancer gnuRadio, appeler l'enseignant qui va mettre à jours les bibliothèques partagées.'''}}. Sinon tenter :
<source>
$ export LD_LIBRARY_PATH=/usr/local/lib/x86_64-linux-gnu:$LD_LIBRARY_PATH
$ gnuradio-companion &
</source>

==== Utilisation du bloc et test ====

* Dans Gnuradio, rafraichir la liste des bloc (bouton ''reload'')
* le bloc <code>passetout</code> doit être présent dans la section <code>monModule</code>
* Tester le bon fonctionnement de ce bloc en lui envoyant une sinusoïde que vous devez observer identique à la sortie du bloc. Vérifier avec des graphes.

==== Application : démodulation ====

En reprenant le signal modulé en amplitude et la fonction de transfert du filtre passe-bas du TP précédent :

* Obtenir l'équation aux différence du filtre, ''ie'' écrire ''y(n)='' en fonction de ''x(n)'', ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.
* Créer un nouveau bloc C++ (similaire au passe-tout précédent) dans le module <code>monModule</code> :
** de type <code>sync</code>
** une entrée en <code>float</code>
** une sortie en <code>float</code>
* Écrire le code permettant d'obtenir ''y(n)'' dans la méthode <code>work()</code> :
** ''x(n)'' est donné par <code>in0[0]</code>
** il sera nécessaire d'affecter <code>out0[0]</code> pour produire ''y(n)''.
** il sera nécessaire de stocker dans des '''attributs''' les valeurs de <code>in[0]</code> afin de disposer de ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.
** On rappelle que les attributs doivent être déclarées dans le fichier <code>.h</code> et initialisés dans le constructeur de la classe.

{{Todos| Réaliser cette implémentation du passe-bas et contrôler que la démodulation est identique à celle obtenue au TP précédent}}

{{Todos| Modifier votre code pour implémenter le filtre complet de démodulation}}

=== Approximation de PID par filtre numérique linéaire ===

==== Rappels PID ====

* Principe

[[Fichier:PIDprincipe.png|400px]]

[[Fichier:PIDdetail.png|400px]]

* Définition mathématique, la sortie du controleur PID ''u(t)'' est donnée par:

[[Fichier:EqPID.png|400px]]

==== PID numérique "classique" ====

On considère que le temps est discrétisé : ''t = n.dt'' où ''dt'' est l'intervalle de temps entre deux valeurs.

* En approximant grossièrement l'intégrale et la dérivée [[Fichier:PIDderivative.png|400px]] [[Fichier:PIDintegral.png|400px]]
** La dérivée est calculée par ''D = (e(n)-e(n-1))/dt''
** L'intégrale est approximée en cumulant progressivement : ''I = I + e(n).dt''

* Notebook exemple : asservissement de température
** ''Ki = Kd = 0'' => chercher le meilleur ''Kp'' => erreur de régime permanent
** ''Kd = 0'' => l'introduction du terme integral permet de corriger cette erreur de régime permanent
** Le terme dérivatif n'est pas nécessaire dans cet exemple car la température ne dépend que de la commande ''u(t)''.

==== PID numérique par approximation d'un filtre continu ====

* Cherchons la fonction de transfert du filtre continu d'un PID.
 En partant de l'équation différentielle
 [[Fichier:EqPID.png|500px]]
 On applique la transformée de Laplace (dérivée => multiplication par ''s'' ; intégrale => division par ''s'') :
 [[Fichier:eqFxTransfertPID.png|130]]
 Le terme dérivatif étant très sensible au bruit, on lui applique généralement un filtre passe bas (''w0/(w0+s)'') :
 [[Fichier:eqFxTransfertPIDetPB.png|130]]
* Approximation de la fonction de transfert pour obtenir un filtre numérique
** ''backward euler''
** et transformée bilinéaire

* Implémentation du Filtre : classe <code>FilterController</code>
* Application sur l'asservissement d'altitude d'un drone

Cours:Elen4 TNS

2026-05-30T08:13:13Z

Fredmn : /* Travaux Pratiques */

<center>
'''<big>S4 - ESE - Traitement numérique du signal</big>'''
</center>

== Description générale ==

=== Contenu (Programme National) ===

Filtrage numérique :
* Équation de récurrence, opérations élémentaires, fonction de transfert en Z, passage à un programme informatique;
* Filtre numérique : ﬁltres récursif et non récursif, réponses temporelles (impulsionnelle, indicielle, signal quelconque), réponse fréquentielle, stabilité;
* Synthèse de ﬁltres numériques simples (approximation d’Euler);
* Utilisation d’outils de synthèse des ﬁltres numériques RIF et RII (Matlab, Labview, GNU radio...) et comparaison des performances des ﬁltres RIF et RII;
* Présentation des différentes structures des ﬁltres numériques (direct, cascade, parallèle);
* Implantation d’un traitement numérique sur cible : ﬁltrage numérique simple, asservissement numérique simple (robot mobile, drone...), traitement de données.

=== Volumes horaire ===

* CM : 4 séances d'1,5h
* TD : 6 séances d'1,5h + une évaluation d'1,5h
* TP : 6 séances de 3h + une évaluation de 2h

=== Évaluations ===

* une évaluation sur table (derniere séance de CM/TD - 1,5h)
* une évaluation pratique (dernière séance de TP - 2h)

== Cours Magistraux ==

Contenu :
* Signaux et systèmes numériques
* Filtres numériques
* Quelques filtres RIF
* Synthèse de filtres numériques
* PID numérique
* Élements sur le traitement des images numériques
* Élements sur le temps-fréquence

 
Documents :
* [[Media:TNS-Support.pdf|Support de cours en pdf]]
* [[Media:TNS-diapos.pdf|Diapositives de cours en pdf]]

== Travaux Dirigés ==

Textes en pdf :

* [[Media:TNS-td1.FxTransfert.pdf|TD1 : Fonctions de transfert]]
* [[Media:TNS-td2.Stabilité.pdf|TD2 : Causabilité et stabilité]]
* [[Media:TNS-td3.RepFreq.pdf|TD3 : Réponses fréquentielles]]
* [[Media:TNS-td4.Facteurs1et2.pdf|TD4 : Facteurs du premier et du second ordre]]
* [[Media:TNS-td5-Structures.pdf|TD5 : Structures de réalisation]]
* [[Media:TNS-td6-ConceptionFiltresRII.pdf|TD6 : Conception de filtres récursifs]]
* Évaluation

== Travaux Pratiques ==

Les TP utiliseront :
* Gnuradio (cf premier TP)
* Python, que nous utiliserons en installation locale avec [https://pixi.prefix.dev/ Pixi], en suivant ce guide rapide : [[Cours:Elen4_TNS#Travail avec Python et Pixi|Travail avec Python et Pixi]]

 
Liste des TP :
* [[Cours:Elen4_TNS_TP_Gnuradio|TP1 - Fondamentaux Gnuradio]]
* [[Cours:Elen4_TNS_TP_FxTransfertStabilité|TP2 - Fonction de transfert et stabilité]]
* [[Cours:Elen4_TNS_TP_Implementations|TP3 - Implémentations de filtres]]
* [[Cours:Elen4_TNS_TP_TraitImage|TP4 - Traitements d'images numériques]]
* [[Cours:Elen4_TNS_TP_TraitAudioEtDemodulation| TP5 - Traitements audio et démodulation]]
* [[Cours:Elen4_TNS_TP_ TpsReel |TP6 - Temps réel : bloc Gnuradio en Python / démodulation / PID Numérique]]
* Évaluation

== Évaluation de Travaux Pratiques ==

Énoncés :
* [[Cours:Elen4_TNS_TP_eval1|Sujet n°1]]

Documents autorisés :
* accès au wiki
* documents de cours
* notes personnelles

== Travail avec Python et Pixi ==

=== Gestionnaire de projets Pixi ===

[https://pixi.prefix.dev/ Pixi] est un gestionnaire de projets Python permettant une reproductibilité grace une installation purement locale à l'utilisateur (pas d'utilisation d'éléments au niveau système). Dans le dossier du projet, on trouve principalement :
* un fichier <code>pixi.toml</code> décrivant les dépendances du projet (souvent de façon souple)
* les fichiers du projets
* un dossier <code>.pixi</code> contenant les binaires Python et les dépendances nécessaires, ainsi qu'un fichier </code>pixi.lock</code> contenant description complète et déterministe de l'environnement installé.

Voici un guide :
# Installer pixi, en suivant l'indication décrite dans https://pixi.prefix.dev/latest/installation/ ''Note : l'installation est locale à l'utilisateur, elle ne sera nécessaire qu'une seule fois pour le semestre'' 

# Dans un terminal, instancier le projet (voir [https://pixi.prefix.dev/latest/first_workspace/ ici]) <source>
> pixi init nomduprojet
</source>
# Vvous positionner dans ce projet <source>
> cd nomduprojet
</source>
# Ajouter les dépendances nécessaire pour ce module <source>
> pixi add numpy scipy matplotlib
</source> ''Incidemment, ces dépendances nécessitent python qui sera installé automatiquement (à l'aide du dépot conda). Vous pouvez afficher le fichier pixi.toml pour observer ces dépendances.''
# Et ajouter les dépendances nécessaire pour travailler avec [https://jupyter.org/ Jupyter] <source>
> pixi add jupyterlab pixi-kernel
</source>
# Travailler avec le workspace ainsi installé :
## en lançant l'interpréteur python, <code> pixi run python</code>
## ou en executant un fichier python, <code> pixi run python monscript.py</code>
## ou en lançant un serveur jupyter, <code> pixi run jupyter lab</code>

'''Important''' :
* Il n'est normalement pas nécessaire d'éditer le fichier <code>pixi.toml</code>
* Il n'est '''jamais''' nécessaire d'éditer le fichier <code>pixi.lock</code>
* Pour distribuer votre projet, seul le fichier <code>pixi.toml</code> et les fichiers sources sont utiles.

=== Packages Python ===

* [https://numpy.org/ Numpy] pour la manipulation des tableaux de valeurs (ie les signaux)
* [https://scipy.org/ Scipy], en particulier [https://docs.scipy.org/doc/scipy/reference/signal.html le package Signal] pour les traitements et les filtrages,
* [https://matplotlib.org/ Matplotlib] pour les graphes

Cours:Elen4 TNS TP TpsReel

2026-05-30T08:12:52Z

Fredmn :

[[Cours:Elen4_TNS|{{Rouge|'''Retour à la page du cours'''}}]]

<center>
'''<big>TP6 : Temps réel - Bloc Gnuradio en Python / démodulation / PID Numérique</big>'''
</center>

Le but de ce TP est double :
* réaliser des implémentations temps réel de filtre IIR en créant un bloc Gnuradio qui execute un traitement codé en Python
* et étudier l'implémentation d'un PID numérique sous forme d'un filtre IIR.

=== Codage de bloc Gnuradio en Python ===

'''EN COURS DE RÉÉCRITURE (C++ vers Python)'''

Ce guide est inspirée du guide [https://wiki.gnuradio.org/index.php?title=Creating_C%2B%2B_OOT_with_gr-modtool Creating an OOT (C++ block example)] en l'adaptant pour nos besoins :

Nous allons créer un simple bloc qui recopie son entrée (en <code>float</code>) sur sa sortie. Donc le filtre caractérisé par ''y(n)'' = ''x(n)'' ou encore ''H(z)''=1. Il s'agit donc d'une sorte de filtre passe-tout.

'''Suivez bien toutes les étapes, sans aller trop rapidement'''

* Vous pourrez utiliser <code>gedit</code> pour éditer les divers fichiers.

==== Création d'un module externe ====

Dans les lignes qui suivent, le <code>$</code> indique que l'on saisi une commande dans un terminal. Le <code>$</code> n'est pas à saisir.

* Ouvrez un terminal et placez-vous à la racine de votre dossier personnel :
<source>
$ cd $HOME
</source>
* Créez un dossier de travail dédié à gnuradio et déplacez-vous à l'intérieur :
<source>
$ mkdir gnuradio
$ cd gnuradio
</source>
* GNU Radio est livré avec gr_modtool, un utilitaire qui permet de créer des modules externes (OOT). Créons un module <code>monModule</code>
<source>
$ gr_modtool newmod monModule
</source>
* Le dossier <code>gr-monModule</code> est créé et contient tout le code squelette d'un module OOT, mais il n'a pas encore de blocs. Déplacez-vous dans <code>gr-monModule</code> :
<source>
$ cd gr-monModule
</source>
* Vous pouvez afficher le contenu de ce dossier par
<source>
$ ls
</source>

==== Création d'un bloc dans ce module ====

* Ajoutez un nouveau bloc nommé <code>passetout</code> :
<source>
$ gr_modtool add passetout
</source>
* Quelques questions permettent alors de spécifier le type de bloc
<source>
GNU Radio module name identified: passetout
('sink', 'source', 'sync', 'decimator', 'interpolator', 'general', 'tagged_stream', 'hier', 'noblock')
</source>
Saisissez <code>sync</code> comme type de bloc, car le bloc que nous écrivons produira le même nombre d'échantillons en sortie que le nombre d'échantillons consommés depuis l'entrée.
<source>
Enter block type: sync
</source>
* Spécifiez <code>cpp</code> comme langage :
<source>
Language (python/cpp): cpp
Language: C++
Block/code identifier: passetout
</source>
* Spécifiez un nom pour le copyright :
<source>
Please specify the copyright holder: Bibi
</source>
* Il est possible de spécifier des paramètres d'entrée qui peuvent permettre de régler le fonctionnement du bloc. Ce ne sera pas notre cas, ne rien saisir sur cette question :
<source>
Enter valid argument list, including default arguments:
</source>
* De même, on ne donnera pas de code permettant de tester le bon fonctionnement :
<source>
Add Python QA code? [Y/n] n
Add C++ QA code? [Y/n] n
</source>
* Plusieurs fichers sont alors crées :
<source>
Adding file 'lib/passetout_impl.h'...
Adding file 'lib/passetout_impl.cc'...
Adding file 'include/gnuradio/monModule/passetout.h'...
Adding file 'python/monModule/bindings/docstrings/passetout_pydoc_template.h'...
Adding file 'python/monModule/bindings/passetout_python.cc'...
Adding file 'grc/monModule_passetout.block.yml'...
Editing grc/CMakeLists.txt...
</source>

Quelques indications :
* le fichier <code>passetout_impl.h</code> contient l'entête de la classe de notre bloc
* le fichier <code>passetout_impl.cc</code> contient l'implémentation de la classe de notre bloc
* le fichier <code>monModule_passetout.block.yml</code> va contenir des informations faisant le lien entre notre code c++ et le code python utilisé en interne par Gnuradio
* Le tout sera compilé par un <code>Makefile</code> généré par <code>cmake</code>.

==== Fichier <code>passetout_impl.h</code> ====

Le code utile généré est le suivant :
<source lang=cpp>
class passetout_impl : public passetout
{
private:
// Nothing to declare in this block.

public:
passetout_impl();
~passetout_impl();

// Where all the action really happens
int work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items);
};
</source>

Pour se réveiller les neurones sur la POO, qu'est-ce que sont
* <code>passetout_impl()</code>,
* <code>~passetout_impl()</code>,
* <code>private</code>, <code>public</code> ?

Le travail sera réalisé dans la méthode <code>work()</code>, mais nous n'avons pas de modification à apporter dans les déclarations par défaut.

==== Fichier <code>passetout_impl.cc</code> ====

Le code utile généré est le suivant :

{{boîte déroulante/début|titre=passetout_impl.cc}}
<source lang=cpp>
namespace monModule {

#pragma message("set the following appropriately and remove this warning")
using input_type = float;
#pragma message("set the following appropriately and remove this warning")
using output_type = float;
passetout::sptr passetout::make() { return gnuradio::make_block_sptr<passetout_impl>(); }

/*
* The private constructor
*/
passetout_impl::passetout_impl()
: gr::sync_block("passetout",
gr::io_signature::make(
1 /* min inputs */, 1 /* max inputs */, sizeof(input_type)),
gr::io_signature::make(
1 /* min outputs */, 1 /*max outputs */, sizeof(output_type)))
{
}

/*
* Our virtual destructor.
*/
passetout_impl::~passetout_impl() {}

int passetout_impl::work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items)
{
auto in = static_cast<const input_type*>(input_items[0]);
auto out = static_cast<output_type*>(output_items[0]);

#pragma message("Implement the signal processing in your block and remove this warning")
// Do <+signal processing+>

// Tell runtime system how many output items we produced.
return noutput_items;
}

} /* namespace monModule */
</source>
{{boîte déroulante/fin}}

Détaillons :
<source lang=cpp>
#pragma message("set the following appropriately and remove this warning")
using input_type = float;
#pragma message("set the following appropriately and remove this warning")
using output_type = float;
</source>
{{Todos| On spécifie ici le type des données d'entrée et de sortie. Pas de modification à apporter, il suffit de supprimer les deux <code>#pragma</code>}}

<source lang=cpp>
passetout_impl::passetout_impl()
: gr::sync_block("passetout",
gr::io_signature::make(
1 /* min inputs */, 1 /* max inputs */, sizeof(input_type)),
gr::io_signature::make(
1 /* min outputs */, 1 /*max outputs */, sizeof(output_type)))
{
}
</source>

{{Todos| On spécifie ici le nombre d'entrées (1) et le nombre de sorties (1). Pas de modification non plus.}}

{{Todos| Expliquez la syntaxe <code>passetout_impl::passetout_impl() : gr::sync_block(...)"</code> }}

<source lang=cpp>
int passetout_impl::work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items)
{
auto in = static_cast<const input_type*>(input_items[0]);
auto out = static_cast<output_type*>(output_items[0]);

#pragma message("Implement the signal processing in your block and remove this warning")
// Do <+signal processing+>

// Tell runtime system how many output items we produced.
return noutput_items;
}
</source>
Cette méthode <code>work()</code> implémente véritablement le filtrage.
* Les tableaux <code>in</code> et <code>out</code> contiennent respectivement les données en entrée et les données en sortie. Il faut donc calculer <code>out</code> en fonction de <code>in</code>
* Les données d'entrée arrivent par paquets dans un buffer. La variable <code>noutput_items</code> contient le nombre de données disponibles en entrées.
* à la fin de la méthode, on renvoie le nombre de données en sortie que l'on a calculé (entre 1 et <code>noutput_items</code>). Les données d'entrées éventuellement non consommées seront conservées dans le buffer pour le prochain appel de <code>work()</code>
{{Todos| On souhaite ici seulement recopier l'entrée sur la sortie, donc }}
# Enlever la ligne <code>#pragma</code>
# ajouter le code <code> out[0] = in[0];</code> (on recopie le premier échantillon disponible en entrée)
# changer <code>return noutput_items;</code> en <code>return 1;</code> (un seul échantillon a été consommé).

==== Fichier <code>monModule_passetout.block.yml</code> ====

Ce fichier au format YAML (''yet another markup language'') fait le lien entre le code c++ et le code python utilisé en interne par GnuRadio.

{{boîte déroulante/début|titre=monModule_passetout.block.yml}}
<source lang=yaml>
id: monModule_passetout
label: passetout
category: '[monModule]'

templates:
imports: from gnuradio import monModule
make: monModule.passetout()

# Make one 'parameters' list entry for every parameter you want settable from the GUI.
# Keys include:
# * id (makes the value accessible as keyname, e.g. in the make entry)
# * label (label shown in the GUI)
# * dtype (e.g. int, float, complex, byte, short, xxx_vector, ...)
# * default
parameters:
- id: parametername_replace_me
label: FIX ME:
dtype: string
default: You need to fill in your grc/monModule_passetout.block.yaml
#- id: ...
# label: ...
# dtype: ...

# Make one 'inputs' list entry per input and one 'outputs' list entry per output.
# Keys include:
# * label (an identifier for the GUI)
# * domain (optional - stream or message. Default is stream)
# * dtype (e.g. int, float, complex, byte, short, xxx_vector, ...)
# * vlen (optional - data stream vector length. Default is 1)
# * optional (optional - set to 1 for optional inputs. Default is 0)
inputs:
#- label: ...
# domain: ...
# dtype: ...
# vlen: ...
# optional: ...

outputs:
#- label: ...
# domain: ...
# dtype: ...
# vlen: ...
# optional: ...

# 'file_format' specifies the version of the GRC yml format used in the file
# and should usually not be changed.
file_format: 1
</source>
{{boîte déroulante/fin}}

{{Todos| Mettre à jour la section <code>parameters</code> (pas de paramètres, on commente) :}}

<source lang=yaml>
#parameters:
#- id: parametername_replace_me
# label: FIX ME:
# dtype: string
# default: You need to fill in your grc/customModule_testMod.block.yaml
</source>

{{Todos| Mettre à jour la section <code>inputs</code> :}}

<source lang=yaml>
inputs:
- label: in
domain: stream
dtype: float
</source>

{{Todos| Mettre à jour la section <code>output</code> :}}

<source lang=yaml>
outputs:
- label: out
domain: stream
dtype: float
</source>

==== Compilation et installation ====

Voici les étapes :
<source lang=bash>
$ cd CHEMIN-DE-VOTRE-DOSSIER/gr-monModule
$ mkdir build
$ cd build
$ cmake ..
$ make
$ make install
</source>

* <code>cmake ..</code> lance la création des fichiers <code>Makefile</code> qui permettent la compilation et l'installation
* <code>make</code> lance la compilation
* <code>make install</code> lance l'installation (copie des fichiers dans les dossiers gnuradio)

{{Todos| Exécuter chacune de ces lignes, en contrôlant l'absence d'erreur. Dans le cas contraire, contrôler les fichiers <code>.h</code>, <code>.cc</code> et <code>.yaml</code>}}

{{Todos| '''Après ces étapes, et avant de lancer gnuRadio, appeler l'enseignant qui va mettre à jours les bibliothèques partagées.'''}}. Sinon tenter :
<source>
$ export LD_LIBRARY_PATH=/usr/local/lib/x86_64-linux-gnu:$LD_LIBRARY_PATH
$ gnuradio-companion &
</source>

==== Utilisation du bloc et test ====

* Dans Gnuradio, rafraichir la liste des bloc (bouton ''reload'')
* le bloc <code>passetout</code> doit être présent dans la section <code>monModule</code>
* Tester le bon fonctionnement de ce bloc en lui envoyant une sinusoïde que vous devez observer identique à la sortie du bloc. Vérifier avec des graphes.

==== Application : démodulation ====

En reprenant le signal modulé en amplitude et la fonction de transfert du filtre passe-bas du TP précédent :

* Obtenir l'équation aux différence du filtre, ''ie'' écrire ''y(n)='' en fonction de ''x(n)'', ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.
* Créer un nouveau bloc C++ (similaire au passe-tout précédent) dans le module <code>monModule</code> :
** de type <code>sync</code>
** une entrée en <code>float</code>
** une sortie en <code>float</code>
* Écrire le code permettant d'obtenir ''y(n)'' dans la méthode <code>work()</code> :
** ''x(n)'' est donné par <code>in0[0]</code>
** il sera nécessaire d'affecter <code>out0[0]</code> pour produire ''y(n)''.
** il sera nécessaire de stocker dans des '''attributs''' les valeurs de <code>in[0]</code> afin de disposer de ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.
** On rappelle que les attributs doivent être déclarées dans le fichier <code>.h</code> et initialisés dans le constructeur de la classe.

{{Todos| Réaliser cette implémentation du passe-bas et contrôler que la démodulation est identique à celle obtenue au TP précédent}}

{{Todos| Modifier votre code pour implémenter le filtre complet de démodulation}}

=== Approximation de PID par filtre numérique linéaire ===

==== Rappels PID ====

* Principe

[[Fichier:PIDprincipe.png|400px]]

[[Fichier:PIDdetail.png|400px]]

* Définition mathématique, la sortie du controleur PID ''u(t)'' est donnée par:

[[Fichier:EqPID.png|400px]]

==== PID numérique "classique" ====

On considère que le temps est discrétisé : ''t = n.dt'' où ''dt'' est l'intervalle de temps entre deux valeurs.

* En approximant grossièrement l'intégrale et la dérivée [[Fichier:PIDderivative.png|400px]] [[Fichier:PIDintegral.png|400px]]
** La dérivée est calculée par ''D = (e(n)-e(n-1))/dt''
** L'intégrale est approximée en cumulant progressivement : ''I = I + e(n).dt''

* Notebook exemple : asservissement de température
** ''Ki = Kd = 0'' => chercher le meilleur ''Kp'' => erreur de régime permanent
** ''Kd = 0'' => l'introduction du terme integral permet de corriger cette erreur de régime permanent
** Le terme dérivatif n'est pas nécessaire dans cet exemple car la température ne dépend que de la commande ''u(t)''.

==== PID numérique par approximation d'un filtre continu ====

* Cherchons la fonction de transfert du filtre continu d'un PID.
 En partant de l'équation différentielle
 [[Fichier:EqPID.png|500px]]
 On applique la transformée de Laplace (dérivée => multiplication par ''s'' ; intégrale => division par ''s'') :
 [[Fichier:eqFxTransfertPID.png|130]]
 Le terme dérivatif étant très sensible au bruit, on lui applique généralement un filtre passe bas (''w0/(w0+s)'') :
 [[Fichier:eqFxTransfertPIDetPB.png|130]]
* Approximation de la fonction de transfert pour obtenir un filtre numérique
** ''backward euler''
** et transformée bilinéaire

* Implémentation du Filtre : classe <code>FilterController</code>
* Application sur l'asservissement d'altitude d'un drone

Cours:Elen4 TNS TP TpsReel

2026-05-30T06:10:48Z

Fredmn : /* PID numérique par approximation d'un filtre continu */

[[Cours:Elen4_TNS|{{Rouge|'''Retour à la page du cours'''}}]]

<center>
'''<big>TP6 : Temps réel : Codage d'un bloc en Python / démodulation / PID Numérique</big>'''
</center>

Le but de ce TP est double :
* réaliser des implémentations temps réel de filtre IIR en créant un bloc Gnuradio qui execute un traitement codé en Python
* et étudier l'implémentation d'un PID numérique sous forme d'un filtre IIR.

=== Codage de bloc Gnuradio en Python ===

'''EN COURS DE RÉÉCRITURE (C++ vers Python)'''

Ce guide est inspirée du guide [https://wiki.gnuradio.org/index.php?title=Creating_C%2B%2B_OOT_with_gr-modtool Creating an OOT (C++ block example)] en l'adaptant pour nos besoins :

Nous allons créer un simple bloc qui recopie son entrée (en <code>float</code>) sur sa sortie. Donc le filtre caractérisé par ''y(n)'' = ''x(n)'' ou encore ''H(z)''=1. Il s'agit donc d'une sorte de filtre passe-tout.

'''Suivez bien toutes les étapes, sans aller trop rapidement'''

* Vous pourrez utiliser <code>gedit</code> pour éditer les divers fichiers.

==== Création d'un module externe ====

Dans les lignes qui suivent, le <code>$</code> indique que l'on saisi une commande dans un terminal. Le <code>$</code> n'est pas à saisir.

* Ouvrez un terminal et placez-vous à la racine de votre dossier personnel :
<source>
$ cd $HOME
</source>
* Créez un dossier de travail dédié à gnuradio et déplacez-vous à l'intérieur :
<source>
$ mkdir gnuradio
$ cd gnuradio
</source>
* GNU Radio est livré avec gr_modtool, un utilitaire qui permet de créer des modules externes (OOT). Créons un module <code>monModule</code>
<source>
$ gr_modtool newmod monModule
</source>
* Le dossier <code>gr-monModule</code> est créé et contient tout le code squelette d'un module OOT, mais il n'a pas encore de blocs. Déplacez-vous dans <code>gr-monModule</code> :
<source>
$ cd gr-monModule
</source>
* Vous pouvez afficher le contenu de ce dossier par
<source>
$ ls
</source>

==== Création d'un bloc dans ce module ====

* Ajoutez un nouveau bloc nommé <code>passetout</code> :
<source>
$ gr_modtool add passetout
</source>
* Quelques questions permettent alors de spécifier le type de bloc
<source>
GNU Radio module name identified: passetout
('sink', 'source', 'sync', 'decimator', 'interpolator', 'general', 'tagged_stream', 'hier', 'noblock')
</source>
Saisissez <code>sync</code> comme type de bloc, car le bloc que nous écrivons produira le même nombre d'échantillons en sortie que le nombre d'échantillons consommés depuis l'entrée.
<source>
Enter block type: sync
</source>
* Spécifiez <code>cpp</code> comme langage :
<source>
Language (python/cpp): cpp
Language: C++
Block/code identifier: passetout
</source>
* Spécifiez un nom pour le copyright :
<source>
Please specify the copyright holder: Bibi
</source>
* Il est possible de spécifier des paramètres d'entrée qui peuvent permettre de régler le fonctionnement du bloc. Ce ne sera pas notre cas, ne rien saisir sur cette question :
<source>
Enter valid argument list, including default arguments:
</source>
* De même, on ne donnera pas de code permettant de tester le bon fonctionnement :
<source>
Add Python QA code? [Y/n] n
Add C++ QA code? [Y/n] n
</source>
* Plusieurs fichers sont alors crées :
<source>
Adding file 'lib/passetout_impl.h'...
Adding file 'lib/passetout_impl.cc'...
Adding file 'include/gnuradio/monModule/passetout.h'...
Adding file 'python/monModule/bindings/docstrings/passetout_pydoc_template.h'...
Adding file 'python/monModule/bindings/passetout_python.cc'...
Adding file 'grc/monModule_passetout.block.yml'...
Editing grc/CMakeLists.txt...
</source>

Quelques indications :
* le fichier <code>passetout_impl.h</code> contient l'entête de la classe de notre bloc
* le fichier <code>passetout_impl.cc</code> contient l'implémentation de la classe de notre bloc
* le fichier <code>monModule_passetout.block.yml</code> va contenir des informations faisant le lien entre notre code c++ et le code python utilisé en interne par Gnuradio
* Le tout sera compilé par un <code>Makefile</code> généré par <code>cmake</code>.

==== Fichier <code>passetout_impl.h</code> ====

Le code utile généré est le suivant :
<source lang=cpp>
class passetout_impl : public passetout
{
private:
// Nothing to declare in this block.

public:
passetout_impl();
~passetout_impl();

// Where all the action really happens
int work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items);
};
</source>

Pour se réveiller les neurones sur la POO, qu'est-ce que sont
* <code>passetout_impl()</code>,
* <code>~passetout_impl()</code>,
* <code>private</code>, <code>public</code> ?

Le travail sera réalisé dans la méthode <code>work()</code>, mais nous n'avons pas de modification à apporter dans les déclarations par défaut.

==== Fichier <code>passetout_impl.cc</code> ====

Le code utile généré est le suivant :

{{boîte déroulante/début|titre=passetout_impl.cc}}
<source lang=cpp>
namespace monModule {

#pragma message("set the following appropriately and remove this warning")
using input_type = float;
#pragma message("set the following appropriately and remove this warning")
using output_type = float;
passetout::sptr passetout::make() { return gnuradio::make_block_sptr<passetout_impl>(); }

/*
* The private constructor
*/
passetout_impl::passetout_impl()
: gr::sync_block("passetout",
gr::io_signature::make(
1 /* min inputs */, 1 /* max inputs */, sizeof(input_type)),
gr::io_signature::make(
1 /* min outputs */, 1 /*max outputs */, sizeof(output_type)))
{
}

/*
* Our virtual destructor.
*/
passetout_impl::~passetout_impl() {}

int passetout_impl::work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items)
{
auto in = static_cast<const input_type*>(input_items[0]);
auto out = static_cast<output_type*>(output_items[0]);

#pragma message("Implement the signal processing in your block and remove this warning")
// Do <+signal processing+>

// Tell runtime system how many output items we produced.
return noutput_items;
}

} /* namespace monModule */
</source>
{{boîte déroulante/fin}}

Détaillons :
<source lang=cpp>
#pragma message("set the following appropriately and remove this warning")
using input_type = float;
#pragma message("set the following appropriately and remove this warning")
using output_type = float;
</source>
{{Todos| On spécifie ici le type des données d'entrée et de sortie. Pas de modification à apporter, il suffit de supprimer les deux <code>#pragma</code>}}

<source lang=cpp>
passetout_impl::passetout_impl()
: gr::sync_block("passetout",
gr::io_signature::make(
1 /* min inputs */, 1 /* max inputs */, sizeof(input_type)),
gr::io_signature::make(
1 /* min outputs */, 1 /*max outputs */, sizeof(output_type)))
{
}
</source>

{{Todos| On spécifie ici le nombre d'entrées (1) et le nombre de sorties (1). Pas de modification non plus.}}

{{Todos| Expliquez la syntaxe <code>passetout_impl::passetout_impl() : gr::sync_block(...)"</code> }}

<source lang=cpp>
int passetout_impl::work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items)
{
auto in = static_cast<const input_type*>(input_items[0]);
auto out = static_cast<output_type*>(output_items[0]);

#pragma message("Implement the signal processing in your block and remove this warning")
// Do <+signal processing+>

// Tell runtime system how many output items we produced.
return noutput_items;
}
</source>
Cette méthode <code>work()</code> implémente véritablement le filtrage.
* Les tableaux <code>in</code> et <code>out</code> contiennent respectivement les données en entrée et les données en sortie. Il faut donc calculer <code>out</code> en fonction de <code>in</code>
* Les données d'entrée arrivent par paquets dans un buffer. La variable <code>noutput_items</code> contient le nombre de données disponibles en entrées.
* à la fin de la méthode, on renvoie le nombre de données en sortie que l'on a calculé (entre 1 et <code>noutput_items</code>). Les données d'entrées éventuellement non consommées seront conservées dans le buffer pour le prochain appel de <code>work()</code>
{{Todos| On souhaite ici seulement recopier l'entrée sur la sortie, donc }}
# Enlever la ligne <code>#pragma</code>
# ajouter le code <code> out[0] = in[0];</code> (on recopie le premier échantillon disponible en entrée)
# changer <code>return noutput_items;</code> en <code>return 1;</code> (un seul échantillon a été consommé).

==== Fichier <code>monModule_passetout.block.yml</code> ====

Ce fichier au format YAML (''yet another markup language'') fait le lien entre le code c++ et le code python utilisé en interne par GnuRadio.

{{boîte déroulante/début|titre=monModule_passetout.block.yml}}
<source lang=yaml>
id: monModule_passetout
label: passetout
category: '[monModule]'

templates:
imports: from gnuradio import monModule
make: monModule.passetout()

# Make one 'parameters' list entry for every parameter you want settable from the GUI.
# Keys include:
# * id (makes the value accessible as keyname, e.g. in the make entry)
# * label (label shown in the GUI)
# * dtype (e.g. int, float, complex, byte, short, xxx_vector, ...)
# * default
parameters:
- id: parametername_replace_me
label: FIX ME:
dtype: string
default: You need to fill in your grc/monModule_passetout.block.yaml
#- id: ...
# label: ...
# dtype: ...

# Make one 'inputs' list entry per input and one 'outputs' list entry per output.
# Keys include:
# * label (an identifier for the GUI)
# * domain (optional - stream or message. Default is stream)
# * dtype (e.g. int, float, complex, byte, short, xxx_vector, ...)
# * vlen (optional - data stream vector length. Default is 1)
# * optional (optional - set to 1 for optional inputs. Default is 0)
inputs:
#- label: ...
# domain: ...
# dtype: ...
# vlen: ...
# optional: ...

outputs:
#- label: ...
# domain: ...
# dtype: ...
# vlen: ...
# optional: ...

# 'file_format' specifies the version of the GRC yml format used in the file
# and should usually not be changed.
file_format: 1
</source>
{{boîte déroulante/fin}}

{{Todos| Mettre à jour la section <code>parameters</code> (pas de paramètres, on commente) :}}

<source lang=yaml>
#parameters:
#- id: parametername_replace_me
# label: FIX ME:
# dtype: string
# default: You need to fill in your grc/customModule_testMod.block.yaml
</source>

{{Todos| Mettre à jour la section <code>inputs</code> :}}

<source lang=yaml>
inputs:
- label: in
domain: stream
dtype: float
</source>

{{Todos| Mettre à jour la section <code>output</code> :}}

<source lang=yaml>
outputs:
- label: out
domain: stream
dtype: float
</source>

==== Compilation et installation ====

Voici les étapes :
<source lang=bash>
$ cd CHEMIN-DE-VOTRE-DOSSIER/gr-monModule
$ mkdir build
$ cd build
$ cmake ..
$ make
$ make install
</source>

* <code>cmake ..</code> lance la création des fichiers <code>Makefile</code> qui permettent la compilation et l'installation
* <code>make</code> lance la compilation
* <code>make install</code> lance l'installation (copie des fichiers dans les dossiers gnuradio)

{{Todos| Exécuter chacune de ces lignes, en contrôlant l'absence d'erreur. Dans le cas contraire, contrôler les fichiers <code>.h</code>, <code>.cc</code> et <code>.yaml</code>}}

{{Todos| '''Après ces étapes, et avant de lancer gnuRadio, appeler l'enseignant qui va mettre à jours les bibliothèques partagées.'''}}. Sinon tenter :
<source>
$ export LD_LIBRARY_PATH=/usr/local/lib/x86_64-linux-gnu:$LD_LIBRARY_PATH
$ gnuradio-companion &
</source>

==== Utilisation du bloc et test ====

* Dans Gnuradio, rafraichir la liste des bloc (bouton ''reload'')
* le bloc <code>passetout</code> doit être présent dans la section <code>monModule</code>
* Tester le bon fonctionnement de ce bloc en lui envoyant une sinusoïde que vous devez observer identique à la sortie du bloc. Vérifier avec des graphes.

==== Application : démodulation ====

En reprenant le signal modulé en amplitude et la fonction de transfert du filtre passe-bas du TP précédent :

* Obtenir l'équation aux différence du filtre, ''ie'' écrire ''y(n)='' en fonction de ''x(n)'', ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.
* Créer un nouveau bloc C++ (similaire au passe-tout précédent) dans le module <code>monModule</code> :
** de type <code>sync</code>
** une entrée en <code>float</code>
** une sortie en <code>float</code>
* Écrire le code permettant d'obtenir ''y(n)'' dans la méthode <code>work()</code> :
** ''x(n)'' est donné par <code>in0[0]</code>
** il sera nécessaire d'affecter <code>out0[0]</code> pour produire ''y(n)''.
** il sera nécessaire de stocker dans des '''attributs''' les valeurs de <code>in[0]</code> afin de disposer de ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.
** On rappelle que les attributs doivent être déclarées dans le fichier <code>.h</code> et initialisés dans le constructeur de la classe.

{{Todos| Réaliser cette implémentation du passe-bas et contrôler que la démodulation est identique à celle obtenue au TP précédent}}

{{Todos| Modifier votre code pour implémenter le filtre complet de démodulation}}

=== Approximation de PID par filtre numérique linéaire ===

==== Rappels PID ====

* Principe

[[Fichier:PIDprincipe.png|400px]]

[[Fichier:PIDdetail.png|400px]]

* Définition mathématique, la sortie du controleur PID ''u(t)'' est donnée par:

[[Fichier:EqPID.png|400px]]

==== PID numérique "classique" ====

On considère que le temps est discrétisé : ''t = n.dt'' où ''dt'' est l'intervalle de temps entre deux valeurs.

* En approximant grossièrement l'intégrale et la dérivée [[Fichier:PIDderivative.png|400px]] [[Fichier:PIDintegral.png|400px]]
** La dérivée est calculée par ''D = (e(n)-e(n-1))/dt''
** L'intégrale est approximée en cumulant progressivement : ''I = I + e(n).dt''

* Notebook exemple : asservissement de température
** ''Ki = Kd = 0'' => chercher le meilleur ''Kp'' => erreur de régime permanent
** ''Kd = 0'' => l'introduction du terme integral permet de corriger cette erreur de régime permanent
** Le terme dérivatif n'est pas nécessaire dans cet exemple car la température ne dépend que de la commande ''u(t)''.

==== PID numérique par approximation d'un filtre continu ====

* Cherchons la fonction de transfert du filtre continu d'un PID.
 En partant de l'équation différentielle
 [[Fichier:EqPID.png|500px]]
 On applique la transformée de Laplace (dérivée => multiplication par ''s'' ; intégrale => division par ''s'') :
 [[Fichier:eqFxTransfertPID.png|130]]
 Le terme dérivatif étant très sensible au bruit, on lui applique généralement un filtre passe bas (''w0/(w0+s)'') :
 [[Fichier:eqFxTransfertPIDetPB.png|130]]
* Approximation de la fonction de transfert pour obtenir un filtre numérique
** ''backward euler''
** et transformée bilinéaire

* Implémentation du Filtre : classe <code>FilterController</code>
* Application sur l'asservissement d'altitude d'un drone

Cours:Elen4 TNS TP TpsReel

2026-05-29T13:32:32Z

Fredmn : /* PID numérique par approximation d'un filtre continu */

[[Cours:Elen4_TNS|{{Rouge|'''Retour à la page du cours'''}}]]

<center>
'''<big>TP6 : Temps réel : Codage d'un bloc en Python / démodulation / PID Numérique</big>'''
</center>

Le but de ce TP est double :
* réaliser des implémentations temps réel de filtre IIR en créant un bloc Gnuradio qui execute un traitement codé en Python
* et étudier l'implémentation d'un PID numérique sous forme d'un filtre IIR.

=== Codage de bloc Gnuradio en Python ===

'''EN COURS DE RÉÉCRITURE (C++ vers Python)'''

Ce guide est inspirée du guide [https://wiki.gnuradio.org/index.php?title=Creating_C%2B%2B_OOT_with_gr-modtool Creating an OOT (C++ block example)] en l'adaptant pour nos besoins :

Nous allons créer un simple bloc qui recopie son entrée (en <code>float</code>) sur sa sortie. Donc le filtre caractérisé par ''y(n)'' = ''x(n)'' ou encore ''H(z)''=1. Il s'agit donc d'une sorte de filtre passe-tout.

'''Suivez bien toutes les étapes, sans aller trop rapidement'''

* Vous pourrez utiliser <code>gedit</code> pour éditer les divers fichiers.

==== Création d'un module externe ====

Dans les lignes qui suivent, le <code>$</code> indique que l'on saisi une commande dans un terminal. Le <code>$</code> n'est pas à saisir.

* Ouvrez un terminal et placez-vous à la racine de votre dossier personnel :
<source>
$ cd $HOME
</source>
* Créez un dossier de travail dédié à gnuradio et déplacez-vous à l'intérieur :
<source>
$ mkdir gnuradio
$ cd gnuradio
</source>
* GNU Radio est livré avec gr_modtool, un utilitaire qui permet de créer des modules externes (OOT). Créons un module <code>monModule</code>
<source>
$ gr_modtool newmod monModule
</source>
* Le dossier <code>gr-monModule</code> est créé et contient tout le code squelette d'un module OOT, mais il n'a pas encore de blocs. Déplacez-vous dans <code>gr-monModule</code> :
<source>
$ cd gr-monModule
</source>
* Vous pouvez afficher le contenu de ce dossier par
<source>
$ ls
</source>

==== Création d'un bloc dans ce module ====

* Ajoutez un nouveau bloc nommé <code>passetout</code> :
<source>
$ gr_modtool add passetout
</source>
* Quelques questions permettent alors de spécifier le type de bloc
<source>
GNU Radio module name identified: passetout
('sink', 'source', 'sync', 'decimator', 'interpolator', 'general', 'tagged_stream', 'hier', 'noblock')
</source>
Saisissez <code>sync</code> comme type de bloc, car le bloc que nous écrivons produira le même nombre d'échantillons en sortie que le nombre d'échantillons consommés depuis l'entrée.
<source>
Enter block type: sync
</source>
* Spécifiez <code>cpp</code> comme langage :
<source>
Language (python/cpp): cpp
Language: C++
Block/code identifier: passetout
</source>
* Spécifiez un nom pour le copyright :
<source>
Please specify the copyright holder: Bibi
</source>
* Il est possible de spécifier des paramètres d'entrée qui peuvent permettre de régler le fonctionnement du bloc. Ce ne sera pas notre cas, ne rien saisir sur cette question :
<source>
Enter valid argument list, including default arguments:
</source>
* De même, on ne donnera pas de code permettant de tester le bon fonctionnement :
<source>
Add Python QA code? [Y/n] n
Add C++ QA code? [Y/n] n
</source>
* Plusieurs fichers sont alors crées :
<source>
Adding file 'lib/passetout_impl.h'...
Adding file 'lib/passetout_impl.cc'...
Adding file 'include/gnuradio/monModule/passetout.h'...
Adding file 'python/monModule/bindings/docstrings/passetout_pydoc_template.h'...
Adding file 'python/monModule/bindings/passetout_python.cc'...
Adding file 'grc/monModule_passetout.block.yml'...
Editing grc/CMakeLists.txt...
</source>

Quelques indications :
* le fichier <code>passetout_impl.h</code> contient l'entête de la classe de notre bloc
* le fichier <code>passetout_impl.cc</code> contient l'implémentation de la classe de notre bloc
* le fichier <code>monModule_passetout.block.yml</code> va contenir des informations faisant le lien entre notre code c++ et le code python utilisé en interne par Gnuradio
* Le tout sera compilé par un <code>Makefile</code> généré par <code>cmake</code>.

==== Fichier <code>passetout_impl.h</code> ====

Le code utile généré est le suivant :
<source lang=cpp>
class passetout_impl : public passetout
{
private:
// Nothing to declare in this block.

public:
passetout_impl();
~passetout_impl();

// Where all the action really happens
int work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items);
};
</source>

Pour se réveiller les neurones sur la POO, qu'est-ce que sont
* <code>passetout_impl()</code>,
* <code>~passetout_impl()</code>,
* <code>private</code>, <code>public</code> ?

Le travail sera réalisé dans la méthode <code>work()</code>, mais nous n'avons pas de modification à apporter dans les déclarations par défaut.

==== Fichier <code>passetout_impl.cc</code> ====

Le code utile généré est le suivant :

{{boîte déroulante/début|titre=passetout_impl.cc}}
<source lang=cpp>
namespace monModule {

#pragma message("set the following appropriately and remove this warning")
using input_type = float;
#pragma message("set the following appropriately and remove this warning")
using output_type = float;
passetout::sptr passetout::make() { return gnuradio::make_block_sptr<passetout_impl>(); }

/*
* The private constructor
*/
passetout_impl::passetout_impl()
: gr::sync_block("passetout",
gr::io_signature::make(
1 /* min inputs */, 1 /* max inputs */, sizeof(input_type)),
gr::io_signature::make(
1 /* min outputs */, 1 /*max outputs */, sizeof(output_type)))
{
}

/*
* Our virtual destructor.
*/
passetout_impl::~passetout_impl() {}

int passetout_impl::work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items)
{
auto in = static_cast<const input_type*>(input_items[0]);
auto out = static_cast<output_type*>(output_items[0]);

#pragma message("Implement the signal processing in your block and remove this warning")
// Do <+signal processing+>

// Tell runtime system how many output items we produced.
return noutput_items;
}

} /* namespace monModule */
</source>
{{boîte déroulante/fin}}

Détaillons :
<source lang=cpp>
#pragma message("set the following appropriately and remove this warning")
using input_type = float;
#pragma message("set the following appropriately and remove this warning")
using output_type = float;
</source>
{{Todos| On spécifie ici le type des données d'entrée et de sortie. Pas de modification à apporter, il suffit de supprimer les deux <code>#pragma</code>}}

<source lang=cpp>
passetout_impl::passetout_impl()
: gr::sync_block("passetout",
gr::io_signature::make(
1 /* min inputs */, 1 /* max inputs */, sizeof(input_type)),
gr::io_signature::make(
1 /* min outputs */, 1 /*max outputs */, sizeof(output_type)))
{
}
</source>

{{Todos| On spécifie ici le nombre d'entrées (1) et le nombre de sorties (1). Pas de modification non plus.}}

{{Todos| Expliquez la syntaxe <code>passetout_impl::passetout_impl() : gr::sync_block(...)"</code> }}

<source lang=cpp>
int passetout_impl::work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items)
{
auto in = static_cast<const input_type*>(input_items[0]);
auto out = static_cast<output_type*>(output_items[0]);

#pragma message("Implement the signal processing in your block and remove this warning")
// Do <+signal processing+>

// Tell runtime system how many output items we produced.
return noutput_items;
}
</source>
Cette méthode <code>work()</code> implémente véritablement le filtrage.
* Les tableaux <code>in</code> et <code>out</code> contiennent respectivement les données en entrée et les données en sortie. Il faut donc calculer <code>out</code> en fonction de <code>in</code>
* Les données d'entrée arrivent par paquets dans un buffer. La variable <code>noutput_items</code> contient le nombre de données disponibles en entrées.
* à la fin de la méthode, on renvoie le nombre de données en sortie que l'on a calculé (entre 1 et <code>noutput_items</code>). Les données d'entrées éventuellement non consommées seront conservées dans le buffer pour le prochain appel de <code>work()</code>
{{Todos| On souhaite ici seulement recopier l'entrée sur la sortie, donc }}
# Enlever la ligne <code>#pragma</code>
# ajouter le code <code> out[0] = in[0];</code> (on recopie le premier échantillon disponible en entrée)
# changer <code>return noutput_items;</code> en <code>return 1;</code> (un seul échantillon a été consommé).

==== Fichier <code>monModule_passetout.block.yml</code> ====

Ce fichier au format YAML (''yet another markup language'') fait le lien entre le code c++ et le code python utilisé en interne par GnuRadio.

{{boîte déroulante/début|titre=monModule_passetout.block.yml}}
<source lang=yaml>
id: monModule_passetout
label: passetout
category: '[monModule]'

templates:
imports: from gnuradio import monModule
make: monModule.passetout()

# Make one 'parameters' list entry for every parameter you want settable from the GUI.
# Keys include:
# * id (makes the value accessible as keyname, e.g. in the make entry)
# * label (label shown in the GUI)
# * dtype (e.g. int, float, complex, byte, short, xxx_vector, ...)
# * default
parameters:
- id: parametername_replace_me
label: FIX ME:
dtype: string
default: You need to fill in your grc/monModule_passetout.block.yaml
#- id: ...
# label: ...
# dtype: ...

# Make one 'inputs' list entry per input and one 'outputs' list entry per output.
# Keys include:
# * label (an identifier for the GUI)
# * domain (optional - stream or message. Default is stream)
# * dtype (e.g. int, float, complex, byte, short, xxx_vector, ...)
# * vlen (optional - data stream vector length. Default is 1)
# * optional (optional - set to 1 for optional inputs. Default is 0)
inputs:
#- label: ...
# domain: ...
# dtype: ...
# vlen: ...
# optional: ...

outputs:
#- label: ...
# domain: ...
# dtype: ...
# vlen: ...
# optional: ...

# 'file_format' specifies the version of the GRC yml format used in the file
# and should usually not be changed.
file_format: 1
</source>
{{boîte déroulante/fin}}

{{Todos| Mettre à jour la section <code>parameters</code> (pas de paramètres, on commente) :}}

<source lang=yaml>
#parameters:
#- id: parametername_replace_me
# label: FIX ME:
# dtype: string
# default: You need to fill in your grc/customModule_testMod.block.yaml
</source>

{{Todos| Mettre à jour la section <code>inputs</code> :}}

<source lang=yaml>
inputs:
- label: in
domain: stream
dtype: float
</source>

{{Todos| Mettre à jour la section <code>output</code> :}}

<source lang=yaml>
outputs:
- label: out
domain: stream
dtype: float
</source>

==== Compilation et installation ====

Voici les étapes :
<source lang=bash>
$ cd CHEMIN-DE-VOTRE-DOSSIER/gr-monModule
$ mkdir build
$ cd build
$ cmake ..
$ make
$ make install
</source>

* <code>cmake ..</code> lance la création des fichiers <code>Makefile</code> qui permettent la compilation et l'installation
* <code>make</code> lance la compilation
* <code>make install</code> lance l'installation (copie des fichiers dans les dossiers gnuradio)

{{Todos| Exécuter chacune de ces lignes, en contrôlant l'absence d'erreur. Dans le cas contraire, contrôler les fichiers <code>.h</code>, <code>.cc</code> et <code>.yaml</code>}}

{{Todos| '''Après ces étapes, et avant de lancer gnuRadio, appeler l'enseignant qui va mettre à jours les bibliothèques partagées.'''}}. Sinon tenter :
<source>
$ export LD_LIBRARY_PATH=/usr/local/lib/x86_64-linux-gnu:$LD_LIBRARY_PATH
$ gnuradio-companion &
</source>

==== Utilisation du bloc et test ====

* Dans Gnuradio, rafraichir la liste des bloc (bouton ''reload'')
* le bloc <code>passetout</code> doit être présent dans la section <code>monModule</code>
* Tester le bon fonctionnement de ce bloc en lui envoyant une sinusoïde que vous devez observer identique à la sortie du bloc. Vérifier avec des graphes.

==== Application : démodulation ====

En reprenant le signal modulé en amplitude et la fonction de transfert du filtre passe-bas du TP précédent :

* Obtenir l'équation aux différence du filtre, ''ie'' écrire ''y(n)='' en fonction de ''x(n)'', ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.
* Créer un nouveau bloc C++ (similaire au passe-tout précédent) dans le module <code>monModule</code> :
** de type <code>sync</code>
** une entrée en <code>float</code>
** une sortie en <code>float</code>
* Écrire le code permettant d'obtenir ''y(n)'' dans la méthode <code>work()</code> :
** ''x(n)'' est donné par <code>in0[0]</code>
** il sera nécessaire d'affecter <code>out0[0]</code> pour produire ''y(n)''.
** il sera nécessaire de stocker dans des '''attributs''' les valeurs de <code>in[0]</code> afin de disposer de ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.
** On rappelle que les attributs doivent être déclarées dans le fichier <code>.h</code> et initialisés dans le constructeur de la classe.

{{Todos| Réaliser cette implémentation du passe-bas et contrôler que la démodulation est identique à celle obtenue au TP précédent}}

{{Todos| Modifier votre code pour implémenter le filtre complet de démodulation}}

=== Approximation de PID par filtre numérique linéaire ===

==== Rappels PID ====

* Principe

[[Fichier:PIDprincipe.png|400px]]

[[Fichier:PIDdetail.png|400px]]

* Définition mathématique, la sortie du controleur PID ''u(t)'' est donnée par:

[[Fichier:EqPID.png|400px]]

==== PID numérique "classique" ====

On considère que le temps est discrétisé : ''t = n.dt'' où ''dt'' est l'intervalle de temps entre deux valeurs.

* En approximant grossièrement l'intégrale et la dérivée [[Fichier:PIDderivative.png|400px]] [[Fichier:PIDintegral.png|400px]]
** La dérivée est calculée par ''D = (e(n)-e(n-1))/dt''
** L'intégrale est approximée en cumulant progressivement : ''I = I + e(n).dt''

* Notebook exemple : asservissement de température
** ''Ki = Kd = 0'' => chercher le meilleur ''Kp'' => erreur de régime permanent
** ''Kd = 0'' => l'introduction du terme integral permet de corriger cette erreur de régime permanent
** Le terme dérivatif n'est pas nécessaire dans cet exemple car la température ne dépend que de la commande ''u(t)''.

==== PID numérique par approximation d'un filtre continu ====

* Cherchons la fonction de transfert du filtre continu d'un PID.
 En partant de l'équation différentielle
 [[Fichier:EqPID.png|500px]]
 On applique la transformée de Laplace (dérivée => multiplication par ''s'' ; intégrale => division par ''s'') :
 [[Fichier:eqFxTransfertPID.png|200]]
 Le terme dérivatif étant très sensible au bruit, on lui applique généralement un filtre passe bas (''w0/(w0+s)'') :
 [[Fichier:eqFxTransfertPIDetPB.png|130]]
* Approximation de la fonction de transfert pour obtenir un filtre numérique
** ''backward euler''
** et transformée bilinéaire

* Implémentation du Filtre : classe <code>FilterController</code>
* Application sur l'asservissement d'altitude d'un drone

Cours:Elen4 TNS TP TpsReel

2026-05-29T13:29:01Z

Fredmn : /* PID numérique par approximation d'un filtre continu */

[[Cours:Elen4_TNS|{{Rouge|'''Retour à la page du cours'''}}]]

<center>
'''<big>TP6 : Temps réel : Codage d'un bloc en Python / démodulation / PID Numérique</big>'''
</center>

Le but de ce TP est double :
* réaliser des implémentations temps réel de filtre IIR en créant un bloc Gnuradio qui execute un traitement codé en Python
* et étudier l'implémentation d'un PID numérique sous forme d'un filtre IIR.

=== Codage de bloc Gnuradio en Python ===

'''EN COURS DE RÉÉCRITURE (C++ vers Python)'''

Ce guide est inspirée du guide [https://wiki.gnuradio.org/index.php?title=Creating_C%2B%2B_OOT_with_gr-modtool Creating an OOT (C++ block example)] en l'adaptant pour nos besoins :

Nous allons créer un simple bloc qui recopie son entrée (en <code>float</code>) sur sa sortie. Donc le filtre caractérisé par ''y(n)'' = ''x(n)'' ou encore ''H(z)''=1. Il s'agit donc d'une sorte de filtre passe-tout.

'''Suivez bien toutes les étapes, sans aller trop rapidement'''

* Vous pourrez utiliser <code>gedit</code> pour éditer les divers fichiers.

==== Création d'un module externe ====

Dans les lignes qui suivent, le <code>$</code> indique que l'on saisi une commande dans un terminal. Le <code>$</code> n'est pas à saisir.

* Ouvrez un terminal et placez-vous à la racine de votre dossier personnel :
<source>
$ cd $HOME
</source>
* Créez un dossier de travail dédié à gnuradio et déplacez-vous à l'intérieur :
<source>
$ mkdir gnuradio
$ cd gnuradio
</source>
* GNU Radio est livré avec gr_modtool, un utilitaire qui permet de créer des modules externes (OOT). Créons un module <code>monModule</code>
<source>
$ gr_modtool newmod monModule
</source>
* Le dossier <code>gr-monModule</code> est créé et contient tout le code squelette d'un module OOT, mais il n'a pas encore de blocs. Déplacez-vous dans <code>gr-monModule</code> :
<source>
$ cd gr-monModule
</source>
* Vous pouvez afficher le contenu de ce dossier par
<source>
$ ls
</source>

==== Création d'un bloc dans ce module ====

* Ajoutez un nouveau bloc nommé <code>passetout</code> :
<source>
$ gr_modtool add passetout
</source>
* Quelques questions permettent alors de spécifier le type de bloc
<source>
GNU Radio module name identified: passetout
('sink', 'source', 'sync', 'decimator', 'interpolator', 'general', 'tagged_stream', 'hier', 'noblock')
</source>
Saisissez <code>sync</code> comme type de bloc, car le bloc que nous écrivons produira le même nombre d'échantillons en sortie que le nombre d'échantillons consommés depuis l'entrée.
<source>
Enter block type: sync
</source>
* Spécifiez <code>cpp</code> comme langage :
<source>
Language (python/cpp): cpp
Language: C++
Block/code identifier: passetout
</source>
* Spécifiez un nom pour le copyright :
<source>
Please specify the copyright holder: Bibi
</source>
* Il est possible de spécifier des paramètres d'entrée qui peuvent permettre de régler le fonctionnement du bloc. Ce ne sera pas notre cas, ne rien saisir sur cette question :
<source>
Enter valid argument list, including default arguments:
</source>
* De même, on ne donnera pas de code permettant de tester le bon fonctionnement :
<source>
Add Python QA code? [Y/n] n
Add C++ QA code? [Y/n] n
</source>
* Plusieurs fichers sont alors crées :
<source>
Adding file 'lib/passetout_impl.h'...
Adding file 'lib/passetout_impl.cc'...
Adding file 'include/gnuradio/monModule/passetout.h'...
Adding file 'python/monModule/bindings/docstrings/passetout_pydoc_template.h'...
Adding file 'python/monModule/bindings/passetout_python.cc'...
Adding file 'grc/monModule_passetout.block.yml'...
Editing grc/CMakeLists.txt...
</source>

Quelques indications :
* le fichier <code>passetout_impl.h</code> contient l'entête de la classe de notre bloc
* le fichier <code>passetout_impl.cc</code> contient l'implémentation de la classe de notre bloc
* le fichier <code>monModule_passetout.block.yml</code> va contenir des informations faisant le lien entre notre code c++ et le code python utilisé en interne par Gnuradio
* Le tout sera compilé par un <code>Makefile</code> généré par <code>cmake</code>.

==== Fichier <code>passetout_impl.h</code> ====

Le code utile généré est le suivant :
<source lang=cpp>
class passetout_impl : public passetout
{
private:
// Nothing to declare in this block.

public:
passetout_impl();
~passetout_impl();

// Where all the action really happens
int work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items);
};
</source>

Pour se réveiller les neurones sur la POO, qu'est-ce que sont
* <code>passetout_impl()</code>,
* <code>~passetout_impl()</code>,
* <code>private</code>, <code>public</code> ?

Le travail sera réalisé dans la méthode <code>work()</code>, mais nous n'avons pas de modification à apporter dans les déclarations par défaut.

==== Fichier <code>passetout_impl.cc</code> ====

Le code utile généré est le suivant :

{{boîte déroulante/début|titre=passetout_impl.cc}}
<source lang=cpp>
namespace monModule {

#pragma message("set the following appropriately and remove this warning")
using input_type = float;
#pragma message("set the following appropriately and remove this warning")
using output_type = float;
passetout::sptr passetout::make() { return gnuradio::make_block_sptr<passetout_impl>(); }

/*
* The private constructor
*/
passetout_impl::passetout_impl()
: gr::sync_block("passetout",
gr::io_signature::make(
1 /* min inputs */, 1 /* max inputs */, sizeof(input_type)),
gr::io_signature::make(
1 /* min outputs */, 1 /*max outputs */, sizeof(output_type)))
{
}

/*
* Our virtual destructor.
*/
passetout_impl::~passetout_impl() {}

int passetout_impl::work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items)
{
auto in = static_cast<const input_type*>(input_items[0]);
auto out = static_cast<output_type*>(output_items[0]);

#pragma message("Implement the signal processing in your block and remove this warning")
// Do <+signal processing+>

// Tell runtime system how many output items we produced.
return noutput_items;
}

} /* namespace monModule */
</source>
{{boîte déroulante/fin}}

Détaillons :
<source lang=cpp>
#pragma message("set the following appropriately and remove this warning")
using input_type = float;
#pragma message("set the following appropriately and remove this warning")
using output_type = float;
</source>
{{Todos| On spécifie ici le type des données d'entrée et de sortie. Pas de modification à apporter, il suffit de supprimer les deux <code>#pragma</code>}}

<source lang=cpp>
passetout_impl::passetout_impl()
: gr::sync_block("passetout",
gr::io_signature::make(
1 /* min inputs */, 1 /* max inputs */, sizeof(input_type)),
gr::io_signature::make(
1 /* min outputs */, 1 /*max outputs */, sizeof(output_type)))
{
}
</source>

{{Todos| On spécifie ici le nombre d'entrées (1) et le nombre de sorties (1). Pas de modification non plus.}}

{{Todos| Expliquez la syntaxe <code>passetout_impl::passetout_impl() : gr::sync_block(...)"</code> }}

<source lang=cpp>
int passetout_impl::work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items)
{
auto in = static_cast<const input_type*>(input_items[0]);
auto out = static_cast<output_type*>(output_items[0]);

#pragma message("Implement the signal processing in your block and remove this warning")
// Do <+signal processing+>

// Tell runtime system how many output items we produced.
return noutput_items;
}
</source>
Cette méthode <code>work()</code> implémente véritablement le filtrage.
* Les tableaux <code>in</code> et <code>out</code> contiennent respectivement les données en entrée et les données en sortie. Il faut donc calculer <code>out</code> en fonction de <code>in</code>
* Les données d'entrée arrivent par paquets dans un buffer. La variable <code>noutput_items</code> contient le nombre de données disponibles en entrées.
* à la fin de la méthode, on renvoie le nombre de données en sortie que l'on a calculé (entre 1 et <code>noutput_items</code>). Les données d'entrées éventuellement non consommées seront conservées dans le buffer pour le prochain appel de <code>work()</code>
{{Todos| On souhaite ici seulement recopier l'entrée sur la sortie, donc }}
# Enlever la ligne <code>#pragma</code>
# ajouter le code <code> out[0] = in[0];</code> (on recopie le premier échantillon disponible en entrée)
# changer <code>return noutput_items;</code> en <code>return 1;</code> (un seul échantillon a été consommé).

==== Fichier <code>monModule_passetout.block.yml</code> ====

Ce fichier au format YAML (''yet another markup language'') fait le lien entre le code c++ et le code python utilisé en interne par GnuRadio.

{{boîte déroulante/début|titre=monModule_passetout.block.yml}}
<source lang=yaml>
id: monModule_passetout
label: passetout
category: '[monModule]'

templates:
imports: from gnuradio import monModule
make: monModule.passetout()

# Make one 'parameters' list entry for every parameter you want settable from the GUI.
# Keys include:
# * id (makes the value accessible as keyname, e.g. in the make entry)
# * label (label shown in the GUI)
# * dtype (e.g. int, float, complex, byte, short, xxx_vector, ...)
# * default
parameters:
- id: parametername_replace_me
label: FIX ME:
dtype: string
default: You need to fill in your grc/monModule_passetout.block.yaml
#- id: ...
# label: ...
# dtype: ...

# Make one 'inputs' list entry per input and one 'outputs' list entry per output.
# Keys include:
# * label (an identifier for the GUI)
# * domain (optional - stream or message. Default is stream)
# * dtype (e.g. int, float, complex, byte, short, xxx_vector, ...)
# * vlen (optional - data stream vector length. Default is 1)
# * optional (optional - set to 1 for optional inputs. Default is 0)
inputs:
#- label: ...
# domain: ...
# dtype: ...
# vlen: ...
# optional: ...

outputs:
#- label: ...
# domain: ...
# dtype: ...
# vlen: ...
# optional: ...

# 'file_format' specifies the version of the GRC yml format used in the file
# and should usually not be changed.
file_format: 1
</source>
{{boîte déroulante/fin}}

{{Todos| Mettre à jour la section <code>parameters</code> (pas de paramètres, on commente) :}}

<source lang=yaml>
#parameters:
#- id: parametername_replace_me
# label: FIX ME:
# dtype: string
# default: You need to fill in your grc/customModule_testMod.block.yaml
</source>

{{Todos| Mettre à jour la section <code>inputs</code> :}}

<source lang=yaml>
inputs:
- label: in
domain: stream
dtype: float
</source>

{{Todos| Mettre à jour la section <code>output</code> :}}

<source lang=yaml>
outputs:
- label: out
domain: stream
dtype: float
</source>

==== Compilation et installation ====

Voici les étapes :
<source lang=bash>
$ cd CHEMIN-DE-VOTRE-DOSSIER/gr-monModule
$ mkdir build
$ cd build
$ cmake ..
$ make
$ make install
</source>

* <code>cmake ..</code> lance la création des fichiers <code>Makefile</code> qui permettent la compilation et l'installation
* <code>make</code> lance la compilation
* <code>make install</code> lance l'installation (copie des fichiers dans les dossiers gnuradio)

{{Todos| Exécuter chacune de ces lignes, en contrôlant l'absence d'erreur. Dans le cas contraire, contrôler les fichiers <code>.h</code>, <code>.cc</code> et <code>.yaml</code>}}

{{Todos| '''Après ces étapes, et avant de lancer gnuRadio, appeler l'enseignant qui va mettre à jours les bibliothèques partagées.'''}}. Sinon tenter :
<source>
$ export LD_LIBRARY_PATH=/usr/local/lib/x86_64-linux-gnu:$LD_LIBRARY_PATH
$ gnuradio-companion &
</source>

==== Utilisation du bloc et test ====

* Dans Gnuradio, rafraichir la liste des bloc (bouton ''reload'')
* le bloc <code>passetout</code> doit être présent dans la section <code>monModule</code>
* Tester le bon fonctionnement de ce bloc en lui envoyant une sinusoïde que vous devez observer identique à la sortie du bloc. Vérifier avec des graphes.

==== Application : démodulation ====

En reprenant le signal modulé en amplitude et la fonction de transfert du filtre passe-bas du TP précédent :

* Obtenir l'équation aux différence du filtre, ''ie'' écrire ''y(n)='' en fonction de ''x(n)'', ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.
* Créer un nouveau bloc C++ (similaire au passe-tout précédent) dans le module <code>monModule</code> :
** de type <code>sync</code>
** une entrée en <code>float</code>
** une sortie en <code>float</code>
* Écrire le code permettant d'obtenir ''y(n)'' dans la méthode <code>work()</code> :
** ''x(n)'' est donné par <code>in0[0]</code>
** il sera nécessaire d'affecter <code>out0[0]</code> pour produire ''y(n)''.
** il sera nécessaire de stocker dans des '''attributs''' les valeurs de <code>in[0]</code> afin de disposer de ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.
** On rappelle que les attributs doivent être déclarées dans le fichier <code>.h</code> et initialisés dans le constructeur de la classe.

{{Todos| Réaliser cette implémentation du passe-bas et contrôler que la démodulation est identique à celle obtenue au TP précédent}}

{{Todos| Modifier votre code pour implémenter le filtre complet de démodulation}}

=== Approximation de PID par filtre numérique linéaire ===

==== Rappels PID ====

* Principe

[[Fichier:PIDprincipe.png|400px]]

[[Fichier:PIDdetail.png|400px]]

* Définition mathématique, la sortie du controleur PID ''u(t)'' est donnée par:

[[Fichier:EqPID.png|400px]]

==== PID numérique "classique" ====

On considère que le temps est discrétisé : ''t = n.dt'' où ''dt'' est l'intervalle de temps entre deux valeurs.

* En approximant grossièrement l'intégrale et la dérivée [[Fichier:PIDderivative.png|400px]] [[Fichier:PIDintegral.png|400px]]
** La dérivée est calculée par ''D = (e(n)-e(n-1))/dt''
** L'intégrale est approximée en cumulant progressivement : ''I = I + e(n).dt''

* Notebook exemple : asservissement de température
** ''Ki = Kd = 0'' => chercher le meilleur ''Kp'' => erreur de régime permanent
** ''Kd = 0'' => l'introduction du terme integral permet de corriger cette erreur de régime permanent
** Le terme dérivatif n'est pas nécessaire dans cet exemple car la température ne dépend que de la commande ''u(t)''.

==== PID numérique par approximation d'un filtre continu ====

* Fonction de transfert Filtre continu d'un PID.
 En partant de l'équation différentielle
 [[Fichier:EqPID.png|500px]]
 On applique la transformée de Laplace (dérivée => multiplication par ''s'' ; intégrale => division par ''s'') :
 [[Fichier:eqFxTransfertPID.png|200]]
 On applique généralement un filtre passe bas (''w0/(w0+s)'') sur le terme dérivatif :
 [[Fichier:eqFxTransfertPIDetPB.png|130]]

* Approximation de la fonction de transfert pour obtenir un filtre numérique
** ''backward euler''
** et transformée bilinéaire

* Implémentation du Filtre : classe <code>FilterController</code>
* Application sur l'asservissement d'altitude d'un drone

Cours:Elen4 TNS TP TpsReel

2026-05-29T13:14:02Z

Fredmn : /* PID numérique par approximation d'un filtre continu */

[[Cours:Elen4_TNS|{{Rouge|'''Retour à la page du cours'''}}]]

<center>
'''<big>TP6 : Temps réel : Codage d'un bloc en Python / démodulation / PID Numérique</big>'''
</center>

Le but de ce TP est double :
* réaliser des implémentations temps réel de filtre IIR en créant un bloc Gnuradio qui execute un traitement codé en Python
* et étudier l'implémentation d'un PID numérique sous forme d'un filtre IIR.

=== Codage de bloc Gnuradio en Python ===

'''EN COURS DE RÉÉCRITURE (C++ vers Python)'''

Ce guide est inspirée du guide [https://wiki.gnuradio.org/index.php?title=Creating_C%2B%2B_OOT_with_gr-modtool Creating an OOT (C++ block example)] en l'adaptant pour nos besoins :

Nous allons créer un simple bloc qui recopie son entrée (en <code>float</code>) sur sa sortie. Donc le filtre caractérisé par ''y(n)'' = ''x(n)'' ou encore ''H(z)''=1. Il s'agit donc d'une sorte de filtre passe-tout.

'''Suivez bien toutes les étapes, sans aller trop rapidement'''

* Vous pourrez utiliser <code>gedit</code> pour éditer les divers fichiers.

==== Création d'un module externe ====

Dans les lignes qui suivent, le <code>$</code> indique que l'on saisi une commande dans un terminal. Le <code>$</code> n'est pas à saisir.

* Ouvrez un terminal et placez-vous à la racine de votre dossier personnel :
<source>
$ cd $HOME
</source>
* Créez un dossier de travail dédié à gnuradio et déplacez-vous à l'intérieur :
<source>
$ mkdir gnuradio
$ cd gnuradio
</source>
* GNU Radio est livré avec gr_modtool, un utilitaire qui permet de créer des modules externes (OOT). Créons un module <code>monModule</code>
<source>
$ gr_modtool newmod monModule
</source>
* Le dossier <code>gr-monModule</code> est créé et contient tout le code squelette d'un module OOT, mais il n'a pas encore de blocs. Déplacez-vous dans <code>gr-monModule</code> :
<source>
$ cd gr-monModule
</source>
* Vous pouvez afficher le contenu de ce dossier par
<source>
$ ls
</source>

==== Création d'un bloc dans ce module ====

* Ajoutez un nouveau bloc nommé <code>passetout</code> :
<source>
$ gr_modtool add passetout
</source>
* Quelques questions permettent alors de spécifier le type de bloc
<source>
GNU Radio module name identified: passetout
('sink', 'source', 'sync', 'decimator', 'interpolator', 'general', 'tagged_stream', 'hier', 'noblock')
</source>
Saisissez <code>sync</code> comme type de bloc, car le bloc que nous écrivons produira le même nombre d'échantillons en sortie que le nombre d'échantillons consommés depuis l'entrée.
<source>
Enter block type: sync
</source>
* Spécifiez <code>cpp</code> comme langage :
<source>
Language (python/cpp): cpp
Language: C++
Block/code identifier: passetout
</source>
* Spécifiez un nom pour le copyright :
<source>
Please specify the copyright holder: Bibi
</source>
* Il est possible de spécifier des paramètres d'entrée qui peuvent permettre de régler le fonctionnement du bloc. Ce ne sera pas notre cas, ne rien saisir sur cette question :
<source>
Enter valid argument list, including default arguments:
</source>
* De même, on ne donnera pas de code permettant de tester le bon fonctionnement :
<source>
Add Python QA code? [Y/n] n
Add C++ QA code? [Y/n] n
</source>
* Plusieurs fichers sont alors crées :
<source>
Adding file 'lib/passetout_impl.h'...
Adding file 'lib/passetout_impl.cc'...
Adding file 'include/gnuradio/monModule/passetout.h'...
Adding file 'python/monModule/bindings/docstrings/passetout_pydoc_template.h'...
Adding file 'python/monModule/bindings/passetout_python.cc'...
Adding file 'grc/monModule_passetout.block.yml'...
Editing grc/CMakeLists.txt...
</source>

Quelques indications :
* le fichier <code>passetout_impl.h</code> contient l'entête de la classe de notre bloc
* le fichier <code>passetout_impl.cc</code> contient l'implémentation de la classe de notre bloc
* le fichier <code>monModule_passetout.block.yml</code> va contenir des informations faisant le lien entre notre code c++ et le code python utilisé en interne par Gnuradio
* Le tout sera compilé par un <code>Makefile</code> généré par <code>cmake</code>.

==== Fichier <code>passetout_impl.h</code> ====

Le code utile généré est le suivant :
<source lang=cpp>
class passetout_impl : public passetout
{
private:
// Nothing to declare in this block.

public:
passetout_impl();
~passetout_impl();

// Where all the action really happens
int work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items);
};
</source>

Pour se réveiller les neurones sur la POO, qu'est-ce que sont
* <code>passetout_impl()</code>,
* <code>~passetout_impl()</code>,
* <code>private</code>, <code>public</code> ?

Le travail sera réalisé dans la méthode <code>work()</code>, mais nous n'avons pas de modification à apporter dans les déclarations par défaut.

==== Fichier <code>passetout_impl.cc</code> ====

Le code utile généré est le suivant :

{{boîte déroulante/début|titre=passetout_impl.cc}}
<source lang=cpp>
namespace monModule {

#pragma message("set the following appropriately and remove this warning")
using input_type = float;
#pragma message("set the following appropriately and remove this warning")
using output_type = float;
passetout::sptr passetout::make() { return gnuradio::make_block_sptr<passetout_impl>(); }

/*
* The private constructor
*/
passetout_impl::passetout_impl()
: gr::sync_block("passetout",
gr::io_signature::make(
1 /* min inputs */, 1 /* max inputs */, sizeof(input_type)),
gr::io_signature::make(
1 /* min outputs */, 1 /*max outputs */, sizeof(output_type)))
{
}

/*
* Our virtual destructor.
*/
passetout_impl::~passetout_impl() {}

int passetout_impl::work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items)
{
auto in = static_cast<const input_type*>(input_items[0]);
auto out = static_cast<output_type*>(output_items[0]);

#pragma message("Implement the signal processing in your block and remove this warning")
// Do <+signal processing+>

// Tell runtime system how many output items we produced.
return noutput_items;
}

} /* namespace monModule */
</source>
{{boîte déroulante/fin}}

Détaillons :
<source lang=cpp>
#pragma message("set the following appropriately and remove this warning")
using input_type = float;
#pragma message("set the following appropriately and remove this warning")
using output_type = float;
</source>
{{Todos| On spécifie ici le type des données d'entrée et de sortie. Pas de modification à apporter, il suffit de supprimer les deux <code>#pragma</code>}}

<source lang=cpp>
passetout_impl::passetout_impl()
: gr::sync_block("passetout",
gr::io_signature::make(
1 /* min inputs */, 1 /* max inputs */, sizeof(input_type)),
gr::io_signature::make(
1 /* min outputs */, 1 /*max outputs */, sizeof(output_type)))
{
}
</source>

{{Todos| On spécifie ici le nombre d'entrées (1) et le nombre de sorties (1). Pas de modification non plus.}}

{{Todos| Expliquez la syntaxe <code>passetout_impl::passetout_impl() : gr::sync_block(...)"</code> }}

<source lang=cpp>
int passetout_impl::work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items)
{
auto in = static_cast<const input_type*>(input_items[0]);
auto out = static_cast<output_type*>(output_items[0]);

#pragma message("Implement the signal processing in your block and remove this warning")
// Do <+signal processing+>

// Tell runtime system how many output items we produced.
return noutput_items;
}
</source>
Cette méthode <code>work()</code> implémente véritablement le filtrage.
* Les tableaux <code>in</code> et <code>out</code> contiennent respectivement les données en entrée et les données en sortie. Il faut donc calculer <code>out</code> en fonction de <code>in</code>
* Les données d'entrée arrivent par paquets dans un buffer. La variable <code>noutput_items</code> contient le nombre de données disponibles en entrées.
* à la fin de la méthode, on renvoie le nombre de données en sortie que l'on a calculé (entre 1 et <code>noutput_items</code>). Les données d'entrées éventuellement non consommées seront conservées dans le buffer pour le prochain appel de <code>work()</code>
{{Todos| On souhaite ici seulement recopier l'entrée sur la sortie, donc }}
# Enlever la ligne <code>#pragma</code>
# ajouter le code <code> out[0] = in[0];</code> (on recopie le premier échantillon disponible en entrée)
# changer <code>return noutput_items;</code> en <code>return 1;</code> (un seul échantillon a été consommé).

==== Fichier <code>monModule_passetout.block.yml</code> ====

Ce fichier au format YAML (''yet another markup language'') fait le lien entre le code c++ et le code python utilisé en interne par GnuRadio.

{{boîte déroulante/début|titre=monModule_passetout.block.yml}}
<source lang=yaml>
id: monModule_passetout
label: passetout
category: '[monModule]'

templates:
imports: from gnuradio import monModule
make: monModule.passetout()

# Make one 'parameters' list entry for every parameter you want settable from the GUI.
# Keys include:
# * id (makes the value accessible as keyname, e.g. in the make entry)
# * label (label shown in the GUI)
# * dtype (e.g. int, float, complex, byte, short, xxx_vector, ...)
# * default
parameters:
- id: parametername_replace_me
label: FIX ME:
dtype: string
default: You need to fill in your grc/monModule_passetout.block.yaml
#- id: ...
# label: ...
# dtype: ...

# Make one 'inputs' list entry per input and one 'outputs' list entry per output.
# Keys include:
# * label (an identifier for the GUI)
# * domain (optional - stream or message. Default is stream)
# * dtype (e.g. int, float, complex, byte, short, xxx_vector, ...)
# * vlen (optional - data stream vector length. Default is 1)
# * optional (optional - set to 1 for optional inputs. Default is 0)
inputs:
#- label: ...
# domain: ...
# dtype: ...
# vlen: ...
# optional: ...

outputs:
#- label: ...
# domain: ...
# dtype: ...
# vlen: ...
# optional: ...

# 'file_format' specifies the version of the GRC yml format used in the file
# and should usually not be changed.
file_format: 1
</source>
{{boîte déroulante/fin}}

{{Todos| Mettre à jour la section <code>parameters</code> (pas de paramètres, on commente) :}}

<source lang=yaml>
#parameters:
#- id: parametername_replace_me
# label: FIX ME:
# dtype: string
# default: You need to fill in your grc/customModule_testMod.block.yaml
</source>

{{Todos| Mettre à jour la section <code>inputs</code> :}}

<source lang=yaml>
inputs:
- label: in
domain: stream
dtype: float
</source>

{{Todos| Mettre à jour la section <code>output</code> :}}

<source lang=yaml>
outputs:
- label: out
domain: stream
dtype: float
</source>

==== Compilation et installation ====

Voici les étapes :
<source lang=bash>
$ cd CHEMIN-DE-VOTRE-DOSSIER/gr-monModule
$ mkdir build
$ cd build
$ cmake ..
$ make
$ make install
</source>

* <code>cmake ..</code> lance la création des fichiers <code>Makefile</code> qui permettent la compilation et l'installation
* <code>make</code> lance la compilation
* <code>make install</code> lance l'installation (copie des fichiers dans les dossiers gnuradio)

{{Todos| Exécuter chacune de ces lignes, en contrôlant l'absence d'erreur. Dans le cas contraire, contrôler les fichiers <code>.h</code>, <code>.cc</code> et <code>.yaml</code>}}

{{Todos| '''Après ces étapes, et avant de lancer gnuRadio, appeler l'enseignant qui va mettre à jours les bibliothèques partagées.'''}}. Sinon tenter :
<source>
$ export LD_LIBRARY_PATH=/usr/local/lib/x86_64-linux-gnu:$LD_LIBRARY_PATH
$ gnuradio-companion &
</source>

==== Utilisation du bloc et test ====

* Dans Gnuradio, rafraichir la liste des bloc (bouton ''reload'')
* le bloc <code>passetout</code> doit être présent dans la section <code>monModule</code>
* Tester le bon fonctionnement de ce bloc en lui envoyant une sinusoïde que vous devez observer identique à la sortie du bloc. Vérifier avec des graphes.

==== Application : démodulation ====

En reprenant le signal modulé en amplitude et la fonction de transfert du filtre passe-bas du TP précédent :

* Obtenir l'équation aux différence du filtre, ''ie'' écrire ''y(n)='' en fonction de ''x(n)'', ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.
* Créer un nouveau bloc C++ (similaire au passe-tout précédent) dans le module <code>monModule</code> :
** de type <code>sync</code>
** une entrée en <code>float</code>
** une sortie en <code>float</code>
* Écrire le code permettant d'obtenir ''y(n)'' dans la méthode <code>work()</code> :
** ''x(n)'' est donné par <code>in0[0]</code>
** il sera nécessaire d'affecter <code>out0[0]</code> pour produire ''y(n)''.
** il sera nécessaire de stocker dans des '''attributs''' les valeurs de <code>in[0]</code> afin de disposer de ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.
** On rappelle que les attributs doivent être déclarées dans le fichier <code>.h</code> et initialisés dans le constructeur de la classe.

{{Todos| Réaliser cette implémentation du passe-bas et contrôler que la démodulation est identique à celle obtenue au TP précédent}}

{{Todos| Modifier votre code pour implémenter le filtre complet de démodulation}}

=== Approximation de PID par filtre numérique linéaire ===

==== Rappels PID ====

* Principe

[[Fichier:PIDprincipe.png|400px]]

[[Fichier:PIDdetail.png|400px]]

* Définition mathématique, la sortie du controleur PID ''u(t)'' est donnée par:

[[Fichier:EqPID.png|400px]]

==== PID numérique "classique" ====

On considère que le temps est discrétisé : ''t = n.dt'' où ''dt'' est l'intervalle de temps entre deux valeurs.

* En approximant grossièrement l'intégrale et la dérivée [[Fichier:PIDderivative.png|400px]] [[Fichier:PIDintegral.png|400px]]
** La dérivée est calculée par ''D = (e(n)-e(n-1))/dt''
** L'intégrale est approximée en cumulant progressivement : ''I = I + e(n).dt''

* Notebook exemple : asservissement de température
** ''Ki = Kd = 0'' => chercher le meilleur ''Kp'' => erreur de régime permanent
** ''Kd = 0'' => l'introduction du terme integral permet de corriger cette erreur de régime permanent
** Le terme dérivatif n'est pas nécessaire dans cet exemple car la température ne dépend que de la commande ''u(t)''.

==== PID numérique par approximation d'un filtre continu ====

* Fonction de transfert Filtre continu d'un PID.
 En partant de l'équation différentielle
 [[Fichier:EqPID.png|500px]]
 On applique la transformée de Laplace (dérivée => multiplication par ''s'' ; intégrale => division par ''s'') :
 [[Fichier:eqFxTransfertPID.png|200]]
 On applique
[[Fichier:eqFxTransfertPIDetPB.png|130]]

* Approximation de la fonction de transfert pour obtenir un filtre numérique
** ''backward euler''
** et transformée bilinéaire

* Implémentation du Filtre : classe <code>FilterController</code>
* Application sur l'asservissement d'altitude d'un drone

Cours:Elen4 TNS TP TpsReel

2026-05-29T13:11:13Z

Fredmn : /* PID numérique "classique" */

[[Cours:Elen4_TNS|{{Rouge|'''Retour à la page du cours'''}}]]

<center>
'''<big>TP6 : Temps réel : Codage d'un bloc en Python / démodulation / PID Numérique</big>'''
</center>

Le but de ce TP est double :
* réaliser des implémentations temps réel de filtre IIR en créant un bloc Gnuradio qui execute un traitement codé en Python
* et étudier l'implémentation d'un PID numérique sous forme d'un filtre IIR.

=== Codage de bloc Gnuradio en Python ===

'''EN COURS DE RÉÉCRITURE (C++ vers Python)'''

Ce guide est inspirée du guide [https://wiki.gnuradio.org/index.php?title=Creating_C%2B%2B_OOT_with_gr-modtool Creating an OOT (C++ block example)] en l'adaptant pour nos besoins :

Nous allons créer un simple bloc qui recopie son entrée (en <code>float</code>) sur sa sortie. Donc le filtre caractérisé par ''y(n)'' = ''x(n)'' ou encore ''H(z)''=1. Il s'agit donc d'une sorte de filtre passe-tout.

'''Suivez bien toutes les étapes, sans aller trop rapidement'''

* Vous pourrez utiliser <code>gedit</code> pour éditer les divers fichiers.

==== Création d'un module externe ====

Dans les lignes qui suivent, le <code>$</code> indique que l'on saisi une commande dans un terminal. Le <code>$</code> n'est pas à saisir.

* Ouvrez un terminal et placez-vous à la racine de votre dossier personnel :
<source>
$ cd $HOME
</source>
* Créez un dossier de travail dédié à gnuradio et déplacez-vous à l'intérieur :
<source>
$ mkdir gnuradio
$ cd gnuradio
</source>
* GNU Radio est livré avec gr_modtool, un utilitaire qui permet de créer des modules externes (OOT). Créons un module <code>monModule</code>
<source>
$ gr_modtool newmod monModule
</source>
* Le dossier <code>gr-monModule</code> est créé et contient tout le code squelette d'un module OOT, mais il n'a pas encore de blocs. Déplacez-vous dans <code>gr-monModule</code> :
<source>
$ cd gr-monModule
</source>
* Vous pouvez afficher le contenu de ce dossier par
<source>
$ ls
</source>

==== Création d'un bloc dans ce module ====

* Ajoutez un nouveau bloc nommé <code>passetout</code> :
<source>
$ gr_modtool add passetout
</source>
* Quelques questions permettent alors de spécifier le type de bloc
<source>
GNU Radio module name identified: passetout
('sink', 'source', 'sync', 'decimator', 'interpolator', 'general', 'tagged_stream', 'hier', 'noblock')
</source>
Saisissez <code>sync</code> comme type de bloc, car le bloc que nous écrivons produira le même nombre d'échantillons en sortie que le nombre d'échantillons consommés depuis l'entrée.
<source>
Enter block type: sync
</source>
* Spécifiez <code>cpp</code> comme langage :
<source>
Language (python/cpp): cpp
Language: C++
Block/code identifier: passetout
</source>
* Spécifiez un nom pour le copyright :
<source>
Please specify the copyright holder: Bibi
</source>
* Il est possible de spécifier des paramètres d'entrée qui peuvent permettre de régler le fonctionnement du bloc. Ce ne sera pas notre cas, ne rien saisir sur cette question :
<source>
Enter valid argument list, including default arguments:
</source>
* De même, on ne donnera pas de code permettant de tester le bon fonctionnement :
<source>
Add Python QA code? [Y/n] n
Add C++ QA code? [Y/n] n
</source>
* Plusieurs fichers sont alors crées :
<source>
Adding file 'lib/passetout_impl.h'...
Adding file 'lib/passetout_impl.cc'...
Adding file 'include/gnuradio/monModule/passetout.h'...
Adding file 'python/monModule/bindings/docstrings/passetout_pydoc_template.h'...
Adding file 'python/monModule/bindings/passetout_python.cc'...
Adding file 'grc/monModule_passetout.block.yml'...
Editing grc/CMakeLists.txt...
</source>

Quelques indications :
* le fichier <code>passetout_impl.h</code> contient l'entête de la classe de notre bloc
* le fichier <code>passetout_impl.cc</code> contient l'implémentation de la classe de notre bloc
* le fichier <code>monModule_passetout.block.yml</code> va contenir des informations faisant le lien entre notre code c++ et le code python utilisé en interne par Gnuradio
* Le tout sera compilé par un <code>Makefile</code> généré par <code>cmake</code>.

==== Fichier <code>passetout_impl.h</code> ====

Le code utile généré est le suivant :
<source lang=cpp>
class passetout_impl : public passetout
{
private:
// Nothing to declare in this block.

public:
passetout_impl();
~passetout_impl();

// Where all the action really happens
int work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items);
};
</source>

Pour se réveiller les neurones sur la POO, qu'est-ce que sont
* <code>passetout_impl()</code>,
* <code>~passetout_impl()</code>,
* <code>private</code>, <code>public</code> ?

Le travail sera réalisé dans la méthode <code>work()</code>, mais nous n'avons pas de modification à apporter dans les déclarations par défaut.

==== Fichier <code>passetout_impl.cc</code> ====

Le code utile généré est le suivant :

{{boîte déroulante/début|titre=passetout_impl.cc}}
<source lang=cpp>
namespace monModule {

#pragma message("set the following appropriately and remove this warning")
using input_type = float;
#pragma message("set the following appropriately and remove this warning")
using output_type = float;
passetout::sptr passetout::make() { return gnuradio::make_block_sptr<passetout_impl>(); }

/*
* The private constructor
*/
passetout_impl::passetout_impl()
: gr::sync_block("passetout",
gr::io_signature::make(
1 /* min inputs */, 1 /* max inputs */, sizeof(input_type)),
gr::io_signature::make(
1 /* min outputs */, 1 /*max outputs */, sizeof(output_type)))
{
}

/*
* Our virtual destructor.
*/
passetout_impl::~passetout_impl() {}

int passetout_impl::work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items)
{
auto in = static_cast<const input_type*>(input_items[0]);
auto out = static_cast<output_type*>(output_items[0]);

#pragma message("Implement the signal processing in your block and remove this warning")
// Do <+signal processing+>

// Tell runtime system how many output items we produced.
return noutput_items;
}

} /* namespace monModule */
</source>
{{boîte déroulante/fin}}

Détaillons :
<source lang=cpp>
#pragma message("set the following appropriately and remove this warning")
using input_type = float;
#pragma message("set the following appropriately and remove this warning")
using output_type = float;
</source>
{{Todos| On spécifie ici le type des données d'entrée et de sortie. Pas de modification à apporter, il suffit de supprimer les deux <code>#pragma</code>}}

<source lang=cpp>
passetout_impl::passetout_impl()
: gr::sync_block("passetout",
gr::io_signature::make(
1 /* min inputs */, 1 /* max inputs */, sizeof(input_type)),
gr::io_signature::make(
1 /* min outputs */, 1 /*max outputs */, sizeof(output_type)))
{
}
</source>

{{Todos| On spécifie ici le nombre d'entrées (1) et le nombre de sorties (1). Pas de modification non plus.}}

{{Todos| Expliquez la syntaxe <code>passetout_impl::passetout_impl() : gr::sync_block(...)"</code> }}

<source lang=cpp>
int passetout_impl::work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items)
{
auto in = static_cast<const input_type*>(input_items[0]);
auto out = static_cast<output_type*>(output_items[0]);

#pragma message("Implement the signal processing in your block and remove this warning")
// Do <+signal processing+>

// Tell runtime system how many output items we produced.
return noutput_items;
}
</source>
Cette méthode <code>work()</code> implémente véritablement le filtrage.
* Les tableaux <code>in</code> et <code>out</code> contiennent respectivement les données en entrée et les données en sortie. Il faut donc calculer <code>out</code> en fonction de <code>in</code>
* Les données d'entrée arrivent par paquets dans un buffer. La variable <code>noutput_items</code> contient le nombre de données disponibles en entrées.
* à la fin de la méthode, on renvoie le nombre de données en sortie que l'on a calculé (entre 1 et <code>noutput_items</code>). Les données d'entrées éventuellement non consommées seront conservées dans le buffer pour le prochain appel de <code>work()</code>
{{Todos| On souhaite ici seulement recopier l'entrée sur la sortie, donc }}
# Enlever la ligne <code>#pragma</code>
# ajouter le code <code> out[0] = in[0];</code> (on recopie le premier échantillon disponible en entrée)
# changer <code>return noutput_items;</code> en <code>return 1;</code> (un seul échantillon a été consommé).

==== Fichier <code>monModule_passetout.block.yml</code> ====

Ce fichier au format YAML (''yet another markup language'') fait le lien entre le code c++ et le code python utilisé en interne par GnuRadio.

{{boîte déroulante/début|titre=monModule_passetout.block.yml}}
<source lang=yaml>
id: monModule_passetout
label: passetout
category: '[monModule]'

templates:
imports: from gnuradio import monModule
make: monModule.passetout()

# Make one 'parameters' list entry for every parameter you want settable from the GUI.
# Keys include:
# * id (makes the value accessible as keyname, e.g. in the make entry)
# * label (label shown in the GUI)
# * dtype (e.g. int, float, complex, byte, short, xxx_vector, ...)
# * default
parameters:
- id: parametername_replace_me
label: FIX ME:
dtype: string
default: You need to fill in your grc/monModule_passetout.block.yaml
#- id: ...
# label: ...
# dtype: ...

# Make one 'inputs' list entry per input and one 'outputs' list entry per output.
# Keys include:
# * label (an identifier for the GUI)
# * domain (optional - stream or message. Default is stream)
# * dtype (e.g. int, float, complex, byte, short, xxx_vector, ...)
# * vlen (optional - data stream vector length. Default is 1)
# * optional (optional - set to 1 for optional inputs. Default is 0)
inputs:
#- label: ...
# domain: ...
# dtype: ...
# vlen: ...
# optional: ...

outputs:
#- label: ...
# domain: ...
# dtype: ...
# vlen: ...
# optional: ...

# 'file_format' specifies the version of the GRC yml format used in the file
# and should usually not be changed.
file_format: 1
</source>
{{boîte déroulante/fin}}

{{Todos| Mettre à jour la section <code>parameters</code> (pas de paramètres, on commente) :}}

<source lang=yaml>
#parameters:
#- id: parametername_replace_me
# label: FIX ME:
# dtype: string
# default: You need to fill in your grc/customModule_testMod.block.yaml
</source>

{{Todos| Mettre à jour la section <code>inputs</code> :}}

<source lang=yaml>
inputs:
- label: in
domain: stream
dtype: float
</source>

{{Todos| Mettre à jour la section <code>output</code> :}}

<source lang=yaml>
outputs:
- label: out
domain: stream
dtype: float
</source>

==== Compilation et installation ====

Voici les étapes :
<source lang=bash>
$ cd CHEMIN-DE-VOTRE-DOSSIER/gr-monModule
$ mkdir build
$ cd build
$ cmake ..
$ make
$ make install
</source>

* <code>cmake ..</code> lance la création des fichiers <code>Makefile</code> qui permettent la compilation et l'installation
* <code>make</code> lance la compilation
* <code>make install</code> lance l'installation (copie des fichiers dans les dossiers gnuradio)

{{Todos| Exécuter chacune de ces lignes, en contrôlant l'absence d'erreur. Dans le cas contraire, contrôler les fichiers <code>.h</code>, <code>.cc</code> et <code>.yaml</code>}}

{{Todos| '''Après ces étapes, et avant de lancer gnuRadio, appeler l'enseignant qui va mettre à jours les bibliothèques partagées.'''}}. Sinon tenter :
<source>
$ export LD_LIBRARY_PATH=/usr/local/lib/x86_64-linux-gnu:$LD_LIBRARY_PATH
$ gnuradio-companion &
</source>

==== Utilisation du bloc et test ====

* Dans Gnuradio, rafraichir la liste des bloc (bouton ''reload'')
* le bloc <code>passetout</code> doit être présent dans la section <code>monModule</code>
* Tester le bon fonctionnement de ce bloc en lui envoyant une sinusoïde que vous devez observer identique à la sortie du bloc. Vérifier avec des graphes.

==== Application : démodulation ====

En reprenant le signal modulé en amplitude et la fonction de transfert du filtre passe-bas du TP précédent :

* Obtenir l'équation aux différence du filtre, ''ie'' écrire ''y(n)='' en fonction de ''x(n)'', ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.
* Créer un nouveau bloc C++ (similaire au passe-tout précédent) dans le module <code>monModule</code> :
** de type <code>sync</code>
** une entrée en <code>float</code>
** une sortie en <code>float</code>
* Écrire le code permettant d'obtenir ''y(n)'' dans la méthode <code>work()</code> :
** ''x(n)'' est donné par <code>in0[0]</code>
** il sera nécessaire d'affecter <code>out0[0]</code> pour produire ''y(n)''.
** il sera nécessaire de stocker dans des '''attributs''' les valeurs de <code>in[0]</code> afin de disposer de ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.
** On rappelle que les attributs doivent être déclarées dans le fichier <code>.h</code> et initialisés dans le constructeur de la classe.

{{Todos| Réaliser cette implémentation du passe-bas et contrôler que la démodulation est identique à celle obtenue au TP précédent}}

{{Todos| Modifier votre code pour implémenter le filtre complet de démodulation}}

=== Approximation de PID par filtre numérique linéaire ===

==== Rappels PID ====

* Principe

[[Fichier:PIDprincipe.png|400px]]

[[Fichier:PIDdetail.png|400px]]

* Définition mathématique, la sortie du controleur PID ''u(t)'' est donnée par:

[[Fichier:EqPID.png|400px]]

==== PID numérique "classique" ====

On considère que le temps est discrétisé : ''t = n.dt'' où ''dt'' est l'intervalle de temps entre deux valeurs.

* En approximant grossièrement l'intégrale et la dérivée [[Fichier:PIDderivative.png|400px]] [[Fichier:PIDintegral.png|400px]]
** La dérivée est calculée par ''D = (e(n)-e(n-1))/dt''
** L'intégrale est approximée en cumulant progressivement : ''I = I + e(n).dt''

* Notebook exemple : asservissement de température
** ''Ki = Kd = 0'' => chercher le meilleur ''Kp'' => erreur de régime permanent
** ''Kd = 0'' => l'introduction du terme integral permet de corriger cette erreur de régime permanent
** Le terme dérivatif n'est pas nécessaire dans cet exemple car la température ne dépend que de la commande ''u(t)''.

==== PID numérique par approximation d'un filtre continu ====

* Fonction de transfert Filtre continu d'un PID

[[Fichier:EqPID.png|500px]]

[[Fichier:eqFxTransfertPID.png|200]]

[[Fichier:eqFxTransfertPIDetPB.png|130]]

* Approximation de la fonction de transfert pour obtenir un filtre numérique
** ''backward euler''
** et transformée bilinéaire

* Implémentation du Filtre : classe <code>FilterController</code>
* Application sur l'asservissement d'altitude d'un drone

Cours:Elen4 TNS TP TpsReel

2026-05-29T13:10:56Z

Fredmn : /* PID numérique "classique" */

[[Cours:Elen4_TNS|{{Rouge|'''Retour à la page du cours'''}}]]

<center>
'''<big>TP6 : Temps réel : Codage d'un bloc en Python / démodulation / PID Numérique</big>'''
</center>

Le but de ce TP est double :
* réaliser des implémentations temps réel de filtre IIR en créant un bloc Gnuradio qui execute un traitement codé en Python
* et étudier l'implémentation d'un PID numérique sous forme d'un filtre IIR.

=== Codage de bloc Gnuradio en Python ===

'''EN COURS DE RÉÉCRITURE (C++ vers Python)'''

Ce guide est inspirée du guide [https://wiki.gnuradio.org/index.php?title=Creating_C%2B%2B_OOT_with_gr-modtool Creating an OOT (C++ block example)] en l'adaptant pour nos besoins :

Nous allons créer un simple bloc qui recopie son entrée (en <code>float</code>) sur sa sortie. Donc le filtre caractérisé par ''y(n)'' = ''x(n)'' ou encore ''H(z)''=1. Il s'agit donc d'une sorte de filtre passe-tout.

'''Suivez bien toutes les étapes, sans aller trop rapidement'''

* Vous pourrez utiliser <code>gedit</code> pour éditer les divers fichiers.

==== Création d'un module externe ====

Dans les lignes qui suivent, le <code>$</code> indique que l'on saisi une commande dans un terminal. Le <code>$</code> n'est pas à saisir.

* Ouvrez un terminal et placez-vous à la racine de votre dossier personnel :
<source>
$ cd $HOME
</source>
* Créez un dossier de travail dédié à gnuradio et déplacez-vous à l'intérieur :
<source>
$ mkdir gnuradio
$ cd gnuradio
</source>
* GNU Radio est livré avec gr_modtool, un utilitaire qui permet de créer des modules externes (OOT). Créons un module <code>monModule</code>
<source>
$ gr_modtool newmod monModule
</source>
* Le dossier <code>gr-monModule</code> est créé et contient tout le code squelette d'un module OOT, mais il n'a pas encore de blocs. Déplacez-vous dans <code>gr-monModule</code> :
<source>
$ cd gr-monModule
</source>
* Vous pouvez afficher le contenu de ce dossier par
<source>
$ ls
</source>

==== Création d'un bloc dans ce module ====

* Ajoutez un nouveau bloc nommé <code>passetout</code> :
<source>
$ gr_modtool add passetout
</source>
* Quelques questions permettent alors de spécifier le type de bloc
<source>
GNU Radio module name identified: passetout
('sink', 'source', 'sync', 'decimator', 'interpolator', 'general', 'tagged_stream', 'hier', 'noblock')
</source>
Saisissez <code>sync</code> comme type de bloc, car le bloc que nous écrivons produira le même nombre d'échantillons en sortie que le nombre d'échantillons consommés depuis l'entrée.
<source>
Enter block type: sync
</source>
* Spécifiez <code>cpp</code> comme langage :
<source>
Language (python/cpp): cpp
Language: C++
Block/code identifier: passetout
</source>
* Spécifiez un nom pour le copyright :
<source>
Please specify the copyright holder: Bibi
</source>
* Il est possible de spécifier des paramètres d'entrée qui peuvent permettre de régler le fonctionnement du bloc. Ce ne sera pas notre cas, ne rien saisir sur cette question :
<source>
Enter valid argument list, including default arguments:
</source>
* De même, on ne donnera pas de code permettant de tester le bon fonctionnement :
<source>
Add Python QA code? [Y/n] n
Add C++ QA code? [Y/n] n
</source>
* Plusieurs fichers sont alors crées :
<source>
Adding file 'lib/passetout_impl.h'...
Adding file 'lib/passetout_impl.cc'...
Adding file 'include/gnuradio/monModule/passetout.h'...
Adding file 'python/monModule/bindings/docstrings/passetout_pydoc_template.h'...
Adding file 'python/monModule/bindings/passetout_python.cc'...
Adding file 'grc/monModule_passetout.block.yml'...
Editing grc/CMakeLists.txt...
</source>

Quelques indications :
* le fichier <code>passetout_impl.h</code> contient l'entête de la classe de notre bloc
* le fichier <code>passetout_impl.cc</code> contient l'implémentation de la classe de notre bloc
* le fichier <code>monModule_passetout.block.yml</code> va contenir des informations faisant le lien entre notre code c++ et le code python utilisé en interne par Gnuradio
* Le tout sera compilé par un <code>Makefile</code> généré par <code>cmake</code>.

==== Fichier <code>passetout_impl.h</code> ====

Le code utile généré est le suivant :
<source lang=cpp>
class passetout_impl : public passetout
{
private:
// Nothing to declare in this block.

public:
passetout_impl();
~passetout_impl();

// Where all the action really happens
int work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items);
};
</source>

Pour se réveiller les neurones sur la POO, qu'est-ce que sont
* <code>passetout_impl()</code>,
* <code>~passetout_impl()</code>,
* <code>private</code>, <code>public</code> ?

Le travail sera réalisé dans la méthode <code>work()</code>, mais nous n'avons pas de modification à apporter dans les déclarations par défaut.

==== Fichier <code>passetout_impl.cc</code> ====

Le code utile généré est le suivant :

{{boîte déroulante/début|titre=passetout_impl.cc}}
<source lang=cpp>
namespace monModule {

#pragma message("set the following appropriately and remove this warning")
using input_type = float;
#pragma message("set the following appropriately and remove this warning")
using output_type = float;
passetout::sptr passetout::make() { return gnuradio::make_block_sptr<passetout_impl>(); }

/*
* The private constructor
*/
passetout_impl::passetout_impl()
: gr::sync_block("passetout",
gr::io_signature::make(
1 /* min inputs */, 1 /* max inputs */, sizeof(input_type)),
gr::io_signature::make(
1 /* min outputs */, 1 /*max outputs */, sizeof(output_type)))
{
}

/*
* Our virtual destructor.
*/
passetout_impl::~passetout_impl() {}

int passetout_impl::work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items)
{
auto in = static_cast<const input_type*>(input_items[0]);
auto out = static_cast<output_type*>(output_items[0]);

#pragma message("Implement the signal processing in your block and remove this warning")
// Do <+signal processing+>

// Tell runtime system how many output items we produced.
return noutput_items;
}

} /* namespace monModule */
</source>
{{boîte déroulante/fin}}

Détaillons :
<source lang=cpp>
#pragma message("set the following appropriately and remove this warning")
using input_type = float;
#pragma message("set the following appropriately and remove this warning")
using output_type = float;
</source>
{{Todos| On spécifie ici le type des données d'entrée et de sortie. Pas de modification à apporter, il suffit de supprimer les deux <code>#pragma</code>}}

<source lang=cpp>
passetout_impl::passetout_impl()
: gr::sync_block("passetout",
gr::io_signature::make(
1 /* min inputs */, 1 /* max inputs */, sizeof(input_type)),
gr::io_signature::make(
1 /* min outputs */, 1 /*max outputs */, sizeof(output_type)))
{
}
</source>

{{Todos| On spécifie ici le nombre d'entrées (1) et le nombre de sorties (1). Pas de modification non plus.}}

{{Todos| Expliquez la syntaxe <code>passetout_impl::passetout_impl() : gr::sync_block(...)"</code> }}

<source lang=cpp>
int passetout_impl::work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items)
{
auto in = static_cast<const input_type*>(input_items[0]);
auto out = static_cast<output_type*>(output_items[0]);

#pragma message("Implement the signal processing in your block and remove this warning")
// Do <+signal processing+>

// Tell runtime system how many output items we produced.
return noutput_items;
}
</source>
Cette méthode <code>work()</code> implémente véritablement le filtrage.
* Les tableaux <code>in</code> et <code>out</code> contiennent respectivement les données en entrée et les données en sortie. Il faut donc calculer <code>out</code> en fonction de <code>in</code>
* Les données d'entrée arrivent par paquets dans un buffer. La variable <code>noutput_items</code> contient le nombre de données disponibles en entrées.
* à la fin de la méthode, on renvoie le nombre de données en sortie que l'on a calculé (entre 1 et <code>noutput_items</code>). Les données d'entrées éventuellement non consommées seront conservées dans le buffer pour le prochain appel de <code>work()</code>
{{Todos| On souhaite ici seulement recopier l'entrée sur la sortie, donc }}
# Enlever la ligne <code>#pragma</code>
# ajouter le code <code> out[0] = in[0];</code> (on recopie le premier échantillon disponible en entrée)
# changer <code>return noutput_items;</code> en <code>return 1;</code> (un seul échantillon a été consommé).

==== Fichier <code>monModule_passetout.block.yml</code> ====

Ce fichier au format YAML (''yet another markup language'') fait le lien entre le code c++ et le code python utilisé en interne par GnuRadio.

{{boîte déroulante/début|titre=monModule_passetout.block.yml}}
<source lang=yaml>
id: monModule_passetout
label: passetout
category: '[monModule]'

templates:
imports: from gnuradio import monModule
make: monModule.passetout()

# Make one 'parameters' list entry for every parameter you want settable from the GUI.
# Keys include:
# * id (makes the value accessible as keyname, e.g. in the make entry)
# * label (label shown in the GUI)
# * dtype (e.g. int, float, complex, byte, short, xxx_vector, ...)
# * default
parameters:
- id: parametername_replace_me
label: FIX ME:
dtype: string
default: You need to fill in your grc/monModule_passetout.block.yaml
#- id: ...
# label: ...
# dtype: ...

# Make one 'inputs' list entry per input and one 'outputs' list entry per output.
# Keys include:
# * label (an identifier for the GUI)
# * domain (optional - stream or message. Default is stream)
# * dtype (e.g. int, float, complex, byte, short, xxx_vector, ...)
# * vlen (optional - data stream vector length. Default is 1)
# * optional (optional - set to 1 for optional inputs. Default is 0)
inputs:
#- label: ...
# domain: ...
# dtype: ...
# vlen: ...
# optional: ...

outputs:
#- label: ...
# domain: ...
# dtype: ...
# vlen: ...
# optional: ...

# 'file_format' specifies the version of the GRC yml format used in the file
# and should usually not be changed.
file_format: 1
</source>
{{boîte déroulante/fin}}

{{Todos| Mettre à jour la section <code>parameters</code> (pas de paramètres, on commente) :}}

<source lang=yaml>
#parameters:
#- id: parametername_replace_me
# label: FIX ME:
# dtype: string
# default: You need to fill in your grc/customModule_testMod.block.yaml
</source>

{{Todos| Mettre à jour la section <code>inputs</code> :}}

<source lang=yaml>
inputs:
- label: in
domain: stream
dtype: float
</source>

{{Todos| Mettre à jour la section <code>output</code> :}}

<source lang=yaml>
outputs:
- label: out
domain: stream
dtype: float
</source>

==== Compilation et installation ====

Voici les étapes :
<source lang=bash>
$ cd CHEMIN-DE-VOTRE-DOSSIER/gr-monModule
$ mkdir build
$ cd build
$ cmake ..
$ make
$ make install
</source>

* <code>cmake ..</code> lance la création des fichiers <code>Makefile</code> qui permettent la compilation et l'installation
* <code>make</code> lance la compilation
* <code>make install</code> lance l'installation (copie des fichiers dans les dossiers gnuradio)

{{Todos| Exécuter chacune de ces lignes, en contrôlant l'absence d'erreur. Dans le cas contraire, contrôler les fichiers <code>.h</code>, <code>.cc</code> et <code>.yaml</code>}}

{{Todos| '''Après ces étapes, et avant de lancer gnuRadio, appeler l'enseignant qui va mettre à jours les bibliothèques partagées.'''}}. Sinon tenter :
<source>
$ export LD_LIBRARY_PATH=/usr/local/lib/x86_64-linux-gnu:$LD_LIBRARY_PATH
$ gnuradio-companion &
</source>

==== Utilisation du bloc et test ====

* Dans Gnuradio, rafraichir la liste des bloc (bouton ''reload'')
* le bloc <code>passetout</code> doit être présent dans la section <code>monModule</code>
* Tester le bon fonctionnement de ce bloc en lui envoyant une sinusoïde que vous devez observer identique à la sortie du bloc. Vérifier avec des graphes.

==== Application : démodulation ====

En reprenant le signal modulé en amplitude et la fonction de transfert du filtre passe-bas du TP précédent :

* Obtenir l'équation aux différence du filtre, ''ie'' écrire ''y(n)='' en fonction de ''x(n)'', ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.
* Créer un nouveau bloc C++ (similaire au passe-tout précédent) dans le module <code>monModule</code> :
** de type <code>sync</code>
** une entrée en <code>float</code>
** une sortie en <code>float</code>
* Écrire le code permettant d'obtenir ''y(n)'' dans la méthode <code>work()</code> :
** ''x(n)'' est donné par <code>in0[0]</code>
** il sera nécessaire d'affecter <code>out0[0]</code> pour produire ''y(n)''.
** il sera nécessaire de stocker dans des '''attributs''' les valeurs de <code>in[0]</code> afin de disposer de ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.
** On rappelle que les attributs doivent être déclarées dans le fichier <code>.h</code> et initialisés dans le constructeur de la classe.

{{Todos| Réaliser cette implémentation du passe-bas et contrôler que la démodulation est identique à celle obtenue au TP précédent}}

{{Todos| Modifier votre code pour implémenter le filtre complet de démodulation}}

=== Approximation de PID par filtre numérique linéaire ===

==== Rappels PID ====

* Principe

[[Fichier:PIDprincipe.png|400px]]

[[Fichier:PIDdetail.png|400px]]

* Définition mathématique, la sortie du controleur PID ''u(t)'' est donnée par:

[[Fichier:EqPID.png|400px]]

==== PID numérique "classique" ====

On considère que le temps est discrétisé : ''t = n.dt'' où ''dt'' est l'intervalle de temps entre deux valeurs.

* En approximant grossièrement l'intégrale et la dérivée [[Fichier:PIDderivative.png|400px]] [[Fichier:PIDintegral.png|400px]]
** La dérivée est calculée par ''D = (e(n)-e(n-1))/dt''
** L'intégrale est approximée en cumulant progressivement : ''I = I + e(n).dt''

* Notebook exemple : asservissement de température
** ''Ki = Kd = 0'' => chercher le meilleur ''Kp'' => erreur de régime permanent
** ''Kd = 0'' => l'introduction du terme integral permet de corriger cette erreur de régime permanent
** Le terme dérivatif n'est pas nécessaire dans cet exemple car la température ne dépend que de la commande.

==== PID numérique par approximation d'un filtre continu ====

* Fonction de transfert Filtre continu d'un PID

[[Fichier:EqPID.png|500px]]

[[Fichier:eqFxTransfertPID.png|200]]

[[Fichier:eqFxTransfertPIDetPB.png|130]]

* Approximation de la fonction de transfert pour obtenir un filtre numérique
** ''backward euler''
** et transformée bilinéaire

* Implémentation du Filtre : classe <code>FilterController</code>
* Application sur l'asservissement d'altitude d'un drone

Cours:Elen4 TNS TP TpsReel

2026-05-29T13:06:59Z

Fredmn : /* PID numérique "classique" */

[[Cours:Elen4_TNS|{{Rouge|'''Retour à la page du cours'''}}]]

<center>
'''<big>TP6 : Temps réel : Codage d'un bloc en Python / démodulation / PID Numérique</big>'''
</center>

Le but de ce TP est double :
* réaliser des implémentations temps réel de filtre IIR en créant un bloc Gnuradio qui execute un traitement codé en Python
* et étudier l'implémentation d'un PID numérique sous forme d'un filtre IIR.

=== Codage de bloc Gnuradio en Python ===

'''EN COURS DE RÉÉCRITURE (C++ vers Python)'''

Ce guide est inspirée du guide [https://wiki.gnuradio.org/index.php?title=Creating_C%2B%2B_OOT_with_gr-modtool Creating an OOT (C++ block example)] en l'adaptant pour nos besoins :

Nous allons créer un simple bloc qui recopie son entrée (en <code>float</code>) sur sa sortie. Donc le filtre caractérisé par ''y(n)'' = ''x(n)'' ou encore ''H(z)''=1. Il s'agit donc d'une sorte de filtre passe-tout.

'''Suivez bien toutes les étapes, sans aller trop rapidement'''

* Vous pourrez utiliser <code>gedit</code> pour éditer les divers fichiers.

==== Création d'un module externe ====

Dans les lignes qui suivent, le <code>$</code> indique que l'on saisi une commande dans un terminal. Le <code>$</code> n'est pas à saisir.

* Ouvrez un terminal et placez-vous à la racine de votre dossier personnel :
<source>
$ cd $HOME
</source>
* Créez un dossier de travail dédié à gnuradio et déplacez-vous à l'intérieur :
<source>
$ mkdir gnuradio
$ cd gnuradio
</source>
* GNU Radio est livré avec gr_modtool, un utilitaire qui permet de créer des modules externes (OOT). Créons un module <code>monModule</code>
<source>
$ gr_modtool newmod monModule
</source>
* Le dossier <code>gr-monModule</code> est créé et contient tout le code squelette d'un module OOT, mais il n'a pas encore de blocs. Déplacez-vous dans <code>gr-monModule</code> :
<source>
$ cd gr-monModule
</source>
* Vous pouvez afficher le contenu de ce dossier par
<source>
$ ls
</source>

==== Création d'un bloc dans ce module ====

* Ajoutez un nouveau bloc nommé <code>passetout</code> :
<source>
$ gr_modtool add passetout
</source>
* Quelques questions permettent alors de spécifier le type de bloc
<source>
GNU Radio module name identified: passetout
('sink', 'source', 'sync', 'decimator', 'interpolator', 'general', 'tagged_stream', 'hier', 'noblock')
</source>
Saisissez <code>sync</code> comme type de bloc, car le bloc que nous écrivons produira le même nombre d'échantillons en sortie que le nombre d'échantillons consommés depuis l'entrée.
<source>
Enter block type: sync
</source>
* Spécifiez <code>cpp</code> comme langage :
<source>
Language (python/cpp): cpp
Language: C++
Block/code identifier: passetout
</source>
* Spécifiez un nom pour le copyright :
<source>
Please specify the copyright holder: Bibi
</source>
* Il est possible de spécifier des paramètres d'entrée qui peuvent permettre de régler le fonctionnement du bloc. Ce ne sera pas notre cas, ne rien saisir sur cette question :
<source>
Enter valid argument list, including default arguments:
</source>
* De même, on ne donnera pas de code permettant de tester le bon fonctionnement :
<source>
Add Python QA code? [Y/n] n
Add C++ QA code? [Y/n] n
</source>
* Plusieurs fichers sont alors crées :
<source>
Adding file 'lib/passetout_impl.h'...
Adding file 'lib/passetout_impl.cc'...
Adding file 'include/gnuradio/monModule/passetout.h'...
Adding file 'python/monModule/bindings/docstrings/passetout_pydoc_template.h'...
Adding file 'python/monModule/bindings/passetout_python.cc'...
Adding file 'grc/monModule_passetout.block.yml'...
Editing grc/CMakeLists.txt...
</source>

Quelques indications :
* le fichier <code>passetout_impl.h</code> contient l'entête de la classe de notre bloc
* le fichier <code>passetout_impl.cc</code> contient l'implémentation de la classe de notre bloc
* le fichier <code>monModule_passetout.block.yml</code> va contenir des informations faisant le lien entre notre code c++ et le code python utilisé en interne par Gnuradio
* Le tout sera compilé par un <code>Makefile</code> généré par <code>cmake</code>.

==== Fichier <code>passetout_impl.h</code> ====

Le code utile généré est le suivant :
<source lang=cpp>
class passetout_impl : public passetout
{
private:
// Nothing to declare in this block.

public:
passetout_impl();
~passetout_impl();

// Where all the action really happens
int work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items);
};
</source>

Pour se réveiller les neurones sur la POO, qu'est-ce que sont
* <code>passetout_impl()</code>,
* <code>~passetout_impl()</code>,
* <code>private</code>, <code>public</code> ?

Le travail sera réalisé dans la méthode <code>work()</code>, mais nous n'avons pas de modification à apporter dans les déclarations par défaut.

==== Fichier <code>passetout_impl.cc</code> ====

Le code utile généré est le suivant :

{{boîte déroulante/début|titre=passetout_impl.cc}}
<source lang=cpp>
namespace monModule {

#pragma message("set the following appropriately and remove this warning")
using input_type = float;
#pragma message("set the following appropriately and remove this warning")
using output_type = float;
passetout::sptr passetout::make() { return gnuradio::make_block_sptr<passetout_impl>(); }

/*
* The private constructor
*/
passetout_impl::passetout_impl()
: gr::sync_block("passetout",
gr::io_signature::make(
1 /* min inputs */, 1 /* max inputs */, sizeof(input_type)),
gr::io_signature::make(
1 /* min outputs */, 1 /*max outputs */, sizeof(output_type)))
{
}

/*
* Our virtual destructor.
*/
passetout_impl::~passetout_impl() {}

int passetout_impl::work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items)
{
auto in = static_cast<const input_type*>(input_items[0]);
auto out = static_cast<output_type*>(output_items[0]);

#pragma message("Implement the signal processing in your block and remove this warning")
// Do <+signal processing+>

// Tell runtime system how many output items we produced.
return noutput_items;
}

} /* namespace monModule */
</source>
{{boîte déroulante/fin}}

Détaillons :
<source lang=cpp>
#pragma message("set the following appropriately and remove this warning")
using input_type = float;
#pragma message("set the following appropriately and remove this warning")
using output_type = float;
</source>
{{Todos| On spécifie ici le type des données d'entrée et de sortie. Pas de modification à apporter, il suffit de supprimer les deux <code>#pragma</code>}}

<source lang=cpp>
passetout_impl::passetout_impl()
: gr::sync_block("passetout",
gr::io_signature::make(
1 /* min inputs */, 1 /* max inputs */, sizeof(input_type)),
gr::io_signature::make(
1 /* min outputs */, 1 /*max outputs */, sizeof(output_type)))
{
}
</source>

{{Todos| On spécifie ici le nombre d'entrées (1) et le nombre de sorties (1). Pas de modification non plus.}}

{{Todos| Expliquez la syntaxe <code>passetout_impl::passetout_impl() : gr::sync_block(...)"</code> }}

<source lang=cpp>
int passetout_impl::work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items)
{
auto in = static_cast<const input_type*>(input_items[0]);
auto out = static_cast<output_type*>(output_items[0]);

#pragma message("Implement the signal processing in your block and remove this warning")
// Do <+signal processing+>

// Tell runtime system how many output items we produced.
return noutput_items;
}
</source>
Cette méthode <code>work()</code> implémente véritablement le filtrage.
* Les tableaux <code>in</code> et <code>out</code> contiennent respectivement les données en entrée et les données en sortie. Il faut donc calculer <code>out</code> en fonction de <code>in</code>
* Les données d'entrée arrivent par paquets dans un buffer. La variable <code>noutput_items</code> contient le nombre de données disponibles en entrées.
* à la fin de la méthode, on renvoie le nombre de données en sortie que l'on a calculé (entre 1 et <code>noutput_items</code>). Les données d'entrées éventuellement non consommées seront conservées dans le buffer pour le prochain appel de <code>work()</code>
{{Todos| On souhaite ici seulement recopier l'entrée sur la sortie, donc }}
# Enlever la ligne <code>#pragma</code>
# ajouter le code <code> out[0] = in[0];</code> (on recopie le premier échantillon disponible en entrée)
# changer <code>return noutput_items;</code> en <code>return 1;</code> (un seul échantillon a été consommé).

==== Fichier <code>monModule_passetout.block.yml</code> ====

Ce fichier au format YAML (''yet another markup language'') fait le lien entre le code c++ et le code python utilisé en interne par GnuRadio.

{{boîte déroulante/début|titre=monModule_passetout.block.yml}}
<source lang=yaml>
id: monModule_passetout
label: passetout
category: '[monModule]'

templates:
imports: from gnuradio import monModule
make: monModule.passetout()

# Make one 'parameters' list entry for every parameter you want settable from the GUI.
# Keys include:
# * id (makes the value accessible as keyname, e.g. in the make entry)
# * label (label shown in the GUI)
# * dtype (e.g. int, float, complex, byte, short, xxx_vector, ...)
# * default
parameters:
- id: parametername_replace_me
label: FIX ME:
dtype: string
default: You need to fill in your grc/monModule_passetout.block.yaml
#- id: ...
# label: ...
# dtype: ...

# Make one 'inputs' list entry per input and one 'outputs' list entry per output.
# Keys include:
# * label (an identifier for the GUI)
# * domain (optional - stream or message. Default is stream)
# * dtype (e.g. int, float, complex, byte, short, xxx_vector, ...)
# * vlen (optional - data stream vector length. Default is 1)
# * optional (optional - set to 1 for optional inputs. Default is 0)
inputs:
#- label: ...
# domain: ...
# dtype: ...
# vlen: ...
# optional: ...

outputs:
#- label: ...
# domain: ...
# dtype: ...
# vlen: ...
# optional: ...

# 'file_format' specifies the version of the GRC yml format used in the file
# and should usually not be changed.
file_format: 1
</source>
{{boîte déroulante/fin}}

{{Todos| Mettre à jour la section <code>parameters</code> (pas de paramètres, on commente) :}}

<source lang=yaml>
#parameters:
#- id: parametername_replace_me
# label: FIX ME:
# dtype: string
# default: You need to fill in your grc/customModule_testMod.block.yaml
</source>

{{Todos| Mettre à jour la section <code>inputs</code> :}}

<source lang=yaml>
inputs:
- label: in
domain: stream
dtype: float
</source>

{{Todos| Mettre à jour la section <code>output</code> :}}

<source lang=yaml>
outputs:
- label: out
domain: stream
dtype: float
</source>

==== Compilation et installation ====

Voici les étapes :
<source lang=bash>
$ cd CHEMIN-DE-VOTRE-DOSSIER/gr-monModule
$ mkdir build
$ cd build
$ cmake ..
$ make
$ make install
</source>

* <code>cmake ..</code> lance la création des fichiers <code>Makefile</code> qui permettent la compilation et l'installation
* <code>make</code> lance la compilation
* <code>make install</code> lance l'installation (copie des fichiers dans les dossiers gnuradio)

{{Todos| Exécuter chacune de ces lignes, en contrôlant l'absence d'erreur. Dans le cas contraire, contrôler les fichiers <code>.h</code>, <code>.cc</code> et <code>.yaml</code>}}

{{Todos| '''Après ces étapes, et avant de lancer gnuRadio, appeler l'enseignant qui va mettre à jours les bibliothèques partagées.'''}}. Sinon tenter :
<source>
$ export LD_LIBRARY_PATH=/usr/local/lib/x86_64-linux-gnu:$LD_LIBRARY_PATH
$ gnuradio-companion &
</source>

==== Utilisation du bloc et test ====

* Dans Gnuradio, rafraichir la liste des bloc (bouton ''reload'')
* le bloc <code>passetout</code> doit être présent dans la section <code>monModule</code>
* Tester le bon fonctionnement de ce bloc en lui envoyant une sinusoïde que vous devez observer identique à la sortie du bloc. Vérifier avec des graphes.

==== Application : démodulation ====

En reprenant le signal modulé en amplitude et la fonction de transfert du filtre passe-bas du TP précédent :

* Obtenir l'équation aux différence du filtre, ''ie'' écrire ''y(n)='' en fonction de ''x(n)'', ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.
* Créer un nouveau bloc C++ (similaire au passe-tout précédent) dans le module <code>monModule</code> :
** de type <code>sync</code>
** une entrée en <code>float</code>
** une sortie en <code>float</code>
* Écrire le code permettant d'obtenir ''y(n)'' dans la méthode <code>work()</code> :
** ''x(n)'' est donné par <code>in0[0]</code>
** il sera nécessaire d'affecter <code>out0[0]</code> pour produire ''y(n)''.
** il sera nécessaire de stocker dans des '''attributs''' les valeurs de <code>in[0]</code> afin de disposer de ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.
** On rappelle que les attributs doivent être déclarées dans le fichier <code>.h</code> et initialisés dans le constructeur de la classe.

{{Todos| Réaliser cette implémentation du passe-bas et contrôler que la démodulation est identique à celle obtenue au TP précédent}}

{{Todos| Modifier votre code pour implémenter le filtre complet de démodulation}}

=== Approximation de PID par filtre numérique linéaire ===

==== Rappels PID ====

* Principe

[[Fichier:PIDprincipe.png|400px]]

[[Fichier:PIDdetail.png|400px]]

* Définition mathématique, la sortie du controleur PID ''u(t)'' est donnée par:

[[Fichier:EqPID.png|400px]]

==== PID numérique "classique" ====

On considère que le temps est discrétisé : ''t = n.dt'' où ''dt'' est l'intervalle de temps entre deux valeurs.

* En approximant grossièrement l'intégrale et la dérivée [[Fichier:PIDderivative.png|400px]] [[Fichier:PIDintegral.png|400px]]
** La dérivée est calculée par ''D = (e(n)-e(n-1))/dt''
** L'intégrale est approximée en cumulant progressivement : ''I = I + e(n).dt''

* Notebook exemple : asservissement de température

==== PID numérique par approximation d'un filtre continu ====

* Fonction de transfert Filtre continu d'un PID

[[Fichier:EqPID.png|500px]]

[[Fichier:eqFxTransfertPID.png|200]]

[[Fichier:eqFxTransfertPIDetPB.png|130]]

* Approximation de la fonction de transfert pour obtenir un filtre numérique
** ''backward euler''
** et transformée bilinéaire

* Implémentation du Filtre : classe <code>FilterController</code>
* Application sur l'asservissement d'altitude d'un drone

Cours:Elen4 TNS TP TpsReel

2026-05-29T13:06:25Z

Fredmn : /* PID numérique "classique" */

[[Cours:Elen4_TNS|{{Rouge|'''Retour à la page du cours'''}}]]

<center>
'''<big>TP6 : Temps réel : Codage d'un bloc en Python / démodulation / PID Numérique</big>'''
</center>

Le but de ce TP est double :
* réaliser des implémentations temps réel de filtre IIR en créant un bloc Gnuradio qui execute un traitement codé en Python
* et étudier l'implémentation d'un PID numérique sous forme d'un filtre IIR.

=== Codage de bloc Gnuradio en Python ===

'''EN COURS DE RÉÉCRITURE (C++ vers Python)'''

Ce guide est inspirée du guide [https://wiki.gnuradio.org/index.php?title=Creating_C%2B%2B_OOT_with_gr-modtool Creating an OOT (C++ block example)] en l'adaptant pour nos besoins :

Nous allons créer un simple bloc qui recopie son entrée (en <code>float</code>) sur sa sortie. Donc le filtre caractérisé par ''y(n)'' = ''x(n)'' ou encore ''H(z)''=1. Il s'agit donc d'une sorte de filtre passe-tout.

'''Suivez bien toutes les étapes, sans aller trop rapidement'''

* Vous pourrez utiliser <code>gedit</code> pour éditer les divers fichiers.

==== Création d'un module externe ====

Dans les lignes qui suivent, le <code>$</code> indique que l'on saisi une commande dans un terminal. Le <code>$</code> n'est pas à saisir.

* Ouvrez un terminal et placez-vous à la racine de votre dossier personnel :
<source>
$ cd $HOME
</source>
* Créez un dossier de travail dédié à gnuradio et déplacez-vous à l'intérieur :
<source>
$ mkdir gnuradio
$ cd gnuradio
</source>
* GNU Radio est livré avec gr_modtool, un utilitaire qui permet de créer des modules externes (OOT). Créons un module <code>monModule</code>
<source>
$ gr_modtool newmod monModule
</source>
* Le dossier <code>gr-monModule</code> est créé et contient tout le code squelette d'un module OOT, mais il n'a pas encore de blocs. Déplacez-vous dans <code>gr-monModule</code> :
<source>
$ cd gr-monModule
</source>
* Vous pouvez afficher le contenu de ce dossier par
<source>
$ ls
</source>

==== Création d'un bloc dans ce module ====

* Ajoutez un nouveau bloc nommé <code>passetout</code> :
<source>
$ gr_modtool add passetout
</source>
* Quelques questions permettent alors de spécifier le type de bloc
<source>
GNU Radio module name identified: passetout
('sink', 'source', 'sync', 'decimator', 'interpolator', 'general', 'tagged_stream', 'hier', 'noblock')
</source>
Saisissez <code>sync</code> comme type de bloc, car le bloc que nous écrivons produira le même nombre d'échantillons en sortie que le nombre d'échantillons consommés depuis l'entrée.
<source>
Enter block type: sync
</source>
* Spécifiez <code>cpp</code> comme langage :
<source>
Language (python/cpp): cpp
Language: C++
Block/code identifier: passetout
</source>
* Spécifiez un nom pour le copyright :
<source>
Please specify the copyright holder: Bibi
</source>
* Il est possible de spécifier des paramètres d'entrée qui peuvent permettre de régler le fonctionnement du bloc. Ce ne sera pas notre cas, ne rien saisir sur cette question :
<source>
Enter valid argument list, including default arguments:
</source>
* De même, on ne donnera pas de code permettant de tester le bon fonctionnement :
<source>
Add Python QA code? [Y/n] n
Add C++ QA code? [Y/n] n
</source>
* Plusieurs fichers sont alors crées :
<source>
Adding file 'lib/passetout_impl.h'...
Adding file 'lib/passetout_impl.cc'...
Adding file 'include/gnuradio/monModule/passetout.h'...
Adding file 'python/monModule/bindings/docstrings/passetout_pydoc_template.h'...
Adding file 'python/monModule/bindings/passetout_python.cc'...
Adding file 'grc/monModule_passetout.block.yml'...
Editing grc/CMakeLists.txt...
</source>

Quelques indications :
* le fichier <code>passetout_impl.h</code> contient l'entête de la classe de notre bloc
* le fichier <code>passetout_impl.cc</code> contient l'implémentation de la classe de notre bloc
* le fichier <code>monModule_passetout.block.yml</code> va contenir des informations faisant le lien entre notre code c++ et le code python utilisé en interne par Gnuradio
* Le tout sera compilé par un <code>Makefile</code> généré par <code>cmake</code>.

==== Fichier <code>passetout_impl.h</code> ====

Le code utile généré est le suivant :
<source lang=cpp>
class passetout_impl : public passetout
{
private:
// Nothing to declare in this block.

public:
passetout_impl();
~passetout_impl();

// Where all the action really happens
int work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items);
};
</source>

Pour se réveiller les neurones sur la POO, qu'est-ce que sont
* <code>passetout_impl()</code>,
* <code>~passetout_impl()</code>,
* <code>private</code>, <code>public</code> ?

Le travail sera réalisé dans la méthode <code>work()</code>, mais nous n'avons pas de modification à apporter dans les déclarations par défaut.

==== Fichier <code>passetout_impl.cc</code> ====

Le code utile généré est le suivant :

{{boîte déroulante/début|titre=passetout_impl.cc}}
<source lang=cpp>
namespace monModule {

#pragma message("set the following appropriately and remove this warning")
using input_type = float;
#pragma message("set the following appropriately and remove this warning")
using output_type = float;
passetout::sptr passetout::make() { return gnuradio::make_block_sptr<passetout_impl>(); }

/*
* The private constructor
*/
passetout_impl::passetout_impl()
: gr::sync_block("passetout",
gr::io_signature::make(
1 /* min inputs */, 1 /* max inputs */, sizeof(input_type)),
gr::io_signature::make(
1 /* min outputs */, 1 /*max outputs */, sizeof(output_type)))
{
}

/*
* Our virtual destructor.
*/
passetout_impl::~passetout_impl() {}

int passetout_impl::work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items)
{
auto in = static_cast<const input_type*>(input_items[0]);
auto out = static_cast<output_type*>(output_items[0]);

#pragma message("Implement the signal processing in your block and remove this warning")
// Do <+signal processing+>

// Tell runtime system how many output items we produced.
return noutput_items;
}

} /* namespace monModule */
</source>
{{boîte déroulante/fin}}

Détaillons :
<source lang=cpp>
#pragma message("set the following appropriately and remove this warning")
using input_type = float;
#pragma message("set the following appropriately and remove this warning")
using output_type = float;
</source>
{{Todos| On spécifie ici le type des données d'entrée et de sortie. Pas de modification à apporter, il suffit de supprimer les deux <code>#pragma</code>}}

<source lang=cpp>
passetout_impl::passetout_impl()
: gr::sync_block("passetout",
gr::io_signature::make(
1 /* min inputs */, 1 /* max inputs */, sizeof(input_type)),
gr::io_signature::make(
1 /* min outputs */, 1 /*max outputs */, sizeof(output_type)))
{
}
</source>

{{Todos| On spécifie ici le nombre d'entrées (1) et le nombre de sorties (1). Pas de modification non plus.}}

{{Todos| Expliquez la syntaxe <code>passetout_impl::passetout_impl() : gr::sync_block(...)"</code> }}

<source lang=cpp>
int passetout_impl::work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items)
{
auto in = static_cast<const input_type*>(input_items[0]);
auto out = static_cast<output_type*>(output_items[0]);

#pragma message("Implement the signal processing in your block and remove this warning")
// Do <+signal processing+>

// Tell runtime system how many output items we produced.
return noutput_items;
}
</source>
Cette méthode <code>work()</code> implémente véritablement le filtrage.
* Les tableaux <code>in</code> et <code>out</code> contiennent respectivement les données en entrée et les données en sortie. Il faut donc calculer <code>out</code> en fonction de <code>in</code>
* Les données d'entrée arrivent par paquets dans un buffer. La variable <code>noutput_items</code> contient le nombre de données disponibles en entrées.
* à la fin de la méthode, on renvoie le nombre de données en sortie que l'on a calculé (entre 1 et <code>noutput_items</code>). Les données d'entrées éventuellement non consommées seront conservées dans le buffer pour le prochain appel de <code>work()</code>
{{Todos| On souhaite ici seulement recopier l'entrée sur la sortie, donc }}
# Enlever la ligne <code>#pragma</code>
# ajouter le code <code> out[0] = in[0];</code> (on recopie le premier échantillon disponible en entrée)
# changer <code>return noutput_items;</code> en <code>return 1;</code> (un seul échantillon a été consommé).

==== Fichier <code>monModule_passetout.block.yml</code> ====

Ce fichier au format YAML (''yet another markup language'') fait le lien entre le code c++ et le code python utilisé en interne par GnuRadio.

{{boîte déroulante/début|titre=monModule_passetout.block.yml}}
<source lang=yaml>
id: monModule_passetout
label: passetout
category: '[monModule]'

templates:
imports: from gnuradio import monModule
make: monModule.passetout()

# Make one 'parameters' list entry for every parameter you want settable from the GUI.
# Keys include:
# * id (makes the value accessible as keyname, e.g. in the make entry)
# * label (label shown in the GUI)
# * dtype (e.g. int, float, complex, byte, short, xxx_vector, ...)
# * default
parameters:
- id: parametername_replace_me
label: FIX ME:
dtype: string
default: You need to fill in your grc/monModule_passetout.block.yaml
#- id: ...
# label: ...
# dtype: ...

# Make one 'inputs' list entry per input and one 'outputs' list entry per output.
# Keys include:
# * label (an identifier for the GUI)
# * domain (optional - stream or message. Default is stream)
# * dtype (e.g. int, float, complex, byte, short, xxx_vector, ...)
# * vlen (optional - data stream vector length. Default is 1)
# * optional (optional - set to 1 for optional inputs. Default is 0)
inputs:
#- label: ...
# domain: ...
# dtype: ...
# vlen: ...
# optional: ...

outputs:
#- label: ...
# domain: ...
# dtype: ...
# vlen: ...
# optional: ...

# 'file_format' specifies the version of the GRC yml format used in the file
# and should usually not be changed.
file_format: 1
</source>
{{boîte déroulante/fin}}

{{Todos| Mettre à jour la section <code>parameters</code> (pas de paramètres, on commente) :}}

<source lang=yaml>
#parameters:
#- id: parametername_replace_me
# label: FIX ME:
# dtype: string
# default: You need to fill in your grc/customModule_testMod.block.yaml
</source>

{{Todos| Mettre à jour la section <code>inputs</code> :}}

<source lang=yaml>
inputs:
- label: in
domain: stream
dtype: float
</source>

{{Todos| Mettre à jour la section <code>output</code> :}}

<source lang=yaml>
outputs:
- label: out
domain: stream
dtype: float
</source>

==== Compilation et installation ====

Voici les étapes :
<source lang=bash>
$ cd CHEMIN-DE-VOTRE-DOSSIER/gr-monModule
$ mkdir build
$ cd build
$ cmake ..
$ make
$ make install
</source>

* <code>cmake ..</code> lance la création des fichiers <code>Makefile</code> qui permettent la compilation et l'installation
* <code>make</code> lance la compilation
* <code>make install</code> lance l'installation (copie des fichiers dans les dossiers gnuradio)

{{Todos| Exécuter chacune de ces lignes, en contrôlant l'absence d'erreur. Dans le cas contraire, contrôler les fichiers <code>.h</code>, <code>.cc</code> et <code>.yaml</code>}}

{{Todos| '''Après ces étapes, et avant de lancer gnuRadio, appeler l'enseignant qui va mettre à jours les bibliothèques partagées.'''}}. Sinon tenter :
<source>
$ export LD_LIBRARY_PATH=/usr/local/lib/x86_64-linux-gnu:$LD_LIBRARY_PATH
$ gnuradio-companion &
</source>

==== Utilisation du bloc et test ====

* Dans Gnuradio, rafraichir la liste des bloc (bouton ''reload'')
* le bloc <code>passetout</code> doit être présent dans la section <code>monModule</code>
* Tester le bon fonctionnement de ce bloc en lui envoyant une sinusoïde que vous devez observer identique à la sortie du bloc. Vérifier avec des graphes.

==== Application : démodulation ====

En reprenant le signal modulé en amplitude et la fonction de transfert du filtre passe-bas du TP précédent :

* Obtenir l'équation aux différence du filtre, ''ie'' écrire ''y(n)='' en fonction de ''x(n)'', ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.
* Créer un nouveau bloc C++ (similaire au passe-tout précédent) dans le module <code>monModule</code> :
** de type <code>sync</code>
** une entrée en <code>float</code>
** une sortie en <code>float</code>
* Écrire le code permettant d'obtenir ''y(n)'' dans la méthode <code>work()</code> :
** ''x(n)'' est donné par <code>in0[0]</code>
** il sera nécessaire d'affecter <code>out0[0]</code> pour produire ''y(n)''.
** il sera nécessaire de stocker dans des '''attributs''' les valeurs de <code>in[0]</code> afin de disposer de ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.
** On rappelle que les attributs doivent être déclarées dans le fichier <code>.h</code> et initialisés dans le constructeur de la classe.

{{Todos| Réaliser cette implémentation du passe-bas et contrôler que la démodulation est identique à celle obtenue au TP précédent}}

{{Todos| Modifier votre code pour implémenter le filtre complet de démodulation}}

=== Approximation de PID par filtre numérique linéaire ===

==== Rappels PID ====

* Principe

[[Fichier:PIDprincipe.png|400px]]

[[Fichier:PIDdetail.png|400px]]

* Définition mathématique, la sortie du controleur PID ''u(t)'' est donnée par:

[[Fichier:EqPID.png|400px]]

==== PID numérique "classique" ====

On considère que le temps est discrétisé : ''t = n.dt'' où ''dt'' est l'intervalle de temps entre deux valeurs.

* En approximant grossièrement l'intégrale et la dérivée
[[Fichier:PIDderivative.png|400px]] [[Fichier:PIDintegral.png|400px]]
** La dérivée est calculée par ''D = (e(n)-e(n-1))/dt''
** L'intégrale est approximée en cumulant progressivement : ''I = I + e(n).dt''

* Notebook exemple : asservissement de température

==== PID numérique par approximation d'un filtre continu ====

* Fonction de transfert Filtre continu d'un PID

[[Fichier:EqPID.png|500px]]

[[Fichier:eqFxTransfertPID.png|200]]

[[Fichier:eqFxTransfertPIDetPB.png|130]]

* Approximation de la fonction de transfert pour obtenir un filtre numérique
** ''backward euler''
** et transformée bilinéaire

* Implémentation du Filtre : classe <code>FilterController</code>
* Application sur l'asservissement d'altitude d'un drone

Cours:Elen4 TNS TP TpsReel

2026-05-29T12:50:25Z

Fredmn : /* Approximation de PID par filtre numérique linéaire */

[[Cours:Elen4_TNS|{{Rouge|'''Retour à la page du cours'''}}]]

<center>
'''<big>TP6 : Temps réel : Codage d'un bloc en Python / démodulation / PID Numérique</big>'''
</center>

Le but de ce TP est double :
* réaliser des implémentations temps réel de filtre IIR en créant un bloc Gnuradio qui execute un traitement codé en Python
* et étudier l'implémentation d'un PID numérique sous forme d'un filtre IIR.

=== Codage de bloc Gnuradio en Python ===

'''EN COURS DE RÉÉCRITURE (C++ vers Python)'''

Ce guide est inspirée du guide [https://wiki.gnuradio.org/index.php?title=Creating_C%2B%2B_OOT_with_gr-modtool Creating an OOT (C++ block example)] en l'adaptant pour nos besoins :

Nous allons créer un simple bloc qui recopie son entrée (en <code>float</code>) sur sa sortie. Donc le filtre caractérisé par ''y(n)'' = ''x(n)'' ou encore ''H(z)''=1. Il s'agit donc d'une sorte de filtre passe-tout.

'''Suivez bien toutes les étapes, sans aller trop rapidement'''

* Vous pourrez utiliser <code>gedit</code> pour éditer les divers fichiers.

==== Création d'un module externe ====

Dans les lignes qui suivent, le <code>$</code> indique que l'on saisi une commande dans un terminal. Le <code>$</code> n'est pas à saisir.

* Ouvrez un terminal et placez-vous à la racine de votre dossier personnel :
<source>
$ cd $HOME
</source>
* Créez un dossier de travail dédié à gnuradio et déplacez-vous à l'intérieur :
<source>
$ mkdir gnuradio
$ cd gnuradio
</source>
* GNU Radio est livré avec gr_modtool, un utilitaire qui permet de créer des modules externes (OOT). Créons un module <code>monModule</code>
<source>
$ gr_modtool newmod monModule
</source>
* Le dossier <code>gr-monModule</code> est créé et contient tout le code squelette d'un module OOT, mais il n'a pas encore de blocs. Déplacez-vous dans <code>gr-monModule</code> :
<source>
$ cd gr-monModule
</source>
* Vous pouvez afficher le contenu de ce dossier par
<source>
$ ls
</source>

==== Création d'un bloc dans ce module ====

* Ajoutez un nouveau bloc nommé <code>passetout</code> :
<source>
$ gr_modtool add passetout
</source>
* Quelques questions permettent alors de spécifier le type de bloc
<source>
GNU Radio module name identified: passetout
('sink', 'source', 'sync', 'decimator', 'interpolator', 'general', 'tagged_stream', 'hier', 'noblock')
</source>
Saisissez <code>sync</code> comme type de bloc, car le bloc que nous écrivons produira le même nombre d'échantillons en sortie que le nombre d'échantillons consommés depuis l'entrée.
<source>
Enter block type: sync
</source>
* Spécifiez <code>cpp</code> comme langage :
<source>
Language (python/cpp): cpp
Language: C++
Block/code identifier: passetout
</source>
* Spécifiez un nom pour le copyright :
<source>
Please specify the copyright holder: Bibi
</source>
* Il est possible de spécifier des paramètres d'entrée qui peuvent permettre de régler le fonctionnement du bloc. Ce ne sera pas notre cas, ne rien saisir sur cette question :
<source>
Enter valid argument list, including default arguments:
</source>
* De même, on ne donnera pas de code permettant de tester le bon fonctionnement :
<source>
Add Python QA code? [Y/n] n
Add C++ QA code? [Y/n] n
</source>
* Plusieurs fichers sont alors crées :
<source>
Adding file 'lib/passetout_impl.h'...
Adding file 'lib/passetout_impl.cc'...
Adding file 'include/gnuradio/monModule/passetout.h'...
Adding file 'python/monModule/bindings/docstrings/passetout_pydoc_template.h'...
Adding file 'python/monModule/bindings/passetout_python.cc'...
Adding file 'grc/monModule_passetout.block.yml'...
Editing grc/CMakeLists.txt...
</source>

Quelques indications :
* le fichier <code>passetout_impl.h</code> contient l'entête de la classe de notre bloc
* le fichier <code>passetout_impl.cc</code> contient l'implémentation de la classe de notre bloc
* le fichier <code>monModule_passetout.block.yml</code> va contenir des informations faisant le lien entre notre code c++ et le code python utilisé en interne par Gnuradio
* Le tout sera compilé par un <code>Makefile</code> généré par <code>cmake</code>.

==== Fichier <code>passetout_impl.h</code> ====

Le code utile généré est le suivant :
<source lang=cpp>
class passetout_impl : public passetout
{
private:
// Nothing to declare in this block.

public:
passetout_impl();
~passetout_impl();

// Where all the action really happens
int work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items);
};
</source>

Pour se réveiller les neurones sur la POO, qu'est-ce que sont
* <code>passetout_impl()</code>,
* <code>~passetout_impl()</code>,
* <code>private</code>, <code>public</code> ?

Le travail sera réalisé dans la méthode <code>work()</code>, mais nous n'avons pas de modification à apporter dans les déclarations par défaut.

==== Fichier <code>passetout_impl.cc</code> ====

Le code utile généré est le suivant :

{{boîte déroulante/début|titre=passetout_impl.cc}}
<source lang=cpp>
namespace monModule {

#pragma message("set the following appropriately and remove this warning")
using input_type = float;
#pragma message("set the following appropriately and remove this warning")
using output_type = float;
passetout::sptr passetout::make() { return gnuradio::make_block_sptr<passetout_impl>(); }

/*
* The private constructor
*/
passetout_impl::passetout_impl()
: gr::sync_block("passetout",
gr::io_signature::make(
1 /* min inputs */, 1 /* max inputs */, sizeof(input_type)),
gr::io_signature::make(
1 /* min outputs */, 1 /*max outputs */, sizeof(output_type)))
{
}

/*
* Our virtual destructor.
*/
passetout_impl::~passetout_impl() {}

int passetout_impl::work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items)
{
auto in = static_cast<const input_type*>(input_items[0]);
auto out = static_cast<output_type*>(output_items[0]);

#pragma message("Implement the signal processing in your block and remove this warning")
// Do <+signal processing+>

// Tell runtime system how many output items we produced.
return noutput_items;
}

} /* namespace monModule */
</source>
{{boîte déroulante/fin}}

Détaillons :
<source lang=cpp>
#pragma message("set the following appropriately and remove this warning")
using input_type = float;
#pragma message("set the following appropriately and remove this warning")
using output_type = float;
</source>
{{Todos| On spécifie ici le type des données d'entrée et de sortie. Pas de modification à apporter, il suffit de supprimer les deux <code>#pragma</code>}}

<source lang=cpp>
passetout_impl::passetout_impl()
: gr::sync_block("passetout",
gr::io_signature::make(
1 /* min inputs */, 1 /* max inputs */, sizeof(input_type)),
gr::io_signature::make(
1 /* min outputs */, 1 /*max outputs */, sizeof(output_type)))
{
}
</source>

{{Todos| On spécifie ici le nombre d'entrées (1) et le nombre de sorties (1). Pas de modification non plus.}}

{{Todos| Expliquez la syntaxe <code>passetout_impl::passetout_impl() : gr::sync_block(...)"</code> }}

<source lang=cpp>
int passetout_impl::work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items)
{
auto in = static_cast<const input_type*>(input_items[0]);
auto out = static_cast<output_type*>(output_items[0]);

#pragma message("Implement the signal processing in your block and remove this warning")
// Do <+signal processing+>

// Tell runtime system how many output items we produced.
return noutput_items;
}
</source>
Cette méthode <code>work()</code> implémente véritablement le filtrage.
* Les tableaux <code>in</code> et <code>out</code> contiennent respectivement les données en entrée et les données en sortie. Il faut donc calculer <code>out</code> en fonction de <code>in</code>
* Les données d'entrée arrivent par paquets dans un buffer. La variable <code>noutput_items</code> contient le nombre de données disponibles en entrées.
* à la fin de la méthode, on renvoie le nombre de données en sortie que l'on a calculé (entre 1 et <code>noutput_items</code>). Les données d'entrées éventuellement non consommées seront conservées dans le buffer pour le prochain appel de <code>work()</code>
{{Todos| On souhaite ici seulement recopier l'entrée sur la sortie, donc }}
# Enlever la ligne <code>#pragma</code>
# ajouter le code <code> out[0] = in[0];</code> (on recopie le premier échantillon disponible en entrée)
# changer <code>return noutput_items;</code> en <code>return 1;</code> (un seul échantillon a été consommé).

==== Fichier <code>monModule_passetout.block.yml</code> ====

Ce fichier au format YAML (''yet another markup language'') fait le lien entre le code c++ et le code python utilisé en interne par GnuRadio.

{{boîte déroulante/début|titre=monModule_passetout.block.yml}}
<source lang=yaml>
id: monModule_passetout
label: passetout
category: '[monModule]'

templates:
imports: from gnuradio import monModule
make: monModule.passetout()

# Make one 'parameters' list entry for every parameter you want settable from the GUI.
# Keys include:
# * id (makes the value accessible as keyname, e.g. in the make entry)
# * label (label shown in the GUI)
# * dtype (e.g. int, float, complex, byte, short, xxx_vector, ...)
# * default
parameters:
- id: parametername_replace_me
label: FIX ME:
dtype: string
default: You need to fill in your grc/monModule_passetout.block.yaml
#- id: ...
# label: ...
# dtype: ...

# Make one 'inputs' list entry per input and one 'outputs' list entry per output.
# Keys include:
# * label (an identifier for the GUI)
# * domain (optional - stream or message. Default is stream)
# * dtype (e.g. int, float, complex, byte, short, xxx_vector, ...)
# * vlen (optional - data stream vector length. Default is 1)
# * optional (optional - set to 1 for optional inputs. Default is 0)
inputs:
#- label: ...
# domain: ...
# dtype: ...
# vlen: ...
# optional: ...

outputs:
#- label: ...
# domain: ...
# dtype: ...
# vlen: ...
# optional: ...

# 'file_format' specifies the version of the GRC yml format used in the file
# and should usually not be changed.
file_format: 1
</source>
{{boîte déroulante/fin}}

{{Todos| Mettre à jour la section <code>parameters</code> (pas de paramètres, on commente) :}}

<source lang=yaml>
#parameters:
#- id: parametername_replace_me
# label: FIX ME:
# dtype: string
# default: You need to fill in your grc/customModule_testMod.block.yaml
</source>

{{Todos| Mettre à jour la section <code>inputs</code> :}}

<source lang=yaml>
inputs:
- label: in
domain: stream
dtype: float
</source>

{{Todos| Mettre à jour la section <code>output</code> :}}

<source lang=yaml>
outputs:
- label: out
domain: stream
dtype: float
</source>

==== Compilation et installation ====

Voici les étapes :
<source lang=bash>
$ cd CHEMIN-DE-VOTRE-DOSSIER/gr-monModule
$ mkdir build
$ cd build
$ cmake ..
$ make
$ make install
</source>

* <code>cmake ..</code> lance la création des fichiers <code>Makefile</code> qui permettent la compilation et l'installation
* <code>make</code> lance la compilation
* <code>make install</code> lance l'installation (copie des fichiers dans les dossiers gnuradio)

{{Todos| Exécuter chacune de ces lignes, en contrôlant l'absence d'erreur. Dans le cas contraire, contrôler les fichiers <code>.h</code>, <code>.cc</code> et <code>.yaml</code>}}

{{Todos| '''Après ces étapes, et avant de lancer gnuRadio, appeler l'enseignant qui va mettre à jours les bibliothèques partagées.'''}}. Sinon tenter :
<source>
$ export LD_LIBRARY_PATH=/usr/local/lib/x86_64-linux-gnu:$LD_LIBRARY_PATH
$ gnuradio-companion &
</source>

==== Utilisation du bloc et test ====

* Dans Gnuradio, rafraichir la liste des bloc (bouton ''reload'')
* le bloc <code>passetout</code> doit être présent dans la section <code>monModule</code>
* Tester le bon fonctionnement de ce bloc en lui envoyant une sinusoïde que vous devez observer identique à la sortie du bloc. Vérifier avec des graphes.

==== Application : démodulation ====

En reprenant le signal modulé en amplitude et la fonction de transfert du filtre passe-bas du TP précédent :

* Obtenir l'équation aux différence du filtre, ''ie'' écrire ''y(n)='' en fonction de ''x(n)'', ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.
* Créer un nouveau bloc C++ (similaire au passe-tout précédent) dans le module <code>monModule</code> :
** de type <code>sync</code>
** une entrée en <code>float</code>
** une sortie en <code>float</code>
* Écrire le code permettant d'obtenir ''y(n)'' dans la méthode <code>work()</code> :
** ''x(n)'' est donné par <code>in0[0]</code>
** il sera nécessaire d'affecter <code>out0[0]</code> pour produire ''y(n)''.
** il sera nécessaire de stocker dans des '''attributs''' les valeurs de <code>in[0]</code> afin de disposer de ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.
** On rappelle que les attributs doivent être déclarées dans le fichier <code>.h</code> et initialisés dans le constructeur de la classe.

{{Todos| Réaliser cette implémentation du passe-bas et contrôler que la démodulation est identique à celle obtenue au TP précédent}}

{{Todos| Modifier votre code pour implémenter le filtre complet de démodulation}}

=== Approximation de PID par filtre numérique linéaire ===

==== Rappels PID ====

* Principe

[[Fichier:PIDprincipe.png|400px]]

[[Fichier:PIDdetail.png|400px]]

* Définition mathématique, la sortie du controleur PID ''u(t)'' est donnée par:

[[Fichier:EqPID.png|400px]]

==== PID numérique "classique" ====

On considère que le temps est discrétisé : ''t = n.Ts'' où ''Ts'' est la période d'échantillonnage.

* En approximant grossièrement l'intégrale et la dérivée
[[Fichier:PIDderivative.png|400px]] [[Fichier:PIDintegral.png|400px]]
** La dérivée est calculée par ''D = (e(n)-e(n-1))/Ts''
** L'intégrale est approximée en cumulant progressivement : ''I = I + e(n).Ts''

* Notebook exemple : asservissement de température

==== PID numérique par approximation d'un filtre continu ====

* Fonction de transfert Filtre continu d'un PID

[[Fichier:EqPID.png|500px]]

[[Fichier:eqFxTransfertPID.png|200]]

[[Fichier:eqFxTransfertPIDetPB.png|130]]

* Approximation de la fonction de transfert pour obtenir un filtre numérique
** ''backward euler''
** et transformée bilinéaire

* Implémentation du Filtre : classe <code>FilterController</code>
* Application sur l'asservissement d'altitude d'un drone

Cours:Elen4 TNS TP TpsReel

2026-05-29T12:36:12Z

Fredmn : /* Approximation de PID par filtre numérique linéaire */

[[Cours:Elen4_TNS|{{Rouge|'''Retour à la page du cours'''}}]]

<center>
'''<big>TP6 : Temps réel : Codage d'un bloc en Python / démodulation / PID Numérique</big>'''
</center>

Le but de ce TP est double :
* réaliser des implémentations temps réel de filtre IIR en créant un bloc Gnuradio qui execute un traitement codé en Python
* et étudier l'implémentation d'un PID numérique sous forme d'un filtre IIR.

=== Codage de bloc Gnuradio en Python ===

'''EN COURS DE RÉÉCRITURE (C++ vers Python)'''

Ce guide est inspirée du guide [https://wiki.gnuradio.org/index.php?title=Creating_C%2B%2B_OOT_with_gr-modtool Creating an OOT (C++ block example)] en l'adaptant pour nos besoins :

Nous allons créer un simple bloc qui recopie son entrée (en <code>float</code>) sur sa sortie. Donc le filtre caractérisé par ''y(n)'' = ''x(n)'' ou encore ''H(z)''=1. Il s'agit donc d'une sorte de filtre passe-tout.

'''Suivez bien toutes les étapes, sans aller trop rapidement'''

* Vous pourrez utiliser <code>gedit</code> pour éditer les divers fichiers.

==== Création d'un module externe ====

Dans les lignes qui suivent, le <code>$</code> indique que l'on saisi une commande dans un terminal. Le <code>$</code> n'est pas à saisir.

* Ouvrez un terminal et placez-vous à la racine de votre dossier personnel :
<source>
$ cd $HOME
</source>
* Créez un dossier de travail dédié à gnuradio et déplacez-vous à l'intérieur :
<source>
$ mkdir gnuradio
$ cd gnuradio
</source>
* GNU Radio est livré avec gr_modtool, un utilitaire qui permet de créer des modules externes (OOT). Créons un module <code>monModule</code>
<source>
$ gr_modtool newmod monModule
</source>
* Le dossier <code>gr-monModule</code> est créé et contient tout le code squelette d'un module OOT, mais il n'a pas encore de blocs. Déplacez-vous dans <code>gr-monModule</code> :
<source>
$ cd gr-monModule
</source>
* Vous pouvez afficher le contenu de ce dossier par
<source>
$ ls
</source>

==== Création d'un bloc dans ce module ====

* Ajoutez un nouveau bloc nommé <code>passetout</code> :
<source>
$ gr_modtool add passetout
</source>
* Quelques questions permettent alors de spécifier le type de bloc
<source>
GNU Radio module name identified: passetout
('sink', 'source', 'sync', 'decimator', 'interpolator', 'general', 'tagged_stream', 'hier', 'noblock')
</source>
Saisissez <code>sync</code> comme type de bloc, car le bloc que nous écrivons produira le même nombre d'échantillons en sortie que le nombre d'échantillons consommés depuis l'entrée.
<source>
Enter block type: sync
</source>
* Spécifiez <code>cpp</code> comme langage :
<source>
Language (python/cpp): cpp
Language: C++
Block/code identifier: passetout
</source>
* Spécifiez un nom pour le copyright :
<source>
Please specify the copyright holder: Bibi
</source>
* Il est possible de spécifier des paramètres d'entrée qui peuvent permettre de régler le fonctionnement du bloc. Ce ne sera pas notre cas, ne rien saisir sur cette question :
<source>
Enter valid argument list, including default arguments:
</source>
* De même, on ne donnera pas de code permettant de tester le bon fonctionnement :
<source>
Add Python QA code? [Y/n] n
Add C++ QA code? [Y/n] n
</source>
* Plusieurs fichers sont alors crées :
<source>
Adding file 'lib/passetout_impl.h'...
Adding file 'lib/passetout_impl.cc'...
Adding file 'include/gnuradio/monModule/passetout.h'...
Adding file 'python/monModule/bindings/docstrings/passetout_pydoc_template.h'...
Adding file 'python/monModule/bindings/passetout_python.cc'...
Adding file 'grc/monModule_passetout.block.yml'...
Editing grc/CMakeLists.txt...
</source>

Quelques indications :
* le fichier <code>passetout_impl.h</code> contient l'entête de la classe de notre bloc
* le fichier <code>passetout_impl.cc</code> contient l'implémentation de la classe de notre bloc
* le fichier <code>monModule_passetout.block.yml</code> va contenir des informations faisant le lien entre notre code c++ et le code python utilisé en interne par Gnuradio
* Le tout sera compilé par un <code>Makefile</code> généré par <code>cmake</code>.

==== Fichier <code>passetout_impl.h</code> ====

Le code utile généré est le suivant :
<source lang=cpp>
class passetout_impl : public passetout
{
private:
// Nothing to declare in this block.

public:
passetout_impl();
~passetout_impl();

// Where all the action really happens
int work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items);
};
</source>

Pour se réveiller les neurones sur la POO, qu'est-ce que sont
* <code>passetout_impl()</code>,
* <code>~passetout_impl()</code>,
* <code>private</code>, <code>public</code> ?

Le travail sera réalisé dans la méthode <code>work()</code>, mais nous n'avons pas de modification à apporter dans les déclarations par défaut.

==== Fichier <code>passetout_impl.cc</code> ====

Le code utile généré est le suivant :

{{boîte déroulante/début|titre=passetout_impl.cc}}
<source lang=cpp>
namespace monModule {

#pragma message("set the following appropriately and remove this warning")
using input_type = float;
#pragma message("set the following appropriately and remove this warning")
using output_type = float;
passetout::sptr passetout::make() { return gnuradio::make_block_sptr<passetout_impl>(); }

/*
* The private constructor
*/
passetout_impl::passetout_impl()
: gr::sync_block("passetout",
gr::io_signature::make(
1 /* min inputs */, 1 /* max inputs */, sizeof(input_type)),
gr::io_signature::make(
1 /* min outputs */, 1 /*max outputs */, sizeof(output_type)))
{
}

/*
* Our virtual destructor.
*/
passetout_impl::~passetout_impl() {}

int passetout_impl::work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items)
{
auto in = static_cast<const input_type*>(input_items[0]);
auto out = static_cast<output_type*>(output_items[0]);

#pragma message("Implement the signal processing in your block and remove this warning")
// Do <+signal processing+>

// Tell runtime system how many output items we produced.
return noutput_items;
}

} /* namespace monModule */
</source>
{{boîte déroulante/fin}}

Détaillons :
<source lang=cpp>
#pragma message("set the following appropriately and remove this warning")
using input_type = float;
#pragma message("set the following appropriately and remove this warning")
using output_type = float;
</source>
{{Todos| On spécifie ici le type des données d'entrée et de sortie. Pas de modification à apporter, il suffit de supprimer les deux <code>#pragma</code>}}

<source lang=cpp>
passetout_impl::passetout_impl()
: gr::sync_block("passetout",
gr::io_signature::make(
1 /* min inputs */, 1 /* max inputs */, sizeof(input_type)),
gr::io_signature::make(
1 /* min outputs */, 1 /*max outputs */, sizeof(output_type)))
{
}
</source>

{{Todos| On spécifie ici le nombre d'entrées (1) et le nombre de sorties (1). Pas de modification non plus.}}

{{Todos| Expliquez la syntaxe <code>passetout_impl::passetout_impl() : gr::sync_block(...)"</code> }}

<source lang=cpp>
int passetout_impl::work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items)
{
auto in = static_cast<const input_type*>(input_items[0]);
auto out = static_cast<output_type*>(output_items[0]);

#pragma message("Implement the signal processing in your block and remove this warning")
// Do <+signal processing+>

// Tell runtime system how many output items we produced.
return noutput_items;
}
</source>
Cette méthode <code>work()</code> implémente véritablement le filtrage.
* Les tableaux <code>in</code> et <code>out</code> contiennent respectivement les données en entrée et les données en sortie. Il faut donc calculer <code>out</code> en fonction de <code>in</code>
* Les données d'entrée arrivent par paquets dans un buffer. La variable <code>noutput_items</code> contient le nombre de données disponibles en entrées.
* à la fin de la méthode, on renvoie le nombre de données en sortie que l'on a calculé (entre 1 et <code>noutput_items</code>). Les données d'entrées éventuellement non consommées seront conservées dans le buffer pour le prochain appel de <code>work()</code>
{{Todos| On souhaite ici seulement recopier l'entrée sur la sortie, donc }}
# Enlever la ligne <code>#pragma</code>
# ajouter le code <code> out[0] = in[0];</code> (on recopie le premier échantillon disponible en entrée)
# changer <code>return noutput_items;</code> en <code>return 1;</code> (un seul échantillon a été consommé).

==== Fichier <code>monModule_passetout.block.yml</code> ====

Ce fichier au format YAML (''yet another markup language'') fait le lien entre le code c++ et le code python utilisé en interne par GnuRadio.

{{boîte déroulante/début|titre=monModule_passetout.block.yml}}
<source lang=yaml>
id: monModule_passetout
label: passetout
category: '[monModule]'

templates:
imports: from gnuradio import monModule
make: monModule.passetout()

# Make one 'parameters' list entry for every parameter you want settable from the GUI.
# Keys include:
# * id (makes the value accessible as keyname, e.g. in the make entry)
# * label (label shown in the GUI)
# * dtype (e.g. int, float, complex, byte, short, xxx_vector, ...)
# * default
parameters:
- id: parametername_replace_me
label: FIX ME:
dtype: string
default: You need to fill in your grc/monModule_passetout.block.yaml
#- id: ...
# label: ...
# dtype: ...

# Make one 'inputs' list entry per input and one 'outputs' list entry per output.
# Keys include:
# * label (an identifier for the GUI)
# * domain (optional - stream or message. Default is stream)
# * dtype (e.g. int, float, complex, byte, short, xxx_vector, ...)
# * vlen (optional - data stream vector length. Default is 1)
# * optional (optional - set to 1 for optional inputs. Default is 0)
inputs:
#- label: ...
# domain: ...
# dtype: ...
# vlen: ...
# optional: ...

outputs:
#- label: ...
# domain: ...
# dtype: ...
# vlen: ...
# optional: ...

# 'file_format' specifies the version of the GRC yml format used in the file
# and should usually not be changed.
file_format: 1
</source>
{{boîte déroulante/fin}}

{{Todos| Mettre à jour la section <code>parameters</code> (pas de paramètres, on commente) :}}

<source lang=yaml>
#parameters:
#- id: parametername_replace_me
# label: FIX ME:
# dtype: string
# default: You need to fill in your grc/customModule_testMod.block.yaml
</source>

{{Todos| Mettre à jour la section <code>inputs</code> :}}

<source lang=yaml>
inputs:
- label: in
domain: stream
dtype: float
</source>

{{Todos| Mettre à jour la section <code>output</code> :}}

<source lang=yaml>
outputs:
- label: out
domain: stream
dtype: float
</source>

==== Compilation et installation ====

Voici les étapes :
<source lang=bash>
$ cd CHEMIN-DE-VOTRE-DOSSIER/gr-monModule
$ mkdir build
$ cd build
$ cmake ..
$ make
$ make install
</source>

* <code>cmake ..</code> lance la création des fichiers <code>Makefile</code> qui permettent la compilation et l'installation
* <code>make</code> lance la compilation
* <code>make install</code> lance l'installation (copie des fichiers dans les dossiers gnuradio)

{{Todos| Exécuter chacune de ces lignes, en contrôlant l'absence d'erreur. Dans le cas contraire, contrôler les fichiers <code>.h</code>, <code>.cc</code> et <code>.yaml</code>}}

{{Todos| '''Après ces étapes, et avant de lancer gnuRadio, appeler l'enseignant qui va mettre à jours les bibliothèques partagées.'''}}. Sinon tenter :
<source>
$ export LD_LIBRARY_PATH=/usr/local/lib/x86_64-linux-gnu:$LD_LIBRARY_PATH
$ gnuradio-companion &
</source>

==== Utilisation du bloc et test ====

* Dans Gnuradio, rafraichir la liste des bloc (bouton ''reload'')
* le bloc <code>passetout</code> doit être présent dans la section <code>monModule</code>
* Tester le bon fonctionnement de ce bloc en lui envoyant une sinusoïde que vous devez observer identique à la sortie du bloc. Vérifier avec des graphes.

==== Application : démodulation ====

En reprenant le signal modulé en amplitude et la fonction de transfert du filtre passe-bas du TP précédent :

* Obtenir l'équation aux différence du filtre, ''ie'' écrire ''y(n)='' en fonction de ''x(n)'', ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.
* Créer un nouveau bloc C++ (similaire au passe-tout précédent) dans le module <code>monModule</code> :
** de type <code>sync</code>
** une entrée en <code>float</code>
** une sortie en <code>float</code>
* Écrire le code permettant d'obtenir ''y(n)'' dans la méthode <code>work()</code> :
** ''x(n)'' est donné par <code>in0[0]</code>
** il sera nécessaire d'affecter <code>out0[0]</code> pour produire ''y(n)''.
** il sera nécessaire de stocker dans des '''attributs''' les valeurs de <code>in[0]</code> afin de disposer de ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.
** On rappelle que les attributs doivent être déclarées dans le fichier <code>.h</code> et initialisés dans le constructeur de la classe.

{{Todos| Réaliser cette implémentation du passe-bas et contrôler que la démodulation est identique à celle obtenue au TP précédent}}

{{Todos| Modifier votre code pour implémenter le filtre complet de démodulation}}

=== Approximation de PID par filtre numérique linéaire ===

==== Rappels PID ====

* Principe

[[Fichier:PIDprincipe.png|400px]]

[[Fichier:PIDdetail.png|400px]]

* Définition mathématique

[[Fichier:EqPID.png|400px]]

==== PID numérique "classique" ====

* En approximant grossièrement l'intégrale et la dérivée

[[Fichier:PIDderivative.png|400px]]

[[Fichier:PIDintegral.png|400px]]

* Notebook exemple : asservissement de température

==== PID numérique par approximation d'un filtre continu ====

* Fonction de transfert Filtre continu d'un PID

[[Fichier:EqPID.png|400px]]

[[Fichier:eqFxTransfertPID.png|150]]

[[Fichier:eqFxTransfertPIDetPB.png|130]]

* Approximation de la fonction de transfert pour obtenir un filtre numérique
** ''backward euler''
** et transformée bilinéaire
* Implémentation du Filtre : classe <code>FilterController</code>
* Application sur l'asservissement d'altitude d'un drone

Cours:Elen4 TNS TP TpsReel

2026-05-29T12:35:24Z

Fredmn : /* Approximation de PID par filtre numérique linéaire */

[[Cours:Elen4_TNS|{{Rouge|'''Retour à la page du cours'''}}]]

<center>
'''<big>TP6 : Temps réel : Codage d'un bloc en Python / démodulation / PID Numérique</big>'''
</center>

Le but de ce TP est double :
* réaliser des implémentations temps réel de filtre IIR en créant un bloc Gnuradio qui execute un traitement codé en Python
* et étudier l'implémentation d'un PID numérique sous forme d'un filtre IIR.

=== Codage de bloc Gnuradio en Python ===

'''EN COURS DE RÉÉCRITURE (C++ vers Python)'''

Ce guide est inspirée du guide [https://wiki.gnuradio.org/index.php?title=Creating_C%2B%2B_OOT_with_gr-modtool Creating an OOT (C++ block example)] en l'adaptant pour nos besoins :

Nous allons créer un simple bloc qui recopie son entrée (en <code>float</code>) sur sa sortie. Donc le filtre caractérisé par ''y(n)'' = ''x(n)'' ou encore ''H(z)''=1. Il s'agit donc d'une sorte de filtre passe-tout.

'''Suivez bien toutes les étapes, sans aller trop rapidement'''

* Vous pourrez utiliser <code>gedit</code> pour éditer les divers fichiers.

==== Création d'un module externe ====

Dans les lignes qui suivent, le <code>$</code> indique que l'on saisi une commande dans un terminal. Le <code>$</code> n'est pas à saisir.

* Ouvrez un terminal et placez-vous à la racine de votre dossier personnel :
<source>
$ cd $HOME
</source>
* Créez un dossier de travail dédié à gnuradio et déplacez-vous à l'intérieur :
<source>
$ mkdir gnuradio
$ cd gnuradio
</source>
* GNU Radio est livré avec gr_modtool, un utilitaire qui permet de créer des modules externes (OOT). Créons un module <code>monModule</code>
<source>
$ gr_modtool newmod monModule
</source>
* Le dossier <code>gr-monModule</code> est créé et contient tout le code squelette d'un module OOT, mais il n'a pas encore de blocs. Déplacez-vous dans <code>gr-monModule</code> :
<source>
$ cd gr-monModule
</source>
* Vous pouvez afficher le contenu de ce dossier par
<source>
$ ls
</source>

==== Création d'un bloc dans ce module ====

* Ajoutez un nouveau bloc nommé <code>passetout</code> :
<source>
$ gr_modtool add passetout
</source>
* Quelques questions permettent alors de spécifier le type de bloc
<source>
GNU Radio module name identified: passetout
('sink', 'source', 'sync', 'decimator', 'interpolator', 'general', 'tagged_stream', 'hier', 'noblock')
</source>
Saisissez <code>sync</code> comme type de bloc, car le bloc que nous écrivons produira le même nombre d'échantillons en sortie que le nombre d'échantillons consommés depuis l'entrée.
<source>
Enter block type: sync
</source>
* Spécifiez <code>cpp</code> comme langage :
<source>
Language (python/cpp): cpp
Language: C++
Block/code identifier: passetout
</source>
* Spécifiez un nom pour le copyright :
<source>
Please specify the copyright holder: Bibi
</source>
* Il est possible de spécifier des paramètres d'entrée qui peuvent permettre de régler le fonctionnement du bloc. Ce ne sera pas notre cas, ne rien saisir sur cette question :
<source>
Enter valid argument list, including default arguments:
</source>
* De même, on ne donnera pas de code permettant de tester le bon fonctionnement :
<source>
Add Python QA code? [Y/n] n
Add C++ QA code? [Y/n] n
</source>
* Plusieurs fichers sont alors crées :
<source>
Adding file 'lib/passetout_impl.h'...
Adding file 'lib/passetout_impl.cc'...
Adding file 'include/gnuradio/monModule/passetout.h'...
Adding file 'python/monModule/bindings/docstrings/passetout_pydoc_template.h'...
Adding file 'python/monModule/bindings/passetout_python.cc'...
Adding file 'grc/monModule_passetout.block.yml'...
Editing grc/CMakeLists.txt...
</source>

Quelques indications :
* le fichier <code>passetout_impl.h</code> contient l'entête de la classe de notre bloc
* le fichier <code>passetout_impl.cc</code> contient l'implémentation de la classe de notre bloc
* le fichier <code>monModule_passetout.block.yml</code> va contenir des informations faisant le lien entre notre code c++ et le code python utilisé en interne par Gnuradio
* Le tout sera compilé par un <code>Makefile</code> généré par <code>cmake</code>.

==== Fichier <code>passetout_impl.h</code> ====

Le code utile généré est le suivant :
<source lang=cpp>
class passetout_impl : public passetout
{
private:
// Nothing to declare in this block.

public:
passetout_impl();
~passetout_impl();

// Where all the action really happens
int work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items);
};
</source>

Pour se réveiller les neurones sur la POO, qu'est-ce que sont
* <code>passetout_impl()</code>,
* <code>~passetout_impl()</code>,
* <code>private</code>, <code>public</code> ?

Le travail sera réalisé dans la méthode <code>work()</code>, mais nous n'avons pas de modification à apporter dans les déclarations par défaut.

==== Fichier <code>passetout_impl.cc</code> ====

Le code utile généré est le suivant :

{{boîte déroulante/début|titre=passetout_impl.cc}}
<source lang=cpp>
namespace monModule {

#pragma message("set the following appropriately and remove this warning")
using input_type = float;
#pragma message("set the following appropriately and remove this warning")
using output_type = float;
passetout::sptr passetout::make() { return gnuradio::make_block_sptr<passetout_impl>(); }

/*
* The private constructor
*/
passetout_impl::passetout_impl()
: gr::sync_block("passetout",
gr::io_signature::make(
1 /* min inputs */, 1 /* max inputs */, sizeof(input_type)),
gr::io_signature::make(
1 /* min outputs */, 1 /*max outputs */, sizeof(output_type)))
{
}

/*
* Our virtual destructor.
*/
passetout_impl::~passetout_impl() {}

int passetout_impl::work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items)
{
auto in = static_cast<const input_type*>(input_items[0]);
auto out = static_cast<output_type*>(output_items[0]);

#pragma message("Implement the signal processing in your block and remove this warning")
// Do <+signal processing+>

// Tell runtime system how many output items we produced.
return noutput_items;
}

} /* namespace monModule */
</source>
{{boîte déroulante/fin}}

Détaillons :
<source lang=cpp>
#pragma message("set the following appropriately and remove this warning")
using input_type = float;
#pragma message("set the following appropriately and remove this warning")
using output_type = float;
</source>
{{Todos| On spécifie ici le type des données d'entrée et de sortie. Pas de modification à apporter, il suffit de supprimer les deux <code>#pragma</code>}}

<source lang=cpp>
passetout_impl::passetout_impl()
: gr::sync_block("passetout",
gr::io_signature::make(
1 /* min inputs */, 1 /* max inputs */, sizeof(input_type)),
gr::io_signature::make(
1 /* min outputs */, 1 /*max outputs */, sizeof(output_type)))
{
}
</source>

{{Todos| On spécifie ici le nombre d'entrées (1) et le nombre de sorties (1). Pas de modification non plus.}}

{{Todos| Expliquez la syntaxe <code>passetout_impl::passetout_impl() : gr::sync_block(...)"</code> }}

<source lang=cpp>
int passetout_impl::work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items)
{
auto in = static_cast<const input_type*>(input_items[0]);
auto out = static_cast<output_type*>(output_items[0]);

#pragma message("Implement the signal processing in your block and remove this warning")
// Do <+signal processing+>

// Tell runtime system how many output items we produced.
return noutput_items;
}
</source>
Cette méthode <code>work()</code> implémente véritablement le filtrage.
* Les tableaux <code>in</code> et <code>out</code> contiennent respectivement les données en entrée et les données en sortie. Il faut donc calculer <code>out</code> en fonction de <code>in</code>
* Les données d'entrée arrivent par paquets dans un buffer. La variable <code>noutput_items</code> contient le nombre de données disponibles en entrées.
* à la fin de la méthode, on renvoie le nombre de données en sortie que l'on a calculé (entre 1 et <code>noutput_items</code>). Les données d'entrées éventuellement non consommées seront conservées dans le buffer pour le prochain appel de <code>work()</code>
{{Todos| On souhaite ici seulement recopier l'entrée sur la sortie, donc }}
# Enlever la ligne <code>#pragma</code>
# ajouter le code <code> out[0] = in[0];</code> (on recopie le premier échantillon disponible en entrée)
# changer <code>return noutput_items;</code> en <code>return 1;</code> (un seul échantillon a été consommé).

==== Fichier <code>monModule_passetout.block.yml</code> ====

Ce fichier au format YAML (''yet another markup language'') fait le lien entre le code c++ et le code python utilisé en interne par GnuRadio.

{{boîte déroulante/début|titre=monModule_passetout.block.yml}}
<source lang=yaml>
id: monModule_passetout
label: passetout
category: '[monModule]'

templates:
imports: from gnuradio import monModule
make: monModule.passetout()

# Make one 'parameters' list entry for every parameter you want settable from the GUI.
# Keys include:
# * id (makes the value accessible as keyname, e.g. in the make entry)
# * label (label shown in the GUI)
# * dtype (e.g. int, float, complex, byte, short, xxx_vector, ...)
# * default
parameters:
- id: parametername_replace_me
label: FIX ME:
dtype: string
default: You need to fill in your grc/monModule_passetout.block.yaml
#- id: ...
# label: ...
# dtype: ...

# Make one 'inputs' list entry per input and one 'outputs' list entry per output.
# Keys include:
# * label (an identifier for the GUI)
# * domain (optional - stream or message. Default is stream)
# * dtype (e.g. int, float, complex, byte, short, xxx_vector, ...)
# * vlen (optional - data stream vector length. Default is 1)
# * optional (optional - set to 1 for optional inputs. Default is 0)
inputs:
#- label: ...
# domain: ...
# dtype: ...
# vlen: ...
# optional: ...

outputs:
#- label: ...
# domain: ...
# dtype: ...
# vlen: ...
# optional: ...

# 'file_format' specifies the version of the GRC yml format used in the file
# and should usually not be changed.
file_format: 1
</source>
{{boîte déroulante/fin}}

{{Todos| Mettre à jour la section <code>parameters</code> (pas de paramètres, on commente) :}}

<source lang=yaml>
#parameters:
#- id: parametername_replace_me
# label: FIX ME:
# dtype: string
# default: You need to fill in your grc/customModule_testMod.block.yaml
</source>

{{Todos| Mettre à jour la section <code>inputs</code> :}}

<source lang=yaml>
inputs:
- label: in
domain: stream
dtype: float
</source>

{{Todos| Mettre à jour la section <code>output</code> :}}

<source lang=yaml>
outputs:
- label: out
domain: stream
dtype: float
</source>

==== Compilation et installation ====

Voici les étapes :
<source lang=bash>
$ cd CHEMIN-DE-VOTRE-DOSSIER/gr-monModule
$ mkdir build
$ cd build
$ cmake ..
$ make
$ make install
</source>

* <code>cmake ..</code> lance la création des fichiers <code>Makefile</code> qui permettent la compilation et l'installation
* <code>make</code> lance la compilation
* <code>make install</code> lance l'installation (copie des fichiers dans les dossiers gnuradio)

{{Todos| Exécuter chacune de ces lignes, en contrôlant l'absence d'erreur. Dans le cas contraire, contrôler les fichiers <code>.h</code>, <code>.cc</code> et <code>.yaml</code>}}

{{Todos| '''Après ces étapes, et avant de lancer gnuRadio, appeler l'enseignant qui va mettre à jours les bibliothèques partagées.'''}}. Sinon tenter :
<source>
$ export LD_LIBRARY_PATH=/usr/local/lib/x86_64-linux-gnu:$LD_LIBRARY_PATH
$ gnuradio-companion &
</source>

==== Utilisation du bloc et test ====

* Dans Gnuradio, rafraichir la liste des bloc (bouton ''reload'')
* le bloc <code>passetout</code> doit être présent dans la section <code>monModule</code>
* Tester le bon fonctionnement de ce bloc en lui envoyant une sinusoïde que vous devez observer identique à la sortie du bloc. Vérifier avec des graphes.

==== Application : démodulation ====

En reprenant le signal modulé en amplitude et la fonction de transfert du filtre passe-bas du TP précédent :

* Obtenir l'équation aux différence du filtre, ''ie'' écrire ''y(n)='' en fonction de ''x(n)'', ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.
* Créer un nouveau bloc C++ (similaire au passe-tout précédent) dans le module <code>monModule</code> :
** de type <code>sync</code>
** une entrée en <code>float</code>
** une sortie en <code>float</code>
* Écrire le code permettant d'obtenir ''y(n)'' dans la méthode <code>work()</code> :
** ''x(n)'' est donné par <code>in0[0]</code>
** il sera nécessaire d'affecter <code>out0[0]</code> pour produire ''y(n)''.
** il sera nécessaire de stocker dans des '''attributs''' les valeurs de <code>in[0]</code> afin de disposer de ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.
** On rappelle que les attributs doivent être déclarées dans le fichier <code>.h</code> et initialisés dans le constructeur de la classe.

{{Todos| Réaliser cette implémentation du passe-bas et contrôler que la démodulation est identique à celle obtenue au TP précédent}}

{{Todos| Modifier votre code pour implémenter le filtre complet de démodulation}}

=== Approximation de PID par filtre numérique linéaire ===

==== Rappels PID ====

* Principe

[[Fichier:PIDprincipe.png|400px]]

[[Fichier:PIDdetail.png|400px]]

* Définition mathématique

[[Fichier:EqPID.png|400px]]

==== PID numérique "classique" ====

* En approximant grossièrement l'intégrale et la dérivée
* Notebook exemple : asservissement de température

==== PID numérique par approximation d'un filtre continu ====

* Fonction de transfert Filtre continu d'un PID

[[Fichier:EqPID.png|400px]]

[[Fichier:eqFxTransfertPID.png|150]]

[[Fichier:eqFxTransfertPIDetPB.png|130]]

* Approximation de la fonction de transfert pour obtenir un filtre numérique
** ''backward euler''
** et transformée bilinéaire
* Implémentation du Filtre : classe <code>FilterController</code>
* Application sur l'asservissement d'altitude d'un drone

Fichier:EqFxTransfertPIDetPB.png

2026-05-29T10:54:06Z

Fredmn :

Fichier:EqFxTransfertPID.png

2026-05-29T10:51:22Z

Fredmn :

Fichier:PIDderivative.png

2026-05-29T10:46:05Z

Fredmn :

Fichier:PIDintegral.png

2026-05-29T10:45:53Z

Fredmn :

Fichier:PIDdetail.png

2026-05-29T10:43:30Z

Fredmn :

Fichier:PIDprincipe.png

2026-05-29T10:41:12Z

Fredmn :

Cours:Elen4 TNS TP TpsReel

2026-05-29T10:40:22Z

Fredmn : /* Approximation de PID par filtre numérique linéaire */

[[Cours:Elen4_TNS|{{Rouge|'''Retour à la page du cours'''}}]]

<center>
'''<big>TP6 : Temps réel : Codage d'un bloc en Python / démodulation / PID Numérique</big>'''
</center>

Le but de ce TP est double :
* réaliser des implémentations temps réel de filtre IIR en créant un bloc Gnuradio qui execute un traitement codé en Python
* et étudier l'implémentation d'un PID numérique sous forme d'un filtre IIR.

=== Codage de bloc Gnuradio en Python ===

'''EN COURS DE RÉÉCRITURE (C++ vers Python)'''

Ce guide est inspirée du guide [https://wiki.gnuradio.org/index.php?title=Creating_C%2B%2B_OOT_with_gr-modtool Creating an OOT (C++ block example)] en l'adaptant pour nos besoins :

Nous allons créer un simple bloc qui recopie son entrée (en <code>float</code>) sur sa sortie. Donc le filtre caractérisé par ''y(n)'' = ''x(n)'' ou encore ''H(z)''=1. Il s'agit donc d'une sorte de filtre passe-tout.

'''Suivez bien toutes les étapes, sans aller trop rapidement'''

* Vous pourrez utiliser <code>gedit</code> pour éditer les divers fichiers.

==== Création d'un module externe ====

Dans les lignes qui suivent, le <code>$</code> indique que l'on saisi une commande dans un terminal. Le <code>$</code> n'est pas à saisir.

* Ouvrez un terminal et placez-vous à la racine de votre dossier personnel :
<source>
$ cd $HOME
</source>
* Créez un dossier de travail dédié à gnuradio et déplacez-vous à l'intérieur :
<source>
$ mkdir gnuradio
$ cd gnuradio
</source>
* GNU Radio est livré avec gr_modtool, un utilitaire qui permet de créer des modules externes (OOT). Créons un module <code>monModule</code>
<source>
$ gr_modtool newmod monModule
</source>
* Le dossier <code>gr-monModule</code> est créé et contient tout le code squelette d'un module OOT, mais il n'a pas encore de blocs. Déplacez-vous dans <code>gr-monModule</code> :
<source>
$ cd gr-monModule
</source>
* Vous pouvez afficher le contenu de ce dossier par
<source>
$ ls
</source>

==== Création d'un bloc dans ce module ====

* Ajoutez un nouveau bloc nommé <code>passetout</code> :
<source>
$ gr_modtool add passetout
</source>
* Quelques questions permettent alors de spécifier le type de bloc
<source>
GNU Radio module name identified: passetout
('sink', 'source', 'sync', 'decimator', 'interpolator', 'general', 'tagged_stream', 'hier', 'noblock')
</source>
Saisissez <code>sync</code> comme type de bloc, car le bloc que nous écrivons produira le même nombre d'échantillons en sortie que le nombre d'échantillons consommés depuis l'entrée.
<source>
Enter block type: sync
</source>
* Spécifiez <code>cpp</code> comme langage :
<source>
Language (python/cpp): cpp
Language: C++
Block/code identifier: passetout
</source>
* Spécifiez un nom pour le copyright :
<source>
Please specify the copyright holder: Bibi
</source>
* Il est possible de spécifier des paramètres d'entrée qui peuvent permettre de régler le fonctionnement du bloc. Ce ne sera pas notre cas, ne rien saisir sur cette question :
<source>
Enter valid argument list, including default arguments:
</source>
* De même, on ne donnera pas de code permettant de tester le bon fonctionnement :
<source>
Add Python QA code? [Y/n] n
Add C++ QA code? [Y/n] n
</source>
* Plusieurs fichers sont alors crées :
<source>
Adding file 'lib/passetout_impl.h'...
Adding file 'lib/passetout_impl.cc'...
Adding file 'include/gnuradio/monModule/passetout.h'...
Adding file 'python/monModule/bindings/docstrings/passetout_pydoc_template.h'...
Adding file 'python/monModule/bindings/passetout_python.cc'...
Adding file 'grc/monModule_passetout.block.yml'...
Editing grc/CMakeLists.txt...
</source>

Quelques indications :
* le fichier <code>passetout_impl.h</code> contient l'entête de la classe de notre bloc
* le fichier <code>passetout_impl.cc</code> contient l'implémentation de la classe de notre bloc
* le fichier <code>monModule_passetout.block.yml</code> va contenir des informations faisant le lien entre notre code c++ et le code python utilisé en interne par Gnuradio
* Le tout sera compilé par un <code>Makefile</code> généré par <code>cmake</code>.

==== Fichier <code>passetout_impl.h</code> ====

Le code utile généré est le suivant :
<source lang=cpp>
class passetout_impl : public passetout
{
private:
// Nothing to declare in this block.

public:
passetout_impl();
~passetout_impl();

// Where all the action really happens
int work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items);
};
</source>

Pour se réveiller les neurones sur la POO, qu'est-ce que sont
* <code>passetout_impl()</code>,
* <code>~passetout_impl()</code>,
* <code>private</code>, <code>public</code> ?

Le travail sera réalisé dans la méthode <code>work()</code>, mais nous n'avons pas de modification à apporter dans les déclarations par défaut.

==== Fichier <code>passetout_impl.cc</code> ====

Le code utile généré est le suivant :

{{boîte déroulante/début|titre=passetout_impl.cc}}
<source lang=cpp>
namespace monModule {

#pragma message("set the following appropriately and remove this warning")
using input_type = float;
#pragma message("set the following appropriately and remove this warning")
using output_type = float;
passetout::sptr passetout::make() { return gnuradio::make_block_sptr<passetout_impl>(); }

/*
* The private constructor
*/
passetout_impl::passetout_impl()
: gr::sync_block("passetout",
gr::io_signature::make(
1 /* min inputs */, 1 /* max inputs */, sizeof(input_type)),
gr::io_signature::make(
1 /* min outputs */, 1 /*max outputs */, sizeof(output_type)))
{
}

/*
* Our virtual destructor.
*/
passetout_impl::~passetout_impl() {}

int passetout_impl::work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items)
{
auto in = static_cast<const input_type*>(input_items[0]);
auto out = static_cast<output_type*>(output_items[0]);

#pragma message("Implement the signal processing in your block and remove this warning")
// Do <+signal processing+>

// Tell runtime system how many output items we produced.
return noutput_items;
}

} /* namespace monModule */
</source>
{{boîte déroulante/fin}}

Détaillons :
<source lang=cpp>
#pragma message("set the following appropriately and remove this warning")
using input_type = float;
#pragma message("set the following appropriately and remove this warning")
using output_type = float;
</source>
{{Todos| On spécifie ici le type des données d'entrée et de sortie. Pas de modification à apporter, il suffit de supprimer les deux <code>#pragma</code>}}

<source lang=cpp>
passetout_impl::passetout_impl()
: gr::sync_block("passetout",
gr::io_signature::make(
1 /* min inputs */, 1 /* max inputs */, sizeof(input_type)),
gr::io_signature::make(
1 /* min outputs */, 1 /*max outputs */, sizeof(output_type)))
{
}
</source>

{{Todos| On spécifie ici le nombre d'entrées (1) et le nombre de sorties (1). Pas de modification non plus.}}

{{Todos| Expliquez la syntaxe <code>passetout_impl::passetout_impl() : gr::sync_block(...)"</code> }}

<source lang=cpp>
int passetout_impl::work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items)
{
auto in = static_cast<const input_type*>(input_items[0]);
auto out = static_cast<output_type*>(output_items[0]);

#pragma message("Implement the signal processing in your block and remove this warning")
// Do <+signal processing+>

// Tell runtime system how many output items we produced.
return noutput_items;
}
</source>
Cette méthode <code>work()</code> implémente véritablement le filtrage.
* Les tableaux <code>in</code> et <code>out</code> contiennent respectivement les données en entrée et les données en sortie. Il faut donc calculer <code>out</code> en fonction de <code>in</code>
* Les données d'entrée arrivent par paquets dans un buffer. La variable <code>noutput_items</code> contient le nombre de données disponibles en entrées.
* à la fin de la méthode, on renvoie le nombre de données en sortie que l'on a calculé (entre 1 et <code>noutput_items</code>). Les données d'entrées éventuellement non consommées seront conservées dans le buffer pour le prochain appel de <code>work()</code>
{{Todos| On souhaite ici seulement recopier l'entrée sur la sortie, donc }}
# Enlever la ligne <code>#pragma</code>
# ajouter le code <code> out[0] = in[0];</code> (on recopie le premier échantillon disponible en entrée)
# changer <code>return noutput_items;</code> en <code>return 1;</code> (un seul échantillon a été consommé).

==== Fichier <code>monModule_passetout.block.yml</code> ====

Ce fichier au format YAML (''yet another markup language'') fait le lien entre le code c++ et le code python utilisé en interne par GnuRadio.

{{boîte déroulante/début|titre=monModule_passetout.block.yml}}
<source lang=yaml>
id: monModule_passetout
label: passetout
category: '[monModule]'

templates:
imports: from gnuradio import monModule
make: monModule.passetout()

# Make one 'parameters' list entry for every parameter you want settable from the GUI.
# Keys include:
# * id (makes the value accessible as keyname, e.g. in the make entry)
# * label (label shown in the GUI)
# * dtype (e.g. int, float, complex, byte, short, xxx_vector, ...)
# * default
parameters:
- id: parametername_replace_me
label: FIX ME:
dtype: string
default: You need to fill in your grc/monModule_passetout.block.yaml
#- id: ...
# label: ...
# dtype: ...

# Make one 'inputs' list entry per input and one 'outputs' list entry per output.
# Keys include:
# * label (an identifier for the GUI)
# * domain (optional - stream or message. Default is stream)
# * dtype (e.g. int, float, complex, byte, short, xxx_vector, ...)
# * vlen (optional - data stream vector length. Default is 1)
# * optional (optional - set to 1 for optional inputs. Default is 0)
inputs:
#- label: ...
# domain: ...
# dtype: ...
# vlen: ...
# optional: ...

outputs:
#- label: ...
# domain: ...
# dtype: ...
# vlen: ...
# optional: ...

# 'file_format' specifies the version of the GRC yml format used in the file
# and should usually not be changed.
file_format: 1
</source>
{{boîte déroulante/fin}}

{{Todos| Mettre à jour la section <code>parameters</code> (pas de paramètres, on commente) :}}

<source lang=yaml>
#parameters:
#- id: parametername_replace_me
# label: FIX ME:
# dtype: string
# default: You need to fill in your grc/customModule_testMod.block.yaml
</source>

{{Todos| Mettre à jour la section <code>inputs</code> :}}

<source lang=yaml>
inputs:
- label: in
domain: stream
dtype: float
</source>

{{Todos| Mettre à jour la section <code>output</code> :}}

<source lang=yaml>
outputs:
- label: out
domain: stream
dtype: float
</source>

==== Compilation et installation ====

Voici les étapes :
<source lang=bash>
$ cd CHEMIN-DE-VOTRE-DOSSIER/gr-monModule
$ mkdir build
$ cd build
$ cmake ..
$ make
$ make install
</source>

* <code>cmake ..</code> lance la création des fichiers <code>Makefile</code> qui permettent la compilation et l'installation
* <code>make</code> lance la compilation
* <code>make install</code> lance l'installation (copie des fichiers dans les dossiers gnuradio)

{{Todos| Exécuter chacune de ces lignes, en contrôlant l'absence d'erreur. Dans le cas contraire, contrôler les fichiers <code>.h</code>, <code>.cc</code> et <code>.yaml</code>}}

{{Todos| '''Après ces étapes, et avant de lancer gnuRadio, appeler l'enseignant qui va mettre à jours les bibliothèques partagées.'''}}. Sinon tenter :
<source>
$ export LD_LIBRARY_PATH=/usr/local/lib/x86_64-linux-gnu:$LD_LIBRARY_PATH
$ gnuradio-companion &
</source>

==== Utilisation du bloc et test ====

* Dans Gnuradio, rafraichir la liste des bloc (bouton ''reload'')
* le bloc <code>passetout</code> doit être présent dans la section <code>monModule</code>
* Tester le bon fonctionnement de ce bloc en lui envoyant une sinusoïde que vous devez observer identique à la sortie du bloc. Vérifier avec des graphes.

==== Application : démodulation ====

En reprenant le signal modulé en amplitude et la fonction de transfert du filtre passe-bas du TP précédent :

* Obtenir l'équation aux différence du filtre, ''ie'' écrire ''y(n)='' en fonction de ''x(n)'', ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.
* Créer un nouveau bloc C++ (similaire au passe-tout précédent) dans le module <code>monModule</code> :
** de type <code>sync</code>
** une entrée en <code>float</code>
** une sortie en <code>float</code>
* Écrire le code permettant d'obtenir ''y(n)'' dans la méthode <code>work()</code> :
** ''x(n)'' est donné par <code>in0[0]</code>
** il sera nécessaire d'affecter <code>out0[0]</code> pour produire ''y(n)''.
** il sera nécessaire de stocker dans des '''attributs''' les valeurs de <code>in[0]</code> afin de disposer de ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.
** On rappelle que les attributs doivent être déclarées dans le fichier <code>.h</code> et initialisés dans le constructeur de la classe.

{{Todos| Réaliser cette implémentation du passe-bas et contrôler que la démodulation est identique à celle obtenue au TP précédent}}

{{Todos| Modifier votre code pour implémenter le filtre complet de démodulation}}

=== Approximation de PID par filtre numérique linéaire ===

==== Rappels PID ====

* Principe

[[Fichier:https://wikigeii.iut-troyes.univ-reims.fr/images/d/d5/PIDprincipe.webp]]

* Définition mathématique

[[Fichier:EqPID.png|400px]]

==== PID numérique "classique" ====

* En approximant grossièrement l'intégrale et la dérivée
* Notebook exemple : asservissement de température

==== PID numérique par approximation d'un filtre continu ====

* Fonction de transfert Filtre continu d'un PID
* Approximation de la fonction de transfert pour obtenir un filtre numérique
** ''backward euler''
** et transformée bilinéaire
* Implémentation du Filtre : classe <code>FilterController</code>
* Application sur l'asservissement d'altitude d'un drone

Cours:Elen4 TNS TP TpsReel

2026-05-29T10:35:37Z

Fredmn : /* Approximation de PID par filtre numérique linéaire */

[[Cours:Elen4_TNS|{{Rouge|'''Retour à la page du cours'''}}]]

<center>
'''<big>TP6 : Temps réel : Codage d'un bloc en Python / démodulation / PID Numérique</big>'''
</center>

Le but de ce TP est double :
* réaliser des implémentations temps réel de filtre IIR en créant un bloc Gnuradio qui execute un traitement codé en Python
* et étudier l'implémentation d'un PID numérique sous forme d'un filtre IIR.

=== Codage de bloc Gnuradio en Python ===

'''EN COURS DE RÉÉCRITURE (C++ vers Python)'''

Ce guide est inspirée du guide [https://wiki.gnuradio.org/index.php?title=Creating_C%2B%2B_OOT_with_gr-modtool Creating an OOT (C++ block example)] en l'adaptant pour nos besoins :

Nous allons créer un simple bloc qui recopie son entrée (en <code>float</code>) sur sa sortie. Donc le filtre caractérisé par ''y(n)'' = ''x(n)'' ou encore ''H(z)''=1. Il s'agit donc d'une sorte de filtre passe-tout.

'''Suivez bien toutes les étapes, sans aller trop rapidement'''

* Vous pourrez utiliser <code>gedit</code> pour éditer les divers fichiers.

==== Création d'un module externe ====

Dans les lignes qui suivent, le <code>$</code> indique que l'on saisi une commande dans un terminal. Le <code>$</code> n'est pas à saisir.

* Ouvrez un terminal et placez-vous à la racine de votre dossier personnel :
<source>
$ cd $HOME
</source>
* Créez un dossier de travail dédié à gnuradio et déplacez-vous à l'intérieur :
<source>
$ mkdir gnuradio
$ cd gnuradio
</source>
* GNU Radio est livré avec gr_modtool, un utilitaire qui permet de créer des modules externes (OOT). Créons un module <code>monModule</code>
<source>
$ gr_modtool newmod monModule
</source>
* Le dossier <code>gr-monModule</code> est créé et contient tout le code squelette d'un module OOT, mais il n'a pas encore de blocs. Déplacez-vous dans <code>gr-monModule</code> :
<source>
$ cd gr-monModule
</source>
* Vous pouvez afficher le contenu de ce dossier par
<source>
$ ls
</source>

==== Création d'un bloc dans ce module ====

* Ajoutez un nouveau bloc nommé <code>passetout</code> :
<source>
$ gr_modtool add passetout
</source>
* Quelques questions permettent alors de spécifier le type de bloc
<source>
GNU Radio module name identified: passetout
('sink', 'source', 'sync', 'decimator', 'interpolator', 'general', 'tagged_stream', 'hier', 'noblock')
</source>
Saisissez <code>sync</code> comme type de bloc, car le bloc que nous écrivons produira le même nombre d'échantillons en sortie que le nombre d'échantillons consommés depuis l'entrée.
<source>
Enter block type: sync
</source>
* Spécifiez <code>cpp</code> comme langage :
<source>
Language (python/cpp): cpp
Language: C++
Block/code identifier: passetout
</source>
* Spécifiez un nom pour le copyright :
<source>
Please specify the copyright holder: Bibi
</source>
* Il est possible de spécifier des paramètres d'entrée qui peuvent permettre de régler le fonctionnement du bloc. Ce ne sera pas notre cas, ne rien saisir sur cette question :
<source>
Enter valid argument list, including default arguments:
</source>
* De même, on ne donnera pas de code permettant de tester le bon fonctionnement :
<source>
Add Python QA code? [Y/n] n
Add C++ QA code? [Y/n] n
</source>
* Plusieurs fichers sont alors crées :
<source>
Adding file 'lib/passetout_impl.h'...
Adding file 'lib/passetout_impl.cc'...
Adding file 'include/gnuradio/monModule/passetout.h'...
Adding file 'python/monModule/bindings/docstrings/passetout_pydoc_template.h'...
Adding file 'python/monModule/bindings/passetout_python.cc'...
Adding file 'grc/monModule_passetout.block.yml'...
Editing grc/CMakeLists.txt...
</source>

Quelques indications :
* le fichier <code>passetout_impl.h</code> contient l'entête de la classe de notre bloc
* le fichier <code>passetout_impl.cc</code> contient l'implémentation de la classe de notre bloc
* le fichier <code>monModule_passetout.block.yml</code> va contenir des informations faisant le lien entre notre code c++ et le code python utilisé en interne par Gnuradio
* Le tout sera compilé par un <code>Makefile</code> généré par <code>cmake</code>.

==== Fichier <code>passetout_impl.h</code> ====

Le code utile généré est le suivant :
<source lang=cpp>
class passetout_impl : public passetout
{
private:
// Nothing to declare in this block.

public:
passetout_impl();
~passetout_impl();

// Where all the action really happens
int work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items);
};
</source>

Pour se réveiller les neurones sur la POO, qu'est-ce que sont
* <code>passetout_impl()</code>,
* <code>~passetout_impl()</code>,
* <code>private</code>, <code>public</code> ?

Le travail sera réalisé dans la méthode <code>work()</code>, mais nous n'avons pas de modification à apporter dans les déclarations par défaut.

==== Fichier <code>passetout_impl.cc</code> ====

Le code utile généré est le suivant :

{{boîte déroulante/début|titre=passetout_impl.cc}}
<source lang=cpp>
namespace monModule {

#pragma message("set the following appropriately and remove this warning")
using input_type = float;
#pragma message("set the following appropriately and remove this warning")
using output_type = float;
passetout::sptr passetout::make() { return gnuradio::make_block_sptr<passetout_impl>(); }

/*
* The private constructor
*/
passetout_impl::passetout_impl()
: gr::sync_block("passetout",
gr::io_signature::make(
1 /* min inputs */, 1 /* max inputs */, sizeof(input_type)),
gr::io_signature::make(
1 /* min outputs */, 1 /*max outputs */, sizeof(output_type)))
{
}

/*
* Our virtual destructor.
*/
passetout_impl::~passetout_impl() {}

int passetout_impl::work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items)
{
auto in = static_cast<const input_type*>(input_items[0]);
auto out = static_cast<output_type*>(output_items[0]);

#pragma message("Implement the signal processing in your block and remove this warning")
// Do <+signal processing+>

// Tell runtime system how many output items we produced.
return noutput_items;
}

} /* namespace monModule */
</source>
{{boîte déroulante/fin}}

Détaillons :
<source lang=cpp>
#pragma message("set the following appropriately and remove this warning")
using input_type = float;
#pragma message("set the following appropriately and remove this warning")
using output_type = float;
</source>
{{Todos| On spécifie ici le type des données d'entrée et de sortie. Pas de modification à apporter, il suffit de supprimer les deux <code>#pragma</code>}}

<source lang=cpp>
passetout_impl::passetout_impl()
: gr::sync_block("passetout",
gr::io_signature::make(
1 /* min inputs */, 1 /* max inputs */, sizeof(input_type)),
gr::io_signature::make(
1 /* min outputs */, 1 /*max outputs */, sizeof(output_type)))
{
}
</source>

{{Todos| On spécifie ici le nombre d'entrées (1) et le nombre de sorties (1). Pas de modification non plus.}}

{{Todos| Expliquez la syntaxe <code>passetout_impl::passetout_impl() : gr::sync_block(...)"</code> }}

<source lang=cpp>
int passetout_impl::work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items)
{
auto in = static_cast<const input_type*>(input_items[0]);
auto out = static_cast<output_type*>(output_items[0]);

#pragma message("Implement the signal processing in your block and remove this warning")
// Do <+signal processing+>

// Tell runtime system how many output items we produced.
return noutput_items;
}
</source>
Cette méthode <code>work()</code> implémente véritablement le filtrage.
* Les tableaux <code>in</code> et <code>out</code> contiennent respectivement les données en entrée et les données en sortie. Il faut donc calculer <code>out</code> en fonction de <code>in</code>
* Les données d'entrée arrivent par paquets dans un buffer. La variable <code>noutput_items</code> contient le nombre de données disponibles en entrées.
* à la fin de la méthode, on renvoie le nombre de données en sortie que l'on a calculé (entre 1 et <code>noutput_items</code>). Les données d'entrées éventuellement non consommées seront conservées dans le buffer pour le prochain appel de <code>work()</code>
{{Todos| On souhaite ici seulement recopier l'entrée sur la sortie, donc }}
# Enlever la ligne <code>#pragma</code>
# ajouter le code <code> out[0] = in[0];</code> (on recopie le premier échantillon disponible en entrée)
# changer <code>return noutput_items;</code> en <code>return 1;</code> (un seul échantillon a été consommé).

==== Fichier <code>monModule_passetout.block.yml</code> ====

Ce fichier au format YAML (''yet another markup language'') fait le lien entre le code c++ et le code python utilisé en interne par GnuRadio.

{{boîte déroulante/début|titre=monModule_passetout.block.yml}}
<source lang=yaml>
id: monModule_passetout
label: passetout
category: '[monModule]'

templates:
imports: from gnuradio import monModule
make: monModule.passetout()

# Make one 'parameters' list entry for every parameter you want settable from the GUI.
# Keys include:
# * id (makes the value accessible as keyname, e.g. in the make entry)
# * label (label shown in the GUI)
# * dtype (e.g. int, float, complex, byte, short, xxx_vector, ...)
# * default
parameters:
- id: parametername_replace_me
label: FIX ME:
dtype: string
default: You need to fill in your grc/monModule_passetout.block.yaml
#- id: ...
# label: ...
# dtype: ...

# Make one 'inputs' list entry per input and one 'outputs' list entry per output.
# Keys include:
# * label (an identifier for the GUI)
# * domain (optional - stream or message. Default is stream)
# * dtype (e.g. int, float, complex, byte, short, xxx_vector, ...)
# * vlen (optional - data stream vector length. Default is 1)
# * optional (optional - set to 1 for optional inputs. Default is 0)
inputs:
#- label: ...
# domain: ...
# dtype: ...
# vlen: ...
# optional: ...

outputs:
#- label: ...
# domain: ...
# dtype: ...
# vlen: ...
# optional: ...

# 'file_format' specifies the version of the GRC yml format used in the file
# and should usually not be changed.
file_format: 1
</source>
{{boîte déroulante/fin}}

{{Todos| Mettre à jour la section <code>parameters</code> (pas de paramètres, on commente) :}}

<source lang=yaml>
#parameters:
#- id: parametername_replace_me
# label: FIX ME:
# dtype: string
# default: You need to fill in your grc/customModule_testMod.block.yaml
</source>

{{Todos| Mettre à jour la section <code>inputs</code> :}}

<source lang=yaml>
inputs:
- label: in
domain: stream
dtype: float
</source>

{{Todos| Mettre à jour la section <code>output</code> :}}

<source lang=yaml>
outputs:
- label: out
domain: stream
dtype: float
</source>

==== Compilation et installation ====

Voici les étapes :
<source lang=bash>
$ cd CHEMIN-DE-VOTRE-DOSSIER/gr-monModule
$ mkdir build
$ cd build
$ cmake ..
$ make
$ make install
</source>

* <code>cmake ..</code> lance la création des fichiers <code>Makefile</code> qui permettent la compilation et l'installation
* <code>make</code> lance la compilation
* <code>make install</code> lance l'installation (copie des fichiers dans les dossiers gnuradio)

{{Todos| Exécuter chacune de ces lignes, en contrôlant l'absence d'erreur. Dans le cas contraire, contrôler les fichiers <code>.h</code>, <code>.cc</code> et <code>.yaml</code>}}

{{Todos| '''Après ces étapes, et avant de lancer gnuRadio, appeler l'enseignant qui va mettre à jours les bibliothèques partagées.'''}}. Sinon tenter :
<source>
$ export LD_LIBRARY_PATH=/usr/local/lib/x86_64-linux-gnu:$LD_LIBRARY_PATH
$ gnuradio-companion &
</source>

==== Utilisation du bloc et test ====

* Dans Gnuradio, rafraichir la liste des bloc (bouton ''reload'')
* le bloc <code>passetout</code> doit être présent dans la section <code>monModule</code>
* Tester le bon fonctionnement de ce bloc en lui envoyant une sinusoïde que vous devez observer identique à la sortie du bloc. Vérifier avec des graphes.

==== Application : démodulation ====

En reprenant le signal modulé en amplitude et la fonction de transfert du filtre passe-bas du TP précédent :

* Obtenir l'équation aux différence du filtre, ''ie'' écrire ''y(n)='' en fonction de ''x(n)'', ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.
* Créer un nouveau bloc C++ (similaire au passe-tout précédent) dans le module <code>monModule</code> :
** de type <code>sync</code>
** une entrée en <code>float</code>
** une sortie en <code>float</code>
* Écrire le code permettant d'obtenir ''y(n)'' dans la méthode <code>work()</code> :
** ''x(n)'' est donné par <code>in0[0]</code>
** il sera nécessaire d'affecter <code>out0[0]</code> pour produire ''y(n)''.
** il sera nécessaire de stocker dans des '''attributs''' les valeurs de <code>in[0]</code> afin de disposer de ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.
** On rappelle que les attributs doivent être déclarées dans le fichier <code>.h</code> et initialisés dans le constructeur de la classe.

{{Todos| Réaliser cette implémentation du passe-bas et contrôler que la démodulation est identique à celle obtenue au TP précédent}}

{{Todos| Modifier votre code pour implémenter le filtre complet de démodulation}}

=== Approximation de PID par filtre numérique linéaire ===

==== Rappels PID ====

* Principe
* Définition mathématique

[[Fichier:EqPID.png|400px]]

==== PID numérique "classique" ====

* En approximant grossièrement l'intégrale et la dérivée
* Notebook exemple : asservissement de température

==== PID numérique par approximation d'un filtre continu ====

* Fonction de transfert Filtre continu d'un PID
* Approximation de la fonction de transfert pour obtenir un filtre numérique
** ''backward euler''
** et transformée bilinéaire
* Implémentation du Filtre : classe <code>FilterController</code>
* Application sur l'asservissement d'altitude d'un drone

Fichier:EqPID.png

2026-05-29T10:33:28Z

Fredmn :

Cours:Elen4 TNS TP TpsReel

2026-05-29T10:28:52Z

Fredmn :

[[Cours:Elen4_TNS|{{Rouge|'''Retour à la page du cours'''}}]]

<center>
'''<big>TP6 : Temps réel : Codage d'un bloc en Python / démodulation / PID Numérique</big>'''
</center>

Le but de ce TP est double :
* réaliser des implémentations temps réel de filtre IIR en créant un bloc Gnuradio qui execute un traitement codé en Python
* et étudier l'implémentation d'un PID numérique sous forme d'un filtre IIR.

=== Codage de bloc Gnuradio en Python ===

'''EN COURS DE RÉÉCRITURE (C++ vers Python)'''

Ce guide est inspirée du guide [https://wiki.gnuradio.org/index.php?title=Creating_C%2B%2B_OOT_with_gr-modtool Creating an OOT (C++ block example)] en l'adaptant pour nos besoins :

Nous allons créer un simple bloc qui recopie son entrée (en <code>float</code>) sur sa sortie. Donc le filtre caractérisé par ''y(n)'' = ''x(n)'' ou encore ''H(z)''=1. Il s'agit donc d'une sorte de filtre passe-tout.

'''Suivez bien toutes les étapes, sans aller trop rapidement'''

* Vous pourrez utiliser <code>gedit</code> pour éditer les divers fichiers.

==== Création d'un module externe ====

Dans les lignes qui suivent, le <code>$</code> indique que l'on saisi une commande dans un terminal. Le <code>$</code> n'est pas à saisir.

* Ouvrez un terminal et placez-vous à la racine de votre dossier personnel :
<source>
$ cd $HOME
</source>
* Créez un dossier de travail dédié à gnuradio et déplacez-vous à l'intérieur :
<source>
$ mkdir gnuradio
$ cd gnuradio
</source>
* GNU Radio est livré avec gr_modtool, un utilitaire qui permet de créer des modules externes (OOT). Créons un module <code>monModule</code>
<source>
$ gr_modtool newmod monModule
</source>
* Le dossier <code>gr-monModule</code> est créé et contient tout le code squelette d'un module OOT, mais il n'a pas encore de blocs. Déplacez-vous dans <code>gr-monModule</code> :
<source>
$ cd gr-monModule
</source>
* Vous pouvez afficher le contenu de ce dossier par
<source>
$ ls
</source>

==== Création d'un bloc dans ce module ====

* Ajoutez un nouveau bloc nommé <code>passetout</code> :
<source>
$ gr_modtool add passetout
</source>
* Quelques questions permettent alors de spécifier le type de bloc
<source>
GNU Radio module name identified: passetout
('sink', 'source', 'sync', 'decimator', 'interpolator', 'general', 'tagged_stream', 'hier', 'noblock')
</source>
Saisissez <code>sync</code> comme type de bloc, car le bloc que nous écrivons produira le même nombre d'échantillons en sortie que le nombre d'échantillons consommés depuis l'entrée.
<source>
Enter block type: sync
</source>
* Spécifiez <code>cpp</code> comme langage :
<source>
Language (python/cpp): cpp
Language: C++
Block/code identifier: passetout
</source>
* Spécifiez un nom pour le copyright :
<source>
Please specify the copyright holder: Bibi
</source>
* Il est possible de spécifier des paramètres d'entrée qui peuvent permettre de régler le fonctionnement du bloc. Ce ne sera pas notre cas, ne rien saisir sur cette question :
<source>
Enter valid argument list, including default arguments:
</source>
* De même, on ne donnera pas de code permettant de tester le bon fonctionnement :
<source>
Add Python QA code? [Y/n] n
Add C++ QA code? [Y/n] n
</source>
* Plusieurs fichers sont alors crées :
<source>
Adding file 'lib/passetout_impl.h'...
Adding file 'lib/passetout_impl.cc'...
Adding file 'include/gnuradio/monModule/passetout.h'...
Adding file 'python/monModule/bindings/docstrings/passetout_pydoc_template.h'...
Adding file 'python/monModule/bindings/passetout_python.cc'...
Adding file 'grc/monModule_passetout.block.yml'...
Editing grc/CMakeLists.txt...
</source>

Quelques indications :
* le fichier <code>passetout_impl.h</code> contient l'entête de la classe de notre bloc
* le fichier <code>passetout_impl.cc</code> contient l'implémentation de la classe de notre bloc
* le fichier <code>monModule_passetout.block.yml</code> va contenir des informations faisant le lien entre notre code c++ et le code python utilisé en interne par Gnuradio
* Le tout sera compilé par un <code>Makefile</code> généré par <code>cmake</code>.

==== Fichier <code>passetout_impl.h</code> ====

Le code utile généré est le suivant :
<source lang=cpp>
class passetout_impl : public passetout
{
private:
// Nothing to declare in this block.

public:
passetout_impl();
~passetout_impl();

// Where all the action really happens
int work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items);
};
</source>

Pour se réveiller les neurones sur la POO, qu'est-ce que sont
* <code>passetout_impl()</code>,
* <code>~passetout_impl()</code>,
* <code>private</code>, <code>public</code> ?

Le travail sera réalisé dans la méthode <code>work()</code>, mais nous n'avons pas de modification à apporter dans les déclarations par défaut.

==== Fichier <code>passetout_impl.cc</code> ====

Le code utile généré est le suivant :

{{boîte déroulante/début|titre=passetout_impl.cc}}
<source lang=cpp>
namespace monModule {

#pragma message("set the following appropriately and remove this warning")
using input_type = float;
#pragma message("set the following appropriately and remove this warning")
using output_type = float;
passetout::sptr passetout::make() { return gnuradio::make_block_sptr<passetout_impl>(); }

/*
* The private constructor
*/
passetout_impl::passetout_impl()
: gr::sync_block("passetout",
gr::io_signature::make(
1 /* min inputs */, 1 /* max inputs */, sizeof(input_type)),
gr::io_signature::make(
1 /* min outputs */, 1 /*max outputs */, sizeof(output_type)))
{
}

/*
* Our virtual destructor.
*/
passetout_impl::~passetout_impl() {}

int passetout_impl::work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items)
{
auto in = static_cast<const input_type*>(input_items[0]);
auto out = static_cast<output_type*>(output_items[0]);

#pragma message("Implement the signal processing in your block and remove this warning")
// Do <+signal processing+>

// Tell runtime system how many output items we produced.
return noutput_items;
}

} /* namespace monModule */
</source>
{{boîte déroulante/fin}}

Détaillons :
<source lang=cpp>
#pragma message("set the following appropriately and remove this warning")
using input_type = float;
#pragma message("set the following appropriately and remove this warning")
using output_type = float;
</source>
{{Todos| On spécifie ici le type des données d'entrée et de sortie. Pas de modification à apporter, il suffit de supprimer les deux <code>#pragma</code>}}

<source lang=cpp>
passetout_impl::passetout_impl()
: gr::sync_block("passetout",
gr::io_signature::make(
1 /* min inputs */, 1 /* max inputs */, sizeof(input_type)),
gr::io_signature::make(
1 /* min outputs */, 1 /*max outputs */, sizeof(output_type)))
{
}
</source>

{{Todos| On spécifie ici le nombre d'entrées (1) et le nombre de sorties (1). Pas de modification non plus.}}

{{Todos| Expliquez la syntaxe <code>passetout_impl::passetout_impl() : gr::sync_block(...)"</code> }}

<source lang=cpp>
int passetout_impl::work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items)
{
auto in = static_cast<const input_type*>(input_items[0]);
auto out = static_cast<output_type*>(output_items[0]);

#pragma message("Implement the signal processing in your block and remove this warning")
// Do <+signal processing+>

// Tell runtime system how many output items we produced.
return noutput_items;
}
</source>
Cette méthode <code>work()</code> implémente véritablement le filtrage.
* Les tableaux <code>in</code> et <code>out</code> contiennent respectivement les données en entrée et les données en sortie. Il faut donc calculer <code>out</code> en fonction de <code>in</code>
* Les données d'entrée arrivent par paquets dans un buffer. La variable <code>noutput_items</code> contient le nombre de données disponibles en entrées.
* à la fin de la méthode, on renvoie le nombre de données en sortie que l'on a calculé (entre 1 et <code>noutput_items</code>). Les données d'entrées éventuellement non consommées seront conservées dans le buffer pour le prochain appel de <code>work()</code>
{{Todos| On souhaite ici seulement recopier l'entrée sur la sortie, donc }}
# Enlever la ligne <code>#pragma</code>
# ajouter le code <code> out[0] = in[0];</code> (on recopie le premier échantillon disponible en entrée)
# changer <code>return noutput_items;</code> en <code>return 1;</code> (un seul échantillon a été consommé).

==== Fichier <code>monModule_passetout.block.yml</code> ====

Ce fichier au format YAML (''yet another markup language'') fait le lien entre le code c++ et le code python utilisé en interne par GnuRadio.

{{boîte déroulante/début|titre=monModule_passetout.block.yml}}
<source lang=yaml>
id: monModule_passetout
label: passetout
category: '[monModule]'

templates:
imports: from gnuradio import monModule
make: monModule.passetout()

# Make one 'parameters' list entry for every parameter you want settable from the GUI.
# Keys include:
# * id (makes the value accessible as keyname, e.g. in the make entry)
# * label (label shown in the GUI)
# * dtype (e.g. int, float, complex, byte, short, xxx_vector, ...)
# * default
parameters:
- id: parametername_replace_me
label: FIX ME:
dtype: string
default: You need to fill in your grc/monModule_passetout.block.yaml
#- id: ...
# label: ...
# dtype: ...

# Make one 'inputs' list entry per input and one 'outputs' list entry per output.
# Keys include:
# * label (an identifier for the GUI)
# * domain (optional - stream or message. Default is stream)
# * dtype (e.g. int, float, complex, byte, short, xxx_vector, ...)
# * vlen (optional - data stream vector length. Default is 1)
# * optional (optional - set to 1 for optional inputs. Default is 0)
inputs:
#- label: ...
# domain: ...
# dtype: ...
# vlen: ...
# optional: ...

outputs:
#- label: ...
# domain: ...
# dtype: ...
# vlen: ...
# optional: ...

# 'file_format' specifies the version of the GRC yml format used in the file
# and should usually not be changed.
file_format: 1
</source>
{{boîte déroulante/fin}}

{{Todos| Mettre à jour la section <code>parameters</code> (pas de paramètres, on commente) :}}

<source lang=yaml>
#parameters:
#- id: parametername_replace_me
# label: FIX ME:
# dtype: string
# default: You need to fill in your grc/customModule_testMod.block.yaml
</source>

{{Todos| Mettre à jour la section <code>inputs</code> :}}

<source lang=yaml>
inputs:
- label: in
domain: stream
dtype: float
</source>

{{Todos| Mettre à jour la section <code>output</code> :}}

<source lang=yaml>
outputs:
- label: out
domain: stream
dtype: float
</source>

==== Compilation et installation ====

Voici les étapes :
<source lang=bash>
$ cd CHEMIN-DE-VOTRE-DOSSIER/gr-monModule
$ mkdir build
$ cd build
$ cmake ..
$ make
$ make install
</source>

* <code>cmake ..</code> lance la création des fichiers <code>Makefile</code> qui permettent la compilation et l'installation
* <code>make</code> lance la compilation
* <code>make install</code> lance l'installation (copie des fichiers dans les dossiers gnuradio)

{{Todos| Exécuter chacune de ces lignes, en contrôlant l'absence d'erreur. Dans le cas contraire, contrôler les fichiers <code>.h</code>, <code>.cc</code> et <code>.yaml</code>}}

{{Todos| '''Après ces étapes, et avant de lancer gnuRadio, appeler l'enseignant qui va mettre à jours les bibliothèques partagées.'''}}. Sinon tenter :
<source>
$ export LD_LIBRARY_PATH=/usr/local/lib/x86_64-linux-gnu:$LD_LIBRARY_PATH
$ gnuradio-companion &
</source>

==== Utilisation du bloc et test ====

* Dans Gnuradio, rafraichir la liste des bloc (bouton ''reload'')
* le bloc <code>passetout</code> doit être présent dans la section <code>monModule</code>
* Tester le bon fonctionnement de ce bloc en lui envoyant une sinusoïde que vous devez observer identique à la sortie du bloc. Vérifier avec des graphes.

==== Application : démodulation ====

En reprenant le signal modulé en amplitude et la fonction de transfert du filtre passe-bas du TP précédent :

* Obtenir l'équation aux différence du filtre, ''ie'' écrire ''y(n)='' en fonction de ''x(n)'', ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.
* Créer un nouveau bloc C++ (similaire au passe-tout précédent) dans le module <code>monModule</code> :
** de type <code>sync</code>
** une entrée en <code>float</code>
** une sortie en <code>float</code>
* Écrire le code permettant d'obtenir ''y(n)'' dans la méthode <code>work()</code> :
** ''x(n)'' est donné par <code>in0[0]</code>
** il sera nécessaire d'affecter <code>out0[0]</code> pour produire ''y(n)''.
** il sera nécessaire de stocker dans des '''attributs''' les valeurs de <code>in[0]</code> afin de disposer de ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.
** On rappelle que les attributs doivent être déclarées dans le fichier <code>.h</code> et initialisés dans le constructeur de la classe.

{{Todos| Réaliser cette implémentation du passe-bas et contrôler que la démodulation est identique à celle obtenue au TP précédent}}

{{Todos| Modifier votre code pour implémenter le filtre complet de démodulation}}

=== Approximation de PID par filtre numérique linéaire ===

==== Rappels PID ====

* Principe
* Définitions mathématique

==== PID numérique "classique" ====

* En approximant grossièrement l'intégrale et la dérivée
* Notebook exemple : asservissement de température

==== PID numérique par approximation d'un filtre continu ====

* Fonction de transfert Filtre continu d'un PID
* Approximation de la fonction de transfert pour obtenir un filtre numérique
** ''backward euler''
** et transformée bilinéaire
* Implémentation du Filtre : classe <code>FilterController</code>
* Application sur l'asservissement d'altitude d'un drone

Cours:Elen4 TNS TP TpsReel

2026-05-29T10:28:21Z

Fredmn : /* Approximation de PID par filtre numérique linéaire */

[[Cours:Elen4_TNS|{{Rouge|'''Retour à la page du cours'''}}]]

<center>
'''<big>TP6 : Temps réel : Codage d'un bloc en Python / démodulation / PID Numérique</big>'''
</center>

Le but de ce TP est double :
* réaliser des implémentations temps réel de filtre IIR en créant un bloc Gnuradio qui execute un traitement codé en Python
* et étudier l'implémentation d'un PID numérique sous forme d'un filtre IIR.

=== Codage de bloc Gnuradio en Python ===

'''EN COURS DE RÉÉCRITURE (C++ vers Python)'''

Ce guide est inspirée du guide [https://wiki.gnuradio.org/index.php?title=Creating_C%2B%2B_OOT_with_gr-modtool Creating an OOT (C++ block example)] en l'adaptant pour nos besoins :

Nous allons créer un simple bloc qui recopie son entrée (en <code>float</code>) sur sa sortie. Donc le filtre caractérisé par ''y(n)'' = ''x(n)'' ou encore ''H(z)''=1. Il s'agit donc d'une sorte de filtre passe-tout.

'''Suivez bien toutes les étapes, sans aller trop rapidement'''

* Vous pourrez utiliser <code>gedit</code> pour éditer les divers fichiers.

==== Création d'un module externe ====

Dans les lignes qui suivent, le <code>$</code> indique que l'on saisi une commande dans un terminal. Le <code>$</code> n'est pas à saisir.

* Ouvrez un terminal et placez-vous à la racine de votre dossier personnel :
<source>
$ cd $HOME
</source>
* Créez un dossier de travail dédié à gnuradio et déplacez-vous à l'intérieur :
<source>
$ mkdir gnuradio
$ cd gnuradio
</source>
* GNU Radio est livré avec gr_modtool, un utilitaire qui permet de créer des modules externes (OOT). Créons un module <code>monModule</code>
<source>
$ gr_modtool newmod monModule
</source>
* Le dossier <code>gr-monModule</code> est créé et contient tout le code squelette d'un module OOT, mais il n'a pas encore de blocs. Déplacez-vous dans <code>gr-monModule</code> :
<source>
$ cd gr-monModule
</source>
* Vous pouvez afficher le contenu de ce dossier par
<source>
$ ls
</source>

==== Création d'un bloc dans ce module ====

* Ajoutez un nouveau bloc nommé <code>passetout</code> :
<source>
$ gr_modtool add passetout
</source>
* Quelques questions permettent alors de spécifier le type de bloc
<source>
GNU Radio module name identified: passetout
('sink', 'source', 'sync', 'decimator', 'interpolator', 'general', 'tagged_stream', 'hier', 'noblock')
</source>
Saisissez <code>sync</code> comme type de bloc, car le bloc que nous écrivons produira le même nombre d'échantillons en sortie que le nombre d'échantillons consommés depuis l'entrée.
<source>
Enter block type: sync
</source>
* Spécifiez <code>cpp</code> comme langage :
<source>
Language (python/cpp): cpp
Language: C++
Block/code identifier: passetout
</source>
* Spécifiez un nom pour le copyright :
<source>
Please specify the copyright holder: Bibi
</source>
* Il est possible de spécifier des paramètres d'entrée qui peuvent permettre de régler le fonctionnement du bloc. Ce ne sera pas notre cas, ne rien saisir sur cette question :
<source>
Enter valid argument list, including default arguments:
</source>
* De même, on ne donnera pas de code permettant de tester le bon fonctionnement :
<source>
Add Python QA code? [Y/n] n
Add C++ QA code? [Y/n] n
</source>
* Plusieurs fichers sont alors crées :
<source>
Adding file 'lib/passetout_impl.h'...
Adding file 'lib/passetout_impl.cc'...
Adding file 'include/gnuradio/monModule/passetout.h'...
Adding file 'python/monModule/bindings/docstrings/passetout_pydoc_template.h'...
Adding file 'python/monModule/bindings/passetout_python.cc'...
Adding file 'grc/monModule_passetout.block.yml'...
Editing grc/CMakeLists.txt...
</source>

Quelques indications :
* le fichier <code>passetout_impl.h</code> contient l'entête de la classe de notre bloc
* le fichier <code>passetout_impl.cc</code> contient l'implémentation de la classe de notre bloc
* le fichier <code>monModule_passetout.block.yml</code> va contenir des informations faisant le lien entre notre code c++ et le code python utilisé en interne par Gnuradio
* Le tout sera compilé par un <code>Makefile</code> généré par <code>cmake</code>.

==== Fichier <code>passetout_impl.h</code> ====

Le code utile généré est le suivant :
<source lang=cpp>
class passetout_impl : public passetout
{
private:
// Nothing to declare in this block.

public:
passetout_impl();
~passetout_impl();

// Where all the action really happens
int work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items);
};
</source>

Pour se réveiller les neurones sur la POO, qu'est-ce que sont
* <code>passetout_impl()</code>,
* <code>~passetout_impl()</code>,
* <code>private</code>, <code>public</code> ?

Le travail sera réalisé dans la méthode <code>work()</code>, mais nous n'avons pas de modification à apporter dans les déclarations par défaut.

==== Fichier <code>passetout_impl.cc</code> ====

Le code utile généré est le suivant :

{{boîte déroulante/début|titre=passetout_impl.cc}}
<source lang=cpp>
namespace monModule {

#pragma message("set the following appropriately and remove this warning")
using input_type = float;
#pragma message("set the following appropriately and remove this warning")
using output_type = float;
passetout::sptr passetout::make() { return gnuradio::make_block_sptr<passetout_impl>(); }

/*
* The private constructor
*/
passetout_impl::passetout_impl()
: gr::sync_block("passetout",
gr::io_signature::make(
1 /* min inputs */, 1 /* max inputs */, sizeof(input_type)),
gr::io_signature::make(
1 /* min outputs */, 1 /*max outputs */, sizeof(output_type)))
{
}

/*
* Our virtual destructor.
*/
passetout_impl::~passetout_impl() {}

int passetout_impl::work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items)
{
auto in = static_cast<const input_type*>(input_items[0]);
auto out = static_cast<output_type*>(output_items[0]);

#pragma message("Implement the signal processing in your block and remove this warning")
// Do <+signal processing+>

// Tell runtime system how many output items we produced.
return noutput_items;
}

} /* namespace monModule */
</source>
{{boîte déroulante/fin}}

Détaillons :
<source lang=cpp>
#pragma message("set the following appropriately and remove this warning")
using input_type = float;
#pragma message("set the following appropriately and remove this warning")
using output_type = float;
</source>
{{Todos| On spécifie ici le type des données d'entrée et de sortie. Pas de modification à apporter, il suffit de supprimer les deux <code>#pragma</code>}}

<source lang=cpp>
passetout_impl::passetout_impl()
: gr::sync_block("passetout",
gr::io_signature::make(
1 /* min inputs */, 1 /* max inputs */, sizeof(input_type)),
gr::io_signature::make(
1 /* min outputs */, 1 /*max outputs */, sizeof(output_type)))
{
}
</source>

{{Todos| On spécifie ici le nombre d'entrées (1) et le nombre de sorties (1). Pas de modification non plus.}}

{{Todos| Expliquez la syntaxe <code>passetout_impl::passetout_impl() : gr::sync_block(...)"</code> }}

<source lang=cpp>
int passetout_impl::work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items)
{
auto in = static_cast<const input_type*>(input_items[0]);
auto out = static_cast<output_type*>(output_items[0]);

#pragma message("Implement the signal processing in your block and remove this warning")
// Do <+signal processing+>

// Tell runtime system how many output items we produced.
return noutput_items;
}
</source>
Cette méthode <code>work()</code> implémente véritablement le filtrage.
* Les tableaux <code>in</code> et <code>out</code> contiennent respectivement les données en entrée et les données en sortie. Il faut donc calculer <code>out</code> en fonction de <code>in</code>
* Les données d'entrée arrivent par paquets dans un buffer. La variable <code>noutput_items</code> contient le nombre de données disponibles en entrées.
* à la fin de la méthode, on renvoie le nombre de données en sortie que l'on a calculé (entre 1 et <code>noutput_items</code>). Les données d'entrées éventuellement non consommées seront conservées dans le buffer pour le prochain appel de <code>work()</code>
{{Todos| On souhaite ici seulement recopier l'entrée sur la sortie, donc }}
# Enlever la ligne <code>#pragma</code>
# ajouter le code <code> out[0] = in[0];</code> (on recopie le premier échantillon disponible en entrée)
# changer <code>return noutput_items;</code> en <code>return 1;</code> (un seul échantillon a été consommé).

==== Fichier <code>monModule_passetout.block.yml</code> ====

Ce fichier au format YAML (''yet another markup language'') fait le lien entre le code c++ et le code python utilisé en interne par GnuRadio.

{{boîte déroulante/début|titre=monModule_passetout.block.yml}}
<source lang=yaml>
id: monModule_passetout
label: passetout
category: '[monModule]'

templates:
imports: from gnuradio import monModule
make: monModule.passetout()

# Make one 'parameters' list entry for every parameter you want settable from the GUI.
# Keys include:
# * id (makes the value accessible as keyname, e.g. in the make entry)
# * label (label shown in the GUI)
# * dtype (e.g. int, float, complex, byte, short, xxx_vector, ...)
# * default
parameters:
- id: parametername_replace_me
label: FIX ME:
dtype: string
default: You need to fill in your grc/monModule_passetout.block.yaml
#- id: ...
# label: ...
# dtype: ...

# Make one 'inputs' list entry per input and one 'outputs' list entry per output.
# Keys include:
# * label (an identifier for the GUI)
# * domain (optional - stream or message. Default is stream)
# * dtype (e.g. int, float, complex, byte, short, xxx_vector, ...)
# * vlen (optional - data stream vector length. Default is 1)
# * optional (optional - set to 1 for optional inputs. Default is 0)
inputs:
#- label: ...
# domain: ...
# dtype: ...
# vlen: ...
# optional: ...

outputs:
#- label: ...
# domain: ...
# dtype: ...
# vlen: ...
# optional: ...

# 'file_format' specifies the version of the GRC yml format used in the file
# and should usually not be changed.
file_format: 1
</source>
{{boîte déroulante/fin}}

{{Todos| Mettre à jour la section <code>parameters</code> (pas de paramètres, on commente) :}}

<source lang=yaml>
#parameters:
#- id: parametername_replace_me
# label: FIX ME:
# dtype: string
# default: You need to fill in your grc/customModule_testMod.block.yaml
</source>

{{Todos| Mettre à jour la section <code>inputs</code> :}}

<source lang=yaml>
inputs:
- label: in
domain: stream
dtype: float
</source>

{{Todos| Mettre à jour la section <code>output</code> :}}

<source lang=yaml>
outputs:
- label: out
domain: stream
dtype: float
</source>

==== Compilation et installation ====

Voici les étapes :
<source lang=bash>
$ cd CHEMIN-DE-VOTRE-DOSSIER/gr-monModule
$ mkdir build
$ cd build
$ cmake ..
$ make
$ make install
</source>

* <code>cmake ..</code> lance la création des fichiers <code>Makefile</code> qui permettent la compilation et l'installation
* <code>make</code> lance la compilation
* <code>make install</code> lance l'installation (copie des fichiers dans les dossiers gnuradio)

{{Todos| Exécuter chacune de ces lignes, en contrôlant l'absence d'erreur. Dans le cas contraire, contrôler les fichiers <code>.h</code>, <code>.cc</code> et <code>.yaml</code>}}

{{Todos| '''Après ces étapes, et avant de lancer gnuRadio, appeler l'enseignant qui va mettre à jours les bibliothèques partagées.'''}}. Sinon tenter :
<source>
$ export LD_LIBRARY_PATH=/usr/local/lib/x86_64-linux-gnu:$LD_LIBRARY_PATH
$ gnuradio-companion &
</source>

==== Utilisation du bloc et test ====

* Dans Gnuradio, rafraichir la liste des bloc (bouton ''reload'')
* le bloc <code>passetout</code> doit être présent dans la section <code>monModule</code>
* Tester le bon fonctionnement de ce bloc en lui envoyant une sinusoïde que vous devez observer identique à la sortie du bloc. Vérifier avec des graphes.

==== Application : démodulation ====

En reprenant le signal modulé en amplitude et la fonction de transfert du filtre passe-bas du TP précédent :

* Obtenir l'équation aux différence du filtre, ''ie'' écrire ''y(n)='' en fonction de ''x(n)'', ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.
* Créer un nouveau bloc C++ (similaire au passe-tout précédent) dans le module <code>monModule</code> :
** de type <code>sync</code>
** une entrée en <code>float</code>
** une sortie en <code>float</code>
* Écrire le code permettant d'obtenir ''y(n)'' dans la méthode <code>work()</code> :
** ''x(n)'' est donné par <code>in0[0]</code>
** il sera nécessaire d'affecter <code>out0[0]</code> pour produire ''y(n)''.
** il sera nécessaire de stocker dans des '''attributs''' les valeurs de <code>in[0]</code> afin de disposer de ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.
** On rappelle que les attributs doivent être déclarées dans le fichier <code>.h</code> et initialisés dans le constructeur de la classe.

{{Todos| Réaliser cette implémentation du passe-bas et contrôler que la démodulation est identique à celle obtenue au TP précédent}}

{{Todos| Modifier votre code pour implémenter le filtre complet de démodulation}}

=== Approximation de PID par filtre numérique linéaire ===

==== Rappels PID ====

* Principe
* Définitions mathématique

==== PID numérique "classique" ===

* En approximant grossièrement l'intégrale et la dérivée
* Notebook exemple : asservissement de température

==== PID numérique par approximation d'un filtre continu ====

* Fonction de transfert Filtre continu d'un PID
* Approximation de la fonction de transfert pour obtenir un filtre numérique
** ''backward euler''
** et transformée bilinéaire
* Implémentation du Filtre : classe <code>FilterController</code>
* Application sur l'asservissement d'altitude d'un drone

Cours:Elen4 TNS TP TpsReel

2026-05-29T10:19:21Z

Fredmn :

Cours:Elen4 TNS TP TpsReel

2026-05-29T10:18:54Z

Fredmn :

[[Cours:Elen4_TNS|{{Rouge|'''Retour à la page du cours'''}}]]

<center>
'''<big>TP6 : Temps réel : Codage d'un bloc en Python / démodulation / PID Numérique</big>'''
</center>

Le but de ce TP est double :
* réaliser des implémentations temps réel de filtre IIR en créant un bloc Gnuradio qui execute un traitement codé en Python
* et étudier l'implémentation d'un PID numérique sous forme d'un filtre IIR.

=== Codage de bloc Gnuradio en Python ===

'''EN COURS DE RÉÉCRITURE (C++ vers Python)'''

Ce guide est inspirée du guide [https://wiki.gnuradio.org/index.php?title=Creating_C%2B%2B_OOT_with_gr-modtool Creating an OOT (C++ block example)] en l'adaptant pour nos besoins :

Nous allons créer un simple bloc qui recopie son entrée (en <code>float</code>) sur sa sortie. Donc le filtre caractérisé par ''y(n)'' = ''x(n)'' ou encore ''H(z)''=1. Il s'agit donc d'une sorte de filtre passe-tout.

'''Suivez bien toutes les étapes, sans aller trop rapidement'''

* Vous pourrez utiliser <code>gedit</code> pour éditer les divers fichiers.

==== Création d'un module externe ====

Dans les lignes qui suivent, le <code>$</code> indique que l'on saisi une commande dans un terminal. Le <code>$</code> n'est pas à saisir.

* Ouvrez un terminal et placez-vous à la racine de votre dossier personnel :
<source>
$ cd $HOME
</source>
* Créez un dossier de travail dédié à gnuradio et déplacez-vous à l'intérieur :
<source>
$ mkdir gnuradio
$ cd gnuradio
</source>
* GNU Radio est livré avec gr_modtool, un utilitaire qui permet de créer des modules externes (OOT). Créons un module <code>monModule</code>
<source>
$ gr_modtool newmod monModule
</source>
* Le dossier <code>gr-monModule</code> est créé et contient tout le code squelette d'un module OOT, mais il n'a pas encore de blocs. Déplacez-vous dans <code>gr-monModule</code> :
<source>
$ cd gr-monModule
</source>
* Vous pouvez afficher le contenu de ce dossier par
<source>
$ ls
</source>

==== Création d'un bloc dans ce module ====

* Ajoutez un nouveau bloc nommé <code>passetout</code> :
<source>
$ gr_modtool add passetout
</source>
* Quelques questions permettent alors de spécifier le type de bloc
<source>
GNU Radio module name identified: passetout
('sink', 'source', 'sync', 'decimator', 'interpolator', 'general', 'tagged_stream', 'hier', 'noblock')
</source>
Saisissez <code>sync</code> comme type de bloc, car le bloc que nous écrivons produira le même nombre d'échantillons en sortie que le nombre d'échantillons consommés depuis l'entrée.
<source>
Enter block type: sync
</source>
* Spécifiez <code>cpp</code> comme langage :
<source>
Language (python/cpp): cpp
Language: C++
Block/code identifier: passetout
</source>
* Spécifiez un nom pour le copyright :
<source>
Please specify the copyright holder: Bibi
</source>
* Il est possible de spécifier des paramètres d'entrée qui peuvent permettre de régler le fonctionnement du bloc. Ce ne sera pas notre cas, ne rien saisir sur cette question :
<source>
Enter valid argument list, including default arguments:
</source>
* De même, on ne donnera pas de code permettant de tester le bon fonctionnement :
<source>
Add Python QA code? [Y/n] n
Add C++ QA code? [Y/n] n
</source>
* Plusieurs fichers sont alors crées :
<source>
Adding file 'lib/passetout_impl.h'...
Adding file 'lib/passetout_impl.cc'...
Adding file 'include/gnuradio/monModule/passetout.h'...
Adding file 'python/monModule/bindings/docstrings/passetout_pydoc_template.h'...
Adding file 'python/monModule/bindings/passetout_python.cc'...
Adding file 'grc/monModule_passetout.block.yml'...
Editing grc/CMakeLists.txt...
</source>

Quelques indications :
* le fichier <code>passetout_impl.h</code> contient l'entête de la classe de notre bloc
* le fichier <code>passetout_impl.cc</code> contient l'implémentation de la classe de notre bloc
* le fichier <code>monModule_passetout.block.yml</code> va contenir des informations faisant le lien entre notre code c++ et le code python utilisé en interne par Gnuradio
* Le tout sera compilé par un <code>Makefile</code> généré par <code>cmake</code>.

==== Fichier <code>passetout_impl.h</code> ====

Le code utile généré est le suivant :
<source lang=cpp>
class passetout_impl : public passetout
{
private:
// Nothing to declare in this block.

public:
passetout_impl();
~passetout_impl();

// Where all the action really happens
int work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items);
};
</source>

Pour se réveiller les neurones sur la POO, qu'est-ce que sont
* <code>passetout_impl()</code>,
* <code>~passetout_impl()</code>,
* <code>private</code>, <code>public</code> ?

Le travail sera réalisé dans la méthode <code>work()</code>, mais nous n'avons pas de modification à apporter dans les déclarations par défaut.

==== Fichier <code>passetout_impl.cc</code> ====

Le code utile généré est le suivant :

{{boîte déroulante/début|titre=passetout_impl.cc}}
<source lang=cpp>
namespace monModule {

#pragma message("set the following appropriately and remove this warning")
using input_type = float;
#pragma message("set the following appropriately and remove this warning")
using output_type = float;
passetout::sptr passetout::make() { return gnuradio::make_block_sptr<passetout_impl>(); }

/*
* The private constructor
*/
passetout_impl::passetout_impl()
: gr::sync_block("passetout",
gr::io_signature::make(
1 /* min inputs */, 1 /* max inputs */, sizeof(input_type)),
gr::io_signature::make(
1 /* min outputs */, 1 /*max outputs */, sizeof(output_type)))
{
}

/*
* Our virtual destructor.
*/
passetout_impl::~passetout_impl() {}

int passetout_impl::work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items)
{
auto in = static_cast<const input_type*>(input_items[0]);
auto out = static_cast<output_type*>(output_items[0]);

#pragma message("Implement the signal processing in your block and remove this warning")
// Do <+signal processing+>

// Tell runtime system how many output items we produced.
return noutput_items;
}

} /* namespace monModule */
</source>
{{boîte déroulante/fin}}

Détaillons :
<source lang=cpp>
#pragma message("set the following appropriately and remove this warning")
using input_type = float;
#pragma message("set the following appropriately and remove this warning")
using output_type = float;
</source>
{{Todos| On spécifie ici le type des données d'entrée et de sortie. Pas de modification à apporter, il suffit de supprimer les deux <code>#pragma</code>}}

<source lang=cpp>
passetout_impl::passetout_impl()
: gr::sync_block("passetout",
gr::io_signature::make(
1 /* min inputs */, 1 /* max inputs */, sizeof(input_type)),
gr::io_signature::make(
1 /* min outputs */, 1 /*max outputs */, sizeof(output_type)))
{
}
</source>

{{Todos| On spécifie ici le nombre d'entrées (1) et le nombre de sorties (1). Pas de modification non plus.}}

{{Todos| Expliquez la syntaxe <code>passetout_impl::passetout_impl() : gr::sync_block(...)"</code> }}

<source lang=cpp>
int passetout_impl::work(int noutput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items)
{
auto in = static_cast<const input_type*>(input_items[0]);
auto out = static_cast<output_type*>(output_items[0]);

#pragma message("Implement the signal processing in your block and remove this warning")
// Do <+signal processing+>

// Tell runtime system how many output items we produced.
return noutput_items;
}
</source>
Cette méthode <code>work()</code> implémente véritablement le filtrage.
* Les tableaux <code>in</code> et <code>out</code> contiennent respectivement les données en entrée et les données en sortie. Il faut donc calculer <code>out</code> en fonction de <code>in</code>
* Les données d'entrée arrivent par paquets dans un buffer. La variable <code>noutput_items</code> contient le nombre de données disponibles en entrées.
* à la fin de la méthode, on renvoie le nombre de données en sortie que l'on a calculé (entre 1 et <code>noutput_items</code>). Les données d'entrées éventuellement non consommées seront conservées dans le buffer pour le prochain appel de <code>work()</code>
{{Todos| On souhaite ici seulement recopier l'entrée sur la sortie, donc }}
# Enlever la ligne <code>#pragma</code>
# ajouter le code <code> out[0] = in[0];</code> (on recopie le premier échantillon disponible en entrée)
# changer <code>return noutput_items;</code> en <code>return 1;</code> (un seul échantillon a été consommé).

==== Fichier <code>monModule_passetout.block.yml</code> ====

Ce fichier au format YAML (''yet another markup language'') fait le lien entre le code c++ et le code python utilisé en interne par GnuRadio.

{{boîte déroulante/début|titre=monModule_passetout.block.yml}}
<source lang=yaml>
id: monModule_passetout
label: passetout
category: '[monModule]'

templates:
imports: from gnuradio import monModule
make: monModule.passetout()

# Make one 'parameters' list entry for every parameter you want settable from the GUI.
# Keys include:
# * id (makes the value accessible as keyname, e.g. in the make entry)
# * label (label shown in the GUI)
# * dtype (e.g. int, float, complex, byte, short, xxx_vector, ...)
# * default
parameters:
- id: parametername_replace_me
label: FIX ME:
dtype: string
default: You need to fill in your grc/monModule_passetout.block.yaml
#- id: ...
# label: ...
# dtype: ...

# Make one 'inputs' list entry per input and one 'outputs' list entry per output.
# Keys include:
# * label (an identifier for the GUI)
# * domain (optional - stream or message. Default is stream)
# * dtype (e.g. int, float, complex, byte, short, xxx_vector, ...)
# * vlen (optional - data stream vector length. Default is 1)
# * optional (optional - set to 1 for optional inputs. Default is 0)
inputs:
#- label: ...
# domain: ...
# dtype: ...
# vlen: ...
# optional: ...

outputs:
#- label: ...
# domain: ...
# dtype: ...
# vlen: ...
# optional: ...

# 'file_format' specifies the version of the GRC yml format used in the file
# and should usually not be changed.
file_format: 1
</source>
{{boîte déroulante/fin}}

{{Todos| Mettre à jour la section <code>parameters</code> (pas de paramètres, on commente) :}}

<source lang=yaml>
#parameters:
#- id: parametername_replace_me
# label: FIX ME:
# dtype: string
# default: You need to fill in your grc/customModule_testMod.block.yaml
</source>

{{Todos| Mettre à jour la section <code>inputs</code> :}}

<source lang=yaml>
inputs:
- label: in
domain: stream
dtype: float
</source>

{{Todos| Mettre à jour la section <code>output</code> :}}

<source lang=yaml>
outputs:
- label: out
domain: stream
dtype: float
</source>

==== Compilation et installation ====

Voici les étapes :
<source lang=bash>
$ cd CHEMIN-DE-VOTRE-DOSSIER/gr-monModule
$ mkdir build
$ cd build
$ cmake ..
$ make
$ make install
</source>

* <code>cmake ..</code> lance la création des fichiers <code>Makefile</code> qui permettent la compilation et l'installation
* <code>make</code> lance la compilation
* <code>make install</code> lance l'installation (copie des fichiers dans les dossiers gnuradio)

{{Todos| Exécuter chacune de ces lignes, en contrôlant l'absence d'erreur. Dans le cas contraire, contrôler les fichiers <code>.h</code>, <code>.cc</code> et <code>.yaml</code>}}

{{Todos| '''Après ces étapes, et avant de lancer gnuRadio, appeler l'enseignant qui va mettre à jours les bibliothèques partagées.'''}}. Sinon tenter :
<source>
$ export LD_LIBRARY_PATH=/usr/local/lib/x86_64-linux-gnu:$LD_LIBRARY_PATH
$ gnuradio-companion &
</source>

==== Utilisation du bloc et test ====

* Dans Gnuradio, rafraichir la liste des bloc (bouton ''reload'')
* le bloc <code>passetout</code> doit être présent dans la section <code>monModule</code>
* Tester le bon fonctionnement de ce bloc en lui envoyant une sinusoïde que vous devez observer identique à la sortie du bloc. Vérifier avec des graphes.

== Application : démodulation ==

En reprenant le signal modulé en amplitude et la fonction de transfert du filtre passe-bas du TP précédent :

* Obtenir l'équation aux différence du filtre, ''ie'' écrire ''y(n)='' en fonction de ''x(n)'', ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.
* Créer un nouveau bloc C++ (similaire au passe-tout précédent) dans le module <code>monModule</code> :
** de type <code>sync</code>
** une entrée en <code>float</code>
** une sortie en <code>float</code>
* Écrire le code permettant d'obtenir ''y(n)'' dans la méthode <code>work()</code> :
** ''x(n)'' est donné par <code>in0[0]</code>
** il sera nécessaire d'affecter <code>out0[0]</code> pour produire ''y(n)''.
** il sera nécessaire de stocker dans des '''attributs''' les valeurs de <code>in[0]</code> afin de disposer de ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.
** On rappelle que les attributs doivent être déclarées dans le fichier <code>.h</code> et initialisés dans le constructeur de la classe.

{{Todos| Réaliser cette implémentation du passe-bas et contrôler que la démodulation est identique à celle obtenue au TP précédent}}

{{Todos| Modifier votre code pour implémenter le filtre complet de démodulation}}

=== Approximation de PID par filtre numérique linéaire ===

Cours:Elen4 TNS TP TraitAudioEtDemodulation

2026-05-26T07:53:51Z

Fredmn : /* Réverbération */

[[Cours:Elen4_TNS|{{Rouge|'''Retour à la page du cours'''}}]]

<center>
'''<big>TP5 : Traitements audio et démodulation d'amplitude</big>'''
</center>

Le but de ce TP est d'ajouter puis de supprimer des effets audio (écho et réverbération). La source sera un enregistrement parlé numérisé. Les effets et leurs suppressions seront implémentés à l'aide de filtres numériques.

=== Traitements audio ===

Ces traitements seront implémentés dans GnuRadio.

===== Écho =====

Les échos se produisent lorsqu'au signal émis s'ajoutent une ou plusieurs répliques retardées et affaiblies de ce même signal source. Nous considérons une situation simple où seul un écho s'ajoute au signal original ''x(n)''. En raison de l'écho, le signal obtenu est
<center>
''s(n) = x(n) + a x(n-d)''
</center>
où ''a'' représente le facteur d'atténuation (0 < ''a'' < 1) et ''d'' est le nombre d'échantillons de retard du signal répliqué.

Vous travaillerez avec un retard de τ=0,5s en considérant que ''τ=d Te'', ''Te'' étant la période d'échantillonnage.

{{q| a)}} Si la fréquence d’échantillonnage est fixée à ''Fe = 22050''Hz, montrer que la fonction de transfert du filtre d'écho est
<center>
''H(z) = 1 + a z-11025''
</center>

{{q| b)}} Télécharger le ﬁchier [[:Fichier:RienNeSertdeCourir.zip|RienNeSertdeCourir.zip]], et l'utiliser comme entrée dans Gnuradio à l'aide d'un bloc <code>Wav File Source</code>. L'écouter en audio en l'envoyant dans un bloc <code>Audio Sink</code>, en spécifiant 22050Hz comme fréquence d'échantillonnage.

{{q| c)}} Appliquer le filtre ''H'' à la phrase enregistrée pour créer une sortie ''y(n)''. Écouter cette phrase pour vérifier à l'oreille la présence d’un écho. L’application du filtre sera réalisée de la même façon qu'au [[Cours:Elen4_TNS_TP_Implementations|TP3 - Implémentations de filtres]].

===== Réverbération =====

La réverbération est due au mélange de réflexions directes ou indirectes et résulte en un son confus. Considérons une situation simple où une seule réverbération est présente. Soit ''x(n)'' le signal original, la réverbération est obtenue en additionnant le signal d’entrée avec le signal de sortie retardé :
<center>
''y(n) = x(n) + b y(n-r)''
</center>

où ''b'' est le facteur d’atténuation (0 < ''b'' < 1) et ''r'' le nombre d’échantillons de retard du signal répliqué. En choisissant un retard de τ (par exemple 0,1s), on a alors ''r = τFe''.

{{q| a)}} La fréquence d’échantillonnage étant toujours ﬁxée à ''Fe''=22050Hz et en considérant un facteur d’atténuation ''b'' = 0,8 montrer que la fonction de transfert de la réverbération est

{{FxT | H(z) |
1
|
1 - b z-r}}

{{q| b)}} Dans GnuRadio, l'implémentation de ce filtre n'est pas possible avec des blocs retards, gain et additionneur car GnuRadio n'accepte pas de boucles. Une solution simple est de passer par un bloc <code>IIR Filter</code>. Dans ce type de bloc, il faut spécifier les coefficients du numérateur et du dénominateur. Pour le dénominateur, vous pourrez créer un bloc <code>variable</code> avec le code suivant :
<source lang=python>
np.concatenate( (np.array([1]), np.zeros(N), np.array([-b])))
</source>
où <code>N</code> est à remplacer par le nombre de zéros nécessaires et <code>b</code> par sa valeur.

{{Todos| Ajouter un bloc <code>import</code> avec le code suivant <code>import numpy as np</code>}}

{{Todos| Implémenter ce filtre et l’appliquer à l’enregistrement. Écouter le résultat ''y'' pour vérifier la présence d’une réverbération. ''Attention au paramètre <code>old style of taps</code> du bloc, consultez sa documentation.''}}

===== Annulation de l'écho et de la réverbération =====

{{q| d)}} On souhaite à présent concevoir un système d’annulation de l’écho. Il s’agit donc de déterminer un filtre numérique de réponse impulsionnelle ''g(n)'' qui doit permettre de supprimer l’écho.

Déterminer la fonction de transfert ''G(z)'' du filtre d’annulation en fonction de ''H(z)''.

{{q| e)}} Appliquer ce filtre au signal ''y'' et écouter le signal qui ne doit plus présenter de phénomène d’écho.

{{q| c)}} De même, concevoir un filtre d’annulation de la réverbération en déterminant sa fonction de transfert.

{{q| d)}} Appliquer ce filtre et écouter le résultat en vérifiant le bon fonctionnement : l'annulation de la réverbération.

{{q| e)}} Comparer les filtres de la section ''Réverbération'' et de la section ''Écho'' et faire une remarque pertinente.

{{q| f)}} Est-il toujours possible de construire un filtre d'annulation, autrement dit, est-il toujours possible de construire un filtre réciproque d'un autre filtre ? (vous pouvez réfléchir en prenant exemple d'un filtre passe-bas par exemple)

=== Démodulation ===

On dispose d'un signal modulé en amplitude par une porteuse de fréquence élevée. Afin de récupérer le signal utile, la démodulation d'amplitude se décompose en deux étapes :
# Redressement du signal modulé
# Application d'un filtre passe-bas pour enlever la porteuse.

<center>
[[Fichier:Tns_figure_demodulation.png|400px]]

Fig : principe d'une démodulation d'amplitude.
</center>

* Le signal modulé est disponible dans le fichier [[Fichier:Tns_tp3_signal_mod.hex]] (valeurs codées en <code>float</code>)
* Le signal démodulé (pour référence) est disponible dans le fichier [[Fichier:Tns_tp3_signal.hex]] (valeurs codées en <code>float</code>)

===== Détermination du Filtre passe-bas =====

Dans un notebook Python/Jupyter :

* En affichant le graphe du contenu fréquentiel du signal modulé :
** Identifier l'information de signal utile et l'information de porteuse de modulation
** Choisir une fréquence de coupure, normalisée ''Wn'' pour un filtre passe-bas, permettant de rejeter la porteuse. Les fréquences normalisées sont comprises entre 0 et 1, où 1 représente la fréquence de Nyquist (moitié de la fréquence d'échantillonnage).
* Déterminer les coefficients de la fonction de transfert de ce passe-bas, à l'aide de la fonction <code>scipy.signal.butter()</code> (avec un filtre d'ordre <code>N=2</code> pour ne pas avoir trop de coefficients). Il s'agit d'un filtre à réponse impulsionnelle infinie du type Butterworth, qui contient une rétroaction.

===== Implémentations de la démodulation =====

''N'oubliez pas le redressement dans la modulation !''

Dans Python/Jupyter :
* Comme un filtre RIF, Puisque le filtre est IIR, la réponse impulsionnelle sera forcément tronquée. Vous pouvez l'obtenir dans Matlab à l'aide de la fonction <code>scipy.signal.dimpulse()</code>.
* Par un produit dans le domaine fréquentiel. Vous pourrez obtenir la réponse fréquentielle du filtre à l'aide de la fonction <code>scipy.signal.freqz()</code>.

Dans Gnuradio :
* Comme un filtre RIF, avec le bloc <code>Frequency Xlating FIR Filter</code> (comme dans le tutoriel [https://wiki.gnuradio.org/index.php/Designing_Filter_Taps Designing Filter Taps]).
* En implémentant le filtre IIR de la même façon que le filtre de réverbération.
* Vous pourrez également chercher à utiliser un bloc <code>Low Pass Filter</code>. Dans ce cas, vous aurez trois paramètres à régler dans ce bloc :
** ''Cutoff Freq'' : une fraction de la fréquence d'échantionnage (<code>samp_rate</code>), déterminée dans la partie précédente.
** ''Transition Width'' : également une fraction de la fréquence d'échantillonnage, qui détermine la plage de transition entre la partie passante et la partie bloquante du passe-bas.
** ''Window'' : choix de la fenêtre de pondération (qui vise à limiter les oscillations du filtre). Vous pourrez tester l'effet de ces diverses fenêtres (cf [https://fr.wikipedia.org/wiki/Fenêtrage Fenêtrage]).

Cours:Elen4 TNS TP TraitAudioEtDemodulation

2026-05-26T07:53:18Z

Fredmn : /* Réverbération */

[[Cours:Elen4_TNS|{{Rouge|'''Retour à la page du cours'''}}]]

<center>
'''<big>TP5 : Traitements audio et démodulation d'amplitude</big>'''
</center>

Le but de ce TP est d'ajouter puis de supprimer des effets audio (écho et réverbération). La source sera un enregistrement parlé numérisé. Les effets et leurs suppressions seront implémentés à l'aide de filtres numériques.

=== Traitements audio ===

Ces traitements seront implémentés dans GnuRadio.

===== Écho =====

Les échos se produisent lorsqu'au signal émis s'ajoutent une ou plusieurs répliques retardées et affaiblies de ce même signal source. Nous considérons une situation simple où seul un écho s'ajoute au signal original ''x(n)''. En raison de l'écho, le signal obtenu est
<center>
''s(n) = x(n) + a x(n-d)''
</center>
où ''a'' représente le facteur d'atténuation (0 < ''a'' < 1) et ''d'' est le nombre d'échantillons de retard du signal répliqué.

Vous travaillerez avec un retard de τ=0,5s en considérant que ''τ=d Te'', ''Te'' étant la période d'échantillonnage.

{{q| a)}} Si la fréquence d’échantillonnage est fixée à ''Fe = 22050''Hz, montrer que la fonction de transfert du filtre d'écho est
<center>
''H(z) = 1 + a z-11025''
</center>

{{q| b)}} Télécharger le ﬁchier [[:Fichier:RienNeSertdeCourir.zip|RienNeSertdeCourir.zip]], et l'utiliser comme entrée dans Gnuradio à l'aide d'un bloc <code>Wav File Source</code>. L'écouter en audio en l'envoyant dans un bloc <code>Audio Sink</code>, en spécifiant 22050Hz comme fréquence d'échantillonnage.

{{q| c)}} Appliquer le filtre ''H'' à la phrase enregistrée pour créer une sortie ''y(n)''. Écouter cette phrase pour vérifier à l'oreille la présence d’un écho. L’application du filtre sera réalisée de la même façon qu'au [[Cours:Elen4_TNS_TP_Implementations|TP3 - Implémentations de filtres]].

===== Réverbération =====

La réverbération est due au mélange de réflexions directes ou indirectes et résulte en un son confus. Considérons une situation simple où une seule réverbération est présente. Soit ''x(n)'' le signal original, la réverbération est obtenue en additionnant le signal d’entrée avec le signal de sortie retardé :
<center>
''y(n) = x(n) + b y(n-r)''
</center>

où ''b'' est le facteur d’atténuation (0 < ''b'' < 1) et ''r'' le nombre d’échantillons de retard du signal répliqué. En choisissant un retard de τ (par exemple 0,1s), on a alors ''r = τFe''.

{{q| a)}} La fréquence d’échantillonnage étant toujours ﬁxée à ''Fe''=22050Hz et en considérant un facteur d’atténuation ''b'' = 0,8 montrer que la fonction de transfert de la réverbération est

{{FxT | H(z) |
1
|
1 - b z-r}}

{{q| b)}} Dans GnuRadio, l'implémentation de ce filtre n'est pas possible avec des blocs retards, gain et additionneur car GnuRadio n'accepte pas de boucles. Une solution simple est de passer par un bloc <code>IIR Filter</code>. Dans ce type de bloc, il faut spécifier les coefficients du numérateur et du dénominateur. Pour le dénominateur, vous pourrez créer un bloc <code>variable</code> avec le code suivant :
<source lang=python>
np.concatenate( (np.array([1]), np.zeros(N), np.array([-b])))
</source>
où <code>N</code> est à remplacer par le nombre de zéros nécessaires et <code>b</code> par sa valeur.

{{Todos| Ajouter un bloc <code>import</code> avec le code suivant <code>import numpy as np</code>}}

{{Todos| Implémenter ce filtre et l’appliquer à l’enregistrement. Écouter le résultat ''y'' pour vérifier la présence d’une réverbération. ''Attention au paramètre <code>old style of taps</code> du bloc, consultez sa documentation.''}}

===== Annulation de l'écho et de la réverbération =====

{{q| d)}} On souhaite à présent concevoir un système d’annulation de l’écho. Il s’agit donc de déterminer un filtre numérique de réponse impulsionnelle ''g(n)'' qui doit permettre de supprimer l’écho.

Déterminer la fonction de transfert ''G(z)'' du filtre d’annulation en fonction de ''H(z)''.

{{q| e)}} Appliquer ce filtre au signal ''y'' et écouter le signal qui ne doit plus présenter de phénomène d’écho.

{{q| c)}} De même, concevoir un filtre d’annulation de la réverbération en déterminant sa fonction de transfert.

{{q| d)}} Appliquer ce filtre et écouter le résultat en vérifiant le bon fonctionnement : l'annulation de la réverbération.

{{q| e)}} Comparer les filtres de la section ''Réverbération'' et de la section ''Écho'' et faire une remarque pertinente.

{{q| f)}} Est-il toujours possible de construire un filtre d'annulation, autrement dit, est-il toujours possible de construire un filtre réciproque d'un autre filtre ? (vous pouvez réfléchir en prenant exemple d'un filtre passe-bas par exemple)

=== Démodulation ===

On dispose d'un signal modulé en amplitude par une porteuse de fréquence élevée. Afin de récupérer le signal utile, la démodulation d'amplitude se décompose en deux étapes :
# Redressement du signal modulé
# Application d'un filtre passe-bas pour enlever la porteuse.

<center>
[[Fichier:Tns_figure_demodulation.png|400px]]

Fig : principe d'une démodulation d'amplitude.
</center>

* Le signal modulé est disponible dans le fichier [[Fichier:Tns_tp3_signal_mod.hex]] (valeurs codées en <code>float</code>)
* Le signal démodulé (pour référence) est disponible dans le fichier [[Fichier:Tns_tp3_signal.hex]] (valeurs codées en <code>float</code>)

===== Détermination du Filtre passe-bas =====

Dans un notebook Python/Jupyter :

* En affichant le graphe du contenu fréquentiel du signal modulé :
** Identifier l'information de signal utile et l'information de porteuse de modulation
** Choisir une fréquence de coupure, normalisée ''Wn'' pour un filtre passe-bas, permettant de rejeter la porteuse. Les fréquences normalisées sont comprises entre 0 et 1, où 1 représente la fréquence de Nyquist (moitié de la fréquence d'échantillonnage).
* Déterminer les coefficients de la fonction de transfert de ce passe-bas, à l'aide de la fonction <code>scipy.signal.butter()</code> (avec un filtre d'ordre <code>N=2</code> pour ne pas avoir trop de coefficients). Il s'agit d'un filtre à réponse impulsionnelle infinie du type Butterworth, qui contient une rétroaction.

===== Implémentations de la démodulation =====

''N'oubliez pas le redressement dans la modulation !''

Dans Python/Jupyter :
* Comme un filtre RIF, Puisque le filtre est IIR, la réponse impulsionnelle sera forcément tronquée. Vous pouvez l'obtenir dans Matlab à l'aide de la fonction <code>scipy.signal.dimpulse()</code>.
* Par un produit dans le domaine fréquentiel. Vous pourrez obtenir la réponse fréquentielle du filtre à l'aide de la fonction <code>scipy.signal.freqz()</code>.

Dans Gnuradio :
* Comme un filtre RIF, avec le bloc <code>Frequency Xlating FIR Filter</code> (comme dans le tutoriel [https://wiki.gnuradio.org/index.php/Designing_Filter_Taps Designing Filter Taps]).
* En implémentant le filtre IIR de la même façon que le filtre de réverbération.
* Vous pourrez également chercher à utiliser un bloc <code>Low Pass Filter</code>. Dans ce cas, vous aurez trois paramètres à régler dans ce bloc :
** ''Cutoff Freq'' : une fraction de la fréquence d'échantionnage (<code>samp_rate</code>), déterminée dans la partie précédente.
** ''Transition Width'' : également une fraction de la fréquence d'échantillonnage, qui détermine la plage de transition entre la partie passante et la partie bloquante du passe-bas.
** ''Window'' : choix de la fenêtre de pondération (qui vise à limiter les oscillations du filtre). Vous pourrez tester l'effet de ces diverses fenêtres (cf [https://fr.wikipedia.org/wiki/Fenêtrage Fenêtrage]).

Cours:Elen4 TNS TP TraitAudioEtDemodulation

2026-05-26T07:53:03Z

Fredmn : /* Réverbération */

[[Cours:Elen4_TNS|{{Rouge|'''Retour à la page du cours'''}}]]

<center>
'''<big>TP5 : Traitements audio et démodulation d'amplitude</big>'''
</center>

Le but de ce TP est d'ajouter puis de supprimer des effets audio (écho et réverbération). La source sera un enregistrement parlé numérisé. Les effets et leurs suppressions seront implémentés à l'aide de filtres numériques.

=== Traitements audio ===

Ces traitements seront implémentés dans GnuRadio.

===== Écho =====

Les échos se produisent lorsqu'au signal émis s'ajoutent une ou plusieurs répliques retardées et affaiblies de ce même signal source. Nous considérons une situation simple où seul un écho s'ajoute au signal original ''x(n)''. En raison de l'écho, le signal obtenu est
<center>
''s(n) = x(n) + a x(n-d)''
</center>
où ''a'' représente le facteur d'atténuation (0 < ''a'' < 1) et ''d'' est le nombre d'échantillons de retard du signal répliqué.

Vous travaillerez avec un retard de τ=0,5s en considérant que ''τ=d Te'', ''Te'' étant la période d'échantillonnage.

{{q| a)}} Si la fréquence d’échantillonnage est fixée à ''Fe = 22050''Hz, montrer que la fonction de transfert du filtre d'écho est
<center>
''H(z) = 1 + a z-11025''
</center>

{{q| b)}} Télécharger le ﬁchier [[:Fichier:RienNeSertdeCourir.zip|RienNeSertdeCourir.zip]], et l'utiliser comme entrée dans Gnuradio à l'aide d'un bloc <code>Wav File Source</code>. L'écouter en audio en l'envoyant dans un bloc <code>Audio Sink</code>, en spécifiant 22050Hz comme fréquence d'échantillonnage.

{{q| c)}} Appliquer le filtre ''H'' à la phrase enregistrée pour créer une sortie ''y(n)''. Écouter cette phrase pour vérifier à l'oreille la présence d’un écho. L’application du filtre sera réalisée de la même façon qu'au [[Cours:Elen4_TNS_TP_Implementations|TP3 - Implémentations de filtres]].

===== Réverbération =====

La réverbération est due au mélange de réflexions directes ou indirectes et résulte en un son confus. Considérons une situation simple où une seule réverbération est présente. Soit ''x(n)'' le signal original, la réverbération est obtenue en additionnant le signal d’entrée avec le signal de sortie retardé :
<center>
''y(n) = x(n) + b y(n-r)''
</center>

où ''b'' est le facteur d’atténuation (0 < ''b'' < 1) et ''r'' le nombre d’échantillons de retard du signal répliqué. En choisissant un retard de τ (par exemple 0,1s), on a alors ''r = τFe''.

{{q| a)}} La fréquence d’échantillonnage étant toujours ﬁxée à ''Fe''=22050Hz et en considérant un facteur d’atténuation ''b'' = 0,8 montrer que la fonction de transfert de la réverbération est

{{FxT | H(z) |
1
|
1 - b z-r}}

{{q| b)}} Dans GnuRadio, l'implémentation de ce filtre n'est pas possible avec des blocs retards, gain et additionneur car GnuRadio n'accepte pas de boucles. Une solution simple est de passer par un bloc <code>IIR Filter</code>. Dans ce type de bloc, il faut spécifier les coefficients du numérateur et du dénominateur. Pour le dénominateur, vous pourrez créer un bloc <code>variable</code> avec le code suivant :
<source lang=python>
np.concatenate( (np.array([1]), np.zeros(N), np.array([-b])))
</source>
où <code>N</code> est à remplacer par le nombre de zéros nécessaires et <code>b</code> par sa valeur.

{{Todos| Ajouter un bloc <code>import</code> avec le code suivant <code>import numpy as np</code>}}

{{Todos| Implémenter ce filtre et l’appliquer à l’enregistrement. Écouter le résultat ''y'' pour vérifier la présence d’une réverbération. '''Attention au paramètre <code>old style of taps</code> du bloc, consultez sa documentation.'''}}

===== Annulation de l'écho et de la réverbération =====

{{q| d)}} On souhaite à présent concevoir un système d’annulation de l’écho. Il s’agit donc de déterminer un filtre numérique de réponse impulsionnelle ''g(n)'' qui doit permettre de supprimer l’écho.

Déterminer la fonction de transfert ''G(z)'' du filtre d’annulation en fonction de ''H(z)''.

{{q| e)}} Appliquer ce filtre au signal ''y'' et écouter le signal qui ne doit plus présenter de phénomène d’écho.

{{q| c)}} De même, concevoir un filtre d’annulation de la réverbération en déterminant sa fonction de transfert.

{{q| d)}} Appliquer ce filtre et écouter le résultat en vérifiant le bon fonctionnement : l'annulation de la réverbération.

{{q| e)}} Comparer les filtres de la section ''Réverbération'' et de la section ''Écho'' et faire une remarque pertinente.

{{q| f)}} Est-il toujours possible de construire un filtre d'annulation, autrement dit, est-il toujours possible de construire un filtre réciproque d'un autre filtre ? (vous pouvez réfléchir en prenant exemple d'un filtre passe-bas par exemple)

=== Démodulation ===

On dispose d'un signal modulé en amplitude par une porteuse de fréquence élevée. Afin de récupérer le signal utile, la démodulation d'amplitude se décompose en deux étapes :
# Redressement du signal modulé
# Application d'un filtre passe-bas pour enlever la porteuse.

<center>
[[Fichier:Tns_figure_demodulation.png|400px]]

Fig : principe d'une démodulation d'amplitude.
</center>

* Le signal modulé est disponible dans le fichier [[Fichier:Tns_tp3_signal_mod.hex]] (valeurs codées en <code>float</code>)
* Le signal démodulé (pour référence) est disponible dans le fichier [[Fichier:Tns_tp3_signal.hex]] (valeurs codées en <code>float</code>)

===== Détermination du Filtre passe-bas =====

Dans un notebook Python/Jupyter :

* En affichant le graphe du contenu fréquentiel du signal modulé :
** Identifier l'information de signal utile et l'information de porteuse de modulation
** Choisir une fréquence de coupure, normalisée ''Wn'' pour un filtre passe-bas, permettant de rejeter la porteuse. Les fréquences normalisées sont comprises entre 0 et 1, où 1 représente la fréquence de Nyquist (moitié de la fréquence d'échantillonnage).
* Déterminer les coefficients de la fonction de transfert de ce passe-bas, à l'aide de la fonction <code>scipy.signal.butter()</code> (avec un filtre d'ordre <code>N=2</code> pour ne pas avoir trop de coefficients). Il s'agit d'un filtre à réponse impulsionnelle infinie du type Butterworth, qui contient une rétroaction.

===== Implémentations de la démodulation =====

''N'oubliez pas le redressement dans la modulation !''

Dans Python/Jupyter :
* Comme un filtre RIF, Puisque le filtre est IIR, la réponse impulsionnelle sera forcément tronquée. Vous pouvez l'obtenir dans Matlab à l'aide de la fonction <code>scipy.signal.dimpulse()</code>.
* Par un produit dans le domaine fréquentiel. Vous pourrez obtenir la réponse fréquentielle du filtre à l'aide de la fonction <code>scipy.signal.freqz()</code>.

Dans Gnuradio :
* Comme un filtre RIF, avec le bloc <code>Frequency Xlating FIR Filter</code> (comme dans le tutoriel [https://wiki.gnuradio.org/index.php/Designing_Filter_Taps Designing Filter Taps]).
* En implémentant le filtre IIR de la même façon que le filtre de réverbération.
* Vous pourrez également chercher à utiliser un bloc <code>Low Pass Filter</code>. Dans ce cas, vous aurez trois paramètres à régler dans ce bloc :
** ''Cutoff Freq'' : une fraction de la fréquence d'échantionnage (<code>samp_rate</code>), déterminée dans la partie précédente.
** ''Transition Width'' : également une fraction de la fréquence d'échantillonnage, qui détermine la plage de transition entre la partie passante et la partie bloquante du passe-bas.
** ''Window'' : choix de la fenêtre de pondération (qui vise à limiter les oscillations du filtre). Vous pourrez tester l'effet de ces diverses fenêtres (cf [https://fr.wikipedia.org/wiki/Fenêtrage Fenêtrage]).

Cours:Elen4 TNS TP TraitAudioEtDemodulation

2026-05-25T05:00:57Z

Fredmn : /* Détermination du Filtre passe-bas */

[[Cours:Elen4_TNS|{{Rouge|'''Retour à la page du cours'''}}]]

<center>
'''<big>TP5 : Traitements audio et démodulation d'amplitude</big>'''
</center>

Le but de ce TP est d'ajouter puis de supprimer des effets audio (écho et réverbération). La source sera un enregistrement parlé numérisé. Les effets et leurs suppressions seront implémentés à l'aide de filtres numériques.

=== Traitements audio ===

Ces traitements seront implémentés dans GnuRadio.

===== Écho =====

Les échos se produisent lorsqu'au signal émis s'ajoutent une ou plusieurs répliques retardées et affaiblies de ce même signal source. Nous considérons une situation simple où seul un écho s'ajoute au signal original ''x(n)''. En raison de l'écho, le signal obtenu est
<center>
''s(n) = x(n) + a x(n-d)''
</center>
où ''a'' représente le facteur d'atténuation (0 < ''a'' < 1) et ''d'' est le nombre d'échantillons de retard du signal répliqué.

Vous travaillerez avec un retard de τ=0,5s en considérant que ''τ=d Te'', ''Te'' étant la période d'échantillonnage.

{{q| a)}} Si la fréquence d’échantillonnage est fixée à ''Fe = 22050''Hz, montrer que la fonction de transfert du filtre d'écho est
<center>
''H(z) = 1 + a z-11025''
</center>

{{q| b)}} Télécharger le ﬁchier [[:Fichier:RienNeSertdeCourir.zip|RienNeSertdeCourir.zip]], et l'utiliser comme entrée dans Gnuradio à l'aide d'un bloc <code>Wav File Source</code>. L'écouter en audio en l'envoyant dans un bloc <code>Audio Sink</code>, en spécifiant 22050Hz comme fréquence d'échantillonnage.

{{q| c)}} Appliquer le filtre ''H'' à la phrase enregistrée pour créer une sortie ''y(n)''. Écouter cette phrase pour vérifier à l'oreille la présence d’un écho. L’application du filtre sera réalisée de la même façon qu'au [[Cours:Elen4_TNS_TP_Implementations|TP3 - Implémentations de filtres]].

===== Réverbération =====

La réverbération est due au mélange de réflexions directes ou indirectes et résulte en un son confus. Considérons une situation simple où une seule réverbération est présente. Soit ''x(n)'' le signal original, la réverbération est obtenue en additionnant le signal d’entrée avec le signal de sortie retardé :
<center>
''y(n) = x(n) + b y(n-r)''
</center>

où ''b'' est le facteur d’atténuation (0 < ''b'' < 1) et ''r'' le nombre d’échantillons de retard du signal répliqué. En choisissant un retard de τ (par exemple 0,1s), on a alors ''r = τFe''.

{{q| a)}} La fréquence d’échantillonnage étant toujours ﬁxée à ''Fe''=22050Hz et en considérant un facteur d’atténuation ''b'' = 0,8 montrer que la fonction de transfert de la réverbération est

{{FxT | H(z) |
1
|
1 - b z-r}}

{{q| b)}} Dans GnuRadio, l'implémentation de ce filtre n'est pas possible avec des blocs retards, gain et additionneur car GnuRadio n'accepte pas de boucles. Une solution simple est de passer par un bloc <code>IIR Filter</code>. Dans ce type de bloc, il faut spécifier les coefficients du numérateur et du dénominateur. Pour le dénominateur, vous pourrez créer un bloc <code>variable</code> avec le code suivant :
<source lang=python>
np.concatenate( (np.array([1]), np.zeros(N), np.array([-b])))
</source>
où <code>N</code> est à remplacer par le nombre de zéros nécessaires et <code>b</code> par sa valeur.

{{Todos| Ajouter un bloc <code>import</code> avec le code suivant <code>import numpy as np</code>}}

{{Todos| Implémenter ce filtre et l’appliquer à l’enregistrement. Écouter le résultat ''y'' pour vérifier la présence d’une réverbération.}}

===== Annulation de l'écho et de la réverbération =====

{{q| d)}} On souhaite à présent concevoir un système d’annulation de l’écho. Il s’agit donc de déterminer un filtre numérique de réponse impulsionnelle ''g(n)'' qui doit permettre de supprimer l’écho.

Déterminer la fonction de transfert ''G(z)'' du filtre d’annulation en fonction de ''H(z)''.

{{q| e)}} Appliquer ce filtre au signal ''y'' et écouter le signal qui ne doit plus présenter de phénomène d’écho.

{{q| c)}} De même, concevoir un filtre d’annulation de la réverbération en déterminant sa fonction de transfert.

{{q| d)}} Appliquer ce filtre et écouter le résultat en vérifiant le bon fonctionnement : l'annulation de la réverbération.

{{q| e)}} Comparer les filtres de la section ''Réverbération'' et de la section ''Écho'' et faire une remarque pertinente.

{{q| f)}} Est-il toujours possible de construire un filtre d'annulation, autrement dit, est-il toujours possible de construire un filtre réciproque d'un autre filtre ? (vous pouvez réfléchir en prenant exemple d'un filtre passe-bas par exemple)

=== Démodulation ===

On dispose d'un signal modulé en amplitude par une porteuse de fréquence élevée. Afin de récupérer le signal utile, la démodulation d'amplitude se décompose en deux étapes :
# Redressement du signal modulé
# Application d'un filtre passe-bas pour enlever la porteuse.

<center>
[[Fichier:Tns_figure_demodulation.png|400px]]

Fig : principe d'une démodulation d'amplitude.
</center>

* Le signal modulé est disponible dans le fichier [[Fichier:Tns_tp3_signal_mod.hex]] (valeurs codées en <code>float</code>)
* Le signal démodulé (pour référence) est disponible dans le fichier [[Fichier:Tns_tp3_signal.hex]] (valeurs codées en <code>float</code>)

===== Détermination du Filtre passe-bas =====

Dans un notebook Python/Jupyter :

* En affichant le graphe du contenu fréquentiel du signal modulé :
** Identifier l'information de signal utile et l'information de porteuse de modulation
** Choisir une fréquence de coupure, normalisée ''Wn'' pour un filtre passe-bas, permettant de rejeter la porteuse. Les fréquences normalisées sont comprises entre 0 et 1, où 1 représente la fréquence de Nyquist (moitié de la fréquence d'échantillonnage).
* Déterminer les coefficients de la fonction de transfert de ce passe-bas, à l'aide de la fonction <code>scipy.signal.butter()</code> (avec un filtre d'ordre <code>N=2</code> pour ne pas avoir trop de coefficients). Il s'agit d'un filtre à réponse impulsionnelle infinie du type Butterworth, qui contient une rétroaction.

===== Implémentations de la démodulation =====

''N'oubliez pas le redressement dans la modulation !''

Dans Python/Jupyter :
* Comme un filtre RIF, Puisque le filtre est IIR, la réponse impulsionnelle sera forcément tronquée. Vous pouvez l'obtenir dans Matlab à l'aide de la fonction <code>scipy.signal.dimpulse()</code>.
* Par un produit dans le domaine fréquentiel. Vous pourrez obtenir la réponse fréquentielle du filtre à l'aide de la fonction <code>scipy.signal.freqz()</code>.

Dans Gnuradio :
* Comme un filtre RIF, avec le bloc <code>Frequency Xlating FIR Filter</code> (comme dans le tutoriel [https://wiki.gnuradio.org/index.php/Designing_Filter_Taps Designing Filter Taps]).
* En implémentant le filtre IIR de la même façon que le filtre de réverbération.
* Vous pourrez également chercher à utiliser un bloc <code>Low Pass Filter</code>. Dans ce cas, vous aurez trois paramètres à régler dans ce bloc :
** ''Cutoff Freq'' : une fraction de la fréquence d'échantionnage (<code>samp_rate</code>), déterminée dans la partie précédente.
** ''Transition Width'' : également une fraction de la fréquence d'échantillonnage, qui détermine la plage de transition entre la partie passante et la partie bloquante du passe-bas.
** ''Window'' : choix de la fenêtre de pondération (qui vise à limiter les oscillations du filtre). Vous pourrez tester l'effet de ces diverses fenêtres (cf [https://fr.wikipedia.org/wiki/Fenêtrage Fenêtrage]).