Pull-up-Widerstand: Pull-down, INPUT_PULLUP und Wert wählen
Was sind Pull-up- und Pull-down-Widerstände? Floating-Eingang, INPUT_PULLUP, interne Widerstände bei ESP32 und Pico, I2C-Pull-ups und 10k-Wert richtig wählen.
Ein Pull-up-Widerstand ist ein meist 10-kΩ-Widerstand, der einen Mikrocontroller-Eingang im Ruhezustand mit der Versorgungsspannung (VCC) verbindet und so auf einem stabilen HIGH-Pegel hält. Ein Pull-down-Widerstand macht dasselbe in die Gegenrichtung: Er zieht den Pin auf Masse (GND) und hält ihn auf LOW. Wenn du an einen Arduino einen Taster, Schalter oder Reed-Kontakt anschließt, sorgen genau diese kleinen Widerstände dafür, dass der gelesene Wert nicht zufällig springt. Bei den meisten Boards steckt der Widerstand schon im Chip; beim Arduino reicht es, INPUT_PULLUP zu schreiben, um ihn zu aktivieren.
In diesem Beitrag lernst du Schritt für Schritt, warum ein offener (floating) Eingang zufällige Werte liefert, worin sich Pull-up und Pull-down unterscheiden, welche internen Widerstände Arduino Uno, ESP32 und Raspberry Pi Pico haben, wie du den richtigen Widerstandswert berechnest und warum der I2C-Bus ohne Pull-ups nicht funktioniert. In jedem Abschnitt findest du echte Messwerte, Formeln und Code zum direkten Hochladen.

Was ist ein offener (floating) Eingang und warum macht er Probleme?
Ein digitaler Eingangspin ist ein hochohmiges Gate (im Bereich von hunderten Megaohm), das nur die Spannung erfasst und fast keinen Strom zieht. Ist am Pin nichts angeschlossen oder hängt er bei offenem Taster an gar nichts, bleibt seine Spannung undefiniert. Man nennt das einen offenen oder floating Eingang. Ein solcher Pin verhält sich wie eine kleine Antenne: Er reagiert auf nahe Kabel, das 50-Hz-Feld der Netzspannung und sogar auf deine Hand in der Nähe, und der gelesene Wert wechselt dutzende Male pro Sekunde zwischen 0 und 1.
Um das Problem zu verstehen, hilft ein Blick auf die Logikpegel. Der ATmega328P des Arduino Uno arbeitet mit 5 V und erkennt alles über 3 V (60 % von VCC) sicher als HIGH und alles unter 1,5 V (30 % von VCC) sicher als LOW. Dazwischen liegt ein unbestimmter Bereich, und ein floating Pin bewegt sich meist genau dort. Die Folgen: Die LED leuchtet ohne Tastendruck, ein Zähler zählt zufällig hoch oder ein Interrupt löst ständig aus. Probier es selbst aus: Stecke an D2 nur ein loses Jumperkabel, lade den folgenden Code hoch und berühre bei geöffnetem Serial Monitor das Kabelende:
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}Was sind Pull-up- und Pull-down-Widerstände und wie funktionieren sie?
Bei einer Pull-up-Schaltung liegt ein Ende des Widerstands am Eingangspin, das andere an VCC; der Taster sitzt zwischen Pin und GND. Bei offenem Taster fließt kaum Strom, am Widerstand fällt keine Spannung ab und der Pin sieht VCC, also HIGH. Drückst du den Taster, wird der Pin direkt mit GND verbunden und liest LOW. Dabei fließt ein kleiner Strom durch den Widerstand: Nach dem Ohmschen Gesetz I = U / R sind das bei 5 V und 10 kΩ 0,5 mA. Würdest du den Pin ohne Widerstand direkt an VCC legen, würde der Tastendruck die Versorgung kurzschließen; der Widerstand zieht den Pin also nach oben und verhindert zugleich diesen Kurzschluss. Den Strom für andere Werte findest du schnell mit dem Ohmschen-Gesetz-Rechner.
Die Pull-down-Schaltung ist das Spiegelbild: Der Widerstand liegt zwischen Pin und GND, der Taster zwischen Pin und VCC. Bei offenem Taster wird der Pin über den Widerstand auf Masse gezogen und liest LOW; beim Drücken liegt er an VCC und liest HIGH. Das fühlt sich für Anfänger natürlicher an, denn Drücken bedeutet 1 und Loslassen 0. Der Chip des Arduino Uno hat aber keinen internen Pull-down; wenn du am Uno einen Pull-down willst, brauchst du einen externen 10-kΩ-Widerstand. ESP32 und Raspberry Pi Pico haben dagegen beide Widerstände eingebaut.
| Merkmal | Pull-up | Pull-down |
|---|---|---|
| Wohin kommt der Widerstand? | Zwischen Pin und VCC | Zwischen Pin und GND |
| Wohin kommt der Taster? | Zwischen Pin und GND | Zwischen Pin und VCC |
| Taster nicht gedrückt | HIGH (1) | LOW (0) |
| Taster gedrückt | LOW (0) | HIGH (1) |
| Logikart | Active Low | Active High |
| Interne Unterstützung | Uno, ESP32, Pico | ESP32, Pico |
| Typische Anwendung | Taster, I2C, Reset-Leitung | MOSFET-Gate, Sensorausgänge |
Interne Pull-up- und Pull-down-Widerstände: Arduino Uno, ESP32 und Pico
| Merkmal | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| Logikpegel | 5 V | 3,3 V | 3,3 V |
| Interner Pull-up | Ja, 20–50 kΩ | Ja, ca. 45 kΩ | Ja, 50–80 kΩ |
| Interner Pull-down | Nein | Ja, ca. 45 kΩ | Ja, 50–80 kΩ (beim Pico 2 problematisch) |
| Aktivieren im Code | INPUT_PULLUP | INPUT_PULLUP / INPUT_PULLDOWN | Pin.PULL_UP / Pin.PULL_DOWN |
| Pull-up-Taster (Pin – GND) | D2 | GPIO 18 | GP2 |
| Pull-down-Taster (Pin – VCC) | D3 + externer 10 kΩ | GPIO 19 (an 3V3) | GP3 (an 3V3) |
| Pins ohne internen Widerstand | Keine | GPIO 34–39 | Keine |
| I2C-Pins (SDA / SCL) | A4 / A5 | GPIO 21 / GPIO 22 | GP4 / GP5 |
INPUT_PULLUP beim Arduino Schritt für Schritt
- Schließe ein Bein des ersten Tasters an D2 und das diagonal gegenüberliegende Bein an GND an; für diesen Taster brauchst du keinen Widerstand, denn es wird der interne Pull-up genutzt.
- Schließe ein Bein des zweiten Tasters an D3 und das diagonal gegenüberliegende Bein an 5V an.
- Setze zwischen D3 und GND einen externen 10-kΩ-Pull-down-Widerstand (Farbringe braun-schwarz-orange).
- Lade den Code hoch, öffne den Serial Monitor mit 9600 Baud und drücke nacheinander beide Taster.
- Prüfe, dass nicht gedrückte Taster 0 und gedrückte 1 anzeigen; die eingebaute LED an D13 leuchtet, sobald einer der Taster gedrückt wird.
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}Die Zeile pinMode(BTN_PULLUP, INPUT_PULLUP) aktiviert den 20–50-kΩ-Widerstand im Chip; deshalb liest D2 ohne Tastendruck HIGH und beim Drücken LOW. D3 ist dagegen ein normaler INPUT, weil der externe 10-kΩ-Widerstand ihn nach unten zieht. Im Code haben wir beide Logiken über einen Vergleich auf dieselbe Bedeutung gebracht: Der Pull-up-Taster gilt als gedrückt, wenn er LOW ist, der Pull-down-Taster, wenn er HIGH ist. Das aus älterem Arduino-Code bekannte Muster pinMode(pin, INPUT) gefolgt von digitalWrite(pin, HIGH) aktiviert übrigens denselben internen Pull-up; INPUT_PULLUP ist die lesbarere Variante.
INPUT_PULLUP und INPUT_PULLDOWN beim ESP32
Fast jeder GPIO-Pin des ESP32 hat sowohl einen Pull-up als auch einen Pull-down von etwa 45 kΩ. Im Arduino-Core aktivierst du sie mit den Konstanten INPUT_PULLUP und INPUT_PULLDOWN; diese sind in den ESP32-Arduino-Core-Versionen 2.x und 3.x gleich. Da der ESP32 mit 3,3 V arbeitet, musst du das andere Ende des Pull-down-Tasters an 3V3 anschließen, nicht an 5V; die GPIO-Pins sind nicht 5-V-tolerant. Im folgenden Beispiel hängt der Taster an GPIO 18 an GND und der an GPIO 19 an 3V3, externe Widerstände sind nicht nötig.
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 und Pin.PULL_DOWN beim Raspberry Pi Pico
Der RP2040-Chip des Raspberry Pi Pico hat an jedem GPIO einen internen Pull-up und Pull-down von etwa 50–80 kΩ. In MicroPython übergibst du beim Erzeugen des Pin-Objekts einfach Pin.PULL_UP oder Pin.PULL_DOWN als dritten Parameter. Im folgenden Code hängt der Taster an GP2 an GND und der an GP3 an 3V3; sobald einer gedrückt wird, leuchtet die LED auf dem Board.
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)Wie wählst du den Wert des Pull-up-Widerstands?
Je kleiner der Pull-Widerstand, desto stärker zieht er den Pin, aber desto mehr Strom fließt beim Tastendruck. Je größer er ist, desto weniger Strom fließt, aber der Pin wird anfälliger für Störungen und Spannungsänderungen werden langsamer. Die Formel für den Strom ist einfach: I = VCC / R. Bei 5 V sind das 5 mA für 1 kΩ, 0,5 mA für 10 kΩ und nur 0,05 mA (50 µA) für 100 kΩ pro gedrücktem Taster. Bei batteriebetriebenen Geräten, bei denen ein Taster lange gedrückt bleiben kann, wirkt sich dieser Unterschied direkt auf die Batterielaufzeit aus.
Die Obergrenze bestimmen zwei Faktoren. Erstens der Leckstrom: Ein Eingang des ATmega328P leckt höchstens etwa 1 µA; an einem 100-kΩ-Pull-up fällt dabei nur 0,1 V ab, das ist unkritisch, bei 1 MΩ wären es aber 1 V und der Pin käme nahe an die Schaltschwelle. Zweitens die Geschwindigkeit: Der Widerstand bildet mit der Kapazität von Pin und Kabel einen RC-Kreis mit der Zeitkonstante τ = R × C. Bei 10 kΩ und einem Kabel mit 100 pF ist τ = 1 µs, was für einen Taster mehr als schnell genug ist. Faustregel: 10 kΩ für Taster, 1–4,7 kΩ für lange, störanfällige Kabel und 47–100 kΩ, wo Strom gespart werden soll. Die Farbringe eines Widerstands entschlüsselst du mit dem Widerstands-Farbcode-Rechner.
| Anwendung | Empfohlener Wert | Begründung |
|---|---|---|
| Taster, Schalter, Reed-Kontakt | 10 kΩ (oder intern) | 0,5 mA bei 5 V, ausreichend starkes Ziehen |
| Taster mit Kabel länger als 1 m | 1–4,7 kΩ | Härteres Ziehen gegen Störungen |
| Batteriebetriebenes Gerät | 47–100 kΩ | Nur etwa 50–100 µA im gedrückten Zustand |
| MOSFET-Gate (Pull-down) | 10–100 kΩ | Verhindert, dass der Motor beim Einschalten von selbst anläuft |
| I2C, 100 kHz | 4,7 kΩ | Anstiegszeit bleibt unter der 1000-ns-Grenze |
| I2C, 400 kHz | 2,2 kΩ | Kleinerer Wert für die 300-ns-Grenze |
Pull-up-Widerstände am I2C-Bus
Beim I2C-Bus sind Pull-up-Widerstände keine Option, sondern Pflicht. Die Geräte an SDA und SCL haben einen Open-Drain-Ausgang: Sie können die Leitung nur auf GND ziehen, aber nicht auf HIGH treiben. Nur die Pull-up-Widerstände bringen die Leitung wieder auf HIGH. So gibt es auch keinen Kurzschluss, wenn zwei Geräte gleichzeitig senden wollen; zieht eines die Leitung auf LOW, sieht das andere das nur. Ohne Pull-ups findet der I2C-Scanner kein Gerät oder das Programm bleibt in den Wire-Funktionen hängen. Details zum Protokoll findest du im Beitrag Was ist I2C.
Beim Arduino Uno aktiviert die Wire-Bibliothek beim Start die internen Pull-ups; 20–50 kΩ sind für I2C aber zu schwach und funktionieren nur zufällig bei kurzen Kabeln. Zum Glück haben die meisten fertigen Module wie OLED, BME280 oder I2C-LCD bereits 4,7-kΩ- oder 10-kΩ-Pull-ups auf der Platine. Oft übersehen wird die Parallelschaltung: Hängst du drei Module mit je 10 kΩ Pull-up an denselben Bus, sinkt der Ersatzwiderstand auf 3,3 kΩ, bei sechs Modulen auf 1,7 kΩ, und die Geräte können die Leitung nur noch schwer auf LOW ziehen. Für die Rechnung gilt: Der kleinste Widerstand ist Rmin = (VCC − 0,4 V) / 3 mA, bei 3,3 V also etwa 1 kΩ; der größte ergibt sich aus Rmax = tr / (0,8473 × Cb). Bei 400 kHz (tr = 300 ns) und 100 pF Buskapazität kommt Rmax auf etwa 3,5 kΩ. Parallele Werte bestimmst du leicht mit dem Reihen-/Parallelschaltungs-Rechner.
| Modus | Geschwindigkeit | Max. Anstiegszeit | Typischer Pull-up (3,3 V) |
|---|---|---|---|
| Standard-Modus | 100 kHz | 1000 ns | 4,7–10 kΩ |
| Fast-Mode | 400 kHz | 300 ns | 2,2–4,7 kΩ |
| Fast-Mode Plus | 1 MHz | 120 ns | 1–1,5 kΩ |
Wo brauchst du Pull-Widerstände? Projektideen
- Taster und Schalter auslesen: Jeder Taster braucht einen Pull-Widerstand; zusammen mit Debounce wird das in der Anleitung zum Taster-Anschluss erklärt.
- Tür- und Fenstersensor: Ein Reed-Kontakt ist ein Schalter, der schließt, wenn sich ein Magnet nähert; mit INPUT_PULLUP liest du ihn mit nur einem Kabel aus.
- Codeschloss: Die Keypad-Bibliothek nutzt an den Zeilenpins interne Pull-ups, deshalb braucht eine 4x4-Matrixtastatur keine zusätzlichen Widerstände.
- Motoren und LED-Streifen schalten: Ein 10-kΩ-Pull-down am Gate eines MOSFETs verhindert, dass der Motor dreht, solange der Pin beim Start des Arduino noch nicht konfiguriert ist.
- Sofortige Reaktion per Interrupt: Ein Interrupt-Pin löst ständig aus, wenn er floatet; mit Pull-up wird er stabil.
- Drehgeber: Die Ausgänge eines Rotary Encoders werden mit Pull-up gelesen; bei nackten Encodern ohne Modul musst du den internen Pull-up aktivieren.
- Sensor- und Displaybus: Wenn du I2C-Module wie OLED, BME280 und RTC an einem Bus sammelst, berechne den Gesamtwert der Pull-ups.
Häufige Fehler und ihre Lösungen
| Symptom | Mögliche Ursache | Lösung |
|---|---|---|
| LED flackert ohne Tastendruck | Pin floatet, kein Pull-Widerstand | INPUT_PULLUP nutzen oder externen 10-kΩ-Widerstand ergänzen |
| Wert ändert sich, wenn du die Hand näherst | Floating-Eingang, langes Kabel wirkt als Antenne | Pull-Widerstand verkleinern (4,7 kΩ), Kabel kürzen |
| Taster erscheint dauernd gedrückt | Pull-up-Logik falsch herum gedeutet | LOW als gedrückt werten oder !digitalRead verwenden |
| Pin hängt beim Drücken bei 1–2 V | Interner Pull-up und externer Pull-down gleichzeitig aktiv | Nur einen verwenden; pinMode auf INPUT setzen |
| INPUT_PULLUP an ESP32 GPIO 35 wirkt nicht | GPIO 34–39 haben keinen internen Widerstand | Externen 10-kΩ-Pull-up ergänzen |
| ESP32 startet nicht oder resettet ständig | Pull-up an GPIO 12 oder Pull-down an GPIO 0 | Taster auf einen GPIO ohne Boot-Funktion verlegen |
| I2C-Gerät nicht gefunden oder Wire hängt | Kein Pull-up oder zu viele Modulwiderstände parallel | 4,7 kΩ ergänzen oder überzählige Widerstände entfernen |
| I2C-Pins von ESP32 oder Pico werden beschädigt | Pull-ups an 5 V angeschlossen | Pull-ups an 3,3 V legen, bei Bedarf Pegelwandler nutzen |
| Mehrfachzählung bei einem Druck | Tasterprellen (Debounce), hat nichts mit Pull zu tun | 20–50 ms Debounce in Software einbauen |
Pull-up- und Pull-down-Widerstände sind klein, gehören aber zu den meistgenutzten Bausteinen der Elektronik; hast du die Logik einmal verstanden, überraschen dich Taster, Sensoren und I2C-Leitungen nicht mehr. Zum Vertiefen findest du in der BlueGrays-App Projekte wie LED per Taster einschalten, ESP32-Tastersteuerung und Pico-Debounce-Vergleich, jeweils mit Schaltplan und fertigem Code.
Häufige Fragen
Wie viel Ohm sollte ein Pull-up-Widerstand haben?
Für Taster und Schalter ist 10 kΩ am gebräuchlichsten; bei 5 V zieht er gedrückt nur 0,5 mA und ist stark genug gegen Störungen. Bei langen Kabeln kannst du auf 4,7 kΩ gehen, bei Batterieschaltungen auf 47–100 kΩ. Am I2C-Bus sind 4,7 kΩ für 100 kHz und 2,2 kΩ für 400 kHz üblich.
Was ist der Unterschied zwischen INPUT und INPUT_PULLUP?
Ein Pin im Modus INPUT liest nur die Spannung und wird in keine Richtung gezogen; ohne externen Widerstand floatet er. INPUT_PULLUP aktiviert dagegen den 20–50-kΩ-Widerstand im Chip und verbindet den Pin mit VCC. So reicht es, den Taster zwischen Pin und GND zu schalten und beim Drücken LOW zu lesen.
Hat der Arduino Uno einen internen Pull-down-Widerstand?
Nein, die AVR-Chips von Uno, Nano und Mega haben nur einen internen Pull-up, und die Konstante INPUT_PULLDOWN ist auf diesen Boards nicht definiert. Wenn du einen Pull-down brauchst, schließt du einen externen 10-kΩ-Widerstand zwischen Pin und GND an. ESP32 und Raspberry Pi Pico unterstützen den internen Pull-down.
Braucht I2C Pull-up-Widerstände?
Ja, da I2C-Geräte die Leitungen nur auf LOW ziehen können, sind Pull-ups nötig, um SDA und SCL auf HIGH zu bringen. Auf den meisten fertigen Modulen sitzen schon 4,7 kΩ oder 10 kΩ, deshalb brauchst du bei einem einzelnen Modul keine zusätzlichen. Bei einem nackten Sensorchip oder langer Leitung ergänzt du an beiden Leitungen 4,7 kΩ.
Soll ich Pull-up oder Pull-down verwenden?
Meist ist der Pull-up praktischer: Er ist auf allen Boards intern vorhanden, und den Taster nach GND zu legen ist sicherer, als die Versorgungsleitung herumzuführen. Pull-down wählst du, wenn du beim Drücken eine 1 lesen willst oder bei Leitungen wie einem MOSFET-Gate, die beim Start LOW bleiben müssen. Welchen du auch nimmst, du musst nur die Logik im Code anpassen.
Was passiert, wenn ein Taster ohne Pull-up angeschlossen wird?
Bei offenem Taster ist der Pin mit nichts verbunden, floatet und fängt elektrische Störungen aus der Umgebung ein. Dann liefert digitalRead zufällig 0 und 1, die LED flackert von selbst oder ein Interrupt löst ständig aus. Zur Lösung nutzt du INPUT_PULLUP oder ergänzt einen externen Widerstand.
Projekte, die du danach bauen kannst
Alle Projekte ansehen
LED mit Taster schalten (Push)
Wie bei einer Türklingel: Das Licht leuchtet, solange du drückst, und geht aus, wenn du loslässt.

LED mit Taster ein- und ausschalten
Einmal drücken und das Licht geht an, noch einmal drücken und es geht aus, genau wie der Lichtschalter in deinem Zimmer.

ESP32 LED-Steuerung mit Drucktaste (Push)
Die LED leuchtet auf, wenn die Taste gedrückt wird und geht aus, wenn sie losgelassen wird. Zeigt, wie der digitale Eingangspin des ESP32 und der interne Pull-up-Widerstand verwendet werden. Dank des INPUT_PULLUP-Modus ist kein externer Widerstand erforderlich.

ESP32 LED Steuerung mit Taster (Toggle)
Jedes Mal, wenn die Taste gedrückt wird, ändert sich der Zustand der LED: ist sie an, schaltet sie aus, ist sie aus, schaltet sie ein. Klassisches Toggle-Muster. Mit der Entprellung wird das mechanische Geräusch des Tasters beseitigt, um ein einmaliges Umschalten mit einem einzigen Druck zu gewährleisten.

Raspberry Pi Pico Taster-gesteuerte LED (Push)
Erstes Eingabe-Projekt mit Pico — Taster lesen! LED leuchtet solange der Taster gedrückt ist. Lerne Pin.IN, Pin.PULL_UP und button.value(). GP14 LED, GP2 Taster mit internem PULL_UP. Gedrückt = 0, losgelassen = 1 — Standard.

Raspberry Pi Pico Taster Toggle LED
Taster + LED — nächste Stufe! Anders als beim einfachen Taster-Projekt musst du den Taster nicht halten. Drücken und loslassen → LED an. Nochmal drücken → LED aus (toggle). Gleiche Schaltung, aber großer Codeunterschied. Lerne Edge Detection, State Tracking und Debounce.

Raspberry Pi Pico Taster Debounce: IRQ vs Software Polling
Einmal Taster gedrückt, Code zählt 3-4? Das ist Contact Bounce! Vergleiche 2 Zählmethoden in Serial: RAW Polling (fängt Bounce, zählt falsch) vs IRQ + Software Debounce (genau). Lerne Contact Bounce Physik, Software Debounce, Pin.irq() Interrupt, IRQ_FALLING Trigger, ISR Handler, global Variablen ISR-Sicherheit.

Reedschalter auslesen
Hast du dich schon mal gefragt, wie der Magnetschalter in Tür- und Fensteralarmen funktioniert?
Weitere Artikel
BlueGrays-App
Diese Schaltung Schritt für Schritt auf dem Handy nachbauen
Schaltplan, Code und Teileliste auf einem Bildschirm. Über 500 Arduino-, ESP32- und Pico-Projekte zum Nachbauen.
Mit dem Handy scannen
Richte die Kamera auf den Code, dann öffnet sich der App-Store deines Handys.
oder im Store öffnen

