Physique-chimie · 1re · Enseignement de spécialité · Projet n°3

La bonne résistance,
au bon moment.

Brancher n'importe quelle résistance en sortie d'une pile ne donne jamais le meilleur résultat : il existe toujours une valeur précise pour laquelle la puissance transmise à la charge est maximale. C'est le principe d'adaptation d'impédance, omniprésent en électronique — jusque dans la manière dont le réseau électrique français est piloté pour limiter le gaspillage.

adaptation.py — aperçur = 0.00 Ω — P = 0.00 W

Objectif du projet : modéliser une source électrique réelle à partir de sa caractéristique expérimentale, déterminer numériquement le point de fonctionnement du circuit pour différentes charges, puis mettre en évidence la valeur de résistance qui maximise la puissance transmise — la condition d'adaptation d'impédance.

Ce projet est autonome : tu n'as besoin d'aucun autre document, les données de la caractéristique tension-courant sont recopiées directement dans le script. Chaque étape contient un script incomplet à compléter, puis à copier-coller dans Thonny (ou dans la console Basthon tout en bas de la page si tu n'as pas Thonny sous la main).

＋

Contexte : pourquoi adapter une charge à sa source ?

À savoir
  • Les problématiques d'adaptation d'une charge à une source électrique sont omniprésentes dans le monde technologique. Le réseau électrique français lui-même doit en permanence être adapté au parc de centrales qui l'alimentent, pour éviter certains gaspillages énergétiques.
  • Une source électrique réelle (une pile, une batterie…) n'est jamais parfaite : sa tension de sortie chute légèrement lorsqu'elle débite du courant, à cause d'une résistance interne. On peut la représenter par l'association en série d'une source idéale de f.é.m. E0 et d'une résistance de sortie Rs.
  • Brancher une résistance de charge r en sortie de cette source, c'est créer un circuit dont le fonctionnement dépend à la fois de la source (E0, Rs) et de la charge (r). Ce projet cherche la valeur de r qui reçoit le plus de puissance possible — la condition dite d'adaptation d'impédance.
00

La caractéristique de la source réelle

À savoir
  • La source réelle étudiée a été caractérisée expérimentalement dans plusieurs états de charge (S = 10 %, 25 %, 50 %, 75 %, 90 %), donnant une famille de courbes tension-courant très proches les unes des autres.
  • On ne retient ici que l'état S = 90 % : un pointage des valeurs de tension u (en V) et de courant i (en A) a été réalisé et saisi dans deux tableaux.
  • Le script ci-dessous est déjà complet : copie-le tel quel dans Thonny (ou dans Basthon) pour commencer.
etape0_donnees.py
import numpy as np
import matplotlib.pyplot as plt
from scipy.optimize import bisect

# Courant débité par la source réelle (A), état de charge S = 90 %
i = np.array([0, 0.2, 0.4, 0.6, 0.8, 1, 1.2, 1.4, 1.6, 1.8])

# Tension à ses bornes (V), pour chacune de ces valeurs de courant
u = np.array([1, 0.9, 0.8, 0.7, 0.6, 0.5, 0.4, 0.3, 0.2, 0.1])
01

Tracer la caractéristique, puis la modéliser

Consigne
  • Trace u en fonction de i, en points bleus ('bo') puis relie-les d'un trait rouge ('r').
  • Modélise ensuite ce nuage de points par une droite avec np.polyfit(i, u, 1), et affiche le résultat : nomme-le rl (pour « régression linéaire »).
  • Comme polyfit renvoie une liste de nombres et non une fonction utilisable directement, définis une fonction urmod(i) qui renvoie rl[1] + rl[0]*i — la tension prédite par le modèle pour un courant i donné.
  • Superpose enfin ce modèle aux points mesurés, en ronds rouges ('ro').
etape1_regression.py
# TODO : trace les points mesurés
plt.plot(_, _, '__')
plt.plot(_, _, '_')

# TODO : régression linéaire de u en fonction de i
rl = np.polyfit(_, _, _)
print(rl)

# TODO : fonction modèle construite à partir des résultats de polyfit
def urmod(i) :
    return rl[_] + rl[_]*i

plt.plot(i, urmod(i), '__')
plt.show()
Indice

np.polyfit(i, u, 1) cherche le polynôme de degré 1 (une droite a·i + b) qui approche au mieux les points : il renvoie [a, b], donc ici rl[0] est la pente et rl[1] l'ordonnée à l'origine.

Résultat attendu

rl affiche [-0.5 1.] : une pente de -0,5 et une ordonnée à l'origine de 1. Physiquement, cela signifie une f.é.m. à vide E0 = 1 V et une résistance de sortie Rs = 0,5 Ω — des ordres de grandeur cohérents pour une batterie portable.

02

Superposer les droites de charge

Consigne
  • Une résistance de charge r obéit à la loi d'Ohm : ur = r × i. Sur le même graphe que la caractéristique de la source, chaque valeur de r dessine donc une droite passant par l'origine.
  • Crée une liste de valeurs de résistances à tester avec rliste = np.arange(10)/5 (des valeurs qui encadrent Rs), puis, dans une boucle for r in rliste :, calcule ur = r*i et trace-la.
etape2_droites_charge.py
rliste = np.arange(10) / _
plt.plot(i, u, '__')
plt.plot(i, u, '_')

# TODO : trace une droite de charge ur = r*i pour chaque valeur de r
for r in ______ :
    ur = _ * _
    plt.plot(i, ur)
plt.show()
Résultat attendu

Un éventail de droites colorées, chacune croisant la caractéristique rouge de la source en un point différent : chaque valeur de r engendre son propre point de fonctionnement. On pourrait lire ces intersections graphiquement, mais ce serait fastidieux et peu précis — d'où l'intérêt de la méthode numérique qui suit.

03

Trouver le point de fonctionnement avec bisect

Consigne
  • Le point de fonctionnement, pour une charge r donnée, correspond au courant if qui vérifie à la fois la caractéristique de la source et celle de la charge : ur(if) = u(if), c'est-à-dire r·if = rl[1] + rl[0]·if.
  • La fonction bisect(f, a, b) du module scipy.optimize trouve numériquement la valeur qui annule une fonction f, entre les bornes a et b. Il faut donc définir une fonction nul(i) qui vaut zéro exactement au point de fonctionnement : nul(i) = rl[1] + rl[0]*i − r*i.
  • Dans une boucle for r in rliste :, appelle bisect(nul, 0, 2) pour chaque valeur de r, et stocke les résultats dans une liste lpfi avec .append(...).
etape3_bisect.py
# TODO : fonction qui s'annule exactement au point de fonctionnement
def nul(i) :
    return rl[_] + rl[_]*i - _*i

lpfi = []
for r in rliste :
    pfi = bisect(___, 0, 2)
    lpfi.append(___)
print(lpfi)
Indice

Remarque subtile : la fonction nul utilise la variable r, qui n'est pas un de ses arguments — elle vient de la boucle for qui l'entoure. Cela fonctionne ici parce que bisect(nul, 0, 2) est appelée immédiatement, à chaque tour de boucle, avec la valeur de r du moment.

Résultat attendu

Une liste de 10 valeurs de courant, décroissantes de 2,0 A (pour r = 0) à environ 0,43 A (pour la plus grande résistance testée) : le courant de fonctionnement diminue quand la résistance de charge augmente, comme attendu.

04

Calculer la puissance reçue et trouver l'adaptation

Consigne
  • La puissance reçue par la charge s'écrit P = r × if². Reprends la même boucle qu'à l'étape précédente, mais calcule et stocke cette fois la puissance dans une liste lp.
  • Trace lp en fonction de rliste, en ronds rouges reliés par un trait bleu, avec une légende 'puissance'.
etape4_puissance.py
lp = []
for r in rliste :
    pfi = bisect(nul, 0, 2)
    pui = r * pfi**_
    lp.append(___)
print(lp)

plt.plot(rliste, lp, '__', label='________')
plt.plot(rliste, lp, '_')
plt.legend()
plt.show()
Résultat attendu

Une courbe en cloche : la puissance reçue par la charge augmente avec r, atteint un maximum pour la quatrième valeur testée (r ≈ 0,5 Ω, environ 0,5 W), puis redescend pour les résistances plus grandes.

＋

Analyse et optimisation

À retenir
  • La puissance fournie est maximale pour une résistance de charge r0 ≈ 0,5 Ω — une valeur qui coïncide, à la précision de la méthode près, avec la résistance de sortie Rs de la source trouvée à l'étape 1. Ce n'est pas une coïncidence.
  • La théorie confirme ce résultat numérique : l'expression littérale de la puissance reçue par la charge est Pr = r · (E0 / (Rs + r))². On peut montrer que cette fonction de r admet un maximum exactement pour r = Rs : c'est la condition d'adaptation d'impédance, un résultat général qui dépasse largement le seul exemple de cette source électrique.

Pense-bête — régression, fonctions et résolution numérique

np.polyfit(x,y,1)renvoie [pente, ordonnée à l'origine]
def f(x): return ...transforme un résultat de polyfit en fonction utilisable
bisect(f, a, b)trouve la racine de f entre a et b
P = r·i²puissance reçue par une résistance
r = Rscondition d'adaptation d'impédance
E0, Rsf.é.m. et résistance de sortie d'une source réelle

Pas de Thonny sous la main ? Utilise Basthon

Ouvrir dans un nouvel onglet ↗
Basthon est une console Python qui tourne directement dans le navigateur, sans rien installer. Colle ici (avec Ctrl+V ou Cmd+V) le code copié avec les boutons « Copier le code » ci-dessus, puis appuie sur Entrée pour l'exécuter.