Ripple (Asynchronous) Counters: Worked Counts, Frequency Division and Propagation Delay

Trace a four-bit ripple counter pulse by pulse, calculate divided output frequencies and propagation delay, then see how reset decoding creates a MOD-10 counter.

KnowledgeGate Team

Exam prep & CS education

Updated 30 Oct 20265 min read
Ripple (Asynchronous) Counters: Worked Counts, Frequency Division and Propagation Delay

Each flip-flop in a ripple counter divides its input frequency by two, but the outputs do not settle together. A four-bit chain exposes the connection among stable count, intermediate states, modulus, divided frequencies and cumulative delay. Counter states use the order Q3Q2Q1Q0, with Q0 as the least significant bit.

1. Ripple counter: what changes asynchronously

In a ripple counter, only the first flip-flop receives the external clock. Each later stage is clocked by the preceding output, so a change travels through the chain. Asynchronous does not mean unclocked. The stages are edge-triggered, but do not share one clock edge.

Consider four negative-edge-triggered JK flip-flops with J=K=1. The external clock drives FF0, then Q0, Q1 and Q2 clock FF1, FF2 and FF3 respectively. Each stage therefore toggles at its falling edge. The broader Sequential Circuits in Digital Electronics: Flip-Flops, Registers and a Worked Mod-4 Counter covers flip-flops, registers and a three-stage ripple sketch; a four-stage ripple analysis adds the full 0-to-15 sequence, MOD-10 reset decoding and cumulative delay.

An n-bit binary ripple counter has 2^n stable states and modulus 2^n. Counting from Q0, output Qk has frequency:

f(Qk) = f_in / 2^(k+1)

This formula is for a complete binary counter. A truncated counter also needs reset analysis.

Four negative-edge-triggered JK flip-flops form a ripple chain, with Q0 through Q3 dividing the input frequency by 2, 4, 8 and 16.

2. Four-bit ripple counter worked example

Start from the clear state 0000. Each external falling edge toggles Q0. A 1 -> 0 transition at Q0 toggles Q1, and the same rule propagates upward.

The counter changes on each pulse:

  • Pulse 0: cleared state 0000

  • Pulse 1: Q0 rises, giving 0001

  • Pulse 2: Q0 falls and Q1 rises, giving 0010

  • Pulse 3: only Q0 rises, giving 0011

  • Pulse 4: Q0 falls, then Q1 falls and Q2 rises, giving 0100

The stable-state sequence is:

Pulse count

Stable Q3Q2Q1Q0

0

0000

1

0001

2

0010

3

0011

4

0100

5

0101

6

0110

7

0111

8

1000

9

1001

10

1010

11

1011

12

1100

13

1101

14

1110

15

1111

16

0000

The stable value equals the pulse count modulo 16. This convention produces an up-counter. If the active edge or interstage output changes, trace two or three pulses before deciding the direction.

3. Ripple counter as a frequency divider

For f_in = 1 MHz, T_in = 1/f_in = 1 microsecond. Divide by two at every stage:

Output

Frequency calculation

Frequency

Period

Q0

1 MHz / 2

500 kHz

2 microseconds

Q1

1 MHz / 4

250 kHz

4 microseconds

Q2

1 MHz / 8

125 kHz

8 microseconds

Q3

1 MHz / 16

62.5 kHz

16 microseconds

One complete Q3 waveform occupies 16 input periods, so it is divide-by-16. It toggles every eight pulses, but frequency counts full cycles. Every ideal output here has 50% duty cycle, unlike some outputs of a truncated MOD-10 counter.

4. Ripple propagation delay and temporary states

Let every flip-flop have t_pd = 12 ns. Just before the eighth active edge, the state is 0111. After the edge at t=0, the output changes in stages:

Time

Event

Observed state

0 to just before 12 ns

No output has responded yet

0111

12 ns

Q0 falls

0110

24 ns

Q1 falls

0100

36 ns

Q2 falls

0000

48 ns

Q3 rises

1000

The worst-case four-stage settling time is 4 x 12 ns = 48 ns. If the parallel count must settle before the next external edge, a first-cut upper bound is:

f_max approximately 1/(48 ns) = 20.83 MHz

A real design keeps margin for setup, reset and decoding delays. During the ripple, a decoder can briefly see 0110, 0100 or 0000, so glitch-sensitive decoding needs timing discipline.

Timing diagram of the 0111 to 1000 transition, showing Q0 through Q3 changing at 12 ns intervals and four temporary counter states.

5. MOD-10 ripple counter by reset decoding

A decade counter needs ten stable states. Since 2^3 = 8 is too small and 2^4 = 16 is sufficient, use four stages. Keep 0000 through 1001 for decimal 0 through 9, then reset.

For active-low clear, feed Q3 and Q1 into a NAND gate connected to every asynchronous CLR. After 1001, the ripple attempts 1010. Both inputs are then 1, so the NAND output clears the counter to 0000.

1010 is a brief decoded reset condition, not an eleventh stable count, so the modulus is 10. Gate and reset delays can create a transient, and selected outputs need not retain 50% duty cycle.

6. Ripple counter versus synchronous counter

Feature

Ripple counter

Synchronous counter

Clocking

Only FF0 receives the external clock

Every flip-flop receives the same external edge

State change

Travels from stage to stage

Begins together at the shared edge

Worst-case path

Roughly n x t_pd

Does not accumulate clock-to-Q delay stage by stage

Decoding

Can see temporary states

No ripple sequence, though logic still needs settling time

Hardware

Very simple

Requires next-state logic

Typical use

Low-speed counting and division

Faster, cleaner parallel counting

The four-stage ripple path took 48 ns with 12 ns devices. A synchronous design does not multiply clock-to-Q delay by four in the same way, although its combinational next-state logic still has delay. Use Sync Counter Analysis MCQs to practise that contrast through questions.

7. Ripple counter exam patterns and common traps

Most questions reduce to four tasks:

  1. Derive width or modulus. Four binary stages give MOD-16 unless reset logic truncates the sequence.

  2. Trace direction from the stated active edge and Q or complemented-output connection.

  3. Divide frequency stage by stage. Here 1 MHz becomes 62.5 kHz at Q3.

  4. Accumulate the longest delay. Here 4 x 12 ns = 48 ns.

Place these skills in the broader GATE CS Exam Preparation syllabus, without assuming every question uses the same convention.

Remember that asynchronous does not mean clockless, bits do not change together, and 1010 is not stable when it triggers clear. Also, f_in/16 is Q3 waveform frequency, not its toggle rate. Direction requires the edge and interstage connection.

Use this 20-second check: write Q3Q2Q1Q0, mark the active edge, trace three pulses, compute 2^n or identify the reset state, divide frequency stage by stage, then multiply the longest ripple path by t_pd. Follow it with Sequential Circuits MCQs: 11 Solved Flip-Flops for immediate practice.

8. Ripple counters: the short version and next step

A ripple counter gets binary counting and repeated divide-by-two behaviour with little logic, but every stage waits for the previous output. That makes propagation delay and decoding glitches grow down the chain. The key results are MOD-16 for four bits, Q3=62.5 kHz from 1 MHz, 48 ns worst-case settling with 12 ns per stage, and MOD-10 by clearing on 1010.

Redraw the four-stage chain from memory and reproduce the 0111 -> 1000 timing before attempting mixed counter questions. If you want Digital Logic sequenced with the rest of GATE CS, GATE Guidance by Sanchit Sir is the structured next step.