Modification du calcul de R1 et R2 avec l'algo de tri de Jérôme et la bibliothèque Numpy

README.md

@@ -22,11 +22,11 @@
   - [Étape 4 : Installer les dépendances](#étape-4--installer-les-dépendances)
 - [Utilisation](#utilisation)
 - [Documentation des fonctions du répertoire `src`](#documentation-des-fonctions-du-répertoire-src)
-  - [display\_functions.py : `print_list_items_by_line(list_to_display, max_item_per_line=25)`](#display_functionspy--print_list_items_by_linelist_to_display-max_item_per_line25)
-  - [e\_series\_gererator.py : `get_available_e_series()`](#e_series_gereratorpy--get_available_e_series)
-  - [e\_series\_gererator.py : `generate_e_series_resistor(start, end, serie)`](#e_series_gereratorpy--generate_e_series_resistorstart-end-serie)
-  - [voltage\_divider\_calculator.py : `get_output_voltage_bridge(Vin, R1, R2)`](#voltage_divider_calculatorpy--get_output_voltage_bridgevin-r1-r2)
-  - [voltage\_divider\_calculator.py : `get_resistor_bridge_values(Vin, Vout, max_somme, e_serie, erreur_min)`](#voltage_divider_calculatorpy--get_resistor_bridge_valuesvin-vout-max_somme-e_serie-erreur_min)
+    - [🔹 display\_functions.py : `print_list_items_by_line(list_to_display, max_item_per_line=25)`](#-display_functionspy--print_list_items_by_linelist_to_display-max_item_per_line25)
+    - [🔹 e\_series\_gererator.py : `get_available_e_series()`](#-e_series_gereratorpy--get_available_e_series)
+    - [🔹 e\_series\_gererator.py : `generate_e_series_resistor(start, end, serie)`](#-e_series_gereratorpy--generate_e_series_resistorstart-end-serie)
+    - [🔹 voltage\_divider\_calculator.py : `get_output_voltage_bridge(Vin, R1, R2)`](#-voltage_divider_calculatorpy--get_output_voltage_bridgevin-r1-r2)
+    - [🔹 voltage\_divider\_calculator.py : `get_resistor_bridge_values(Vin, Vout, max_somme, e_serie, erreur_min)`](#-voltage_divider_calculatorpy--get_resistor_bridge_valuesvin-vout-max_somme-e_serie-erreur_min)
 - [Ouvert aux contributions](#ouvert-aux-contributions)
 - [Licence](#licence)
 
@@ -407,7 +407,7 @@ Vous pouvez modifier les valeurs d'entrée du programme pour tester différentes
 
 ## Documentation des fonctions du répertoire `src`
 
-### display_functions.py : `print_list_items_by_line(list_to_display, max_item_per_line=25)`
+#### 🔹 display_functions.py : `print_list_items_by_line(list_to_display, max_item_per_line=25)`
 
 Affiche les éléments d'une liste avec la méthode `print()` en regroupant un nombre maximum d'éléments par ligne.
 
@@ -415,13 +415,13 @@ Affiche les éléments d'une liste avec la méthode `print()` en regroupant un n
 * **max_item_per_line:** Le nombre maximum d'éléments à afficher par ligne.
 * **Retour:** Aucun.
 
-### e_series_gererator.py : `get_available_e_series()`
+#### 🔹 e_series_gererator.py : `get_available_e_series()`
 
 Fonction pour obtenir la liste des séries de résistances normalisées disponibles.
 
 * **Retour:** Une liste des séries de résistances normalisées disponibles.
 
-### e_series_gererator.py : `generate_e_series_resistor(start, end, serie)`
+#### 🔹 e_series_gererator.py : `generate_e_series_resistor(start, end, serie)`
 
 Fonction pour générer une série de résistances normalisées selon la norme CEI 60063.
 
@@ -430,7 +430,7 @@ Fonction pour générer une série de résistances normalisées selon la norme C
 * **serie:** La série E souhaitée (par exemple: "E24", "E48", "E96", etc.).
 * **Retour:** La liste de valeurs de résistances normalisées dans la série spécifiée.
 
-### voltage_divider_calculator.py : `get_output_voltage_bridge(Vin, R1, R2)`
+#### 🔹 voltage_divider_calculator.py : `get_output_voltage_bridge(Vin, R1, R2)`
 
 Fonction pour calculer la tension de sortie d'un pont diviseur.
 
@@ -439,7 +439,7 @@ Fonction pour calculer la tension de sortie d'un pont diviseur.
 * **R2:** Valeur de la résistance R2 en ohms.
 * **Retour:** Tension de sortie du pont diviseur en volts.
 
-### voltage_divider_calculator.py : `get_resistor_bridge_values(Vin, Vout, max_somme, e_serie, erreur_min)`
+#### 🔹 voltage_divider_calculator.py : `get_resistor_bridge_values(Vin, Vout, max_somme, e_serie, erreur_min)`
 
 Fonction pour calculer les valeurs de résistance d'un pont diviseur.
 
@@ -464,7 +464,7 @@ Fonction pour calculer les valeurs de résistance d'un pont diviseur.
 
 ✒️ _**Contact :**_
 
-Vous pouvez me contacter par mail à l'adresse suivante :
+_Vous pouvez me contacter par mail à l'adresse suivante :_
 
 📨 <a href="mailto:arnauld.biganzoli@laplace.univ-tlse.fr?subject=Contact%20sur%20le%20projet%20Python%20pour%20pont%20diviseur%20de%20tension">arnauld.biganzoli [at] laplace.univ-tlse.fr</a>
 
@@ -482,6 +482,6 @@ _**Merci de votre intérêt pour ce projet !**_
 
 Ce projet est sous licence [GNU GPLv3](https://www.gnu.org/licenses/quick-guide-gplv3.fr.html)
 
-_La GNU GPLv3 vous garantit la liberté d'utilisation, de modification et de distribution de ce projet, à l'exception de distribuer des versions à code source fermé._
+🏆 _La GNU GPLv3 vous garantit la liberté d'utilisation, de modification et de distribution de ce projet, à l'exception de distribuer des versions à code source fermé._
 
 Merci de consulter le fichier [LICENCE](LICENSE) pour plus d'informations.

src/voltage_divider_calculator.py

@@ -36,7 +36,7 @@ Description: Module for calculating the resistance values of a divider bridge
 # =============================================================================
 __author__ = ["Arnauld BIGANZOLI"]
 __copyright__ = "Copyright (c) 2025 LAPLACE, UMR INP-UPS-CNRS N°5213"
-__credits__ = ["Arnauld BIGANZOLI"]
+__credits__ = ["Arnauld BIGANZOLI", "Jérôme BRIOT"]
 __license__ = "GNU GPLv3"
 __version__ = "1.0.0"
 __maintainer__ = "Arnauld BIGANZOLI"
@@ -85,29 +85,41 @@ def get_resistor_bridge_values(Vin, Vout, max_somme, e_serie, erreur_min):
     Returns:
         _type_: R1, R2
     """
-    meilleure_erreur = float("inf")
-    meilleure_R1 = None
-    meilleure_R2 = None
-
-    for R1 in e_serie:
-        # Optimisation : on ne considère que les R2 tels que R1 + R2 <= max_somme
-        # print("Calcul pour R1 = ", R1)
-        for R2 in e_serie:
-            # print("avec R2 = ", R2)
-            if R1 + R2 <= max_somme:
-                Vout_calc = get_output_voltage_bridge(
-                    Vin, R1, R2
-                )  # Calcul de la tension de sortie
-                erreur = abs(Vout_calc - Vout)
-
-                # Si on trouve une solution meilleure, on met à jour les valeurs
-                if erreur < meilleure_erreur:
-                    meilleure_erreur = erreur  # Mise à jour de l'erreur minimale
-                    meilleure_R1 = R1
-                    meilleure_R2 = R2
-                    # Si l'erreur est inférieure au seuil, on peut arrêter la recherche
-                    # if erreur < erreur_min:
-                    #     return meilleure_R1, meilleure_R2
+    # Création d'un tableau numpy pour les valeurs de résistances de la série E passée en paramètre
+    tab_serie = np.array(e_serie)
+    print(tab_serie)
+    # pause = input("Pause")
+
+    # Calcule de toutes les valeurs vin * R1 / (R1 + R2) en une seule ligne
+    v = Vin * np.divide(tab_serie, np.add.outer(tab_serie, tab_serie))
+    print("Tension de sortie pour chaque couple de résistances :\n", v)
+
+    # Calcul de l'erreur par rapport à la tension de sortie voulue
+    err = (v - Vout) / Vout  # err max = 0.5 (50%)
+    print("err max = \n", err)
+
+    # https://numpy.org/doc/2.1/reference/generated/numpy.ndarray.html
+    # https://note.nkmk.me/en/python-numpy-select-element-row-column-array/
+    ind = np.unravel_index(np.argsort(abs(err), axis=None), err.shape)
+
+    err = err[ind]
+    v = v[ind]
+    t = np.tile(tab_serie, (tab_serie.shape[0], 1))
+    tt = t.transpose()
+    t = t[ind]
+    tt = tt[ind]
+
+    # Affectation des valeurs de résistances pour lesquelles l'erreur est minimale
+    meilleure_R1, meilleure_R2 = int(tt[0]), int(t[0])
+    # print(f"R1 min = {meilleure_R1} ohms")
+    # print(f"R2 min = {meilleure_R2} ohms\n")
+    # pause = input("Pause")
+
+    # Affichage des résultats dans un tableau
+    print("  R1\t  R2\t Vout\t Err")
+    for a, b, c, d in zip(tt, t, v, err):
+        if abs(d) <= erreur_min:
+            print(f"{a:4d}\t{b:4d}\t{c:.3f}V\t{d*100:+3.1f}%")
 
     return meilleure_R1, meilleure_R2
 
@@ -149,11 +161,47 @@ if __name__ == "__main__":
     resistor_in_serie = generate_e_series_resistor(
         r_start, r_end, serie
     )  # Création des valeurs de résistances dans la série
-    erreur_min = 0.05  # Seuil d'erreur acceptable
+
+    # **Calcul de l'erreur**
+    #
+    # 1. **Calculer la différence absolue :**
+    #
+    # * On soustrait la valeur théorique (Vout souhaitée) à la valeur mesurée :
+    #     * Différence = Vout mesurée - Vout souhaitée
+    #     * Différence = 4.05 V - 4 V
+    #     * Différence = 0.05 V
+
+    # Valeur absolue du seuil d'erreur acceptable en V par rapport à la tension de sortie
+    abs_voltage_threshold_error = (
+        0.05  # acceptable error threshold in V relative to the output voltage
+    )
+
+    # 2. **Calculer l'erreur relative :**
+    #
+    # * On divise la différence absolue par la valeur théorique :
+    #     * Erreur relative = (Différence / Vout souhaitée)
+    #     * Erreur relative = (0.05 V / 4 V)
+    #     * Erreur relative = 0.0125
+
+    relative_error_threshold = (
+        abs_voltage_threshold_error / Vout
+    )  # Seuil d'erreur relative acceptable par rapport à la tension de sortie
+
+    # 3. **Convertir en pourcentage :**
+    #
+    # * On multiplie l'erreur relative par 100 pour obtenir l'erreur en pourcentage :
+    #     * Erreur en pourcentage = Erreur relative * 100
+    #     * Erreur en pourcentage = 0.0125 * 100
+    #     * Erreur en pourcentage = 1.25 %
+
+    # Erreur minimum en pourcentage par rapport à la tension de sortie
+    erreur_min_in_percentage = (
+        relative_error_threshold * 100
+    )  # Seuil d'erreur acceptable en pourcentage par rapport à la tension de sortie
 
     # Trouver les valeurs résistances du pont diviseur
     R1, R2 = get_resistor_bridge_values(
-        Vin, Vout, max_somme, resistor_in_serie, erreur_min
+        Vin, Vout, max_somme, resistor_in_serie, abs_voltage_threshold_error
     )
 
     # Présentation des résultats
@@ -167,7 +215,10 @@ if __name__ == "__main__":
     # print(resistor_in_serie)
     print_list_items_by_line(resistor_in_serie, 10)
 
-    print(f"\nAvec une erreur minimale souhaitée de {erreur_min} V,", end=" ")
+    print(
+        f"\nAvec une erreur minimale souhaitée de {abs_voltage_threshold_error} V,",
+        end=" ",
+    )
     print("les valeurs de résistances calculées sont:")
     # print(f"R1 = {int(R1)} ohms")
     # print(f"R2 = {int(R2)} ohms\n")
@@ -182,10 +233,10 @@ if __name__ == "__main__":
     Vout_calc = Vin * R2 / (R1 + R2)
     print(f"La tension de sortie calculée est de {Vout_calc:.3f} V")
     print(f"L'erreur de calcul est de {abs(Vout_calc - Vout):.4f} V")
-    print(f"L'erreur maximale autorisée était de {erreur_min:.3f} V\n")
+    print(f"L'erreur maximale autorisée était de {abs_voltage_threshold_error:.3f} V\n")
 
     # Comparaison de l'erreur de calcul avec l'erreur maximale autorisée
-    if abs(Vout_calc - Vout) <= erreur_min:
+    if abs(Vout_calc - Vout) <= abs_voltage_threshold_error:
         print(
             "L'erreur de calcul est inférieure à l'erreur maximale autorisée, les valeurs de résistances sont validées.\n"
         )