NE555 Timer: Pinbelegung, astabile und monostabile Schaltung

Der NE555 (kurz 555-Timer) ist ein günstiger Timer-IC mit 8 Beinchen, der mit nur einem Widerstand und einem Kondensator Zeiten von Mikrosekunden bis zu Stunden einstellen kann. Eine LED in festen Abständen blinken lassen, eine Lampe nach einem Tastendruck eine Minute lang eingeschaltet lassen, einem Summer einen Ton entlocken oder einen Motor per PWM ansteuern: Das alles schafft er ohne Mikrocontroller und ohne eine Zeile Code. Hans Camenzind entwarf den Chip 1971 für Signetics, 1972 kam er auf den Markt, und seitdem gehört er zu den meistproduzierten ICs der Welt; 2003 wurde die Jahresproduktion auf rund eine Milliarde Stück geschätzt.

In diesem Artikel lernst du die Pinbelegung des 555 kennen und erfährst, wie die Komparatoren und das Flipflop im Inneren arbeiten. Du baust die zwei Grundschaltungen (astabiler Blinker und monostabiles Monoflop), verstehst, woher die Formeln für Frequenz und Zeit kommen, senkst das Tastverhältnis unter 50 % und setzt den 555 zusammen mit Arduino, ESP32 und Raspberry Pi Pico ein. Wenn du nicht von Hand rechnen willst, zeigt dir der 555-Timer-Rechner Frequenz, Tastverhältnis und Signalverlauf sofort an.

Was ist der NE555 und wie funktioniert er?

Im 555 stecken vier wesentliche Teile. Der erste ist ein Spannungsteiler aus drei gleichen Widerständen in Reihe zwischen VCC und GND (beim klassischen NE555 je 5 kΩ); er erzeugt zwei Referenzspannungen: 2/3 und 1/3 von VCC. Der zweite sind zwei Komparatoren, die an diesen Referenzen hängen: Der Schwellwert-Komparator vergleicht den THRES-Pin mit 2/3 VCC, der Trigger-Komparator den TRIG-Pin mit 1/3 VCC. Der dritte ist ein RS-Flipflop, das von den beiden Komparatoren gesetzt und zurückgesetzt wird, und der vierte die vom Flipflop gesteuerte Endstufe samt Entladetransistor, der den Kondensator leert.

Die Regel ist eigentlich ganz einfach: Fällt die Spannung an TRIG unter 1/3 VCC, geht der Ausgang auf HIGH und der Entladetransistor sperrt. Steigt die Spannung an THRES über 2/3 VCC, geht der Ausgang auf LOW, und der Entladetransistor schaltet durch und zieht Pin 7 auf GND. Passiert keins von beidem, behält der Ausgang seinen bisherigen Zustand. Die Zeit hängt also davon ab, wie lange sich der externe Kondensator über einen Widerstand zwischen diesen beiden Schwellen auf- und entlädt. Bei 5 V liegen die Schwellen bei 3,33 V und 1,67 V, bei 9 V bei 6 V und 3 V. Oft heißt es, der Name komme von den drei 5-kΩ-Widerständen im Inneren; Camenzind selbst erzählte jedoch, dass Signetics die Zahl willkürlich gewählt hat.

NE555 Pinbelegung

Die halbmondförmige Kerbe oder der kleine Punkt auf dem Gehäuse markiert Pin 1. Liegt die Kerbe links und schaust du von oben darauf, laufen die Pins 1–4 in der unteren Reihe von links nach rechts und die Pins 5–8 in der oberen Reihe von rechts nach links; die Nummern steigen also gegen den Uhrzeigersinn, und Pin 8 (VCC) liegt Pin 1 direkt gegenüber. Das DIP-8-Gehäuse passt genau über die Mittelrille eines Steckbretts: Je eine Beinchenreihe muss auf jeder Seite der Rille sitzen.

Drei Betriebsarten: astabil, monostabil und bistabil

Astabile Schaltung: LED-Blinker mit dem NE555

In der astabilen Schaltung werden TRIG (2) und THRES (6) verbunden und an den Timing-Kondensator gelegt. Der Kondensator lädt sich von VCC über R1 und R2 auf; erreicht seine Spannung 2/3 VCC, geht der Ausgang auf LOW, der Entladetransistor schaltet durch und der Kondensator entlädt sich jetzt nur über R2 in Pin 7. Sinkt die Spannung auf 1/3 VCC, geht der Ausgang wieder auf HIGH, und der Zyklus wiederholt sich von selbst. Der Kondensator wird nie ganz leer, sondern pendelt zwischen 1/3 und 2/3 VCC; nur beim Einschalten startet er leer, deshalb ist die erste HIGH-Phase etwas länger. Die folgende Schaltung läuft an einer 9-V-Batterie und lässt zwei LEDs abwechselnd im Sekundentakt leuchten; einfacher geht ein Polizei-Blinklicht nicht.

1. Setze den 555 mit der Kerbe nach links über die Mittelrille des Steckbretts. Wenn du nicht weißt, wie ein Steckbrett innen verbunden ist, lies zuerst Was ist ein Breadboard?.
2. Verbinde Pin 8 (VCC) und Pin 4 (RESET) mit der +9-V-Schiene und Pin 1 (GND) mit der Minusschiene. Setze einen 100-nF-Keramikkondensator möglichst nah am Chip zwischen Pin 8 und Pin 1.
3. Schließe R1 = 10 kΩ zwischen Pin 8 und Pin 7 und R2 = 68 kΩ zwischen Pin 7 und Pin 6 an.
4. Verbinde Pin 6 und Pin 2 mit einer Drahtbrücke. Von diesem Punkt geht ein Elko mit C = 10 µF nach GND; sein kurzes (Minus-)Bein muss auf der GND-Seite liegen.
5. Setze einen 10-nF-Kondensator (Aufdruck 103) von Pin 5 (CONT) nach GND.
6. Führe vom Ausgang (Pin 3) über einen 470-Ω-Widerstand zur Anode der ersten LED und verbinde ihre Kathode mit GND; diese LED leuchtet, solange der Ausgang HIGH ist. Verbinde die Anode der zweiten LED über 470 Ω mit +9 V und ihre Kathode mit dem Ausgang; diese LED leuchtet, solange der Ausgang LOW ist.
7. Schließe die Batterie an: Die beiden LEDs sollten abwechselnd etwa 0,54 s und 0,47 s leuchten. Leuchtet keine, prüfe als Erstes, ob Pin 4 an VCC liegt.

Bei 9 V liegt der HIGH-Ausgang des NE555 bei etwa 7,5 V, daher fließen durch die erste LED etwa 12 mA und durch die zweite etwa 15 mA. Betreibst du die Schaltung an 5 V, verringere die Widerstände auf 220–330 Ω; den Wert berechnest du mit dem LED-Vorwiderstand-Rechner, alles zur LED selbst steht in Was ist eine LED?. Da die Frequenz nicht von der Versorgungsspannung abhängt, blinken dieselben Werte für R1, R2 und C auch an 5 V einmal pro Sekunde.

NE555 Formeln für Frequenz und Zeit

Lädt sich ein Kondensator über einen Widerstand R auf, steigt seine Spannung entlang einer Exponentialkurve; τ = R·C ist die Zeitkonstante, die in Was ist ein Kondensator? ausführlich erklärt wird. Von 1/3 VCC bis 2/3 VCC dauert es genau ln 2 · R · C ≈ 0,693 · R · C, weil sich der Restabstand zum Ziel in dieser Zeit halbiert. Da das Laden über R1 + R2 und das Entladen nur über R2 läuft, sind HIGH- und LOW-Zeit verschieden. Addiert man beide Zeiten und bildet den Kehrwert, ergibt sich der Faktor 1 / 0,693 ≈ 1,44 und die bekannte Formel: f = 1,44 / ((R1 + 2·R2) · C).

Bei der Wahl der Werte solltest du einige Grenzen kennen. R1 muss mindestens 1 kΩ haben, sonst verbindet der Entladetransistor beim Durchschalten VCC fast direkt mit GND. Laut Datenblatt von Texas Instruments sollte R1 + R2 wegen des kleinen Stroms am Schwellwerteingang bei 5 V etwa 3,4 MΩ und bei 15 V 10 MΩ nicht überschreiten; in der Praxis bist du zwischen 1 kΩ und 1 MΩ auf der sicheren Seite. Geh beim Kondensator nicht unter 1 nF, denn die Eigenkapazität von Steckbrett und Kabeln verfälscht sonst die Rechnung. Nutze den NE555 unter 100 kHz; für schnellere Signale nimm eine CMOS-Version. Die Aufdrucke auf Kondensatoren entschlüsselst du mit dem Werkzeug Kondensatorcode, die Ladekurve zeigt dir das Werkzeug RC-Zeitkonstante.

Tastverhältnis einstellen: unter 50 % kommen

In der astabilen Grundschaltung lädt sich der Kondensator über R1 + R2 auf, entlädt sich aber nur über R2; deshalb ist die HIGH-Zeit immer länger als die LOW-Zeit, und das Tastverhältnis kann nicht unter 50 % fallen. Machst du R2 viel größer als R1, näherst du dich 50 %, unterschreitest den Wert aber nie. Die Lösung ist eine 1N4148-Diode parallel zu R2, mit der Anode zu Pin 7 und der Kathode zu Pin 6. Beim Laden fließt der Strom durch die Diode und umgeht R2; beim Entladen sperrt die Diode, und der Strom fließt über R2. So wird tH ≈ 0,693 · R1 · C und tL ≈ 0,693 · R2 · C, und das Tastverhältnis sinkt auf R1 / (R1 + R2). Mit R1 = 10 kΩ, R2 = 47 kΩ und C = 10 µF leuchtet die LED zum Beispiel 69 ms und ist 326 ms aus: ein kurzer, auffälliger Blitz mit 17,5 % Tastverhältnis. Der Spannungsabfall der Diode von rund 0,6 V macht die HIGH-Zeit vor allem an 5 V etwas länger als berechnet. Wie Dioden grundsätzlich funktionieren, liest du in Was ist eine Diode?.

Willst du die Frequenz festhalten und nur das Tastverhältnis verstellen, nimm ein Potentiometer und zwei Dioden. Verbinde den Schleifer mit Pin 7; ein Ende des Potis führst du über eine Diode (Anode am Poti) zum Kondensator, das andere Ende über eine zweite, umgekehrt gepolte Diode (Kathode am Poti) ebenfalls zum Kondensator. Mit R1 = 1 kΩ, einem 100-kΩ-Poti und C = 10 nF bleibt die Frequenz bei etwa 1,4 kHz, während sich das Tastverhältnis grob zwischen 1 % und 99 % ändert, denn die Summe aus Lade- und Entladewiderstand bleibt beim Drehen gleich. Mit einem MOSFET am Ausgang ist das der klassische Weg, die Drehzahl eines Gleichstrommotors oder die Helligkeit eines 12-V-LED-Streifens einzustellen; Details findest du in Was ist PWM? und MOSFET mit Arduino verwenden.

Monostabile Schaltung: Monoflop und Treppenlicht

In der monostabilen Schaltung werden Pin 6 (THRES) und Pin 7 (DISCH) verbunden; von diesem Punkt geht ein Widerstand R nach VCC und ein Kondensator C nach GND. Der TRIG-Pin (2) wird mit einem Pull-up-Widerstand auf HIGH gehalten. Im Ruhezustand ist der Ausgang LOW, und der Entladetransistor hält den Kondensator leer. Kommt ein kurzer LOW-Impuls an TRIG, geht der Ausgang auf HIGH, der Entladetransistor sperrt und der Kondensator lädt sich über R auf. Erreicht seine Spannung 2/3 VCC, kehrt der Ausgang auf LOW zurück und der Kondensator wird sofort entladen. Diesmal lädt er sich von null bis 2/3 VCC auf, deshalb dauert der Impuls ln 3 · R · C ≈ 1,1 · R · C und ist ebenfalls unabhängig von der Versorgungsspannung.

1. Verbinde Pin 8 und Pin 4 mit +5 V und Pin 1 mit GND; setze 100 nF zwischen Pin 8 und Pin 1 und 10 nF zwischen Pin 5 und GND.
2. Verbinde Pin 6 und Pin 7. Von diesem Punkt geht R = 470 kΩ nach +5 V und ein Elko mit C = 100 µF nach GND (Minusbein an GND).
3. Ziehe TRIG (Pin 2) mit 10 kΩ auf +5 V und schließe einen Taster zwischen Pin 2 und GND an. Mehr zum Anschließen von Tastern liest du in Taster am Arduino anschließen.
4. Schließe zum ersten Test eine LED über einen 330-Ω-Widerstand an den Ausgang (Pin 3) an.
5. Drück kurz auf den Taster: Die LED bleibt etwa 1,1 × 470 kΩ × 100 µF ≈ 52 Sekunden an und geht dann aus. Wegen der Toleranz des Elkos von ±20 % ist alles zwischen 42 und 62 Sekunden normal.
6. Für eine echte Lampe steuerst du statt der LED ein Relais: Vom Ausgang geht es über 1 kΩ an die Basis eines BC547, der Emitter kommt an GND, der Kollektor an ein Ende der Relaisspule; das andere Spulenende geht an +5 V. Vergiss die 1N4007-Freilaufdiode parallel zur Spule nicht (Kathode an +5 V); was der Transistor dabei tut, erklärt Was ist ein Transistor?.

Um die Zeit vorzeitig zu beenden, kannst du einen zweiten Taster an den RESET-Pin (4) hängen: Zieh den Pin mit 10 kΩ auf VCC und schließe den Taster zwischen RESET und GND an; sobald du drückst, geht der Ausgang auf LOW und der Kondensator wird entladen. Eine monostabile Schaltung triggert sich manchmal beim ersten Einschalten einmal von selbst. Dagegen hilft es, den RESET-Pin über 10 kΩ mit VCC und über 10 µF mit GND zu verbinden: Beim Einschalten bleibt der Chip so lange im Reset, bis sich dieser Kondensator geladen hat, und arbeitet erst normal, wenn die Versorgung stabil ist.

Wie nutzt man den NE555 mit Arduino?

555 und Arduino sind keine Konkurrenten, sondern ein gutes Team. Einen einfachen Blinker kannst du auf dem Arduino auch mit millis() bauen, aber der 555 braucht keinen Code, läuft mit bis zu 16 V, liefert 200 mA am Ausgang und arbeitet weiter, selbst wenn der Arduino hängt. Deshalb kommt der 555 meist in einer von drei Rollen dazu: als Signalquelle, die der Arduino misst, als Hardware-Timer, den der Arduino triggert (Kapazitätsmesser, Impulsverlängerung), und als Oszillator, den der Arduino über den RESET-Pin ein- und ausschaltet (Sirene oder Summerton). Im letzten Fall verbindest du einfach Pin 4 des 555 mit einem Arduino-Ausgang: Ist der Pin HIGH, schwingt der Oszillator, ist er LOW, schweigt er.

Im ersten Beispiel misst der Arduino Frequenz und Tastverhältnis des Blinkers und vergleicht sie mit den berechneten Werten. Die Schaltung ist die gleiche astabile Schaltung wie oben (R1 = 10 kΩ, R2 = 68 kΩ, C = 10 µF), wird aber statt aus 9 V aus dem 5V-Pin des Arduino versorgt, und der Ausgang (Pin 3) geht an D2. Die Funktion pulseIn() liefert, wie lange ein Pin HIGH oder LOW bleibt, in Mikrosekunden.

1// 555 flaşörünün frekansını ve duty cycle'ını ölçer / Measures the frequency and duty cycle of a 555 flasher
2const int SIGNAL_PIN = 2;                    // 555 çıkışı (pin 3) / 555 output (pin 3)
3const float R1_OHM = 10000.0;                // R1 = 10 kΩ
4const float R2_OHM = 68000.0;                // R2 = 68 kΩ
5const float C_FARAD = 10e-6;                 // C = 10 µF
6const unsigned long TIMEOUT_US = 3000000UL;  // 3 s: ~1 Hz sinyal için / for a ~1 Hz signal
7
8void setup() {
9  Serial.begin(9600);
10  pinMode(SIGNAL_PIN, INPUT);
11
12  // Formüllerle hesaplanan değerler / Values from the formulas
13  float fCalc = 1.44 / ((R1_OHM + 2 * R2_OHM) * C_FARAD);
14  float dutyCalc = 100.0 * (R1_OHM + R2_OHM) / (R1_OHM + 2 * R2_OHM);
15  Serial.print(F("Hesaplanan / Calculated: f = "));
16  Serial.print(fCalc, 3);
17  Serial.print(F(" Hz, duty = "));
18  Serial.print(dutyCalc, 1);
19  Serial.println(F(" %"));
20}
21
22void loop() {
23  unsigned long highUs = pulseIn(SIGNAL_PIN, HIGH, TIMEOUT_US);  // HIGH süresi / HIGH time
24  unsigned long lowUs = pulseIn(SIGNAL_PIN, LOW, TIMEOUT_US);    // LOW süresi / LOW time
25
26  if (highUs == 0 || lowUs == 0) {           // zaman aşımı / timeout
27    Serial.println(F("Sinyal yok / No signal"));
28    return;
29  }
30
31  unsigned long periodUs = highUs + lowUs;
32  float f = 1000000.0 / periodUs;            // f = 1 / T
33  float duty = 100.0 * highUs / periodUs;    // duty = tH / T
34
35  Serial.print(F("Olculen / Measured: f = "));
36  Serial.print(f, 3);
37  Serial.print(F(" Hz, duty = "));
38  Serial.print(duty, 1);
39  Serial.print(F(" %, tH = "));
40  Serial.print(highUs / 1000);
41  Serial.print(F(" ms, tL = "));
42  Serial.print(lowUs / 1000);
43  Serial.println(F(" ms"));
44}

pulseIn() wartet standardmäßig höchstens 1 Sekunde; bei einem Signal um 1 Hz wartet die Funktion erst, bis der laufende Impuls endet, und dann, bis ein neuer beginnt, deshalb haben wir das Timeout auf 3 Sekunden erhöht. Im seriellen Monitor weicht die gemessene Frequenz normalerweise um 5–20 % vom berechneten Wert ab; der größte Teil davon kommt von der Toleranz des Elkos. Diese Abweichung ist zugleich ein Weg, den echten Wert des Kondensators zu bestimmen: Setze die gemessene Frequenz in f = 1,44 / ((R1 + 2·R2) · C) ein und löse nach C auf. Bei schnelleren Signalen liefert das Zählen der Flanken per Interrupt genauere Ergebnisse als pulseIn().

Den 555 mit Arduino triggern: ein Kapazitätsmesser

Da die Impulsdauer im monostabilen Betrieb t = 1,1 · R · C beträgt, kannst du bei bekanntem R und gemessenem t den Wert des Kondensators mit C = t / (1,1 · R) bestimmen. Die Schaltung: Pin 6 und Pin 7 verbunden, von diesem Punkt 100 kΩ nach 5 V und der zu messende Kondensator nach GND; Pin 4 und Pin 8 an 5 V, Pin 5 über 10 nF an GND. TRIG (Pin 2) wird mit 10 kΩ auf 5 V gezogen und mit D7 verbunden, der Ausgang (Pin 3) geht an D2. Der Arduino schickt über D7 einen 10-µs-LOW-Impuls und misst mit micros(), wie lange der Ausgang HIGH bleibt.

1// 555 monostable ile kondansatör ölçer / Capacitance meter with a 555 monostable
2const int TRIG_PIN = 7;                      // 555 pin 2 (TRIG)
3const int OUT_PIN = 2;                       // 555 pin 3 (OUT)
4const float R_OHM = 100000.0;                // 6-7 ile 5V arasındaki direnç / resistor between pins 6-7 and 5V
5const float CAL = 1.0;                       // kalibrasyon: gerçek / ölçülen / calibration: real / measured
6const unsigned long TIMEOUT_US = 6000000UL;  // 6 s: ~47 µF'a kadar / up to ~47 µF
7
8void setup() {
9  Serial.begin(9600);
10  pinMode(OUT_PIN, INPUT);
11  pinMode(TRIG_PIN, OUTPUT);
12  digitalWrite(TRIG_PIN, HIGH);              // TRIG beklemede HIGH / TRIG idles HIGH
13}
14
15void loop() {
16  while (digitalRead(OUT_PIN) == HIGH) {}    // önceki darbenin bitmesini bekle / wait for any previous pulse to end
17
18  digitalWrite(TRIG_PIN, LOW);               // 10 µs'lik LOW darbesiyle tetikle / trigger with a 10 µs LOW pulse
19  delayMicroseconds(10);
20  digitalWrite(TRIG_PIN, HIGH);
21
22  unsigned long t0 = micros();
23  while (digitalRead(OUT_PIN) == LOW) {      // çıkışın HIGH olmasını bekle / wait for OUT to go HIGH
24    if (micros() - t0 > 1000) {
25      Serial.println(F("555 yanit vermiyor / 555 not responding"));
26      delay(1000);
27      return;
28    }
29  }
30
31  t0 = micros();
32  while (digitalRead(OUT_PIN) == HIGH) {     // darbe süresini ölç / time the pulse
33    if (micros() - t0 > TIMEOUT_US) {
34      Serial.println(F("Kondansator cok buyuk / Capacitor too large"));
35      delay(1000);
36      return;
37    }
38  }
39  unsigned long widthUs = micros() - t0;
40
41  // t = 1,1 · R · C  ->  C = t / (1,1 · R)
42  float capNf = CAL * (widthUs * 1e-6) / (1.1 * R_OHM) * 1e9;
43
44  Serial.print(F("t = "));
45  Serial.print(widthUs);
46  Serial.print(F(" us, C = "));
47  if (capNf >= 1000.0) {
48    Serial.print(capNf / 1000.0, 2);
49    Serial.println(F(" uF"));
50  } else {
51    Serial.print(capNf, 1);
52    Serial.println(F(" nF"));
53  }
54  delay(1000);
55}

Hier messen wir von Hand mit micros() statt mit pulseIn(), denn direkt nach dem Triggern ist der Ausgang bereits HIGH, und pulseIn() würde diesen Impuls als „vorherigen Impuls“ werten und überspringen. Auf dem Uno hat micros() eine Auflösung von 4 µs; mit 100 kΩ ergibt ein 1-nF-Kondensator einen Impuls von 110 µs, daher liegt der Messbereich ungefähr zwischen 1 nF und 47 µF. Miss einen bekannten Kondensator und trage das Verhältnis von echtem zu gemessenem Wert in den Faktor CAL ein, um dein Messgerät zu kalibrieren. Entlade einen Elko vor dem Anschließen, indem du seine Beine kurzschließt, und schließe sein Plusbein auf der Seite von Pin 6 und 7 an.

NE555 mit ESP32 und Raspberry Pi Pico

ESP32 und Raspberry Pi Pico arbeiten mit 3,3 V, und ihre Pins vertragen keine 5 V. Der klassische NE555 braucht dagegen mindestens 4,5 V und läuft deshalb nicht an 3,3 V. Die sauberste Lösung ist ein CMOS-555 wie der TLC555, LMC555 oder ICM7555: Er hat dieselbe Pinbelegung, läuft am 3V3-Pin, und sein Ausgang pendelt zwischen 0 und 3,3 V, sodass er direkt an einen GPIO passt. Hast du nur einen NE555, versorge ihn mit 5 V und teile seinen Ausgang mit 10 kΩ (in Reihe) und 20 kΩ (nach GND) herunter. Da der HIGH-Pegel des NE555 bei etwa 3,5 V liegt, sinkt die Teilerspannung auf rund 2,3 V: Das reicht für die 2-V-Schwelle des Pico, ist aber für die Schwelle des ESP32 von etwa 2,5 V grenzwertig. Nimm am ESP32 deshalb lieber einen CMOS-555.

Im ESP32-Beispiel erzeugt ein CMOS-555 mit R1 = 1 kΩ, R2 = 6,8 kΩ und C = 100 nF ein Signal von etwa 986 Hz; es hat dieselben Verhältnisse wie der Blinker, ist aber tausendmal schneller. Der ESP32 führt bei jeder steigenden Flanke eine Interrupt-Routine aus und gibt aus, wie viele Flanken er in einer Sekunde gezählt hat; diese Zahl ist direkt die Frequenz in Hz. Aus einer einzelnen, mit pulseIn() gemessenen HIGH-Zeit wird zusätzlich das Tastverhältnis berechnet.

1// ESP32 + CMOS 555 (TLC555) frekans ve duty ölçer / ESP32 + CMOS 555 (TLC555) frequency and duty meter
2const int SIGNAL_PIN = 27;                   // 555 çıkışı (pin 3) / 555 output (pin 3)
3
4volatile uint32_t edgeCount = 0;
5portMUX_TYPE mux = portMUX_INITIALIZER_UNLOCKED;
6
7void IRAM_ATTR onRise() {
8  portENTER_CRITICAL_ISR(&mux);
9  edgeCount++;                               // her yükselen kenarı say / count every rising edge
10  portEXIT_CRITICAL_ISR(&mux);
11}
12
13void setup() {
14  Serial.begin(115200);
15  pinMode(SIGNAL_PIN, INPUT);
16  attachInterrupt(digitalPinToInterrupt(SIGNAL_PIN), onRise, RISING);
17}
18
19void loop() {
20  static uint32_t lastMs = millis();
21  if (millis() - lastMs < 1000) return;      // 1 saniyelik ölçüm penceresi / 1-second gate
22  lastMs += 1000;
23
24  portENTER_CRITICAL(&mux);
25  uint32_t edges = edgeCount;                // sayacı oku ve sıfırla / read and reset the counter
26  edgeCount = 0;
27  portEXIT_CRITICAL(&mux);
28
29  unsigned long highUs = pulseIn(SIGNAL_PIN, HIGH, 100000UL);  // tek bir HIGH süresi / one HIGH time
30  float duty = highUs * (float)edges / 10000.0;                // duty % = tH(µs) · f(Hz) / 10000
31
32  Serial.printf("f = %u Hz, tH = %lu us, duty = %.1f %%\n", (unsigned)edges, highUs, duty);
33}

Auf dem Pico ist die MicroPython-Funktion machine.time_pulse_us() das Gegenstück zu pulseIn() beim Arduino, mit einem wichtigen Unterschied: Liegt der Pin bereits auf dem gewünschten Pegel, beginnt sie sofort zu messen. Deshalb dient der erste Aufruf dazu, einen angebrochenen Impuls zu überspringen und sich auf eine Flanke des Signals zu synchronisieren; die folgenden LOW- und HIGH-Messungen erfassen vollständige Impulse. Das Beispiel misst den Sekundenblinker und schaltet bei jeder Messung die Onboard-LED um.

1# Pico ile 555 flaşörünü ölçmek / Measuring a 555 flasher with the Pico
2from machine import Pin, time_pulse_us
3import time
4
5sig = Pin(15, Pin.IN)       # 555 çıkışı: CMOS 555 doğrudan, NE555 bölücüyle / 555 output: CMOS 555 direct, NE555 via a divider
6led = Pin(25, Pin.OUT)      # dahili LED (Pico W'de Pin("LED")) / onboard LED (Pin("LED") on a Pico W)
7TIMEOUT = 2_000_000         # 2 s zaman aşımı / 2 s timeout
8
9while True:
10    # İlk ölçüm yarım darbeyi atlar ve kenara senkronlar / The first call skips a partial pulse and syncs to an edge
11    if time_pulse_us(sig, 1, TIMEOUT) < 0:
12        print("Sinyal yok / No signal")
13        continue
14    low_us = time_pulse_us(sig, 0, TIMEOUT)    # tam LOW süresi / full LOW time
15    high_us = time_pulse_us(sig, 1, TIMEOUT)   # tam HIGH süresi / full HIGH time
16    if low_us < 0 or high_us < 0:
17        continue
18    period = low_us + high_us
19    print("f = {:.3f} Hz, duty = {:.1f} %, tH = {} ms, tL = {} ms".format(
20        1_000_000 / period, 100 * high_us / period, high_us // 1000, low_us // 1000))
21    led.toggle()            # her ölçümde LED'i değiştir / toggle the LED on every reading
22    time.sleep_ms(200)

Projektideen mit dem NE555

• Polizei-Blinklicht: Lass eine rote und eine blaue LED abwechselnd leuchten, die eine vom Ausgang nach GND, die andere von VCC zum Ausgang geschaltet; mit 4,7 kΩ, 47 kΩ und 1 µF bekommst du ein schnelles Blitzlicht.
• Zweiton-Sirene: Führe den Ausgang eines langsamen ersten 555 über einen Widerstand an Pin 5 (CONT) eines zweiten 555; wenn sich die Schwellen verschieben, steigt und fällt dessen Ton. Für den Klang nimmst du einen passiven Summer oder einen kleinen Lautsprecher.
• Treppenlicht: Baue mit einem monostabilen 555, einem Relais und Tastern einen Timer, der eine Lampe eine Minute lang einschaltet, wobei die Taster auf den verschiedenen Etagen parallel geschaltet sind.
• Kapazitätsmesser: Miss mit dem Arduino-Code aus diesem Artikel Kondensatoren mit unleserlichem Aufdruck und zeige das Ergebnis auf einem I2C-LCD-Display an.
• IR-Sender: Steuere mit einem auf 38 kHz abgeglichenen astabilen 555 eine IR-LED an und erkenne das Signal mit einem IR-Empfänger; so entsteht eine einfache Lichtschranke. Fernbedienungsempfänger wie TSOP oder VS1838B können einen dauerhaften Träger nach kurzer Zeit als Störung werten und unterdrücken; schalte diesen 555 deshalb mit einem zweiten, langsamen 555 über seinen RESET-Pin ein und aus, damit er in Paketen sendet.
• Motordrehzahl-Steller: Verbinde die PWM-Schaltung mit Poti und fester Frequenz mit einem MOSFET, um die Leistung eines 12-V-Gleichstrommotors oder LED-Streifens einzustellen.
• Ausfall-Detektor (Missing Pulse): Setze einen PNP-Transistor (z. B. BC557) parallel zum Timing-Kondensator und verbinde seine Basis mit TRIG; jeder LOW-Impuls, den der Arduino regelmäßig schickt, triggert den 555 und entlädt zugleich den Kondensator, sodass die Zeit neu beginnt. Hängt sich der Arduino auf und die Impulse bleiben aus, läuft die Zeit ab und der 555 löst einen Alarm oder einen Neustart aus.

Häufige Fehler und ihre Lösungen

Der NE555 ist eines der besten Bauteile zum Lernen, weil er die Grundideen der Zeitsteuerung in der Elektronik (RC-Ladung, Schwellwerte, Komparator, Flipflop) in einem einzigen günstigen Chip zeigt. Bau zuerst den Sekundenblinker, wechsle dann die Werte für einen Summerton und probiere danach das monostabile Treppenlicht und den Arduino-Kapazitätsmesser aus. In der BlueGrays-App findest du Projekte wie Polizei-Blinklicht, Bahnübergang-Warnlicht, Treppenhausbeleuchtung und Summer Schritt für Schritt mit Schaltplänen und Code, sodass du die Arduino- und Pico-Varianten deiner 555-Schaltungen direkt nebeneinander ausprobieren kannst.