T Flip Flop Circuit Diagram: Toggle Operation and Counter Use
This is a free printable t flip flop circuit diagram: download the diagram as SVG or open it and print to paper or PDF.
The T flip-flop (Toggle flip-flop) is a single-input sequential device that either holds or toggles its output on every active clock edge depending on whether the T input is 0 or 1. Its characteristic equation Q(t+1) = T ⊕ Q(t) makes it the natural building block for binary ripple counters and frequency dividers, since setting T=1 permanently causes the output to divide the clock frequency by 2. The T flip-flop is most commonly implemented by converting a JK flip-flop with its J and K inputs tied together.
The T flip-flop has two inputs: T (toggle) and CLK, plus the usual complementary outputs Q and Q̄. The excitation table has only two rows: when T=0 the output holds its current value (Q(t+1)=Q(t)); when T=1 the output toggles (Q(t+1)=Q̄(t)). This simple behaviour makes the truth table trivial to memorise.
Characteristic equation: Q(t+1) = T ⊕ Q(t) = T·Q̄(t) + T'·Q(t). Expanding: if T=1, the XOR reduces to Q(t+1)=Q̄(t) (toggle); if T=0, Q(t+1)=Q(t) (hold). This is identical to the JK flip-flop with J=K=T.
Conversion from JK to T: The simplest T flip-flop implementation ties J and K together to a single T line. The JK characteristic equation Q(t+1)=J·Q̄+K'·Q becomes Q(t+1)=T·Q̄+T'·Q=T⊕Q when J=K=T. No additional gates are needed — just a wire join.
Conversion from D to T: To make a T flip-flop from a D flip-flop, add an XOR gate at the D input: D = T ⊕ Q(t). The Q output feeds back through an XOR with T to create the toggle behaviour. This requires one XOR gate per bit.
Binary ripple counter: The most common application of T flip-flops. With T=1 permanently, each stage divides its input clock by 2. Connecting four T flip-flops in a chain (Q of stage n feeds CLK of stage n+1) gives a 4-bit ripple counter that counts from 0 to 15 (binary 0000 to 1111). The output frequency at stage n is f_CLK / 2ⁿ. The ripple counter has a propagation delay that grows with the number of stages — for high-speed applications, a synchronous counter (74HC163) where all flip-flops share a common clock is preferred.
Synchronous T flip-flop counter: In a synchronous binary counter, all flip-flops share one clock but the T inputs are conditionally enabled using carry logic. The carry chain ensures all bits update simultaneously, eliminating the ripple glitch.
Frequency division: A single T flip-flop with T=1 (always toggle) and a 10 MHz clock input produces a 5 MHz square wave at Q with exactly 50% duty cycle. Cascading n stages divides by 2ⁿ, giving 5 MHz → 2.5 MHz → 1.25 MHz and so on.
Excitation table (used in state machine design): When designing a next-state circuit that drives T flip-flops, the excitation table maps the present state and desired next state to the required T input: if Q(t)→Q(t+1) is 0→0 or 1→1, T=0 (no toggle needed); if Q(t)→Q(t+1) is 0→1 or 1→0, T=1 (toggle required). This simplifies Karnaugh map minimisation for the input logic.
Build and simulate a 4-bit ripple counter from four T flip-flops (JK with J=K=1) in the free online schematic editor at circuitdiagrammaker.com to see the binary counting sequence live.
How to wire t flip flop circuit diagram
- Convert a JK flip-flop Use a 74HC112 JK flip-flop IC and connect a single wire from the T input terminal to both the J and K pins. This immediately gives T flip-flop behaviour.
- Set T=1 for constant toggle Tie the T line to VCC (logic HIGH) to make the flip-flop toggle on every clock edge, creating a divide-by-2 frequency divider.
- Connect a clock source Apply a square wave from a 555 astable circuit or function generator to the CLK pin. The output Q will toggle at half the clock frequency.
- Observe Q on an LED or oscilloscope Connect Q through a 330 Ω resistor to an LED; you will see the LED flash at half the input clock rate confirming the toggle operation.
- Chain stages for a counter Connect Q of stage 1 to CLK of stage 2 (and so on). With four stages, the circuit counts from 0000 to 1111 in binary before repeating.
- Add T=0 hold state Connect T to a logic switch. When T=0 the counter freezes; when T=1 it resumes counting. This is the enable function in practice.
- Read the binary output Connect LEDs to Q of each stage (Q0 = LSB through Q3 = MSB) to display the binary count visually on the breadboard.
Specifications
| T=0 (at clock edge) | Q(t+1) = Q(t) — Hold |
|---|---|
| T=1 (at clock edge) | Q(t+1) = Q̄(t) — Toggle |
| Characteristic equation | Q(t+1) = T ⊕ Q(t) |
| Excitation: Q(t)=0 → Q(t+1)=0 | T = 0 |
| Excitation: Q(t)=0 → Q(t+1)=1 | T = 1 |
| Excitation: Q(t)=1 → Q(t+1)=0 | T = 1 |
| Excitation: Q(t)=1 → Q(t+1)=1 | T = 0 |
| Implementation from JK | Tie J = K = T (no extra gates) |
| Implementation from D | D = T ⊕ Q (requires 1× XOR gate) |
| Standard IC (JK used as T) | 74HC112 with J and K tied together |
| 4-bit ripple counter IC | 74HC93 / 74HC93A |
| 4-bit synchronous counter | 74HC163 (preferred, no ripple glitch) |
| Frequency division ratio | f_out = f_CLK / 2ⁿ for n cascaded stages |
Safety warnings
- Connect T (and therefore J and K) to a defined logic level — never leave inputs floating on CMOS ICs as this can cause excessive static current and device damage.
- At high clock frequencies, heat dissipation in CMOS counters can become significant; verify the IC's maximum operating frequency and avoid exceeding the rated VCC.
Tools needed
- 74HC112 dual JK flip-flop IC (J and K shorted to T) or 74HC93 ripple counter
- 555 astable circuit or function generator for clock
- Breadboard and jumper wires
- 5 V regulated power supply
- 4× LEDs and 4× 330 Ω resistors for counter output display
- circuitdiagrammaker.com for schematic simulation
Common mistakes
- Forgetting to tie J and K together when converting a JK IC to a T flip-flop, leaving one input floating and causing indeterminate behaviour.
- Using a ripple counter at high clock frequencies where the cumulative propagation delay causes glitch outputs on intermediate stages.
- Misreading the toggle output as a divide-by-1 instead of divide-by-2, miscalculating the output frequency in counter designs.
- Not accounting for the hold-time requirement when changing T synchronously near the clock edge, which can cause metastability.
- Confusing the T flip-flop excitation table with the D flip-flop excitation table when designing next-state logic for state machines.
Troubleshooting
- Counter outputs show glitches between valid count states
- Cause: Ripple counter propagation delay causes intermediate invalid states as carry ripples through multiple stages. Fix: Add output latches or replace the ripple counter with a synchronous counter IC like the 74HC163.
- Flip-flop does not toggle even with T=1 and clock applied
- Cause: J or K input is floating rather than both tied to T; or CLK signal is not reaching the IC. Fix: Verify J=K=T with a logic probe; check CLK continuity on the pin with a probe or oscilloscope.
- Counter counts only part way then freezes
- Cause: One stage's Q is not properly connected to the CLK input of the next stage, breaking the chain. Fix: Probe each inter-stage connection and verify the Q-to-CLK wire has continuity.
Frequently asked questions
What is a T flip flop circuit diagram?
It shows a JK flip-flop with J and K inputs shorted together as T, along with CLK, Q, and Q̄ connections, implementing a circuit that holds its output when T=0 and inverts it when T=1 on each clock edge.
What is the truth table for a T flip flop?
T=0 at clock edge → Q(t+1)=Q(t) (Hold); T=1 at clock edge → Q(t+1)=Q̄(t) (Toggle). There are no forbidden states.
What is the characteristic equation of a T flip flop?
Q(t+1) = T ⊕ Q(t), meaning the next state is the XOR of T and the current state. When T=1 the output always toggles; when T=0 it always holds.
How is a T flip flop made from a JK flip flop?
Simply connect J and K to the same T input. Since J=K=T, the JK truth table reduces to: T=0→Hold, T=1→Toggle, which is exactly the T flip-flop behaviour.
How is a T flip flop used in a binary counter?
With T permanently HIGH (T=1), the flip-flop divides the clock by 2. Chaining n flip-flops with each stage's Q feeding the next stage's clock creates a modulo-2ⁿ binary ripple counter.
What is the excitation table of a T flip flop?
Present→Next: 0→0 requires T=0; 0→1 requires T=1; 1→0 requires T=1; 1→1 requires T=0. The T value equals the XOR of the present and desired next state.
What is the difference between a ripple counter and a synchronous counter using T flip flops?
In a ripple counter, each flip-flop's Q clocks the next stage, so carry propagates sequentially causing glitches. In a synchronous counter, all flip-flops share one clock and the T inputs use combinational carry logic for simultaneous updates.