Bases
d’électronique.

• Calculer la résistance à mettre devant une LED, et pourquoi.
• Lire un schéma simple et le monter sur une breadboard.
• Comprendre ce qu’une broche d’Arduino peut et ne peut pas alimenter.
• Mesurer tension, courant et résistance avec un multimètre.

Matériel : breadboard, LED, résistances (220 Ω, 1 kΩ, 10 kΩ), bouton, potentiomètre, photorésistance, multimètre, une pile ou une alimentation 5 V.

Une tension est toujours une différence entre deux points. On choisit un point de référence, la masse (GND, 0 V), et toutes les tensions sont mesurées par rapport à lui. Tous les composants d’un circuit doivent partager la même masse : deux cartes qui communiquent sans masse commune, c’est le bug n°1 des débutants.

U = RI, P = UI, et leurs combinaisons P = U²/R = RI². Avec elles, on dimensionne 90 % d’un circuit de robot. Le court-circuit : résistance quasi nulle → courant énorme → chaleur → fumée. Une batterie LiPo court-circuitée peut prendre feu : d’où les fusibles et la vérification au multimètre avant de mettre sous tension.

Les résistances du commerce suivent la série E12 : 12 valeurs par décade. On prend la valeur normalisée juste au-dessus du calcul : un peu moins de courant, jamais plus. Une LED tolère 20 mA en continu ; 15 mA est déjà très lumineux. Une broche d’Arduino fournit au plus 20 mA (40 mA absolu) : une LED avec 220 Ω, oui ; deux en parallèle sur la même broche, c’est limite ; un moteur, jamais.

Nœuds : le courant qui entre dans un point ressort intégralement (rien ne s’accumule). Mailles : en faisant le tour d’une boucle, les tensions s’additionnent à zéro (on revient à la même « hauteur »). Toute l’analyse de circuit en prépa découle de ces deux lois, et elles suffisent ici pour comprendre série (même courant) et parallèle (même tension).

Pour une sensibilité maximale, on prend R_bas proche de la résistance du capteur dans la zone qui nous intéresse. Un potentiomètre est un pont diviseur réglable : ses deux extrémités sur 5 V et GND, son curseur donne de 0 à 5 V. Attention : un diviseur consomme en permanence (5 V / 20 kΩ = 0,25 mA) et ne fournit presque pas de courant : il sert à mesurer, pas à alimenter.

Un bouton mécanique ne fait pas un contact franc : pendant 1 à 10 ms, il « rebondit » et la broche voit 0101010 avant de se stabiliser. Un compteur naïf compte alors 5 appuis pour un. On anti-rebond (debounce) par logiciel (ignorer les changements pendant 20 ms après un changement) ou par matériel (condensateur). Séance 22.

Entrée numérique : 0 ou 1. Sortie numérique : 0 V ou 5 V. Entrée analogique (ADC) : une tension → un entier de 0 à 1023. Sortie « analogique » : en réalité une PWM (séance 23). Une tension supérieure à la référence (5 V, ou 3,3 V !) ne donne pas une valeur plus grande : elle détruit la broche. C’est la première chose à vérifier avant de brancher un capteur sur un ESP32.

Un transistor laisse passer un courant important (collecteur → émetteur) quand un petit courant arrive sur sa base. La broche fournit 4 mA, le moteur en tire 1 A depuis son alimentation. La diode de roue libre est obligatoire avec tout moteur ou bobine : à la coupure, la bobine génère une pointe de tension inverse qui détruirait le transistor. Un MOSFET fait la même chose sans courant de base ; un pont en H permet d’inverser le sens.

1. Dessiner le schéma. 2. Alimentation débranchée. 3. Placer les composants en suivant le schéma, fils courts, couleurs (rouge +, noir GND). 4. Vérifier à l’œil puis au multimètre (continuité entre + et GND = court-circuit !). 5. Brancher. 6. Mesurer les tensions attendues. Une LED à l’envers ne s’allume pas et ne casse rien ; une alimentation à l’envers sur une carte la détruit.

def verifier_led(U_alim, U_led, R):
    if U_alim <= U_led:
        return "ne s'allume pas (tension insuffisante)"
    I = (U_alim - U_led) / R * 1000
    if I > 20: return f"DANGER : {I:.0f} mA"
    if I < 5:  return f"trop faible : {I:.1f} mA"
    return f"OK : {I:.1f} mA"

La LED blanche sur 3,3 V avec 100 Ω ne reçoit que 1 mA : à peine visible. Sur une carte 3,3 V, les LED bleues et blanches sont un problème ; on préfère rouge ou verte, ou un transistor vers 5 V.

U_bat, capacite = 7.2, 2.0                 # V, Ah
rendement = 0.85
I_logique = sum(c["I_moy"] for n, c in composants.items() if c["U"] == 5)
P_logique = 5 * I_logique
I_bat_logique = P_logique / rendement / U_bat        # ce que la batterie fournit pour la partie 5 V
I_moteurs = composants["moteurs"]["I_moy"]           # supposés directement sur la batterie
I_total = I_bat_logique + I_moteurs
I_pointe = sum(c["I_max"] for c in composants.values())
print(f"Courant moyen batterie : {I_total:.2f} A, pointe : {I_pointe:.2f} A")
print(f"Autonomie moteurs 100 % : {capacite / I_total:.2f} h")
print(f"Autonomie moteurs 60 % : {capacite / (I_bat_logique + 0.6 * I_moteurs):.2f} h")
print(f"Régulateur : dissipe {(U_bat - 5) * I_logique / rendement:.2f} W (chauffe !)")

≈ 1,9 A moyen, 4,7 A en pointe : les piles AA tiennent, à condition que les fils et le connecteur supportent la pointe. Un régulateur linéaire dissiperait (7,2 − 5) × I en chaleur ; un régulateur à découpage (85 %) est bien meilleur. Le démarrage des moteurs peut faire chuter la tension et redémarrer l’Arduino : c’est le bug classique du robot qui « reboote quand il accélère ». Solution : condensateur de découplage, ou alimentation logique séparée.

def charge(R, C, U0=5.0, dt=None, duree=None):
    tau = R * C
    dt = dt or tau / 200; duree = duree or 6 * tau
    t, U = 0.0, 0.0; ts, Us = [0.0], [0.0]
    while t < duree:
        U += (U0 - U) / tau * dt; t += dt
        ts.append(t); Us.append(U)
    return ts, Us

R, C = 10_000, 100e-6
ts, Us = charge(R, C)
tau = R * C
print(f"τ = {tau} s ; 63 % à t ≈ {next(t for t, u in zip(ts, Us) if u >= 0.63 * 5):.2f} s ; 99 % à ≈ {next(t for t, u in zip(ts, Us) if u >= 0.99 * 5):.2f} s (théorie : τ et 4.6 τ)")
ts2, Us2 = charge(10_000, 100e-9)
print(f"Anti-rebond : 2.5 V atteint en {1000 * next(t for t, u in zip(ts2, Us2) if u >= 2.5):.2f} ms (théorie : RC·ln2 = {1000 * 10_000 * 100e-9 * math.log(2):.2f} ms)")

plt.plot(ts, Us, label="charge (Euler)")
plt.plot(ts, [5 * (1 - math.exp(-t / tau)) for t in ts], "--", label="formule")
plt.plot(ts, [5 * math.exp(-t / tau) for t in ts], label="décharge")
plt.xlabel("t (s)"); plt.ylabel("U (V)"); plt.legend(); plt.grid(alpha=.3); plt.show()

τ = 1 s : 63 % en 1 s, 99 % en 4,6 s. L’anti-rebond RC = 1 ms retarde le front de 0,7 ms : trop court pour des rebonds de 5 ms — il faudrait C = 1 µF (τ = 10 ms). Le condensateur est le composant « mémoire de tension » : découplage d’alimentation (il fournit la pointe de courant que la batterie ne peut pas donner assez vite), filtrage, temporisation. L’équation dU/dt = (U₀ − U)/τ est votre première équation différentielle linéaire ; sa solution exponentielle est le pain quotidien de la prépa, et vous venez de la vérifier numériquement.