Bases · 13 min de lecture

Calcul de puissance électrique : P = U × I, watt et kWh

Calcul de puissance électrique : formule P = U × I, watt et kWh, facture, échauffement d'une résistance et du 7805, choix d'adaptateur, LED et moteurs.

Le calcul de puissance électrique consiste à trouver quelle énergie un circuit ou un appareil consomme par seconde, et la formule de base est très simple : P = U × I, c'est-à-dire puissance (watt) égale tension (volt) multipliée par courant (ampère). Un circuit qui consomme 2 A sous 5 V dissipe 10 W ; un moteur qui consomme 0,5 A sous 12 V, 6 W. Cette seule formule répond à de nombreuses questions en électronique : choisir un adaptateur, savoir si une résistance va griller, estimer l'autonomie d'une pile ou calculer une facture d'électricité.

Si tu fais des projets avec Arduino, ESP32 ou Raspberry Pi Pico, savoir calculer la puissance t'évite trois gros soucis : des cartes qui redémarrent toutes seules à cause d'un adaptateur trop faible, des régulateurs assez chauds pour brûler les doigts et des résistances qui fument. Dans cet article, tu vas apprendre les formules, les unités (W, Wh, kWh, mAh), le calcul de consommation et de facture, l'échauffement des résistances et des régulateurs, le choix d'un adaptateur, et des exemples détaillés pour des rubans LED et des projets avec moteurs. Enfin, nous mesurerons vraiment la puissance avec un capteur INA219 sur Arduino et Pico.

Qu'est-ce que la puissance électrique et comment la calculer ?

La puissance indique la vitesse à laquelle l'énergie est utilisée ou convertie. Son unité est le watt (W) et 1 W correspond à 1 joule par seconde. Si tu compares la tension à la pression de l'eau dans un tuyau et le courant au débit, la puissance est le travail que l'eau fournit chaque seconde : plus la pression ou le débit augmente, plus le travail augmente. La formule de base est P = U × I ; en remplaçant dans la relation U = R × I de la loi d'Ohm, tu obtiens deux autres formes pratiques : P = R × I² et P = U² / R. Le choix dépend des deux valeurs que tu connais. Pour faire les calculs rapidement, tu peux aussi utiliser le calculateur de loi d'Ohm.

FormuleQuand l'utiliser ?Exemple
P = U × IQuand tu connais la tension et le courant5 V × 2 A = 10 W
P = R × I²Quand tu connais le courant et la résistance (échauffement d'une résistance)150 Ω × (0,02 A)² = 0,06 W
P = U² / RQuand tu connais la tension et la résistance (fils chauffants)(12 V)² / 100 Ω = 1,44 W
I = P / UPour trouver le courant consommé à partir de la puissance60 W / 12 V = 5 A
E = P × tÉnergie consommée pendant une durée donnée10 W × 3 h = 30 Wh

Watt, kWh et mAh : consommation d'énergie et calcul de facture

La confusion la plus fréquente est celle entre puissance et énergie. Le watt est une vitesse instantanée ; comme le compteur de vitesse d'une voiture, il répond à « combien en ce moment ». Le wattheure (Wh) et le kilowattheure (kWh) sont de l'énergie ; comme le compteur kilométrique, ils répondent à « combien au total ». Un appareil de 100 W qui fonctionne 10 heures consomme 1000 Wh, soit 1 kWh. La facture d'électricité est calculée sur les kWh consommés, pas sur la puissance. Les mAh (milliampère-heure) inscrits sur les piles indiquent une quantité de charge électrique ; pour la convertir en énergie, multiplie par la tension : Wh = mAh × V / 1000.

UnitéQue mesure-t-elle ?Équivalent / exemple
mW (milliwatt)Puissance1 W = 1000 mW ; une LED témoin consomme environ 40 mW
W (watt)Puissance5 V × 1 A = 5 W
kW (kilowatt)Puissance1 kW = 1000 W ; une bouilloire fait environ 2 kW
Wh (wattheure)Énergie10 W × 1 h = 10 Wh
kWh (kilowattheure)Énergie (l'unité de la facture)1000 W × 1 h = 1 kWh
mAh (milliampère-heure)Charge électrique (capacité d'une pile)2500 mAh × 3,7 V = 9,25 Wh
kW et kWh ne sont pas la même chose. Dire « cet appareil consomme 50 kW par mois » est faux ; il faut dire 50 kWh. De même, une pile Li-Ion de 2000 mAh et 3,7 V et une pile NiMH de 2000 mAh et 1,2 V ne stockent pas la même énergie : la première stocke 7,4 Wh, la seconde seulement 2,4 Wh. Pour comparer des piles, convertis toujours en Wh.

Pour trouver la consommation mensuelle d'un appareil, trois étapes suffisent : multiplie la puissance (W) par la durée de fonctionnement quotidienne (heures), multiplie par 30 jours, puis divise par 1000 pour obtenir des kWh. Pour le montant de la facture, multiplie ensuite les kWh par le prix unitaire. Par exemple, une ampoule LED de 9 W allumée 5 heures par jour consomme 9 × 5 × 30 = 1350 Wh = 1,35 kWh ; avec un prix de 0,25 €/kWh pris comme exemple, cela fait environ 0,34 € par mois. Le tableau ci-dessous montre à quel point l'impact d'un Arduino qui tourne 24 h/24 est minime, alors qu'un ruban LED ou une bouilloire change nettement la donne. N'oublie pas que l'adaptateur lui-même gaspille aussi quelques centaines de milliwatts à cause de son rendement.

AppareilPuissanceUtilisation quotidienneConsommation mensuelle
Arduino Uno (USB, au repos)≈ 0,25 W24 h≈ 0,18 kWh
ESP32 (Wi-Fi actif, moyenne)≈ 0,5 W24 h≈ 0,36 kWh
Ampoule LED 9 W9 W5 h1,35 kWh
Ruban LED 12 V de 5 m (5050, 60 LED/m)72 W5 h10,8 kWh
Bouilloire2000 W10 minutes10 kWh

Pourquoi une résistance chauffe-t-elle ? Choisir la bonne puissance en watts

Quand un courant traverse une résistance, la puissance dissipée se transforme entièrement en chaleur ; c'est l'effet Joule, et il se calcule avec P = R × I². Les résistances standard que tu utilises sur breadboard supportent généralement 1/4 W (0,25 W). Pour une conception sûre, une bonne règle est de choisir une résistance pouvant dissiper au moins le double de la puissance calculée, car plus elle approche sa limite, plus elle chauffe et plus sa valeur dérive. Exemple 1 : pour piloter une LED rouge (2 V, 20 mA) depuis 5 V, la résistance vaut (5 − 2) / 0,02 = 150 Ω ; la puissance dissipée est 3 V × 0,02 A = 0,06 W et 1/4 W suffit largement. Exemple 2 : si tu alimentes une seule LED blanche (3,2 V) depuis 12 V, 8,8 V tombent aux bornes de la résistance ; avec 470 Ω le courant est d'environ 18,7 mA et la puissance monte à 8,8 × 0,0187 ≈ 0,165 W. C'est les deux tiers de 1/4 W et la résistance chauffe nettement ; il vaut donc mieux choisir 1/2 W, ou mettre plusieurs LED en série pour réduire la tension aux bornes de la résistance. Tu peux trouver les valeurs en quelques secondes avec le calculateur de résistance pour LED.

Puissance de la résistanceAspect typiqueCharge continue maximale conseillée
1/8 W (0,125 W)Très petite, corps fin≈ 0,06 W
1/4 W (0,25 W)Résistance standard de la breadboard≈ 0,125 W
1/2 W (0,5 W)Corps un peu plus épais≈ 0,25 W
1 W – 2 WRésistance à film d'oxyde métallique, gros corps≈ 0,5 – 1 W
5 W – 10 WRésistance en céramique blanche (bloc)≈ 2,5 – 5 W

Échauffement d'un régulateur : calcul pour le 7805 et l'AMS1117

LM7805 : régulateur de tension linéaire 5 V
Régulateur linéaire LM7805 : la différence entre la tension d'entrée et de sortie, multipliée par le courant, se transforme directement en chaleur.

Les régulateurs linéaires comme le 7805, l'AMS1117 et celui de la carte Arduino dissipent l'excès de tension sous forme de chaleur. La puissance perdue se calcule avec P = (Uentrée − Usortie) × I et le rendement vaut environ Usortie / Uentrée. Si tu produis du 5 V à partir de 12 V et que tu tires 500 mA, le régulateur produit (12 − 5) × 0,5 = 3,5 W de chaleur. Sans dissipateur, la résistance thermique d'un boîtier TO-220 vers l'air ambiant est d'environ 50–65 °C/W ; 3,5 W ajoutent donc plus de 175 °C à la température ambiante et le régulateur se coupe pour se protéger. Tu dois soit utiliser un grand dissipateur, soit réduire la tension d'entrée. La solution la plus efficace est un convertisseur à découpage (buck) comme le LM2596 : avec un rendement de 85–90 %, il ne perd que 0,3–0,5 W pour le même travail. Pour plus de détails, consulte les articles Régulateur de tension 7805 et Convertisseur abaisseur LM2596.

RégulateurEntrée → SortieCourantPerte en chaleurRendement
LM78059 V → 5 V0,3 A1,2 W≈ 56 %
LM780512 V → 5 V0,5 A3,5 W≈ 42 %
AMS1117-3.35 V → 3,3 V0,3 A0,51 W≈ 66 %
LM2596 (buck)12 V → 5 V2 A≈ 1,4 W≈ 88 %
Alimenter l'Arduino Uno en 12 V par la prise jack DC et faire fonctionner un servo, un relais ou un ruban LED depuis la broche 5V fait vite surchauffer le petit régulateur de la carte : même une charge de 200 mA représente (12 − 5) × 0,2 = 1,4 W, ce qui est beaucoup trop pour ce petit boîtier CMS. Utilise 7–9 V sur la prise DC et alimente les charges à fort courant depuis une source 5 V séparée en reliant les GND. Tout le sujet est détaillé dans l'article Alimentation de l'Arduino.

Choisir un adaptateur : combien d'ampères, combien de watts ?

  1. Note la tension de fonctionnement de chaque composant du projet et son courant dans le pire des cas ; ces valeurs se trouvent dans les fiches techniques ou la description des modules.
  2. Additionne les courants des composants alimentés sous la même tension. Pour les moteurs et les servos, prends en compte non pas le courant normal mais le courant de démarrage et de blocage (stall) : un servo SG90 peut consommer jusqu'à 650 mA quand il force. Un condensateur de 470–1000 µF placé près des servos atténue les chutes de tension lors des pics de courant.
  3. Si un régulateur s'intercale, avec un régulateur linéaire le courant d'entrée est égal au courant de sortie ; avec un convertisseur buck, calcule à partir de la puissance : Ientrée ≈ (Usortie × Isortie) / (Uentrée × rendement).
  4. Ajoute une marge de 20–30 % au courant total ; quand ils fonctionnent en continu à la limite de leur valeur nominale, les adaptateurs chauffent et leur tension de sortie chute.
  5. Choisis la tension exactement égale à celle dont tu as besoin, et un courant égal ou supérieur à ta valeur calculée. Le courant indiqué sur l'adaptateur est un maximum ; ton circuit n'en tire que ce dont il a besoin, donc prendre du 5 V 3 A au lieu de 5 V 2 A ne pose aucun problème. En revanche, choisir une tension trop élevée peut griller le circuit.
Composant (5 V)QuantitéCourant typiqueTotal
Arduino Uno1≈ 50 mA50 mA
Servo SG90 (en mouvement)2≈ 250 mA500 mA
LED WS2812B (blanc complet)3060 mA1800 mA
Capteur de distance HC-SR041≈ 15 mA15 mA
LCD I2C 16x2 (rétroéclairage allumé)1≈ 30 mA30 mA
Total≈ 2,4 A (12 W) → avec 25 % de marge, adaptateur 5 V 3 A (15 W)

Exemple de calcul : rubans LED et projets WS2812B

Les rubans LED 5050 en 12 V comptent en général 60 LED par mètre et ont une puissance d'environ 14,4 W/m. Pour 3 mètres de ruban, il faut 14,4 × 3 = 43,2 W ; le courant est I = 43,2 / 12 = 3,6 A. Avec 25 % de marge, cela monte à 4,5 A, donc un adaptateur 12 V 5 A (60 W) convient. Si tu veux faire varier la luminosité du ruban en PWM avec un Arduino, il faut un MOSFET ; un MOSFET logic-level comme l'IRLZ44N a une résistance à l'état passant d'environ 0,022 Ω sous 5 V de grille, et la perte est P = R × I² = 0,022 × 3,6² ≈ 0,29 W, donc aucun dissipateur n'est nécessaire. Pour les LED adressables WS2812B, chaque LED consomme environ 60 mA en blanc complet : un ruban de 1 mètre avec 144 LED représente 144 × 0,06 = 8,64 A, soit 43 W sous 5 V. Un tel courant provoque une chute de tension dans le fin cuivre du ruban ; alimente les longs rubans en plusieurs points et limite la luminosité dans le code. Pour plus de détails, regarde les articles WS2812B NeoPixel, Contrôle d'un ruban LED RVB et Utiliser un MOSFET avec Arduino.

Exemple de calcul : projets avec moteurs et autonomie des piles

Les moteurs jaunes TT à réducteur consomment environ 150–250 mA à vide sous 6 V, mais le courant peut dépasser 1 A quand la roue se bloque. Une voiture robot à quatre moteurs consomme au total environ 1 A en conduite normale. Un L298N alimenté par deux piles 18650 (7,4 V) chute d'environ 2 V à cause de ses transistors bipolaires ; les moteurs ne voient donc qu'environ 5,4 V et le L298N dissipe 2 V × 1 A = 2 W en chaleur. Près d'un quart des 7,4 W tirés des piles se perd dans le pilote ; les pilotes à MOSFET comme le TB6612FNG réduisent largement cette perte. Tu peux estimer grossièrement l'autonomie avec capacité (mAh) / courant moyen (mA) × 0,8 : avec un pack de 2500 mAh et un courant moyen de 1,2 A, Arduino compris, tu obtiens 2500 / 1200 × 0,8 ≈ 1,7 heure de conduite. Le calculateur d'autonomie de pile fait ce calcul pour toi ; pour aller plus loin, regarde les articles Commande d'un moteur DC avec le L298N, Comparatif des pilotes de moteur et Capacité d'une pile en mAh.

Mesurer la puissance avec Arduino : le capteur INA219

Faire des calculs, c'est bien, mais pour voir la consommation réelle il faut mesurer. Tu peux mesurer le courant avec un multimètre, mais pour suivre des charges variables et l'énergie accumulée dans le temps, le module INA219 est bien plus pratique. Ce module mesure la petite chute de tension aux bornes d'une résistance shunt de 0,1 Ω placée en série avec la charge et lit en même temps la tension de la charge ; via I2C, tu peux mesurer jusqu'à 26 V et, avec les réglages par défaut, jusqu'à environ 3,2 A. Le code fait exactement les calculs de cet article : P = U × I pour la puissance instantanée et E = P × t pour l'énergie totale. Il suffit d'installer la bibliothèque Adafruit INA219 depuis le Gestionnaire de bibliothèques. Pour la logique de mesure et l'étalonnage, consulte l'article Capteur de courant INA219.

Broche INA219Arduino UnoESP32Raspberry Pi Pico
VCC5V3V33V3 (broche 36)
GNDGNDGNDGND
SCLA5GPIO 22GP5
SDAA4GPIO 21GP4
VIN+Borne positive de l'alimentationBorne positive de l'alimentationBorne positive de l'alimentation
VIN−Borne positive de la chargeBorne positive de la chargeBorne positive de la charge
C++ (Arduino IDE)
1#include <Wire.h>
2#include <Adafruit_INA219.h>
3
4Adafruit_INA219 ina219;          // varsayılan I2C adresi 0x40 / default I2C address 0x40
5
6float energy_mWh = 0.0;          // biriken enerji / accumulated energy
7unsigned long lastMs = 0;
8
9void setup() {
10  Serial.begin(115200);
11  if (!ina219.begin()) {
12    Serial.println(F("INA219 bulunamadi / INA219 not found"));
13    while (1) { delay(10); }
14  }
15  lastMs = millis();
16}
17
18void loop() {
19  float busV = ina219.getBusVoltage_V();        // yük gerilimi (V) / load voltage (V)
20  float current_mA = ina219.getCurrent_mA();    // akım (mA) / current (mA)
21  float power_mW = busV * current_mA;           // güç: P = V x I / power: P = V x I
22
23  unsigned long now = millis();
24  float dtHours = (now - lastMs) / 3600000.0;   // ms -> saat / ms -> hours
25  lastMs = now;
26  energy_mWh += power_mW * dtHours;             // enerji: E = P x t / energy: E = P x t
27
28  Serial.print(F("V: "));
29  Serial.print(busV, 2);
30  Serial.print(F(" V  I: "));
31  Serial.print(current_mA, 1);
32  Serial.print(F(" mA  P: "));
33  Serial.print(power_mW, 0);
34  Serial.print(F(" mW  E: "));
35  Serial.print(energy_mWh, 2);
36  Serial.println(F(" mWh"));
37
38  delay(1000);
39}

Le code lit chaque seconde la tension et le courant de la charge, puis les multiplie pour obtenir la puissance en milliwatts. Ensuite, il convertit en heures le temps écoulé entre deux mesures avec millis(), le multiplie par la puissance et l'ajoute à l'énergie totale ; tu vois ainsi dans le moniteur série combien de mWh ton appareil a consommé jusqu'ici. La fonction getPower_mW() de la bibliothèque donne le même résultat ; ici, nous avons fait la multiplication nous-mêmes pour montrer la formule. Détail important : la borne négative de l'alimentation que tu mesures doit être reliée au GND de l'Arduino, sinon la lecture de tension n'a aucun sens. Le shunt se branche toujours en série avec la charge ; relier VIN+ et VIN− directement aux deux pôles d'une pile provoque un court-circuit.

Mesurer la puissance avec ESP32 et Raspberry Pi Pico

Le code Arduino ci-dessus fonctionne sans aucune modification sur l'ESP32 ; la bibliothèque Wire utilise par défaut les broches GPIO 21 (SDA) et GPIO 22 (SCL). L'ESP32 est une carte intéressante pour ce type de mesure, car sa consommation varie beaucoup selon la situation : lors d'un envoi de données en Wi-Fi, le courant instantané peut dépasser 240 mA, la moyenne tourne autour de 80–120 mA, et en deep sleep la puce ne consomme qu'environ 10 µA. Les pics de courant soudains font chuter la tension sur un mauvais câble USB ou un adaptateur faible et provoquent des redémarrages brownout ; avec l'INA219, tu peux voir ces pics et mesurer de combien de fois le deep sleep prolonge l'autonomie. Sur le Raspberry Pi Pico, un court code MicroPython qui lit directement les registres de l'INA219 suffit, sans installer de bibliothèque :

MicroPython
1from machine import Pin, I2C
2import time
3
4i2c = I2C(0, sda=Pin(4), scl=Pin(5), freq=400000)
5ADDR = 0x40              # INA219 varsayılan adresi / INA219 default address
6R_SHUNT = 0.1            # modüldeki şönt direnci (ohm) / shunt resistor on the module (ohm)
7
8def read_reg(reg):
9    data = i2c.readfrom_mem(ADDR, reg, 2)   # 2 bayt oku / read 2 bytes
10    return (data[0] << 8) | data[1]
11
12energy_wh = 0.0                              # biriken enerji / accumulated energy
13last = time.ticks_ms()
14
15while True:
16    raw = read_reg(0x01)                     # şönt gerilimi yazmacı / shunt voltage register
17    if raw > 32767:                          # işaretli sayıya çevir / convert to signed
18        raw -= 65536
19    shunt_v = raw * 0.00001                  # 1 birim = 10 uV / 1 LSB = 10 uV
20    bus_v = (read_reg(0x02) >> 3) * 0.004    # 1 birim = 4 mV / 1 LSB = 4 mV
21    current_a = shunt_v / R_SHUNT            # Ohm kanunu: I = V / R / Ohm's law: I = V / R
22    power_w = bus_v * current_a              # güç: P = V x I / power: P = V x I
23
24    now = time.ticks_ms()
25    dt_h = time.ticks_diff(now, last) / 3600000   # ms -> saat / ms -> hours
26    last = now
27    energy_wh += power_w * dt_h              # enerji: E = P x t / energy: E = P x t
28
29    print("V: {:.2f} V  I: {:.1f} mA  P: {:.0f} mW  E: {:.4f} Wh".format(
30        bus_v, current_a * 1000, power_w * 1000, energy_wh))
31    time.sleep(1)

Idées de projets autour du calcul de puissance

  • Wattmètre USB : avec un INA219 et un écran OLED, affiche la puissance instantanée et le total en Wh d'un chargeur de téléphone ou de ton projet Arduino.
  • Testeur de piles : décharge une pile à travers une charge résistive et mesure sa capacité en mAh et en Wh ; utilise les résultats pour comparer des piles 18650.
  • Compteur de prise intelligente : suis la consommation en kWh d'un appareil branché avec un ESP32 et calcule le coût mensuel ; pour le côté 220 V, utilise des modules isolés et sûrs, et regarde l'article Prise intelligente ESP32.
  • Afficheur de puissance de bureau : ajoute un capteur de courant à un voltmètre Arduino pour fabriquer un appareil qui affiche tension, courant et puissance en même temps.
  • Suivi de panneau solaire : mesure la puissance qui va du panneau à la batterie et enregistre les Wh produits pendant la journée.
  • Expérience d'autonomie : fais tourner le même code ESP32 avec et sans deep sleep, mesure le courant moyen et compare l'autonomie.

Erreurs fréquentes et solutions

ErreurSymptômeSolution
Choisir un adaptateur avec un courant insuffisantLa carte redémarre au hasard, les LED scintillent, le servo trembleCalcule le courant total et ajoute 20–30 % de marge
Croire qu'un adaptateur à tension plus élevée est « plus puissant »Le régulateur surchauffe, des composants brûlentChoisis la tension exacte et un courant suffisant
Ne pas calculer la puissance d'une résistanceLa résistance noircit, odeur de brûlé, sa valeur dériveCalcule avec P = R × I² et choisis une résistance de puissance double
Faire chuter une forte tension avec un régulateur linéaireLe 7805 chauffe beaucoup et se coupe par protection thermiqueRéduis la tension d'entrée, utilise un dissipateur ou un convertisseur buck
Prendre les mAh pour de l'énergieDes piles de tensions différentes sont mal comparéesConvertis avec Wh = mAh × V / 1000
Brancher l'ampèremètre en parallèleLe fusible du multimètre saute, la source est court-circuitéePour mesurer un courant, branche toujours l'appareil en série avec la charge
Le moyen le plus rapide d'estimer l'échauffement d'un circuit est de calculer, pour chaque composant, « tension à ses bornes × courant qui le traverse ». En dessous de 0,1 W, il n'y a généralement pas de problème ; les petits composants chauffent de façon perceptible au toucher vers 0,5 W, et à partir de 1 W tu dois absolument penser au refroidissement. Pour mesurer les valeurs réelles, tu peux consulter l'article Comment utiliser un multimètre ?.

Quand tu maîtrises la formule P = U × I et ses deux formes dérivées, acheter un adaptateur, choisir une résistance, estimer l'autonomie d'une pile et calculer une facture reposent sur des calculs et non sur des suppositions. Si tu prends l'habitude de dresser un petit tableau de puissance dans chaque nouveau projet, les composants grillés et les redémarrages inexplicables disparaissent en grande partie. Dans l'application BlueGrays, tu peux étudier pas à pas, avec schémas et codes, des projets de LED, de rubans LED, de moteurs et de voltmètre numérique, et tester sur de vrais circuits les calculs appris ici.

Questions fréquentes

Comment calculer les watts ?

Les watts sont le produit de la tension par le courant : P = U × I. Par exemple, un appareil qui consomme 2 A sous 12 V dissipe 24 W. Si tu ne connais que le courant et la résistance, utilise P = R × I² ; si tu connais la tension et la résistance, utilise P = U² / R.

1 kWh correspond à combien de watts ?

Le kWh n'est pas une puissance mais une unité d'énergie, il n'est donc pas égal directement à une valeur en watts. 1 kWh est l'énergie consommée par un appareil de 1000 W pendant 1 heure. Une lampe de 100 W consomme 1 kWh en 10 heures, un appareil de 10 W en 100 heures.

Comment calculer la consommation électrique mensuelle d'un appareil ?

Multiplie la puissance de l'appareil (W) par ses heures de fonctionnement quotidiennes et par 30 jours, puis divise par 1000 pour obtenir des kWh. Par exemple, un ruban LED de 72 W allumé 5 heures par jour consomme 72 × 5 × 30 / 1000 = 10,8 kWh. Multiplie cette valeur par le prix du kWh pour obtenir le coût mensuel.

Un adaptateur avec plus d'ampères peut-il abîmer l'appareil ?

Non, tant que la tension est correcte. Le courant indiqué sur l'adaptateur est le maximum qu'il peut fournir ; le circuit ne tire que ce dont il a besoin. Le vrai danger est de choisir une tension trop élevée ou un adaptateur dont le courant est inférieur au besoin.

Comment convertir des ampères en watts ?

Tu convertis les ampères en watts en les multipliant par la tension : W = A × V. Un adaptateur USB qui fournit 3 A sous 5 V donne 15 W, et un appareil résistif qui consomme 2 A sur le secteur 220 V dissipe environ 440 W. En courant alternatif, le facteur de puissance entre aussi en compte pour les appareils à moteur, et il est impossible de passer des ampères aux watts sans connaître la tension.

Quelle puissance en watts doit avoir une résistance ?

Calcule d'abord la puissance dissipée par la résistance avec P = R × I² ou P = U × I, puis choisis une résistance d'au moins le double de cette valeur. Quand tu pilotes une LED avec Arduino, la puissance dissipée est généralement inférieure à 0,1 W, donc une résistance standard de 1/4 W suffit. Dans les circuits de 12 V et plus, des résistances de 1/2 W ou plus peuvent être nécessaires.

Voir tous les projets
Clignotement d'une LED
AR-1Débutant

Clignotement d'une LED

Le tout premier bonjour de l'électronique : allumer et éteindre une seule LED. L'Arduino allume et éteint la LED à intervalles très courts, la lumière clignote donc rapidement.

4.6(198)
1242
Allumage d'une LED externe sur le Raspberry Pi Pico (plaque d'essai)
PI-2Débutant

Allumage d'une LED externe sur le Raspberry Pi Pico (plaque d'essai)

L'étape suivante après la LED intégrée du Pico : brancher une LED externe sur une plaque d'essai et la piloter par la broche GP14. Tu apprends à utiliser n'importe quelle broche GPIO du Pico en sortie, la polarité de la LED (patte longue = anode/+, patte courte = cathode/–) et pourquoi une résistance de limitation (220Ω) est indispensable. Sans elle, trop de courant traverse la LED, qui peut griller.

4.5(2)
7
Voltmètre numérique avec écran LCD
AR-56Intermédiaire
Premium

Voltmètre numérique avec écran LCD

Découvre quelle tension fournit une pile ou un adaptateur avec un appareil de mesure fait maison.

4.5(27)
36
Ampoule 220V avec bouton poussoir (Push)
AR-19Avancé
Premium

Ampoule 220V avec bouton poussoir (Push)

Tant que tu appuies sur le bouton, une vraie ampoule de 220 volts reste allumée, et elle s'éteint dès que tu relâches.

4.4(30)
38
Utilisation du ruban LED WS2812B
AR-69Intermédiaire
Premium

Utilisation du ruban LED WS2812B

Tu découvres un ruban LED intelligent dont chaque lumière peut prendre sa propre couleur.

4.8(54)
70
Contrôle d'une bande NeoPixel WS2812B avec l'ESP32
ES-24Intermédiaire
Premium

Contrôle d'une bande NeoPixel WS2812B avec l'ESP32

Les LED adressables WS2812B (NeoPixel) sont des LED RGB intelligentes chaînées et pilotées par une seule broche de données. On pilote un ruban WS2812B de 8 LED avec la bibliothèque Adafruit_NeoPixel pour créer un arc-en-ciel fluide. La logique 3,3 V de l'ESP32 convient à la plupart des WS2812B ; en cas d'instabilité, on montre la solution : résistance série de 470Ω et condensateur de 1000µF. L'animation fait glisser la teinte dans l'espace HSV.

4.9(19)
30
Voiture contrôlée par Bluetooth avec L298N
AR-80Avancé
Premium

Voiture contrôlée par Bluetooth avec L298N

Transforme ton téléphone en télécommande et pilote ta propre voiture robot. L'Arduino reçoit, via un module Bluetooth, les ordres d'une appli de télécommande sur ton téléphone et fait tourner les…

5.0(39)
66
Mode veille profonde de l'ESP32 — Économie de batterie (OLED + compteur RAM RTC)
ES-33Avancé
Premium

Mode veille profonde de l'ESP32 — Économie de batterie (OLED + compteur RAM RTC)

Le mode Deep Sleep de l'ESP32 coupe le CPU et la plupart des périphériques et réduit la consommation à environ 10µA, un point clé pour les objets IoT sur batterie. Ce projet utilise trois sources de réveil : un minuteur (15 s), une broche externe (EXT0, le bouton sur GPIO 33) et une broche tactile (T0/GPIO 4). Les compteurs marqués RTC_DATA_ATTR sont conservés pendant le deep sleep.

4.3(10)
16