Reedkontakt am Arduino: Türsensor, Alarmanlage und Tacho bauen

Ein Reedkontakt (Reed-Schalter, Magnetschalter) ist ein einfacher Sensor, der einen Stromkreis schließt, wenn ein Magnet zwei dünne Metallzungen in einem Glasröhrchen zusammenzieht; er selbst verbraucht dabei keinerlei Strom. Am Arduino liest du ihn genau wie einen Taster: Ist ein Magnet in der Nähe, schließt der Kontakt, entfernt er sich, öffnet er wieder. Dieses kleine Glasröhrchen steckt in Tür- und Fensteralarmen, Fahrradtachos, Schwimmerschaltern und Windmessern.

In dieser Anleitung lernst du Schritt für Schritt, was in einem Reedkontakt steckt, welche Typen es gibt (Schließer und Öffner), bei welchem Abstand und in welcher Ausrichtung der Magnet am besten wirkt und wie du ihn mit einem Pull-up-Widerstand an den Arduino anschließt. Danach entprellst du den Kontakt per Software, baust einen Türalarm und einen Fahrradtacho, schickst mit einem ESP32 die Nachricht "Tür geöffnet" auf dein Handy und bringst dieselbe Schaltung mit MicroPython auf einem Raspberry Pi Pico zum Laufen. Zum Schluss vergleichen wir den Reedkontakt mit einem Hall-Sensor und sammeln die häufigsten Fehler.

Was ist ein Reedkontakt und wie funktioniert er?

Das Herz eines Reedkontakts ist ein kleines Glasröhrchen, das mit einem reaktionsträgen Gas wie Stickstoff gefüllt oder luftleer ist. Von beiden Enden ragen zwei biegsame Zungen aus einer Nickel-Eisen-Legierung hinein und überlappen sich in der Mitte mit einem sehr kleinen Spalt; das englische Wort "reed" (Zunge) bezieht sich auf sie. Die Spitzen sind mit harten Metallen wie Rhodium oder Ruthenium beschichtet, was den Übergangswiderstand niedrig hält und den Verschleiß verringert. Kommt ein Magnet in die Nähe, werden beide Zungen magnetisiert, an den überlappenden Spitzen entstehen entgegengesetzte Pole, und die Zungen ziehen sich bis zur Berührung an. Entfernt sich der Magnet, trennt die Federkraft der Zungen die Kontakte wieder. Weil das Glas die Kontakte vor Staub, Feuchtigkeit und Oxidation schützt, schaffen Reedkontakte bei kleinem Strom Hunderte Millionen Schaltspiele.

Im Handel wird das Bauteil oft auch "Reed-Relais" genannt, technisch ist das Glasröhrchen allein aber ein Reedkontakt (Reed-Schalter). Ein echtes Reed-Relais ist dasselbe Röhrchen mit einer Spule darum; dort schließt der Strom durch die Spule die Kontakte statt eines Magneten. In diesem Artikel geht es um den magnetisch betätigten Schalter und die Sensormodule, auf denen er sitzt. Sein größter Vorteil: Er verbraucht selbst keinen Strom. Durch ihn fließt nur der Strom deiner eigenen Schaltung, deshalb ist er ideal für Geräte, die monatelang mit Batterien laufen.

Technische Daten des Reedkontakts

Die Empfindlichkeit wird in AW (Amperewindungen) angegeben: Strom mal Windungszahl, die in einer genormten Prüfspule nötig sind, um den Reed zu schließen. Je kleiner der Wert, desto schwächer darf der Magnet sein und desto größer ist der Schaltabstand. Dazu kommt eine Hysterese: Das Feld zum Schließen der Kontakte (Anzug) ist stärker als das Feld, das sie geschlossen hält. Ein Reed, den ein Magnet bei 15 mm schließt, öffnet zum Beispiel erst wieder bei etwa 20 mm. Dieser Unterschied verringert das Flattern bei kleinen Erschütterungen, aber in deinem Aufbau muss der Magnet auch über den Abfallabstand hinaus wandern.

Schließer, Öffner und Wechsler (Form A, B, C)

Reedkontakte gibt es in drei Kontaktanordnungen. Die Angaben NO (Schließer, normally open) und NC (Öffner, normally closed) beschreiben immer den Zustand ohne Magnet.

Auslösen mit dem Magneten: Abstand, Ausrichtung und Empfindlichkeit

Am besten löst du einen Reedkontakt mit einem kleinen Neodym-Magneten aus. Eine Neodym-Scheibe mit 10×3 mm schaltet einen üblichen Reed meist aus 10–20 mm; ein schwarzer Ferritmagnet gleicher Größe schafft etwa die Hälfte. Fertige Türsensoren arbeiten typisch mit 15–25 mm. Der Abstand hängt aber nicht nur von der Stärke, sondern auch von der Ausrichtung ab: Liegt die Nord-Süd-Achse des Magneten parallel zum Glasröhrchen und nähert er sich dessen Mitte, erhältst du ein einziges, sauberes Schließen. Steht der Magnet quer zum Röhrchen, schaltet er genau in der Mitte womöglich gar nicht, dafür an zwei Stellen nahe den Enden. Schiebt man einen parallelen Magneten am Röhrchen entlang, entstehen außerdem neben dem Hauptbereich zwei kleine Nebenzonen. Fährt der Magnet am Reed vorbei, kann der Kontakt daher zwei- bis dreimal schließen und öffnen; das ist der häufigste Grund, warum Zählprojekte eine Umdrehung als zwei oder drei zählen.

• Die Polarität ist egal: Ein Reed reagiert auf Nord- und Südpol gleich; den Magneten umzudrehen ändert nichts.
• Magnet zur Mitte des Röhrchens ausrichten: Bei Türsensoren sollten Magnet und Reedgehäuse nebeneinander und parallel sitzen, mit möglichst kleinem Spalt.
• Stahltüren verkürzen den Abstand: Eisen bündelt das Magnetfeld in sich. Setze Sensor und Magnet mit einem 5–10 mm dicken Kunststoff-Abstandshalter auf oder nimm einen stärkeren Magneten.
• Erst den Abstand messen: Bewege den Magneten bei geöffnetem seriellen Monitor langsam heran und wieder weg. Bei geschlossener Tür sollte der Magnet sicher innerhalb des Anzugsabstands liegen, bei leicht geöffneter Tür schon außerhalb des Abfallabstands.
• Abstand zu starken Feldern halten: Lautsprecher, Motoren und andere Magnete können den Reed ungewollt schließen; montiere ihn nicht direkt daneben.

Reedkontakt am Arduino anschließen: Warum ist ein Pull-up-Widerstand nötig?

Da sich ein Reedkontakt wie ein Taster verhält, erzeugt er selbst keine Spannung; er verbindet oder trennt nur seine beiden Anschlüsse. Bei offenem Kontakt hängt der Pin in der Luft (er floatet), und du liest durch Störungen zufällige HIGH- und LOW-Werte. Die Lösung ist ein Pull-up-Widerstand: Der Pin wird über einen Widerstand auf 5 V (oder 3,3 V) gezogen, und der Reed kommt zwischen Pin und GND. Ohne Magnet liest der Pin HIGH; schließt der Magnet den Kontakt, liegt der Pin direkt an GND und liest LOW. Der Arduino Uno hat einen internen Pull-up von 20–50 kΩ, daher genügt pinMode(pin, INPUT_PULLUP), ein externer Widerstand ist nicht nötig. Die Details dieser Logik findest du im Artikel Taster am Arduino anschließen.

Schritt für Schritt: die erste Schaltung erkennt den Magneten

1. Verbinde ein Beinchen des Reedkontakts mit Pin D2 des Arduino und das andere mit GND. Ein einzelner Reed hat keine Polarität, die Richtung der Beinchen spielt keine Rolle.
2. Nutzt du ein Modul, verbinde VCC mit 5V, GND mit GND und den Ausgang DO mit D2.
3. Lade den folgenden Code hoch und öffne den seriellen Monitor mit 9600 Baud.
4. Nähere den Magneten langsam und parallel zum Glasröhrchen; die LED auf der Platine sollte leuchten und "magnet detected" sollte erscheinen.
5. Miss beim Wegbewegen mit einem Lineal, bei welchem Abstand die LED erlischt; das ist dein Abfallabstand.

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}

Achte im Code nur auf die umgekehrte Logik: Wegen INPUT_PULLUP liest du LOW, wenn der Magnet da ist, und HIGH, wenn nicht. Bei 3-poligen Modulen mit LM393 geht der Ausgang meist ebenfalls auf LOW, wenn sich der Magnet nähert, und die DO-LED auf der Platine leuchtet; da das je nach Modell abweichen kann, prüfe dein Modul zuerst im seriellen Monitor. Das Potentiometer stellt die Schwelle des Komparators ein; weil der Reed ohnehin nur offen oder geschlossen ist, hat es kaum Einfluss auf den Schaltabstand, und die Mittelstellung genügt meistens. Mini-Module wie das KY-021 haben keinen Komparator; auf der Platine sitzen nur der Reed und ein 10-kΩ-Widerstand.

Entprellen: Kontaktprellen und Erschütterungen

Wie jeder mechanische Kontakt kann auch ein Reed beim Schließen ein paarmal prellen. Beim Reed ist dieses Prellen sehr kurz, meist unter 1 ms, doch das eigentliche Problem liegt woanders. Bewegt sich der Magnet langsam an der Grenze des Anzugsabstands oder klappert die Tür im Wind, kann der Kontakt innerhalb einer Sekunde viele Male öffnen und schließen. Ein System, das beim Öffnen der Tür eine Nachricht schickt, verschickt deshalb womöglich fünf Meldungen für ein einziges Öffnen. Die Lösung: Statt jede Änderung sofort zu übernehmen, wartest du, bis der Zustand eine bestimmte Zeit stabil bleibt. Für einen Türsensor reichen 50–100 ms; bei einem Drehzahlzähler bewährt sich die kürzeste physikalisch mögliche Zeit zwischen zwei Impulsen als Sperrzeit.

Wenn du eine Hardwarelösung möchtest, setze einen 100-nF-Kondensator zwischen Pin und GND. Zusammen mit einem 10-kΩ-Pull-up ergibt sich eine Zeitkonstante von τ = R × C = 10 kΩ × 100 nF = 1 ms, die sehr kurze Preller glättet. Andere Kombinationen aus Widerstand und Kondensator kannst du mit dem RC-Zeitkonstanten-Rechner ausprobieren. Mit dem internen Pull-up liegt der Widerstand bei 20–50 kΩ, die Zeit steigt also auf 2–5 ms. Bei Türsensoren mit mehreren Metern Kabel schützen ein externer Pull-up von 4,7–10 kΩ und dieser Kondensator zusätzlich vor Störungen.

Tür- und Fensterkontakt mit Alarm: das Projekt

Das häufigste Reed-Projekt ist ein Türsensor. Befestige den Magneten am beweglichen Türflügel und den Reed am Rahmen; bei geschlossener Tür liegen beide nebeneinander, der Kontakt ist geschlossen und der Pin liest LOW. Öffnet sich die Tür, entfernt sich der Magnet und der Pin geht auf HIGH. Diese Anordnung hat einen schönen Nebeneffekt: Durchtrennt jemand das Sensorkabel, geht der Pin ebenfalls auf HIGH, und das System wertet es als "Tür geöffnet". Genau deshalb arbeiten Alarmanlagen mit Ruhestromschleifen. Der folgende Code zählt jedes Öffnen, misst, wie lange die Tür offen bleibt, und lässt den Summer im Takt piepen, wenn die Tür länger als 30 Sekunden offen steht; perfekt für Kühlschrank oder Gefriertruhe.

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}

Weil der Code kein delay() verwendet, prüft die Schleife den Pin ständig und verpasst kein Öffnen; diese Technik erklären wir ausführlich im Artikel millis statt delay. Jedes Mal, wenn sich der Rohwert ändert, wird die Zeit lastChange neu gesetzt, und der Zustand doorOpen ändert sich erst, wenn der Wert 50 ms lang gleich bleibt. Der Summer-Teil teilt millis() durch 250 und schaltet so jede Viertelsekunde um. Für eine echte Alarmanlage kannst du das System mit einem Keypad und Code scharf- und unscharf schalten und im Raum einen PIR-Bewegungsmelder ergänzen. Einen umfassenderen Aufbau findest du im Artikel Alarmanlage mit Arduino.

Fahrradtacho: Umdrehungen mit dem Reedkontakt zählen

Die meisten Fahrradtachos bestehen aus einem Reedkontakt und einem kleinen Magneten an einer Speiche. Bei jeder Radumdrehung fährt der Magnet einmal am Reed an der Gabel vorbei und erzeugt einen Impuls. Misst du die Zeit zwischen zwei Impulsen, erhältst du die Geschwindigkeit; zählst du die Impulse, die Strecke: Geschwindigkeit (km/h) = Umfang (mm) / Zeit (ms) × 3,6. Dabei entspricht mm/ms genau m/s, und der Faktor 3,6 rechnet in km/h um. Beispiel: Bei einem 700x25C-Rad mit 2105 mm Umfang und 253 ms zwischen zwei Impulsen ergibt sich 2105 / 253 × 3,6 ≈ 30 km/h. Am genauesten bestimmst du den Umfang, indem du das Rad mit dem Ventil unten genau eine Umdrehung abrollst und den Abstand der beiden Markierungen am Boden misst.

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}

Da der Impuls mit attachInterrupt erfasst wird, geht keine Umdrehung verloren, egal wie beschäftigt loop() ist; beim Arduino Uno liefern nur die Pins D2 und D3 diese Art von Interrupt. Der Wert LOCKOUT_MS ist sehr wichtig: 80 ms entsprechen bei einem Rad mit 2105 mm einer Höchstgeschwindigkeit von etwa 95 km/h (2105 / 80 × 3,6). Impulse, die schneller aufeinander folgen, sind physikalisch unmöglich und werden als Prellen, Nebenzonen des Magneten oder Prellen beim Öffnen ignoriert. Kommt 3 Sekunden lang kein Impuls, gilt die Geschwindigkeit als null. Mit demselben Aufbau misst du auch die Drehzahl eines Motors oder Rades: U/min = 60000 / Zeit (ms). Mehr zu Interrupts findest du in der Anleitung Arduino-Interrupts; um die Geschwindigkeit am Lenker anzuzeigen, kombiniere den Code mit einem OLED-Display.

Reedkontakt oder Hall-Sensor?

Die zweite Möglichkeit, einen Magneten zu erkennen, ist ein Hall-Sensor. Er wandelt das Magnetfeld in einem Halbleiterchip in ein elektrisches Signal um; er hat keine beweglichen Teile, braucht aber eine Versorgungsspannung. Die Faustregel: Für einen Tür- oder Fenstersensor, der lange mit Batterie läuft und selten auslöst, nimm einen Reed; für schnelles, dauerhaftes Zählen wie bei einem Motor, einem Lüfter oder einem Durchflusssensor, die sich Dutzende Male pro Sekunde drehen, ist ein Hall-Sensor die bessere Wahl.

Tür-offen-Benachrichtigung mit dem ESP32 (Telegram)

Dank WLAN kann der ESP32-Türsensor dir in dem Moment, in dem die Tür aufgeht, eine Nachricht aufs Handy schicken. Dafür erstellst du in Telegram mit BotFather einen Bot, holst dir den Token und deine eigene Chat-ID und installierst in der Arduino IDE die Bibliotheken UniversalTelegramBot und ArduinoJson; diese Schritte erklären wir ausführlich im Artikel ESP32-Telegram-Bot. Verbinde ein Beinchen des Reeds mit GPIO 27 und das andere mit GND. Der Code meldet das Öffnen und Schließen der Tür, erinnert dich, wenn sie länger als 5 Minuten offen steht, und versucht es 10 Sekunden später erneut, falls das WLAN gerade weg ist.

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}

Eine Nachricht an Telegram zu senden kann 1–2 Sekunden dauern, und so lange wartet die Schleife; weil die Zustandsmaschine den Pin danach aber erneut liest, geht der letzte Zustand der Tür nie verloren. Soll der Sensor mit Batterie laufen, schicke den ESP32 in den Deep Sleep und lass ihn mit esp_sleep_enable_ext0_wakeup(GPIO_NUM_27, 1) aufwachen, sobald die Tür aufgeht und der Pin HIGH wird. Stellst du vor dem Einschlafen den Weckpegel auf das Gegenteil des aktuellen Pin-Zustands, wacht die Platine beim Öffnen und beim Schließen auf. Denk dabei auch an den Strom durch den Pull-up: Bei geschlossener Tür ist der Reed geschlossen, und durch einen 10-kΩ-Widerstand fließen dauerhaft 3,3 V / 10 kΩ = 330 µA; mit 100 kΩ sind es nur 33 µA. Im Deep Sleep ist ein externer Widerstand sicherer als der interne Pull-up. Die Akkulaufzeit schätzt du mit dem Akkulaufzeit-Rechner ab.

Reedkontakt mit Raspberry Pi Pico und MicroPython

Einen Reedkontakt am Raspberry Pi Pico auszulesen, sind mit MicroPython nur ein paar Zeilen. Schließe den Reed zwischen GP15 und GND an, den Pluspol des aktiven Summers an GP14 und den Minuspol an GND. Da der Pico mit 3,3 V arbeitet, versorge ein Modul unbedingt über den Pin 3V3(OUT); speist du das Modul mit 5 V, liegt auch der Ausgang DO bei 5 V und kann den Eingang des Pico beschädigen. Der interne Pull-up des Pico liegt bei etwa 50–80 kΩ und reicht für kurze Kabel aus.

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)

Der Code baut dieselbe Entprell-Logik wie beim Arduino mit time.ticks_ms() und time.ticks_diff() auf; ticks_diff liefert auch beim Überlauf des Zählers die richtige Differenz. Für Impulse, die nicht verloren gehen dürfen, etwa bei einem Tacho, kannst du mit reed.irq(trigger=Pin.IRQ_FALLING, handler=...) einen Interrupt nutzen. Mit einem Pico W kannst du das Pico-W-Beispiel aus dem Artikel Telegram-Bot ergänzen, um dasselbe Ereignis per WLAN aufs Handy zu schicken. Wenn du den Pico zum ersten Mal nutzt, beginne mit der Anleitung Was ist der Raspberry Pi Pico.

Projektideen mit dem Reedkontakt

• Funk-Tür- und Fenstersensor: Melde jedes Öffnen zu Hause mit einem ESP32 aufs Handy oder schicke es per MQTT an Home Assistant.
• Kühlschranktür-Warner: Er piept im Takt, wenn die Tür länger als 30 Sekunden offen steht.
• Fahrradcomputer: Zeige aktuelle Geschwindigkeit, Gesamtstrecke und Durchschnittstempo auf einem Display.
• Wind- und Regenmesser: In Wetterstationen erzeugt das Schalenanemometer pro Umdrehung und der Kippwaagen-Regenmesser pro Kippen einen Reed-Impuls.
• Schwimmerschalter: Der Magnet im Schwimmer öffnet und schließt den Reed im Schaft und meldet so den vollen Tank; Details im Artikel Wasserstandssensor.
• Geheimes Schubladenschloss: Baue ein Solenoid-Schloss, das sich nur öffnet, wenn ein Magnet an die richtige Stelle gehalten wird.
• Briefkasten-Melder: Ein Reed an der Klappe weckt den ESP32 aus dem Deep Sleep, wenn Post kommt.

Häufige Fehler und Lösungen

• Der Pin liest zufällige Werte: Es fehlt ein Pull-up. Setze pinMode auf INPUT_PULLUP oder ergänze einen externen 10-kΩ-Pull-up-Widerstand.
• Die Logik ist vertauscht: Mit Pull-up liest der Pin LOW, wenn der Magnet da ist; vielleicht erwartet dein Code HIGH, oder dein Sensor ist ein Öffner (NC). Prüfe es mit dem Multimeter.
• Mehrere Zählungen pro Öffnen: Es fehlt die Entprellung, oder der Magnet läuft durch die Nebenzonen. Ergänze eine Stabilitätszeit und richte den Magneten parallel zum Röhrchen aus.
• Der Reed schließt nie: Der Magnet ist zu schwach, der Abstand zu groß, der Magnet steht quer zur Mitte des Röhrchens oder eine Stahltür schluckt das Feld. Nimm einen stärkeren Neodym-Magneten und einen Kunststoff-Abstandshalter.
• Der Reed bleibt dauerhaft geschlossen: Die Kontakte sind durch zu hohen Strom oder eine kapazitive Last womöglich verschweißt. Schalte Motoren, Lampen oder Relaisspulen nie direkt mit einem Reed; nutze ein Relaismodul oder einen Transistor.
• Das Glasröhrchen ist gesprungen: Die Beinchen wurden zu nah am Körper gebogen. Halte das Beinchen mit einer Zange fest, biege es mindestens 2–3 mm vom Glas entfernt und löte zügig.
• Fehlalarme bei langen Kabeln: Der interne Pull-up ist zu schwach. Verwende einen externen Pull-up von 4,7–10 kΩ, einen 100-nF-Kondensator am Pin und verdrilltes Kabel.

Ein Reedkontakt ist ein günstiger und äußerst zuverlässiger Sensor, der einen Magneten ganz ohne eigenen Stromverbrauch erkennt; mit der richtigen Magnetausrichtung, einem Pull-up-Widerstand und ein paar Zeilen Entprell-Code arbeitet er jahrelang problemlos. In der BlueGrays-App findest du die Projekte Reedkontakt auslesen und Reedkontakt-Türsensor sowie Projekte wie den ESP32-Bewegungsalarm und die Alarmanlage mit Telegram-Benachrichtigung, jeweils Schritt für Schritt mit Schaltplan und Code.