Gidsen · 15 min leestijd

Arduino-voltmeter: meet 0–25 V met een LCD en kalibratie

Een Arduino-voltmeter bouwen: meet 0–25 V met een spanningsdeler, kies weerstanden, voeg zenerbeveiliging toe, kalibreer, gebruik een LCD, een INA219 en een batterijtester.

Een Arduino-voltmeter is een meetinstrument dat je in één avond bouwt: twee weerstanden, één analoge ingang en een paar regels code zijn genoeg om 0–25 V nauwkeurig te meten en op een display te tonen. De analoge ingangen van Arduino kunnen maximaal 5 V lezen. Om een hogere spanning te meten schaal je die eerst terug met een spanningsdeler en reken je hem in de code met dezelfde verhouding weer op. Batterijmonitors, voedingsdisplays, zonnepaneellogges en batterijtesters draaien allemaal op dit ene idee.

In deze gids leer je stap voor stap hoe je weerstandswaarden kiest voor een bepaald bereik, hoe een zenerdiode en een serieweerstand de analoge ingang beschermen tegen overspanning, hoe de kant-en-klare 0–25 V-spanningssensormodule werkt en hoe het instellen van de referentiespanning en kalibreren je metingen dicht bij die van een multimeter brengt. Daarna toon je de waarde op een I2C-LCD, bouw je dezelfde voltmeter op een ESP32 en een Raspberry Pi Pico, voeg je stroommeting toe met een INA219 om er een wattmeter van te maken en maak je tot slot een tester die de echte capaciteit van een batterij in mAh meet.

Digitale voltmeter
De voltmeter die je met Arduino bouwt, kan de spanning op twee decimalen tonen, net als deze paneelmeters.

Hoe werkt een Arduino-voltmeter?

Arduino kent spanning niet rechtstreeks; de ADC (analoog-digitaalomzetter) vergelijkt de spanning op de analoge ingang met een referentiespanning en geeft het resultaat als geheel getal terug. De ADC van de Arduino Uno is 10-bits: hij leest 0 bij 0 V en 1023 bij de referentiespanning (standaard 5 V). De spanning op de pin is Vpin = meetwaarde × Vref / 1024. Staat er een spanningsdeler voor de ingang, dan is de spanning die je echt meet Vin = Vpin × (R1 + R2) / R2. De nauwkeurigheid van de hele voltmeter hangt dus af van drie dingen: de echte waarde van Vref, de verhouding van de twee weerstanden en de eigen fout van de ADC.

BoardADCReferentie1 stap op de pin1 stap bij een 0–25 V-deler
Arduino Uno, Nano, Pro Mini10-bits (0–1023)5 V (AVcc)4,88 mV24,4 mV (30 kΩ + 7,5 kΩ)
ESP3212-bits (0–4095)Ongeveer 3,3 V (11 dB demping)Ongeveer 0,8 mVOngeveer 9 mV (100 kΩ + 10 kΩ)
Raspberry Pi Pico12-bits (0–65535 via read_u16)3,3 V (ADC_VREF)0,81 mV8,9 mV (100 kΩ + 10 kΩ)

De spanningsdeler en weerstanden kiezen voor 0–25 V

De spanning die je meet komt binnen via de bovenste weerstand R1, het middelpunt waar de twee weerstanden samenkomen gaat naar de analoge pin en de onderste weerstand R2 gaat naar GND. Bepaal bij het kiezen van weerstanden eerst de hoogste spanning en kies dan een verhouding waarbij de pin bij die spanning net onder de referentie blijft, bijvoorbeeld ongeveer 4,5 V op een Uno. Het paar van 30 kΩ en 7,5 kΩ dat in kant-en-klare modules zit, deelt precies door 5: 25 V op de ingang geeft 5,00 V op de pin. Kies de waarden ook niet willekeurig: is de totale weerstand te laag, dan onttrekt de deler onnodig stroom aan de bron die je meet, en is hij te hoog, dan kan de bemonsteringscondensator in de ADC niet opladen en gaat de meetwaarde driften. Het datasheet van de ATmega328P adviseert dat de bron die een analoge ingang aanstuurt maximaal 10 kΩ is; bij een deler is die bronweerstand R1 en R2 parallel (6 kΩ voor 30 kΩ en 7,5 kΩ). De formule in detail, plus belastingseffecten, vind je in het artikel over de spanningsdeler.

BereikArduino Uno (5 V): R1 + R2Pin bij volle schaalESP32 / Pico (3,3 V): R1 + R2Pin bij volle schaal
0–10 V12 kΩ + 10 kΩ4,55 V33 kΩ + 10 kΩ2,33 V
0–25 V30 kΩ + 7,5 kΩ (kant-en-klare module)5,00 V100 kΩ + 10 kΩ2,27 V
0–30 V56 kΩ + 10 kΩ4,55 V120 kΩ + 10 kΩ2,31 V
0–50 V100 kΩ + 10 kΩ4,55 V220 kΩ + 10 kΩ2,17 V
In plaats van de verhouding voor je eigen bereik met de hand uit te rekenen, kun je de spanningsdelercalculator gebruiken. In de kolommen voor ESP32 en Pico hebben we de pin bewust onder 2,5 V gehouden, omdat de ADC van de ESP32 bovenin zijn lineariteit verliest. Kies liever metaalfilmweerstanden van 1%; twee weerstanden van 5% kunnen de verhouding in het slechtste geval ongeveer 10% laten verschuiven.

Beveiliging: zenerdiode, serieweerstand en condensator

Zelfs met een juist berekende deler kan een verkeerde meetpen, een piek op de voeding of per ongeluk 48 V in plaats van 25 V aanraken de pin boven 5 V duwen. De pinnen van de ATmega328P verdragen maximaal de voedingsspanning plus 0,5 V. In de pin zitten beveiligingsdiodes naar 5 V en GND, maar die kunnen alleen kleine stromen aan. Het goede nieuws is dat de bovenste weerstand van de deler de stroom al beperkt. Met een R1 van 30 kΩ vloeit zelfs bij het aanraken van 50 V hooguit ongeveer 1,5 mA de pin in. Om die stroom verder te verlagen en de overtollige spanning veilig af te voeren, kun je de volgende lagen toevoegen.

  • Serieweerstand: Plaats een weerstand van 4,7–10 kΩ tussen het middelpunt van de deler en de analoge pin. Bij overspanning daalt de stroom naar de interne diodes van de pin tot het microampèrebereik.
  • Condensator van 100 nF: Sluit hem aan tussen de analoge pin en GND. Hij compenseert de hogere bronweerstand door de serieweerstand, omdat de ADC de lading die hij tijdens het bemonsteren nodig heeft uit deze condensator haalt. Hij filtert ook ruis en korte pieken.
  • Zenerdiode van 5,1 V: Sluit een zener zoals de 1N4733A of BZX55C5V1 aan met de kathode op de pin en de anode op GND. Probeert de spanning boven 5,1 V uit te komen, dan gaat de zener geleiden en voert hij het teveel af naar GND.
  • Let op de lekstroom van de zener: Een zener gaat al iets onder zijn doorslagspanning een kleine stroom trekken en bij een deler met hoge weerstand trekt die stroom de meetwaarde omlaag. Gebruik je een zener, houd het maximum op de pin dan rond 4 V, of gebruik in plaats daarvan een Schottkydiode (BAT85) van de pin naar de 5V-lijn.
  • Omgekeerde polariteit: Sluit je de meetpennen verkeerd om aan, dan komt er een negatieve spanning op de pin. De serieweerstand beperkt de stroom; voor extra veiligheid kun je een tweede Schottkydiode toevoegen met de anode op GND en de kathode op de pin.
Deze voltmeter is alleen voor gelijkspanning (DC) en lage spanningen (hooguit enkele tientallen volt). Probeer nooit het 230 V-net te meten met twee weerstanden: dat is mogelijk levensgevaarlijk en verbindt de GND van de Arduino met het net. Gebruik voor netspanning een galvanisch gescheiden transformatormodule zoals de ZMPT101B. Bovendien moet de min van de bron die je meet verbonden zijn met de GND van de Arduino; zonder gemeenschappelijke massa zegt de meetwaarde niets.

De kant-en-klare spanningssensormodule (0–25 V)

Wil je niet solderen, dan kun je de kleine rode of blauwe module gebruiken die als "spanningssensor" wordt verkocht. Er zit niets magisch in: alleen een deler van precies een weerstand van 30 kΩ en een van 7,5 kΩ, een schroefklem en een header met drie pinnen. Omdat de verhouding 5 is, kun je met een Arduino van 5 V 0–25 V meten, maar met een board van 3,3 V slechts tot 16,5 V. Op een board van 3,3 V zet het aanraken van 25 V 5 V op de pin en beschadigt die, dus voor de ESP32 en de Pico is het veiliger om zelf een deler te bouwen volgens de tabel hierboven. De module heeft geen beveiligingsdiode, dus de maatregelen met zener of Schottky uit de vorige sectie gelden hier ook.

ModulepinFunctieArduino UnoESP32 (eigen deler)Raspberry Pi Pico (eigen deler)
VCC (schroefklem)Plus van de te meten bronBron +Bovenkant van R1Bovenkant van R1
GND (schroefklem)Min van de te meten bronBron −Bron − en GNDBron − en GND
SGedeeld signaalA0GPIO 34 (ADC1)GP26 (ADC0, pin 31)
+Bij de meeste modules niet aangeslotenNiet aansluiten--
−GND van de moduleGNDGNDGND (bijv. pin 33)

Stap voor stap: je eerste Arduino-voltmeter

  1. Sluit de S-pin van de module aan op A0 en de −-pin op GND. Bouw je zelf een deler, plaats dan de 30 kΩ aan de kant van de bron en de 7,5 kΩ aan de GND-kant en leid het middelpunt naar A0.
  2. Sluit de Arduino aan op USB, meet met een multimeter tussen de 5V-pin en GND en noteer de waarde. De USB-spanning ligt vaak ergens tussen 4,7 en 5,1 V.
  3. Vul de gemeten waarde in bij de constante VREF in de onderstaande code en upload die.
  4. Sluit de bron die je wilt meten aan op de schroefklem van de module: plus op VCC, min op GND. Een 9V-batterij of een regelbare labvoeding is ideaal voor een eerste test.
  5. Open de Serial Monitor op 9600 baud. Lees de spanning af, meet tegelijk de bron met je multimeter en vergelijk de twee waarden.
C++ (Arduino IDE)
1// Arduino voltmetre: 0-25 V gerilim sensörü modülü / Arduino voltmeter: 0-25 V voltage sensor module
2// Modül S -> A0, modül - -> GND / module S -> A0, module - -> GND
3// Ölçülen kaynak modülün VCC ve GND klemensine / measured source goes to the module's VCC and GND terminals
4const int SENSE_PIN = A0;
5const float VREF = 5.00;       // 5V pininde ölçtüğün gerilim / voltage you measured on the 5V pin
6const float R1 = 30000.0;      // üst direnç (ohm) / top resistor (ohms)
7const float R2 = 7500.0;       // alt direnç (ohm) / bottom resistor (ohms)
8const float CAL = 1.000;       // kalibrasyon: gerçek / okunan / calibration: real / measured
9const int SAMPLES = 32;        // ortalama için örnek sayısı / samples to average
10
11float readVoltage() {
12  analogRead(SENSE_PIN);                    // ilk okumayı at / discard the first reading
13  unsigned long sum = 0;
14  for (int i = 0; i < SAMPLES; i++) {
15    sum += analogRead(SENSE_PIN);
16    delayMicroseconds(500);
17  }
18  float adc = (float)sum / SAMPLES;         // 0-1023 arası ortalama / average between 0 and 1023
19  float vPin = adc * VREF / 1024.0;         // pindeki gerilim / voltage at the pin
20  return vPin * (R1 + R2) / R2 * CAL;       // bölücüden önceki gerilim / voltage before the divider
21}
22
23void setup() {
24  Serial.begin(9600);
25}
26
27void loop() {
28  float v = readVoltage();
29  if (v < 0.05) v = 0.0;                    // boşta gürültüyü sıfırla / zero the noise when idle
30  Serial.print(F("Gerilim / Voltage: "));
31  Serial.print(v, 2);
32  Serial.println(F(" V"));
33  delay(500);
34}

De code middelt telkens 32 metingen, waardoor de ±1-staps-jitter van de ADC grotendeels verdwijnt en het laatste cijfer rustig blijft. De eerste meting wordt weggegooid, omdat de bemonsteringscondensator van de ADC nog lading van het vorige kanaal vasthoudt. Alles onder 0,05 V afronden naar nul voorkomt dat er willekeurige waarden zoals 0,02–0,04 V verschijnen als er niets is aangesloten. Houd er rekening mee dat de resolutie 24,4 mV is: ook al zie je twee decimalen, het laatste cijfer beweegt in stappen van 0,02–0,03 V. Heb je een fijnere resolutie nodig, verklein dan het bereik; met een 0–10 V-deler daalt één stap naar 10,7 mV.

Referentiespanning en kalibratie

Mensen zeggen vaak dat Arduino-voltmeters "verkeerd meten", maar de echte bron van de fout is meestal de referentie. Staat er in de code 5.00 V terwijl het board 4,80 V van USB krijgt, dan is elke meting 4% te hoog: een batterij van 12,00 V toont 12,50 V. Deze spanning verschilt van een desktop tot een laptop en van de ene USB-kabel tot de andere, en voed je het board met een externe adapter, dan neemt de regelaar het over en is de waarde weer anders. Er zijn drie manieren om dit op te lossen: de 5V-pin meten en in de code zetten, een vaste interne referentie gebruiken, of de voedingsspanning van het board bij elke meting opnieuw berekenen.

MethodeCodeVoordeelLet op
Standaard (AVcc)analogReference(DEFAULT)Geen instellingen, volledig 0–5 V-bereikWat de voeding doet, doet de meetwaarde ook
Interne referentie van 1,1 VanalogReference(INTERNAL)Stabiel en onafhankelijk van de voedingVerschilt per board van 1,0 tot 1,2 V; de delerverhouding moet ongeveer 23 zijn (bijv. 220 kΩ + 10 kΩ)
Externe referentie (AREF)analogReference(EXTERNAL)Beste nauwkeurigheid met een precisiereferentie zoals de LM4040Deze regel moet draaien voordat je een spanning op AREF zet, anders ontstaat er kortsluiting met de interne referentie
Voedingsmeting (readVcc)De onderstaande codeGeen extra onderdelen, blijft nauwkeurig als USB of de batterij verandertWerkt alleen op AVR-boards (Uno, Nano, Pro Mini); kalibreer de waarde van 1,1 V één keer
C++ (Arduino IDE)
1// Kendi besleme gerilimini ölçen voltmetre (ATmega328P: Uno, Nano, Pro Mini)
2// Voltmeter that measures its own supply (ATmega328P: Uno, Nano, Pro Mini)
3const int SENSE_PIN = A0;
4const float R1 = 30000.0;      // üst direnç / top resistor
5const float R2 = 7500.0;       // alt direnç / bottom resistor
6long bandgapMv = 1100;         // iç referans (mV), kalibrasyonla düzelt / internal reference (mV), fix by calibration
7
8long readVccMv() {
9  // Referans AVcc, ölçülen kanal iç 1,1 V / reference AVcc, measured channel is the internal 1.1 V
10  ADMUX = _BV(REFS0) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1);
11  delay(2);                                  // referans otursun / let the reference settle
12  ADCSRA |= _BV(ADSC);                       // dönüşümü başlat / start a conversion
13  while (bit_is_set(ADCSRA, ADSC)) {}        // bitmesini bekle / wait until it finishes
14  unsigned int raw = ADCW;                   // 10 bit sonuç / 10-bit result
15  return bandgapMv * 1024L / raw;            // Vcc = 1,1 V x 1024 / okunan / Vcc = 1.1 V x 1024 / reading
16}
17
18float readVoltage(float vcc) {
19  analogRead(SENSE_PIN);                     // kanal değişti, ilk okumayı at / channel changed, discard first
20  unsigned long sum = 0;
21  for (int i = 0; i < 32; i++) sum += analogRead(SENSE_PIN);
22  float vPin = (sum / 32.0) * vcc / 1024.0;
23  return vPin * (R1 + R2) / R2;
24}
25
26void setup() {
27  Serial.begin(9600);
28}
29
30void loop() {
31  float vcc = readVccMv() / 1000.0;
32  float v = readVoltage(vcc);
33  Serial.print(F("Vcc: "));
34  Serial.print(vcc, 3);
35  Serial.print(F(" V   Giris / Input: "));
36  Serial.print(v, 2);
37  Serial.println(F(" V"));
38  delay(500);
39}
  1. De interne referentie kalibreren: Draai de readVcc-code en vergelijk de Vcc-waarde in de Serial Monitor met wat je multimeter op de 5V-pin leest. Nieuwe bandgapMv = 1100 × gemeten / getoond. Toont het board bijvoorbeeld 5.12 V en leest de multimeter 4.98 V, vul dan 1100 × 4.98 / 5.12 ≈ 1070 in.
  2. Eenpuntskalibratie: Sluit een bekende spanning aan bij de bovenkant van het bereik (bijv. 12 V). CAL = waarde van de multimeter / waarde van de Arduino. Deze factor corrigeert ook de verhoudingsfout door de tolerantie van de weerstanden.
  3. Tweepuntskalibratie: Zie je bij lage spanningen een constante offset, meet dan op twee punten, een laag (bijv. 2 V) en een hoog (bijv. 20 V). Helling = (M2 − M1) / (A2 − A1), offset = M1 − helling × A1; het resultaat is echt = helling × meetwaarde + offset (M is de waarde van de multimeter, A die van de Arduino).
  4. Controleren: Controleer het resultaat na het kalibreren met een derde spanning in het midden van het bereik. Een zorgvuldig gebouwde Uno-voltmeter meet 0–25 V met minder dan 1% fout.

Een digitale voltmeter met een LCD

I2C 16x2 LCD-display
Dankzij de I2C-backpack sluit je de 16x2-LCD aan met slechts vier draden: GND, VCC, SDA en SCL.

Om de voltmeter onafhankelijk van de computer te maken, toon je de waarde gewoon op een I2C-LCD. Sluit GND van de LCD aan op GND, VCC op 5V, SDA op A4 en SCL op A5. Installeer de bibliotheek LiquidCrystal I2C (Frank de Brabander) via de Library Manager. Het adres van het display is meestal 0x27, of 0x3F bij sommige modules. De onderstaande code toont op de bovenste regel de actuele spanning en op de onderste regel de laagste en hoogste waarde sinds het inschakelen, zodat je ook de spanningsdip van een batterij kunt vangen terwijl een motor draait.

C++ (Arduino IDE)
1// LCD ekranlı dijital voltmetre (0-25 V, min/maks) / Digital voltmeter with LCD (0-25 V, min/max)
2// LCD: SDA -> A4, SCL -> A5, VCC -> 5V, GND -> GND; sensör S -> A0 / sensor S -> A0
3#include <Wire.h>
4#include <LiquidCrystal_I2C.h>
5
6LiquidCrystal_I2C lcd(0x27, 16, 2);   // adres 0x27 ya da 0x3F / address 0x27 or 0x3F
7
8const int SENSE_PIN = A0;
9const float VREF = 5.00;              // 5V pininde ölçülen / measured on the 5V pin
10const float RATIO = (30000.0 + 7500.0) / 7500.0;   // = 5,0
11const float CAL = 1.000;              // kalibrasyon katsayısı / calibration factor
12
13float vMin = 99.99;
14float vMax = 0.0;
15
16float readVoltage() {
17  analogRead(SENSE_PIN);
18  unsigned long sum = 0;
19  for (int i = 0; i < 32; i++) sum += analogRead(SENSE_PIN);
20  float v = (sum / 32.0) * VREF / 1024.0 * RATIO * CAL;
21  return v < 0.05 ? 0.0 : v;
22}
23
24void printField(float value) {
25  char buf[8];
26  dtostrf(value, 5, 2, buf);          // sabit genişlik: " 9.87" / fixed width: " 9.87"
27  lcd.print(buf);
28}
29
30void setup() {
31  lcd.init();
32  lcd.backlight();
33  lcd.print(F("Voltmetre 0-25V"));
34  delay(1000);
35  lcd.clear();
36}
37
38void loop() {
39  float v = readVoltage();
40  if (v > 0.5) {                      // boştayken min/maks güncelleme / don't update min/max when idle
41    if (v < vMin) vMin = v;
42    if (v > vMax) vMax = v;
43  }
44
45  lcd.setCursor(0, 0);
46  lcd.print(F("V: "));
47  printField(v);
48  lcd.print(F(" V      "));
49
50  lcd.setCursor(0, 1);
51  lcd.print(F("L"));
52  printField(vMin > 99.0 ? 0.0 : vMin);
53  lcd.print(F("  H"));
54  printField(vMax);
55  lcd.print(F("  "));
56  delay(300);
57}

De voltmeter bouwen met een ESP32

De ESP32 werkt op 3,3 V en zijn pinnen verdragen niet meer dan 3,6 V, dus gebruik voor 0–25 V een deler van 100 kΩ + 10 kΩ: 25 V op de ingang geeft 2,27 V op de pin. Sluit de deler aan op een van de ADC1-pinnen (GPIO 32–39); ADC2-pinnen werken niet zolang Wi-Fi aan staat. De ADC van de ESP32 is 12-bits, maar niet lineair aan de uiteinden: hij ziet onder 0,15 V nauwelijks iets en de fout neemt toe boven 2,5 V. De functie analogReadMilliVolts() gebruikt kalibratiegegevens die in de fabriek in de chip zijn geschreven en geeft een veel nauwkeuriger resultaat in millivolt dan de ruwe waarde. Om de resterende offset weg te nemen, past de code met de constanten GAIN en OFFSET de tweepuntskalibratie uit de vorige sectie toe.

C++ (Arduino IDE)
1// ESP32 voltmetre: 100k + 10k bölücü ile 0-25 V / ESP32 voltmeter: 0-25 V with a 100k + 10k divider
2// Kaynak + -> 100k -> GPIO 34 -> 10k -> GND, kaynak - -> GND / source + -> 100k -> GPIO 34 -> 10k -> GND
3const int SENSE_PIN = 34;                 // ADC1_CH6, Wi-Fi açıkken de çalışır / works with Wi-Fi on
4const float RATIO = (100000.0 + 10000.0) / 10000.0;   // = 11,0
5const float GAIN = 1.000;                 // iki noktalı kalibrasyon: eğim / two-point calibration: slope
6const float OFFSET = 0.00;                // iki noktalı kalibrasyon: kayma (V) / two-point calibration: offset (V)
7
8float readVoltage() {
9  uint32_t mv = 0;
10  for (int i = 0; i < 64; i++) {
11    mv += analogReadMilliVolts(SENSE_PIN);   // fabrika kalibrasyonlu mV / factory-calibrated mV
12  }
13  float vPin = mv / 64.0 / 1000.0;           // pindeki gerilim (V) / voltage at the pin (V)
14  float v = vPin * RATIO * GAIN + OFFSET;
15  return v < 0.10 ? 0.0 : v;
16}
17
18void setup() {
19  Serial.begin(115200);
20  analogReadResolution(12);                  // 0-4095
21}
22
23void loop() {
24  float v = readVoltage();
25  Serial.printf("Gerilim / Voltage: %.2f V\n", v);
26  delay(500);
27}

De voltmeter bouwen met een Raspberry Pi Pico (MicroPython)

Op de Raspberry Pi Pico zijn de analoge ingangen GP26, GP27 en GP28. Sluit dezelfde deler van 100 kΩ + 10 kΩ als bij de ESP32 aan op GP26. In MicroPython geeft read_u16() het 12-bits resultaat geschaald naar 0–65535 terug. De ADC-referentie van de Pico wordt gefilterd uit de 3,3V-lijn; meet voor een betere nauwkeurigheid met een multimeter tussen ADC_VREF (pin 35) en GND en vul de waarde in bij VREF. Er zit ook een bonus in de code: op de standaard Pico is GP29 (ADC3) verbonden met een interne deler die de VSYS-voedingsingang van het board door 3 deelt. Zonder extra onderdelen kun je dus ook de spanning lezen van de batterij die de Pico voedt. Op de Pico W en Pico 2 W wordt GP29 gedeeld met de draadloze chip, dus deze regel werkt op die boards niet rechtstreeks.

MicroPython
1# Raspberry Pi Pico voltmetre (MicroPython) / Raspberry Pi Pico voltmeter (MicroPython)
2# Kaynak + -> 100k -> GP26 -> 10k -> GND / source + -> 100k -> GP26 -> 10k -> GND
3from machine import ADC
4import time
5
6sense = ADC(26)            # GP26 = ADC0 (pin 31)
7vsys = ADC(29)             # GP29 = VSYS / 3 (yalnız standart Pico / standard Pico only)
8VREF = 3.3                 # ADC_VREF; multimetreyle ölçüp düzelt / measure and correct with a multimeter
9RATIO = (100000 + 10000) / 10000    # = 11.0
10GAIN = 1.000               # iki noktalı kalibrasyon: eğim / two-point calibration: slope
11OFFSET = 0.00              # iki noktalı kalibrasyon: kayma (V) / two-point calibration: offset (V)
12
13
14def pin_voltage(adc, samples=64):
15    total = 0
16    for _ in range(samples):
17        total += adc.read_u16()            # 0-65535
18    return total / samples * VREF / 65535  # pindeki gerilim / voltage at the pin
19
20
21while True:
22    v_in = pin_voltage(sense) * RATIO * GAIN + OFFSET
23    if v_in < 0.05:
24        v_in = 0.0
25    v_sys = pin_voltage(vsys) * 3          # VSYS = GP29 x 3
26    print("Giris / Input: {:.2f} V   VSYS: {:.2f} V".format(v_in, v_sys))
27    time.sleep(0.5)

Stroom toevoegen voor een wattmeter: ACS712 of INA219

ACS712-stroomsensormodule
De ACS712 meet stroom met het hall-effect en houdt de gemeten schakeling elektrisch gescheiden van de Arduino.

Voeg je stroommeting toe aan een voltmeter, dan krijg je ook het vermogen: P = V × I. Levert een batterij van 12 V 1,5 A, dan is het vermogen 18 W. Tel het vermogen over tijd op en je krijgt energie: een last van 18 W die 2 uur draait, verbruikt 36 Wh. Er zijn twee gangbare opties. De ACS712 heeft een analoge uitgang, meet ook wisselstroom en zorgt voor scheiding; hij wordt gewoon een tweede analoog kanaal op je bestaande voltmeter. De INA219 is een DC-vermogensmonitor die spanning en stroom in dezelfde chip met 12-bits nauwkeurigheid meet en via I2C communiceert; op zichzelf is hij een kant-en-klare wattmeter.

EigenschapSpanningsmodule + ACS712 (5A)INA219-module
Spanningsbereik0–25 V (bepaald door de deler)0–26 V (in de chip)
Stroombereik±5 A±3,2 A (met een shunt van 0,1 Ω)
StroomresolutieOngeveer 26 mA op een Uno0,1 mA
WisselstroomJaNee
AansluitingTwee analoge pinnenI2C (SDA, SCL), adres 0x40
Het best voorMotoren, stroom aan de netzijde en situaties waar scheiding nodig isKleine DC-vermogensmetingen zoals batterijen, zonnepanelen en USB-apparaten
C++ (Arduino IDE)
1// INA219 + I2C LCD ile wattmetre: V, A, W ve Wh / Wattmeter with INA219 + I2C LCD: V, A, W and Wh
2// Kaynak + -> INA219 VIN+ ; INA219 VIN- -> yük + ; yük - -> kaynak - -> Arduino GND
3// Source + -> INA219 VIN+ ; INA219 VIN- -> load + ; load - -> source - -> Arduino GND
4#include <Wire.h>
5#include <Adafruit_INA219.h>
6#include <LiquidCrystal_I2C.h>
7
8Adafruit_INA219 ina219;               // varsayılan adres 0x40 / default address 0x40
9LiquidCrystal_I2C lcd(0x27, 16, 2);
10
11float energyWh = 0.0;
12unsigned long lastMs = 0;
13
14void printField(float value, int width, int decimals) {
15  char buf[10];
16  dtostrf(value, width, decimals, buf);
17  lcd.print(buf);
18}
19
20void setup() {
21  Serial.begin(9600);
22  lcd.init();
23  lcd.backlight();
24  if (!ina219.begin()) {              // modül bulunamadı / module not found
25    lcd.print(F("INA219 yok!"));
26    while (true) delay(10);
27  }
28  // ina219.setCalibration_16V_400mA();  // küçük akımlar için daha hassas / finer for small currents
29  lastMs = millis();
30}
31
32void loop() {
33  float busV = ina219.getBusVoltage_V();           // VIN- ile GND arası / between VIN- and GND
34  float shuntMv = ina219.getShuntVoltage_mV();     // şönt üzerindeki düşüm / drop across the shunt
35  float loadV = busV + shuntMv / 1000.0;           // kaynağın gerilimi / source voltage
36  float currentA = ina219.getCurrent_mA() / 1000.0;
37  float powerW = loadV * currentA;
38
39  unsigned long now = millis();
40  energyWh += powerW * (now - lastMs) / 3600000.0; // W x saat = Wh / W x hours = Wh
41  lastMs = now;
42
43  lcd.setCursor(0, 0);
44  printField(loadV, 5, 2);  lcd.print(F("V "));
45  printField(currentA, 6, 3); lcd.print(F("A  "));
46  lcd.setCursor(0, 1);
47  printField(powerW, 6, 2); lcd.print(F("W "));
48  printField(energyWh, 6, 2); lcd.print(F("Wh"));
49
50  Serial.print(loadV, 2);    Serial.print(F(" V, "));
51  Serial.print(currentA, 3); Serial.print(F(" A, "));
52  Serial.print(powerW, 2);   Serial.print(F(" W, "));
53  Serial.print(energyWh, 3); Serial.println(F(" Wh"));
54  delay(500);
55}

De INA219 berekent de stroom uit de kleine spanningsval over de shuntweerstand van 0,1 Ω tussen VIN+ en VIN−, dus de module komt in serie aan de positieve kant van de bron (high side). Omdat de busspanning tussen VIN− en GND wordt gemeten, telt de code de spanningsval over de shunt erbij op om de echte spanning van de bron te krijgen. De standaardkalibratie is voor 32 V en 2 A; meet je maar enkele honderden milliampères, activeer dan de regel setCalibration_16V_400mA() om het bereik te verkleinen tot 400 mA en de nauwkeurigheid bij kleine stromen te verbeteren. Energie vind je door het huidige vermogen maal de verstreken tijd van elke lus op te tellen; het wordt gereset als je de Arduino uitschakelt, dus schrijf de waarde regelmatig naar EEPROM om hem te bewaren. Voor code die dezelfde berekening met de ACS712 doet, zie de sectie over vermogen en energie in het ACS712-artikel.

Batterijtester: een voltmeter die capaciteit meet (mAh)

18650 li-ioncel
De capaciteit die op een 18650-cel staat en de echte capaciteit verschillen vaak; de tester onthult de waarheid.

De spanning van een batterij vertelt je niet precies hoeveel energie er nog in zit; ook een volle maar versleten cel kan 4,1 V tonen. De manier om de echte capaciteit te vinden, is de batterij ontladen via een bekende belasting en de stroom over de tijd optellen: mAh = Σ (stroom × tijd). In deze schakeling schakelt een MOSFET de belasting aan en uit en meet de Arduino één keer per seconde de batterijspanning en de spanning onderaan de belastingsweerstand. Het verschil tussen die twee, gedeeld door de belastingsweerstand, geeft de stroom. Bereikt de batterij haar afschakelspanning, dan gaat de MOSFET uit en wordt het resultaat afgedrukt. Aan het begin vergelijkt de code ook de onbelaste en belaste spanning van de batterij om haar inwendige weerstand te berekenen; hoe hoger de inwendige weerstand, hoe meer de spanning van de batterij inzakt bij hoge stroom.

OnderdeelAansluitingOpmerking
Batterij +Naar A0 via 10 kΩ; ook de bovenkant van de belastingsweerstandPlaats 100 nF tussen A0 en GND
Belastingsweerstand van 4,7 ΩTussen batterij + en de drain van de MOSFETMinstens 5 W (liever 10 W) cementweerstand; bij een 18650 vloeit ongeveer 0,9 A en hij wordt heet
MOSFET drainOnderkant van de belastingsweerstand; naar A1 via 10 kΩPlaats ook 100 nF tussen A1 en GND
MOSFET sourceGNDDe min van de batterij wordt hier ook aangesloten
MOSFET gateNaar D9 via 220 Ω; naar GND via 100 kΩGebruik een logic-level MOSFET zoals de IRLZ44N
C++ (Arduino IDE)
1// Pil kapasite test cihazı: mAh, Wh ve iç direnç / Battery capacity tester: mAh, Wh and internal resistance
2// Pil + -> 10k -> A0 ; pil + -> 4,7 ohm yük -> MOSFET drain ; drain -> 10k -> A1
3// Battery + -> 10k -> A0 ; battery + -> 4.7 ohm load -> MOSFET drain ; drain -> 10k -> A1
4// MOSFET source -> GND ; gate <- D9 (220 ohm), gate -> 100k -> GND ; pil - / battery - -> GND
5const int BAT_PIN = A0;
6const int DRAIN_PIN = A1;
7const int LOAD_PIN = 9;
8const float VREF = 5.00;        // 5V pininde ölçülen / measured on the 5V pin
9const float R_LOAD = 4.7;       // yük direnci, multimetreyle ölç / load resistor, measure it
10const float CUTOFF_V = 3.00;    // Li-ion 3,00 V ; alkalin AA / alkaline AA 0,90 V
11
12float mAh = 0.0;
13float wh = 0.0;
14unsigned long lastMs = 0;
15unsigned long startMs = 0;
16bool running = false;
17
18float readPin(int pin) {
19  analogRead(pin);                          // kanal değişti, ilk okumayı at / discard first reading
20  unsigned long sum = 0;
21  for (int i = 0; i < 32; i++) sum += analogRead(pin);
22  return (sum / 32.0) * VREF / 1024.0;
23}
24
25float loadCurrent(float vBat) {
26  return (vBat - readPin(DRAIN_PIN)) / R_LOAD;   // dirençteki gerilim / R / voltage across R / R
27}
28
29void setup() {
30  Serial.begin(9600);
31  pinMode(LOAD_PIN, OUTPUT);
32  digitalWrite(LOAD_PIN, LOW);              // yük kapalı / load off
33  delay(1000);
34
35  float vOpen = readPin(BAT_PIN);           // yüksüz gerilim / open-circuit voltage
36  if (vOpen < CUTOFF_V + 0.1) {
37    Serial.println(F("Pil zayif ya da takili degil / Battery low or missing"));
38    return;
39  }
40  digitalWrite(LOAD_PIN, HIGH);             // yükü aç / load on
41  delay(1000);
42  float vLoad = readPin(BAT_PIN);
43  float amps = loadCurrent(vLoad);
44  Serial.print(F("Bos / Open: "));
45  Serial.print(vOpen, 3);
46  Serial.print(F(" V  Yuklu / Loaded: "));
47  Serial.print(vLoad, 3);
48  Serial.print(F(" V  Ic direnc / Internal R: "));
49  Serial.print((vOpen - vLoad) / amps * 1000.0, 0);
50  Serial.println(F(" mOhm"));
51
52  running = true;
53  startMs = lastMs = millis();
54}
55
56void loop() {
57  if (!running) return;
58  unsigned long now = millis();
59  if (now - lastMs < 1000) return;          // saniyede bir ölç / measure once per second
60
61  float hours = (now - lastMs) / 3600000.0;
62  lastMs = now;
63  float vBat = readPin(BAT_PIN);
64  float amps = loadCurrent(vBat);
65  mAh += amps * 1000.0 * hours;             // akım x süre / current x time
66  wh += vBat * amps * hours;
67
68  Serial.print((now - startMs) / 1000);
69  Serial.print(F(" s  "));
70  Serial.print(vBat, 3);
71  Serial.print(F(" V  "));
72  Serial.print(amps, 3);
73  Serial.print(F(" A  "));
74  Serial.print(mAh, 0);
75  Serial.println(F(" mAh"));
76
77  if (vBat <= CUTOFF_V) {                   // kesme gerilimi / cut-off voltage
78    digitalWrite(LOAD_PIN, LOW);
79    running = false;
80    Serial.print(F("Bitti / Done: "));
81    Serial.print(mAh, 0);
82    Serial.print(F(" mAh, "));
83    Serial.print(wh, 2);
84    Serial.println(F(" Wh"));
85  }
86}

Met een belasting van 4,7 Ω ontlaadt een 18650-cel met een stroom die rond 0,9 A begint en daalt naar 0,65 A; een gezonde cel van 2500 mAh testen duurt ongeveer drie uur. Stel bij li-ion de afschakelspanning nooit lager in dan 3,0 V, anders raakt de cel beschadigd. Test je een alkaline AA-batterij, stel CUTOFF_V dan in op 0.9 V; bij dezelfde belasting trekt die ongeveer 0,3 A. Je kunt het resultaat vergelijken met het label en met de batterijduurcalculator. De inwendige weerstand van een nieuwe 18650, op deze manier gemeten inclusief houder en draden, is meestal lager dan 0,15 Ω; een cel boven 0,3 Ω gebruik je beter niet voor toepassingen met hoge stroom. Wil je de capaciteitseenheden begrijpen, lees dan het artikel over mAh en batterijcapaciteit.

Sluit li-ioncellen nooit kort en leg de belastingsweerstand niet op een brandbaar oppervlak; een weerstand die ongeveer 4 W dissipeert, kan 80–100 °C bereiken. Laat de test niet onbeheerd draaien en test nooit opgezwollen of gedeukte cellen.

Projectideeën met een Arduino-voltmeter

  • Batterijmonitor en alarm bij lage spanning: Houd de 12V-batterij in een camper of zonnesysteem in de gaten en laat een buzzer klinken als de spanning onder 11,8 V zakt.
  • Zonnepaneellogger: Schrijf elke minuut de spanning van het paneel, en via de INA219 ook de stroom, naar een SD-kaart en bereken de dagopbrengst in Wh.
  • Display voor een labvoeding: Voeg een voltmeter en een INA219 toe aan de uitgang van een LM2596-module om er een labvoeding van te maken.
  • Batterijmonitoring op afstand: Stuur de spanning die je met een ESP32 meet via MQTT naar Home Assistant, of krijg een Telegram-bericht als hij laag is.
  • Controle van een 18650-pakket: Test de capaciteit van de cellen die je met een TP4056 oplaadt en combineer daarna cellen met een vergelijkbare capaciteit tot een gebalanceerd pakket.
  • Display met grote cijfers: Toon de waarde op een 7-segmentdisplay of een OLED-display in plaats van de LCD, groot genoeg om vanaf de andere kant van de kamer te lezen.

Veelgemaakte fouten en hoe je ze oplost

SymptoomWaarschijnlijke oorzaakOplossing
Meetwaarde is steeds 2–5% te hoog of te laagVREF is 5.00 V in de code, maar het board draait op een andere spanningMeet de 5V-pin en vul die in bij VREF, of gebruik de readVcc-methode
Waarde blijft heen en weer springenDe min van de bron is niet verbonden met de GND van de Arduino, of de lijn is ruisgevoeligVerbind een gemeenschappelijke GND, middel de metingen, plaats 100 nF bij de pin
Blijft bij hoge spanning op dezelfde waarde stekenDe pin bereikte de referentie en de ADC liep vast op 1023Vergroot het bereik door de delerverhouding te verhogen
Meetwaarde buigt bovenin af en is niet lineairLekstroom van de zener, of het bovenste bereik van de ADC van de ESP32Houd de pin onder 4 V (2,5 V op de ESP32) of gebruik een Schottky
Op de ESP32 is de meetwaarde 0 of bevroren zodra Wi-Fi startDe deler zit op een ADC2-pinGebruik een van de ADC1-pinnen, GPIO 32–39
INA219 toont negatieve stroomVIN+ en VIN− zijn verwisseldDe plus van de bron gaat naar VIN+, de plus van de belasting naar VIN−
LCD is verlicht maar toont geen tekstVerkeerd I2C-adres of verkeerde contrastinstellingZoek het adres met een I2C-scanner en draai aan de trimmer op de achterkant
Voordat je een nieuw gebouwde deler op de Arduino aansluit, schakel je de bron in en meet je de spanning op het middelpunt met een multimeter. Ligt die dicht bij wat je berekend hebt en onder de referentie, dan kun je hem veilig op de pin aansluiten. Deze controle van tien seconden voorkomt dat twee verwisselde weerstanden je board om zeep helpen.

Een Arduino-voltmeter is een van de beste manieren om te leren hoe meten werkt: met twee weerstanden, één formule en een beetje kalibratie krijg je resultaten die dicht bij die van een multimeter liggen; voeg een stroomsensor toe en het wordt een wattmeter, voeg een MOSFET toe en het wordt een batterijtester. In de BlueGrays-app laat het project "Digitale voltmeter met LCD" je dezelfde schakeling stap voor stap bouwen met een bedradingsschema en kant-en-klare code, en van daaruit kun je doorgaan naar projecten voor batterijmonitoring en vermogensmeting.

Veelgestelde vragen

Hoeveel volt kan een Arduino meten?

Je kunt maximaal 5 V (3,3 V op de ESP32 en Pico) rechtstreeks op een analoge pin aansluiten. Met een spanningsdeler kun je die grens zo ver verhogen als je wilt: 30 kΩ + 7,5 kΩ meet 25 V en 100 kΩ + 10 kΩ meet 50 V. Boven enkele tientallen volt worden veiligheid en isolatie echter belangrijk, en netspanning mag je nooit op deze manier meten.

Waarom meet mijn Arduino-voltmeter verkeerd?

De meest voorkomende reden is de referentiespanning: in de code staat 5.00 V, maar het board krijgt 4,7–4,9 V van USB, waardoor elke meting met dezelfde verhouding verschuift. Andere oorzaken zijn weerstanden van 5%, een ontbrekende gemeenschappelijke GND en een deler met te veel weerstand. De 5V-pin meten en in de code invullen, of de readVcc-methode gebruiken, en daarna de CAL-factor instellen met een bekende spanning lost het op.

Kan ik de 0–25 V-spanningssensormodule met een ESP32 gebruiken?

Dat kan, maar wel voorzichtig. Omdat de verhouding van de module 5 is, kan een ESP32 er maar tot 16,5 V mee meten; raak je 25 V aan, dan komt er 5 V op de pin en raakt de ESP32 beschadigd. Zelf een deler van 100 kΩ + 10 kΩ voor de ESP32 bouwen is zowel veiliger als nauwkeuriger, omdat de ADC dan in zijn lineaire gebied blijft.

Kan een Arduino 230 V wisselspanning van het net meten?

Nooit met een spanningsdeler: dat is mogelijk levensgevaarlijk en verbindt de Arduino met het net. Gebruik voor netspanning een module zoals de ZMPT101B, die een kleine transformator bevat en galvanische scheiding biedt. De uitgang is wisselspanning, dus de code berekent de RMS-waarde.

Kan een Arduino negatieve spanning meten?

Niet rechtstreeks; een analoge pin kan niet onder GND lezen en kan beschadigd raken. De oplossing is het signaal met weerstanden omhoog te schuiven richting 5 V: twee gelijke weerstanden tussen het signaal en 5 V maken bijvoorbeeld een middelpunt dat −5 V tot +5 V afbeeldt op 0–5 V. Voor nauwkeuriger werk gebruikt men een opamp-niveauverschuiver.

Kan een Arduino-voltmeter even nauwkeurig zijn als een multimeter?

Een gekalibreerde Uno-voltmeter meet 0–25 V met minder dan 1% fout, wat genoeg is voor de meeste hobbytoepassingen en dicht bij een goedkope multimeter komt. Door de 10-bits ADC is de resolutie beperkt tot ongeveer 24 mV op een bereik van 25 V. Voor betere resultaten kun je een externe 16-bits ADC zoals de ADS1115, weerstanden van 0,1% en een precisiereferentie gebruiken.

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
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
Een lcd-scherm gebruiken met I2C
AR-32Beginner
Premium

Een lcd-scherm gebruiken met I2C

Geef je Arduino een eigen scherm en laat hem zijn eerste bericht schrijven. Het lcd-scherm met twee regels sluit je aan met maar een paar draden; op de bovenste regel verschijnt een groet, daarna een…

4.8(53)
70
ESP32 I2C-LCD-display (16x2)
ES-17Gemiddeld
Premium

ESP32 I2C-LCD-display (16x2)

In dit project sluit je een 16x2-tekens-LCD via I2C aan op de ESP32 en toon je tekst. Met I2C bedien je het scherm met slechts 2 datapinnen (SDA en SCL), in plaats van de 6+ pinnen die een klassieke parallelle aansluiting verspilt. De code toont op de eerste regel een vaste tekst en op de tweede regel een teller die elke seconde oploopt. Bij het opstarten schrijft een I2C-scanner ook het adres van het display naar de Serial Monitor (meestal 0x27 of 0x3F).

4.9(23)
40
Afstand meten met een lcd-scherm
AR-31Gevorderd
Premium

Afstand meten met een lcd-scherm

Een gereedschap dat afstand meet zonder liniaal: beweeg je hand heen en weer voor de sensor en kijk hoe het getal verandert.

4.6(45)
59
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