Basis · 12 min leestijd

Elektrisch vermogen berekenen: P = V × I, watt, kWh en voorbeelden

Elektrisch vermogen berekenen: de formule P = V × I, watt versus kWh, energiekosten, opwarming van weerstanden en regelaars, een adapter kiezen, plus voorbeelden met ledstrips en motoren.

Elektrisch vermogen berekenen betekent uitzoeken hoeveel energie een schakeling of apparaat per seconde verbruikt. De basisformule is heel eenvoudig: P = V × I, dus vermogen (watt) is spanning (volt) maal stroom (ampère). Een schakeling die 2 A trekt bij 5 V verbruikt 10 W; een motor die 0,5 A trekt bij 12 V verbruikt 6 W. Met deze ene formule beantwoord je veel elektronicavragen: welke adapter je moet kopen, of een weerstand doorbrandt, hoeveel uur een batterij meegaat en zelfs hoe hoog je energierekening wordt.

Bouw je projecten met Arduino, ESP32 of Raspberry Pi Pico, dan bespaart vermogen berekenen je drie grote ergernissen: boards die uit zichzelf resetten door een te zwakke adapter, regelaars die zo heet worden dat je je vinger brandt, en rokende weerstanden. In dit artikel leer je de formules, de eenheden (W, Wh, kWh, mAh), energieverbruik en kostenberekening, opwarming van weerstanden en regelaars, het kiezen van een adapter en stap voor stap uitgewerkte voorbeelden voor ledstrips en motorprojecten. Tot slot meten we het vermogen echt met een INA219-sensor op Arduino en Pico.

Wat is elektrisch vermogen en hoe bereken je het?

Vermogen laat zien hoe snel energie wordt gebruikt of omgezet. De eenheid is de watt (W); 1 W betekent 1 joule energie per seconde. Stel je spanning voor als de druk van het water in een buis en stroom als de hoeveelheid water die erdoor stroomt: vermogen is dan het werk dat dat water per seconde verricht. Neemt de druk of de stroom toe, dan neemt ook het werk toe. De basisformule is P = V × I; vul je V = I × R uit de wet van Ohm in, dan krijg je nog twee handige vormen: P = I² × R en P = V² / R. Welke je gebruikt, hangt af van de twee waarden die je kent. Je kunt de berekeningen ook snel doen met de rekenmachine voor de wet van Ohm.

FormuleWanneer gebruik je hemVoorbeeld
P = V × IAls je spanning en stroom kent5 V × 2 A = 10 W
P = I² × RAls je stroom en weerstand kent (opwarming van weerstanden)(0,02 A)² × 150 Ω = 0,06 W
P = V² / RAls je spanning en weerstand kent (verwarmingselementen)(12 V)² / 100 Ω = 1,44 W
I = P / VOm de stroom te vinden die een apparaat uit zijn vermogen trekt60 W / 12 V = 5 A
E = P × tEnergie die over een bepaalde tijd wordt verbruikt10 W × 3 uur = 30 Wh

Watt, kWh en mAh: energieverbruik en kostenberekening

Het meest verwarrende onderwerp is het verschil tussen vermogen en energie. Watt is een momentane snelheid; net als de snelheidsmeter in een auto beantwoordt het de vraag "hoeveel nu". Wattuur (Wh) en kilowattuur (kWh) zijn energie; net als de kilometerteller beantwoorden ze de vraag "hoeveel in totaal". Een apparaat van 100 W dat 10 uur draait, verbruikt 1.000 Wh, oftewel 1 kWh. Je energierekening is gebaseerd op verbruikte kWh, niet op vermogen. De mAh (milliampère-uur) op batterijen geeft de hoeveelheid elektrische lading aan; om die om te rekenen naar energie vermenigvuldig je met de spanning: Wh = mAh × V / 1000.

EenheidWat het meetEquivalent / voorbeeld
mW (milliwatt)Vermogen1 W = 1.000 mW; een indicatieled is ongeveer 40 mW
W (watt)Vermogen5 V × 1 A = 5 W
kW (kilowatt)Vermogen1 kW = 1.000 W; een waterkoker is ongeveer 2 kW
Wh (wattuur)Energie10 W × 1 uur = 10 Wh
kWh (kilowattuur)Energie (de eenheid op je rekening)1.000 W × 1 uur = 1 kWh
mAh (milliampère-uur)Elektrische lading (batterijcapaciteit)2.500 mAh × 3,7 V = 9,25 Wh
kW en kWh zijn niet hetzelfde. Zeggen dat "dit apparaat 50 kW per maand verbruikt" is fout; het juiste getal is 50 kWh. Ook bevatten een Li-Ion-accu van 2.000 mAh en 3,7 V en een NiMH-accu van 2.000 mAh en 1,2 V niet evenveel energie: de eerste slaat 7,4 Wh op, de tweede maar 2,4 Wh. Reken batterijen daarom altijd om naar Wh als je ze vergelijkt.

Drie stappen zijn genoeg om het maandverbruik van een apparaat te vinden: vermenigvuldig het vermogen (W) met de dagelijkse looptijd (uren), vermenigvuldig het resultaat met 30 dagen en deel door 1.000 om kWh te krijgen. Voor de kosten op je rekening vermenigvuldig je de kWh met de prijs per eenheid. Een ledlamp van 9 W die 5 uur per dag brandt, verbruikt bijvoorbeeld 9 × 5 × 30 = 1.350 Wh = 1,35 kWh; met een voorbeeldprijs van € 0,30/kWh zijn de maandelijkse kosten ongeveer € 0,40. De tabel hieronder laat duidelijk zien hoe klein de invloed van een Arduino die 24/7 draait op je rekening is, terwijl een ledstrip of waterkoker een groot verschil maakt. Bedenk dat de adapter zelf door rendementsverlies ook nog een paar honderd extra milliwatt verspilt.

ApparaatVermogenDagelijks gebruikMaandverbruik
Arduino Uno (USB, stand-by)≈ 0,25 W24 uur≈ 0,18 kWh
ESP32 (Wi-Fi aan, gemiddeld)≈ 0,5 W24 uur≈ 0,36 kWh
Ledlamp van 9 W9 W5 uur1,35 kWh
5 m 12V-ledstrip (5050, 60 leds/m)72 W5 uur10,8 kWh
Waterkoker2000 W10 minuten10 kWh

Waarom worden weerstanden heet? Het juiste vermogen kiezen

Als er stroom door een weerstand loopt, wordt het afgevoerde vermogen volledig omgezet in warmte; dit heet joule-opwarming en wordt berekend met P = I² × R. De standaardweerstanden die je op breadboards gebruikt, kunnen meestal 1/4 W (0,25 W) aan. Voor een veilig ontwerp is het een goede vuistregel een weerstand te kiezen die minstens twee keer het berekende vermogen aankan, want als een weerstand zijn limiet nadert, wordt hij erg heet en loopt zijn waarde weg. Voorbeeld 1: om een rode led (2 V, 20 mA) vanaf 5 V aan te sturen is de weerstand (5 − 2) / 0,02 = 150 Ω; het vermogen in de weerstand is 3 V × 0,02 A = 0,06 W en 1/4 W is ruim voldoende. Voorbeeld 2: stuur je één witte led (3,2 V) aan vanaf 12 V, dan valt er 8,8 V over de weerstand; met 470 Ω is de stroom ongeveer 18,7 mA en stijgt het vermogen naar 8,8 × 0,0187 ≈ 0,165 W. Dat is twee derde van 1/4 W en de weerstand wordt merkbaar warm, dus het is slimmer 1/2 W te kiezen of meerdere leds in serie te zetten om de spanning over de weerstand te verlagen. Je vindt de waarden in enkele seconden met de rekenmachine voor ledweerstanden.

Vermogen van de weerstandTypisch uiterlijkAanbevolen max. continue belasting
1/8 W (0,125 W)Heel klein, dun lichaam≈ 0,06 W
1/4 W (0,25 W)Standaard breadboardweerstand≈ 0,125 W
1/2 W (0,5 W)Iets dikker lichaam≈ 0,25 W
1 W – 2 WGrote metaaloxideweerstand≈ 0,5 – 1 W
5 W – 10 WWitte keramische (cement)weerstand≈ 2,5 – 5 W

Opwarming van regelaars: berekening voor 7805 en AMS1117

LM7805 5 V lineaire spanningsregelaar
LM7805 lineaire regelaar: het spanningsverschil tussen ingang en uitgang, vermenigvuldigd met de stroom, wordt rechtstreeks warmte.

Lineaire regelaars zoals de 7805, de AMS1117 en de regelaar op een Arduino-board branden overtollige spanning af als warmte. Het vermogensverlies vind je met P = (Vin − Vout) × I en het rendement is ruwweg Vout / Vin. Maak je 5 V uit 12 V en trek je 500 mA, dan produceert de regelaar (12 − 5) × 0,5 = 3,5 W aan warmte. De thermische weerstand van een TO-220-behuizing zonder koelplaat is ongeveer 50–65 °C/W; 3,5 W geeft dus meer dan 175 °C boven de omgevingstemperatuur en de regelaar schakelt zichzelf uit ter bescherming. Je moet dan een grote koelplaat gebruiken of de ingangsspanning verlagen. De efficiëntste oplossing is een schakelende (buck-)converter zoals de LM2596: bij 85–90% rendement verspilt die voor dezelfde taak maar 0,3–0,5 W. Voor details zie de artikelen 7805-spanningsregelaar en LM2596 buck-converter.

RegelaarIngang → uitgangStroomWarmteverliesRendement
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%
Voed je een Arduino Uno met 12 V via de DC-jack en stuur je een servo, relais of ledstrip aan vanaf de 5V-pin, dan raakt de kleine regelaar op het board snel oververhit: zelfs een belasting van 200 mA betekent (12 − 5) × 0,2 = 1,4 W, veel te veel voor deze kleine SMD-behuizing. Gebruik 7–9 V op de DC-jack en voed belastingen met hoge stroom vanuit een aparte 5V-voeding, met de massa's met elkaar verbonden. Het hele onderwerp komt aan bod in Arduino voeden.

Een adapter kiezen: hoeveel ampère en watt heb je nodig?

  1. Noteer de werkspanning en de stroom in het slechtste geval van elk onderdeel in het project; deze waarden staan in datasheets of modulebeschrijvingen.
  2. Tel de stromen op van onderdelen die op dezelfde spanning draaien. Neem bij motoren en servo's de aanloop- en blokkeerstroom, niet de normale stroom: een SG90-servo kan tot 650 mA trekken als hij wordt belast. Een condensator van 470–1.000 µF vlak bij de servo's vermindert spanningsdips bij plotselinge stroompieken.
  3. Zit er een regelaar tussen: bij een lineaire regelaar is de ingangsstroom gelijk aan de uitgangsstroom; bij een buck-converter reken je vanuit het vermogen: Iin ≈ (Vout × Iout) / (Vin × rendement).
  4. Tel een marge van 20–30% op bij de totale stroom; adapters worden warm en hun uitgangsspanning zakt weg als ze continu op hun nominale limiet werken.
  5. Kies precies de vereiste spanning en een stroom die gelijk is aan of groter dan je berekende waarde. De stroomwaarde van een adapter is een bovengrens; je schakeling trekt alleen wat hij nodig heeft, dus 5 V 3 A kopen in plaats van 5 V 2 A doet geen kwaad. Een hogere spanning kiezen kan de schakeling echter doen doorbranden.
Onderdeel (5 V)AantalTypische stroomTotaal
Arduino Uno1≈ 50 mA50 mA
SG90-servo (in beweging)2≈ 250 mA500 mA
WS2812B-led (volledig wit)3060 mA1800 mA
HC-SR04-afstandssensor1≈ 15 mA15 mA
I2C 16x2-LCD (achtergrondverlichting aan)1≈ 30 mA30 mA
Totaal≈ 2,4 A (12 W) → met 25% marge een adapter van 5 V 3 A (15 W)

Rekenvoorbeeld: ledstrips en WS2812B-projecten

12V-5050-ledstrips hebben meestal 60 leds per meter en ongeveer 14,4 W/m. Voor 3 meter strip heb je 14,4 × 3 = 43,2 W nodig; de stroom is I = 43,2 / 12 = 3,6 A. Met 25% marge komt dat op 4,5 A, dus een adapter van 12 V 5 A (60 W) is geschikt. Wil je de strip met PWM vanaf een Arduino dimmen, dan komt er een MOSFET tussen; een logic-level-MOSFET zoals de IRLZ44N heeft bij 5 V gatespanning een inschakelweerstand van ongeveer 0,022 Ω, dus het verlies is P = I² × R = 3,6² × 0,022 ≈ 0,29 W, waardoor geen koelplaat nodig is. Bij adresseerbare WS2812B-leds trekt elke led ongeveer 60 mA op volledig wit: een strip van 1 meter met 144 leds per meter betekent 144 × 0,06 = 8,64 A, oftewel 43 W bij 5 V. Zoveel stroom veroorzaakt spanningsverlies in het dunne koper van de strip; voed lange strips daarom op meerdere punten en beperk de helderheid in software. Voor details zie de artikelen WS2812B NeoPixel, RGB-ledstrip aansturen en Een MOSFET gebruiken met Arduino.

Rekenvoorbeeld: motorprojecten en batterijduur

Gele TT-tandwielmotoren trekken ongeveer 150–250 mA onbelast bij 6 V, maar als een wiel blokkeert kan de stroom boven 1 A komen. Een robotauto met vier motoren trekt tijdens normaal rijden in totaal ongeveer 1 A. Een L298N die door twee 18650-cellen (7,4 V) wordt gevoed, verliest ongeveer 2 V door zijn bipolaire transistors; de motoren krijgen dus ongeveer 5,4 V en de L298N verspilt 2 V × 1 A = 2 W als warmte. Bijna een kwart van de 7,4 W die uit de batterijen wordt getrokken, gaat verloren in de driver; drivers op basis van MOSFET's zoals de TB6612FNG verminderen dit verlies aanzienlijk. De batterijduur schat je grofweg met capaciteit (mAh) / gemiddelde stroom (mA) × 0,8: uit een pakket van 2.500 mAh haal je, bij een gemiddelde stroom van 1,2 A inclusief de Arduino, 2.500 / 1.200 × 0,8 ≈ 1,7 uur rijden. De rekenmachine voor batterijduur doet dit voor je; lees daarna verder in Gelijkstroommotor aansturen met de L298N, Motordrivers vergeleken en mAh-batterijcapaciteit.

Vermogen meten met Arduino: de INA219-sensor

Rekenen is mooi, maar je moet meten om het echte verbruik te zien. Je kunt stroom meten met een multimeter, maar voor het volgen van wisselende belastingen en energie die zich in de tijd opbouwt, is de INA219-module veel praktischer. Deze module meet de kleine spanningsval over een shuntweerstand van 0,1 Ω die in serie met de belasting staat en leest tegelijk de belastingspanning uit; via I2C meet je spanningen tot 26 V en, in de standaardopstelling, stromen tot ongeveer 3,2 A. De code doet precies wat de formules in dit artikel zeggen: P = V × I voor het momentane vermogen en E = P × t voor de totale energie. Je hoeft alleen de bibliotheek Adafruit INA219 te installeren via de Library Manager. Voor de meetlogica en kalibratie zie het artikel INA219-stroomsensor.

INA219-pinArduino UnoESP32Raspberry Pi Pico
VCC5V3V33V3 (pin 36)
GNDGNDGNDGND
SCLA5GPIO 22GP5
SDAA4GPIO 21GP4
VIN+Pluspool van de voedingPluspool van de voedingPluspool van de voeding
VIN−Pluspool van de belastingPluspool van de belastingPluspool van de belasting
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}

Elke seconde leest de code de belastingspanning en de stroom en vermenigvuldigt ze om het vermogen in milliwatt te krijgen. Daarna rekent hij de tijd tussen twee metingen met millis() om naar uren, vermenigvuldigt die met het vermogen en telt het resultaat op bij de totale energie; zo zie je in de Serial Monitor hoeveel mWh je apparaat tot nu toe heeft verbruikt. De functie getPower_mW() van de bibliotheek geeft hetzelfde resultaat; hier hebben we de vermenigvuldiging zelf gedaan om de formule te laten zien. Een belangrijk detail: de minpool van de voeding die je meet moet met de GND van de Arduino zijn verbonden, anders is de spanningsmeting zinloos. De shunt staat altijd in serie met de belasting; als je VIN+ en VIN− rechtstreeks over de twee polen van een batterij aansluit, ontstaat kortsluiting.

Vermogen meten met ESP32 en Raspberry Pi Pico

De Arduino-code hierboven draait zonder wijzigingen op de ESP32; de Wire-bibliotheek gebruikt standaard GPIO 21 (SDA) en GPIO 22 (SCL). De ESP32 is een interessant board voor dit soort metingen omdat zijn verbruik zo sterk varieert: bij het versturen van data via Wi-Fi kan de momentane stroom boven 240 mA komen, het gemiddelde ligt rond 80–120 mA en in deep sleep trekt de chip slechts ongeveer 10 µA. Plotselinge stroompieken trekken de spanning omlaag bij een zwakke USB-kabel of adapter en veroorzaken brownout-resets; met de INA219 zie je die pieken en meet je hoeveel deep sleep de batterijduur verlengt. Op de Raspberry Pi Pico hoef je geen bibliotheek te installeren; een kort MicroPython-script dat de INA219-registers rechtstreeks uitleest, is genoeg:

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)

Projectideeën met vermogensberekening

  • USB-vermogensmeter: toon het momentane vermogen en de totale Wh van een telefoonlader of je Arduino-project met een INA219 en een OLED-display.
  • Batterijtester: ontlaad een batterij via een weerstandsbelasting en meet de capaciteit in mAh en Wh; gebruik de resultaten om 18650-batterijen te vergelijken.
  • Slimme stekkermeter: volg het kWh-verbruik van een apparaat op het stopcontact met een ESP32 en bereken de maandelijkse kosten; gebruik geïsoleerde, veilige modules voor de 230 V-kant en zie het artikel ESP32 slimme stekker.
  • Vermogensdisplay voor op je bureau: voeg een stroomsensor toe aan een Arduino-voltmeter om een meter te bouwen die spanning, stroom en vermogen tegelijk toont.
  • Zonnepaneelmonitor: meet het vermogen dat van het paneel naar de batterij stroomt en log de over de dag opgewekte Wh.
  • Batterijduurexperiment: draai dezelfde ESP32-code met en zonder deep sleep, meet de gemiddelde stroom en vergelijk de batterijduur.

Veelgemaakte fouten en hoe je ze oplost

FoutSymptoomOplossing
Een adapter met te weinig stroom kiezenHet board reset willekeurig, leds flikkeren, de servo triltBereken de totale stroom en tel er 20–30% marge bij
Denken dat een adapter met hogere spanning "krachtiger" isDe regelaar raakt oververhit, onderdelen branden doorKies de exacte spanning en genoeg stroom
Het vermogen van een weerstand niet berekenenDe weerstand wordt zwart, ruikt verbrand, zijn waarde loopt wegBereken met P = I² × R en kies een weerstand met tweemaal het vermogen
Een grote spanning laten wegvallen over een lineaire regelaarDe 7805 wordt erg heet en schakelt uit door de thermische beveiligingVerlaag de ingangsspanning, gebruik een koelplaat of een buck-converter
mAh als energie beschouwenBatterijen met verschillende spanningen worden verkeerd vergelekenReken om met Wh = mAh × V / 1000
De ampèremeter parallel aansluitenDe zekering van de multimeter springt, de voeding wordt kortgeslotenSluit de meter bij het meten van stroom altijd in serie met de belasting aan
De snelste manier om in te schatten hoe heet een schakeling wordt, is voor elk onderdeel "de spanning die erover valt × de stroom erdoor" te vermenigvuldigen. Is het resultaat lager dan 0,1 W, dan is er meestal geen probleem; kleine onderdelen voelen bij ongeveer 0,5 W merkbaar warm aan en vanaf 1 W moet je zeker aan koeling denken. Om de echte waarden te meten, zie Een multimeter gebruiken.

Als je P = V × I en de twee afgeleide vormen eenmaal kent, berust het kopen van een adapter, het kiezen van een weerstand, het inschatten van de batterijduur en het berekenen van je rekening op berekening in plaats van gokken. Maak je er een gewoonte van om in elk nieuw project een kleine vermogenstabel op te stellen, dan verdwijnen doorgebrande onderdelen en onverklaarbare resets grotendeels. In de BlueGrays-app verken je projecten met leds, ledstrips, motoren en een digitale voltmeter stap voor stap met schakelschema's en code, en probeer je de berekeningen die je hier hebt geleerd uit op echte schakelingen.

Veelgestelde vragen

Hoe bereken je watt?

Watt is spanning maal stroom: P = V × I. Een apparaat dat 2 A trekt bij 12 V verbruikt bijvoorbeeld 24 W. Ken je alleen stroom en weerstand, gebruik dan P = I² × R; ken je spanning en weerstand, gebruik dan P = V² / R.

Hoeveel watt is 1 kWh?

Een kWh is een eenheid van energie, niet van vermogen, dus het is niet direct gelijk aan een wattwaarde. 1 kWh is de energie die een apparaat van 1.000 W in 1 uur verbruikt. Een lamp van 100 W verbruikt 1 kWh in 10 uur en een apparaat van 10 W in 100 uur.

Hoe bereken je het maandelijkse stroomverbruik van een apparaat?

Vermenigvuldig het vermogen (W) van het apparaat met de dagelijkse gebruiksuren en met 30 dagen en deel door 1.000 om kWh te krijgen. Een ledstrip van 72 W die 5 uur per dag aan staat, verbruikt bijvoorbeeld 72 × 5 × 30 / 1.000 = 10,8 kWh. Vermenigvuldig dit met de prijs per kWh voor de maandelijkse kosten.

Kan een adapter met meer ampère mijn apparaat beschadigen?

Niet zolang de spanning klopt. De stroomwaarde op een adapter is het maximum dat hij kan leveren; de schakeling trekt alleen wat hij nodig heeft. Het echte gevaar is een te hoge spanning kiezen of een adapter gebruiken waarvan de stroom lager is dan wat je nodig hebt.

Hoe reken je ampère om naar watt?

Vermenigvuldig ampère met spanning: W = A × V. Een USB-adapter die 3 A levert bij 5 V geeft 15 W en een weerstandsapparaat dat 2 A trekt op 230 V-net verbruikt ongeveer 460 W. Bij wisselstroom speelt voor apparaten met een motor ook de arbeidsfactor mee, en je kunt niet van ampère naar watt rekenen zonder de spanning te kennen.

Hoeveel watt moet een weerstand aankunnen?

Bereken eerst het in de weerstand afgevoerde vermogen met P = I² × R of P = V × I en kies dan een weerstand die minstens twee keer die waarde aankan. Als je een led aanstuurt vanaf een Arduino, ligt het vermogen meestal onder 0,1 W, dus een standaardweerstand van 1/4 W volstaat. Bij schakelingen van 12 V en hoger heb je misschien weerstanden van 1/2 W of groter nodig.

Alle projecten bekijken
LED laten knipperen
AR-1Beginner

LED laten knipperen

De allereerste hallo van de elektronica: één LED aan- en uitzetten. De Arduino zet de LED met korte tussenpozen aan en uit, zodat het licht snel knippert.

4.6(200)
1246
Raspberry Pi Pico: een externe led aansturen (breadboard)
PI-2Beginner

Raspberry Pi Pico: een externe led aansturen (breadboard)

De volgende stap na de ingebouwde led van de Pico: sluit een externe led aan op een breadboard en bestuur hem via pin GP14. Je leert hoe je elke GPIO-pin van de Pico als uitgang gebruikt, de polariteit van de led (lang pootje = anode/+, kort pootje = kathode/–) en waarom een stroombeperkende weerstand (220Ω) een must is. Zonder weerstand loopt er te veel stroom door de led en kan hij doorbranden.

4.5(2)
7
Digitale voltmeter met lcd-scherm
AR-56Gemiddeld
Premium

Digitale voltmeter met lcd-scherm

Ontdek hoeveel spanning een batterij of voedingsadapter geeft met een meter die je zelf hebt gebouwd.

4.5(27)
36
230V-lamp laten branden met een drukknop
AR-19Gevorderd
Premium

230V-lamp laten branden met een drukknop

Zolang je de knop vasthoudt, brandt een echte lamp op netspanning, en zodra je loslaat gaat hij uit.

4.4(30)
38
Een WS2812B-ledstrip gebruiken
AR-69Gemiddeld
Premium

Een WS2812B-ledstrip gebruiken

Maak kennis met een slimme ledstrip waarvan je elk lampje apart kunt kleuren. De Arduino laat eerst de eerste vijf leds rood branden, zet een seconde later de andere vijf blauw, schakelt dan alles…

4.8(54)
70
ESP32 WS2812B NeoPixel-strip aansturen
ES-24Gemiddeld
Premium

ESP32 WS2812B NeoPixel-strip aansturen

WS2812B-leds (NeoPixel) zijn adresseerbare slimme RGB-leds die je kunt doorlussen en via één datapin kunt aansturen. In dit project sturen we een WS2812B-strip met 8 leds aan met de Adafruit_NeoPixel-bibliotheek en maken we een vloeiende regenbooganimatie. De 3,3V-logica van de ESP32 werkt met de meeste WS2812B-batches; wordt het instabiel, dan laten we de oplossing zien met een serieweerstand van 470Ω en een condensator van 1000µF. De animatie schuift de tint op in de HSV-kleurruimte.

4.9(19)
30
Auto met Bluetooth-besturing en L298N
AR-80Gevorderd
Premium

Auto met Bluetooth-besturing en L298N

Verander je telefoon in een afstandsbediening en bestuur je eigen robotauto. De Arduino ontvangt via een Bluetooth-module commando's van een afstandsbedieningsapp op je telefoon en laat de wielen…

5.0(39)
66
ESP32 Deep Sleep: batterij sparen (OLED + RTC RAM-teller)
ES-33Gevorderd
Premium

ESP32 Deep Sleep: batterij sparen (OLED + RTC RAM-teller)

De Deep Sleep-modus van de ESP32 schakelt de CPU en de meeste randapparatuur uit, waardoor het stroomverbruik daalt tot ongeveer 10µA; dat is cruciaal voor IoT-apparaten op batterijen. Dit project gebruikt drie wekbronnen: een timer (15 s), een externe pin (EXT0, de knop op GPIO 33) en een touchpin (T0/GPIO 4). Tellers met RTC_DATA_ATTR blijven behouden tijdens deep sleep.

4.3(10)
16