Basis · 20 min leestijd

Wat is een ADC? Analoog-naar-digitaalomzetting met Arduino

Wat is een ADC en hoe werkt hij? Analoge en digitale signalen, 10- en 12-bits resolutie, analogReference, spanningsformule, ESP32 ADC2 en ruis verminderen.

Een ADC (analoog-digitaalomzetter) is de schakeling die een continu variërende spanning op een pin omzet in een getal waar de microcontroller mee kan werken. Elke keer dat je analogRead() aanroept op een Arduino, doet deze omzetter op de achtergrond het werk: de 10-bits ADC van de Arduino Uno zet een spanning tussen 0 en 5 V om in een getal van 0 tot 1023, terwijl de 12-bits ADC's van de ESP32 en de Raspberry Pi Pico ongeveer 0–3,3 V omzetten in een getal van 0 tot 4095. De ADC is de sleutel om alles met een analoge uitgang uit te lezen: potentiometers, LDR's, bodemvochtsensoren, joysticks en temperatuursensoren.

In deze gids leer je het verschil tussen analoge en digitale signalen, hoe een ADC stap voor stap een spanning in een getal omzet en hoe resolutie en referentiespanning je metingen beïnvloeden. Met echte getallen werken we de formule uit die een meting omrekent naar volt, het veranderen van het meetbereik met analogReference, de samplefrequentie en praktische manieren om ruis te verminderen. We behandelen ook de ADC van de ESP32, die aan de uiteinden niet lineair is, het ADC2-conflict met Wi-Fi en de verzwakkingsinstelling, het gebruik van de ADC van de Raspberry Pi Pico met MicroPython, en tot slot een korte introductie van de DAC, die het omgekeerde werk doet.

Een potentiometer uitlezen met de ADC
Een potentiometer is de makkelijkste manier om een ADC uit te proberen: de spanning op de middelste pin varieert tussen 0 V en de voedingsspanning terwijl je aan de knop draait.

Wat is het verschil tussen analoge en digitale signalen?

Een analoog signaal is een grootheid die binnen een bereik oneindig veel waarden kan aannemen en continu in de tijd verandert. Wanneer de spanning op de middelste pin van een potentiometer van 0 V naar 5 V gaat, doorloopt ze alle waarden daartussen, zoals 1,2 V, 1,21 V en 1,215 V; ook de geluidsgolf van een microfoon, de temperatuurafhankelijke spanning van een thermistor en de langzaam dalende spanning van een batterij zijn analoog. Een digitaal signaal kent daarentegen alleen bepaalde niveaus. In de wereld van de logica van de Arduino zijn dat er twee: LOW (0) en HIGH (1). Op de Uno beschouwt een digitale ingang alles onder ongeveer 1,5 V als LOW en alles boven 3,0 V als HIGH; het gebied daartussen is ongedefinieerd. Daarom kan digitalRead() op een batterij 3,7 V niet van 4,2 V onderscheiden en noemt beide HIGH. De kracht van een digitaal signaal is de ongevoeligheid voor ruis: 4,6 V en 5,0 V betekenen allebei hetzelfde HIGH. Om een analoge waarde te meten, op te slaan of mee te rekenen, moet je hem eerst omzetten in een getal, oftewel een digitale waarde, en het onderdeel dat dit doet is de ADC.

Wat is een ADC en hoe werkt hij?

Het werk van een ADC is samen te vatten in twee stappen. De eerste is sampling: op het moment van meten kopieert de omzetter de ingangsspanning naar een kleine condensator (de sample-and-hold-schakeling) en houdt die stabiel tot de omzetting klaar is; in de ATmega328P is deze condensator ongeveer 14 pF. De tweede is kwantisatie: de vastgehouden spanning wordt afgerond naar de dichtstbijzijnde stap op een schaal die de referentiespanning in gelijke stappen verdeelt, en het stapnummer wordt als resultaat teruggegeven. De ADC's in de Arduino Uno, ESP32 en Pico zijn allemaal van het type successieve benadering (SAR, Successive Approximation Register). Een SAR-ADC werkt als een raadspel met getallen: eerst probeert hij de helft van de referentie, zet de meest significante bit op 1 als de ingang hoger is en laat hem op 0 als hij lager is, probeert dan de helft van het resterende bereik en herhaalt dit voor elke bit. Zo vindt een 10-bits ADC met slechts 10 vergelijkingen de juiste stap uit 1024 mogelijkheden. Voor het gemak laat de tabel hieronder zien hoe een 4-bits ADC met een referentie van 5 V een ingang van 3,2 V meet:

StapGeteste bitVergelijkingsspanningIs de ingang (3,2 V) hoger?Resultaatbits
1Bit 3 (waarde 8)8 / 16 × 5 = 2,500 VJa → 11000
2Bit 2 (waarde 4)12 / 16 × 5 = 3,750 VNee → 01000
3Bit 1 (waarde 2)10 / 16 × 5 = 3,125 VJa → 11010
4Bit 0 (waarde 1)11 / 16 × 5 = 3,4375 VNee → 01010
ResultaatAlle bits klaar1010 = 10 → 10 × 5 / 16 = 3,125 VFout 0,075 V (één stap is 0,3125 V)1010

Het verschil van 0,075 V in het resultaat is de kwantisatiefout, en geen enkele ADC ontkomt eraan: als de echte spanning tussen twee stappen ligt, kan de ADC maar één van die twee teruggeven. De fout blijft kleiner dan één stap (LSB), dus hoe kleiner de stap, hoe fijner de meting. Omdat de sample-and-hold-condensator bij elke meting moet opladen, is ook de weerstand van de bron die de ADC aanstuurt belangrijk: de datasheet van de ATmega328P adviseert een uitgangsimpedantie van ongeveer 10 kΩ of minder, en een spanningsdeler met hogere weerstand kan de condensator niet op tijd opladen, waardoor de metingen gaan afwijken. Naast het SAR-type in microcontrollers bestaan er andere soorten ADC. Sigma-delta-ADC's zijn traag maar zeer nauwkeurig: de HX711 in weegprojecten biedt 24 bits en de via I2C aangesloten ADS1115-module 16 bits. Flash-ADC's gebruiken voor elke stap een aparte comparator; ze zijn extreem snel en zitten in oscilloscopen.

ADC-resolutie: wat betekenen 10 bits en 12 bits?

De resolutie geeft aan in hoeveel stappen de ADC zijn meetbereik verdeelt. Een N-bits ADC levert 2^N stappen: 10 bits betekent 1024 stappen (0–1023), 12 bits 4096 stappen (0–4095) en 16 bits 65.536 stappen. De spanning van één stap heet de LSB (least significant bit) en volgt uit LSB = Vref / 2^N. Op de Arduino Uno is dat 5 V / 1024 = 4,88 mV, en op de ESP32 en Pico 3,3 V / 4096 = 0,81 mV. De Uno ziet dus geen veranderingen kleiner dan 4,88 mV; met een LM35 die 10 mV/°C geeft, is dat een stap van ongeveer 0,5 °C. Maar resolutie en nauwkeurigheid zijn niet hetzelfde. Ruis, niet-lineariteit en referentiefout van een ADC maken sommige bits op papier nutteloos. De maat hiervoor is het effectieve aantal bits (ENOB): de ADC van de RP2040 in de Raspberry Pi Pico geeft een 12-bits resultaat, maar volgens de datasheet is het effectieve aantal bits 8,7. Laten we de ADC's van de drie boards naast elkaar zetten:

EigenschapArduino Uno R3ESP32 (WROOM-32)Raspberry Pi Pico
ADC-resolutie10 bits (0–1023)12 bits (0–4095)12 bits (geschaald naar 0–65535 in MicroPython)
Analoge ingangen6 (A0–A5; A0–A7 op de Nano)18 kanalen: 8 op ADC1, 10 op ADC23 pinnen (GP26–GP28) + VSYS/3 (GP29) + temperatuursensor
Standaardmeetbereik0–5 VOngeveer 0–3,1 V (11 dB verzwakking)0–3,3 V (ADC_VREF)
Eén stap (LSB)4,88 mVOngeveer 0,8 mV0,81 mV
ReferentieoptiesDEFAULT (5 V), INTERNAL (1,1 V), EXTERNAL (AREF)Verzwakking: 0, 2,5, 6 en 11 dBExterne referentie op de ADC_VREF-pin
SamplefrequentieOngeveer 10.000 metingen/s20 kHz – 2 MHz in continue modus (DMA)500.000 metingen/s in hardware
Opmerking over nauwkeurigheidAbsolute fout ±2 LSBNiet-lineair aan de uiteinden, kalibratie nodigENOB 8,7 bits, ongeveer 30 mV offset
Analoge uitgang (DAC)Geen (er wordt PWM gebruikt)2 kanalen, 8 bits (GPIO 25 en 26)Geen (er wordt PWM gebruikt)

Formule om een ADC-waarde om te rekenen naar spanning

Het getal dat de ADC teruggeeft betekent op zichzelf niets; om het om te rekenen naar een spanning gebruik je de referentiespanning en het aantal stappen: Spanning = ADC-waarde × Vref / 2^N. Op de Arduino Uno is dat V = waarde × 5.0 / 1024, dus als analogRead() 512 teruggaf, is de spanning op de pin 512 × 5 / 1024 = 2,50 V. De andere kant op vind je met waarde = V × 1024 / Vref welk getal bij een bepaalde spanning hoort: 3,3 V wordt op de Uno ongeveer 675. In veel voorbeelden zie je een deling door 1023 in plaats van 1024. De datasheet van de ATmega328P geeft de formule ADC = Vin × 1024 / Vref; de hoogste waarde, 1023, staat voor één stap onder Vref. Delen door 1023 laat de hoogste waarde precies 5,00 V tonen, maar verschuift elke waarde met ongeveer 0,1%. Dat verschil is kleiner dan de eigen fout van de ADC van ±2 LSB, dus beide werken; het gaat erom dat je binnen een project consequent bent. De echte grote foutbron is Vref zelf: de 5V-pin van een via USB gevoede Uno ligt vaak ergens tussen 4,7 en 5,1 V, en 5.0 in de formule zetten geeft tot 5% fout. Meet voor nauwkeurige metingen dus de 5V-pin met een multimeter en zet de echte waarde in je code. De enige analoge ingang (A0) van de ESP8266 is ook 10 bits; de chip zelf meet 0–1 V, en de ingebouwde spanningsdeler op boards als de NodeMCU en Wemos D1 Mini vergroot dat bereik tot ongeveer 0–3,2 V.

Board en instellingLeesbereikOmrekenen naar voltVoorbeeld
Arduino Uno / Nano (DEFAULT, 5 V)0–1023V = waarde × 5.0 / 1024768 → 3,75 V
Uno, analogReference(INTERNAL)0–1023V = waarde × 1.1 / 1024512 → 0,55 V
ESP32 (11 dB)0–4095Gekalibreerd: analogReadMilliVolts() / 1000; globaal: waarde × 3.3 / 40951650 mV → 1,65 V
Raspberry Pi Pico (read_u16)0–65535V = waarde × 3.3 / 6553532768 → 1,65 V
ESP8266 NodeMCU / Wemos D1 Mini (A0)0–1023V = waarde × 3.2 / 1024512 → 1,60 V

Een potentiometer aansluiten: Arduino, ESP32 en Pico

PotentiometerpinArduino UnoESP32Raspberry Pi Pico
Buitenste pin 15V3V33V3(OUT) (pin 36)
Middelste pin (signaal)A0GPIO 34 (ADC1_CH6)GP26 / ADC0 (pin 31)
Buitenste pin 2GNDGNDAGND (pin 33) of GND
Optionele ruiscondensator100 nF tussen A0 en GND100 nF tussen GPIO 34 en GND100 nF tussen GP26 en AGND
De analoge ingangen van de ESP32 en de Raspberry Pi Pico accepteren maximaal 3,3 V; als je de buitenste pin van de potentiometer op 5 V aansluit, of een sensor met een 5V-uitgang direct aansluit, kun je de pin blijvend beschadigen. Ook op de Uno mag je nooit meer dan de voedingsspanning (5 V) of minder dan 0 V op een ingang zetten; breng hogere spanningen omlaag met een spanningsdeler. Een analoge pin waar niets op is aangesloten en die zweeft, leest willekeurige waarden; dat is geen defect, de pin hangt gewoon "in de lucht".

Stap voor stap: je eerste ADC-meting met Arduino

  1. Bouw de schakeling: Sluit de buitenste pinnen van een potentiometer van 10 kΩ aan op 5V en GND, en de middelste pin op A0.
  2. Meet de 5V-pin: Meet met een multimeter de spanning tussen 5V en GND en vul die in bij de constante VREF in de code (bijv. 4.93).
  3. Upload de code: Open de onderstaande sketch in de Arduino IDE, kies je board en poort en upload hem.
  4. Open de Serial Monitor: Zet hem op 9600 baud en kijk hoe de ADC-waarde verandert tussen 0 en 1023 terwijl je aan de knop draait (details in de Serial Monitor-gids).
  5. Controleer: Meet met de multimeter tussen A0 en GND en vergelijk dit met de spanning op het scherm; het verschil moet rond 10–20 mV blijven.
C++ (Arduino IDE)
1// Potansiyometreyi ADC ile okuma / Reading a potentiometer with the ADC
2// Kenar bacaklar 5V ve GND'ye, orta bacak A0'a / Outer legs to 5V and GND, wiper to A0
3const int POT_PIN = A0;
4const float VREF = 5.0;      // 5V pininde ölçtüğün gerilim / voltage you measured on the 5V pin
5
6void setup() {
7  Serial.begin(9600);
8}
9
10void loop() {
11  int raw = analogRead(POT_PIN);             // 0-1023 arası sayı / number between 0-1023
12  float volts = raw * VREF / 1024.0;         // sayıyı volta çevir / convert the number to volts
13  int percent = map(raw, 0, 1023, 0, 100);   // yüzdeye ölçekle / scale to percent
14
15  Serial.print(F("ADC: "));
16  Serial.print(raw);
17  Serial.print(F("  Gerilim / Voltage: "));
18  Serial.print(volts, 3);
19  Serial.print(F(" V  Yuzde / Percent: "));
20  Serial.println(percent);
21  delay(200);
22}

analogRead() voltooit een meting in ongeveer 100 µs en geeft een geheel getal tussen 0 en 1023. De code rekent dit getal eerst met de formule om naar volt en daarna met map() naar een percentage. Omdat map() met gehele getallen rekent, laat het het decimale deel vallen; als je een decimaal resultaat nodig hebt, doe de berekening dan zelf met float. Dit is een ratiometrische meting: omdat de potentiometer en de ADC uit dezelfde 5 V worden gevoed, verandert de stand van de knop, en dus de ADC-waarde, niet als de voeding zakt naar 4,9 V; alleen de berekende spanning verandert. Hetzelfde geldt voor sensoren die via een deler worden gelezen, zoals LDR's en NTC's. Als je daarentegen de spanning van een batterij meet, of een sensor met een vaste mV-uitgang zoals de LM35, komt de echte waarde van Vref rechtstreeks in het resultaat terecht.

Referentiespanning en analogReference

De referentiespanning (Vref) is de top van de schaal van de ADC: als de ingangsspanning gelijk is aan of hoger dan Vref, blijft het resultaat steken op de maximale waarde (1023). Een lagere Vref verkleint het meetbereik maar maakt elke stap kleiner, zodat je kleine signalen fijner meet. Op de Arduino Uno kies je de referentie met de functie analogReference(). Met de optie INTERNAL wordt Vref 1,1 V en daalt één stap naar 1,07 mV; je kunt een LM35 (10 mV/°C) dan in stappen van ongeveer 0,1 °C uitlezen, maar in ruil daarvoor is niets boven 1,1 V, dus 110 °C, meetbaar. De interne referentie van 1,1 V kan zelf van chip tot chip variëren tussen 1,0 en 1,2 V, dus nauwkeurige projecten hebben eenmalig een kalibratie met een multimeter nodig. De eerste paar metingen na het wisselen van de referentie kunnen onnauwkeurig zijn, zoals ook de Arduino-documentatie vermeldt, dus een paar metingen weggooien na het omschakelen is een goede gewoonte. De referentie-instelling geldt bovendien voor alle analoge pinnen van het board tegelijk. De opties verschillen per board:

OptieReferentieBoardsWanneer gebruiken
DEFAULT5 V (3,3 V op 3,3V-boards)Uno, Nano, Mega, LeonardoSensoren die ratiometrisch zijn met de voeding, zoals potentiometers, LDR's en joysticks
INTERNAL1,1 V (ATmega328P); 2,56 V op de LeonardoUno, Nano, Leonardo (niet op de Mega)Laagspanningssensoren zoals de LM35
INTERNAL1V1 / INTERNAL2V561,1 V / 2,56 VAlleen MegaKleine signalen op de Mega
EXTERNALDe spanning op de AREF-pin (0–5 V)Uno, Nano, MegaJe eigen precisiereferentie gebruiken (bijv. 2,5 V of 4,096 V)
AR_INTERNALOngeveer 1,43 V (interne referentie van de chip)Uno R4 Minima en WiFiKleine signalen op de Uno R4
Als je een externe referentie op de AREF-pin hebt aangesloten, moet je analogReference(EXTERNAL) aanroepen vóór je analogRead() aanroept. Anders wordt de referentie die in de chip wordt opgewekt kortgesloten met de spanning op de AREF-pin en kan de microcontroller beschadigd raken. Als je tussen referenties wilt wisselen, sluit de externe spanning dan via een weerstand van 5 kΩ aan op AREF; omdat die met de interne weerstand van de pin van ongeveer 32 kΩ een deler vormt, moet je rekening houden met een iets lagere spanning op AREF (ongeveer 2,2 V bij 2,5 V). Zet nooit minder dan 0 V of meer dan 5 V op AREF.

Samplefrequentie: hoeveel metingen per seconde kan een ADC doen?

De samplefrequentie is het aantal metingen dat de ADC in één seconde kan doen. Op de Arduino Uno wordt de ADC-klok op 125 kHz gezet door 16 MHz door 128 te delen, en een omzetting duurt 13 klokcycli; daarom duurt analogRead() ongeveer 100 µs en kun je hooguit zo'n 10.000 metingen per seconde doen. Dat is ruim voldoende voor langzaam veranderende grootheden zoals temperatuur, licht of batterijspanning; vaak volstaan zelfs 10 metingen per seconde. Voor snelle signalen komt de regel van Nyquist kijken: om een signaal zonder verlies vast te leggen, moet je minstens twee keer zo snel samplen als zijn hoogste frequentie, en in de praktijk heeft 5–10 keer de voorkeur. Om 50 Hz-netbrom te zien heb je minstens 100 metingen/s nodig, en om spraak tot 4 kHz op te nemen minstens 8.000 metingen/s. Als je op de Uno snellere metingen nodig hebt, kun je de ADC-prescaler verlagen: met ADCSRA = (ADCSRA & 0xF8) | 0x04; in setup() wordt de prescaler 16, stijgt de ADC-klok naar 1 MHz en duurt analogRead() nog ongeveer 16 µs, ten koste van wat nauwkeurigheid. Op de ESP32 staan losse analogRead()-aanroepen tienduizenden metingen per seconde toe, en in continue modus met DMA (analogContinuous() in Arduino) kun je een frequentie tussen 20 kHz en 2 MHz kiezen; deze modus werkt alleen met ADC1-pinnen. De ADC van de Raspberry Pi Pico draait op een eigen klok van 48 MHz, rondt elke omzetting af in 96 cycli, oftewel 2 µs, en haalt 500.000 metingen per seconde; een MicroPython-lus kan dat niet bijhouden, en voor volle snelheid heb je de C SDK en DMA nodig.

ESP32-ADC: niet-lineariteit, het conflict tussen ADC2 en Wi-Fi, en verzwakking

Op papier meet de 12-bits ADC van de ESP32 vier keer fijner dan die van de Uno, maar in de praktijk zijn er drie dingen om op te letten. De eerste is niet-lineariteit: dicht bij 0 V leest de ADC van de ESP32 tot ongeveer 100–150 mV nog 0, en aan de bovenkant raakt hij verzadigd op 4095 voordat de ingang 3,3 V bereikt; ook de curve daartussen is geen perfecte rechte lijn. De tweede is variatie van de referentie: de interne referentie van de ESP32 is ontworpen op 1100 mV, maar volgens Espressif varieert die van chip tot chip tussen 1000 en 1200 mV, wat een fout van ongeveer ±9% in ongekalibreerde metingen betekent. Daarom schrijft Espressif tijdens de productie kalibratiegegevens in de eFuses van de chips. De Arduino-functie analogReadMilliVolts() gebruikt die gegevens om de ruwe waarde direct om te zetten in gekalibreerde millivolts, en is in de meeste gevallen veel nauwkeuriger dan analogRead() × 3.3 / 4095 uitrekenen. De derde is verzwakking (attenuation): de ADC-kern kan alleen tot ongeveer 1 V meten, dus hogere spanningen worden aan de ingang teruggeschaald door een instelbare verzwakker. De Arduino-standaard is 11 dB, waarmee je tot ongeveer 3,1 V kunt lezen, maar het nauwkeurige bereik dat Espressif voor deze instelling aanbeveelt is 150–2450 mV. Voor kleine signalen verbetert een lagere verzwakking zowel de nauwkeurigheid als de resolutie:

VerzwakkingArduino-constanteNauwkeurig bereikGebruik
0 dBADC_0db100–950 mVKleine signalen, fijnste meting
2,5 dBADC_2_5db100–1250 mVSensoruitgangen rond 1 V
6 dBADC_6db150–1750 mVSignalen van gemiddeld niveau
11 dB (standaard)ADC_11db150–2450 mV (metingen lopen door tot ongeveer 3,1 V)Potentiometers en 0–3,3V-sensoren
Op de ESP32 wordt ADC2 ook gebruikt door de Wi-Fi-driver. Zodra Wi-Fi is gestart, kun je de ADC2-pinnen (GPIO 0, 2, 4, 12, 13, 14, 15, 25, 26, 27) niet meer lezen; ESP-IDF geeft dan een timeoutfout (ESP_ERR_TIMEOUT) terug, en in huidige versies van de Arduino-core geeft analogRead() 0 terug. Sluit analoge sensoren in Wi-Fi-projecten altijd aan op ADC1-pinnen: GPIO 32, 33, 34, 35, 36 (VP) en 39 (VN). Hiervan zijn 34–39 alleen ingang en hebben ze geen interne pull-upweerstanden, wat ze ideaal maakt voor analoge metingen. GPIO 0, 2, 12 en 15 zijn bovendien boot- (strapping-)pinnen, dus ze zijn totaal ongeschikt voor analoge sensoren.
C++ (Arduino IDE)
1// ESP32 ADC: ham değer ve kalibre milivolt / ESP32 ADC: raw value and calibrated millivolts
2// Potansiyometre: 3V3, GND ve orta bacak GPIO 34 / Pot: 3V3, GND and wiper to GPIO 34
3const int POT_PIN = 34;      // ADC1_CH6, Wi-Fi açıkken de çalışır / ADC1_CH6, works with Wi-Fi on
4
5void setup() {
6  Serial.begin(115200);
7  analogReadResolution(12);                     // 0-4095 (varsayılan / default)
8  analogSetPinAttenuation(POT_PIN, ADC_11db);   // yaklaşık 3,1 V'a kadar / up to about 3.1 V
9}
10
11void loop() {
12  uint32_t rawSum = 0;
13  uint32_t mvSum = 0;
14  for (int i = 0; i < 16; i++) {                // 16 ölçümün ortalaması / average of 16 readings
15    rawSum += analogRead(POT_PIN);              // ham ADC değeri / raw ADC value
16    mvSum += analogReadMilliVolts(POT_PIN);     // eFuse kalibrasyonlu mV / eFuse-calibrated mV
17  }
18  float raw = rawSum / 16.0;
19  float naiveV = raw * 3.3 / 4095.0;            // basit formül / naive formula
20  float calibratedV = mvSum / 16.0 / 1000.0;    // kalibre edilmiş / calibrated
21
22  Serial.printf("Ham / Raw: %4.0f  Formul / Formula: %.3f V  Kalibre / Calibrated: %.3f V\n",
23                raw, naiveV, calibratedV);
24  delay(500);
25}

De code toont twee resultaten naast elkaar: de ruwe waarde omgerekend met de eenvoudige formule en de waarde die door analogReadMilliVolts() is gekalibreerd. Als je de potentiometer naar een van de uiteinden draait, zie je het verschil groeien, en helemaal onderaan, waar de formule 0.000 V toont, meet de multimeter nog steeds ongeveer 0,1 V. analogSetPinAttenuation() verandert de verzwakking voor één pin, terwijl analogSetAttenuation() hem voor alle pinnen verandert. De ESP32 is merkbaar ruisgevoeliger dan de Uno, vooral terwijl Wi-Fi zendt; Espressifs eigen advies is een condensator van 100 nF aan de ingang te zetten en meerdere samples te middelen, wat het gemiddelde van 16 metingen in de code doet. Nieuwere chips zoals de ESP32-S3 en ESP32-C3 gebruiken een geavanceerdere curve-fitting-kalibratie, maar pinnummers en ADC2-regels verschillen per model, dus kijk altijd in de pinout van je board (Pinout-tool). Hoe je een deler bouwt om spanningen boven 3,3 V te meten, leggen we uit in de gids over de spanningsdeler.

ADC op de Raspberry Pi Pico (MicroPython)

De Raspberry Pi Pico heeft drie analoge ingangen die je van buitenaf kunt gebruiken: GP26 (ADC0), GP27 (ADC1) en GP28 (ADC2). GP29 (ADC3) meet een derde van de VSYS-voedingsspanning op het board, en ADC4 is verbonden met de interne temperatuursensor van de chip. De MicroPython-functie read_u16() schaalt het 12-bits resultaat naar het bereik 0–65535 zodat dezelfde code op verschillende boards werkt, maar de echte resolutie blijft 4096 stappen. De RP2040 heeft geen aparte referentiespanning; hij gebruikt zijn eigen ADC-voeding als referentie. Op de Pico wordt deze voeding (ADC_VREF, pin 35) afgeleid van de uitgang van de 3,3V-schakelende regelaar (SMPS), gefilterd via een weerstand van ongeveer 200 Ω. De datasheet van het Raspberry Pi-board noemt drie gevolgen: de nauwkeurigheid van de 3,3 V is beperkt, de voeding is enigszins ruisig en de stroom die de ADC opneemt veroorzaakt een offset van ongeveer 30 mV. De oplossingen staan in hetzelfde document: zet GP23 hoog om de regelaar in zijn PWM-modus met minder rimpel te zetten, verbind een ongebruikt ADC-kanaal met AGND en trek de meting daarvan als offset af, en sluit voor veel betere nauwkeurigheid een 3,0V-referentie zoals de LM4040 aan tussen ADC_VREF en AGND (het meetbereik wordt dan 0–3,0 V). De ADC van de RP2040 staat er ook om bekend kleine sprongen (DNL-fouten) te hebben bij de waarden 512, 1536, 2560 en 3584; het middelen van meerdere metingen vermindert hun effect. Op de Pico W is GP23 gereserveerd voor de draadloze chip en wordt de regelaarmodus aangestuurd via WL_GPIO1, dus verwijder op een Pico W de GP23-regels in de onderstaande code.

MicroPython
1from machine import ADC, Pin
2import time
3
4pot = ADC(26)                 # GP26 = ADC0 (pin 31)
5chip_temp = ADC(4)            # dahili sıcaklık sensörü / internal temperature sensor
6VREF = 3.3                    # ADC_VREF; multimetreyle ölçüp düzelt / measure and correct with a multimeter
7
8# Yalnız Pico ve Pico 2 (W değil): SMPS PWM moduna, daha az gürültü / Plain Pico and Pico 2 only (not W): SMPS to PWM mode, less noise
9smps_mode = Pin(23, Pin.OUT)
10smps_mode.value(1)
11
12
13def read_average(adc, samples=16):
14    total = 0
15    for _ in range(samples):
16        total += adc.read_u16()           # 0-65535 (12 bit ölçeklenmiş / 12-bit scaled)
17    return total / samples
18
19
20while True:
21    raw = read_average(pot)
22    volts = raw * VREF / 65535            # sayıyı volta çevir / convert the number to volts
23    t_volts = read_average(chip_temp) * VREF / 65535
24    temp_c = 27 - (t_volts - 0.706) / 0.001721    # RP2040 veri sayfası formülü / RP2040 datasheet formula
25    print("ADC: {:5d}  {:.3f} V  Yonga / Chip: {:.1f} C".format(int(raw), volts, temp_c))
26    time.sleep(0.5)

Manieren om ADC-ruis te verminderen

Zelfs bij het meten van een stabiele spanning is het normaal dat de ADC-waarde een stap of twee schommelt; kwantisatie, rimpel op de voeding, interferentie die door lange draden wordt opgepikt en motoren of Wi-Fi-zenders in de buurt dragen er allemaal aan bij. Op de Uno wordt een schommeling van ±1–2 stappen als gezond beschouwd; veel meer wijst meestal op een probleem in de schakeling. Je kunt ruis zowel in hardware als in software bestrijden:

  • Voeg een condensator toe: Een keramische condensator van 100 nF tussen de analoge pin en GND filtert snelle storing weg en geeft de sample-and-hold-condensator bij bronnen met hoge weerstand een kant-en-klare lading.
  • Houd draden kort: Als de sensorkabel lang is, draai dan de signaal- en GND-draad om elkaar; leg motor- en relaisdraden uit de buurt van analoge lijnen.
  • Zorg voor goede aarding: Laat de terugstroom van belastingen met hoge stroom zoals motoren, relais en ledstrips niet door de GND-draad van de sensor lopen; verbind de massa's in één punt (steraarding).
  • Gebruik een schone referentie: USB-voeding is ruisig; voor absolute spanningsmetingen geeft de interne referentie of een externe referentie-IC stabielere resultaten.
  • Gooi de eerste meting na het wisselen van kanaal weg: De multiplexer aan de ADC-ingang kan lading van het vorige kanaal meedragen; gooi bij het om de beurt lezen van meerdere pinnen op elke pin één meting weg.
  • Middelen: Het middelen van N metingen vermindert willekeurige ruis met ongeveer √N; 16 metingen brengen de ruis terug tot een kwart.
  • Oversampling: Als je 4^n metingen optelt en het resultaat n bits naar rechts schuift, win je n extra bits resolutie; de som van 16 metingen 2 bits opschuiven maakt van de 10 bits van de Uno 12 bits. Hiervoor moet het signaal minstens één stap natuurlijke ruis hebben.
  • Mediaan- en exponentiële filters: Een mediaanfilter verwijdert plotselinge pieken door motoren, terwijl een exponentieel voortschrijdend gemiddelde (EMA) met heel weinig geheugen een vloeiende curve geeft.
C++ (Arduino IDE)
1// Ham, ortalama ve EMA filtreli ADC değerleri / Raw, averaged and EMA-filtered ADC values
2// Serial Plotter ile izle / Watch with the Serial Plotter
3const int SENSOR_PIN = A0;
4const float ALPHA = 0.1;     // EMA katsayısı (0-1) / EMA coefficient (0-1)
5float ema = 0;
6
7void setup() {
8  Serial.begin(115200);
9  analogRead(SENSOR_PIN);              // ilk okumayı at / discard the first reading
10  ema = analogRead(SENSOR_PIN);        // filtreyi başlat / seed the filter
11}
12
13void loop() {
14  int raw = analogRead(SENSOR_PIN);    // ham değer / raw value
15
16  long sum = 0;
17  for (int i = 0; i < 16; i++) {       // 16 ölçüm topla / sum 16 readings
18    sum += analogRead(SENSOR_PIN);
19  }
20  float average = sum / 16.0;          // ortalama (0-1023) / average (0-1023)
21
22  ema += ALPHA * (raw - ema);          // üstel hareketli ortalama / exponential moving average
23
24  Serial.print(F("ham:"));
25  Serial.print(raw);
26  Serial.print(F(" ortalama:"));
27  Serial.print(average);
28  Serial.print(F(" ema:"));
29  Serial.println(ema);
30  delay(20);
31}

Als je de code uploadt en de Serial Plotter in de Arduino IDE opent, zie je drie lijnen: de ruwe waarde schommelt, het gemiddelde van 16 metingen is duidelijk rustiger, en de EMA is de vloeiendste curve maar reageert iets later op veranderingen. De ALPHA-coëfficiënt kies je tussen 0 en 1: 0.1 betekent dat elke nieuwe meting voor 10% bijdraagt aan het resultaat, zodat grofweg de laatste 10 metingen invloed hebben; verhoog je hem, dan wordt de reactie sneller maar groeit de ruis. Welk filter je kiest hangt af van het signaal; een sterke EMA past bij een langzaam veranderende temperatuur, terwijl een kort gemiddelde beter is voor een joystick die snel moet reageren. In de gids over sensordata filteren vergelijken we voortschrijdende gemiddelden, mediaanfilters en hysterese met echte sensorvoorbeelden.

Een korte introductie van de DAC: van digitaal naar analoog

Een DAC (digitaal-analoogomzetter) doet het omgekeerde van een ADC: hij neemt een getal en maakt er een evenredige spanning van. Schrijf 0 naar een 8-bits DAC en je krijgt 0 V, schrijf 255 en je komt dicht bij de voedingsspanning, schrijf 128 en je krijgt ongeveer de helft ervan. De eenvoudigste DAC's worden gebouwd met een weerstandsladder die R-2R heet. Laten we hier een veelgemaakte verwarring ophelderen: analogWrite() op de Arduino Uno is geen DAC, het maakt PWM; de pin schakelt in werkelijkheid snel tussen 0 V en 5 V. Dat is prima voor ledhelderheid en motorsnelheid, maar als je echt een stabiele spanning nodig hebt, moet je een RC-laagdoorlaatfilter achter de PWM-uitgang zetten; de tijdconstante van het filter bereken je met de RC-tijdconstante-tool. Wat boards met een echte DAC betreft: de ESP32 heeft twee 8-bits DAC's op GPIO 25 en GPIO 26, te gebruiken met dacWrite(pin, value), terwijl de ESP32-S3 en ESP32-C3 geen DAC hebben. De Arduino Uno R4 heeft een 12-bits DAC op pin A0. Voor de Uno R3, Nano en Pico is de makkelijkste route de 12-bits MCP4725-module die via I2C wordt aangesloten. Met een DAC kun je geluid maken, sinus- of driehoeksgolven uitsturen en zelfs de DAC-uitgang op een ADC-ingang aansluiten om de ADC met bekende spanningen te testen:

C++ (Arduino IDE)
1// ESP32 DAC ile sinüs dalgası / Sine wave with the ESP32 DAC
2// Çıkış GPIO 25'te, osiloskopla izle / Output on GPIO 25, watch it with an oscilloscope
3const int DAC_PIN = 25;      // DAC1 = GPIO 25 (DAC2 = GPIO 26)
4const int STEPS = 64;        // bir periyottaki nokta sayısı / points per period
5uint8_t sineTable[STEPS];
6
7void setup() {
8  for (int i = 0; i < STEPS; i++) {
9    sineTable[i] = 128 + 127 * sin(2 * PI * i / STEPS);  // 1-255 arası tablo / table between 1-255
10  }
11}
12
13void loop() {
14  for (int i = 0; i < STEPS; i++) {
15    dacWrite(DAC_PIN, sineTable[i]);   // 0 → 0 V, 255 → yaklaşık 3,3 V / 0 → 0 V, 255 → about 3.3 V
16    delayMicroseconds(150);            // yaklaşık 100 Hz / roughly 100 Hz
17  }
18}

Projectideeën met de ADC

  • Digitale voltmeter: Meet 0–25 V met een spanningsdeler en toon het resultaat op een LCD; de stappen staan in de gids Arduino-voltmeter.
  • Automatisch nachtlampje: Lees de spanning van een LDR en zet de leds aan zodra het donker wordt.
  • Slimme plantenpot: Gebruik de analoge uitgang van een bodemvochtsensor om een pomp te laten draaien als de grond uitdroogt.
  • Robot met joystickbesturing: De twee assen van een joystick zijn twee aparte analoge ingangen; zet hun waarden om in motorsnelheid en -richting.
  • Stroommeter: Lees de stroomevenredige spanning van een ACS712 uit om te zien hoeveel stroom een apparaat opneemt.
  • Geluidsniveaumeter: Sample de analoge uitgang van een KY-038-geluidssensor snel en laat een ledbalk oplichten volgens de piekwaarde.
  • Batterijmeter: Meet de spanning in een project op batterijen en toon de resterende lading als percentage op een display.

Veelgemaakte fouten en hoe je ze oplost

SymptoomWaarschijnlijke oorzaakOplossing
De waarde springt willekeurig rond terwijl er niets is aangeslotenDe pin zweeftSluit de sensor aan; lees ongebruikte pinnen niet uit, of trek ze naar GND
De waarde blijft steken op 1023 (4095 op de ESP32)De ingang ligt boven de referentie, of INTERNAL is geselecteerdPas de referentie of verzwakking aan, breng hoge spanningen omlaag met een deler
Op de ESP32 geeft analogRead() 0 terug zodra Wi-Fi aan staatDe sensor zit op een ADC2-pinGebruik de ADC1-pinnen, GPIO 32–39
De ESP32 toont 0 bij kleine spanningen en 4095 bij groteDe ADC is aan de uiteinden niet lineairGebruik analogReadMilliVolts() en houd het signaal binnen 150–2450 mV
De berekende spanning wijkt 3–5% af van de multimeterVref is niet 5,00 V (USB-voeding)Meet de 5V-pin en zet die in VREF, of voeg een kalibratiefactor toe
Bij het om de beurt lezen van twee pinnen beïnvloeden de waarden elkaarMultiplexer en hoge bronweerstandGooi de eerste meting na het omschakelen weg, houd de bron onder 10 kΩ, voeg 100 nF toe
De waarden springen wanneer een motor of relais draaitRuis op de gedeelde GND-lijn, inzakkende voedingGeef de belastingen een eigen GND-terugleiding, gebruik condensatoren en een mediaanfilter
De metingen gingen fout na het aanleggen van een spanning op AREFAREF werd gebruikt zonder analogReference(EXTERNAL) aan te roepenSelecteer eerst EXTERNAL, of sluit aan op AREF via een weerstand van 5 kΩ
Na het selecteren van INTERNAL bereikt de potentiometer halverwege 1023De referentie van 1,1 V beïnvloedt alle analoge pinnenSchakel terug naar DEFAULT voordat je ratiometrische sensoren leest en gooi een paar metingen weg
Op de Pico ligt de meting boven 0, ook met de ingang op GNDADC-offset en ruis op ADC_VREFVerbind een kanaal met AGND, meet de offset en trek die af; zet GP23 hoog
De snelste manier om een ADC-schakeling te controleren is een bekende spanning meten. Sluit eerst de analoge ingang aan op GND en controleer of je een waarde dicht bij 0 ziet. Neem dan een AA-batterij waarvan je de spanning met een multimeter hebt gemeten en sluit de minpool aan op GND en de pluspool op de analoge pin: bij ongeveer 1,5 V zou je op de Uno rond 307 moeten zien, op de ESP32 rond 1500 mV met analogReadMilliVolts() en op de Pico rond 29.800 met read_u16(). Als het resultaat klopt, zijn je code en bedrading goed; zo niet, dan is het probleem hoogstwaarschijnlijk de referentiespanning of de gemeenschappelijke GND.

De ADC is de brug tussen de fysieke wereld en je code: als je zijn resolutie, referentiespanning en samplefrequentie kent, weet je ook wat elk getal op het scherm voorstelt en hoe ver je het kunt vertrouwen. Meet de referentie goed op de Uno, gebruik de ADC1-pinnen en analogReadMilliVolts() op de ESP32, houd op de Pico rekening met offset en ruis en maak het resultaat daarna rustiger met middelen en filters. In de BlueGrays-app vind je projecten die op analoge metingen zijn gebouwd, zoals lichtintensiteit lezen met een LDR, een digitale voltmeter met een LCD, temperatuur meten met een NTC en een servo en ledhelderheid aansturen met een potentiometer, elk met schakelschema's en code stap voor stap.

Veelgestelde vragen

Wat is een ADC en waar wordt hij voor gebruikt?

Een ADC (analoog-digitaalomzetter) is de schakeling die de spanning op een pin omzet in een getal dat de microcontroller kan verwerken. Hij wordt gebruikt om onderdelen met een analoge uitgang uit te lezen, zoals potentiometers, LDR's en temperatuur- en vochtsensoren. Op een Arduino laat de opdracht analogRead() deze omzetter draaien.

Wat is het verschil tussen analoge en digitale signalen?

Een analoog signaal kan elke waarde binnen een bereik aannemen en verandert continu, terwijl een digitaal signaal alleen uit bepaalde niveaus bestaat, LOW en HIGH op een Arduino. digitalRead() vertelt je alleen of een pin 0 of 1 is, terwijl analogRead() je als getal vertelt hoeveel spanning er staat.

Waarom geeft Arduino analogRead waarden van 0 tot 1023?

De ADC van de Arduino Uno is 10 bits en levert 2^10 = 1024 verschillende stappen, genummerd van 0 tot 1023. Een waarde van 0 staat voor 0 V en 1023 voor één stap onder de referentiespanning (meestal 5 V). De 12-bits ADC's in de ESP32 en Pico geven waarden van 0 tot 4095.

Hoe reken je een ADC-waarde om naar spanning?

Gebruik de formule spanning = ADC-waarde × referentiespanning / aantal stappen. Op de Arduino Uno is dat V = waarde × 5.0 / 1024; op de ESP32 geeft analogReadMilliVolts() direct gekalibreerde millivolts. Gebruik op de Pico V = waarde × 3.3 / 65535 voor de read_u16()-waarde van MicroPython.

Werken de ADC2-pinnen van de ESP32 met Wi-Fi?

Nee. Op de ESP32 gebruikt de Wi-Fi-driver ook de ADC2-eenheid, dus je kunt de ADC2-pinnen (GPIO 0, 2, 4, 12–15, 25–27) niet lezen terwijl Wi-Fi aan staat. Sluit analoge sensoren in Wi-Fi-projecten aan op de ADC1-pinnen (GPIO 32–39).

Wat is een DAC en hoe verschilt die van een ADC?

Een DAC (digitaal-analoogomzetter) doet het omgekeerde van een ADC: hij zet een getal om in een spanning. Een ADC gebruik je om de spanning van een sensor te meten, een DAC om een spanning te maken, zoals geluid of een signaal. De Arduino Uno heeft geen DAC en analogWrite() maakt PWM; de ESP32 heeft twee 8-bits DAC's op GPIO 25 en 26, en de Uno R4 heeft een 12-bits DAC op A0.

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
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
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
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
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
Servomotor aansturen met een potentiometer
AR-36Beginner
Premium

Servomotor aansturen met een potentiometer

Als je aan de knop van de potentiometer draait, draait de arm van de servomotor mee: het ene uiteinde van de knop staat voor nul graden, het andere voor een halve slag.

4.6(37)
53
Led bedienen met joystick
AR-59Gemiddeld
Premium

Led bedienen met joystick

Duw het stokje van de joystick helemaal in een richting en de led voor die richting gaat branden: er zijn vier kleuren voor rechts, links, omhoog en omlaag.

4.7(50)
67
ESP32 kleurenmixlamp (3 potmeters + RGB-led + OLED)
ES-36Gevorderd
Premium

ESP32 kleurenmixlamp (3 potmeters + RGB-led + OLED)

Een slimme kleurenmixlamp: draai aan 3 potmeters op de ESP32 en mix elke kleur die je wilt! Terwijl je aan de rode, groene en blauwe potmeter draait, verandert de RGB-led met gemeenschappelijke kathode meteen van kleur. Het SSD1306 OLED-display toont per kanaal de waarde van 0-255, vulbalken en de HEX-webkleurcode (zoals #FF8040) live.

4.7(6)
10