Want to build electronics that blink, beep, sweep, and sense — but don't know where to start? The 555 timer IC is the single most versatile chip for beginners, and when you pair it with an Arduino, you unlock projects that teach you timing, PWM, analog sensing, and digital control all at once. This guide walks through ten 555 timer projects with full circuit diagrams, code, and wiring — from a classic blinker to a PWM motor driver and a touch-activated switch.
Why the 555 Timer + Arduino Is a Perfect First Combo
The NE555 (or its CMOS cousin TLC555) is a three-decade-old chip that still appears in millions of products. It runs on 3V to 15V, can source or sink up to 200mA, and generates stable timing pulses from microseconds to minutes. Its three operating modes — astable (oscillator), monostable (one-shot), and bistable (flip-flop) — cover 90% of what beginners need to learn.
An Arduino brings digital control, analog reading, and serial debugging to the table. Together, they let you replace potentiometers with code, log timing data to your PC, or trigger the 555 from sensor inputs.
Before diving into specific builds, make sure you have these basics on hand:
| Component | Purpose |
|---|---|
| NE555 or TLC555 | The star of the show |
| Breadboard + jumper wires | Prototyping and wiring |
| 100µF + 0.1µF capacitors | Power decoupling and timing |
| 1kΩ – 10kΩ resistors | Current limiting and timing |
| 10kΩ potentiometer | Adjustable timing resistor |
| LEDs + 220Ω resistors | Visual output |
| Arduino Uno or Nano | Control and monitoring |
1. LED Flasher (Astable Mode) – The Hello World of 555 Timer Projects
Every 555 timer projects list starts here. This astable circuit blinks an LED at a frequency determined by R1, R2, and C1.
Circuit Diagram
+5V
│
R1 (1kΩ)
│
┌────┤(7) Discharge
│ │
R2 │
(10kΩ)│
│ │
├────┤(2) Trigger
│ │
C1 │
(10µF)│
│ │
GND GND
Connect pin 4 (Reset) and pin 8 (Vcc) to +5V. Pin 1 (GND) goes to ground. Output at pin 3 drives an LED through a 220Ω resistor to ground.
Frequency = 1.44 / ((R1 + 2×R2) × C1). With values above, you get about 6.5 Hz — a visible blink.
Arduino Integration
Replace R2 with a digital potentiometer (like MCP4131) controlled via SPI. The Arduino adjusts the blink rate in real time:
#include <SPI.h>
const int CS = 10;
void setup() {
SPI.begin();
pinMode(CS, OUTPUT);
digitalWrite(CS, HIGH);
}
void loop() {
for (int i = 0; i < 128; i++) {
digitalWrite(CS, LOW);
SPI.transfer(0x00); // command byte
SPI.transfer(i); // resistance value
digitalWrite(CS, HIGH);
delay(100);
}
}
This turns a fixed blinker into a programmable strobe — great for learning timing control without soldering a new resistor each time.
2. Touch-Activated Switch (Monostable Mode)
A monostable configuration produces a single output pulse when triggered. Here, your finger acts as the trigger.
Circuit
Connect a small piece of copper foil or a wire to pin 2 (Trigger). When you touch it, the capacitance of your body pulls the pin low, starting a fixed-duration pulse. Output stays high for time = 1.1 × R1 × C1.
Use R1 = 1MΩ and C1 = 100µF for a 110-second pulse — plenty of time to blink an LED or control a relay.
// Arduino monitors the 555 output pin
const int outputPin = 3; // 555 output connected to D3
void setup() {
Serial.begin(9600);
pinMode(outputPin, INPUT);
}
void loop() {
int state = digitalRead(outputPin);
if (state == HIGH) {
Serial.println("Touched!");
delay(200);
}
}
You can replace the manual touch with an Arduino digital pin. Pull pin 2 low with digitalWrite(triggerPin, LOW) followed by a brief delay(10) and digitalWrite(triggerPin, HIGH). The 555 handles the precise timing while the Arduino handles higher-level logic.
3. PWM Motor Speed Controller (Astable with Duty Cycle Control)
The 555 can generate a PWM signal by adjusting the ratio of R1 to R2. With a 1N4001 diode across R2, you can set duty cycle independent of frequency.
Parts
- NE555
- 10kΩ potentiometer (for duty cycle)
- 100nF capacitor (timing cap)
- IRFZ44N N-channel MOSFET (to drive motor)
- 1N4001 flyback diode
Circuit
Wire the 555 in astable mode. Connect the potentiometer as a voltage divider feeding pin 5 (Control Voltage). Adjusting the pot changes the threshold and trigger levels, altering duty cycle from ~5% to 95%.
Output from pin 3 drives the MOSFET gate through a 1kΩ gate resistor. The motor connects between +12V and MOSFET drain.
Arduino Monitoring
Read the duty cycle with an oscilloscope or with Arduino:
const int pwmInput = 2; // 555 output to D2 (interrupt pin)
volatile unsigned long highTime = 0;
volatile unsigned long lowTime = 0;
volatile byte state = 0;
void setup() {
Serial.begin(115200);
attachInterrupt(digitalPinToInterrupt(pwmInput), measurePWM, CHANGE);
}
void loop() {
if (state) {
float duty = 100.0 * highTime / (highTime + lowTime);
Serial.print("Duty cycle: ");
Serial.println(duty);
state = 0;
}
delay(100);
}
void measurePWM() {
static unsigned long lastTime = 0;
unsigned long now = micros();
if (digitalRead(pwmInput) == HIGH) {
lowTime = now - lastTime;
} else {
highTime = now - lastTime;
state = 1;
}
lastTime = now;
}
This is the heart of closed-loop motor control — you can log duty cycle and compare it to setpoints.
4. Missing Pulse Detector (Stable Mode with Trigger)
This clever circuit detects when a periodic signal stops. The 555 is held in reset by incoming pulses; if pulses stop, the output goes high.
Wiring
- Connect pin 2 to a 10kΩ pull-up to +5V, then to your signal source (e.g., an Arduino PWM pin).
- Connect a capacitor from pin 6 to ground.
- Pin 7 goes to +5V through a 1kΩ resistor.
When the signal stops low for longer than the RC time constant (1.1 × R × C), the output fires.
Arduino Integration
Feed a 1 kHz square wave from tone(9, 1000) on an Arduino pin. The 555 holds its output low. When you stop the tone, the output goes high. Read it with:
const int detectPin = 4;
void setup() {
pinMode(9, OUTPUT);
pinMode(detectPin, INPUT);
Serial.begin(9600);
tone(9, 1000);
}
void loop() {
if (digitalRead(detectPin) == HIGH) {
Serial.println("Signal lost!");
noTone(9); // optional: restart after detection
delay(1000);
tone(9, 1000);
}
}
Useful for watchdog timers, alarm systems, or detecting when a sensor stops sending data.
5. Voltage-to-Frequency Converter (VCO Mode)
By applying a control voltage to pin 5, the 555 output frequency changes. This creates a simple VCO — a key building block for frequency-shift keying (FSK) and analog-to-digital conversion.
Circuit
- Astable mode with fixed R1=10kΩ, R2=10kΩ, C1=100nF
- Pin 5 connected to Arduino analog output (PWM filtered through RC)
Arduino Code
const int pwmPin = 9; // 490 Hz PWM
void setup() {
pinMode(pwmPin, OUTPUT);
}
void loop() {
for (int i = 0; i < 256; i++) {
analogWrite(pwmPin, i);
delay(20);
}
}
Smooth the PWM output with a 1kΩ resistor and 10µF capacitor to ground before feeding pin 5. The 555 output frequency will sweep from ~3kHz to ~7kHz. You can read this with pulseIn() on an Arduino input pin to create a simple digitizer.
6. Sequential Timer with Relay Output
Trigger a 555 in monostable mode, then feed its output to a second 555 in delayed start. This creates a two-stage timer — useful for "water first, then heat" scenarios.
Wiring Stack
- 555#1: monostable, triggered by push button, output drives relay 1
- 555#2: monostable, triggered by falling edge of 555#1 output, drives relay 2
The timing resistors and capacitors set stage durations. Use 100kΩ + 100µF for ~11 seconds per stage.
Relays connect to pin 3 through a 1kΩ base resistor driving a 2N2222 transistor or a MOSFET for larger loads.
Arduino Control
Replace the push button with an Arduino pin:
const int triggerPin = 7;
void setup() {
pinMode(triggerPin, OUTPUT);
digitalWrite(triggerPin, HIGH);
}
void loop() {
if (Serial.available()) {
char c = Serial.read();
if (c == 's') {
digitalWrite(triggerPin, LOW);
delay(50);
digitalWrite(triggerPin, HIGH);
}
}
}
Send 's' over serial, and both stages run their course independently.
7. Frequency Divider (Bistable Mode)
The 555 in bistable mode acts like an SR flip-flop. Trigger (pin 2) sets output high; Reset (pin 4) sets it low. Feed a square wave from the Arduino to pin 2, and the output changes state on each rising edge — a divide-by-2 circuit.
Circuit
- Pin 6 tied to ground (reset internal comparator)
- Pin 4 pulled high through 10kΩ
- Pin 2 receives the input signal
Arduino Integration
const int inputPin = 8; // 1 kHz wave from tone()
void setup() {
pinMode(inputPin, OUTPUT);
tone(inputPin, 1000);
}
void loop() {
// 555 output toggles at 500 Hz
}
Cascade two 555 dividers for divide-by-4, or use one 555 and a CD4017 counter chip for divide-by-10. This is how old clock circuits created sub-frequencies without microcontrollers.
8. Rain Sensor Alarm (Astable with External Trigger)
Use two exposed wires as a moisture sensor. When rain bridges the gap, the 555 fires and sounds a buzzer.
Circuit
- Monostable mode with trigger pulled to ground through a 1MΩ resistor
- Two copper tracks or exposed wires connect pin 2 to +5V
- Output drives a piezoelectric buzzer through a 100Ω resistor
Normally, the 1MΩ holds pin 2 low. Rainwater creates a conductive path to +5V, raising pin 2 above 1/3 Vcc and triggering the monostable.
Arduino Data Logging
Read the output pin with Arduino:
const int alarmPin = 3;
void setup() {
Serial.begin(115200);
pinMode(alarmPin, INPUT);
}
void loop() {
if (digitalRead(alarmPin) == HIGH) {
Serial.println("RAIN DETECTED");
}
delay(1000);
}
Combine with an RTC module and an SD card shield to log rainfall events over weeks.
9. Audible Continuity Tester (Astable with Speaker)
Test circuit continuity with an audio tone instead of an LED — easier to hear when your hands are busy.
Circuit
- Replace the LED in the astable flasher with an 8Ω speaker through a 100µF coupling capacitor
- Add a test probe between pin 4 (Reset) and ground
When the probes touch, pin 4 goes high, enabling the oscillator. A tone of ~1 kHz plays through the speaker. Open probes = silence.
Arduino Upgrade
Read the tone frequency with pulseIn() and display it on an OLED:
#include <Wire.h>
#include <Adafruit_SSD1306.h>
#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 32
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, -1);
const int tonePin = 2;
void setup() {
pinMode(tonePin, INPUT);
display.begin(SSD1306_SWITCHCAPVCC, 0x3C);
display.display();
delay(2000);
display.clearDisplay();
display.setTextSize(1);
display.setTextColor(SSD1306_WHITE);
}
void loop() {
unsigned long freq = pulseIn(tonePin, HIGH, 100000);
display.clearDisplay();
display.setCursor(0, 0);
if (freq > 0) {
display.print("Freq: ");
display.print(1000000.0 / (2 * freq));
display.print(" Hz");
} else {
display.print("Open circuit");
}
display.display();
delay(200);
}
Check our guide on OLED Display Arduino for wiring details.
10. PWM LED Dimmer with Arduino Feedback
Combine the 555 PWM motor driver from project #3 with a photoresistor for closed-loop lighting.
Circuit
- 555 astable PWM generator
- Photoresistor in a voltage divider feeding Arduino analog input
- Arduino reads ambient light, adjusts a digital potentiometer (or a transistor base voltage) to change 555 PWM duty cycle
Code
const int ldrPin = A0;
const int digiPotCS = 10;
void setup() {
pinMode(digiPotCS, OUTPUT);
digitalWrite(digiPotCS, HIGH);
SPI.begin();
Serial.begin(9600);
}
void loop() {
int light = analogRead(ldrPin);
// Map brightness (0-1023) to pot value (0-128)
int potVal = map(light, 0, 1023, 0, 128);
digitalWrite(digiPotCS, LOW);
SPI.transfer(0x00);
SPI.transfer(potVal);
digitalWrite(digiPotCS, HIGH);
Serial.print("Light: ");
Serial.print(light);
Serial.print(" Pot: ");
Serial.println(potVal);
delay(200);
}
The LED maintains constant perceived brightness regardless of room light. This is the core concept behind automatic headlights and display backlight control.
Wrapping Up
These 555 timer projects are designed to teach you fundamental electronics: RC time constants, feedback loops, comparator thresholds, and mixed-signal systems. Each build starts with a standalone 555 circuit, then adds Arduino for monitoring, control, or data logging. You can mix and match — use the rain sensor alarm with the OLED display, or the VCO with the PWM dimmer.
Start with the 555 Timer IC: Build a Simple LED Flasher if you haven't built it yet, then work your way through the list. By the tenth project, you'll be comfortable designing your own hybrid analog-digital circuits.
All code from this post is available on GitHub — fork it, modify the timings, and make each project your own.