Ring and Johnson counters: Visual walkthrough — Hardware deep dive

Step 1 — What is a single storage box (a flip-flop)?

WHAT. Before any counter, meet the smallest character in the story: one memory box called a flip-flop. It holds exactly one symbol — a $0$ or a $1$ — and it only changes at the instant a clock "ticks".

WHY this and not just a wire? A plain wire forgets instantly. We need something that remembers its bit between ticks so a pattern can be stored and shuffled around. The specific box we use is a D-type flip-flop: whatever sits on its input wire (called $D$ , for "Data") gets copied into memory on the tick, and shows up on its output wire (called $Q$ ).

PICTURE. One box, its $D$ arrow coming in, its $Q$ arrow going out, and the rule written on it.

Step 2 — Chain the boxes: the bucket-brigade

WHAT. Line up $n$ boxes. Wire each box's output into the next box's input: $Q_{0} \to D_{1}$ , $Q_{1} \to D_{2}$ , $Q_{2} \to D_{3}$ . This is a shift register — a bucket-brigade that passes each stored bit one seat to the right per tick.

WHY wire them this way? Because "pass the bit along" is the only motion we want. On each tick, box 1 becomes whatever box 0 was, box 2 becomes whatever box 1 was, and so on. The whole pattern slides right by one.

D_{1} = Q_{0}, D_{2} = Q_{1}, D_{3} = Q_{2}

Read each equation as "the box on the left of the arrow copies the box on the right at the next tick." Note nothing feeds $D_{0}$ yet — that dangling input is the decision that creates a counter.

PICTURE. Four boxes with the chain arrows, and one lonely unconnected $D_{0}$ on the far left waiting for a wire.

Step 3 — Close the loop → a ring counter

WHAT. Fill the dangling $D_{0}$ by looping the last output straight back to the first input:

D_{0} = Q_{3}

Here $Q_{3}$ is "what the rightmost box shows now"; $D_{0}$ is "what the leftmost box becomes next." So the bit that falls off the right end reappears on the left. Now nothing leaks out — the pattern circulates forever. That closed loop is the ring counter.

WHY the straight wire (no changes)? Because we want the same bit to travel around unchanged, like one glowing ball handed in a circle. If exactly one box holds a $1$ and the rest hold $0$ , that $1$ just orbits.

PICTURE. The chain from Step 2 bent into a loop, with the feedback wire highlighted (burnt orange) from $Q_{3}$ back to $D_{0}$ .

Step 4 — Watch the ring count → the number $n$ appears

WHAT. Inject a single $1$ (state $1000$ , meaning $Q_{3} Q_{2} Q_{1} Q_{0} = 1000$ ) and turn the crank. Each tick slides the lone $1$ one seat right; when it falls off the right it re-enters on the left.

1000 tick 0100 tick 0010 tick 0001 tick 1000

WHY does the answer come out $n$ ? Count the distinct pictures. There are exactly $4$ seats where the single $1$ can sit — one per box. After $4$ ticks it has visited every seat and come home. So the cycle length equals the number of boxes:

N_{ring} = n (n = 4 here)

Each symbol: $N_{ring}$ = how many states before it repeats; $n$ = number of flip-flops. They are equal because "one hot bit in $n$ seats" has exactly $n$ arrangements.

PICTURE. The four legal states drawn as four rows of lamps; the single lit lamp marches diagonally, arrow looping back to the top.

Step 5 — Add the twist → a Johnson counter

WHAT. Change one wire. Instead of feeding $Q_{3}$ back, feed its complement (its opposite) back:

D_{0} = \overline{Q_{3}}

The bar over $Q_{3}$ means "flip it": if $Q_{3} = 1$ then $\overline{Q_{3}} = 0$ , and if $Q_{3} = 0$ then $\overline{Q_{3}} = 1$ . So the bit that comes around the loop enters inverted. This one inverter turns the ring into a Johnson counter (a "twisted ring").

WHY does flipping the feedback change everything? Because now the register no longer recirculates a fixed pattern — it reacts to its own tail. When the rightmost box is empty ( $Q_{3} = 0$ ), the loop keeps pushing $1$ s in. Once the rightmost box fills ( $Q_{3} = 1$ ), the loop switches to pushing $0$ s in. So the register fills up, then empties out — a two-phase breathing motion instead of a spin.

PICTURE. Same loop as Step 3, but a plum inverter triangle sits in the feedback wire; a call-out shows " $Q_{3} = 0 \Rightarrow$ inject 1" vs " $Q_{3} = 1 \Rightarrow$ inject 0."

Step 6 — Watch Johnson fill → the number $n$ (first half)

WHAT. Start empty ( $0000$ ). While $Q_{3} = 0$ , feedback injects $1$ s from the left. Watch the $1$ s pile up:

0000 tick 0001 tick 0011 tick 0111 tick 1111

WHY exactly $n$ ticks to fill? There are $n = 4$ boxes, and each tick lights one more from the right side. Going from " $0$ ones" to "all $n$ ones" therefore takes exactly $n$ ticks. Right when we hit $1111$ , the rightmost box is $Q_{3} = 1$ , so $\overline{Q_{3}} = 0$ — the machine is about to reverse.

fill phase length = n

PICTURE. Four rows $0000 \to 1111$ , lamps lighting one-per-row from the right, a teal "+1 lamp each tick" annotation.

Step 7 — Watch Johnson empty → the other $n$ → the total $2 n$

WHAT. Now $Q_{3} = 1$ so feedback injects $0$ s. The register drains from the left:

1111 tick 1110 tick 1100 tick 1000 tick 0000

We are back to $0000$ , where it all began — one full cycle done.

WHY does the grand total come out $2 n$ ? Add the two phases:

fill n + empty n = N_{Johnson} = 2 n (2 n = 8 here)

Each symbol: the first $n$ = ticks to fill, the second $n$ = ticks to empty, $N_{Johnson}$ = total distinct states per cycle. The twist (the inverter) is precisely what gives you a second set of $n$ patterns for free — the same silicon, double the states.

PICTURE. Four rows $1111 \to 0000$ , lamps going dark one-per-row from the left, with the fill-half greyed above so you see all $8$ states stacked.

Step 8 — The degenerate & danger cases (never leave a gap)

WHAT. Two failure modes the happy path hides:

Ring stuck at zero. If a ring counter powers up as $0000$ , then $D_{0} = Q_{3} = 0$ and every box copies a $0$ forever. Dead. It cannot create a $1$ — feedback only copies. Fix: preset exactly one $1$ at power-on.
Johnson dead loop. If a Johnson counter powers up in an unused pattern like $0101$ , trace it: $\overline{Q_{3}} = 1$ , shift $\Rightarrow 1010$ , then $\overline{Q_{3}} = 0$ , shift $\Rightarrow 0101$ . It ping-pongs $0101 \leftrightarrow 1010$ forever, never joining the real cycle.

WHY show this? Because a real chip will land in a random state at power-up. The clean $n$ / $2 n$ cycles are only some of the $2^{n}$ patterns; the leftovers ( $2^{n} - N$ of them) must be accounted for.

unused states = 2^{n} - N = {2^{4} - 4 = 12 2^{4} - 8 = 8 ring Johnson

Fix. Make the counter self-starting: modify the feedback so every illegal state is forced back onto the legal ring (see Self-starting Sequential Circuits). For the 4-bit Johnson, a classic correction is $D_{0} = \overline{Q_{3}} \cdot (Q_{0} + \overline{Q_{2}})$ , which routes strays like $0101$ into a legal state within a few ticks.

PICTURE. Left: ring frozen at $0000$ (all lamps dark, self-loop arrow). Right: the $0101 \leftrightarrow 1010$ dead loop drawn as a two-node island, disconnected from the main 8-state ring.

The one-picture summary

One diagram compresses the whole story: the same $4$ -box register, the same "slide right" motion — the only difference is whether the feedback wire is straight ( $D_{0} = Q_{3}$ , a ring of $n = 4$ states) or inverted ( $D_{0} = \overline{Q_{3}}$ , a twisted ring of $2 n = 8$ states). Straight loop ⇒ a lone bit orbits. Twisted loop ⇒ fill then empty.

Recall Feynman retelling — say it back in plain words

Picture four cups in a row, and a rule: every tick, each cup grabs whatever its left neighbour had. That's just passing water rightward — a shift register.

Ring: connect the last cup's water straight back to the first. Put water in one cup only. Now that splash marches right, falls off the end, reappears at the start — round and round. Four cups ⇒ four possible spots ⇒ four states. That's $n$ .

Johnson: same setup, but the last cup passes the opposite of what it holds. When the last cup is dry it keeps sending water in, so the row fills up from the right — that's $4$ ticks. The moment it's completely full, the last cup is wet, so now it sends dryness in, and the row empties from the left — another $4$ ticks. Fill four, empty four ⇒ eight states. That's $2 n$ , all from adding one little "flip it" gate.

Two warnings: an empty ring stays empty forever (you must drop in that first splash by hand), and a Johnson counter can get stuck sloshing $0101 \leftrightarrow 1010$ if it wakes up wrong — so you wire in a correction that shoves it back home.

[!recall]- Quick self-test

Ring counter,

n

boxes — how many states and why?

n

, because one hot bit has exactly

n

seats to sit in.

Johnson counter,

n

boxes — how many states and why?

2 n

n

ticks to fill +

n

ticks to empty, because the inverted feedback flips injection direction at full/empty.

What single wire change converts ring → Johnson?

Put an inverter in the feedback:

D_{0} = \overline{Q_{3}}

instead of

D_{0} = Q_{3}

Why can't a ring counter start itself from

0000

Feedback only copies existing bits; with all

0

D_{0} = Q_{3} = 0

forever — no bit to circulate.

What follows Johnson state

1111

1110

, since

\overline{Q_{3}} = 0

shifts a

0

into the left.

Connections

Ring and Johnson counters — the parent topic this walkthrough derives.
Shift Registers — the bucket-brigade of Steps 1–2.
Flip-Flops (D type) — the single memory box of Step 1.
Self-starting Sequential Circuits — the lock-out fix of Step 8.
Frequency Division — ring divides clock by $n$ , Johnson by $2 n$ (the cycle lengths we derived).
Glitches and Decoding Hazards — why one-bit-at-a-time transitions matter.