Arduino-sensorwaarden filteren: voortschrijdend gemiddelde, mediaan, EMA en Kalman
Arduino-sensorwaarden filteren: voortschrijdend gemiddelde, mediaanfilter, EMA, hysterese, samplefrequentie, filters vergelijken in de Serial Plotter en een introductie tot het Kalmanfilter.
Arduino-sensorwaarden filteren betekent dat je de onrustige, springende waarden van analogRead() of een afstandssensor omzet in een rustig, betrouwbaar getal waarmee je project kan werken. Je ziet 511, 513, 510, 514 in de Serial Monitor terwijl je de potentiometer niet aanraakt, een HC-SR04 die af en toe zomaar 3 cm of 400 cm meet, een nachtlampje dat flikkert op de grens tussen donker en licht: het zijn allemaal gezichten van hetzelfde probleem. Meestal is de sensor niet kapot; elektrische ruis, stapfouten van de ADC of een enkele slechte echo zijn in de meting geslopen. Het goede nieuws: een filter van een paar regels lost de meeste van deze problemen op.
In deze gids zie je eerst de soorten ruis en de eerste maatregelen aan de kant van de schakeling. Daarna programmeren we vijf methoden, te beginnen met de eenvoudigste: gemiddelde over meerdere metingen, het voortschrijdend gemiddelde, het mediaanfilter dat pieken verwijdert, het exponentiële filter (EMA) dat heel weinig geheugen nodig heeft en hysterese, die onstabiele drempels kalmeert. We zetten ze naast elkaar in de Serial Plotter van de Arduino IDE, bespreken hoe je de samplefrequentie kiest en geven een korte introductie tot het Kalmanfilter. De laatste onderdelen gaan over de ruisgevoelige ADC van de ESP32 en MicroPython-code voor de Raspberry Pi Pico.

Waarom zijn sensorgegevens ruisgevoelig?
Het is misleidend om meetfouten als één ding te zien. Verschillende soorten ruis vragen om verschillende filters, dus eerst moet je weten welk probleem je hebt. Daarvoor is het genoeg om een tijdje de ruwe waarden naar de Serial Monitor te printen en naar de getallen te kijken. Als de waarden rond een bepaald getal blijven schommelen, heb je willekeurige ruis; als de meeste metingen kloppen maar er af en toe een volkomen absurde waarde langskomt, heb je pieken; als de waarde langzaam wegkruipt, is het probleem geen ruis maar drift.
| Soort ruis | Hoe het eruitziet | Typische oorzaak | Geschikte oplossing |
|---|---|---|---|
| Willekeurige ruis | De waarde schommelt met ±2–10 stappen | Rimpel op de voeding, lange draden, eigen ruis van de ADC | Middelen, voortschrijdend gemiddelde, EMA |
| Piek | Een enkele waarde die ver ernaast zit | Gemiste echo bij de HC-SR04, los contact, storing door motoren | Mediaanfilter |
| Stapfout (kwantisatiefout) | De waarde wisselt tussen twee naburige getallen | ADC-resolutie (5 V / 1024 = 4,9 mV op de Uno) | Middelen, hysterese |
| Periodieke ruis | Regelmatige rimpel | 100 Hz flikkering van lampen, 50 Hz net | Middelen over veelvouden van 20 ms |
| Drift | De waarde verandert langzaam over minuten | Temperatuur, dalende batterijspanning | Kalibratie en een stabiele referentie, geen filter |
Eerst de schakeling: verminder ruis bij de bron
Een softwarefilter kan geen informatie terugbrengen die de schakeling nooit heeft vastgelegd, dus de eerste taak is het ruis moeilijker maken om binnen te komen. Houd analoge sensordraden kort en leg ze uit de buurt van de draden van stroomvretende onderdelen zoals motoren en relais. Een keramische condensator van 100 nF tussen de analoge ingang en GND, dicht bij de sensor geplaatst, absorbeert een groot deel van de snelle storing. De afsnijfrequentie van een RC-laagdoorlaatfilter van een weerstand en een condensator is f = 1 / (2πRC): 10 kΩ en 1 µF geven ongeveer 16 Hz, dus snellere veranderingen worden onderdrukt. Je kunt de waarden berekenen met de tool RC-tijdconstante. In motorprojecten helpt het ook om de GND van de sensoren via een apart pad naar het board te leiden, los van de GND van de motordriver, en het board te voeden met een stabiele voeding. Hoe de ADC werkt en hoe de referentiespanning daarop doorwerkt, leggen we uit in Wat is een ADC?.
Testopstelling
We proberen de code in dit artikel uit met drie eenvoudige sensoren. De potentiometer is ideaal om willekeurige ruis te zien, de LDR voor periodieke ruis en drempelbeslissingen, en de HC-SR04 voor pieken. Sluit de LDR aan tussen 5 V en de analoge pin en de weerstand van 10 kΩ tussen de analoge pin en GND, zodat de meetwaarde stijgt naarmate het lichter wordt. Meer details vind je in de artikelen over de LDR-lichtsensor en de potentiometer.
| Aansluiting | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| Loper van de potentiometer | A0 | GPIO 34 | GP26 (ADC0) |
| Middelpunt van de LDR + 10 kΩ-spanningsdeler | A1 | GPIO 35 | GP27 (ADC1) |
| HC-SR04 TRIG | D9 | GPIO 5 | GP2 |
| HC-SR04 ECHO | D10 | GPIO 18 (met spanningsdeler) | GP3 (met spanningsdeler) |
| LED of relais (hysteresevoorbeeld) | D8 | - | - |
| Voeding | Pot en LDR 5V, HC-SR04 5V | Pot en LDR 3V3, HC-SR04 5V | Pot en LDR 3V3, HC-SR04 VBUS |
1. Gemiddelde over meerdere metingen
Het eenvoudigste filter is een aantal metingen achter elkaar nemen en hun gemiddelde gebruiken. Willekeurige ruis duwt elke meting een andere kant op, dus in de som heft het zichzelf op. De statistiek heeft hier een regel voor: in het gemiddelde van N onafhankelijke metingen daalt de ruis met ongeveer √N. 4 samples halveren de ruis en 16 samples brengen hem terug tot een kwart; 64 samples brengen hem terug tot een achtste, maar duren vier keer zo lang. Op de Arduino Uno duurt één analogRead() ongeveer 112 µs, dus een gemiddelde van 16 samples is in minder dan 2 ms klaar. De enige nadelen van deze methode zijn dat de processor bij elke meting even bezig wordt gehouden en dat ze zwak is tegen pieken: als één van de 16 samples absurd is, bederft die ook het gemiddelde.
1const int POT_PIN = A0;
2
3// Art arda "adet" ölçüm al, ortalamasını döndür / take "adet" readings in a row, return the average
4int ortalamaOku(int pin, int adet) {
5 long toplam = 0; // taşmasın diye long / long to avoid overflow
6 for (int i = 0; i < adet; i++) {
7 toplam += analogRead(pin);
8 delayMicroseconds(100); // ölçümler arasında kısa ara / short gap between readings
9 }
10 return toplam / adet;
11}
12
13void setup() {
14 Serial.begin(115200);
15}
16
17void loop() {
18 int ham = analogRead(POT_PIN);
19 int ort4 = ortalamaOku(POT_PIN, 4);
20 int ort16 = ortalamaOku(POT_PIN, 16);
21 // Serial Plotter için etiket:değer biçimi / label:value format for the Serial Plotter
22 Serial.print("Ham:");
23 Serial.print(ham);
24 Serial.print(",Ort4:");
25 Serial.print(ort4);
26 Serial.print(",Ort16:");
27 Serial.println(ort16);
28 delay(20);
29}2. Voortschrijdend gemiddelde
Een voortschrijdend gemiddelde houdt het gemiddelde van de laatste N metingen bij en gooit bij elke nieuwe meting de oudste eruit en voegt de nieuwe toe. Zo neem je per lus één meting, maar profiteer je toch van een gemiddelde over N metingen. In plaats van elke keer N getallen op te tellen, houdt de code een variabele som bij: die trekt de waarde die eruit gaat af en telt de waarde die erin komt op. De berekening gaat dus even snel, hoe groot het venster ook is. De prijs van een voortschrijdend gemiddelde is vertraging: de uitvoer loopt ongeveer (N−1)/2 metingen achter op de echte waarde. Een venster van 10 metingen, elke 10 ms bemonsterd, loopt ongeveer 45 ms achter; voor een potentiometer of temperatuur maakt dat niet uit, maar in een snelle robot merk je het.
1const int POT_PIN = A0;
2const int PENCERE = 10; // son 10 ölçüm / last 10 readings
3
4int tampon[PENCERE]; // dairesel tampon / circular buffer
5int sira = 0;
6long toplam = 0;
7bool dolu = false;
8
9int hareketliOrtalama(int yeni) {
10 toplam -= tampon[sira]; // en eski değeri çıkar / remove the oldest value
11 tampon[sira] = yeni;
12 toplam += yeni; // yeni değeri ekle / add the new value
13 sira = (sira + 1) % PENCERE;
14 if (sira == 0) dolu = true;
15 return dolu ? toplam / PENCERE : toplam / sira; // ilk turda bölen küçük / smaller divisor at start
16}
17
18unsigned long sonOlcum = 0;
19
20void setup() {
21 Serial.begin(115200);
22}
23
24void loop() {
25 if (millis() - sonOlcum >= 10) { // 100 Hz örnekleme / 100 Hz sampling
26 sonOlcum = millis();
27 int ham = analogRead(POT_PIN);
28 int filtreli = hareketliOrtalama(ham);
29 Serial.print("Ham:");
30 Serial.print(ham);
31 Serial.print(",Hareketli:");
32 Serial.println(filtreli);
33 }
34}| Venster (N) | Ruisonderdrukking | Vertraging (één meting per 10 ms) | Goed voor |
|---|---|---|---|
| 4 | Ongeveer 2× | 15 ms | Regeling die snel moet reageren |
| 10 | Ongeveer 3× | 45 ms | Potentiometer, joystick, LDR |
| 32 | Ongeveer 5,7× | 155 ms | Temperatuur, luchtvochtigheid, batterijspanning |
| 100 | 10× | 495 ms | Zeer langzaam veranderende waarden, rustige weergave op een display |
3. Mediaanfilter: pieken verwijderen
Middelen is zwak tegen pieken. Als de HC-SR04 vier keer 50 cm meet en daarna één keer de echo mist en 0 meet, is het gemiddelde van de vijf 40 cm; die waarde is niet juist en laat de fout ook niet zien. Een mediaanfilter sorteert in plaats daarvan de laatste N metingen van klein naar groot en neemt de middelste. In hetzelfde voorbeeld is de gesorteerde lijst 0, 50, 50, 50, 50 en is de middelste waarde 50; de foute meting haalt het resultaat nooit. Een mediaanfilter met 5 elementen verwijdert tot 2 foute metingen achter elkaar volledig. De tweede fijne eigenschap van de mediaan is dat hij een plotselinge, echte verandering niet uitsmeert zoals een gemiddelde: als een obstakel echt dichterbij komt, springt de waarde binnen een paar metingen in een nette stap naar het nieuwe niveau in plaats van in een zachte curve. De code hieronder doet elke 60 ms een meting met de HC-SR04 en print de mediaan van de laatste 5. Meer details vind je in het artikel over de HC-SR04-afstandssensor.
1const int TRIG_PIN = 9;
2const int ECHO_PIN = 10;
3const int N = 5; // medyan penceresi, tek sayı olmalı / median window, must be odd
4
5int olcumler[N];
6int sira = 0;
7
8int mesafeOlc() {
9 digitalWrite(TRIG_PIN, LOW);
10 delayMicroseconds(2);
11 digitalWrite(TRIG_PIN, HIGH);
12 delayMicroseconds(10);
13 digitalWrite(TRIG_PIN, LOW);
14 unsigned long sure = pulseIn(ECHO_PIN, HIGH, 25000); // ~4 m zaman aşımı / ~4 m timeout
15 return sure / 58; // yankı yoksa 0 / 0 if no echo
16}
17
18int medyan() {
19 int kopya[N];
20 for (int i = 0; i < N; i++) kopya[i] = olcumler[i];
21 for (int i = 1; i < N; i++) { // eklemeli sıralama / insertion sort
22 int deger = kopya[i];
23 int j = i - 1;
24 while (j >= 0 && kopya[j] > deger) {
25 kopya[j + 1] = kopya[j];
26 j--;
27 }
28 kopya[j + 1] = deger;
29 }
30 return kopya[N / 2]; // ortadaki eleman / middle element
31}
32
33void setup() {
34 Serial.begin(115200);
35 pinMode(TRIG_PIN, OUTPUT);
36 pinMode(ECHO_PIN, INPUT);
37 for (int i = 0; i < N; i++) { // tamponu ilk ölçümlerle doldur / fill the buffer first
38 olcumler[i] = mesafeOlc();
39 delay(60);
40 }
41}
42
43void loop() {
44 int ham = mesafeOlc();
45 olcumler[sira] = ham;
46 sira = (sira + 1) % N;
47 Serial.print("Ham:");
48 Serial.print(ham);
49 Serial.print(",Medyan:");
50 Serial.println(medyan());
51 delay(60); // HC-SR04 için en az 60 ms / at least 60 ms for HC-SR04
52}4. Exponentieel filter (EMA): gladstrijken met weinig geheugen
Het exponentieel voortschrijdend gemiddelde (EMA) gebruikt geen buffer; het onthoudt alleen het vorige resultaat. Bij elke nieuwe meting beweegt het resultaat naar de meting toe met een klein deel van het verschil tussen beide: y = y + α × (x − y). Hierin is x de nieuwe meting, y de gefilterde waarde en α (alfa) een coëfficiënt tussen 0 en 1. Hoe kleiner α, hoe rustiger maar trager het filter. Het heet exponentieel omdat de invloed van elke meting exponentieel wegebt in de tijd. Het is de softwarevariant van het RC-laagdoorlaatfilter uit de elektronica. De tijdconstante van de EMA is ruwweg τ ≈ T / α (T is het meetinterval): bij een meting per 10 ms en α = 0,1 bereikt het filter 63 procent van een plotselinge verandering in ongeveer 100 ms en 95 procent in ongeveer 300 ms. De code bevat zowel een floating-pointversie als een integerversie die sneller draait op kleine boards zoals de Uno; de integerversie gebruikt α = 1/16 en een shift (>>) in plaats van een deling.
1const int LDR_PIN = A1;
2const float ALFA = 0.1; // 0-1 arası; küçük = daha sakin / 0-1; smaller = smoother
3
4float ema = -1; // henüz başlamadı / not started yet
5long emaX16 = -1; // tamsayılı EMA x16 / integer EMA times 16
6
7unsigned long sonOlcum = 0;
8
9void setup() {
10 Serial.begin(115200);
11}
12
13void loop() {
14 if (millis() - sonOlcum >= 10) {
15 sonOlcum = millis();
16 int ham = analogRead(LDR_PIN);
17
18 if (ema < 0) ema = ham; // ilk değerle başlat / start from the first reading
19 ema += ALFA * (ham - ema); // y = y + a(x - y)
20
21 if (emaX16 < 0) emaX16 = (long)ham << 4;
22 emaX16 += ham - (emaX16 >> 4); // alfa = 1/16, float yok / alpha = 1/16, no float
23
24 Serial.print("Ham:");
25 Serial.print(ham);
26 Serial.print(",EMA:");
27 Serial.print(ema, 1);
28 Serial.print(",EMA_int:");
29 Serial.println(emaX16 >> 4);
30 }
31}| α (alfa) | Vergelijkbaar venster (ongeveer) | Reactietijd 63% (bemonstering per 10 ms) | Karakter |
|---|---|---|---|
| 0,5 | 3 | 10–20 ms | Zeer snel, weinig gladstrijking |
| 0,2 | 9 | 50 ms | Snel, lichte gladstrijking |
| 0,1 | 19 | 100 ms | Gebalanceerd, een goed beginpunt voor de meeste sensoren |
| 0,05 | 39 | 200 ms | Rustig, traag |
| 0,01 | 199 | 1 s | Zeer rustig, alleen voor langzaam veranderende waarden |
Het "vergelijkbare venster" in de tabel is de ongeveer even grote omvang van een voortschrijdend gemiddelde dat dezelfde gladstrijking geeft en wordt berekend als N ≈ 2/α − 1. Het grootste voordeel van de EMA is het geheugen: een voortschrijdend gemiddelde van 100 elementen heeft 200 bytes RAM nodig, terwijl de EMA één variabele nodig heeft. Als je meerdere sensoren moet filteren in de 2 KB RAM van de Arduino Uno, maakt dat verschil uit. Het nadeel is dat hij even zwak is tegen pieken als middelen; een grote piek trekt het resultaat meerdere metingen lang mee.
Filters vergelijken in de Serial Plotter
Het verschil tussen filters is moeilijk te zien in getallen, maar in een grafiek in één oogopslag duidelijk. De code hieronder leest de potentiometer met 100 Hz, stuurt dezelfde meting langs vier verschillende paden en print ze allemaal in het formaat label:waarde. Om het verschil duidelijker te maken, voegt de code bij ongeveer 3 procent van de metingen een kunstmatige piek toe; verwijder deze regel in een echt project. In de grafiek zie je dat de mediaan de pieken volledig verwijdert, terwijl het voortschrijdend gemiddelde en de EMA ze omzetten in kleine bulten.
- Upload de code en sluit de Serial Monitor als die open staat; de Serial Monitor en de Serial Plotter kunnen niet tegelijk open zijn.
- Open in de Arduino IDE Tools › Serial Plotter of klik rechtsboven op het grafiekpictogram.
- Stel de snelheid rechtsonder in op 115200 baud.
- Draai de potentiometer langzaam en dan snel, en kijk hoe elke lijn reageert.
- Gebruik de vakjes naast de labels om lijnen aan en uit te zetten en twee filters direct te vergelijken.
1const int POT_PIN = A0;
2
3// Hareketli ortalama / moving average
4const int PENCERE = 10;
5int maTampon[PENCERE];
6int maSira = 0;
7long maToplam = 0;
8
9int hareketliOrtalama(int yeni) {
10 maToplam += yeni - maTampon[maSira];
11 maTampon[maSira] = yeni;
12 maSira = (maSira + 1) % PENCERE;
13 return maToplam / PENCERE;
14}
15
16// 5'lik medyan / median of 5
17int mdTampon[5];
18int mdSira = 0;
19
20int medyan5(int yeni) {
21 mdTampon[mdSira] = yeni;
22 mdSira = (mdSira + 1) % 5;
23 int a[5];
24 for (int i = 0; i < 5; i++) a[i] = mdTampon[i];
25 for (int i = 1; i < 5; i++) { // eklemeli sıralama / insertion sort
26 int d = a[i], j = i - 1;
27 while (j >= 0 && a[j] > d) { a[j + 1] = a[j]; j--; }
28 a[j + 1] = d;
29 }
30 return a[2];
31}
32
33// Üstel filtre / exponential filter
34float ema = 0;
35const float ALFA = 0.1;
36
37unsigned long sonOlcum = 0;
38
39void setup() {
40 Serial.begin(115200);
41 int ilk = analogRead(POT_PIN);
42 for (int i = 0; i < PENCERE; i++) maTampon[i] = ilk; // tamponları doldur / prefill buffers
43 maToplam = (long)ilk * PENCERE;
44 for (int i = 0; i < 5; i++) mdTampon[i] = ilk;
45 ema = ilk;
46 randomSeed(analogRead(A5));
47}
48
49void loop() {
50 if (millis() - sonOlcum < 10) return; // 100 Hz
51 sonOlcum = millis();
52
53 int ham = analogRead(POT_PIN);
54 if (random(100) < 3) { // TEST: %3 yapay sıçrama, projede sil / TEST: 3% fake spikes, remove in a project
55 ham = constrain(ham + random(-400, 400), 0, 1023);
56 }
57 ema += ALFA * (ham - ema);
58
59 Serial.print("Ham:");
60 Serial.print(ham);
61 Serial.print(",Hareketli:");
62 Serial.print(hareketliOrtalama(ham));
63 Serial.print(",Medyan:");
64 Serial.print(medyan5(ham));
65 Serial.print(",EMA:");
66 Serial.println(ema, 1);
67}In de grafiek verschijnen de labels in kleur rechtsboven. Als je tussen de labels geen komma en tussen label en waarde geen dubbele punt gebruikt, kan de Serial Plotter de lijnen niet goed scheiden. De oude plotter in Arduino IDE 1.8 ondersteunt labels maar beperkt; als je problemen krijgt, stuur dan alleen door komma's gescheiden getallen. Voor problemen met de seriële poort en de baudrate kun je het artikel Arduino Serial Monitor bekijken.
5. Hysterese: beslissingen die bij de drempel flikkeren voorkomen
Een filter kalmeert de waarde, maar lost het beslissingsprobleem op zichzelf niet op. Een nachtlampje dat zegt "zet de lamp aan als de lichtwaarde onder 350 komt" schakelt in de schemering meerdere keren per seconde aan en uit doordat de waarde tussen 349 en 351 zwalkt. Dat slijt de contacten van een relais snel. De oplossing is hysterese: je gebruikt twee aparte drempels voor aan- en uitschakelen. De lamp gaat bijvoorbeeld aan als de waarde onder 300 zakt, maar de waarde moet boven 400 komen om hem uit te zetten. De "dode zone" van 100 stappen daartussen voorkomt dat kleine schommelingen de beslissing veranderen. De code hieronder combineert hysterese met een EMA en een korte bevestigingstijd: de voorwaarde moet 1 seconde ononderbroken gelden, zodat ook een voorbijgaande schaduw of een momentje koplampen de beslissing niet verandert.
1const int LDR_PIN = A1;
2const int LAMBA_PIN = 8; // LED ya da röle modülü / LED or relay module
3const int YAK_ESIK = 300; // bunun altı karanlık / below this is dark
4const int SONDUR_ESIK = 400; // bunun üstü aydınlık / above this is bright
5const unsigned long ONAY_MS = 1000; // koşul 1 sn sürmeli / condition must last 1 s
6
7float ema = -1;
8bool lambaAcik = false;
9unsigned long kosulBasladi = 0;
10bool kosulVar = false;
11
12void setup() {
13 Serial.begin(115200);
14 pinMode(LAMBA_PIN, OUTPUT);
15}
16
17void loop() {
18 int ham = analogRead(LDR_PIN);
19 if (ema < 0) ema = ham;
20 ema += 0.05 * (ham - ema); // yavaş EMA / slow EMA
21
22 // Durum değiştirmek için hangi koşul gerekiyor? / which condition flips the state?
23 bool degistir = lambaAcik ? (ema > SONDUR_ESIK) : (ema < YAK_ESIK);
24
25 if (degistir) {
26 if (!kosulVar) {
27 kosulVar = true;
28 kosulBasladi = millis(); // koşul şimdi başladı / condition just started
29 } else if (millis() - kosulBasladi >= ONAY_MS) {
30 lambaAcik = !lambaAcik; // 1 sn sürdü, kararı değiştir / lasted 1 s, flip the decision
31 digitalWrite(LAMBA_PIN, lambaAcik ? HIGH : LOW);
32 kosulVar = false;
33 }
34 } else {
35 kosulVar = false; // koşul bozuldu, sayacı sıfırla / condition broke, reset the timer
36 }
37
38 Serial.print("EMA:");
39 Serial.print(ema, 0);
40 Serial.print(",Yak:");
41 Serial.print(YAK_ESIK);
42 Serial.print(",Sondur:");
43 Serial.print(SONDUR_ESIK);
44 Serial.print(",Lamba:");
45 Serial.println(lambaAcik ? 600 : 100); // grafikte görünsün / visible on the plot
46 delay(10);
47}Bekijk voordat je de drempels instelt de waarden van de ruimte over de dag in de Serial Plotter. De dode zone moet minstens twee tot drie keer breder zijn dan de schommeling van de gefilterde waarde. Dezelfde methode wordt gebruikt in thermostaten (bijvoorbeeld de verwarming uit bij 22 °C en aan bij 20 °C), in pompen van watertanks en in batterijbeveiligingen. Het ontdenderen van knoppen is eigenlijk ook een soort bevestigingstijd; de details staan in Hoe sluit je een knop aan.
Hoe kies je de samplefrequentie
Om een filter goed te laten werken, moet de sensor met de juiste snelheid worden uitgelezen. Lees je te langzaam, dan mis je snelle veranderingen; lees je te snel, dan geeft de sensor steeds dezelfde waarde terug of is hij helemaal niet klaar. De basisregel is de Nyquist-regel: bemonster minstens twee keer zo snel als de snelste verandering die je wilt volgen; in de praktijk is 5–10 keer veiliger. Sommige sensoren hebben ook een eigen ondergrens en sneller uitlezen levert niets op. Als lichtflikkering ertoe doet: op een net van 50 Hz flikkeren lampen 100 keer per seconde. De makkelijkste manier om deze flikkering bij een LDR of een andere analoge sensor te onderdrukken, is metingen met gelijke tussenpozen te nemen over een periode die een veelvoud van 20 ms is en die te middelen; doordat het venster hele netperioden beslaat, heft de flikkering zichzelf op.
| Sensor | Aanbevolen leesinterval | Opmerking |
|---|---|---|
| DHT11 / DHT22 | 1 s / 2 s | Vaker uitlezen geeft dezelfde waarde of een fout terug |
| DS18B20 (12-bit) | 750 ms | Dat is de conversietijd |
| HC-SR04 | Minstens 60 ms | Wacht tot de vorige echo is weggestorven |
| Potentiometer, joystick | 10–20 ms | 50–100 Hz is ruim voldoende voor menselijke beweging |
| LDR (om lampflikkering te onderdrukken) | Elke 1 ms gedurende 20 ms, daarna middelen | De 50 Hz-netflikkering heft zichzelf op |
| MPU6050 | 5–10 ms | Een gangbaar bereik voor bewegingsmeting met 100–200 Hz |
Een korte introductie tot het Kalmanfilter
Het Kalmanfilter houdt rekening met hoe ruisgevoelig de meting is en hoe snel de echte waarde kan veranderen, en past zijn eigen versterking aan. In de eenvoudigste eendimensionale vorm heeft het twee instellingen: R is de variantie van de meetruis (hoeveel de sensor schommelt); Q is de procesruis (hoe snel je verwacht dat de echte waarde verandert). Bij elke stap vergroot het filter eerst zijn onzekerheid met Q, berekent dan de versterking K = P / (P + R) en beweegt zijn schatting met het deel K naar de meting toe. Als de meting ruisgevoelig is (grote R), is K klein en vertrouwt het filter de meting minder; als de waarde naar verwachting snel verandert (grote Q), wordt K groter en reageert het filter snel. Een opvallend resultaat: als Q en R vast zijn, settelt K na een tijdje op een constante en wordt het eendimensionale Kalmanfilter in feite een EMA. De echte kracht van Kalman komt naar voren als hij meerdere grootheden samen schat, bijvoorbeeld door versnellingsmeter- en gyroscoopgegevens te combineren om een kantelhoek te vinden. Zijn eenvoudigere neef, het complementaire filter, vind je in het artikel over de MPU6050.
1const int POT_PIN = A0;
2
3struct Kalman1D {
4 float q; // süreç gürültüsü / process noise
5 float r; // ölçüm gürültüsü (varyans) / measurement noise (variance)
6 float p; // tahminin belirsizliği / estimate uncertainty
7 float x; // tahmin / estimate
8 bool ilk;
9};
10
11Kalman1D kf = {0.05, 9.0, 1.0, 0.0, true}; // r = 9: yaklaşık ±3 basamak titreşim / about ±3 counts of jitter
12
13float kalmanGuncelle(Kalman1D &k, float olcum) {
14 if (k.ilk) { k.x = olcum; k.ilk = false; return k.x; }
15 k.p += k.q; // 1. tahmin: belirsizlik artar / predict: uncertainty grows
16 float kazanc = k.p / (k.p + k.r); // 2. Kalman kazancı / Kalman gain
17 k.x += kazanc * (olcum - k.x); // 3. ölçüme doğru düzelt / correct toward the measurement
18 k.p *= (1.0 - kazanc); // 4. belirsizlik azalır / uncertainty shrinks
19 return k.x;
20}
21
22void setup() {
23 Serial.begin(115200);
24}
25
26void loop() {
27 int ham = analogRead(POT_PIN);
28 float tahmin = kalmanGuncelle(kf, ham);
29 Serial.print("Ham:");
30 Serial.print(ham);
31 Serial.print(",Kalman:");
32 Serial.println(tahmin, 1);
33 delay(10);
34}R is makkelijk te schatten: neem 100 ruwe metingen zonder de potentiometer aan te raken en kijk hoe wijd de waarden uitgespreid liggen. Als ze ongeveer ±3 stappen rond het gemiddelde schommelen, is de standaarddeviatie ongeveer 3 en de variantie ongeveer 9. Vind Q door te experimenteren: een kleine Q (0,001) geeft een zeer rustige maar trage uitvoer, een grote Q (1) een snelle maar onrustigere. Kies als beginpunt een Q tussen 1 en 10 procent van R en stem die fijn af in de Serial Plotter terwijl je aan de potentiometer draait.
ADC-ruis en filteren op de ESP32
De 12-bit ADC van de ESP32 lost fijnere stappen op dan die van de Arduino Uno, maar is ruisgevoeliger en niet lineair, vooral aan de uiteinden van 0–0,1 V en 3,1–3,3 V. Met Wi-Fi aan neemt de ruis verder toe. Twee dingen maken het leven makkelijker: gebruik analogReadMilliVolts(), dat de fabrieksKalibratie van de chip toepast in plaats van een ruwe waarde terug te geven, en middel 16–64 samples per meting voordat je een EMA toepast. De code hieronder leest de potentiometer in deze twee stappen; sluit de sensor in projecten die Wi-Fi gebruiken altijd aan op de ADC1-pins GPIO 32–39.
1const int POT_PIN = 34; // ADC1 pini, Wi-Fi ile çalışır / ADC1 pin, works with Wi-Fi
2const int ORNEK = 32; // her ölçümde 32 örnek / 32 samples per reading
3const float ALFA = 0.15;
4
5float ema = -1;
6
7int millivoltOku() {
8 uint32_t toplam = 0;
9 for (int i = 0; i < ORNEK; i++) {
10 toplam += analogReadMilliVolts(POT_PIN); // kalibre mV / calibrated mV
11 }
12 return toplam / ORNEK;
13}
14
15void setup() {
16 Serial.begin(115200);
17 analogReadResolution(12); // 0-4095
18}
19
20void loop() {
21 int ham = analogRead(POT_PIN); // karşılaştırma için tek ham ölçüm / single raw reading for comparison
22 int mv = millivoltOku();
23 if (ema < 0) ema = mv;
24 ema += ALFA * (mv - ema);
25 Serial.printf("Ham:%d,mV:%d,EMA_mV:%.1f\n", ham, mv, ema);
26 delay(20);
27}Filteren met de Raspberry Pi Pico en MicroPython
Op de Raspberry Pi Pico geeft ADC.read_u16() een waarde tussen 0 en 65535, maar de echte resolutie van de ADC is 12 bits en de onderste bits zijn ruisgevoelig. In MicroPython maakt de functie sorted() de mediaan heel eenvoudig, en een lijst plus een lopende som is genoeg voor een voortschrijdend gemiddelde. De code hieronder leest de potentiometer met 100 Hz en print de uitvoer van drie filters in een formaat dat Thonny kan tekenen in zijn venster View › Plotter.
1from machine import ADC
2import time
3
4pot = ADC(26) # GP26 = ADC0
5
6PENCERE = 10
7tampon = [pot.read_u16()] * PENCERE # hareketli ortalama tamponu / moving average buffer
8toplam = sum(tampon)
9sira = 0
10son5 = tampon[:5] # medyan için son 5 değer / last 5 values for the median
11ema = float(tampon[0])
12ALFA = 0.1
13
14while True:
15 ham = pot.read_u16()
16
17 toplam += ham - tampon[sira] # hareketli ortalama / moving average
18 tampon[sira] = ham
19 sira = (sira + 1) % PENCERE
20 hareketli = toplam // PENCERE
21
22 son5.pop(0) # medyan / median
23 son5.append(ham)
24 medyan = sorted(son5)[2]
25
26 ema += ALFA * (ham - ema) # üstel filtre / exponential filter
27
28 print("Ham:", ham, "Hareketli:", hareketli, "Medyan:", medyan, "EMA:", int(ema))
29 time.sleep_ms(10)De plotter van Thonny toont de getallen op elke regel als aparte lijnen en gebruikt de tekst voor de getallen als label. MicroPython draait langzamer dan Arduino, dus duw de filters niet naar zeer hoge frequenties; rond 100 Hz met kleine vensters draait comfortabel op de Pico. Als MicroPython nieuw voor je is, begin dan met het artikel MicroPython-basis.
Welk filter kies je?
| Situatie | Voorgesteld filter | Waarom? |
|---|---|---|
| Een potentiometer, joystick of analoge sensor schommelt | Voortschrijdend gemiddelde of EMA (α = 0,1–0,2) | Eenvoudig, snel, genoeg gladstrijking |
| Er komt af en toe een absurde waarde binnen (HC-SR04, doorstroomsensor) | Mediaan over 3 of 5 punten | Verwijdert de incidentele fout volledig |
| Zowel pieken als schommelingen | Eerst mediaan, dan EMA | Lost de twee problemen na elkaar op |
| Heel weinig RAM, veel sensoren | Integer-EMA | Eén variabele per sensor |
| Een aan/uit-beslissing flikkert bij de drempel | Hysterese en een bevestigingstijd | Lost het beslissingsprobleem op; een filter alleen is niet genoeg |
| Rimpel van lampen of het net | Gelijkmatig gemiddelde over 20 ms | Beslaat een hele periode van 50 Hz |
| Meerdere sensoren combineren (kanteling, positie) | Kalmanfilter of complementair filter | Combineert de sterke punten van elke sensor |
Veelgemaakte fouten en oplossingen
| Symptoom | Waarschijnlijke oorzaak | Oplossing |
|---|---|---|
| De gefilterde waarde reageert veel te laat | Het venster is te groot of α te klein | Verklein het venster of verhoog α; reken de vertraging uit met de tabellen |
| Het voortschrijdend gemiddelde klimt bij het opstarten langzaam vanaf nul | De buffer begint gevuld met nullen | Vul de buffer vooraf met de eerste meting, of deel door het aantal tot hij vol is |
| Het gemiddelde loopt bij 64 samples helemaal uit de hand | De int-som is overgelopen (64 × 1023 = 65.472 > 32.767) | Maak de somvariabele een long |
| Het mediaanfilter verandert niets | Het venster is 2 of een even getal, of de pieken komen achter elkaar | Gebruik een oneven venster (3, 5, 7) dat groter is dan het aantal pieken achter elkaar |
| Lijnen in de Serial Plotter zijn samengevoegd of hebben allemaal één kleur | Verkeerd labelformaat | Gebruik label:waarde met komma's ertussen en sluit de regel af met println |
| De EMA-waarde verandert nooit | Integerdeling: 1/10 geschreven in plaats van 0.1 | Schrijf de coëfficiënt als float (0.1) of gebruik de integer-EMA-formule |
| Waarden schommelen nog steeds ondanks het filter | Het probleem is geen ruis maar drift of een zwakke voeding | Controleer de voeding, voeg een condensator van 100 nF toe en kalibreer |
Sensorwaarden filteren is de goedkoopste manier om metingen betrouwbaar te maken: je hebt geen extra onderdelen nodig en een paar regels code laten je projecten stabieler draaien. Nu je weet hoe je middelen, het voortschrijdend gemiddelde, de mediaan, de EMA en hysterese samen gebruikt, heb je onrustige displays, valse alarmen en ratelende relais achter je. In de BlueGrays-app kun je projecten ontdekken zoals licht meten met een LDR, een nachtlampje, afstand meten met de HC-SR04, een parkeersensor en een hoogtemeter, met stap-voor-stap schakelschema's en kant-en-klare code, en zelf de resultaten zien door deze filters eraan toe te voegen.
Veelgestelde vragen
Waarom blijven sensorwaarden op Arduino veranderen?
Bij analoge metingen verschuiven rimpel op de voeding, lange draden, motoren in de buurt en de eigen ruis van de ADC de waarde met een paar stappen. Dat is normaal en betekent niet dat de sensor kapot is. Een condensator van 100 nF op de analoge ingang en een middel- of EMA-filter in software maken de waarden rustiger.
Wat is een voortschrijdend gemiddelde?
Een voortschrijdend gemiddelde is het gemiddelde van de laatste N metingen; bij elke nieuwe meting wordt de oudste waarde verwijderd en de nieuwe toegevoegd. Het vermindert de ruis met ongeveer √N, maar vertraagt de uitvoer met (N−1)/2 metingen. Op Arduino kost het maar een paar regels met een circulaire buffer en één somvariabele.
Wat is het verschil tussen een mediaanfilter en een gemiddelde?
Een gemiddelde houdt rekening met elke waarde, dus één absurde meting bederft het resultaat. Een mediaanfilter sorteert de waarden en neemt de middelste, dus het negeert incidentele foute metingen volledig. Daarom is de mediaan beter voor sensoren zoals de HC-SR04 die soms foute waarden geven, en is middelen beter voor onrustige analoge metingen.
Hoe kies ik de coëfficiënt voor een exponentieel filter (EMA)?
De coëfficiënt α ligt tussen 0 en 1; een kleine α geeft een rustigere maar tragere uitvoer, een grote α een snellere maar onrustigere. Bij een meting per 10 ms geeft α = 0,1 een tijdconstante van ongeveer 100 ms en is dat een goed beginpunt voor de meeste sensoren. De reactietijd reken je uit met τ ≈ T / α.
Hoe teken ik meerdere waarden in de Arduino Serial Plotter?
Print de waarden op elke regel in het formaat label:waarde met komma's ertussen en sluit de regel af met println, bijvoorbeeld Ham:512,EMA:509. De Serial Plotter toont elk label als een aparte gekleurde lijn. Sluit eerst de Serial Monitor als die open staat en stel de baudrate in op die van je code.
Kan een Kalmanfilter op Arduino worden gebruikt?
Ja, een eenvoudig eendimensionaal Kalmanfilter draait in een paar regels zelfs op een Arduino Uno. Het wordt afgesteld met de meetruis R en de procesruis Q; voor één sensor liggen de resultaten meestal zeer dicht bij een goed afgestelde EMA. Het echte voordeel komt naar voren bij het combineren van meerdere sensoren, zoals een versnellingsmeter en een gyroscoop.
Projecten om hierna te bouwen
Alle projecten bekijken
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.

Afstand meten met HC-SR04 (Serial-weergave)
De HC-SR04-sensor werkt net als een vleermuis die in het donker zijn weg vindt: hij stuurt een geluid uit dat je niet kunt horen, luistert naar de echo en meet hoe ver het object voor hem staat.

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

Parkeersensor met HC-SR04
Een minversie van de parkeersensor van een auto: hoe dichterbij iets komt, hoe sneller de pieptonen.

Lengtemeetproject
Een lengtemeter die aan een deurpost hangt en in centimeters laat zien hoe lang de persoon eronder is.

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.

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.

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.
Meer artikelen
BlueGrays-app
Bouw deze schakeling stap voor stap op je telefoon
Schakelschema, code en onderdelenlijst op één scherm. Meer dan 500 Arduino-, ESP32- en Pico-projecten om te bouwen.
Scan met je telefoon
Richt je camera op de code en de appstore van je telefoon opent.
of open de store

