Identification des filtres d'ordre 2

• Liste des AAvs concernés: AAv1, AAv4
• URL du projet: https://git.enib.fr/choqueuse/analog_filter_a2024

Description du travail

Objectifs

Dans ce travail, nous souhaitons développer une librairie Python pour analyser les principaux circuits électroniques d'ordre 2. Pour chaque circuit d'ordre 2, nous souhaitons traiter les problèmes suivants :

1. Calcul de la fonction de transfert, puis écriture sous forme normalisée,
2. Implémentation d'une fonction lti permettant d'obtenir la fonction de transfert en Python à partir des composants,
3. Implémentation d'une fonction get_params permettant d'obtenir les paramètres de la fonction de transfert (coefficient d'amplication, ${\omega }_0$ et $m$),
4. Implémentation d'une fonction set_components permettant de calibrer les composants du filtre à partir des paramètres de la fonction de transfert.
5. Validation sur LTSpice

Fonctions de transfert normalisées

• Passe-bas (LP)

$$H(s)=\frac{T_0}{\frac{1}{{\omega }_0^2}{s}^2+\frac{2m}{{\omega }_0}s+1}$$

• Passe-bande (BP)

$$H(s)=\frac{\frac{2m{T}_m}{{\omega }_0}s}{\frac{1}{{\omega }_0^2}{s}^2+\frac{2m}{{\omega }_0}s+1}$$

• Passe-haut (HP)

$$H(s)=\frac{\frac{T_{\mathrm{\infty }}}{{\omega }_0^2}{s}^2}{\frac{1}{{\omega }_0^2}{s}^2+\frac{2m}{{\omega }_0}s+1}$$

Analyse Théorique

Pour illustrer le travail, nous allons considérer l'analyse complète du circuit suivant :

Fonction de transfert

En utilisant le pont diviseur de tension, nous obtenons

$$V_s(s)=\frac{Z_{eq}}{R_1+Z_{eq}}{V}_X(s)\Rightarrow \frac{V_s(s)}{V_X(s)}=\frac{1}{1+\frac{R_1}{Z_{eq}}}$$

où

$$\frac{1}{Z_{eq}}=\frac{1}{Z_L}+\frac{1}{Z_{R_2}}+\frac{1}{Z_c}=\frac{1}{Ls}+\frac{1}{R_2}+Cs$$

Il en vient que :

$$H(s)=\frac{\frac{L}{R_1}s}{1+L(\frac{R_2+R_1}{R_2{R}_1})s+LC{s}^2}$$

Identification des paramètres

En identifiant la fonction de transfert avec la fonction de transfert normalisée d'un passe-bande, nous obtenons :

$$H(s)=\frac{\frac{2m{T}_m}{{\omega }_0}s}{\frac{1}{{\omega }_0^2}{s}^2+\frac{2m}{{\omega }_0}s+1}$$

avec

$$\begin{array}{rl}{w}_0& =\frac{1}{\sqrt{LC}}\\ m& =\frac{1}{2}\left(\frac{R_2+R_1}{R_2{R}_1}\right)\sqrt{\frac{L}{C}}\\ T_m& =\frac{R_2}{R_2+R_1}\end{array}$$

Calibration des composants

Comme nous avons 3 équations et 4 composants, nous devons fixer un composant. En fixant la bobine L, nous obtenons alors les équations suivantes :

$$\begin{array}{rl}C& =\frac{1}{L{\omega }_0^2}\\ R_1& =\frac{1}{2m{T}_m}\sqrt{\frac{L}{C}}\\ R_2& =\frac{R_1{T}_m}{1-T_m}\end{array}$$

Implementation Python

Dans ce projet, chaque étudiant doit réaliser le travail pour un circuit passif et un circuit actif. Pour permettre la gestion collaborative du code, nous allons utiliser le serveur gitlab de l'ENIB.

Utilisation de Gitlab

Pour travailler efficacement sur notre projet collaboratif, nous allons utiliser GitLab, une plateforme de gestion de versions et de collaboration en ligne très populaire dans les entreprises. Nous allons utiliser le serveur gitlab hébergé à l'ENIB.

1. Installation de Git via Conda : Si vous n'avez pas encore Git installé sur votre machine, vous pouvez l'installer facilement via Conda en utilisant la commande suivante : conda install git. Cela vous permettra d'utiliser Git en ligne de commande pour gérer votre code.

2. Cloner le dépôt GitLab : Une fois Git installé, vous pouvez cloner le dépôt du projet sur votre machine locale. Rendez-vous sur la page du projet GitLab, copiez l'URL du dépôt et utilisez la commande suivante dans votre terminal pour télécharger tous les fichiers du projet sur votre machine.:

git clone https://git.enib.fr/choqueuse/analog_filter_{promotion}.git

3. Création d'une branche : Pour travailler sur une nouvelle fonctionnalité, il est nécessaire de créer une branche dédiée. Cela permet de travailler en parallèle sans affecter le travail des autres contributeurs. Pour créer une nouvelle branche, utilisez la commande suivante :

git checkout -b analog_filter_{nom}_{prenom}

4. Faire des changements et les valider : Après avoir apporté des modifications au code, vous devez les valider (commit). Pour cela, utilisez les commandes:

git add .
git commit -m "Description de vos modifications"

5. Pousser vos modifications sur GitLab : Une fois vos changements validés, vous devez les envoyer sur GitLab. Assurez-vous d'abord d'être sur la branche que vous avez créée, puis utilisez :

git push origin analog_filter_{nom}_{prenom}

6. Merge Request (Demande de fusion) : Une fois votre travail terminé sur une branche, créez une "Merge Request" (MR) via GitLab pour intégrer vos modifications à la branche principale (main). Cette MR permet aux autres membres du projet de réviser votre code avant qu'il ne soit fusionné.

Structure du projet

Le projet nommé analog_filter_{promotion}est disponible sur le gitlab de l'ENIB. L'architecture du projet est présentée si dessous :

.
├── Makefile
├── README.md
├── docs
│   ├── Makefile
│   ├── build
│   ├── make.bat
│   └── source
├── examples
│   └── one_shot.py
├── requirements.txt
├── src
│   ├── __init__.py
│   ├── active.py
│   ├── core.py
│   └── passive.py
└── tests
    ├── __init__.py
    ├── test_analog_filter.py
    └── test_data.py

• README.md: fichier décrivant le contenu du dossier,
• Makefile: fichier permettant de lancer rapidement des commandes via la commande make,
• docs: répertoire contenant la documentation (gérée automatiquement par Sphinx),
• examples: répertoire contenant des scripts d'exemple pour tester son code lors de son dévelopement,
• src: dossier contenant le code source de la librairie,
• tests : dossier contenant les scripts de tests (gérés via pytest)

Implémentation de la Classe RLC_BP3_Filter

Pour implementer les fonctionnalités python demandées, nous allons utiliser une approche objet. La classe du filtre BP concerné est disponible dans le fichier src/passive.py et est nommée RLC_BP2.

Par rapport au code du départ, il est nécessaire de :

• compléter l'expression de la fonction de transfert dans le docstring python,
• redéfinir la méthode lti(self) permettant de construire un objet lti à partir de la valeur des composants,
• redéfinir la méthode get_params(self) pour calculer les paramètres $T_m$, $w0$ et $m$,
• redéfinir la méthode set_params(self, T, w0, m) pour déterminer les composants du filtres à partir des paramètres $T_m$, $w0$ et $m$.

...
class RLC_BP2(Analog_Filter):

    """
    RLC_BP2 Filter
    ---------------

    Circuit
    ~~~~~~~

     .. image:: _static/img/RLC_BP2.svg
       :align: center
       :width: 50%

    Transfert Function
    ~~~~~~~~~~~~~~~~~~

    .. math::

        H(s)=\\frac{(L/R_2)p}{CLs^2 + L((R_2+R_1)/(R_2R_1))s+1}

    Parameters
    ~~~~~~~~~~
        R1 : float, optional
            Default Value None
        R2 : float, optional
            Default Value None
        L : float, optional
            family name of the person
        C : float, optional
            Default Value None
    """
    type = "BP"

    def __init__(self, R1=None, R2=None, L=None, C=None):
        self.R1 = R1
        self.R2 = R2
        self.L = L
        self.C = C

    def lti(self):
        """
        Returns the lti object
        """
        num = [self.L / self.R1, 0]
        den = [self.L * self.C, self.L * (self.R1 + self.R2) / (self.R1 * self.R2), 1]
        return lti(num, den)

    def get_params(self):
        T = self.R2 / (self.R1 + self.R2)
        w0 = 1 / np.sqrt(self.L*self.C)
        m = 0.5 * ((self.R1+self.R2)/(self.R1*self.R2)) * np.sqrt(self.L/self.C)
        return T, w0, m

    def set_components(self, T, w0, m):
        C = 1 / (self.L * (w0**2))
        R1 = (1 / (2 * m * T)) * np.sqrt(self.L / C)
        R2 = R1 * T / (1 - T)
        # store value in object
        self.C = C
        self.R1 = R1
        self.R2 = R2

Test

Script one_shot

Pour valider le bon fonctionnement de la classe, il est possible dans un premier temps de modifier le contenu du script examples/one_shot.py pour instancier un objet de notre classe et tester la fonctionnement de quelques méthodes. Pour executer le script one_shot.py, il suffit de lancer la commande :

make one_shot.py

Il est recommandé de recréer le circuit sur LT_spice afin de vérifier la bonne correspondance des résultats.

Utilisation de pytest

Les tests automatisés sont cruciaux pour garantir la fiabilité, la stabilité et la qualité de votre code en détectant rapidement les bugs et en validant les modifications avant le déploiement. Ils permettent de maintenir un code propre et de réduire les risques d'introduire des erreurs, facilitant ainsi la maintenance à long terme. Pytest est un outil puissant pour écrire et exécuter des tests en Python, offrant une syntaxe simple et flexible, ainsi que des fonctionnalités avancées pour gérer efficacement les cas de test, les fixtures, et les rapports de test, ce qui améliore la robustesse globale du projet.

Le projet contient un répertoire tests incluant

1. Un test permettant de vérifier la correspondance des paramètres du filtre pour un jeu de composants particuliers.
2. Un test permettant de vérifier que la méthode set_components permet bien de respecter le cahier des charges (valeurs des paramètres du filtre)

Pour executer ces tests, il suffit de lancer la commande :

make tests

Avec nos modifications du code, pytest doit indiquer que 2 tests sont réussis (2 passed)

Respect du PEP8

Dans un projet collaboratif, il est important que votre code respecte les bonnes pratiques d'écriture. En python, le PEP8 définit un ensemble de règles à respecter (https://peps.python.org/pep-0008/). Respecter le PEP 8 est crucial pour assurer la lisibilité, la cohérence et la maintenance du code, surtout dans des projets collaboratifs. Cela facilite la collaboration entre développeurs et permet d'utiliser efficacement les outils de développement automatisés, tout en montrant un niveau de professionnalisme dans votre travail.

Flake8 est un programme permettant de vérifier que les règles du PEP8 sont bien respectées. Pour lancer une analyse flake8, il suffit de lancer la commande :

make lint

Lors d'une analyse avec flake8, les lignes en rouge indiquent des violations du style de codage définies par PEP 8 ou des erreurs de syntaxe. Chaque message inclut un code d'erreur qui précise le type de problème (par exemple, E pour les erreurs de style, F pour les erreurs de syntaxe), ainsi que la ligne concernée dans le code, vous permettant de corriger ces issues pour améliorer la qualité du code.

Génération de la documentation

La documentation est essentielle pour assurer la compréhension, la maintenance et l'utilisation efficace de votre code par vous-même et d'autres développeurs. Elle sert de guide pour expliquer le fonctionnement, les fonctionnalités, et les bonnes pratiques à suivre, réduisant ainsi le temps d'apprentissage et facilitant la collaboration. Sphinx est un outil puissant pour générer de la documentation en Python, permettant de créer des documents clairs, bien structurés, et faciles à naviguer. Il supporte le format reStructuredText et peut automatiquement extraire les docstrings du code, ce qui garantit une documentation à jour et intégrée directement au processus de développement.

Pour générer la documentation automatiquement à partir des docstrings, il suffit de lancer la commande

make docs

Après la génération, la documentation est disponible sous la forme de pages web accessibles dans le répertoire ./docs/build/html/index.html