Basis · 14 min leestijd

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.

HC-SR04 ultrasone afstandssensor
Sensoren zoals de HC-SR04 geven af en toe een foute meting; een mediaanfilter verwijdert zulke pieken.

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 ruisHoe het eruitzietTypische oorzaakGeschikte oplossing
Willekeurige ruisDe waarde schommelt met ±2–10 stappenRimpel op de voeding, lange draden, eigen ruis van de ADCMiddelen, voortschrijdend gemiddelde, EMA
PiekEen enkele waarde die ver ernaast zitGemiste echo bij de HC-SR04, los contact, storing door motorenMediaanfilter
Stapfout (kwantisatiefout)De waarde wisselt tussen twee naburige getallenADC-resolutie (5 V / 1024 = 4,9 mV op de Uno)Middelen, hysterese
Periodieke ruisRegelmatige rimpel100 Hz flikkering van lampen, 50 Hz netMiddelen over veelvouden van 20 ms
DriftDe waarde verandert langzaam over minutenTemperatuur, dalende batterijspanningKalibratie 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.

AansluitingArduino UnoESP32Raspberry Pi Pico
Loper van de potentiometerA0GPIO 34GP26 (ADC0)
Middelpunt van de LDR + 10 kΩ-spanningsdelerA1GPIO 35GP27 (ADC1)
HC-SR04 TRIGD9GPIO 5GP2
HC-SR04 ECHOD10GPIO 18 (met spanningsdeler)GP3 (met spanningsdeler)
LED of relais (hysteresevoorbeeld)D8--
VoedingPot en LDR 5V, HC-SR04 5VPot en LDR 3V3, HC-SR04 5VPot en LDR 3V3, HC-SR04 VBUS
Sluit op de ESP32 en de Pico de potentiometer en de LDR-spanningsdeler aan op 3V3; de analoge pins mogen nooit meer dan 3,3 V zien. De HC-SR04 werkt op 5 V en zijn ECHO-uitgang geeft 5 V, dus breng op de ESP32 en de Pico de ECHO-pin terug naar 3,3 V met een spanningsdeler van 1 kΩ en 2 kΩ. De waarden van de deler kun je controleren met de tool Spanningsdeler.

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.

C++ (Arduino IDE)
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.

C++ (Arduino IDE)
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)RuisonderdrukkingVertraging (één meting per 10 ms)Goed voor
4Ongeveer 2×15 msRegeling die snel moet reageren
10Ongeveer 3×45 msPotentiometer, joystick, LDR
32Ongeveer 5,7×155 msTemperatuur, luchtvochtigheid, batterijspanning
10010×495 msZeer 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.

C++ (Arduino IDE)
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}
Je kunt mediaan en middelen ook combineren: verwijder eerst pieken met een mediaan over 5 punten en voer het resultaat dan in een voortschrijdend gemiddelde of EMA om de resterende schommelingen glad te strijken. Dit duo is de meest gebruikte oplossing voor metingen met zowel pieken als schommelingen, zoals afstands- en doorstroomsensoren. Maak het mediaanvenster niet groot; 3 of 5 is genoeg voor de meeste klussen, en 9 of meer geeft zonder reden vertraging.

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.

C++ (Arduino IDE)
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,5310–20 msZeer snel, weinig gladstrijking
0,2950 msSnel, lichte gladstrijking
0,119100 msGebalanceerd, een goed beginpunt voor de meeste sensoren
0,0539200 msRustig, traag
0,011991 sZeer 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.

  1. Upload de code en sluit de Serial Monitor als die open staat; de Serial Monitor en de Serial Plotter kunnen niet tegelijk open zijn.
  2. Open in de Arduino IDE Tools › Serial Plotter of klik rechtsboven op het grafiekpictogram.
  3. Stel de snelheid rechtsonder in op 115200 baud.
  4. Draai de potentiometer langzaam en dan snel, en kijk hoe elke lijn reageert.
  5. Gebruik de vakjes naast de labels om lijnen aan en uit te zetten en twee filters direct te vergelijken.
C++ (Arduino IDE)
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.

C++ (Arduino IDE)
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.

SensorAanbevolen leesintervalOpmerking
DHT11 / DHT221 s / 2 sVaker uitlezen geeft dezelfde waarde of een fout terug
DS18B20 (12-bit)750 msDat is de conversietijd
HC-SR04Minstens 60 msWacht tot de vorige echo is weggestorven
Potentiometer, joystick10–20 ms50–100 Hz is ruim voldoende voor menselijke beweging
LDR (om lampflikkering te onderdrukken)Elke 1 ms gedurende 20 ms, daarna middelenDe 50 Hz-netflikkering heft zichzelf op
MPU60505–10 msEen 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.

C++ (Arduino IDE)
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.

C++ (Arduino IDE)
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.

MicroPython
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?

SituatieVoorgesteld filterWaarom?
Een potentiometer, joystick of analoge sensor schommeltVoortschrijdend 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 puntenVerwijdert de incidentele fout volledig
Zowel pieken als schommelingenEerst mediaan, dan EMALost de twee problemen na elkaar op
Heel weinig RAM, veel sensorenInteger-EMAEén variabele per sensor
Een aan/uit-beslissing flikkert bij de drempelHysterese en een bevestigingstijdLost het beslissingsprobleem op; een filter alleen is niet genoeg
Rimpel van lampen of het netGelijkmatig gemiddelde over 20 msBeslaat een hele periode van 50 Hz
Meerdere sensoren combineren (kanteling, positie)Kalmanfilter of complementair filterCombineert de sterke punten van elke sensor

Veelgemaakte fouten en oplossingen

SymptoomWaarschijnlijke oorzaakOplossing
De gefilterde waarde reageert veel te laatHet venster is te groot of α te kleinVerklein het venster of verhoog α; reken de vertraging uit met de tabellen
Het voortschrijdend gemiddelde klimt bij het opstarten langzaam vanaf nulDe buffer begint gevuld met nullenVul 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 handDe int-som is overgelopen (64 × 1023 = 65.472 > 32.767)Maak de somvariabele een long
Het mediaanfilter verandert nietsHet venster is 2 of een even getal, of de pieken komen achter elkaarGebruik 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 kleurVerkeerd labelformaatGebruik label:waarde met komma's ertussen en sluit de regel af met println
De EMA-waarde verandert nooitIntegerdeling: 1/10 geschreven in plaats van 0.1Schrijf de coëfficiënt als float (0.1) of gebruik de integer-EMA-formule
Waarden schommelen nog steeds ondanks het filterHet probleem is geen ruis maar drift of een zwakke voedingControleer de voeding, voeg een condensator van 100 nF toe en kalibreer
Kijk altijd eerst naar de ruwe gegevens voordat je een filter kiest. Een paar minuten naar de ruwe waarde in de Serial Plotter kijken laat meteen zien of het probleem schommeling, pieken, periodieke rimpel of drift is. Begin dan met het eenvoudigste filter en ga pas naar het volgende als dat nodig is. In de meeste projecten werkt een mediaan over 5 punten plus een EMA met α = 0,1 beter dan een ingewikkeld Kalmanfilter en is het veel makkelijker te begrijpen.

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.

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
Afstand meten met HC-SR04 (Serial-weergave)
AR-27Beginner

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.

4.6(50)
82
Nachtlampje met LDR
AR-12Beginner

Nachtlampje met LDR

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

4.7(105)
224
Parkeersensor met HC-SR04
AR-28Gemiddeld
Premium

Parkeersensor met HC-SR04

Een minversie van de parkeersensor van een auto: hoe dichterbij iets komt, hoe sneller de pieptonen.

4.8(64)
86
Lengtemeetproject
AR-33Gemiddeld
Premium

Lengtemeetproject

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

4.5(25)
34
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
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 HC-SR04 ultrasone afstandssensor
ES-14Gemiddeld

ESP32 HC-SR04 ultrasone afstandssensor

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

4.9(29)
48