troyesGEII - Contributions [fr]

Cours:PooTD2 barregraphe

2026-09-14T08:23:53Z

Fredmn : /* 74HC138 */

=schéma=
[[Image:CarteBarregraphe.png|500px|droite]]
*[[Media:CarteLeds.pdf]]

=74HC138=

la carte utilise un démultiplexeur [[Media:Sn74hc138.pdf|74HC138]] pour commander l'état de 8 leds.

*description
**on choisit le numéro de la led avec un nombre sur 3 bits ( CBA )
**si l'entrée Enable est à 0, toutes les leds sont éteintes
**Attention : il faut forcer un peu les connecteurs (détrompeurs devant) ET contrôler que la nappe n'est pas croisée
*signaux sur les connecteurs
**le connecteur CN2 :
***En
***C : bit de poids fort du nombre
**le connecteur CN1
***B
***A : bit de poids faible du nombre
*Exemple : pour allumer la led 5 ( 101 en binaire), il faut
**En à 1
**C à 1
**B à 0
**A à 1

=création d'une classe Barregraphe=
*constructeur avec 4 paramètres (dans l'ordre le numéro de GPIO de En,C,B,A)
*attributs :
**numGpioEn
**numGpioC
**numGpioB
**numGpioA
*méthode
**allumerLedNumero(int numero)

{{Question|Ecrire le programme et vérifier le fonctionnement}}

=ajout de fonctionnalités (méthodes)=

*ajouter des méthodes (et attribut si besoin)
**allumerLedSuivante()
**allumerLedPrecedente()

{{Question|utiliser 2 boutons pour :}}
*si le bouton 1 est appuyé, on passe à la led suivante toutes les 250ms
*si le bouton 2 est appuyé, on passe à la led précédente toutes les 250ms

Cours:Elen4 TNS

2026-09-10T05:23:09Z

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). Gnuradio est disponible en local sur les ordinateurs, mais aussi directement en ligne : https://gnuradioworld.com/
* 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:InfoS3 POO

2026-09-07T07:37:34Z

Fredmn : /* Pratique */

= Pratique =

Attention : nous utilisons Qt5 au département.

* Pour installer QT Creator (ainsi que C++ et Qt) sous de nombreux OS : suivre ce tutoriel
https://guillaumebelz.github.io/

* Guide d'installation de Qt par Geoffrey Lecoq (merci à lui) : [[Fichier:GuideQT_Lecoq.pdf]]

= Évaluations =

*[[Cours:DevoirPOOcpp2|Évaluation n°1]]
*[[Cours:DevoirMaisonPOO1|Devoir maison n°1]]


*[[Cours:DevoirPOO2Ressources|Évaluation n°2 ressources]]
*[[Cours:DevoirPOO2|Évaluation n°2 sujet]]

= Cours magistral =

== Diapositives et support de cours ==

* Diapositives de la partie Introduction : [[Media:POOintro.pdf]]
* Diapositives de la partie Notions : [[Media:POOnotions.pdf]]
* Diapositives de la partie Approfondissements : [[Media:POOapprofondissements.pdf]]
* Support de cours imprimable : [[Media:POOsupport.pdf]]

== Projets de démonstration de CM ==

* Projet <code>minimal</code> : [[Media:minimal.zip]]
* Projet <code>simpleNonOOCar</code> : [[Media:simpleNonOOCar.zip]]
* Projet <code>simpleOOCar</code> : [[Media:simpleOOCar.zip]]
* Projet <code>twoOOCars</code> : [[Media:twoOOCars.zip]]
* Projet <code>formes_start</code> : [[Media:formes_start.zip]]
* Projet <code>formes</code> : [[Media:formes.zip]]
* Projet <code>formes_nonpolymorphes</code> [[Media:formes_nonpolymorphes.zip]]
* Projet <code>formes_polymorphes</code> [[Media:formes_polymorphes.zip]]

== Lectures externes potentiellement utiles ==

'''Cours de POO d'openclassrooms''' :

1. [https://openclassrooms.com/fr/courses/7137751-programmez-en-oriente-objet-avec-c/7673331-decouvrez-la-notion-de-poo Découvrez La notion de programmation orientée objet (POO)]

2. [https://openclassrooms.com/fr/courses/7137751-programmez-en-oriente-objet-avec-c Programmez en orienté objet avec C++]

'''Les pointeurs et leur utilisation avec des objets''' :

1. [https://openclassrooms.com/fr/courses/1894236-apprenez-a-programmer-en-c/7534366-declarez-les-pointeurs Déclarez les pointeurs]

2. [https://openclassrooms.com/fr/courses/7137751-programmez-en-oriente-objet-avec-c/7531356-associez-les-classes-et-les-pointeurs Associez les classes et les pointeurs]



= Séances : C++ sous QT Creator =

*[[Cours:pooTD1_ledsbps|séance 1 (4,5h) : découverte du C++ et de QT Creator]]
*[[Cours:pooTD2_barregraphe|séance 2 (1,5h) : Écriture d'une classe (Barregraphe)]]
* séance 3 (1h) : Évaluation
*[[Cours:interfaceQT|séance 3 (1,5h) : 1ère interface graphique]]
*[[Cours:signalSlotQT|séance 4 (3h) : classe avec slot et émission de signal]]
*[[Cours:TPheritageIO|séance 5 (3h): on hérite ! (pi4)]]
*[[Cours:pointeursCpp|séance 6 (1,5h) : manipulation de pointeurs/références]]
*[[Cours:DiyWidgetQT|séance 7 (3h) : création d'un widget DIY]] (à déplacer pour utilisation dans le DM)
*[[Cours:TPqtFNS|séance 8 (1,5h) : Machine à état fini]]
*[[Cours:pooSignal|séance 9 (0,5h) : Emission de signal]]
*[[Cours:qtTCP|séance 10 (1,5h) : Révisions ou communication entre 2 cartes par TCP]]

==Archives==
*[[Cours:pooTD2_classes|séance 2 (3h) : création de classes et manipulation d'objets]]
*{{Rouge|Evaluation (1,5h)}}
*[[Cours:interfaceQT|séance 3 (1,5h) : 1ère interface graphique]]
*[[Cours:signalSlotQT|séance 4 (1.5h) : classe avec slot et émission de signal]]
*[[Cours:TPgpioQT|séance 5 (3h) : GPIO (pi4) ]]
*[[Cours:TPheritageIO|séance 6 (4,5h): on hérite ! (pi4)]]
*[[Cours:HeritageWidgetQT|séance 7 (1,5h) : spécialisation de Widgets]]
*[[Cours:TPqtFNS|séance 8 (3h) : Machine à état fini ("pi4") ]]
*[[Cours:pointeursCpp|séance 9 (1,5h) : manipulation de pointeurs/références]]

*{{Rouge|Evaluation (3h) (pi4)}}

=Pour aller plus loin=
*[[Cours:diyWidgetQT|Créer son widget]]
*[[Cours:TPgpioControleur|Tp 2 : contrôleur de lampes]]
*[[Cours:gitQtCreator|Utilisation de git avec qt creator]]

=Ressources=
*https://www.kdab.com/wp-content/uploads/stories/slides/DD13/dd13_signalsslots.pdf

=Logiciel=
==Vm Qt Creator==

Vous pouvez utiliser l'image VirtualBox suivante sur laquelle QtCreator est installé

https://drive.google.com/file/d/1BdVNnAtpYM14ztf215gBVx5b2P8iAAix/view?usp=sharing

Le mot de passe est geii

==Simulation de gpio==

*simulateur leds/bp/interrupteur
**dans la machine virtuelle VirtualBox
**au besoin supprimer le fichier GpioSimulateur.zip dans le répertoire "Téléchargements"
**télécharger [[Media:GpioSimulateur.zip]] dans le répertoire "Téléchargements"
**lancer un "émulateur de Terminal", taper les commandes :
<source lang=bash>
cd ~/Téléchargements/
rm gpioSimulateur
unzip GpioSimulateur.zip
chmod +x gpioSimulateur
./gpioSimulateur
</source>

=Vrac=

==Idées==

*classe filtrage capteur tor
*moyenne glissante capteur analogique

==[[Cours:POONomenclature|Nomenclature diagramme objet]]==

==Autres pages wiki utiles==
*[[Cours:modulesGrove]]
*[[Cours:rpi]]
*[[Cours:pooQT]]
*[[Cours:QT]]
*[[Cours:infoS3_POO_archives]]

=Cas particuliers=

==surcharge et signaux/slots==

Il faudra indiquer au compilateur le type des paramètres pour faire le choix du bon signal et/ou slot :

<source lang=cpp>
connect(ui->doubleSpinBox,QOverload<double>::of(&QDoubleSpinBox::valueChanged),
this,&MainWindow::afficheDouble);
connect(ui->doubleSpinBox,QOverload<double>::of(&QDoubleSpinBox::valueChanged),
this,QOverload<double>::of(&MainWindow::affiche));
connect(ui->doubleSpinBox,QOverload<const QString &>::of(&QDoubleSpinBox::valueChanged),
this,QOverload<const QString &>::of(&MainWindow::affiche));
</source>

Cours:InfoS3 POO

2026-09-03T08:39:51Z

Fredmn : /* Lecture externes potentiellement utiles */

= Pratique =

* Pour installer QT Creator (ainsi que C++ et Qt) sous de nombreux OS : suivre ce tutoriel
https://guillaumebelz.github.io/qtinstall/

* Guide d'installation de Qt par Geoffrey Lecoq (merci à lui) : [[Fichier:GuideQT_Lecoq.pdf]]

= Évaluations =

*[[Cours:DevoirPOOcpp2|Évaluation n°1]]
*[[Cours:DevoirMaisonPOO1|Devoir maison n°1]]


*[[Cours:DevoirPOO2Ressources|Évaluation n°2 ressources]]
*[[Cours:DevoirPOO2|Évaluation n°2 sujet]]

= Cours magistral =

== Diapositives et support de cours ==

* Diapositives de la partie Introduction : [[Media:POOintro.pdf]]
* Diapositives de la partie Notions : [[Media:POOnotions.pdf]]
* Diapositives de la partie Approfondissements : [[Media:POOapprofondissements.pdf]]
* Support de cours imprimable : [[Media:POOsupport.pdf]]

== Projets de démonstration de CM ==

* Projet <code>minimal</code> : [[Media:minimal.zip]]
* Projet <code>simpleNonOOCar</code> : [[Media:simpleNonOOCar.zip]]
* Projet <code>simpleOOCar</code> : [[Media:simpleOOCar.zip]]
* Projet <code>twoOOCars</code> : [[Media:twoOOCars.zip]]
* Projet <code>formes_start</code> : [[Media:formes_start.zip]]
* Projet <code>formes</code> : [[Media:formes.zip]]
* Projet <code>formes_nonpolymorphes</code> [[Media:formes_nonpolymorphes.zip]]
* Projet <code>formes_polymorphes</code> [[Media:formes_polymorphes.zip]]

== Lectures externes potentiellement utiles ==

'''Cours de POO d'openclassrooms''' :

1. [https://openclassrooms.com/fr/courses/7137751-programmez-en-oriente-objet-avec-c/7673331-decouvrez-la-notion-de-poo Découvrez La notion de programmation orientée objet (POO)]

2. [https://openclassrooms.com/fr/courses/7137751-programmez-en-oriente-objet-avec-c Programmez en orienté objet avec C++]

'''Les pointeurs et leur utilisation avec des objets''' :

1. [https://openclassrooms.com/fr/courses/1894236-apprenez-a-programmer-en-c/7534366-declarez-les-pointeurs Déclarez les pointeurs]

2. [https://openclassrooms.com/fr/courses/7137751-programmez-en-oriente-objet-avec-c/7531356-associez-les-classes-et-les-pointeurs Associez les classes et les pointeurs]



= Séances : C++ sous QT Creator =

*[[Cours:pooTD1_ledsbps|séance 1 (4,5h) : découverte du C++ et de QT Creator]]
*[[Cours:pooTD2_barregraphe|séance 2 (1,5h) : Écriture d'une classe (Barregraphe)]]
* séance 3 (1h) : Évaluation
*[[Cours:interfaceQT|séance 3 (1,5h) : 1ère interface graphique]]
*[[Cours:signalSlotQT|séance 4 (3h) : classe avec slot et émission de signal]]
*[[Cours:TPheritageIO|séance 5 (3h): on hérite ! (pi4)]]
*[[Cours:pointeursCpp|séance 6 (1,5h) : manipulation de pointeurs/références]]
*[[Cours:DiyWidgetQT|séance 7 (3h) : création d'un widget DIY]] (à déplacer pour utilisation dans le DM)
*[[Cours:TPqtFNS|séance 8 (1,5h) : Machine à état fini]]
*[[Cours:pooSignal|séance 9 (0,5h) : Emission de signal]]
*[[Cours:qtTCP|séance 10 (1,5h) : Révisions ou communication entre 2 cartes par TCP]]

==Archives==
*[[Cours:pooTD2_classes|séance 2 (3h) : création de classes et manipulation d'objets]]
*{{Rouge|Evaluation (1,5h)}}
*[[Cours:interfaceQT|séance 3 (1,5h) : 1ère interface graphique]]
*[[Cours:signalSlotQT|séance 4 (1.5h) : classe avec slot et émission de signal]]
*[[Cours:TPgpioQT|séance 5 (3h) : GPIO (pi4) ]]
*[[Cours:TPheritageIO|séance 6 (4,5h): on hérite ! (pi4)]]
*[[Cours:HeritageWidgetQT|séance 7 (1,5h) : spécialisation de Widgets]]
*[[Cours:TPqtFNS|séance 8 (3h) : Machine à état fini ("pi4") ]]
*[[Cours:pointeursCpp|séance 9 (1,5h) : manipulation de pointeurs/références]]

*{{Rouge|Evaluation (3h) (pi4)}}

=Pour aller plus loin=
*[[Cours:diyWidgetQT|Créer son widget]]
*[[Cours:TPgpioControleur|Tp 2 : contrôleur de lampes]]
*[[Cours:gitQtCreator|Utilisation de git avec qt creator]]

=Ressources=
*https://www.kdab.com/wp-content/uploads/stories/slides/DD13/dd13_signalsslots.pdf

=Logiciel=
==Vm Qt Creator==

Vous pouvez utiliser l'image VirtualBox suivante sur laquelle QtCreator est installé

https://drive.google.com/file/d/1BdVNnAtpYM14ztf215gBVx5b2P8iAAix/view?usp=sharing

Le mot de passe est geii

==Simulation de gpio==

*simulateur leds/bp/interrupteur
**dans la machine virtuelle VirtualBox
**au besoin supprimer le fichier GpioSimulateur.zip dans le répertoire "Téléchargements"
**télécharger [[Media:GpioSimulateur.zip]] dans le répertoire "Téléchargements"
**lancer un "émulateur de Terminal", taper les commandes :
<source lang=bash>
cd ~/Téléchargements/
rm gpioSimulateur
unzip GpioSimulateur.zip
chmod +x gpioSimulateur
./gpioSimulateur
</source>

=Vrac=

==Idées==

*classe filtrage capteur tor
*moyenne glissante capteur analogique

==[[Cours:POONomenclature|Nomenclature diagramme objet]]==

==Autres pages wiki utiles==
*[[Cours:modulesGrove]]
*[[Cours:rpi]]
*[[Cours:pooQT]]
*[[Cours:QT]]
*[[Cours:infoS3_POO_archives]]

=Cas particuliers=

==surcharge et signaux/slots==

Il faudra indiquer au compilateur le type des paramètres pour faire le choix du bon signal et/ou slot :

<source lang=cpp>
connect(ui->doubleSpinBox,QOverload<double>::of(&QDoubleSpinBox::valueChanged),
this,&MainWindow::afficheDouble);
connect(ui->doubleSpinBox,QOverload<double>::of(&QDoubleSpinBox::valueChanged),
this,QOverload<double>::of(&MainWindow::affiche));
connect(ui->doubleSpinBox,QOverload<const QString &>::of(&QDoubleSpinBox::valueChanged),
this,QOverload<const QString &>::of(&MainWindow::affiche));
</source>

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