Ring and Johnson counters

Two special shift-register counters built by feeding the output of a shift register back to its input. They trade off "wasted" states for glitch-free, self-decoding counting.

[!intuition] The core picture

A shift register is just a chain of flip-flops passing a bit along like a bucket-brigade of people passing a ball. A counter normally needs an adder or complex logic. But what if we just take a shift register and loop its last output back into its first input? The pattern of 1s and 0s circulates forever — and that circulating pattern IS the count.

• Ring counter = feed $Q_{last}$ straight back to $D_{first}$. One "hot" bit circulates.
• Johnson counter (a.k.a. twisted-ring / switch-tail) = feed the complement $\overline{Q_{last}}$ back. This twist doubles the number of states.

WHY care? No decoding logic is needed to know the state — you read it directly. And each transition changes only one flip-flop at a time, so there are no decoding glitches (unlike a binary counter where multiple bits flip at once).

[!definition] Definitions

• Ring counter: an $n$-flip-flop shift register with $Q_{n-1}$ (or $\overline{Q}$) wired to $D_0$; exactly one flip-flop is high, and the 1 rotates. Has ==$n$== valid states.
• Johnson counter: same shift register but the inverted last output feeds the first input; produces ==$2n$== valid states.
• A valid/used state is one the counter actually visits in its normal cycle; all others are unused (lock-out) states.

[!formula] Number of states — derived, not memorised

WHY does a ring counter give $n$ states? Load a single 1 into $n$ cells. Each clock shifts it one position. After $n$ shifts the 1 has visited every cell and returned home. So the cycle length = number of cells: $\boxed{N_{\text{ring}} = n}$

WHY does Johnson give $2n$? Trace the fill/empty process. Start all 0. Feedback is $\overline{Q_{last}}=1$, so a 1 enters. Each clock the 1s fill from the left until the register is all 1s — that's $n$ steps. Now $\overline{Q_{last}}=0$, so 0s enter and empty the register from the left — another $n$ steps to reach all 0s again. $\text{fill } n \text{ steps} + \text{empty } n \text{ steps} = \boxed{N_{\text{Johnson}} = 2n}$

Efficiency (the 80/20 fact). With $n$ flip-flops you could count to $2^n$. So: $\text{state utilisation}=\frac{N}{2^n}=\begin{cases}\dfrac{n}{2^n} & \text{ring}\\[2mm]\dfrac{2n}{2^n} & \text{Johnson}\end{cases}$ Johnson is twice as efficient as ring but both are hugely wasteful vs a binary counter. You pay silicon for simplicity + no glitches.

[!example] Worked: 4-bit Ring counter ($n=4$)

Wiring: $D_0=Q_3,\; D_1=Q_0,\; D_2=Q_1,\; D_3=Q_2$. Preset with $1000$.

• Why start at 1000? The ring counter cannot generate its own starting 1 — feedback just copies. You must inject one 1 (preset/clear). Why this step? Because $D_0=Q_3$: if all cells were 0, $D_0=0$ forever → stuck at 0000.
• Why only 4 states? One 1 in 4 positions → 4 arrangements. Why this step? The number of hot positions equals the register length.

[!example] Worked: 4-bit Johnson counter ($n=4 \Rightarrow 8$ states)

Wiring identical except $D_0=\overline{Q_3}$. Start at $0000$.

• Why does it fill then empty? Once $Q_3=1$, feedback $\overline{Q_3}=0$ starts injecting 0s. Why this step? The twist (complement) is what flips the incoming bit and doubles the cycle.
• Decoding a state uniquely with a 2-input AND. Notice each state has exactly one "0→1 boundary" or "1→0 boundary". E.g. state $0011$ is the only one with $Q_1=1,Q_2=0$. So decode it with $Q_1\overline{Q_2}$. Why this step? Adjacent-bit patterns are unique per Johnson state → each output needs just a 2-input gate, cheap and glitch-free.

[!example] Self-starting fix (mini-derivation)

Problem: what if a Johnson counter powers up in an unused state like $0101$? Trace it: $0101\to \overline{Q_3}=1$, shift → $1010 \to 0101$… it oscillates in a dead loop, never joining the main cycle.

• Fix: modify the feedback so $D_0 = \overline{Q_3\,+\,\overline{Q_1}}$ style correction (a common trick: $D_0=\overline{Q_3}\cdot(Q_0+\overline{Q_2})$ variants) forcing illegal states back into the valid cycle. Why this step? A self-correcting counter must have every unused state eventually map into a used one, guaranteeing recovery after noise/power-up.

[!mistake] Common mistakes (steel-manned)

"A ring counter with $n$ flip-flops counts to $2^n$." Why it feels right: every other counter you learned (binary ripple/sync) does $2^n$. The fix: ring counters encode the count as position of a single 1, giving only $n$ states. The whole point is trading count-range for zero decode logic.

"Ring and Johnson are the same, one just has an inverter — no big deal." Why it feels right: the circuits differ by one wire. The fix: that inverter twists the ring and doubles states ($n\to2n$) and enables 2-gate self-decoding. One wire changes the fundamental state count.

"They start counting by themselves." Why it feels right: other counters just power on and go. The fix: both need initialisation (preset a 1 into a ring; clear a Johnson) or must be made self-starting, else they can lock into dead loops.

"Johnson state $1111$ then $0000$ — did we skip?" Why it feels right: looks like a jump. The fix: at $1111$ feedback is $\overline{Q_3}=0$, so a 0 shifts in giving $1110$, not $0000$. The all-0 state comes only after all 1s are shifted out.

[!recall]- Explain it to a 12-year-old

Imagine a line of 4 kids passing a single glowing ball to the right; the last kid throws it back to the first. Wherever the ball is = the "count" — that's a ring counter, 4 possible spots. Now the twist: the last kid, instead of passing the same ball, passes the opposite — if he has a lit ball he passes a dark one, and vice-versa. Now the whole line lights up one-by-one, then goes dark one-by-one. Twice as many patterns from the same kids! That's a Johnson counter. You never need a scoreboard — just look at the lights.

[!mnemonic]

• Ring = one 1 Runs in a Ring → $n$ states.
• Johnson = Just add iNverter → doubles → $2n$ (J for "twisted / double").
• "Ring: n. Johnson: 2n. Binary: 2ⁿ." — increasing count, increasing decode-cost.

Flashcards

Connections

• Shift Registers — the base building block both counters are made from.
• Synchronous Counters — compare: full $2^n$ range but multi-bit transitions cause glitches.
• Flip-Flops (D type) — the storage element used here.
• Glitches and Decoding Hazards — why single-bit-change counters matter.
• Self-starting Sequential Circuits — lock-out and correction feedback.
• Frequency Division — a ring counter divides clock by $n$, Johnson by $2n$.

Concept Map

Hinglish (regional understanding)