Design a 3-Bit Binary Counter Using T Flip-Flops

Verified Sources

Nov 3, 2026

A $3$ -bit binary counter cycles through all $2^3=8$ states in order: $000 \rightarrow 001 \rightarrow 010 \rightarrow 011 \rightarrow 100 \rightarrow 101 \rightarrow 110 \rightarrow 111 \rightarrow 000.$

We can build this counter using $3$ T flip-flops (one per bit). The key design rule is: for a T flip-flop, when $T=1$ the output toggles; when $T=0$ the output holds. This lets us derive each flip-flop’s $T$ input from the lower-order bits.

We define:

$Q_0$ : least-significant bit (LSB)
$Q_1$ : middle bit
$Q_2$ : most-significant bit (MSB)

So the counter is a synchronous design where all flip-flops share a common clock edge.

Mermaid state flow (conceptual):

Derive T inputs and connect the 3-bit counter

1
Step 1
The next state must increment modulo 8 (LSB changes every clock; $Q_1$ changes every 2 clocks; $Q_2$ changes every 4 clocks).
2
Step 2
For each bit $Q_i$ , choose $T_i$ so that $Q_i$ toggles exactly when the counter is supposed to change that bit. When $T_i=0$ , $Q_i$ must hold.
3
Step 3
Since $Q_0$ toggles every clock, set $T_0 = 1$ (logic high) so $Q_0$ toggles on every active clock edge.
4
Step 4
In a binary counter, $Q_1$ toggles when the LSB $Q_0$ transitions from 1 back to 0 during the increment pattern, which corresponds to the condition that $Q_0=1$ at the triggering clock edge. Thus set $T_1 = Q_0$ .
5
Step 5
Similarly, $Q_2$ toggles once every 4 clocks, which occurs when both $Q_0=1$ and $Q_1=1$ at the triggering edge (i.e., on the appropriate increment boundary). Set $T_2 = Q_0 \land Q_1$ .
6
Step 6
Connect a common clock to all three T flip-flops. Feed $T_0=1$ , $T_1=Q_0$ , and $T_2=Q_0 \land Q_1$ into the respective T inputs.

Final design equations

Let the flip-flops be clocked synchronously and updated on the same active clock edge.

The required combinational inputs are:

$T_0 = 1$
$T_1 = Q_0$
$T_2 = Q_0 Q_1$

Design checklist:

$Q_0$ toggles every clock because $T_0=1$ .
$Q_1$ toggles when $Q_0=1$ because $T_1=Q_0$ .
$Q_2$ toggles when $Q_0Q_1=1$ because $T_2=Q_0Q_1$ .

Mermaid logic wiring (conceptual):

Bit-change schedule across the 8 states

Shows when each bit toggles during the sequence 000→…→111→000. (Toggle at a transition means the bit changes value.)

Pro Tip: Verify toggle conditions, not just next-state values

For a T flip-flop counter, it’s easiest to design by ensuring $T_i=1$ exactly at the clock edges where bit $i$ must flip. Then the counter behavior follows automatically from toggle semantics.

Warning: Synchronous design assumes one common clock edge

All T inputs are evaluated combinationally and sampled at the same active clock edge. If your flip-flops are not truly synchronous (different clocks or clock skew assumptions), the derived $T_0, T_1, T_2$ equations may produce incorrect counting glitches.

Common checks and edge cases

Implementation roadmap

Define state/bit roles

Assign $Q_0$ (LSB) through $Q_2$ (MSB) and decide count order (binary up)."

Derive toggling moments

Use toggle schedule: LSB toggles every clock; next bit every 2 clocks; MSB every 4 clocks."

Compute T inputs

Set $T_0=1$ , $T_1=Q_0$ , $T_2=Q_0Q_1$ ."

Wire and simulate

Connect all flip-flops to a common clock; simulate 8 transitions and confirm wrap-around."

T flip-flop counter quick checks

1 / 5

Question · Term

What does T=1 do in a T flip-flop?

Click to reveal

Answer · Definition

It toggles the output on the active clock edge.

Knowledge Check

Question 1 of 4

Q1Single choice

In a 3-bit binary counter made from T flip-flops, which input should be tied to logic 1 to toggle the LSB every clock?

None of the above

Explore Related Topics

Designing a Turing Machine for the 2’s Complement of a Binary String

Understanding Digital Counters: Principles, Types, and Applications

Digital counters are sequential circuits built from cascaded flip‑flops that count input events, with a maximum modulus of 2ᴺ for N stages, and are classified as asynchronous (ripple) or synchronous based on clock distribution.

Asynchronous counters cascade flip‑flop clocks, causing cumulative propagation delay and limiting maximum frequency.
Synchronous counters receive the clock simultaneously, using combinational logic to eliminate ripple delay and support higher speeds.
Designing a synchronous Mod‑6 counter involves defining the state sequence, creating excitation tables, simplifying with Karnaugh maps, and wiring JK flip‑flops with derived logic.
Ring counters yield N states; Johnson counters double this to 2N states.
Prevent glitches and lock‑out by using Gray‑code sequencing, output strobes, and ensuring unused states redirect to the main count sequence.

Basic Blocks and Control-Flow Graphs (CFGs) from Three-Address Code

Browse all research articles