Timer NE555: piedinatura, circuito astabile e monostabile

Il timer NE555 (o integrato 555) è un chip economico a 8 piedini che permette di impostare tempi da pochi microsecondi a diverse ore con una sola resistenza e un condensatore. Far lampeggiare un LED a ritmo fisso, tenere accesa una lampada per un minuto dopo la pressione di un pulsante, generare un tono su un buzzer o pilotare un motore in PWM: fa tutto questo senza microcontrollore e senza una riga di codice. Progettato da Hans Camenzind per Signetics nel 1971 e messo in commercio nel 1972, è diventato uno dei circuiti integrati più prodotti al mondo; nel 2003 se ne stimava una produzione di circa un miliardo di pezzi all'anno.

In questa guida imparerai la piedinatura del 555, come funzionano al suo interno i comparatori e il flip-flop, i due circuiti di base (il lampeggiatore astabile e il monostabile a impulso singolo), da dove vengono le formule di frequenza e durata, come portare il duty cycle sotto il 50% e come usare il 555 insieme ad Arduino, ESP32 e Raspberry Pi Pico. Se non vuoi fare i calcoli a mano, il calcolatore per timer 555 mostra subito frequenza, duty cycle e forma d'onda.

Cos'è il timer NE555 e come funziona?

Dentro il 555 ci sono quattro parti principali. La prima è un partitore di tensione formato da tre resistenze uguali in serie tra VCC e GND (da 5 kΩ ciascuna nel classico NE555); fornisce due tensioni di riferimento: 2/3 e 1/3 di VCC. La seconda è una coppia di comparatori collegati a questi riferimenti: il comparatore di soglia confronta il pin THRES con 2/3 VCC, il comparatore di trigger confronta il pin TRIG con 1/3 VCC. La terza è un flip-flop SR che i due comparatori impostano e azzerano, e la quarta è lo stadio di uscita comandato dal flip-flop, insieme al transistor di scarica che svuota il condensatore.

La regola in realtà è molto semplice: quando la tensione su TRIG scende sotto 1/3 VCC, l'uscita va HIGH e il transistor di scarica si spegne. Quando la tensione su THRES supera 2/3 VCC, l'uscita va LOW e il transistor di scarica entra in conduzione, portando il pin 7 a GND. Se non succede nessuna delle due cose, l'uscita mantiene lo stato precedente. A fissare il tempo è la durata della carica e della scarica del condensatore esterno, attraverso una resistenza, tra queste due soglie. Con 5 V di alimentazione le soglie sono 3,33 V e 1,67 V; con 9 V sono 6 V e 3 V. Si dice spesso che il nome derivi dalle tre resistenze interne da 5 kΩ, ma Camenzind ha raccontato che Signetics scelse il numero in modo arbitrario.

Piedinatura del NE555 (pinout)

La tacca a mezzaluna o il piccolo puntino sulla parte superiore del chip indica il pin 1. Con la tacca a sinistra e guardando dall'alto, i pin 1–4 vanno da sinistra a destra nella fila inferiore e i pin 5–8 da destra a sinistra nella fila superiore; la numerazione procede quindi in senso antiorario e il pin 8 (VCC) si trova proprio di fronte al pin 1. Il contenitore DIP-8 si inserisce perfettamente a cavallo del canale centrale della breadboard: ogni fila di piedini deve stare su un lato del canale.

Tre modi di funzionamento: astabile, monostabile e bistabile

Circuito astabile: lampeggiatore LED con il NE555

Nel circuito astabile i pin TRIG (2) e THRES (6) vengono uniti e collegati al condensatore di temporizzazione. Il condensatore si carica da VCC attraverso R1 e R2; quando la sua tensione raggiunge 2/3 VCC l'uscita va LOW, il transistor di scarica entra in conduzione e il condensatore si scarica verso il pin 7 solo attraverso R2. Quando la tensione scende a 1/3 VCC l'uscita torna HIGH e il ciclo si ripete da solo. Il condensatore non si svuota mai del tutto, ma oscilla tra 1/3 e 2/3 VCC; solo all'accensione parte da zero, per questo il primo periodo HIGH è un po' più lungo. Il circuito seguente funziona con una batteria da 9 V e accende due LED in modo alternato una volta al secondo: è il lampeggiante della polizia più semplice che si possa fare.

1. Inserisci il 555 a cavallo del canale centrale della breadboard con la tacca rivolta a sinistra. Se non sai come è collegata internamente una breadboard, leggi prima Cos'è una breadboard?.
2. Collega i pin 8 (VCC) e 4 (RESET) alla linea dei +9 V e il pin 1 (GND) alla linea negativa. Inserisci un condensatore ceramico da 100 nF tra i pin 8 e 1, il più vicino possibile al chip.
3. Collega R1 = 10 kΩ tra i pin 8 e 7 e R2 = 68 kΩ tra i pin 7 e 6.
4. Unisci i pin 6 e 2 con un filo. Da questo punto collega verso GND un condensatore elettrolitico da C = 10 µF; il piedino corto (negativo) deve andare dal lato di GND.
5. Inserisci un condensatore da 10 nF (sigla 103) tra il pin 5 (CONT) e GND.
6. Dall'uscita (pin 3) passa attraverso una resistenza da 470 Ω fino all'anodo del primo LED e collega il catodo a GND; questo LED si accende quando l'uscita è HIGH. Collega l'anodo del secondo LED a +9 V tramite 470 Ω e il catodo all'uscita; questo LED si accende quando l'uscita è LOW.
7. Collega la batteria: i due LED dovrebbero accendersi alternandosi per circa 0,54 s e 0,47 s. Se non si accende nessuno dei due, controlla per prima cosa che il pin 4 sia a VCC.

A 9 V l'uscita HIGH del NE555 è di circa 7,5 V, quindi nel primo LED scorrono circa 12 mA e nel secondo circa 15 mA. Se alimenti il circuito a 5 V, abbassa le resistenze a 220–330 Ω; calcola il valore con il calcolatore della resistenza per LED e consulta Cos'è un LED? per tutto ciò che riguarda il LED. Poiché la frequenza non dipende dalla tensione di alimentazione, gli stessi valori di R1, R2 e C danno sempre un lampeggio al secondo anche a 5 V.

Formule di frequenza e durata del NE555

Quando un condensatore si carica attraverso una resistenza R, la sua tensione sale seguendo una curva esponenziale; τ = R·C è la costante di tempo, spiegata in dettaglio in Cos'è un condensatore?. Passare da 1/3 VCC a 2/3 VCC richiede esattamente ln 2 · R · C ≈ 0,693 · R · C, perché in quel tempo la distanza che manca all'obiettivo si dimezza. Dato che la carica avviene attraverso R1 + R2 e la scarica solo attraverso R2, i tempi HIGH e LOW sono diversi. Sommando i due tempi e facendo il reciproco compare il fattore 1 / 0,693 ≈ 1,44 e si ottiene la famosa formula: f = 1,44 / ((R1 + 2·R2) · C).

Quando scegli i valori, tieni presenti alcuni limiti. R1 deve essere di almeno 1 kΩ; altrimenti, quando il transistor di scarica conduce, collega VCC quasi direttamente a GND. Secondo il datasheet di Texas Instruments, a causa della piccola corrente assorbita dall'ingresso di soglia, R1 + R2 non dovrebbe superare circa 3,4 MΩ a 5 V e 10 MΩ a 15 V; in pratica restare tra 1 kΩ e 1 MΩ è la scelta più sicura. Non scendere sotto 1 nF per il condensatore, perché la capacità propria della breadboard e dei cavi falserebbe il calcolo. Usa il NE555 sotto i 100 kHz; per segnali più veloci scegli una versione CMOS. Per decifrare i numeri stampati su un condensatore usa lo strumento codice condensatore, e per vedere la curva di carica lo strumento costante di tempo RC.

Regolare il duty cycle: scendere sotto il 50%

Nel circuito astabile di base il condensatore si carica attraverso R1 + R2 ma si scarica solo attraverso R2, quindi il tempo HIGH è sempre più lungo del tempo LOW e il duty cycle non può scendere sotto il 50%; scegliendo R2 molto più grande di R1 ti avvicini al 50%, ma non vai mai sotto. La soluzione è aggiungere un diodo 1N4148 in parallelo a R2, con l'anodo verso il pin 7 e il catodo verso il pin 6. Durante la carica la corrente passa nel diodo e scavalca R2; durante la scarica il diodo è polarizzato inversamente e la corrente scorre in R2. Si ottiene così tH ≈ 0,693 · R1 · C e tL ≈ 0,693 · R2 · C, e il duty cycle scende a R1 / (R1 + R2). Per esempio, con R1 = 10 kΩ, R2 = 47 kΩ e C = 10 µF il LED resta acceso 69 ms e spento 326 ms: un lampo breve e ben visibile con un duty cycle del 17,5%. La caduta di circa 0,6 V del diodo allunga un po' il tempo HIGH rispetto al calcolo, soprattutto a 5 V. Per capire come si comportano i diodi, leggi Cos'è un diodo?.

Se vuoi tenere fissa la frequenza e regolare solo il duty cycle, usa un potenziometro e due diodi. Collega il cursore del potenziometro al pin 7; collega un estremo al condensatore tramite un diodo (anodo dal lato del potenziometro) e l'altro estremo, sempre al condensatore, tramite un secondo diodo orientato al contrario (catodo dal lato del potenziometro). Con R1 = 1 kΩ, un potenziometro da 100 kΩ e C = 10 nF la frequenza resta a circa 1,4 kHz mentre il duty cycle varia all'incirca dall'1% al 99%, perché ruotando il potenziometro la somma delle resistenze di carica e scarica resta la stessa. Con un MOSFET in uscita è il metodo classico per regolare la velocità di un motore in corrente continua o la luminosità di una striscia LED a 12 V; trovi i dettagli in Cos'è il PWM? e Usare un MOSFET con Arduino.

Circuito monostabile: impulso singolo e luce temporizzata

Nel circuito monostabile i pin 6 (THRES) e 7 (DISCH) sono uniti; da questo punto parte una resistenza R verso VCC e un condensatore C verso GND. Il pin TRIG (2) viene tenuto HIGH da una resistenza di pull-up. A riposo l'uscita è LOW e il transistor di scarica tiene vuoto il condensatore. Quando su TRIG arriva un breve impulso LOW, l'uscita va HIGH, la scarica si interrompe e il condensatore comincia a caricarsi attraverso R. Quando la sua tensione raggiunge 2/3 VCC, l'uscita torna LOW e il condensatore viene scaricato all'istante. Questa volta la carica parte da zero fino a 2/3 VCC, quindi l'impulso dura ln 3 · R · C ≈ 1,1 · R · C e anche in questo caso non dipende dalla tensione di alimentazione.

1. Collega i pin 8 e 4 a +5 V e il pin 1 a GND; inserisci 100 nF tra i pin 8 e 1 e 10 nF tra il pin 5 e GND.
2. Unisci i pin 6 e 7. Da questo punto collega R = 470 kΩ verso +5 V e un condensatore elettrolitico da C = 100 µF verso GND (piedino negativo a GND).
3. Porta il pin TRIG (2) a +5 V con una resistenza da 10 kΩ e collega un pulsante tra il pin 2 e GND. Per i dettagli sul collegamento dei pulsanti, leggi Come collegare un pulsante ad Arduino.
4. Per la prima prova, collega un LED all'uscita (pin 3) tramite una resistenza da 330 Ω.
5. Premi brevemente il pulsante: il LED resta acceso circa 1,1 × 470 kΩ × 100 µF ≈ 52 secondi e poi si spegne. Per la tolleranza di ±20% dell'elettrolitico, un risultato tra 42 e 62 secondi è normale.
6. Per una lampada vera, pilota un relè al posto del LED: dall'uscita passa con 1 kΩ alla base di un transistor BC547, collega l'emettitore a GND e il collettore a un capo della bobina del relè; l'altro capo della bobina va a +5 V. Non dimenticare un diodo 1N4007 in antiparallelo alla bobina (catodo verso +5 V); per il ruolo del transistor, leggi Cos'è un transistor?.

Per interrompere la temporizzazione in anticipo puoi aggiungere un secondo pulsante sul pin RESET (4): porta il pin a VCC con 10 kΩ e collega il pulsante tra RESET e GND; appena lo premi, l'uscita va LOW e il condensatore viene scaricato. Un monostabile a volte si attiva da solo una volta quando riceve alimentazione. Per evitarlo, collega il pin RESET a VCC tramite 10 kΩ e a GND tramite 10 µF: all'accensione il chip resta in reset per il breve tempo necessario a caricare quel condensatore e inizia a funzionare normalmente quando l'alimentazione è stabile.

Come si usa il NE555 con Arduino?

Il 555 e Arduino non sono rivali, ma una buona squadra. Un semplice lampeggiatore puoi farlo anche con Arduino usando millis(), ma il 555 non richiede codice, funziona fino a 16 V, eroga 200 mA in uscita e continua a lavorare anche se Arduino si blocca. Per questo il 555 affianca di solito Arduino in uno di tre ruoli: come sorgente di segnale che Arduino misura, come timer hardware che Arduino attiva (misuratore di capacità, allungatore di impulsi) e come oscillatore che Arduino accende e spegne tramite il pin RESET (sirena o tono per buzzer). Nell'ultimo caso basta collegare il pin 4 del 555 a un'uscita di Arduino: con il pin HIGH l'oscillatore funziona, con il pin LOW tace.

Nel primo esempio Arduino misura frequenza e duty cycle del lampeggiatore e li confronta con i valori calcolati con le formule. Il circuito è lo stesso astabile visto sopra (R1 = 10 kΩ, R2 = 68 kΩ, C = 10 µF), ma alimentato dal pin 5V di Arduino invece che a 9 V, con l'uscita (pin 3) collegata a D2. La funzione pulseIn() restituisce, in microsecondi, per quanto tempo un pin resta HIGH o LOW.

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}

Per impostazione predefinita pulseIn() aspetta al massimo 1 secondo; con un segnale di circa 1 Hz attende prima la fine dell'impulso in corso e poi l'inizio di uno nuovo, perciò abbiamo portato il timeout a 3 secondi. È normale che nel Monitor seriale la frequenza misurata si discosti del 5–20% da quella calcolata; la maggior parte della differenza dipende dalla tolleranza dell'elettrolitico. Questa differenza è anche un modo per conoscere il valore reale del condensatore: inserisci la frequenza misurata in f = 1,44 / ((R1 + 2·R2) · C) e ricava C. Con segnali più veloci, contare i fronti con un interrupt invece di usare pulseIn() dà risultati più precisi.

Attivare il 555 con Arduino: un misuratore di capacità

Dato che in modalità monostabile l'impulso dura t = 1,1 · R · C, se conosci R e misuri t puoi trovare il valore del condensatore con C = t / (1,1 · R). Il circuito è questo: pin 6 e 7 uniti, con 100 kΩ da questo punto verso 5 V e il condensatore da misurare verso GND; pin 4 e 8 a 5 V, pin 5 a GND tramite 10 nF. Il pin TRIG (2) viene portato a 5 V con 10 kΩ e collegato a D7, mentre l'uscita (pin 3) va a D2. Arduino invia da D7 un impulso LOW di 10 µs e misura con micros() per quanto tempo l'uscita resta HIGH.

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}

Qui misuriamo a mano con micros() invece di usare pulseIn(), perché subito dopo il trigger l'uscita è già HIGH e pulseIn() considererebbe quell'impulso come «impulso precedente» e lo salterebbe. Sull'Uno micros() ha una risoluzione di 4 µs; con 100 kΩ un condensatore da 1 nF dà un impulso di 110 µs, quindi il campo di misura va all'incirca da 1 nF a 47 µF. Misura un condensatore noto e scrivi il rapporto tra il suo valore reale e quello misurato nel fattore CAL per calibrare il tuo strumento. Prima di collegare un elettrolitico, scaricalo cortocircuitandone i piedini e collega il piedino positivo dal lato dei pin 6 e 7.

Il NE555 con ESP32 e Raspberry Pi Pico

ESP32 e Raspberry Pi Pico funzionano a 3,3 V e i loro pin non tollerano i 5 V. Il classico NE555, invece, richiede almeno 4,5 V e quindi non può essere alimentato a 3,3 V. La soluzione più pulita è un 555 CMOS come il TLC555, l'LMC555 o l'ICM7555: ha la stessa piedinatura, si alimenta dal pin 3V3 e la sua uscita va da 0 a 3,3 V, quindi si collega direttamente a un GPIO. Se hai solo un NE555, alimentalo a 5 V e dividi la sua uscita con 10 kΩ (in serie) e 20 kΩ (verso GND). Poiché il livello HIGH del NE555 è di circa 3,5 V, l'uscita del partitore scende a circa 2,3 V: abbastanza per la soglia di 2 V del Pico, ma al limite per la soglia di circa 2,5 V dell'ESP32. Con l'ESP32 preferisci quindi un 555 CMOS.

Nell'esempio con ESP32, un 555 CMOS con R1 = 1 kΩ, R2 = 6,8 kΩ e C = 100 nF genera un segnale di circa 986 Hz; ha le stesse proporzioni del lampeggiatore, ma è mille volte più veloce. L'ESP32 esegue una routine di interrupt a ogni fronte di salita e stampa quanti fronti ha contato in un secondo; quel numero è direttamente la frequenza in Hz. Il duty cycle si calcola da un singolo tempo HIGH misurato con pulseIn().

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}

Sul Pico la funzione machine.time_pulse_us() di MicroPython è l'equivalente di pulseIn() di Arduino, con una differenza importante: se il pin è già al livello richiesto, inizia a misurare subito. Per questo la prima chiamata serve a saltare un impulso incompleto e a sincronizzarsi su un fronte del segnale; le misure LOW e HIGH che seguono riguardano impulsi completi. L'esempio misura il lampeggiatore da un lampo al secondo e a ogni lettura cambia lo stato del LED integrato.

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)

Idee di progetto con il NE555

• Lampeggiante della polizia: Accendi alternandoli un LED rosso e uno blu, uno collegato dall'uscita a GND e l'altro da VCC all'uscita; con 4,7 kΩ, 47 kΩ e 1 µF ottieni un effetto stroboscopico veloce.
• Sirena bitonale: Porta l'uscita di un primo 555 lento, tramite una resistenza, al pin 5 (CONT) di un secondo 555; quando le soglie si spostano, il tono del secondo chip sale e scende. Per il suono usa un buzzer passivo o un piccolo altoparlante.
• Luce scale temporizzata: Costruisci con un 555 monostabile, un relè e dei pulsanti un timer che tenga accesa una lampada per un minuto, con i pulsanti dei vari piani collegati in parallelo.
• Misuratore di capacità: Con il codice Arduino di questo articolo misura i condensatori con la sigla cancellata e mostra il risultato su un display LCD I2C.
• Trasmettitore IR: Pilota un LED infrarosso con un 555 astabile regolato a 38 kHz e rileva il segnale con un ricevitore IR; ottieni un semplice allarme a interruzione di fascio. I ricevitori per telecomandi come il TSOP o il VS1838B possono scambiare una portante continua per un disturbo e sopprimerla dopo poco, quindi accendi e spegni questo 555 dal suo pin RESET con un secondo 555 lento per trasmettere a raffiche.
• Regolatore di velocità per motore: Collega il circuito PWM a frequenza fissa con potenziometro a un MOSFET per regolare la potenza di un motore in corrente continua a 12 V o di una striscia LED.
• Rilevatore di impulsi mancanti: Aggiungi un transistor PNP (per esempio un BC557) in parallelo al condensatore di temporizzazione, con la base collegata a TRIG; ogni impulso LOW che Arduino invia a intervalli regolari attiva il 555 e insieme scarica il condensatore, così la temporizzazione riparte da capo. Se Arduino si blocca e gli impulsi si fermano, il tempo scade e il 555 fa scattare un allarme o riavvia il sistema.

Errori comuni e soluzioni

Il NE555 è uno dei componenti migliori per imparare, perché racchiude in un solo chip economico le idee di base della temporizzazione in elettronica (carica RC, soglia, comparatore, flip-flop). Comincia dal lampeggiatore da un lampo al secondo, poi cambia i valori per ottenere un tono per buzzer e infine prova la luce temporizzata monostabile e il misuratore di capacità con Arduino. Nell'app BlueGrays trovi passo dopo passo, con schemi e codice, progetti come il lampeggiante della polizia, le luci del passaggio a livello, l'illuminazione delle scale e il buzzer, così puoi provare fianco a fianco le versioni Arduino e Pico dei tuoi circuiti con il 555.