Blinking an LED with a 555 timer and no code

Every microcontroller tutorial on this site does the same job with a chip that runs code. This one does it with a chip that runs nothing at all: the NE555 has no processor inside it, no program memory and no clock of its own, only three comparators worth of analog logic and a flip-flop. Every timing interval it produces comes entirely from the resistor and capacitor wired around it, and that is worth building once precisely because it is the clearest possible answer to "where does the timing actually come from": in a 555 circuit, unlike a microcontroller sketch, there is nowhere else for it to be hiding.

The circuit above blinks an LED from a 555 wired as an astable, with a slide switch that swaps between two different blink rates while it runs, so the effect of changing the resistors is something you can watch rather than take on faith.

The capacitor charges toward the supply through R1 and R2 together. When it crosses two thirds of the supply, an internal comparator trips the chip's flip-flop, the output goes low, and pin 7 starts discharging the same capacitor back down, this time through R2 alone. When the capacitor falls past one third of the supply, a second comparator flips the flip-flop back, the output goes high again, and the cycle repeats for as long as power is applied. Charging through two resistors and discharging through one is also why an astable's duty cycle is never quite 50 percent unless the circuit is deliberately built to make it so.

The frequency this produces has a name-brand formula: f = 1.44 / ((R1 + 2 × R2) × C). With R1 at 10 kilohms, R2 at 47 kilohms and C at 10 microfarads, that comes out to roughly 1.4 Hz, a slow, deliberate blink. Flip the switch to the 4.7 kilohm resistor and the same formula gives roughly 7.4 Hz, visibly faster. Mokxi's capacitor is solved as a real RC network rather than assumed to match the formula, and it lands within a small fraction of a percent of it across a wide range of R and C, so changing a value in the properties panel while the circuit runs moves the blink rate by the amount the formula predicts, not merely in the right direction.

A 555 blinker is not a smaller version of an Arduino sketch; it is a genuinely different tool for the same visible result. It has no code to write or upload, it keeps working with the microcontroller left out of the design entirely, and it is the natural first build for someone who wants to understand timing from the resistor and capacitor up rather than from a language's delay() function down. An Arduino, in turn, is the better choice the moment the blink needs to respond to anything else on the board, or needs a rate that changes based on a sensor reading rather than a switch position. Both are worth having built once.

The comparison is also a useful check on the Arduino build itself. The Uno's own `blink` sketch times its half-second waits from a hardware timer interrupt, not from spinning the CPU, and a 555 astable does the analog equivalent: an internal comparator, not a loop of any kind, decides when to flip the output. Neither one is faster or more accurate in any absolute sense; the microcontroller's timer is crystal-referenced and highly repeatable run to run, while the 555's rate depends on the actual tolerance of its resistors and capacitor, which is why a 555 build is usually trimmed by ear or by scope rather than trusted to hit a frequency to three decimal places out of the parts bin.

It is also worth noticing what a 555 cannot do that a microcontroller can: it has no memory of anything before the present cycle, no way to count presses, and no way to change its own behavior based on anything but the voltage on its five pins right now. That is not a shortcoming so much as the honest description of an analog chip, and it is exactly the line where reaching for a microcontroller stops being overkill and starts being the only tool that actually does the job.