README.md

<h2>Calculateur de résistances pour pont diviseur de tension</h2>

<h3>
<a href="" title="" target="_blank">
<table>
  <tr>
    <td><img src="images/calculator-icon.png" width="60" alt="Calculateur de résistances pour pont diviseur de tension" /></td>
    <td><i>Programme pour calculer les valeurs optimales du couple R1 et R2, afin d'avoir une tension de sortie ayant l'erreur la plus faible avec des résistances de séries normalisées.</i></td>
  </tr>
</table>
</a>
</h3>

📚 **Sommaire :**

- [Introduction](#introduction)
- [Description du projet](#description-du-projet)
- [Installation](#installation)
  - [Étape 1 : Cloner le dépôt](#étape-1--cloner-le-dépôt)
  - [Étape 2 : Installer les dépendances dans un environnement virtuel](#étape-2--installer-les-dépendances-dans-un-environnement-virtuel)
  - [Étape 3 : Exécuter le programme de calcul de résistances](#étape-3--exécuter-le-programme-de-calcul-de-résistances)
  - [É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\\table\_formatting.py : `print_list_items_by_line(list_to_display, max_item_per_line=25)`](#-displaytable_formattingpy--print_list_items_by_linelist_to_display-max_item_per_line25)
    - [🔹 calculator\\e\_series\_gererator.py : `get_available_e_series()`](#-calculatore_series_gereratorpy--get_available_e_series)
    - [🔹 calculator\\e\_series\_gererator.py : `generate_e_series_resistor(start, end, serie)`](#-calculatore_series_gereratorpy--generate_e_series_resistorstart-end-serie)
    - [🔹 calculator\\e\_series\_values.py](#-calculatore_series_valuespy)
    - [🔹 calculator\\voltage\_divider\_calculator.py : `get_output_voltage_bridge(Vin, R1, R2)`](#-calculatorvoltage_divider_calculatorpy--get_output_voltage_bridgevin-r1-r2)
    - [🔹 calculator\\voltage\_divider\_calculator.py : `get_resistor_bridge_values(Vin, Vout, max_somme, e_serie, erreur_min)`](#-calculatorvoltage_divider_calculatorpy--get_resistor_bridge_valuesvin-vout-max_somme-e_serie-erreur_min)
- [Conception de l'application graphique](#conception-de-lapplication-graphique)
- [Ouvert aux contributions](#ouvert-aux-contributions)
- [Licence](#licence)

---

<br />

## Introduction

Le pont diviseur de tension est un des circuits du monde de l'électronique le plus simple. Il permet d'obtenir une tension inférieure à une tension d'alimentation. Constitué de deux résistances en série, il est utilisé en électronique pour créer des références de tension ou atténuer des signaux.

Le [principe de fonctionnement du pont diviseur de tension](https://fr.wikipedia.org/wiki/Diviseur_de_tension) est basé sur la loi d'Ohm et la loi des mailles. La tension de sortie du pont diviseur est calculée en fonction de la tension d'entrée et des valeurs des résistances.

<!-- ![voltage-divider](images/voltage-divider.png "Schéma d'un pont diviseur de tension") -->
<!-- $Vout = Vin \cdot \frac{R_2}{R_1 + R_2}$ -->

<img src="/images/voltage-divider.png" width="150" alt="Schéma d'un pont diviseur de tension">

La tension de sortie $Vout$ est donnée par la formule suivante :

$Vout = Vin \times \frac{R_2}{R_1 + R_2}$

<br />

**La problématique**

Le calcul des valeurs exactes de R1 et R2 pour un pont diviseur de tension peut sembler simple à première vue, mais il est souvent rendu complexe par plusieurs facteurs :

* **Nombre infini de solutions théoriques:** Pour une paire de valeurs Vin et Vout données, il existe une infinité de combinaisons de R1 et R2 possibles qui satisfont à l'équation du pont diviseur.
* **Contraintes pratiques:**
    * **Série normalisée:** Les résistances disponibles commercialement sont normalisées selon des séries (_E3, E6, E12, etc._). Il faut donc trouver les valeurs standardisées les plus proches des valeurs calculées, ce qui introduit une marge d'erreur.
    * **Tolérance:** Les résistances ont une tolérance, ce qui signifie que leur valeur réelle peut légèrement différer de la valeur nominale.
    * **Puissance dissipée:** Bien que cela ne soit pas un problème pour les tensions faibles, les résistances doivent être choisies de manière à ne pas dissiper une puissance excessive.
* **Précision souhaitée:** Le niveau de précision requis pour la tension de sortie peut varier en fonction de l'application. Un calcul d'incertitude peut être nécessaire pour évaluer la fiabilité du pont diviseur et définir les marges d'erreur acceptables.

<br />

Juste un exemple pour illustrer la problématique du choix d'appairage des résistances pour un pont diviseur de tension donnée. **Si l'on prend simplement les valeurs de résistances dans la série E48** et que l'on ne prend que des valeurs de résistances **entre 1 kΩ et 10 kΩ**, on doit alors **choisir parmi les 2401 valeurs possibles de couples de résistance** pour obtenir la tension de sortie la plus proche de la tension de sortie désirée.

<details>

<summary><i>Développer la section pour plus de détail sur le calcul du nombre de combinaison possible...</i></summary>

<b>Nombre total de combinaisons :</b>

Soit les valeurs de résistances comprises entre 1 kΩ à 10 kΩ de la série E48, soit 49 valeurs au total :

<table>
  <tr>
    <td>1000</td>
    <td>1050</td>
    <td>1100</td>
    <td>1150</td>
    <td>1210</td>
    <td>1270</td>
    <td>1330</td>
    <td>1400</td>
    <td>1470</td>
    <td>1540</td>
  </tr>
  <tr>
    <td>1620</td>
    <td>1690</td>
    <td>1780</td>
    <td>1870</td>
    <td>1960</td>
    <td>2050</td>
    <td>2150</td>
    <td>2260</td>
    <td>2370</td>
    <td>2490</td>
  </tr>
  <tr>
    <td>2610</td>
    <td>2740</td>
    <td>2870</td>
    <td>3010</td>
    <td>3160</td>
    <td>3320</td>
    <td>3480</td>
    <td>3650</td>
    <td>3830</td>
    <td>4020</td>
  </tr>
  <tr>
    <td>4220</td>
    <td>4420</td>
    <td>4640</td>
    <td>4870</td>
    <td>5110</td>
    <td>5360</td>
    <td>5620</td>
    <td>5900</td>
    <td>6190</td>
    <td>6490</td>
  </tr>
  <tr>
    <td>6810</td>
    <td>7150</td>
    <td>7500</td>
    <td>7870</td>
    <td>8250</td>
    <td>8660</td>
    <td>9090</td>
    <td>9530</td>
    <td>10000</td>
    <td></td>
  </tr>
</table>

Puisqu'il y a 49 éléments dans le premier ensemble, et que pour chacun, il y a 49 paires possibles, le nombre total de combinaisons est :

49 (éléments/ensemble) x 49 (combinaisons/élément) :  $49 \times 49 = 2401$ combinaisons possibles.

<b><i>En associant par paire les résistances des deux ensembles R1 et R2, comprenant 49 valeurs chacune, cela nous donne un total de 2401 combinaisons possibles.</i></b>
</div>
</details>

<br />

**Pourquoi un calculateur Python ?**

Il existe de nombreux outils en ligne pour calculer les valeurs d'un pont diviseur de tension,<br />en voici un exemple proposé par [Circuit Digest](https://circuitdigest.com/calculators/voltage-divider-calculator) :

<!-- ![voltage-divider-calculator](images/circuitdigest-voltage-divider-calculator.png "Calculateur de pont diviseur de tension de Circuit Digest") -->

<a href="https://circuitdigest.com/calculators/voltage-divider-calculator" title="Calculateur de pont diviseur de tension de Circuit Digest">
<img src="/images/circuitdigest-voltage-divider-calculator.png" width="450" />
</a><br />

<br />

**Alors, pourquoi développer un calculateur Python ?**

Les outils en ligne peuvent être très utiles, mais ils présentent quelques inconvénients :

* **Limitations:** Ils peuvent ne pas prendre en compte toutes les contraintes pratiques (série normalisée, puissance, tolérance).
* **Personnalisation:** Ils peuvent ne pas permettre de personnaliser les paramètres du calcul (série de résistances, seuil d'erreur).
* **Fiabilité:** Ils peuvent ne pas être mis à jour régulièrement ou être sujets à des erreurs de calcul que l'on ne verrait pas.
* **Flexibilité:** Ils peuvent ne pas être facilement intégrés à d'autres outils ou processus.
* **Dépendance:** Ils peuvent être soumis à des restrictions d'accès ou de disponibilité en ligne.
* **Confidentialité:** Ceci n'est vraisemblablement pas un problème pour un calculateur de pont diviseur de tension, mais certains outils en ligne peuvent collecter des données personnelles.

Un calculateur Python peut apporter une solution efficace à ces problématiques :

* **L'automatisation des calculs:** Permets d'effectuer rapidement des calculs pour différentes combinaisons de valeurs en entrée du programme.
* **Prise en compte des contraintes:** Il peut intégrer des contraintes telles que la série normalisée ou la tolérance des résistances, voir l'impédance ou la puissance maximale...
* **Flexibilité:** Il peut être facilement adapté à différentes situations ou besoins spécifiques.
* **Visualisation:** Il peut fournir des résultats sous différentes formes, graphiques, tableaux pour faciliter l'analyse ou application de bureau type calculatrice.

<br />

🤔 **Comment résoudre le problème ?**

1. **Formulation mathématique:**
   * Utiliser la formule du pont diviseur pour établir une relation entre Vin, Vout, R1 et R2.
   * Introduire des contraintes supplémentaires (série normalisée, tolérance, etc.).
2. **Algorithme de résolution:**
   * **Méthode naïve:** Tester toutes les combinaisons possibles de valeurs standardisées de R1 et R2 jusqu'à trouver celle qui minimise l'erreur par rapport à la tension de sortie désirée.
   * **Méthodes plus sophistiquées:** Utiliser des algorithmes d'optimisation numérique pour trouver rapidement la solution optimale.
3. **Implémentation en Python:**
   * Utiliser des bibliothèques numériques comme NumPy pour les calculs matriciels et SciPy pour les algorithmes d'optimisation.
   * Créer une interface utilisateur (graphique ou en ligne de commande) pour faciliter l'utilisation du calculateur.

🚀 **En résumé**

**Le calcul des résistances d'un pont diviseur** est un problème qui peut sembler simple, mais qui **devient rapidement complexe** lorsqu'on prend en compte les contraintes pratiques et la nécessité de trouver une solution optimale. **Un calculateur Python permet d’automatiser ce processus** et de fournir des résultats précis et fiables, **en tenant compte de tous vos paramètres pertinents**.

De plus, **vous pouvez personnaliser le calculateur pour répondre à vos besoins spécifiques** et l'intégrer facilement à d'autres outils ou processus. C'est un outil puissant et flexible qui peut vous faire gagner du temps et vous aider à prendre des décisions éclairées en matière de conception électronique. On pourrait par exemple envisager de l'intégrer à un outil de conception assistée par ordinateur (CAO) pour automatiser la sélection des composants, rajouter des paramètres de contraintes de puissance, de tolérance, de série normalisée. Voir réaliser des calculs de puissance dissipée ou sur l'incertitude de mesure due à la tolérance des résistances, etc.

🎯 **Les principaux avantages d'un tel outil sont:**

* **Gain de temps:** Les calculs sont effectués rapidement et automatiquement.
* **Précision:** Les résultats sont plus précis grâce à l'utilisation d'algorithmes d'optimisation.
* **Flexibilité:** L'outil peut être facilement adapté à différents besoins.
* **Facilité d'utilisation:** Il est possible de créer une interface utilisateur intuitive permettant à des utilisateurs non experts d'effectuer des calculs complexes.

## Description du projet

Ce projet à pour but de fournir un calculateur en Python permettant de trouver les valeurs de R1 et R2 d'un pont diviseur de tension, à partir de 5 données en entrée :

- La tension d'entrée du pont (Vin),
- La tension de sortie du pont désirée (Vout),
- La limite max de la somme de R1 et R2,
- La [série normalisée de la norme CEI 60063](https://fr.wikipedia.org/wiki/CEI_60063) à utiliser,
- La valeur du seuil d'erreur acceptable.

Le programme retourne les valeurs de R1 et R2 qui respectent les contraintes imposées.

Ce programme a été développé pour répondre à un besoin de conception afin d'adapter des tensions d'entrée à des tensions de sortie spécifiques, en utilisant des résistances de séries normalisées.

De base, j'utile [l'outil intégré de KiCad](https://docs.kicad.org/master/en/pcb_calculator/pcb_calculator.html#e-series) permettant de gérer une solution d'association de résistances en série et/ou en parallèle, en utilisant les séries E de résistances normalisées.

![kicad-resistor-calculator](images/kicad-resistor-calculator.png "Outil de calcul de résistances de KiCad")

Cependant, cet outil ne permet pas de trouver les valeurs de résistances pour un pont diviseur de tension, en respectant une contrainte de somme maximale de R1 et R2.

C'est pourquoi j'ai développé ce programme en Python, pour répondre à ce besoin spécifique.

👨‍🏫 J'espère que ce programme pourra être utile à d'autres personnes, et [je suis ouvert à toutes suggestions d'amélioration](#ouvert-aux-contributions).

---

<br />

## Installation

1. Cloner le dépôt : `git clone https://gitlab.com/votre_namespace/votre_projet.git`
2. Créer un environnement virtuel : `python -m venv .env`
3. Activer l'environnement virtuel : `source .env/bin/activate` (sous Linux/macOS) ou `.env\Scripts\activate` (sous Windows)
4. Installer les dépendances : `pip install -r requirements.txt`

<details>

<summary><i>Développer la section pour plus de détail sur l'installation...</i></summary>

Dans un premier temps, [vous devez avoir une version de Python installé sur votre ordinateur](https://src.koda.cnrs.fr/laplace-service-commun-electronique/membres/arnauld-biganzoli/python/gitlab-profile/-/blob/main/docs/methode-de-developpement-pour-python.md).

Ici, j'aivais initilement commencé le développement des scripts est la version `3.12.5`, mais je suis actuemment en train de travailler avec la version `3.13`.

<img src="https://src.koda.cnrs.fr/laplace-service-commun-electronique/membres/arnauld-biganzoli/python/gitlab-profile/-/raw/main/images/Python-3.13.1-Setup-64-bit-img01.png
" width="400"><br />

Vérifier la version de Python installée sur votre ordinateur avec la commande suivante dans votre terminal [PowerShell](https://learn.microsoft.com/fr-fr/powershell/scripting/install/installing-powershell-on-windows) ou votre console de commande Windows :

```pwsh
PS C:\gitlab\laplace-service-commun-electronique\membres\arnauld-biganzoli\python\calculateur-de-resistances-pour-pont-diviseur-de-tension> py --version
Python 3.13.1
```

### Étape 1 : Cloner le dépôt

Pour installer ce projet, vous pouvez cloner le dépôt soit en utilisant le lien HTTPS (ou SSH), soit en utilisant VS Code ou un autre éditeur de code:

```bash
git clone https://src.koda.cnrs.fr/laplace-service-commun-electronique/membres/arnauld-biganzoli/python/calculateur-de-resistances-pour-pont-diviseur-de-tension.git
```

### Étape 2 : Installer les dépendances dans un environnement virtuel

Pour utiliser ce programme, vous devez installer les dépendances du projet depuis votre environnement virtuel local.

Si vous n'avez pas d'environnement virtuel, vous pouvez en créer un avec la commande suivante :

```bash
python -m venv .env
```

Activer l'environnement virtuel avec la commande suivante :

```bash
.env\Scripts\activate
```

Puis mettez à jour [le gestionnaire de paquets](https://fr.wikipedia.org/wiki/Pip_(gestionnaire_de_paquets)) `pip` avec la commande suivante :

```bash
python.exe -m pip install --upgrade pip
```

Installer maintenant les dépendances avec la commande suivante :

```bash
pip install -r requirements.txt
```

### Étape 3 : Exécuter le programme de calcul de résistances

```bash
(.env) > python src\voltage_divider_calculator.py

Pour une tension d'alimentation de 5 V et une tension de sortie de 4 V, avec des resistances de 1.0 k à 10.0 k dans la série E48 :
1000    1050    1100    1150    1210    1270    1330    1400    1470    1540
1620    1690    1780    1870    1960    2050    2150    2260    2370    2490
2610    2740    2870    3010    3160    3320    3480    3650    3830    4020
4220    4420    4640    4870    5110    5360    5620    5900    6190    6490
6810    7150    7500    7870    8250    8660    9090    9530    10000

Avec une erreur minimale souhaité de 0.002, les valeurs de resistances calculées sont:
R1 =  1620 ohms
R2 =  6490 ohms

La tension de sortie calculée est de 4.001 V
L'erreur de calcul est de 0.0012 V
L'erreur maximale autorisée était de 0.002 V

L'erreur de calcul est inférieure à l'erreur maximale autorisée, les valeurs de résistances sont validées.
```

### Étape 4 : Installer les dépendances

Il n'y a actuellement pas de dépendances externes à installer pour ce projet, car il utilise uniquement des bibliothèques Python standard.

Pour installer des dépendances dans un projet, vous pouvez utiliser le fichier `requirements.txt` fourni.

```bash
pip install -r requirements.txt
```

</details>

---

<br />

## Utilisation

<table>
    <tr>
        <td><img src="/images/cmd-terminal-icon.png" width="40"></td>
        <td>Lancez le script depuis votre console de commande pour obtenir les valeurs de résistances du pont diviseur de tension.</td>
    </tr>
</table>

Exemple de calcul de valeurs de résistances pour un diviseur avec une tension d'alimentation de 5 V et une tension de sortie de 4 V.
On souhaite utiliser des résistances de la série E6 comprises entre 4 k à 10k, dont la somme maximale ne doit pas dépasser 15000 ohms
L'erreur minimale souhaitée est de 0.6 Volts.

<details>

<summary><i>Développer la section pour voir le script Python...<i></summary>

Écrivez votre propre script à partir des sources de ce projet et personnalisez l'affichage des données comme vous le souhaitez...

<div style="background-color: rgba(255, 0, 0, 0.25); padding: 10px;">

```python
from e_series_gererator import generate_e_series_resistor
from voltage_divider_calculator import get_resistor_bridge_values

Vcc         = 5      # Tension d'alimentation
Vout        = 4      # Tension de sortie
r_start     = 4000   # Valeur minimale de la résistance
r_end       = 10000  # Valeur maximale de la résistance
serie       = "E6"   # Test the function with E48 serie
max_somme   = 15000  # Somme maximale des resistances
erreur_min  = 0.6    # Seuil d'erreur acceptable atteint
#erreur_min = 0.5    # Seuil d'erreur acceptable non atteint
                     # Generate resistors values from E serie
resistances = generate_e_series_resistor(r_start, r_end, serie)

# Rechercher les valeurs résistances du pont diviseur
R1, R2 = get_resistor_bridge_values(Vcc, Vout, max_somme, resistances, erreur_min)

# Affichage des valeurs de résistances trouvées
print(f"Pour une tension d'alimentation de {Vcc} V et une tension de sortie de {Vout} V,")
print(f"si l'on prend des valeurs de résistances entre {r_start/1000} k à {r_end/1000} k dans la série {serie}, soit {resistances} en ohms,")

# Afficher max_somme/1000 pour afficher la valeur en kOhms sans la partie décimale
print(f"et que l'on souhaite que la somme maximale de R1 + R2 ne dépasse pas {round(max_somme/1000)} kohms, avec une erreur minimale de {erreur_min} V,")

# Calcul de la longeur de la chaîne pour la valeur de la somme des résistances
str_resistor_value_len = len(str(max_somme))  # Calculer la longueur de la chaîne de max_somme

print("alors les valeurs de résistances retournées par la fonction sont:")
print(f"R1 = {int(R1):>{str_resistor_value_len}} ohms")
print(f"R2 = {int(R2):>{str_resistor_value_len}} ohms\n")

# Calcul de la tension de sortie avec les valeurs de résistances trouvées
Vout_calc = Vcc * 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")

# Comparaison de l'erreur de calcul avec l'erreur maximale autorisée
if abs(Vout_calc - Vout) < erreur_min:
    print("L'erreur de calcul est inférieure à l'erreur maximale autorisée, les valeurs de résistances sont validées\n")
else:
    print("L'erreur de calcul est supérieure à l'erreur maximale autorisée, les valeurs de résistances ne satisfassent pas les critères de calcul !\n")
    print("Il est recommandé de revoir les valeurs de résistances du pont diviseur, en changeant la valeur de la résistance de départ, la série de résistances ou l'erreur minimale autorisée.\n")
```

</div>

</details>

Les valeurs de résistances calculées seront affichées dans le terminal.

```bash
(.env) > python examples/simple_example_resistance_calculation.py
Pour une tension d'alimentation de 5 V et une tension de sortie de 4 V,
si l'on prend des valeurs de résistances entre 4.0 k à 10.0 k dans la série E6, soit [4700.0, 6800.0, 10000.0] en ohms,
et que l'on souhaite que la somme maximale de R1 + R2 ne dépasse pas 15 kohms, avec une erreur minimale de 0.6 V,
alors les valeurs de résistances retournées sont:
R1 =  4700 ohms
R2 = 10000 ohms

La tension de sortie calculée est de 3.401 V
L'erreur de calcul est de 0.599 V
L'erreur maximale autorisée était de 0.600 V

L'erreur de calcul est inférieure à l'erreur maximale autorisée, les valeurs de résistances sont validées
```

Vous pouvez modifier les valeurs d'entrée du programme pour tester différentes combinaisons de tensions d'entrée et de sortie, de séries de résistances, de contraintes de somme maximale, et de seuils d'erreur.

<br />

## Documentation des fonctions du répertoire `src`

#### 🔹 display\table_formatting.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.

* **list_to_display:** La liste à afficher.
* **max_item_per_line:** Le nombre maximum d'éléments à afficher par ligne.
* **Retour:** Aucun.

#### 🔹 calculator\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.

#### 🔹 calculator\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.

* **start:** La valeur de départ (inclusive) en ohms.
* **end:** La valeur de fin (inclusive) en ohms.
* **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.

#### 🔹 calculator\e_series_values.py

Contient les multiplicateurs de résistances des séries E selon la norme CEI 60063 dans la liste `e_series_multipliers`.

#### 🔹 calculator\voltage_divider_calculator.py : `get_output_voltage_bridge(Vin, R1, R2)`

Fonction pour calculer la tension de sortie d'un pont diviseur.

* **Vin:** Tension d'entrée du pont diviseur.
* **R1:** Valeur de la résistance R1 en ohms.
* **R2:** Valeur de la résistance R2 en ohms.
* **Retour:** Tension de sortie du pont diviseur en volts.

#### 🔹 calculator\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.

* **Vcc (float):** Tension d'alimentation.
* **Vout (float):** Tension de sortie souhaitée.
* **max_somme (int):** Somme maximale des résistances R1 et R2.
* **e_serie (_type_):** Série de résistances normalisées.
* **erreur_min (float):** Seuil d'erreur acceptable.
* **Retour:** Les valeurs des résistances R1 et R2 qui respectent les contraintes imposées.

---

<br />

## Conception de l'application graphique

L'idée est de créer une interface utilisateur simple et intuitive pour permettre à l'utilisateur de saisir les valeurs d'entrée du pont diviseur (Vin, Vout, série de résistances, etc.) et d'obtenir les valeurs de résistances calculées en sortie.

Voici un aperçu de l'étude de la conception pour l'application graphique pour le calcul des valeurs de résistances d'un pont diviseur de tension :

![design-app-for-voltage-divider-bridge](images/global-design-app-for-voltage-divider-bridge.drawio.png)

Une première version de l'application graphique pour le calcul des valeurs de résistances d'un pont diviseur de tension :

![app-tkinter-for-voltage-divider-bridge](images/app-tkinter-for-voltage-divider-bridge.png)

Pour lancer l'application graphique, vous pouvez exécuter le script `main.py` dans le répertoire `src` :

```bash
(.env) > python src/main.py
```

A comparer avec les scripts du répertoire `examples` :

```bash
(.env) > python examples/simple_example_resistance_calculation.py # pré rempli avec des valeurs de test
(.env) > python examples/example_resistance_calculation.py # demande à l'utilisateur de saisir les différentes valeurs
```

---

<br />

## Ouvert aux contributions

👍_**N'hésitez pas à contribuer à ce projet en :**_

* Soumettant des idées de nouveaux projets :smiley:
* M'aider à améliorer la documentation existante 📝
* Faire remonter et proposer des corrections de bugs ✅

✒️ _**Contact :**_

_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>

_**Merci de votre intérêt pour ce projet !**_

---

<br />

## Licence

![Laplace](https://src.koda.cnrs.fr/laplace-service-commun-electronique/membres/arnauld-biganzoli/python/gitlab-profile/-/raw/main/images/logo-laplace.png "Logo LAPLACE")

**Copyright (c) 2025 LAPLACE, UMR INP-UPS-CNRS N°5213**

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é._

Merci de consulter le fichier [LICENCE](LICENSE) pour plus d'informations.

https://www.gnu.org/licenses/gpl-3.0.txt