Componenten · 16 min leestijd

Reedschakelaar met Arduino: deursensor, alarm en snelheidsmeter

Hoe een reedschakelaar werkt en hoe je hem aansluit op Arduino: NO/NC-types, magneetafstand, pull-up en debounce, deuralarm, fietssnelheidsmeter, ESP32- en Pico-code.

Een reedschakelaar (magneetschakelaar) is een eenvoudige sensor die een schakeling sluit wanneer een magneet twee dunne metalen blaadjes in een glazen buisje tegen elkaar trekt, en hij verbruikt zelf helemaal geen stroom. Op een Arduino lees je hem uit als een knop: de contacten sluiten als er een magneet in de buurt is en gaan weer open als die weggaat. Dit kleine glazen buisje zit verstopt in deur- en raamalarmen, fietscomputers, vlotterschakelaars voor het waterniveau en windmeters.

In deze gids leer je stap voor stap wat er in een reedschakelaar zit, wat de NO- en NC-types zijn, op welke afstand en in welke stand de magneet het best werkt en hoe je hem met een pull-upweerstand op een Arduino aansluit. Daarna los je contactdender op in software, bouw je een alarm voor een open deur en een fietssnelheidsmeter, stuur je met een ESP32 een melding "deur geopend" naar je telefoon en laat je dezelfde schakeling draaien op een Raspberry Pi Pico met MicroPython. In de laatste delen vergelijken we de reedschakelaar met een hallsensor en zetten we de meest gemaakte fouten op een rij.

Reedschakelaarmodule en glazen reedschakelaar
Reedschakelaarmodule: het glazen buisje links bevat twee metalen blaadjes; de LM393-comparator en de potmeter op het board maken van het signaal een schone digitale uitgang op de DO-pin.

Wat is een reedschakelaar en hoe werkt hij?

Het hart van een reedschakelaar is een klein glazen buisje dat is gevuld met een inert gas zoals stikstof of vacuüm is gezogen. Twee buigzame blaadjes van nikkel-ijzer komen van beide kanten binnen en overlappen elkaar in het midden met een heel kleine tussenruimte; het woord "reed" verwijst naar deze blaadjes. De uiteinden zijn bekleed met harde metalen zoals rhodium of ruthenium, wat de contactweerstand laag houdt en slijtage vermindert. Komt er een magneet dichtbij, dan worden beide blaadjes gemagnetiseerd, ontstaan er tegengestelde polen op de overlappende uiteinden en trekken de blaadjes elkaar aan tot ze contact maken. Gaat de magneet weg, dan scheidt de veerkracht van de blaadjes de contacten weer. Omdat het glas de contacten beschermt tegen stof, vocht en oxidatie, kunnen reedschakelaars bij lage stroom honderden miljoenen keren schakelen.

Veel verkopers noemen dit onderdeel een "reedrelais", maar technisch gezien is het glazen buisje op zichzelf een reedschakelaar. Een echt reedrelais is hetzelfde glazen buisje met een spoel eromheen; daar sluit de stroom door de spoel de contacten in plaats van een magneet. Dit artikel gaat over de schakelaar die met een magneet werkt en over de sensormodules eromheen. Het grootste voordeel is dat hij geen stroom verbruikt: er loopt alleen de stroom van je eigen schakeling doorheen, waardoor hij ideaal is voor apparaten die maandenlang op batterijen draaien.

Specificaties van een reedschakelaar

EigenschapTypische waarde (kleine glazen reed)
ContacttypeVorm A (NO, normaal open) is het meest gangbaar
Glazen behuizingOngeveer 2 mm doorsnede, 10–15 mm lang
SchakelvermogenTot 10 W
SchakelspanningTot 100–200 V DC
SchakelstroomOngeveer 0,5 A
ContactweerstandMinder dan 0,1 Ω
SchakeltijdMinder dan 1 ms (inclusief dender)
Gevoeligheid10–40 AT (ampèrewindingen)
Levensduur100 miljoen tot 1 miljard schakelingen bij lage stroom
Eigen verbruikGeen (passief onderdeel)

De gevoeligheid wordt opgegeven in AT (ampèrewindingen): de stroom vermenigvuldigd met het aantal windingen dat nodig is om de reed te sluiten in een standaard testspoel. Hoe lager de waarde, hoe zwakker de magneet kan zijn die hem schakelt, dus hoe verder weg hij nog werkt. Er is ook hysterese: het veld dat nodig is om de contacten te sluiten (aantrekken) is sterker dan het veld dat nodig is om ze gesloten te houden. Een reed die door een magneet op 15 mm wordt gesloten, gaat bijvoorbeeld misschien pas weer open bij ongeveer 20 mm. Dit verschil vermindert gerammel bij kleine trillingen, maar je ontwerp moet er wel voor zorgen dat de magneet ook voorbij de loslaatafstand komt.

NO-, NC- en wisselcontact-reedtypes (vorm A, B, C)

Reedschakelaars bestaan in drie contactuitvoeringen. De aanduidingen NO (normaal open) en NC (normaal gesloten) beschrijven altijd de contacttoestand zonder magneet.

TypeZonder magneetMagneet dichtbijAansluitingenWaar wordt het gebruikt?
Form A (NO)OpenGesloten2Deursensoren, snelheidstellers, de meeste modules
Form B (NC)GeslotenOpen2Toepassingen die de schakeling moeten sluiten als de magneet weggaat
Vorm C (wisselcontact)COM–NC geslotenCOM–NO gesloten3Schakelingen die zowel een open als een gesloten uitgang nodig hebben
Deurcontacten voor alarmsystemen (zoals het gangbare type MC-38) worden vaak "NC" genoemd. NC betekent hier dat de schakeling gesloten is zolang de deur dicht is, dus met de magneet ernaast; binnenin zit eigenlijk een reed van vorm A (NO). Test je sensor dus eerst met de doorgangstest (piepstand) van een multimeter, met en zonder magneet; als je de code alleen op het label baseert, krijg je mogelijk omgekeerde logica.

Schakelen met een magneet: afstand, stand en gevoeligheid

De beste manier om een reedschakelaar te schakelen is een kleine neodymiummagneet. Een neodymiumschijfje van 10×3 mm schakelt een gangbare reed meestal op 10–20 mm; een zwarte ferrietmagneet van dezelfde grootte halveert die afstand ongeveer. Kant-en-klare deursensoren werken meestal op 15–25 mm. De afstand hangt niet alleen af van de sterkte van de magneet, maar ook van zijn stand: als je de noord-zuidas van de magneet parallel aan het glazen buisje houdt en naar het midden brengt, krijg je één schone sluiting. Staat de magneet loodrecht op het buisje, dan schakelt hij precies in het midden misschien helemaal niet en schakelt hij op twee punten dicht bij de uiteinden. Een parallelle magneet die langs het buisje schuift, geeft ook kleine extra sluitzones aan weerszijden van de hoofdzone. Als de magneet de reed passeert, kunnen de contacten dus twee of drie keer sluiten en openen; dit is de meest voorkomende reden dat telprojecten één omwenteling als twee of drie tellen.

Soorten neodymiummagneten: schijf, kubus, blok en verzonken
Neodymiummagneten zijn ideaal om een reedschakelaar te schakelen; verzonken magneten zijn makkelijk op een deur of kozijn te schroeven.
  • De polariteit maakt niet uit: een reed reageert hetzelfde op de noord- en de zuidpool; de magneet omdraaien verandert niets aan het resultaat.
  • Lijn de magneet uit met het midden van het buisje: bij deursensoren moeten de magneet en de reedbehuizing naast elkaar en parallel zitten, met een zo klein mogelijke tussenruimte.
  • Stalen deuren verkleinen de afstand: ijzer trekt het veld van de magneet naar zich toe. Verhoog de sensor en de magneet met een afstandsstukje van 5–10 mm kunststof of gebruik een sterkere magneet.
  • Meet eerst de afstand: beweeg met de Serial Monitor open de magneet langzaam naar de reed toe en ervan af. Bij een gesloten deur moet de magneet ruim binnen de aantrekafstand zitten; zodra de deur een klein stukje opengaat, moet hij voorbij de loslaatafstand zijn.
  • Houd afstand van sterke velden: luidsprekers, motoren en andere magneten kunnen de reed ongewild sluiten; monteer de reed niet vlak naast ze.

Reedschakelaar op Arduino aansluiten: waarom is een pull-upweerstand onmisbaar?

Omdat een reedschakelaar zich als een knop gedraagt, levert hij zelf geen spanning; hij verbindt of verbreekt alleen zijn twee pootjes. Zolang de contacten open zijn, is de pin met niets verbonden (hij zweeft) en lees je willekeurige HIGH- en LOW-waarden door ruis. De oplossing is een pull-upweerstand: de pin wordt via een weerstand naar 5 V (of 3,3 V) getrokken en de reed komt tussen de pin en GND. Zonder magneet leest de pin HIGH; als de magneet de contacten sluit, is de pin direct met GND verbonden en leest hij LOW. De Arduino Uno heeft een interne pull-upweerstand van 20–50 kΩ, dus pinMode(pin, INPUT_PULLUP) is genoeg en een externe weerstand is niet nodig. Voor de details van deze logica zie je de gids een knop aansluiten op Arduino.

AansluitingArduino UnoESP32Raspberry Pi Pico
Reedpootje 1 (losse reed)D2GPIO 27GP15 (fysieke pin 20)
Reedpootje 2 (losse reed)GNDGNDGND
Pull-upIntern (INPUT_PULLUP)Intern (INPUT_PULLUP)Intern (Pin.PULL_UP)
Module-VCC5V3V33V3(OUT) (fysieke pin 36)
Module-GNDGNDGNDGND
Module-DOD2GPIO 27GP15
Status-ledD13 (ingebouwde led)GPIO 2 (ingebouwde led)Ingebouwde led
Actieve buzzer (+)D8Niet gebruiktGP14
Sluit een reedschakelaar nooit direct aan tussen 5V en GND of op een pin die als OUTPUT is ingesteld: zodra er een magneet in de buurt komt, maak je kortsluiting, kunnen de dunne contacten aan elkaar lassen en kan de regelaar van het board beschadigd raken. Op de ESP32 zijn GPIO 34–39 alleen ingang en hebben ze geen interne pull-upweerstanden; gebruik je deze pins voor een reed, voeg dan een externe pull-upweerstand van 10 kΩ toe.

Eerste schakeling stap voor stap: een magneet detecteren

  1. Verbind één pootje van de reedschakelaar met de D2-pin van de Arduino en het andere met GND. Een losse reed heeft geen polariteit, dus de richting van de pootjes maakt niet uit.
  2. Gebruik je een module, verbind dan VCC met 5V, GND met GND en de DO-uitgang met D2.
  3. Upload de onderstaande code en open de Serial Monitor op 9600 baud.
  4. Breng de magneet langzaam dichterbij terwijl je hem parallel aan het glazen buisje houdt; de ingebouwde led moet gaan branden en "magneet gedetecteerd" moet op het scherm verschijnen.
  5. Meet tijdens het wegbewegen van de magneet met een liniaal bij welke afstand de led uitgaat; dit is je loslaatafstand.
C++ (Arduino IDE)
1const byte REED_PIN = 2;             // reed: D2 ile GND arasında / reed between D2 and GND
2const byte LED_PIN = 13;             // karttaki LED / onboard LED
3
4void setup() {
5  Serial.begin(9600);
6  pinMode(REED_PIN, INPUT_PULLUP);   // dahili pull-up: mıknatıs yokken HIGH / internal pull-up: HIGH without a magnet
7  pinMode(LED_PIN, OUTPUT);
8}
9
10void loop() {
11  if (digitalRead(REED_PIN) == LOW) {       // kontak kapalı: mıknatıs yakında / contacts closed: magnet nearby
12    digitalWrite(LED_PIN, HIGH);
13    Serial.println(F("Miknatis var / magnet detected"));
14  } else {                                  // kontak açık: mıknatıs uzakta / contacts open: magnet away
15    digitalWrite(LED_PIN, LOW);
16    Serial.println(F("Miknatis yok / no magnet"));
17  }
18  delay(200);
19}

Het enige om op te letten in de code is de omgekeerde logica: doordat je INPUT_PULLUP gebruikt, lees je LOW als de magneet aanwezig is en HIGH als hij er niet is. Bij LM393-modules met 3 pinnen gaat de uitgang meestal ook LOW als de magneet nadert en gaat de DO-led op het board branden; omdat dit per model kan verschillen, controleer je eigen module eerst in de Serial Monitor. De potmeter op de module stelt de drempel van de comparator in; omdat de reed al als aan/uit werkt, heeft hij weinig effect op de detectieafstand en kun je hem gewoon in het midden laten staan. Minimodules zoals de KY-021 hebben geen comparator; op het board zitten alleen de reed en een weerstand van 10 kΩ.

Debounce: contactdender en trillingen

Zoals elk mechanisch contact kan een reedschakelaar bij het sluiten een paar keer denderen. Bij een reed is deze dender heel kort, meestal minder dan 1 ms, maar dat is niet het echte probleem. Beweegt de magneet langzaam op de rand van de aantrekafstand, of rammelt de deur in de wind, dan kunnen de contacten binnen een seconde vele keren openen en sluiten. Daarom kan een systeem dat een melding "deur geopend" verstuurt vijf berichten sturen voor één opening. De oplossing is om te wachten tot de toestand een bepaalde tijd ongewijzigd blijft in plaats van elke verandering meteen te accepteren. Voor een deursensor is 50–100 ms genoeg; voor een snelheidsteller werkt het goed om de kortst fysiek mogelijke tijd tussen twee pulsen als blokkeertijd te gebruiken.

Wil je een hardwareoplossing, plaats dan een condensator van 100 nF tussen de pin en GND. Samen met een pull-up van 10 kΩ geeft dit een tijdconstante van τ = R × C = 10 kΩ × 100 nF = 1 ms, wat heel korte denderpulsen afvlakt. Met de RC-tijdconstanteberekening kun je andere combinaties van weerstand en condensator uitproberen. Met de interne pull-up is de weerstand 20–50 kΩ, dus de tijd groeit naar 2–5 ms. Bij deursensoren met meerdere meters kabel beschermt een externe pull-up van 4,7–10 kΩ plus deze condensator ook tegen ruis.

Sensor voor open deur en raam met een alarmproject

Het meest voorkomende reedproject is een deursensor. Monteer de magneet op het bewegende deel van de deur en de reed op het kozijn; als de deur dicht is, zitten ze naast elkaar, zijn de contacten gesloten en leest de pin LOW. Als de deur opengaat, beweegt de magneet weg en gaat de pin HIGH. Deze opstelling heeft een mooi neveneffect: als iemand de sensorkabel doorknipt, gaat de pin ook HIGH en ziet het systeem dat als "deur geopend". Daarom gebruiken alarmsystemen een gesloten lus in de bedrading. De onderstaande code telt elke opening, meet hoe lang de deur openstaat en laat de buzzer met tussenpozen piepen als de deur langer dan 30 seconden openblijft; perfect voor de deur van een koelkast of vriezer.

C++ (Arduino IDE)
1const byte REED_PIN = 2;                  // reed: D2 ile GND arası / reed between D2 and GND
2const byte BUZZER_PIN = 8;                // aktif buzzer artı ucu / active buzzer positive leg
3const byte LED_PIN = 13;                  // karttaki LED / onboard LED
4const unsigned long STABLE_MS = 50;       // debounce: 50 ms değişmeden kalmalı / debounce: must hold for 50 ms
5const unsigned long OPEN_LIMIT = 30000;   // 30 sn'den uzun açık kalırsa alarm / alarm if open longer than 30 s
6
7bool doorOpen = false;                    // onaylanmış durum / confirmed state
8bool lastReading = false;                 // son ham okuma / last raw reading
9unsigned long lastChange = 0;             // ham okumanın son değiştiği an / when the raw reading last changed
10unsigned long openedAt = 0;               // kapının açıldığı an / when the door was opened
11unsigned int openCount = 0;               // toplam açılış / total openings
12
13void setup() {
14  Serial.begin(9600);
15  pinMode(REED_PIN, INPUT_PULLUP);
16  pinMode(BUZZER_PIN, OUTPUT);
17  pinMode(LED_PIN, OUTPUT);
18  doorOpen = (digitalRead(REED_PIN) == HIGH);   // açılıştaki durumu al / take the state at boot
19  lastReading = doorOpen;
20}
21
22void loop() {
23  unsigned long now = millis();
24  bool reading = (digitalRead(REED_PIN) == HIGH);   // HIGH: mıknatıs uzak, kapı açık / HIGH: magnet away, door open
25
26  if (reading != lastReading) {           // ham değer değişti, sayacı yeniden başlat / raw value changed, restart the timer
27    lastReading = reading;
28    lastChange = now;
29  }
30
31  if (reading != doorOpen && now - lastChange >= STABLE_MS) {   // 50 ms kararlı: gerçek değişim / stable for 50 ms: real change
32    doorOpen = reading;
33    if (doorOpen) {
34      openedAt = now;
35      openCount++;
36      Serial.print(F("Kapi acildi / door opened, sayac / count: "));
37      Serial.println(openCount);
38    } else {
39      Serial.print(F("Kapi kapandi / door closed, sure / duration (s): "));
40      Serial.println((now - openedAt) / 1000);
41    }
42  }
43
44  digitalWrite(LED_PIN, doorOpen ? HIGH : LOW);     // LED kapı açıkken yanar / LED is on while the door is open
45
46  // Uzun süre açık kalırsa çeyrek saniyede bir öt / beep every quarter second if left open too long
47  bool alarm = doorOpen && (now - openedAt > OPEN_LIMIT);
48  digitalWrite(BUZZER_PIN, (alarm && (now / 250) % 2) ? HIGH : LOW);
49}

Omdat de code geen delay() gebruikt, controleert de lus de pin voortdurend en mist hij nooit een opening; deze techniek leggen we uitgebreid uit in het artikel millis vs delay. Telkens als de ruwe meting verandert, wordt de tijd lastChange opnieuw ingesteld, en de toestand doorOpen verandert pas als de waarde 50 ms gelijk blijft. In het buzzerdeel wordt millis() door 250 gedeeld om elke kwartseconde aan en uit te schakelen. Om er een echt alarm van te maken, kun je het in- en uitschakelen met een keypad met wachtwoord en een PIR-bewegingssensor in de kamer toevoegen. Voor een completere opzet kun je het artikel Arduino-alarmsysteem bekijken.

Fietssnelheidsmeter: omwentelingen tellen met een reedschakelaar

De meeste fietscomputers bestaan uit een reedschakelaar en een kleine magneet die op een spaak is geklemd. Elke keer dat het wiel draait, passeert de magneet de reed op de vork één keer en geeft hij een puls. Meet de tijd tussen twee pulsen en je krijgt de snelheid; tel de pulsen en je krijgt de afstand: snelheid (km/u) = omtrek (mm) / tijd (ms) × 3,6. Hier is mm/ms precies m/s, en vermenigvuldigen met 3,6 rekent het om naar km/u. Bij een wiel van 700x25C met een omtrek van 2105 mm betekent 253 ms tussen twee pulsen bijvoorbeeld 2105 / 253 × 3,6 ≈ 30 km/u. De nauwkeurigste manier om de omtrek te bepalen is het wiel precies één omwenteling laten rollen met het ventiel onderaan en de afstand tussen de twee markeringen op de grond meten.

BandenmaatOngeveer omtrekTijd per omwenteling bij 30 km/u
20x1.75 (BMX, kinderfiets)1515 mm182 ms
26x2.1 (mountainbike)2068 mm248 ms
29x2.1 (mountainbike)2288 mm275 ms
700x25C (racefiets)2105 mm253 ms
700x28C (stad, gravel)2136 mm256 ms
C++ (Arduino IDE)
1const byte REED_PIN = 2;                  // kesme pini D2 (INT0) / interrupt pin D2 (INT0)
2const float WHEEL_MM = 2105.0;            // 700x25C tekerlek çevresi (mm) / 700x25C wheel circumference (mm)
3const unsigned long LOCKOUT_MS = 80;      // daha sık darbe imkânsız (~95 km/sa) / faster pulses are impossible (~95 km/h)
4const unsigned long TIMEOUT_MS = 3000;    // 3 sn darbe yoksa hız 0 / no pulse for 3 s means speed 0
5
6volatile unsigned long lastPulseMs = 0;   // son geçerli darbe zamanı / time of the last valid pulse
7volatile unsigned long periodMs = 0;      // son iki darbe arası süre / time between the last two pulses
8volatile unsigned long revCount = 0;      // toplam tur / total revolutions
9
10void onMagnet() {                         // ISR: kısa ve hızlı / ISR: short and fast
11  unsigned long now = millis();
12  unsigned long dt = now - lastPulseMs;
13  if (dt < LOCKOUT_MS) return;            // sıçrama ya da çift darbe: yok say / bounce or double pulse: ignore
14  periodMs = (dt < TIMEOUT_MS) ? dt : 0;  // uzun duraklamadan sonraki ilk darbe hız vermez / first pulse after a stop gives no speed
15  lastPulseMs = now;
16  revCount++;
17}
18
19void setup() {
20  Serial.begin(9600);
21  pinMode(REED_PIN, INPUT_PULLUP);
22  attachInterrupt(digitalPinToInterrupt(REED_PIN), onMagnet, FALLING);   // mıknatıs gelince HIGH->LOW / HIGH->LOW when the magnet arrives
23}
24
25void loop() {
26  static unsigned long lastPrint = 0;
27  if (millis() - lastPrint < 500) return; // saniyede 2 kez yaz / print twice per second
28  lastPrint = millis();
29
30  noInterrupts();                         // çok baytlı değerleri güvenle kopyala / copy multi-byte values safely
31  unsigned long period = periodMs;
32  unsigned long last = lastPulseMs;
33  unsigned long revs = revCount;
34  interrupts();
35
36  float speedKmh = 0;
37  if (period > 0 && millis() - last < TIMEOUT_MS) {
38    speedKmh = WHEEL_MM / period * 3.6;   // mm/ms = m/s; 3,6 ile çarp = km/sa / multiply by 3.6 = km/h
39  }
40  float distanceKm = revs * WHEEL_MM / 1000000.0;   // tur x çevre / revolutions x circumference
41
42  Serial.print(F("Hiz / speed: "));
43  Serial.print(speedKmh, 1);
44  Serial.print(F(" km/h   Mesafe / distance: "));
45  Serial.print(distanceKm, 3);
46  Serial.println(F(" km"));
47}

Omdat de puls wordt opgevangen met attachInterrupt, wordt er geen omwenteling gemist, hoe druk loop() ook is; op de Arduino Uno bieden alleen de pins D2 en D3 dit soort interrupt. De waarde LOCKOUT_MS is erg belangrijk: 80 ms komt bij een wiel van 2105 mm overeen met een topsnelheid van ongeveer 95 km/u (2105 / 80 × 3,6). Pulsen die dichter op elkaar komen zijn fysiek onmogelijk en worden daarom genegeerd als dender, als zijdelingse sluitzones van de magneet of als het contact dat dendert bij het openen. Komt er 3 seconden geen puls binnen, dan wordt de snelheid als nul beschouwd. Met dezelfde opzet kun je de snelheid van een motor of een wiel meten in omwentelingen per minuut: RPM = 60000 / tijd (ms). Meer over interrupts vind je in de gids Arduino-interrupt; om de snelheid op een display op het stuur te tonen, combineer je de code met een OLED-display.

Reedschakelaar of hallsensor?

De tweede manier om een magneet te detecteren is een hallsensor. Een hallsensor zet het magnetische veld in een halfgeleiderchip om in een elektrisch signaal; hij heeft geen bewegende delen, maar heeft voeding nodig om te werken. De korte vuistregel: kies voor een deur- of raamsensor die lang op batterijen draait en zelden schakelt een reed; voor snel en continu tellen, zoals bij een motor, een ventilator of een waterstroomsensor die tientallen keren per seconde draait, is een hallsensor de betere keuze.

EigenschapReedschakelaarHallsensor (A3144, US1881, 49E)
WerkingMechanisch contact, gesloten door een magneetHalfgeleider, zet het veld om in een elektrisch signaal
VoedingNiet nodig, verbruikt zelf geen stroomVereist (enkele mA)
SchakelsnelheidHonderden keren per secondeTot tienduizenden Hz
ContactdenderJa (minder dan 1 ms)Geen
LevensduurMechanische slijtage, 100 miljoen – 1 miljard schakelingenGeen bewegende delen, geen slijtage
PoolherkenningNee, reageert op beide polenAfhankelijk van het model: unipolair, bipolair of latching
Analoge metingNee, alleen open of geslotenLineaire modellen (49E) meten de veldsterkte
Belasting schakelenKan kleine AC/DC-belastingen direct schakelenAlleen signaaluitgang
DuurzaamheidGlazen buisje is gevoelig voor stoten en buigenKunststof behuizing, bestand tegen schokken

Melding bij geopende deur met ESP32 (Telegram)

Dankzij de Wi-Fi van de ESP32 kan de deursensor op het moment dat de deur opengaat een bericht naar je telefoon sturen. Daarvoor maak je in Telegram met BotFather een bot aan, haal je het token en je eigen chat-ID op en installeer je de bibliotheken UniversalTelegramBot en ArduinoJson in de Arduino IDE; deze stappen leggen we uitgebreid uit in het artikel ESP32 Telegram-bot. Verbind één pootje van de reed met GPIO 27 en het andere met GND. De code stuurt een bericht als de deur opengaat en sluit, herinnert je eraan als de deur langer dan 5 minuten openstaat en probeert het bericht 10 seconden later opnieuw als de Wi-Fi op dat moment uitvalt.

C++ (Arduino IDE)
1#include <WiFi.h>
2#include <WiFiClientSecure.h>
3#include <UniversalTelegramBot.h>
4#include <ArduinoJson.h>
5
6const char* WIFI_SSID = "AgAdi";          // Wi-Fi adın (yalnız 2,4 GHz) / your Wi-Fi name (2.4 GHz only)
7const char* WIFI_PASS = "Sifre123";       // Wi-Fi şifren / your Wi-Fi password
8#define BOT_TOKEN "1234567890:AAExxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"   // BotFather'ın verdiği token / token from BotFather
9#define CHAT_ID   "123456789"             // bildirimin gideceği ID / the ID that receives alerts
10
11const int REED_PIN = 27;                  // reed: GPIO 27 ile GND arası / reed between GPIO 27 and GND
12const int LED_PIN  = 2;                   // çoğu DevKit'te dahili LED / onboard LED on most DevKits
13const unsigned long STABLE_MS = 100;      // değişim 100 ms sürmeli / a change must last 100 ms
14const unsigned long REMIND_MS = 300000;   // 5 dk açık kalırsa hatırlat / remind after 5 min open
15const unsigned long RETRY_MS  = 10000;    // gönderilemeyen mesajı 10 sn sonra dene / retry a failed message after 10 s
16
17WiFiClientSecure client;                  // şifreli (HTTPS) bağlantı / encrypted (HTTPS) connection
18UniversalTelegramBot bot(BOT_TOKEN, client);
19
20bool doorOpen = false;                    // onaylanmış kapı durumu / confirmed door state
21bool lastRaw = false;                     // son ham okuma / last raw reading
22unsigned long lastChange = 0;
23unsigned long openedAt = 0;
24bool reminded = false;
25String pending = "";                      // gönderilmeyi bekleyen mesaj / message waiting to be sent
26unsigned long lastTry = 0;
27
28void notify(const String& text) {
29  Serial.println(text);
30  if (WiFi.status() == WL_CONNECTED && bot.sendMessage(CHAT_ID, text)) {
31    pending = "";                         // gönderildi / sent
32  } else {
33    pending = text;                       // Wi-Fi yoksa sonra dene / no Wi-Fi: try again later
34    lastTry = millis();
35  }
36}
37
38void setup() {
39  Serial.begin(115200);
40  pinMode(REED_PIN, INPUT_PULLUP);        // dahili pull-up; GPIO 34-39'da yoktur / internal pull-up; GPIO 34-39 have none
41  pinMode(LED_PIN, OUTPUT);
42
43  WiFi.mode(WIFI_STA);
44  WiFi.begin(WIFI_SSID, WIFI_PASS);
45  Serial.print("Wi-Fi'ye baglaniyor / connecting to Wi-Fi");
46  while (WiFi.status() != WL_CONNECTED) {
47    delay(500);
48    Serial.print(".");
49  }
50  Serial.println();
51  Serial.println(WiFi.localIP());
52  client.setCACert(TELEGRAM_CERTIFICATE_ROOT);   // api.telegram.org kök sertifikası / root certificate of api.telegram.org
53
54  doorOpen = (digitalRead(REED_PIN) == HIGH);    // HIGH = mıknatıs uzak = kapı açık / HIGH = magnet away = door open
55  lastRaw = doorOpen;
56  openedAt = millis();
57  digitalWrite(LED_PIN, doorOpen ? HIGH : LOW);
58  notify(String("Kapı sensörü hazır, kapı ") + (doorOpen ? "AÇIK" : "KAPALI") + " / door sensor ready");
59}
60
61void loop() {
62  unsigned long now = millis();
63  bool raw = (digitalRead(REED_PIN) == HIGH);
64
65  if (raw != lastRaw) {                   // ham değer değişti / raw value changed
66    lastRaw = raw;
67    lastChange = now;
68  }
69
70  if (raw != doorOpen && now - lastChange >= STABLE_MS) {   // kararlı değişim / stable change
71    doorOpen = raw;
72    digitalWrite(LED_PIN, doorOpen ? HIGH : LOW);
73    if (doorOpen) {
74      openedAt = now;
75      reminded = false;
76      notify("Kapı AÇILDI! / door OPENED!");
77    } else {
78      unsigned long sec = (now - openedAt) / 1000;
79      notify("Kapı kapandı / door closed (" + String(sec) + " sn)");
80    }
81  }
82
83  if (doorOpen && !reminded && now - openedAt > REMIND_MS) {   // açık unutuldu / left open
84    reminded = true;
85    notify("Kapı 5 dakikadır açık! / door open for 5 minutes!");
86  }
87
88  if (pending.length() > 0 && now - lastTry > RETRY_MS) {      // bekleyen mesajı yeniden dene / retry the pending message
89    String msg = pending;
90    notify(msg);
91  }
92}

Een bericht naar Telegram sturen kan 1–2 seconden duren en de lus wacht in die tijd; omdat de toestandsmachine de pin na het versturen opnieuw leest, gaat de laatste toestand van de deur echter nooit verloren. Wil je de sensor op batterijen laten draaien, zet de ESP32 dan in deep sleep en gebruik esp_sleep_enable_ext0_wakeup(GPIO_NUM_27, 1), zodat hij wakker wordt als de deur opengaat en de pin HIGH wordt. Stel je het wakeniveau voor het slapengaan in op het tegenovergestelde van de huidige toestand van de pin, dan wordt het board zowel bij openen als bij sluiten wakker. Houd in dat geval ook rekening met de stroom door de pull-upweerstand: terwijl de deur dicht is, is de reed gesloten, dus er loopt continu 3,3 V / 10 kΩ = 330 µA door een weerstand van 10 kΩ; met 100 kΩ daalt de stroom naar 33 µA. In deep sleep is een externe weerstand de veiligste keuze in plaats van de interne pull-up. De levensduur van de batterij kun je schatten met de batterijduurcalculator.

Reedschakelaar met Raspberry Pi Pico en MicroPython

Een reedschakelaar uitlezen op de Raspberry Pi Pico kost maar een paar regels MicroPython. Verbind de reed tussen GP15 en GND, en daarna de pluspool van de actieve buzzer met GP14 en de minpool met GND. Omdat de Pico op 3,3 V draait, voed je een module altijd via de pin 3V3(OUT); voed je de module met 5 V, dan stijgt de DO-uitgang naar 5 V en kan de ingang van de Pico beschadigd raken. De interne pull-up van de Pico is ongeveer 50–80 kΩ, wat genoeg is voor korte kabels.

MicroPython
1from machine import Pin
2import time
3
4reed = Pin(15, Pin.IN, Pin.PULL_UP)   # reed: GP15 ile GND arası / reed between GP15 and GND
5buzzer = Pin(14, Pin.OUT)             # aktif buzzer artı ucu / active buzzer positive leg
6led = Pin("LED", Pin.OUT)             # dahili LED (Pico ve Pico W) / onboard LED (Pico and Pico W)
7
8STABLE_MS = 50                        # debounce süresi / debounce time
9door_open = reed.value() == 1         # 1 = mıknatıs uzak = kapı açık / 1 = magnet away = door open
10last_raw = door_open
11last_change = time.ticks_ms()
12open_count = 0
13led.value(door_open)
14
15while True:
16    raw = reed.value() == 1
17    now = time.ticks_ms()
18    if raw != last_raw:                       # ham değer değişti / raw value changed
19        last_raw = raw
20        last_change = now
21    if raw != door_open and time.ticks_diff(now, last_change) >= STABLE_MS:
22        door_open = raw                       # 50 ms kararlı: gerçek değişim / stable for 50 ms: real change
23        led.value(door_open)
24        if door_open:
25            open_count += 1
26            print("Kapi acildi / door opened:", open_count)
27            buzzer.on()
28            time.sleep_ms(100)                # kısa bip / short beep
29            buzzer.off()
30        else:
31            print("Kapi kapandi / door closed")
32    time.sleep_ms(5)

De code bouwt dezelfde debounce-logica als op de Arduino met time.ticks_ms() en time.ticks_diff(); ticks_diff geeft het juiste verschil, ook als de teller rondgaat. Voor pulsen die je niet mag missen, zoals bij een snelheidsteller, kun je een interrupt gebruiken met reed.irq(trigger=Pin.IRQ_FALLING, handler=...). Heb je een Pico W, dan kun je het Pico W-voorbeeld uit het artikel over de Telegram-bot aan deze code toevoegen om dezelfde gebeurtenis via Wi-Fi naar je telefoon te sturen. Gebruik je de Pico voor het eerst, begin dan met de gids wat is de Raspberry Pi Pico.

Projectideeën met een reedschakelaar

  • Draadloze deur- en raamsensor: meld elke opening in je huis met een ESP32 op je telefoon of stuur het via MQTT naar Home Assistant.
  • Koelkastdeurherinnering: laat met tussenpozen een piep horen als de deur langer dan 30 seconden openstaat.
  • Fietscomputer: toon de actuele snelheid, de totale afstand en de gemiddelde snelheid op een display.
  • Wind- en regenmeter: in weerstations geeft de bekeranemometer één reedpuls per omwenteling en de kantelbakregenmeter één puls per kanteling.
  • Vlotterschakelaar voor het niveau: de magneet in de vlotter opent en sluit de reed in de steel om te melden dat het reservoir vol is; details in het artikel waterniveausensor.
  • Geheim ladeslot: bouw een solenoïdeslot dat alleen opengaat als een magneet op de juiste plek wordt gehouden.
  • Brievenbusmelding: een reed op de klep maakt de ESP32 wakker uit deep sleep als er post komt.

Veelgemaakte fouten en hoe je ze oplost

  • De pin leest willekeurige waarden: er is geen pull-up. Stel pinMode in op INPUT_PULLUP of voeg een externe pull-upweerstand van 10 kΩ toe.
  • De logica is omgekeerd: met een pull-up leest de pin LOW als de magneet aanwezig is; je code verwacht misschien HIGH, of je sensor is een NC-type. Controleer het met een multimeter.
  • Meerdere tellingen voor één opening: er is geen debounce, of de magneet passeert de zijdelingse sluitzones. Voeg een stabiele tijd toe en lijn de magneet parallel aan het buisje uit.
  • De reed sluit nooit: de magneet is zwak, de afstand is te groot, de magneet staat loodrecht op het midden van het buisje of een stalen deur absorbeert het veld. Gebruik een sterkere neodymiummagneet en een kunststof afstandsstukje.
  • De reed blijft de hele tijd gesloten: de contacten kunnen zijn vastgelast door te veel stroom of een capacitieve belasting. Stuur nooit direct een motor, lamp of relaisspoel aan met een reed; schakel belastingen met een relaismodule of een transistor.
  • Het glazen buisje is gebarsten: de pootjes zijn te dicht bij de behuizing gebogen. Houd het pootje vast met een tang, buig het minstens 2–3 mm van het glas af en soldeer snel.
  • Valse alarmen bij lange kabels: de interne pull-up is te zwak. Gebruik een externe pull-up van 4,7–10 kΩ, een condensator van 100 nF op de pin en getwiste kabel.
Test de reedschakelaar met de doorgangstest (piepstand) van een multimeter voordat je hem in een schakeling zet: met de meetpennen op beide pootjes moet hij piepen als de magneet nadert en stoppen als die weggaat. Deze test van tien seconden laat zeker zien dat de reed werkt en of hij NO of NC is; het is ook de makkelijkste manier om de schakelafstand van de magneet met een liniaal te meten.

Een reedschakelaar is een goedkope en uiterst betrouwbare sensor die een magneet detecteert zonder stroom te verbruiken; met de juiste stand van de magneet, een pull-upweerstand en een paar regels debounce-code werkt hij jarenlang zonder problemen. In de BlueGrays-app vind je de projecten Reedschakelaar waarde uitlezen en Reedschakelaar-deursensor, en ook projecten zoals het ESP32-bewegingsalarm en het alarmsysteem met Telegram-meldingen, met schakelschema's en code stap voor stap.

Veelgestelde vragen

Hoe werkt een reedschakelaar?

Een reedschakelaar bestaat uit twee nikkel-ijzeren blaadjes in een glazen buisje. Komt er een magneet dichtbij, dan worden de blaadjes gemagnetiseerd, trekken ze elkaar aan en sluiten de contacten; gaat de magneet weg, dan scheidt de veerkracht ze weer. Hij verbruikt zelf geen stroom en wordt op een Arduino uitgelezen als een knop.

Is een reedschakelaar normaal open of normaal gesloten?

De meeste reedschakelaars zijn NO (normaal open, vorm A): open zonder magneet en gesloten als er een magneet in de buurt komt. Er bestaan ook NC-uitvoeringen (vorm B) en wisselcontactuitvoeringen met drie pootjes (vorm C). Bij deurcontacten voor alarmen betekent het label "NC" echter dat de schakeling gesloten is zolang de deur dicht is en de magneet ernaast zit, dus testen met een multimeter is het veiligst.

Hoe ver weg kan een magneet een reedschakelaar schakelen?

Dat hangt af van de sterkte van de magneet en de gevoeligheid van de reed. Een kleine neodymiummagneet schakelt gangbare reeds meestal op 1–2 cm en kant-en-klare deursensoren werken op 15–25 mm; met ferrietmagneten is de afstand ongeveer de helft. Als je de magneet parallel aan het buisje houdt en uit de buurt van stalen oppervlakken, wordt de afstand groter.

Heeft een reedschakelaar een weerstand nodig?

De Arduino-ingang heeft een pull-up- of pull-downweerstand nodig; anders zweeft de pin en leest hij willekeurige waarden zolang de contacten open zijn. Omdat de Arduino, ESP32 en Pico interne pull-ups hebben die je inschakelt met INPUT_PULLUP of Pin.PULL_UP, is een externe weerstand meestal niet nodig. Bij lange kabels geeft een externe weerstand van 4,7–10 kΩ stabielere resultaten.

Wat is het verschil tussen een reedschakelaar en een hallsensor?

Een reedschakelaar is een mechanisch contact; hij heeft geen voeding nodig en kan kleine belastingen direct schakelen, maar hij dendert en het glazen buisje is breekbaar. Een hallsensor is een halfgeleider; hij heeft voeding nodig, dendert niet en is veel sneller. Een reed verdient de voorkeur voor deursensoren op batterijen, een hallsensor voor snel tellen van omwentelingen.

Kan een reedschakelaar een lamp op netspanning schakelen?

Kleine glazen reedschakelaars kunnen meestal maximaal 10 W schakelvermogen aan, dus een lamp of motor op netspanning direct schakelen last de contacten vast en is gevaarlijk. Gebruik de reed op de Arduino alleen als signaal, bedien de netbelasting met een relaismodule en volg altijd de veiligheidsregels bij het werken met netspanning.

Alle projecten bekijken
Een reedschakelaar uitlezen
AR-37Beginner

Een reedschakelaar uitlezen

Heb je je ooit afgevraagd hoe de magneetschakelaar in deur- en raamalarmen werkt?

4.5(22)
29
Deursensor met reedschakelaar
AR-38Beginner
Premium

Deursensor met reedschakelaar

Zie aan een lampje of je deur open of dicht is. Je bevestigt een kleine magneet aan de deur en een magneetgevoelige schakelaar aan de deurpost; als de deur dicht is, zitten ze naast elkaar en brandt…

4.7(34)
44
LED aansturen met een drukknop (Push)
AR-9Beginner

LED aansturen met een drukknop (Push)

Net als een deurbel: het licht blijft aan zolang je indrukt en gaat uit als je loslaat.

4.8(114)
253
ESP32-ledbesturing met drukknop (Push)
ES-2Beginner

ESP32-ledbesturing met drukknop (Push)

De led brandt zolang je de knop indrukt en gaat uit als je loslaat. Laat zien hoe je de digitale ingangspin en de interne pull-upweerstand van de ESP32 gebruikt. Met de modus INPUT_PULLUP heb je geen externe weerstand nodig.

4.6(36)
57
ESP32-bewegingsalarm (PIR + buzzer + LED + Telegram)
ES-41Gevorderd
Premium

ESP32-bewegingsalarm (PIR + buzzer + LED + Telegram)

Een slim beveiligingsalarm: als de PIR-sensor beweging detecteert, gaat de buzzer af, licht de LED op en krijgt de eigenaar direct een Telegram-melding. Een afkoeltijd van 30 seconden beperkt hoe vaak het alarm zich herhaalt; valse detecties van de PIR-sensor filtert dit niet weg. Gebruik het thuis, in een garage, een berging of een studeerkamer.

9
Raspberry Pi Pico-knop ontdenderen: IRQ vs software-polling
PI-13Gemiddeld
Premium

Raspberry Pi Pico-knop ontdenderen: IRQ vs software-polling

Als één druk op een knop je code 3-4 keer liet tellen, is contactdender de boosdoener: de metalen contacten van de knop gaan binnen microseconden vele malen open en dicht als ze elkaar raken! In dit project tellen we dezelfde knop op 2 manieren en vergelijken we ze naast elkaar in Serial: RAW-polling (vangt de dender op en telt fout) en IRQ + software-ontdendering (telt goed).

12
Lasersysteem voor beveiliging
AR-23Gevorderd
Premium

Lasersysteem voor beveiliging

Net als de laserroofscènes in films: een laserstraal valt op een lichtsensor en zodra iemand de straal onderbreekt, gaat de rode led branden en begint de buzzer te piepen.

4.8(61)
78