Interruptor reed Arduino: sensor de puerta, alarma y velocímetro

Un interruptor reed (sensor magnético o relé reed) es un sensor sencillo que cierra un circuito cuando un imán junta dos finas láminas metálicas dentro de un tubo de vidrio, y que por sí mismo no consume nada de energía. En Arduino se lee igual que un pulsador: con un imán cerca el contacto se cierra y, al alejarlo, se vuelve a abrir. Este pequeño tubo de vidrio está dentro de alarmas de puertas y ventanas, cuentakilómetros de bicicleta, interruptores de nivel con flotador y anemómetros.

En esta guía aprenderás paso a paso qué hay dentro de un interruptor reed, los tipos NA y NC, a qué distancia y con qué orientación funciona mejor el imán y cómo conectarlo a Arduino con una resistencia pull-up. Después resolverás el rebote del contacto por software, construirás una alarma de puerta abierta y un velocímetro de bicicleta, enviarás a tu móvil un aviso de "puerta abierta" con un ESP32 y harás funcionar el mismo circuito en una Raspberry Pi Pico con MicroPython. En las últimas secciones comparamos el reed con un sensor Hall y reunimos los errores más frecuentes.

¿Qué es un interruptor reed y cómo funciona?

El corazón de un interruptor reed es un pequeño tubo de vidrio relleno de un gas inerte, como el nitrógeno, o al vacío. Por sus dos extremos entran dos láminas flexibles de aleación de níquel y hierro que se solapan en el centro con una separación muy pequeña; la palabra inglesa "reed" (lengüeta) viene de ellas. Sus puntas están recubiertas de metales duros como el rodio o el rutenio, lo que mantiene baja la resistencia de contacto y reduce el desgaste. Cuando se acerca un imán, las dos láminas se magnetizan, en las puntas solapadas aparecen polos opuestos y se atraen hasta tocarse. Al alejar el imán, la elasticidad de las láminas vuelve a separar los contactos. Como el vidrio protege los contactos del polvo, la humedad y la oxidación, un interruptor reed puede conmutar cientos de millones de veces con corrientes bajas.

Muchas tiendas llaman a esta pieza "relé reed", pero técnicamente el tubo de vidrio por sí solo es un interruptor reed (reed switch). Un relé reed de verdad es el mismo tubo con una bobina enrollada alrededor; en él, la corriente de la bobina cierra los contactos en lugar de un imán. Este artículo trata del interruptor accionado por imán y de los módulos sensores que lo incorporan. Su mayor ventaja es que no consume energía: solo pasa por él la corriente de tu propio circuito, por eso es ideal para dispositivos que funcionan meses con pilas.

Características técnicas del interruptor reed

La sensibilidad se expresa en AT (amperios-vuelta): la corriente multiplicada por el número de espiras que hacen falta para cerrar el reed en una bobina de prueba estándar. Cuanto menor es el valor, más débil puede ser el imán y, por tanto, mayor la distancia de activación. También hay histéresis: el campo necesario para cerrar los contactos (activación) es más fuerte que el que hace falta para mantenerlos cerrados. Por ejemplo, un reed que el imán cierra a 15 mm puede no abrirse de nuevo hasta unos 20 mm. Esta diferencia reduce los cierres y aperturas por pequeñas vibraciones, pero en tu diseño el imán también debe alejarse más allá de la distancia de desactivación.

Tipos NA, NC y conmutado (Forma A, B y C)

Los interruptores reed tienen tres disposiciones de contacto. Las indicaciones NA (normalmente abierto, NO en inglés) y NC (normalmente cerrado) describen siempre el estado del contacto sin imán.

Activación con imán: distancia, orientación y sensibilidad

La mejor forma de activar un interruptor reed es un pequeño imán de neodimio. Un disco de neodimio de 10×3 mm suele activar un reed común a 10–20 mm; un imán de ferrita negro del mismo tamaño reduce esa distancia aproximadamente a la mitad. Los sensores de puerta comerciales suelen trabajar a 15–25 mm. La distancia no depende solo de la fuerza del imán, sino también de su orientación: si el eje norte-sur del imán está paralelo al tubo de vidrio y se acerca a su centro, obtienes un único cierre limpio. Si el imán está perpendicular al tubo, puede no activarlo justo en el centro y hacerlo en dos puntos cerca de los extremos. Al deslizar un imán paralelo a lo largo del tubo aparecen además pequeñas zonas de cierre a ambos lados de la principal. Por eso, cuando el imán pasa por delante del reed, el contacto puede cerrarse y abrirse dos o tres veces; es la causa más habitual de que un proyecto de conteo registre una vuelta como dos o tres.

• La polaridad no importa: El reed reacciona igual al polo norte y al polo sur; dar la vuelta al imán no cambia el resultado.
• Alinea el imán con el centro del tubo: En los sensores de puerta, el imán y el cuerpo del reed deben quedar uno junto al otro y en paralelo, con la menor separación posible.
• Las puertas de acero acortan la distancia: El hierro concentra en sí mismo el campo del imán. Eleva el sensor y el imán con un separador de plástico de 5–10 mm o usa un imán más fuerte.
• Mide primero la distancia: Con el monitor serie abierto, acerca y aleja el imán despacio. Con la puerta cerrada, el imán debe estar holgadamente dentro de la distancia de activación y, al entreabrirla, fuera de la distancia de desactivación.
• Mantenlo lejos de campos fuertes: Altavoces, motores y otros imanes pueden cerrar el reed sin querer; no lo montes justo al lado de ellos.

Conexión del interruptor reed a Arduino: ¿por qué hace falta una resistencia pull-up?

Como el interruptor reed se comporta como un pulsador, no genera ninguna tensión por sí mismo; solo une o separa sus dos patas. Con el contacto abierto, el pin no está conectado a nada (queda flotante) y lees valores HIGH y LOW aleatorios por el ruido. La solución es una resistencia pull-up: el pin se lleva a 5 V (o 3,3 V) mediante una resistencia y el reed se conecta entre el pin y GND. Sin imán el pin lee HIGH; cuando el imán cierra el contacto, el pin queda unido directamente a GND y lee LOW. El Arduino Uno tiene una resistencia pull-up interna de 20–50 kΩ, así que basta con escribir pinMode(pin, INPUT_PULLUP) y no necesitas resistencia externa. Encontrarás los detalles de esta lógica en la guía cómo conectar un pulsador a Arduino.

Primer circuito paso a paso: detectar el imán

1. Conecta una pata del interruptor reed al pin D2 del Arduino y la otra a GND. Un reed suelto no tiene polaridad, así que da igual el sentido de las patas.
2. Si usas un módulo, conecta VCC a 5V, GND a GND y la salida DO a D2.
3. Carga el código siguiente y abre el monitor serie a 9600 baudios.
4. Acerca despacio el imán, paralelo al tubo de vidrio; el LED de la placa debe encenderse y en pantalla debe aparecer "magnet detected".
5. Al alejar el imán, mide con una regla a qué distancia se apaga el LED; esa es tu distancia de desactivación.

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}

Lo único a lo que debes prestar atención en el código es la lógica invertida: como usas INPUT_PULLUP, lees LOW cuando hay imán y HIGH cuando no lo hay. En los módulos de 3 pines con LM393, la salida también suele pasar a LOW al acercar el imán y se enciende el LED DO de la placa; como puede variar de un modelo a otro, comprueba primero tu módulo en el monitor serie. El potenciómetro del módulo ajusta el umbral del comparador; como el reed ya funciona como abierto o cerrado, apenas influye en la distancia de detección y normalmente basta con dejarlo en la posición central. Los minimódulos como el KY-021 no tienen comparador; en la placa solo hay el reed y una resistencia de 10 kΩ.

Antirrebote: rebote del contacto y vibraciones

Como cualquier contacto mecánico, el reed puede rebotar unas cuantas veces al cerrarse. En un reed este rebote es muy corto, normalmente menos de 1 ms, pero el verdadero problema es otro. Si el imán se mueve despacio en el límite de la distancia de activación o la puerta vibra con el viento, el contacto puede abrirse y cerrarse muchas veces en un segundo. Por eso un sistema que avisa cuando se abre la puerta puede enviar cinco mensajes por una sola apertura. La solución es esperar a que el estado se mantenga sin cambios durante un tiempo en lugar de aceptar cada cambio al instante. Para un sensor de puerta bastan 50–100 ms; en un contador de velocidad funciona bien usar como tiempo de bloqueo el intervalo más corto físicamente posible entre dos pulsos.

Si prefieres una solución por hardware, puedes poner un condensador de 100 nF entre el pin y GND. Junto con una pull-up de 10 kΩ se obtiene una constante de tiempo de τ = R × C = 10 kΩ × 100 nF = 1 ms, que suaviza los rebotes muy cortos. Puedes probar otras combinaciones de resistencia y condensador con la calculadora de constante de tiempo RC. Con la pull-up interna la resistencia es de 20–50 kΩ, así que el tiempo sube a 2–5 ms. En sensores de puerta con varios metros de cable, una pull-up externa de 4,7–10 kΩ y este condensador también protegen frente al ruido.

Sensor de puerta y ventana abierta: proyecto de alarma

El proyecto con reed más habitual es el sensor de puerta. Coloca el imán en la hoja móvil de la puerta y el reed en el marco; con la puerta cerrada quedan uno junto al otro, el contacto está cerrado y el pin lee LOW. Al abrir la puerta, el imán se aleja y el pin pasa a HIGH. Esta disposición tiene un efecto secundario muy útil: si alguien corta el cable del sensor, el pin también pasa a HIGH y el sistema lo interpreta como "puerta abierta". Por eso las alarmas utilizan circuitos de lazo cerrado. El código siguiente cuenta cada apertura, mide cuánto tiempo permanece abierta la puerta y hace pitar el zumbador de forma intermitente si queda abierta más de 30 segundos; es perfecto para la puerta de la nevera o del congelador.

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}

Como el código no usa delay(), el bucle comprueba el pin continuamente y no se pierde ninguna apertura; explicamos esta técnica con detalle en el artículo millis frente a delay. Cada vez que cambia la lectura en bruto se reinicia el tiempo lastChange, y el estado doorOpen solo cambia si el valor se mantiene igual durante 50 ms. La parte del zumbador divide millis() entre 250 para encenderlo y apagarlo cada cuarto de segundo. Para convertirlo en una alarma de verdad, puedes armarla y desarmarla con un teclado matricial y una contraseña, y añadir un sensor de movimiento PIR dentro de la habitación. Para un montaje más completo, echa un vistazo al artículo sistema de alarma con Arduino.

Velocímetro de bicicleta: contar vueltas con un interruptor reed

La mayoría de los cuentakilómetros de bicicleta se componen de un interruptor reed y un pequeño imán sujeto a un radio. Cada vez que la rueda gira, el imán pasa una vez por delante del reed de la horquilla y genera un pulso. Si mides el tiempo entre dos pulsos obtienes la velocidad y, si cuentas los pulsos, la distancia: velocidad (km/h) = circunferencia (mm) / tiempo (ms) × 3,6. Aquí mm/ms equivale exactamente a m/s, y multiplicar por 3,6 lo convierte en km/h. Por ejemplo, en una rueda 700x25C de 2105 mm de circunferencia, 253 ms entre dos pulsos dan 2105 / 253 × 3,6 ≈ 30 km/h. La forma más precisa de medir la circunferencia es hacer rodar la rueda exactamente una vuelta con la válvula abajo y medir la distancia entre las dos marcas en el suelo.

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}

Como el pulso se captura con attachInterrupt, no se pierde ninguna vuelta por muy ocupado que esté loop(); en el Arduino Uno solo los pines D2 y D3 ofrecen este tipo de interrupción. El valor LOCKOUT_MS es muy importante: 80 ms equivalen a una velocidad máxima de unos 95 km/h en una rueda de 2105 mm (2105 / 80 × 3,6). Los pulsos que llegan más seguidos son físicamente imposibles y se ignoran como rebotes, zonas laterales del imán o rebote del contacto al abrirse. Si no llega ningún pulso en 3 segundos, la velocidad se considera cero. Con la misma estructura puedes medir también las revoluciones de un motor o una rueda: RPM = 60000 / tiempo (ms). Para saber más sobre interrupciones, consulta la guía interrupciones en Arduino; para mostrar la velocidad en el manillar, combina el código con una pantalla OLED.

¿Interruptor reed o sensor Hall?

La segunda forma de detectar un imán es un sensor Hall. El sensor Hall convierte el campo magnético en una señal eléctrica dentro de un chip semiconductor; no tiene piezas móviles, pero necesita alimentación para funcionar. La regla rápida: para un sensor de puerta o ventana que funcionará mucho tiempo con pilas y se activa pocas veces, elige un reed; para conteos rápidos y continuos, como un motor, un ventilador o un sensor de caudal de agua que giran decenas de veces por segundo, el sensor Hall es la mejor opción.

Aviso de puerta abierta con ESP32 (Telegram)

Gracias al Wi-Fi del ESP32, el sensor de puerta puede enviar un mensaje a tu móvil en el momento en que se abre la puerta. Para ello tienes que crear un bot con BotFather en Telegram, obtener su token y tu propio chat ID, e instalar las librerías UniversalTelegramBot y ArduinoJson en el Arduino IDE; explicamos estos pasos con detalle en el artículo bot de Telegram con ESP32. Conecta una pata del reed al GPIO 27 y la otra a GND. El código envía un mensaje cuando la puerta se abre y se cierra, te lo recuerda si sigue abierta más de 5 minutos y, si en ese momento no hay Wi-Fi, vuelve a intentarlo 10 segundos después.

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}

Enviar un mensaje a Telegram puede tardar 1–2 segundos y durante ese tiempo el bucle espera; sin embargo, como la máquina de estados vuelve a leer el pin al terminar el envío, nunca se pierde el último estado de la puerta. Si quieres alimentar el sensor con pilas, pon el ESP32 en sueño profundo y usa esp_sleep_enable_ext0_wakeup(GPIO_NUM_27, 1) para que se despierte cuando la puerta se abra y el pin pase a HIGH. Si antes de dormir configuras el nivel de despertar al contrario del estado actual del pin, la placa se despertará tanto al abrir como al cerrar. En ese caso ten en cuenta también la corriente que pasa por la pull-up: con la puerta cerrada el reed está cerrado y por una resistencia de 10 kΩ circulan de forma continua 3,3 V / 10 kΩ = 330 µA; con 100 kΩ la corriente baja a 33 µA. En sueño profundo, lo más seguro es usar una resistencia externa en lugar de la pull-up interna. Puedes estimar la duración de la batería con la calculadora de duración de batería.

Interruptor reed con Raspberry Pi Pico y MicroPython

Leer un interruptor reed en la Raspberry Pi Pico son solo unas líneas de MicroPython. Conecta el reed entre GP15 y GND, y el polo positivo del zumbador activo a GP14 y el negativo a GND. Como la Pico funciona a 3,3 V, si usas un módulo aliméntalo siempre desde el pin 3V3(OUT); si lo alimentas con 5 V, la salida DO sube a 5 V y puede dañar la entrada de la Pico. La pull-up interna de la Pico ronda los 50–80 kΩ y basta para cables cortos.

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)

El código implementa la misma lógica antirrebote que en Arduino con time.ticks_ms() y time.ticks_diff(); ticks_diff da la diferencia correcta incluso cuando el contador se desborda. Para pulsos que no deben perderse, como en un velocímetro, puedes usar una interrupción con reed.irq(trigger=Pin.IRQ_FALLING, handler=...). Si tienes una Pico W, añade a este código el ejemplo para Pico W del artículo del bot de Telegram y envía el mismo evento a tu móvil por Wi-Fi. Si es la primera vez que usas la Pico, empieza por la guía qué es la Raspberry Pi Pico.

Ideas de proyectos con interruptor reed

• Sensor inalámbrico de puertas y ventanas: Avisa a tu móvil de cada apertura en casa con un ESP32 o envíala a Home Assistant por MQTT.
• Avisador de puerta de la nevera: Pita de forma intermitente cuando la puerta queda abierta más de 30 segundos.
• Cuentakilómetros de bici: Muestra en una pantalla la velocidad actual, la distancia total y la velocidad media.
• Anemómetro y pluviómetro: En las estaciones meteorológicas, el anemómetro de cazoletas genera un pulso del reed por vuelta y el pluviómetro de balancín uno por cada vuelco.
• Interruptor de nivel con flotador: El imán del flotador abre y cierra el reed del vástago para indicar que el depósito está lleno; más detalles en el artículo sensor de nivel de agua.
• Cerradura secreta de cajón: Construye una cerradura de solenoide que solo se abre al acercar un imán al punto exacto.
• Aviso de buzón: Un reed en la tapa despierta al ESP32 del sueño profundo cuando llega una carta.

Errores frecuentes y soluciones

• El pin lee valores aleatorios: Falta la pull-up. Configura pinMode como INPUT_PULLUP o añade una resistencia pull-up externa de 10 kΩ.
• La lógica funciona al revés: Con pull-up se lee LOW cuando hay imán; quizá tu código espera HIGH o tu sensor es de tipo NC. Compruébalo con el multímetro.
• Varias cuentas por una sola apertura: No hay antirrebote o el imán pasa por las zonas de cierre laterales. Añade un tiempo de estabilidad y alinea el imán en paralelo al tubo.
• El reed nunca se cierra: El imán es débil, la distancia es excesiva, el imán está perpendicular al centro del tubo o una puerta de acero absorbe el campo. Usa un imán de neodimio más potente y un separador de plástico.
• El reed se queda siempre cerrado: Los contactos pueden haberse soldado por exceso de corriente o por una carga capacitiva. No acciones nunca directamente un motor, una lámpara o la bobina de un relé con un reed; conmuta las cargas con un módulo de relé o un transistor.
• El tubo de vidrio se ha agrietado: Las patas se doblaron demasiado cerca del cuerpo. Sujeta la pata con unos alicates, dóblala al menos a 2–3 mm del vidrio y suelda rápido.
• Falsas alarmas con cables largos: La pull-up interna se queda corta. Usa una pull-up externa de 4,7–10 kΩ, un condensador de 100 nF en el pin y cable de par trenzado.

El interruptor reed es un sensor barato y muy fiable que detecta un imán sin consumir energía; con la orientación correcta del imán, una resistencia pull-up y unas pocas líneas de antirrebote funciona sin problemas durante años. En la aplicación BlueGrays encontrarás los proyectos Lectura del interruptor reed y Sensor de puerta con interruptor reed, además de otros como la alarma de movimiento con ESP32 y el sistema de alarma con avisos por Telegram, con esquemas y código paso a paso.