Basis · 16 min leestijd

Spanningsdeler: formule, weerstandskeuze en Arduino-voorbeelden

Hoe werkt een spanningsdeler? Vout = Vin × R2 / (R1 + R2), weerstanden kiezen, belastingseffect, 12 V meten met Arduino, 5 V naar 3,3 V, LDR en NTC.

Een spanningsdeler is de eenvoudigste schakeling om met twee weerstanden in serie een spanning om te zetten in een kleinere, voorspelbare spanning. De uitgangsspanning is Vout = Vin × R2 / (R1 + R2): R1 zit aan de bron, R2 zit aan massa (GND) en de uitgang haal je van het middelpunt waar ze samenkomen. Twee weerstanden van 10 kΩ delen 12 V bijvoorbeeld precies door twee, naar 6 V. Deze twee weerstanden zitten in het hart van talloze schakelingen: van een 12V-batterij meten met een Arduino en een 5V-sensorsignaal omlaag brengen naar de 3,3V-pinnen van een ESP32, tot sensoren uitlezen zoals LDR's en NTC-thermistoren.

In deze gids zie je met echte getallen waar de formule vandaan komt, hoe je de weerstandswaarden kiest en waarom de uitgangsspanning daalt als je iets op de deler aansluit (het belastingseffect). Daarna bouwen we stap voor stap code die de batterijspanning meet met een Arduino Uno, ESP32 en Raspberry Pi Pico, kiezen we de juiste weerstandsparen om 5 V om te zetten naar 3,3 V en lezen we een LDR en een NTC uit met een deler. Tot slot leggen we uit waarom je een spanningsdeler nooit als voeding mag gebruiken.

Weerstanden voor een spanningsdeler
Een spanningsdeler heeft maar twee weerstanden nodig; voor nauwkeurige metingen geven metaalfilmweerstanden van 1% preciezere resultaten.

Wat is een spanningsdeler en hoe werkt hij?

De formule van de spanningsdeler volgt rechtstreeks uit de wet van Ohm. Door R1 en R2, die in serie tussen de bron en massa staan, loopt dezelfde stroom: I = Vin / (R1 + R2). De spanning over R2, de uitgang, is die stroom maal R2: Vout = I × R2 = Vin × R2 / (R1 + R2). Kort gezegd wordt de bronspanning over de weerstanden verdeeld in verhouding tot hun waarde; de grotere weerstand krijgt het grotere deel. De uitgang is altijd kleiner dan de ingang, omdat de verhouding R2 / (R1 + R2) kleiner is dan 1. Meer over hoe spanning zich in serieschakelingen verdeelt vind je in Serie- en parallelweerstand berekenen.

GrootheidFormuleVoorbeeld (Vin = 12 V, R1 = 22 kΩ, R2 = 10 kΩ)
UitgangsspanningVout = Vin × R2 / (R1 + R2)12 × 10 / 32 = 3,75 V
Delingsverhoudingk = R2 / (R1 + R2)10 / 32 = 0,3125
Ingang uit de uitgangVin = Vout × (R1 + R2) / R23,75 × 3,2 = 12 V
R1 voor een gewenste verhoudingR1 = R2 × (Vin / Vout − 1)10 kΩ × (12 / 3,75 − 1) = 22 kΩ
DeelstroomI = Vin / (R1 + R2)12 / 32 kΩ = 0,375 mA
Totaal vermogenP = Vin² / (R1 + R2)144 / 32 kΩ = 4,5 mW
Uitgangsweerstand (Thévenin)Rth = R1 × R2 / (R1 + R2)22 × 10 / 32 = 6,875 kΩ

Je kunt ook terugrekenen: als je 12 V wilt terugbrengen naar 3,3 V en je hebt 10 kΩ gekozen voor R2, krijg je R1 = 10 × (12 / 3,3 − 1) ≈ 26,4 kΩ. Die waarde bestaat niet in de winkel, dus kies je de eerstvolgende standaardwaarde omhoog, 27 kΩ, en wordt de uitgang 12 × 10 / 37 ≈ 3,24 V. R1 naar boven afronden verlaagt de uitgang iets, en dat is de veilige kant voor de pin. Een potentiometer is eigenlijk ook een instelbare spanningsdeler: de loper splitst de weerstandsbaan in R1 en R2. Wil je het liever niet met de hand uitrekenen, dan geeft de spanningsdelercalculator je meteen de uitgang uit de ingangsspanning en de weerstanden. In de elektronica zie je spanningsdelers vooral voor deze taken:

  • Hogere spanningen meten: bronnen zoals een 12V-batterij of een 7,4V-lithiumpakket terugbrengen naar het bereik dat een analoge ingang kan meten.
  • Niveau omlaag schuiven: een 5V-signaal veilig maken voor de 3,3V-ingangen van een ESP32 of Raspberry Pi Pico.
  • Weerstandssensoren uitlezen: de weerstandsverandering van onderdelen zoals LDR's, NTC's, buigsensoren en krachtsensoren (FSR) omzetten in een spanning.
  • Veel knoppen op één pin uitlezen: met een weerstandsladder krijgt elke knop een andere spanning, zodat vijf knoppen één analoge pin kunnen delen.
  • Terugkoppeling van regelaars: regelaars zoals de LM317 en de instelbare LM2596 houden hun uitgang stabiel door die via een deler te meten; voor de LM317 geldt Vout = 1,25 × (1 + R2 / R1).
  • Een referentiespanning maken: de helft van de voedingsspanning opwekken als referentie in opamp-schakelingen.

Zo kies je de weerstandswaarden

De formule let alleen op de verhouding: 1 kΩ + 1 kΩ en 100 kΩ + 100 kΩ delen evenveel, precies door twee. In de praktijk doen de absolute waarden er toch toe. Kleine weerstanden laten veel stroom door de deler lopen; die stroom is verspilde energie en maakt een batterij in batterijprojecten voor niets leeg. Grote weerstanden trekken weinig stroom, maar hun uitgang is zwak: een aangesloten belasting of de bemonsteringscondensator in de analoge ingang verstoort de uitgangsspanning gemakkelijk, en ruis die de draden oppikken komt er sneller in. De juiste keuze is een balans tussen deze twee uitersten:

Totale weerstand (R1 + R2)Stroom bij 12 VVoordelenNadelenTypisch gebruik
100 Ω – 1 kΩ12–120 mANauwelijks beïnvloed door de belasting, erg snelWordt warm, verspilt veel stroomBijna nooit in meetschakelingen
1 kΩ – 30 kΩ0,4–12 mAIdeale uitgangsweerstand voor een ADC, geschikt voor snelle signalenConstant stroomverbruik in batterijprojectenSignaalconversie van 5 V naar 3,3 V, meten met Arduino
30 kΩ – 300 kΩ40–400 µABatterijvriendelijk, geen opwarmingKan een condensator van 100 nF aan de analoge ingang nodig hebbenBatterijbewaking
1 MΩ en hogerMinder dan 12 µATrekt bijna geen stroomGevoelig voor ruis, de ADC kan hem niet nauwkeurig uitlezen, zelfs een multimeter belast hemAlleen met een opampbuffer
  1. Zoek de hoogste ingangsspanning. Een 12V-loodaccu kan tijdens het opladen 14,4 V bereiken; neem het slechtste geval van de spanning die je gaat meten en tel er 10% marge bij op.
  2. Zoek de hoogste spanning die de pin accepteert. 5 V op de Arduino Uno, 3,3 V op de ESP32 en Pico; kies als veilige doelen ongeveer 4,5 V op de Uno, 2,5 V op de ESP32 en 3,0 V op de Pico.
  3. Bereken de verhouding: k = gewenste uitgang / hoogste ingang. Bijvoorbeeld 4,5 / 14,4 ≈ 0,31.
  4. Kies R2 (10 kΩ is in de meeste gevallen een goed startpunt) en bereken R1 met R1 = R2 × (1 / k − 1). Rond het resultaat naar boven af op de eerstvolgende waarde uit de standaardwaarden voor weerstanden.
  5. Controleer de stroom en het vermogen: I = Vin / (R1 + R2) en P = Vin² / (R1 + R2). Probeer in batterijprojecten de stroom in het microamperebereik te houden.
  6. Controleer de uitgangsweerstand: R1 × R2 / (R1 + R2) moet voor de Arduino Uno onder 10 kΩ liggen; zo niet, voeg dan een condensator van 100 nF toe tussen de analoge pin en GND.
  7. Zet de echte verhouding in je code: bereken de verhouding opnieuw met de standaardwaarden die je gekozen hebt, meet daarna met een multimeter zodra de schakeling klaar is en kalibreer.
De tolerantie van de weerstanden vertekent de verhouding direct. In het slechtste geval kunnen twee weerstanden van 5% van 22 kΩ en 10 kΩ de verhouding ergens tussen 0,291 en 0,334 laten verschuiven, ongeveer ±7%, dus je leest 12 V misschien als 11,2 V of 12,8 V. Met metaalfilmweerstanden van 1% daalt de fout naar ±1,4%, en één kalibratie met een multimeter haalt hem bijna helemaal weg.

Belastingseffect: wat gebeurt er als je iets op de deler aansluit?

De formule gaat ervan uit dat er geen stroom uit de uitgang wordt getrokken. Zodra je een belasting aansluit, staat die parallel aan R2, wordt de vervangingsweerstand van het onderste been kleiner en daalt de uitgangsspanning. Het makkelijkst reken je dit uit door de deler te zien als zijn Thévenin-equivalent: een bron met de spanning die je onbelast meet (Vth) en een inwendige weerstand Rth = R1 × R2 / (R1 + R2). Met een belasting RL wordt de uitgang Vth × RL / (Rth + RL). De tabel hieronder toont een bron van 10 V gedeeld door 10 kΩ + 10 kΩ (Vth = 5 V, Rth = 5 kΩ) met verschillende belastingen op de uitgang:

Belasting op de uitgang (RL)UitgangsspanningFout
Geen belasting5,00 V0%
1 MΩ4,98 V0,5%
100 kΩ4,76 V4,8%
10 kΩ3,33 V33%
1 kΩ0,83 V83%

De vuistregel: als de belastingsweerstand minstens 100 keer de uitgangsweerstand van de deler (Rth) is, blijft de fout onder 1%. Is de belasting kleiner, maak dan de weerstanden kleiner of zet een opamp als spanningsvolger (buffer) ertussen. De analoge ingang van een microcontroller heeft zelf een zeer hoge weerstand, maar binnenin zit een kleine bemonsteringscondensator die bij elke omzetting wordt opgeladen (ongeveer 14 pF bij de ATmega328P). Daarom raadt de datasheet een uitgangsweerstand van de bron van ongeveer 10 kΩ of minder aan. Gebruik je een deler met hogere waarden, voeg dan een condensator van 100 nF toe tussen de analoge pin en GND: die houdt de lading klaar die op het moment van bemonsteren nodig is. En als je meerdere analoge pinnen na elkaar uitleest, wist het weggooien van de eerste meting op elke pin de fout die overblijft na het omschakelen van kanaal.

Waarom een spanningsdeler geen voeding kan zijn

De meest voorkomende valkuil voor beginners is met twee weerstanden 5 V uit een 12V-adapter halen en daar een Arduino of module mee proberen te voeden. Op papier geeft een deler van 7 kΩ en 5 kΩ precies 5 V uit 12 V, maar alleen zolang er geen stroom uit de uitgang wordt getrokken. Een board dat 50 mA trekt, gedraagt zich als een belasting van ongeveer 100 Ω; parallel aan de 5 kΩ van R2 zakt het onderste been naar 98 Ω en stort de uitgang in tot 0,17 V. Maak je de weerstanden kleiner, 70 Ω en 50 Ω, dan trekt de schakeling nu 100 mA en zet hij 1,2 W om in warmte, ook als er niets is aangesloten; met de belasting eraan zakt de uitgang nog steeds naar 3,9 V, en elke keer dat de stroom van het board verandert (Wi-Fi, een servo, een relais) beweegt de spanning mee. Bovendien stijgt de spanning weer als de belasting wordt weggehaald, en dat kan gevoelige onderdelen beschadigen.

Gebruik om een schakeling te voeden een spanningsregelaar, geen spanningsdeler. Voor kleine stromen houdt een 7805-spanningsregelaar (een AMS1117 voor 3,3 V) en voor hogere stroom en rendement een step-down-converter zoals de LM2596 de uitgang stabiel, wat de belasting ook doet. Gebruik een spanningsdeler alleen voor metingen en signalen, en sluit nooit netspanning via een eenvoudige deler aan op een Arduino; daarvoor bestaan geïsoleerde modules.

12V-batterij- en celspanning meten met Arduino

De analoge ingangen van de Arduino Uno kunnen maximaal 5 V lezen; een 12V-batterij er rechtstreeks op aansluiten zou de pin vernielen. De oplossing is een deler van 22 kΩ (R1) en 10 kΩ (R2): met een verhouding van 0,3125 komt een laadspanning van 14,4 V als 4,5 V op de pin aan en kan de schakeling tot 16 V meten. Bij 12 V trekt de deler maar 0,375 mA en zijn uitgangsweerstand van 6,9 kΩ ligt onder de aanbevolen grens van 10 kΩ. De 10-bits ADC lost ongeveer 4,9 mV per stap op; met de deler is dat een resolutie van ongeveer 15,6 mV aan de ingang. Omdat de ESP32 en Pico op 3,3 V werken, gebruiken we op die boards een grotere R1 (56 kΩ):

AansluitingArduino UnoESP32Raspberry Pi Pico
R1 (bovenste weerstand)22 kΩ56 kΩ56 kΩ
R2 (onderste weerstand)10 kΩ10 kΩ10 kΩ
Bovenkant van R1Plus van de bron (+12 V)Plus van de bron (+12 V)Plus van de bron (+12 V)
Middelpunt (R1–R2)A0GPIO 34 (ADC1)GP26 (ADC0, pin 31)
Onderkant van R2 en min van de bronGNDGNDGND (bijv. pin 38)
Pinspanning bij 14,4 V4,50 V2,18 V2,18 V
Hoogste meetbare ingang16 VOngeveer 16 V (nauwkeurig bereik)Ongeveer 21 V
De min van de bron en de GND van de Arduino moeten met elkaar verbonden zijn; zonder gemeenschappelijke massa heeft de gemeten spanning geen referentie en springen de metingen betekenisloos heen en weer (zie Wat is GND? voor details). Ook het verwisselen van de weerstanden is gevaarlijk: met 10 kΩ boven en 22 kΩ onder komt 8,25 V van de 12 V op de pin. Meet het middelpunt met een multimeter voordat je de schakeling op de microcontroller aansluit.
C++ (Arduino IDE)
1// 12 V akü gerilimini gerilim bölücüyle ölçme / Measuring a 12 V battery with a voltage divider
2// Kaynak + -> 22k (R1) -> A0 -> 10k (R2) -> GND / Source + -> 22k (R1) -> A0 -> 10k (R2) -> GND
3// Kaynağın eksisi Arduino GND'sine bağlı / Source minus is tied to the Arduino GND
4const int VIN_PIN = A0;
5const float VREF = 5.0;      // 5V pininde ölçtüğün gerilim / voltage you measured on the 5V pin
6const float R1 = 22000.0;    // üst direnç (ohm) / top resistor (ohms)
7const float R2 = 10000.0;    // alt direnç (ohm) / bottom resistor (ohms)
8const float CAL = 1.000;     // kalibrasyon: gerçek / okunan / calibration: real / measured
9const float LOW_V = 11.8;    // düşük akü eşiği (V) / low battery threshold (V)
10
11float readInputVoltage() {
12  analogRead(VIN_PIN);                        // ilk okumayı at / discard the first reading
13  long sum = 0;
14  for (int i = 0; i < 16; i++) {              // 16 ölçümün ortalaması / average of 16 readings
15    sum += analogRead(VIN_PIN);
16    delay(2);
17  }
18  float vPin = (sum / 16.0) * VREF / 1024.0;  // pindeki gerilim / voltage at the pin
19  return vPin * (R1 + R2) / R2 * CAL;         // bölücüden önceki gerilim / voltage before the divider
20}
21
22void setup() {
23  Serial.begin(9600);
24  pinMode(LED_BUILTIN, OUTPUT);
25}
26
27void loop() {
28  float v = readInputVoltage();
29  Serial.print(F("Giris / Input: "));
30  Serial.print(v, 2);
31  Serial.println(F(" V"));
32  digitalWrite(LED_BUILTIN, v < LOW_V ? HIGH : LOW);  // akü zayıfsa LED yanar / LED on when the battery is low
33  delay(1000);
34}

De code gooit de eerste meting weg zodat de bemonsteringscondensator van de ADC kan stabiliseren en middelt daarna 16 metingen om ruis te verminderen. Het getal dat hij leest wordt eerst omgerekend naar de pinspanning (we delen door 1024 omdat de datasheet van de ATmega328P ADC = Vin × 1024 / Vref geeft) en daarna vermenigvuldigd met (R1 + R2) / R2 = 3,2 om de spanning vóór de deler te krijgen. De grootste foutbron is Vref: de 5V-pin van een Uno die via USB wordt gevoed, zit vaak ergens tussen 4,7 en 5,1 V. Meet daarom de 5V-pin met een multimeter en zet de waarde in VREF; meet daarna de echte spanning van de batterij met de multimeter, vergelijk die met de waarde in de Serial Monitor en vul CAL = echt / gemeten in in de code. Deze ene stap corrigeert de fouten van Vref en de weerstandstolerantie samen. Sluit je de deler aan na de aan/uit-schakelaar van het apparaat, dan trekt hij geen stroom zolang het apparaat uit staat; 0,375 mA komt neer op ongeveer 9 mAh per dag, wat voor een autoaccu niets is maar voor een kleine batterij merkbaar. Geschikte weerstandsparen voor andere bronnen:

Te meten bronSpanningsbereikArduino Uno (5 V): R1 + R2ESP32 / Pico (3,3 V): R1 + R2
Li-ion/LiPo-cel (1S)3,0–4,2 VGeen deler nodig (4,2 V < 5 V)100 kΩ + 100 kΩ → max. 2,10 V
2S Li-ion-pakket6,0–8,4 V10 kΩ + 10 kΩ → max. 4,20 V100 kΩ + 33 kΩ → max. 2,08 V
3S LiPo-pakket9,0–12,6 V22 kΩ + 10 kΩ → max. 3,94 V56 kΩ + 10 kΩ → max. 1,91 V
12V-loodaccu10,5–14,4 V22 kΩ + 10 kΩ → max. 4,50 V56 kΩ + 10 kΩ → max. 2,18 V
24V-systeem21–29 V56 kΩ + 10 kΩ → max. 4,39 V120 kΩ + 10 kΩ → max. 2,23 V

Spanning meten met de ESP32

Op de ESP32 is de ADC 12-bits (0–4095), maar hij verschilt op twee belangrijke punten. Ten eerste kunnen ADC2-pinnen niet worden gelezen zolang Wi-Fi aan staat, dus sluit de deler altijd aan op een van de ADC1-pinnen, GPIO 32–39 (GPIO 34–39 zijn alleen ingang en ideaal voor deze taak). Ten tweede is de ADC aan de uiteinden niet lineair: bij de standaarddemping van 11 dB raadt Espressif ongeveer 150–2450 mV aan als nauwkeurigste bereik. De pin toont waarden tot ongeveer 3,1 V, maar in dat gebied groeit de fout. Daarom kozen we een deler van 56 kΩ + 10 kΩ: 14,4 V komt als 2,18 V op de pin aan en blijft in het nauwkeurige bereik. In plaats van de ruwe analogRead() gebruiken we analogReadMilliVolts(), die rechtstreeks millivolt teruggeeft met de kalibratiegegevens die in de fabriek in de chip zijn geschreven:

C++ (Arduino IDE)
1// ESP32: 56k + 10k bölücüyle 12 V ölçme / ESP32: measuring 12 V with a 56k + 10k divider
2const int VIN_PIN = 34;        // ADC1_CH6, Wi-Fi açıkken de çalışır / ADC1_CH6, works with Wi-Fi on
3const float R1 = 56000.0;      // üst direnç (ohm) / top resistor (ohms)
4const float R2 = 10000.0;      // alt direnç (ohm) / bottom resistor (ohms)
5const float CAL = 1.000;       // multimetreyle ayarla / tune with a multimeter
6
7void setup() {
8  Serial.begin(115200);
9  analogReadResolution(12);    // 0-4095 (varsayılan / default)
10}
11
12void loop() {
13  uint32_t mv = 0;
14  for (int i = 0; i < 32; i++) {
15    mv += analogReadMilliVolts(VIN_PIN);     // kalibre edilmiş milivolt / calibrated millivolts
16  }
17  float vPin = mv / 32.0 / 1000.0;           // pindeki gerilim (V) / voltage at the pin (V)
18  float vIn = vPin * (R1 + R2) / R2 * CAL;   // bölücüden önceki gerilim / voltage before the divider
19  Serial.printf("Pin: %.3f V  Giris / Input: %.2f V\n", vPin, vIn);
20  delay(1000);
21}

Spanning meten met de Raspberry Pi Pico (MicroPython)

Op de Raspberry Pi Pico zijn de analoge ingangen GP26, GP27 en GP28 (ADC0–ADC2). De read_u16() van MicroPython schaalt de 12-bits meting naar het bereik 0–65535, en de referentie is ADC_VREF, die van de 3,3 V van het board komt. Omdat de ADC van de Pico tot 3,3 V kan meten, kom je met een deler van 56 kΩ + 10 kΩ tot ongeveer 21 V. Een mooi detail: de Pico gebruikt zelf een spanningsdeler. Een deler op het board deelt de voedingsspanning VSYS door drie en voert die naar GP29 (ADC3); vermenigvuldig de spanning die je met ADC(29) leest met 3 en je ziet de voedingsspanning van het board (op de Pico W wordt GP29 gedeeld met de draadloze chip, dus dit werkt daar niet rechtstreeks).

MicroPython
1from machine import ADC
2import time
3
4adc = ADC(26)            # GP26 = ADC0 (pin 31)
5VREF = 3.3               # ADC_VREF; multimetreyle ölçüp düzelt / measure and correct with a multimeter
6R1 = 56000               # üst direnç (ohm) / top resistor (ohms)
7R2 = 10000               # alt direnç (ohm) / bottom resistor (ohms)
8CAL = 1.000              # kalibrasyon katsayısı / calibration factor
9
10
11def read_input_voltage(samples=32):
12    total = 0
13    for _ in range(samples):
14        total += adc.read_u16()                  # 0-65535
15    v_pin = total / samples * VREF / 65535       # pindeki gerilim / voltage at the pin
16    return v_pin * (R1 + R2) / R2 * CAL          # bölücüden önceki gerilim / voltage before the divider
17
18
19while True:
20    v_in = read_input_voltage()
21    print("Giris / Input: {:.2f} V".format(v_in))
22    time.sleep(1)

Een 5V-signaal omlaag brengen naar 3,3 V (voor ESP32 en Pico)

De pinnen van de ESP32 en Pico zijn niet 5V-tolerant. Als de ECHO-uitgang van de HC-SR04, de TX-pin van een Arduino Uno of de digitale uitgang van een module op 5 V rechtstreeks op deze boards wordt aangesloten, worden de beschermingsdiodes van de ingang overbelast en kan de pin na verloop van tijd uitvallen. Voor signalen in één richting is een spanningsdeler de goedkoopste oplossing. Het doel is een spanning die nooit boven 3,3 V komt maar nog hoog genoeg is om door het board als HIGH te worden gelezen: de ESP32 beschouwt 75% van zijn voeding (ongeveer 2,5 V) als minimaal HIGH-niveau, en de RP2040 van de Pico gebruikt 2,0 V. Een uitgang tussen 3,0 en 3,3 V geeft dus ruime marge op beide boards. Dit is ook de methode die de gids over de HC-SR04-afstandssensor aanbeveelt om de ECHO-pin op 3,3V-boards aan te sluiten.

R1 (signaalzijde)R2 (GND-zijde)Uitgang bij 5 V ingangUitgangsweerstandOordeel
1 kΩ2 kΩ (twee van 1 kΩ in serie)3,33 V667 ΩDe klassieke keuze; ook prima voor snelle signalen
1,2 kΩ2,2 kΩ3,24 V776 ΩStandaard E12-waarden, net onder 3,3 V
10 kΩ20 kΩ3,33 V6,7 kΩLage stroom; genoeg voor UART en de HC-SR04
2,2 kΩ3,3 kΩ3,00 V1,3 kΩVeiligste marge; beide boards lezen nog steeds HIGH
4,7 kΩ10 kΩ3,40 V3,2 kΩGrensgeval; als de 5V-rail stijgt naar 5,25 V krijg je 3,57 V, niet aan te raden

Samen met de eigen capaciteit van de pin vormt de deler een klein RC-filter. De uitgangsweerstand van 6,7 kΩ van een deler van 10 kΩ + 20 kΩ en ongeveer 15 pF pin- en breadboardcapaciteit geven een tijdconstante van rond 100 ns; een UART van 115200 baud (8,7 µs per bit) merkt dat niet, maar de flanken van SPI-signalen van een paar MHz worden afgerond. Kies op snelle lijnen liever 1 kΩ + 2 kΩ. Bedenk ook dat een deler maar in één richting werkt, van de hogere naar de lagere spanning. In de andere richting heb je meestal niets nodig: de Arduino Uno beschouwt alles boven 3,0 V als HIGH, dus hij kan de 3,3V-uitgang van de ESP32 lezen, zij het met een kleine marge. Op bidirectionele lijnen zoals I2C is een deler echter nutteloos; daar gebruik je een niveauconverter op basis van MOSFET's.

Een LDR en een NTC uitlezen met een spanningsdeler

LDR (fotoweerstand) lichtsensor
De weerstand van een LDR verandert met het licht; bouw met een vaste weerstand een spanningsdeler en die verandering wordt een spanning die de Arduino kan lezen.

Microcontrollers kunnen weerstand niet rechtstreeks meten, alleen spanning. Als je een weerstandssensor zoals een LDR of een NTC in serie zet met een vaste weerstand tot een spanningsdeler, wordt de weerstandsverandering een spanningsverandering op het middelpunt. De waarde van de vaste weerstand bepaalt de gevoeligheid. Voor de grootste spanningsuitslag moet de vaste weerstand het meetkundig gemiddelde zijn van de kleinste en grootste weerstand van de sensor over het bereik waar het je om gaat: R = √(Rmin × Rmax). Voor een LDR die 1 kΩ leest in fel licht en 100 kΩ in zwak licht geeft dat √(1 k × 100 k) = 10 kΩ. Bij 5 V loopt de uitgang met 10 kΩ over 4,09 V, terwijl de uitslag met 1 kΩ of 100 kΩ krimpt tot 2,45 V. Daarom zitten er in startersets weerstanden van 10 kΩ. Er is nog een bonus: omdat de deler en de ADC op dezelfde 5 V werken, hangt de berekende weerstand niet af van de voedingsspanning (een ratiometrische meting), dus de code hieronder heeft niet eens een Vref-waarde nodig.

C++ (Arduino IDE)
1// LDR ve NTC'yi gerilim bölücüyle okuma / Reading an LDR and an NTC with voltage dividers
2// A0: 5V -> LDR -> A0 -> 10k -> GND
3// A1: 5V -> 10k -> A1 -> NTC 10k (B = 3950) -> GND
4const float R_FIXED = 10000.0;  // sabit dirençler (ohm) / fixed resistors (ohms)
5const float R0 = 10000.0;       // NTC'nin 25 °C direnci / NTC resistance at 25 °C
6const float BETA = 3950.0;      // NTC B katsayısı / NTC beta coefficient
7const float T0 = 298.15;        // 25 °C kelvin cinsinden / 25 °C in kelvin
8
9void setup() {
10  Serial.begin(9600);
11}
12
13void loop() {
14  analogRead(A0);                         // kanal değişti, ilk okumayı at / channel changed, discard first reading
15  int ldrRaw = analogRead(A0);
16  analogRead(A1);
17  int ntcRaw = analogRead(A1);
18  if (ldrRaw < 1) ldrRaw = 1;             // sıfıra bölmeyi önle / avoid division by zero
19
20  // Oransal ölçüm: besleme gerilimi hesaptan düşer / ratiometric: the supply voltage cancels out
21  float rLdr = R_FIXED * (1024.0 / ldrRaw - 1.0);
22  float rNtc = R_FIXED * ntcRaw / (1024.0 - ntcRaw);
23  float tempC = 1.0 / (1.0 / T0 + log(rNtc / R0) / BETA) - 273.15;  // Beta denklemi / Beta equation
24
25  Serial.print(F("LDR: "));
26  Serial.print(rLdr / 1000.0, 1);
27  Serial.print(F(" kOhm   NTC: "));
28  Serial.print(rNtc / 1000.0, 2);
29  Serial.print(F(" kOhm   "));
30  Serial.print(tempC, 1);
31  Serial.println(F(" C"));
32  delay(1000);
33}

In de code zit de LDR boven, dus de meting stijgt naarmate het lichter wordt; zijn weerstand is R = 10 kΩ × (1024 / ADC − 1). De NTC zit onder, en als de temperatuur stijgt, dalen zijn weerstand en dus de gelezen spanning. Voor de gangbare NTC's van 10 kΩ bij 25 °C met een B-coëfficiënt van 3950 volgt de temperatuur uit de Beta-vergelijking: 1 / T = 1 / T0 + ln(R / R0) / B (temperaturen in kelvin). Omdat de vaste weerstand overeenkomt met de weerstand van de NTC bij 25 °C, is de uitgang bij kamertemperatuur precies de helft van de voeding, en daar is de gevoeligheid het hoogst. Voor meer nauwkeurigheid over een breed temperatuurbereik behandelen we de Steinhart-Hart-vergelijking en de zelfopwarming van de NTC in de gids over de NTC-thermistor.

Projectideeën met een spanningsdeler

  • Batterijmonitor en alarm voor lege batterij: houd de batterij in een camper of zonnesysteem in de gaten en laat een buzzer klinken als hij onder 11,8 V zakt; voor voedingsopties in batterijprojecten, zie Een Arduino op batterijen laten werken.
  • Digitale voltmeter: toon de spanning die je meet op een LCD- of OLED-display; de stappen staan in Een Arduino-voltmeter bouwen.
  • Automatisch nachtlampje: gebruik een LDR-deler om leds of een relais aan te zetten als het donker wordt.
  • Zonnevolger: vergelijk de spanningen van twee LDR-delers om een paneel naar het licht te draaien (zonnevolger).
  • Vijf knoppen op één pin: bouw een ladder van verschillende weerstanden en bepaal uit de analoge waarde welke knop is ingedrukt (knoppen aansluiten).
  • Thermostaat: meet de temperatuur met een NTC-deler en schakel via een relais een ventilator of verwarming bij de temperatuur die je instelt.

Veelgemaakte fouten en hoe je ze oplost

SymptoomWaarschijnlijke oorzaakOplossing
Metingen zijn betekenisloos en blijven springenDe min van de bron is niet verbonden met de GND van de ArduinoVerbind een gemeenschappelijke GND
Pinspanning is veel hoger dan verwachtR1 en R2 zijn verwisseldDe grotere weerstand komt aan de bronzijde (boven); meet met een multimeter voordat je aansluit
Meting wijkt 5–10% af van de echte waardeWeerstanden van 5%, of Vref is niet 5,00 VGebruik metaalfilmweerstanden van 1% en kalibreer met VREF en CAL in de code
Uitgang zakt als een module wordt aangeslotenBelastingseffect: de belasting staat parallel aan R2Maak de belasting minstens 100 × Rth, gebruik kleinere weerstanden of een opampbuffer
Meting drijft weg bij een deler met hoge waardenDe bemonsteringscondensator van de ADC kan niet volledig opladenVoeg een condensator van 100 nF toe aan de pin en gooi de eerste meting weg
ESP32-meting werkt niet meer als Wi-Fi startDe deler zit op een ADC2-pinGebruik GPIO 32–39 (ADC1)
Batterij loopt leeg, ook als het apparaat uit staatDe deler trekt de hele tijd stroom uit de batterijSluit de deler aan na de schakelaar en gebruik weerstanden met hoge waarden
Een module die door de deler wordt gevoed, werkt nietEen deler is geen voedingGebruik een regelaar zoals een 7805, AMS1117 of LM2596
I2C werkt niet via een delerEen deler werkt in één richting, I2C is bidirectioneelGebruik een MOSFET-niveauconverter
Zet bij elke nieuwe deler die je bouwt de bron aan en meet de spanning op het middelpunt met een multimeter voordat je hem op de microcontroller aansluit. Komt de waarde tot op een paar procent overeen met de spanningsdelercalculator, verplaats dan de draad naar de analoge pin. Deze controle van tien seconden voorkomt dat een verwisselde weerstand je board grillt.

Een spanningsdeler is maar twee weerstanden en één formule, en toch duikt hij op in bijna elk project dat iets meet. Kies de verhouding met de formule, kies de absolute waarden door stroom af te wegen tegen uitgangsweerstand, houd rekening met het belastingseffect en kalibreer het resultaat met een multimeter, en je krijgt betrouwbare metingen. De achtergrond over analoge metingen lees je in Wat is een ADC?. In de BlueGrays-app vind je projecten zoals lichtsterkte meten met een LDR, een LDR-nachtlampje, een digitale voltmeter met LCD, temperatuurmeting met een NTC en een ESP32-HC-SR04-afstandsmeter, allemaal stap voor stap uitgelegd met schakelschema's en code.

Veelgestelde vragen

Wat is de formule van de spanningsdeler?

De uitgangsspanning is Vout = Vin × R2 / (R1 + R2), waarbij R1 de weerstand aan de bronzijde is en R2 die aan de massazijde. Als je bijvoorbeeld 9 V deelt met 10 kΩ en 10 kΩ, krijg je 4,5 V. De formule is alleen exact als er geen stroom uit de uitgang wordt getrokken.

Kan ik met een spanningsdeler 5 V uit 12 V halen?

Voor een meting of een signaal wel: met 22 kΩ en 10 kΩ breng je 12 V omlaag naar 3,75 V en lees je dat met een analoge ingang van een Arduino. Om een board of module te voeden niet; de uitgang stort in zodra de belasting stroom trekt. Gebruik voor voeding een regelaar zoals de 7805 of een step-down-converter zoals de LM2596.

Welke weerstanden heb ik nodig om 5 V om te zetten naar 3,3 V?

Het gangbaarste paar is 1 kΩ aan de signaalzijde en 2 kΩ aan de massazijde, waarmee 5 V 3,33 V wordt. Dezelfde verhouding krijg je met 10 kΩ en 20 kΩ, maar kleinere waarden zijn beter voor snelle signalen. Heb je geen 2 kΩ, dan geven 2,2 kΩ en 3,3 kΩ 3,0 V, wat de ESP32 en Pico nog steeds als HIGH lezen.

Hoe kies ik weerstandswaarden voor een spanningsdeler?

Bepaal eerst de verhouding uit de hoogste ingangsspanning en de limiet van de pin, kies dan R2 (meestal 10 kΩ) en bereken R1. Is de totale weerstand laag, dan verspilt de deler stroom; is hij erg hoog, dan nemen het belastingseffect en ADC-fouten toe. Op een Arduino is een uitgangsweerstand onder 10 kΩ, en in batterijprojecten een totaal van rond 100 kΩ, een goede balans.

Hoe meet ik 12 V met een Arduino?

Verbind de plus van de batterij via 22 kΩ met A0, A0 via 10 kΩ met GND en de min van de batterij met de GND van de Arduino. Vermenigvuldig in de code de waarde van analogRead() met 5 / 1024 voor de pinspanning en vermenigvuldig die daarna met 3,2 voor de batterijspanning. Met deze deler kun je veilig tot 16 V meten.

Maakt een spanningsdeler de batterij leeg?

Ja, een deler trekt voortdurend I = Vin / (R1 + R2). Een deler van 32 kΩ trekt bij 12 V 0,375 mA, ongeveer 9 mAh per dag: niets voor een autoaccu maar aanzienlijk voor een kleine batterij. Gebruik in batterijprojecten weerstanden van rond 100 kΩ met een condensator van 100 nF aan de analoge pin, of sluit de deler aan na de schakelaar van het apparaat.

Alle projecten bekijken
Lichtsterkte meten met een LDR
AR-11Beginner

Lichtsterkte meten met een LDR

Wil je zien hoe licht je kamer is, als getal? De LDR, een klein onderdeel dat op licht reageert, meet het licht om je heen en de Arduino schrijft de waarde elke halve seconde naar je computerscherm.

4.6(83)
143
Nachtlampje met LDR
AR-12Beginner

Nachtlampje met LDR

Een klein nachtlampje dat vanzelf aangaat als het donker wordt en uitgaat als het ochtend is.

4.7(105)
224
Lichtsterkte meten met de ESP32 en een LDR-module
ES-11Beginner

Lichtsterkte meten met de ESP32 en een LDR-module

Volg in de Serial Monitor in realtime de ruwe ADC-waarde van de LDR-module en het relatieve lichtpercentage, berekend uit referentiewaarden voor donker en licht. Dit percentage is geen luxmeting. Je leert hoe de module gekalibreerd wordt. Ideaal om vóór Project 10 te doen, want je gebruikt het om de drempelwaarde te bepalen.

4.6(36)
55
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
Temperatuur meten met NTC en 2x16 LCD-display
AR-44Beginner
Premium

Temperatuur meten met NTC en 2x16 LCD-display

Meet de temperatuur om je heen met een sensor die op een klein kraaltje lijkt. Dit onderdeel, een NTC, laat elektriciteit makkelijker door naarmate het warmer wordt; de Arduino leest die verandering…

4.5(33)
44
ESP32-nachtlampje met LDR
ES-10Beginner
Premium

ESP32-nachtlampje met LDR

Nachtlampje waarvan de LED in het donker automatisch aangaat en bij licht uit. Je gebruikt de D0-pin (digitale uitgang) van de LDR-sensormodule: de donkerdrempel stel je in met de kleine potmeter op de module en de module zelf geeft het HIGH/LOW-signaal. De ESP32 leest dit signaal alleen met digitalRead(); de code is heel eenvoudig.

4.6(17)
30
ESP32 HC-SR04 ultrasone afstandssensor
ES-14Gemiddeld

ESP32 HC-SR04 ultrasone afstandssensor

De ultrasone sensor HC-SR04 meet afstand door te timen hoe lang zijn geluidspuls erover doet om van een voorwerp terug te kaatsen (time of flight). In dit project stuurt de ESP32 een puls van 10 microseconden naar de TRIG-pin en leest hij de echotijd met pulseIn() van de ECHO-pin. De afstand wordt in cm getoond op een 16x2 I2C-LCD. De HC-SR04 werkt op 5V, dus de ECHO-pin heeft een spanningsdeler nodig, anders raakt de 3,3V-GPIO van de ESP32 beschadigd.

4.9(29)
48
ESP32 ledhelderheid regelen met een potmeter (analoog → PWM)
ES-13Gemiddeld
Premium

ESP32 ledhelderheid regelen met een potmeter (analoog → PWM)

In dit project regel je de helderheid van een led analoog met een potmeter. De ADC-pin van de ESP32 leest de spanning van 0–3,3 V van de potmeter; die waarde wordt omgezet in een PWM-signaal (pulsbreedtemodulatie) en naar de led gestuurd. Als je aan de potmeter draait, wordt de led dus geleidelijk helderder en zwakker. Met Arduino Core 3.0+ kun je analogWrite() direct gebruiken; op de ESP32-S2/S3 ligt de ADC-resolutie vast op 12 bit.

4.5(19)
32