LED-J-Letter-Sequencer

This project is a DIY electronics build that creates an animated 'J' letter using 20 LEDs. The sequencing is controlled by two CD4017 decade counters, clocked by a 555 timer configured as an astable multivibrator. This was built as a thoughtful birthday gift.

Project Overview

The goal was to create a visual display of the letter 'J' with chasing LEDs. Twenty LEDs are used in total, arranged on a perfboard to form the letter.

Design Philosophy & Why Not a Microcontroller?

While a similar LED sequencing effect could be readily achieved with a microcontroller (like an Arduino Uno or ESP32) and a few lines of code, this project intentionally uses "raw" electronic components like the 555 timer and CD4017 decade counters. The reasons for this approach include:

• Learning & Satisfaction: Building with discrete logic ICs offers a deeper understanding of fundamental timing, counting, and sequencing principles. There's a unique satisfaction in creating functionality from these basic building blocks without relying on pre-written libraries or higher-level abstractions.
• The Joy of Hardware: For enthusiasts, the process of designing, soldering, and debugging a circuit entirely at the hardware level is a rewarding challenge in itself.
• Simplicity for the Task: For a dedicated, repetitive task like this LED sequencer, dedicated ICs can be a very straightforward and robust solution.
• Potential Longevity & Robustness: Simple, dedicated ICs like the CD4000 series are known for their robustness. For a device intended to run continuously for its display purpose, a simpler hardware-based solution might offer a long operational lifespan with fewer potential points of failure compared to a more complex microcontroller system (especially concerning software stability over very long periods).
• Power Efficiency for a Dedicated Task: This circuit is designed to be relatively power-efficient for its function. The CMOS CD4017 ICs have low static power consumption, and the primary power draw comes from the LEDs themselves (one or two active at a time, depending on the cascading behavior). This allows the circuit to run for an extended period (e.g., estimated 5+ hours) on standard AA batteries without needing frequent changes, which might be more challenging to achieve with a general-purpose microcontroller board that isn't aggressively optimized for low-power sleep modes.

In essence, this project prioritizes the hands-on electronics experience and the elegance of a solution built from fundamental components.

Components Used

• 2 x CD4017BE Decade Counter ICs (Texas Instruments)
• 1 x NE555P Timer IC
• 20 x Yellow LEDs
• Resistors for 555 Timer:
  • R1: 1kΩ
  • R2: 10kΩ
• Capacitor for 555 Timer:
  • C1: 22µF
• Current Limiting Resistors for LEDs: ( typically 220Ω - 1kΩ for 6V operation, I used 330Ω)
• 2 x 100nF Bypass Capacitors (one for each CD4017 VDD)
• Perfboard (9x15 cm)
• Assorted Wires
• 4 x AA Battery Holder
• 4 x AA Batteries (providing ~6V)
• 1 x SPST Switch

Circuit Design & Explanation

The circuit can be broken down into two main parts: the clock generator (555 timer) and the LED driver/sequencer (CD4017 counters).

1. 555 Timer (Astable Oscillator)

The 555 timer is configured in astable mode to generate a continuous square wave (clock signal) for the CD4017 counters.

• R1 (1kΩ) and R2 (10kΩ) along with C1 (22µF) determine the frequency and duty cycle of the output.
  • Frequency (f) ≈ 1.44 / ((R1 + 2*R2) * C1)
  • f ≈ 1.44 / ((1000 + 2*10000) * 22e-6) ≈ 1.44 / (21000 * 22e-6) ≈ 1.44 / 0.462 ≈ 3.12 Hz
  • Duty Cycle ≈ (R1 + R2) / (R1 + 2*R2) * 100%
  • Duty Cycle ≈ (1000 + 10000) / (1000 + 2*10000) * 100% ≈ (11000 / 21000) * 100% ≈ 52.38%
• The output of the 555 timer (Pin 3) is connected to the Clock input (Pin 14) of the first CD4017.

2. CD4017 Decade Counters

Two CD4017 decade counters are used to drive the 20 LEDs. Each CD4017 has 10 decoded outputs (Q0-Q9) that go high one at a time in sequence on the rising edge of a clock pulse.

Hand-drawn Schematic Reference:

Common Connections for both CD4017s:

• VDD (Pin 16): Connected to +6V (VCC).
• VSS (Pin 8): Connected to Ground (GND).
• Reset (Pin 15): Connected to Ground. This is an active-high reset, so tying it low allows the counter to operate normally.
• Clock Inhibit (Pin 13): Connected to Ground. Tying this low enables the clock input.
• Outputs (Q0-Q9: Pins 3, 2, 4, 7, 10, 1, 5, 6, 9, 11 respectively): Each output is connected to the anode of an LED, with the cathode connected to ground through a current-limiting resistor.
• Bypass Capacitor: A 100nF capacitor is connected between VDD (Pin 16) and VSS (Pin 8) for each CD4017 to decouple the power supply.

Cascading the CD4017s:

• First CD4017 (U1):
  • Clock (Pin 14): Connected to the output (Pin 3) of the 555 timer.
  • Carry Out (Pin 12): Connected to the Clock input (Pin 14) of the second CD4017.
• Second CD4017 (U2):
  • Clock (Pin 14): Connected to the Carry Out (Pin 12) of the first CD4017.
  • Carry Out (Pin 12): Not used in this 20-LED configuration.

Power Supply

The circuit is powered by four AA batteries in series, providing approximately 6V. A switch is included in the power line.

Observed Behavior & The "Misunderstanding" of Cascading

The initial expectation for the cascaded counters was that after the first 10 LEDs (driven by U1) completed their sequence, the second set of 10 LEDs (driven by U2) would immediately start their full sequence from 1 to 10.

Actual Observed Behavior: This is the standard and correct behavior for cascading CD4017s using the Carry Out pin:

1. The first CD4017 (U1) sequences through its 10 LEDs (Q0-Q9) based on the 555 timer clock.
2. When U1 completes its 10th count (Q9 goes high then low) and rolls over from count 9 to 0, its Carry Out (Pin 12) pin outputs a positive pulse.
3. This single pulse from U1's Carry Out serves as the clock signal for the second CD4017 (U2).
4. Therefore, U2 advances by one count (e.g., its Q0 LED lights up).
5. U1 then immediately begins its 0-9 sequence again.
6. This cycle repeats: U1 completes a full 0-9 sequence, which then advances U2 by one more step.

In essence:

• The first LED of U2 lights up. U1 cycles 0-9.
• The second LED of U2 lights up. U1 cycles 0-9.
• ...and so on.
• The tenth LED of U2 lights up. U1 cycles 0-9.
• Then the entire process repeats from the beginning.

This means that to light all 20 LEDs sequentially as if they were one continuous chain of 20 (U1 Q0-Q9, then U2 Q0-Q9, then repeat), this direct cascading method via Carry Out does not achieve that. The Carry Out pin provides a clock pulse for every 10 input clock pulses, effectively acting as a "divide-by-10" output.

Construction Notes

• The circuit was built on a 9x15 cm perfboard.
• Wiring was done point-to-point on the underside of the board.
• The CD4017 datasheet referenced was a Texas Instruments version, revised in February 2004, btw this is when i was born :) .

Learning Points & Future Considerations

• This project was a great hands-on experience with 555 timers and CD4017 decade counters.
• A key learning was understanding the precise behavior of the Carry Out pin when cascading counters. It doesn't simply "pass the torch" for a continuous sequence but rather clocks the next stage after a full cycle of its own.
• For a true 20-LED sequential chase (1-20 then repeat): A different logic approach would be needed. Options include:
  • Using shift registers (e.g., two 74HC595s).
  • More complex counter logic to enable U2 only after U1 has finished and disable U1 while U2 is active, then reset. This would likely involve additional logic gates.

---