Fundamentos · 11 min de lectura

Resistencia Pull-up: qué es, pull-down e INPUT_PULLUP

¿Qué es una resistencia pull-up y pull-down? Entrada flotante, INPUT_PULLUP, resistencias internas de ESP32 y Pico, pull-ups I2C y cómo elegir el valor.

Una resistencia pull-up es una resistencia, normalmente de 10 kΩ, que conecta una entrada del microcontrolador a la tensión de alimentación (VCC) cuando no se usa, manteniendo el pin en un nivel HIGH estable. La resistencia pull-down hace lo mismo al revés: lleva el pin a masa (GND) y lo mantiene en LOW. Estas pequeñas resistencias son la razón por la que el valor que lees al conectar un botón, un interruptor o un relé reed al Arduino no salta al azar. En la mayoría de las placas ya está dentro del chip; en Arduino basta con escribir INPUT_PULLUP para activarla.

En este artículo aprenderás paso a paso por qué una entrada flotante (floating) genera valores aleatorios, la diferencia entre pull-up y pull-down, las resistencias internas del Arduino Uno, el ESP32 y la Raspberry Pi Pico, cómo se calcula el valor correcto y por qué el bus I2C no funciona sin pull-ups. En cada sección tienes medidas reales, fórmulas y código listo para cargar.

Resistencias de orificio pasante para pull-up y pull-down
Resistencias de orificio pasante: en las entradas de botones, el valor más habitual para pull-up y pull-down es 10 kΩ (marrón-negro-naranja).

¿Qué es una entrada flotante y por qué da problemas?

Un pin de entrada digital es una puerta de impedancia muy alta (cientos de megaohmios) que solo detecta tensión y casi no consume corriente. Si no hay nada conectado al pin, o si con el botón abierto el pin no está conectado a ningún sitio, su tensión queda indefinida. Esto se llama entrada flotante (floating). Un pin así se comporta como una pequeña antena: le afectan los cables cercanos, el campo de 50 Hz de la red eléctrica e incluso la proximidad de tu dedo, y el valor leído oscila entre 0 y 1 decenas de veces por segundo.

Para entender el problema hay que mirar los umbrales lógicos. El ATmega328P del Arduino Uno, alimentado a 5 V, considera HIGH seguro todo lo que supere 3 V (el 60 % de VCC) y LOW seguro lo que esté por debajo de 1,5 V (el 30 % de VCC). La zona intermedia es indefinida, y un pin flotante suele moverse justo ahí. El resultado: el LED se enciende solo sin pulsar el botón, el contador sube aleatoriamente o la interrupción se dispara sin parar. Para verlo con tus propios ojos, conecta solo un cable jumper suelto a D2 sin botón, carga el siguiente código y toca el extremo del cable con el Monitor Serie abierto:

C++ (Arduino IDE)
1void setup() {
2  Serial.begin(9600);
3  pinMode(2, INPUT);                // pull direnci yok, pin havada / no pull resistor, pin is floating
4}
5
6void loop() {
7  Serial.println(digitalRead(2));   // rastgele 0 ve 1 görürsün / you will see random 0s and 1s
8  delay(100);
9}

¿Qué es una resistencia pull-up y pull-down y cómo funcionan?

En un montaje pull-up, un extremo de la resistencia va al pin de entrada y el otro a VCC; el botón se coloca entre el pin y GND. Con el botón abierto casi no circula corriente por el pin, así que no hay caída de tensión en la resistencia y el pin ve el nivel VCC, es decir, HIGH. Al pulsar el botón, el pin se conecta directamente a GND y se lee LOW. En ese momento pasa una pequeña corriente por la resistencia: según la ley de Ohm, I = V / R, o sea 0,5 mA con 5 V y 10 kΩ. Si hubieras conectado el pin directamente a VCC en lugar de usar la resistencia, pulsar el botón provocaría un cortocircuito en la alimentación; la resistencia tira del pin hacia arriba y además evita ese cortocircuito. Puedes calcular la corriente para otros valores rápidamente con la calculadora de la ley de Ohm.

El montaje pull-down es su reflejo: la resistencia va entre el pin y GND, y el botón entre el pin y VCC. Con el botón abierto, el pin se lleva a masa a través de la resistencia y se lee LOW; al pulsar, el pin se conecta a VCC y se lee HIGH. Esta estructura resulta más natural a los principiantes, porque pulsar es 1 y soltar es 0. Sin embargo, el chip del Arduino Uno no tiene pull-down interno; si quieres pull-down en el Uno, necesitas una resistencia externa de 10 kΩ. El ESP32 y la Raspberry Pi Pico, en cambio, incluyen ambas resistencias.

CaracterísticaPull-upPull-down
¿Dónde va la resistencia?Entre el pin y VCCEntre el pin y GND
¿Dónde va el botón?Entre el pin y GNDEntre el pin y VCC
Botón sin pulsarHIGH (1)LOW (0)
Botón pulsadoLOW (0)HIGH (1)
Tipo de lógicaActiva en bajoActiva en alto
Soporte internoUno, ESP32, PicoESP32, Pico
Uso típicoBotón, I2C, línea de resetPuerta de MOSFET, salidas de sensores

Pull-up y pull-down internas: Arduino Uno, ESP32 y Pico

CaracterísticaArduino UnoESP32Raspberry Pi Pico
Nivel lógico5 V3,3 V3,3 V
Pull-up internaSí, 20–50 kΩSí, unos 45 kΩSí, 50–80 kΩ
Pull-down internaNoSí, unos 45 kΩSí, 50–80 kΩ (con problemas en la Pico 2)
Cómo activarla en el códigoINPUT_PULLUPINPUT_PULLUP / INPUT_PULLDOWNPin.PULL_UP / Pin.PULL_DOWN
Botón pull-up (pin – GND)D2GPIO 18GP2
Botón pull-down (pin – VCC)D3 + 10 kΩ externaGPIO 19 (a 3V3)GP3 (a 3V3)
Pines sin resistencia internaNingunoGPIO 34–39Ninguno
Pines I2C (SDA / SCL)A4 / A5GPIO 21 / GPIO 22GP4 / GP5
En el ESP32, los GPIO 34–39 son solo de entrada y no tienen pull-up ni pull-down internas; en estos pines escribir INPUT_PULLUP no cambia nada, y una resistencia externa de 10 kΩ es imprescindible. Presta atención también a los pines de arranque (strapping): una pull-up que mantenga el GPIO 12 en HIGH durante el arranque fija la tensión de la flash a 1,8 V y puede impedir que la placa arranque; una pull-down que lleve el GPIO 0 a LOW pone la placa en modo de programación.

Cómo usar INPUT_PULLUP en Arduino paso a paso

  1. Conecta una pata del primer botón a D2 y la pata diagonal a GND; este botón no necesita resistencia, se usará la pull-up interna.
  2. Conecta una pata del segundo botón a D3 y la pata diagonal a 5V.
  3. Coloca una resistencia pull-down externa de 10 kΩ entre D3 y GND (bandas marrón-negro-naranja).
  4. Carga el código, abre el Monitor Serie a 9600 baudios y pulsa los dos botones por turno.
  5. Comprueba que los botones sueltos muestran 0 y los pulsados 1; el LED integrado en D13 se enciende al pulsar cualquiera de los botones.
C++ (Arduino IDE)
1const int BTN_PULLUP = 2;     // buton D2 - GND, dahili pull-up / button D2 - GND, internal pull-up
2const int BTN_PULLDOWN = 3;   // buton D3 - 5V, harici 10k D3 - GND / button D3 - 5V, external 10k D3 - GND
3const int LED_PIN = 13;       // dahili LED / built-in LED
4
5void setup() {
6  Serial.begin(9600);
7  pinMode(BTN_PULLUP, INPUT_PULLUP);   // dahili pull-up açık / internal pull-up enabled
8  pinMode(BTN_PULLDOWN, INPUT);        // Uno'da dahili pull-down yok / Uno has no internal pull-down
9  pinMode(LED_PIN, OUTPUT);
10}
11
12void loop() {
13  bool a = (digitalRead(BTN_PULLUP) == LOW);     // pull-up: basınca LOW / pull-up: LOW when pressed
14  bool b = (digitalRead(BTN_PULLDOWN) == HIGH);  // pull-down: basınca HIGH / pull-down: HIGH when pressed
15  digitalWrite(LED_PIN, (a || b) ? HIGH : LOW);
16  Serial.print(a ? 1 : 0);
17  Serial.print(' ');
18  Serial.println(b ? 1 : 0);
19  delay(50);
20}

La línea pinMode(BTN_PULLUP, INPUT_PULLUP) activa la resistencia de 20–50 kΩ del interior del chip; por eso D2 lee HIGH sin pulsar y LOW al pulsar. D3, en cambio, se configura como INPUT normal, porque la resistencia externa de 10 kΩ lo mantiene abajo. En el código usamos comparaciones para que dos lógicas distintas signifiquen lo mismo: el botón pull-up cuenta como pulsado cuando es LOW, y el pull-down cuando es HIGH. El patrón que ves en códigos antiguos de Arduino, pinMode(pin, INPUT) seguido de digitalWrite(pin, HIGH), también activa la misma pull-up interna; INPUT_PULLUP es su versión más legible.

Las entradas con pull-up se llaman activas en bajo (active low). Para mantener tu código legible, invierte la lógica desde el principio con una línea como bool pulsado = !digitalRead(pin);; así, en el resto del programa un botón pulsado siempre es true. Si además quieres tratar el rebote (debounce), consulta el artículo Cómo conectar un botón a Arduino.

INPUT_PULLUP e INPUT_PULLDOWN en el ESP32

Casi todos los pines GPIO del ESP32 tienen tanto pull-up como pull-down de unos 45 kΩ. En el core de Arduino las activas con las constantes INPUT_PULLUP e INPUT_PULLDOWN, que son iguales en las versiones 2.x y 3.x del core ESP32 Arduino. Como el ESP32 funciona a 3,3 V, el otro extremo del botón pull-down debe ir al pin 3V3, no a 5V; los GPIO no toleran 5 V. En el siguiente ejemplo, el botón del GPIO 18 va a GND y el del GPIO 19 a 3V3, sin ninguna resistencia externa.

C++ (Arduino IDE)
1const int BTN_PULLUP = 18;     // buton GPIO18 - GND / button GPIO18 - GND
2const int BTN_PULLDOWN = 19;   // buton GPIO19 - 3V3 / button GPIO19 - 3V3
3const int LED_PIN = 2;         // çoğu kartta dahili LED / built-in LED on most boards
4
5void setup() {
6  Serial.begin(115200);
7  pinMode(BTN_PULLUP, INPUT_PULLUP);       // dahili pull-up / internal pull-up
8  pinMode(BTN_PULLDOWN, INPUT_PULLDOWN);   // dahili pull-down / internal pull-down
9  pinMode(LED_PIN, OUTPUT);
10}
11
12void loop() {
13  bool a = (digitalRead(BTN_PULLUP) == LOW);     // pull-up: basınca LOW / pull-up: LOW when pressed
14  bool b = (digitalRead(BTN_PULLDOWN) == HIGH);  // pull-down: basınca HIGH / pull-down: HIGH when pressed
15  digitalWrite(LED_PIN, (a || b) ? HIGH : LOW);
16  Serial.print(a ? 1 : 0);
17  Serial.print(' ');
18  Serial.println(b ? 1 : 0);
19  delay(50);
20}

Pin.PULL_UP y Pin.PULL_DOWN en la Raspberry Pi Pico

El chip RP2040 de la Raspberry Pi Pico tiene en cada GPIO una pull-up y una pull-down internas de unos 50–80 kΩ. En MicroPython basta con pasar Pin.PULL_UP o Pin.PULL_DOWN como tercer parámetro al crear el objeto pin. En el código siguiente, el botón de GP2 va a GND y el de GP3 a 3V3; al pulsar cualquiera de ellos, se enciende el LED de la placa.

MicroPython
1from machine import Pin
2import time
3
4btn_up = Pin(2, Pin.IN, Pin.PULL_UP)       # buton GP2 - GND / button GP2 - GND
5btn_down = Pin(3, Pin.IN, Pin.PULL_DOWN)   # buton GP3 - 3V3 / button GP3 - 3V3
6led = Pin(25, Pin.OUT)                     # dahili LED, Pico W'de LED adini kullan / onboard LED, use the LED name on Pico W
7
8while True:
9    a = btn_up.value() == 0       # pull-up: basinca 0 / pull-up: 0 when pressed
10    b = btn_down.value() == 1     # pull-down: basinca 1 / pull-down: 1 when pressed
11    led.value(1 if (a or b) else 0)
12    time.sleep_ms(20)
Si usas una Pico 2, ten cuidado: en la revisión A2 del chip RP2350 hay un error de hardware conocido como E9 por el que la pull-down interna por sí sola no es fiable; al soltar el pin puede quedarse atascado en torno a 2 V y el botón parecerá pulsado todo el tiempo. En esta placa prefiere la configuración pull-up o usa una pull-down externa de 8,2 kΩ o menos (por ejemplo, 4,7 kΩ).

¿Cómo se elige el valor de la resistencia pull-up?

Cuanto más pequeña es la resistencia, con más fuerza tira del pin, pero más corriente gasta al pulsar el botón. Cuanto mayor es, menos corriente consume, pero el pin se vuelve más débil frente al ruido y los cambios de tensión se hacen más lentos. La fórmula de la corriente es simple: I = VCC / R. A 5 V, 1 kΩ son 5 mA por botón pulsado; 10 kΩ, 0,5 mA; y 100 kΩ solo 0,05 mA, es decir, 50 µA. En dispositivos con batería y botones que pueden quedar pulsados mucho tiempo, esta diferencia afecta directamente a la autonomía.

Hay dos factores que fijan el límite superior. El primero es la corriente de fuga: una entrada del ATmega328P pierde como máximo alrededor de 1 µA; en una pull-up de 100 kΩ eso solo provoca una caída de 0,1 V y no supone problema, pero con 1 MΩ la caída sube a 1 V y el pin se acerca al umbral. El segundo es la velocidad: la resistencia forma con la capacitancia del pin y del cable un circuito RC, con constante de tiempo τ = R × C. Con 10 kΩ y un cable de 100 pF, τ = 1 µs, más que suficientemente rápido para un botón. La regla general es: 10 kΩ para botones, 1–4,7 kΩ para cables largos y ruidosos, y 47–100 kΩ donde haga falta ahorrar batería. Para descifrar las bandas de color de una resistencia puedes usar la herramienta de código de colores de resistencias.

AplicaciónValor recomendadoMotivo
Botón, interruptor, relé reed10 kΩ (o la interna)0,5 mA a 5 V, tracción suficientemente fuerte
Botón con cable de más de 1 m1–4,7 kΩTracción más firme contra el ruido
Dispositivo con batería47–100 kΩSolo unos 50–100 µA al pulsar
Puerta de MOSFET (pull-down)10–100 kΩEvita que el motor arranque solo al encender
I2C, 100 kHz4,7 kΩEl tiempo de subida queda por debajo del límite de 1000 ns
I2C, 400 kHz2,2 kΩUn valor menor para cumplir el límite de 300 ns

Resistencias pull-up en el bus I2C

En el bus I2C la resistencia pull-up no es una opción, es una obligación. Los dispositivos conectados a SDA y SCL usan salida de drenador abierto (open-drain): solo pueden llevar la línea a GND, no pueden subirla a HIGH. Lo único que devuelve la línea a HIGH son las resistencias pull-up. Así, aunque dos dispositivos intenten hablar a la vez, no hay cortocircuito; cuando uno baja la línea a LOW, el otro solo lo observa. Sin pull-ups, el escáner I2C no encuentra ningún dispositivo o el programa se queda colgado en las funciones de Wire. Para conocer los detalles del protocolo, consulta el artículo Qué es I2C.

En el Arduino Uno, la librería Wire activa las pull-ups internas al iniciarse; pero 20–50 kΩ son débiles para I2C y solo funcionan por casualidad con cables cortos. Por suerte, la mayoría de los módulos listos como OLED, BME280 o LCD I2C ya llevan soldada en la placa una pull-up de 4,7 kΩ o 10 kΩ. Un detalle que se pasa por alto con frecuencia es la conexión en paralelo: si conectas a la misma línea tres módulos con pull-up de 10 kΩ cada uno, la resistencia equivalente baja a 3,3 kΩ, y con seis módulos a 1,7 kΩ, y a los dispositivos les cuesta más llevar la línea a LOW. Para el cálculo, la resistencia mínima es Rmin = (VCC − 0,4 V) / 3 mA, unos 1 kΩ a 3,3 V; la máxima se obtiene con Rmax = tr / (0,8473 × Cb). A 400 kHz (tr = 300 ns) y con 100 pF de capacitancia de línea, Rmax sale en torno a 3,5 kΩ. Los valores en paralelo los encuentras fácilmente con la calculadora de resistencias en serie y paralelo.

ModoVelocidadTiempo de subida máximoPull-up típica (3,3 V)
Modo estándar100 kHz1000 ns4,7–10 kΩ
Modo rápido (Fast-mode)400 kHz300 ns2,2–4,7 kΩ
Fast-mode Plus1 MHz120 ns1–1,5 kΩ

¿Dónde necesitarás resistencias pull? Ideas de proyectos

  • Lectura de botones e interruptores: todo botón necesita una resistencia pull; se explica junto con el debounce en la guía para conectar botones.
  • Sensor de puerta y ventana: el relé reed es un interruptor que se cierra al acercar un imán; con INPUT_PULLUP se lee con un solo cable.
  • Cerradura con código: la librería del teclado matricial usa pull-ups internas en los pines de las filas, así que el teclado 4x4 no necesita resistencias adicionales.
  • Control de motores y tiras LED: una pull-down de 10 kΩ en la puerta de un MOSFET evita que el motor gire mientras el Arduino arranca y el pin aún no está configurado.
  • Reacción inmediata con interrupciones: los pines de interrupción se disparan continuamente si quedan flotantes; con una pull-up se estabilizan.
  • Encoder rotativo: las salidas del encoder rotativo se leen con pull-ups; en encoders sueltos, sin módulo, tienes que activar la pull-up interna.
  • Líneas de sensores y pantallas: al juntar en el mismo bus módulos I2C como OLED, BME280 y RTC, calcula el valor total de las pull-ups.

Errores comunes y cómo solucionarlos

SíntomaCausa probableSolución
El LED parpadea sin pulsar el botónPin flotante, sin resistencia pullUsa INPUT_PULLUP o añade una resistencia externa de 10 kΩ
El valor cambia al acercar la manoEntrada flotante, el cable largo actúa como antenaReduce la resistencia pull (4,7 kΩ) y acorta el cable
El botón parece estar siempre pulsadoLógica pull-up interpretada al revésCuenta LOW como pulsado o usa !digitalRead
Al pulsar, el pin se queda entre 1 y 2 VPull-up interna y pull-down externa activas a la vezUsa solo una; pon pinMode en INPUT
INPUT_PULLUP no funciona en el GPIO 35 del ESP32Los GPIO 34–39 no tienen resistencia internaAñade una pull-up externa de 10 kΩ
El ESP32 no arranca o se reinicia continuamentePull-up en el GPIO 12 o pull-down en el GPIO 0Mueve el botón a un GPIO que no sea de arranque
No se encuentra el dispositivo I2C o Wire se cuelgaNo hay pull-up, o demasiadas resistencias de módulos en paraleloAñade 4,7 kΩ o quita las resistencias de los módulos sobrantes
Se dañan los pines I2C del ESP32 o la PicoPull-ups conectadas a 5 VConecta las pull-ups a 3,3 V y usa un conversor de nivel lógico si hace falta
Varios conteos en una sola pulsaciónRebote del botón (debounce), no tiene que ver con la pullAplica un debounce por software de 20–50 ms
Si activas la pull-up interna y además conectas una pull-down externa al mismo pin, las dos resistencias forman un divisor de tensión. Por ejemplo, en el Uno una pull-up interna de 35 kΩ con una pull-down externa de 10 kΩ mantiene el pin a 5 × 10 / 45 ≈ 1,1 V, un valor peligrosamente cercano al límite LOW (1,5 V). Que cada pin tenga una sola resistencia pull: o dentro o fuera.

Las resistencias pull-up y pull-down son pequeñas, pero están entre los bloques más usados de la electrónica; cuando entiendes su lógica, los botones, los sensores y los buses I2C dejan de darte sorpresas. Para afianzar lo aprendido, echa un vistazo en la app BlueGrays a los proyectos de encender un LED con un botón, control de botón con ESP32 y comparación de debounce en la Pico; en cada uno te esperan el esquema paso a paso y el código listo.

Preguntas frecuentes

¿Cuántos ohmios debe tener una resistencia pull-up?

Para botones e interruptores, el valor más habitual es 10 kΩ; a 5 V solo consume 0,5 mA al pulsar y es suficientemente fuerte frente al ruido. Con cables largos puedes bajar a 4,7 kΩ, y en circuitos con batería subir a 47–100 kΩ. En el bus I2C se prefieren 4,7 kΩ para 100 kHz y 2,2 kΩ para 400 kHz.

¿Cuál es la diferencia entre INPUT e INPUT_PULLUP?

Un pin en modo INPUT solo lee la tensión y no se tira hacia ningún lado; si no hay una resistencia externa, el pin queda flotante. INPUT_PULLUP activa la resistencia interna de 20–50 kΩ del chip y conecta el pin a VCC. Así solo tienes que conectar el botón entre el pin y GND y leer LOW al pulsar.

¿El Arduino Uno tiene resistencia pull-down interna?

No. Los chips AVR del Uno, el Nano y el Mega solo tienen pull-up interna, y la constante INPUT_PULLDOWN no está definida en estas placas. Si necesitas una pull-down, conecta una resistencia externa de 10 kΩ entre el pin y GND. El ESP32 y la Raspberry Pi Pico sí admiten pull-down interna.

¿Hace falta resistencia pull-up para I2C?

Sí. Como los dispositivos I2C solo pueden llevar las líneas a LOW, las resistencias pull-up que suben SDA y SCL a HIGH son imprescindibles. La mayoría de los módulos listos ya traen resistencias de 4,7 kΩ o 10 kΩ en la placa, así que con un solo módulo no hace falta añadir ninguna. Si usas un chip de sensor suelto o la línea es larga, añade 4,7 kΩ en ambas líneas.

¿Debo usar pull-up o pull-down?

En la mayoría de los casos la pull-up es más práctica: está disponible internamente en todas las placas y conectar el botón a GND es más seguro que pasear la línea de alimentación con un cable. La pull-down se prefiere donde quieras leer 1 al pulsar o en líneas como la puerta de un MOSFET, que deben permanecer en LOW al arrancar. Elijas la que elijas, solo tienes que plantear la lógica del código en consecuencia.

¿Qué pasa si conecto un botón sin resistencia pull-up?

Con el botón abierto, el pin no está conectado a nada, queda flotante y capta el ruido eléctrico del entorno. Entonces digitalRead devuelve 0 y 1 al azar, el LED parpadea solo o la interrupción se dispara sin parar. Para solucionarlo basta con usar INPUT_PULLUP o añadir una resistencia externa.

Ver todos los proyectos
Encender un LED con pulsador (Push)
AR-9Principiante

Encender un LED con pulsador (Push)

Como un timbre: la luz se enciende mientras pulsas y se apaga cuando sueltas. El Arduino escucha el botón todo el rato; mientras está pulsado enciende el LED, y en cuanto levantas el dedo lo apaga.

4.8(114)
253
Encender y apagar un LED con un botón
AR-10Principiante

Encender y apagar un LED con un botón

Pulsas el botón una vez y la luz se enciende, lo pulsas otra vez y se apaga, igual que el interruptor de tu habitación.

4.7(103)
177
Control de LED con pulsador en ESP32 (Push)
ES-2Principiante

Control de LED con pulsador en ESP32 (Push)

El LED se enciende cuando se pulsa el botón y se apaga cuando se suelta. Muestra cómo se utiliza el pin de entrada digital del ESP32 y la resistencia pull-up interna. Gracias al modo INPUT_PULLUP, no se necesita ninguna resistencia externa.

4.6(36)
57
Control de LED con botón en ESP32 (Toggle)
ES-3Principiante

Control de LED con botón en ESP32 (Toggle)

Cada vez que se pulsa el botón, cambia el estado del LED: si está encendido se apaga, si está apagado se enciende. Patrón de conmutación clásico. Con debounce limpiamos el ruido mecánico del pulsador para garantizar una sola conmutación con una sola pulsación.

4.6(39)
59
Raspberry Pi Pico LED Controlado por Botón (Push)
PI-9Principiante
Premium

Raspberry Pi Pico LED Controlado por Botón (Push)

¡Primer proyecto de entrada con Pico — lectura de botón! LED se enciende mientras el botón está presionado. Aprende Pin.IN, Pin.PULL_UP y button.value(). GP14 LED, GP2 botón con PULL_UP interno. Presionado = 0, liberado = 1 — estándar.

11
Raspberry Pi Pico Botón Toggle LED
PI-10Principiante

Raspberry Pi Pico Botón Toggle LED

¡Botón + LED — siguiente nivel! A diferencia del proyecto básico de botón, no necesitas mantener el botón presionado. Presiona y suelta → LED encendido. Presiona de nuevo → LED apagado (toggle). Mismo circuito, gran diferencia de código. Aprende edge detection, state tracking y debounce.

10
Raspberry Pi Pico Botón Debounce: IRQ vs Software Polling
PI-13Intermedio
Premium

Raspberry Pi Pico Botón Debounce: IRQ vs Software Polling

¿Una pulsación y el código cuenta 3-4? ¡Es contact bounce! Compara 2 métodos de conteo en Serial: polling RAW (captura bounce, cuenta mal) vs IRQ + software debounce (preciso). Aprende física del bounce, software debounce, Pin.irq() interrupt, IRQ_FALLING trigger, ISR handlers, seguridad de variables globales en ISR.

12
Lectura de un interruptor reed
AR-37Principiante

Lectura de un interruptor reed

¿Alguna vez te has preguntado cómo funciona el interruptor magnético de las alarmas de puertas y ventanas?

4.5(22)
29