Excitation tables and flip-flop conversion

Why it exists

The four flip-flop types (SR, D, JK, T) are interchangeable in function but not in the logic they need around them. A counter is simplest with T flip-flops, a register with D flip-flops, a general state machine is easy to derive with JK. Parts are sold in a few types, so a designer often has one type and needs another. The same table, the excitation table, is also the heart of the design procedure for counters and state machines on the following pages. GATE asks for the excitation table entries, which inputs convert one flip-flop to another, and how many gates a conversion needs.

Prerequisites

You need the characteristic tables and equations of the four types from latches and flip-flops, and don't care minimisation from Karnaugh maps.

Precise definitions

Characteristic equations (the next state $Q^+$ from the present state $Q$ and the inputs).

Excitation table. The reverse question: given the present state $Q$ and the required next state $Q^+$, which inputs achieve it? An X means the input can be 0 or 1 (a don't care).

Why the X entries appear: to stay at 0 a JK flip-flop may have $J K = 00$ (hold) or $01$ (reset), so $K$ is free; to go from 0 to 1 it may have $JK = 10$ (set) or $11$ (toggle), so $K$ is free; and symmetrically for $J$ when starting from 1.

Conversion procedure. To build a flip-flop of wanted type from one of the available type:

1. Write a table with the wanted flip-flop's inputs and the present state $Q$, and fill in the required next state $Q^+$ from the wanted characteristic equation.
2. For each row, read the available flip-flop's required inputs from its excitation table (using the transition $Q \to Q^+$).
3. Treat the X entries (and any input combination that is illegal for the wanted type, such as $S = R = 1$) as don't cares and minimise each available input as a function of the wanted inputs and $Q$ with a Karnaugh map.
4. Draw the logic that makes those inputs from the wanted inputs and the flip-flop's own $Q$ and $Q'$.

The twelve conversions (each derived by the procedure and checked on every state and legal input):

Two patterns to remember: a JK flip-flop needs no extra gates to act as T (tie the inputs together), and a T or D flip-flop converts to any other type with the characteristic equation of the wanted type: $D = Q^+$ of the wanted flip-flop, and $T = Q \oplus Q^+$.

How it works

Convert an SR flip-flop into a JK flip-flop. Follow the table for the wanted JK ($Q^+ = JQ' + K'Q$) and read $S$ and $R$ from the SR excitation table:

The two K-maps below minimise $S$ and $R$ using the X entries as don't cares.

The result is $S = JQ'$ and $R = KQ$: set the SR flip-flop only when $J = 1$ and the flip-flop is 0, and reset it only when $K = 1$ and it is 1. Feeding $Q$ and $Q'$ back like this is what prevents $S = R = 1$ ever happening.

Worked examples

#include <stdio.h>
 
enum { SR, JK, D, T };
static const char *name[] = { "SR", "JK", "D", "T" };
 
static int next_state(int type, int q, int a, int b) {
    switch (type) {
    case SR: return a || (!b && q);
    case JK: return (a && !q) || (!b && q);
    case D: return a;
    default: return a ^ q;
    }
}
 
/* the two inputs (a, b) of the available flip-flop, as functions of the desired flip-flop's inputs (x, y) and Q */
static void conv(int avail, int want, int x, int y, int q, int *a, int *b) {
    *b = 0;
    if (avail == JK && want == T) { *a = x; *b = x; }
    else if (avail == JK && want == D) { *a = x; *b = !x; }
    else if (avail == JK && want == SR) { *a = x; *b = y; }
    else if (avail == D && want == T) *a = x ^ q;
    else if (avail == D && want == JK) *a = (x && !q) || (!y && q);
    else if (avail == D && want == SR) *a = x || (!y && q);
    else if (avail == T && want == D) *a = x ^ q;
    else if (avail == T && want == JK) *a = (x && !q) || (y && q);
    else if (avail == T && want == SR) *a = (x && !q) || (y && q);
    else if (avail == SR && want == D) { *a = x; *b = !x; }
    else if (avail == SR && want == JK) { *a = x && !q; *b = y && q; }
    else if (avail == SR && want == T) { *a = x && !q; *b = x && q; }
    else *a = 0;
}
 
int main(void) {
    int total = 0, pairs = 0;
    for (int avail = 0; avail < 4; avail++)
        for (int want = 0; want < 4; want++) {
            if (avail == want) continue;
            int bad = 0;
            for (int x = 0; x < 2; x++)
                for (int y = 0; y < 2; y++)
                    for (int q = 0; q < 2; q++) {
                        if (want == SR && x && y) continue;
                        if ((want == D || want == T) && y) continue;
                        int a, b;
                        conv(avail, want, x, y, q, &a, &b);
                        bad += next_state(avail, q, a, b) != next_state(want, q, x, y);
                    }
            pairs++;
            total += bad;
            if (bad) printf("%s as %s: %d wrong\n", name[avail], name[want], bad);
        }
    printf("%d conversions checked, %d wrong rows\n", pairs, total);
    int q = 0;
    printf("T built from D (D = T xor Q), T = 1 five times:");
    for (int i = 0; i < 5; i++) {
        int a, b;
        conv(D, T, 1, 0, q, &a, &b);
        q = next_state(D, q, a, b);
        printf(" %d", q);
    }
    printf("\n");
    return 0;
}

12 conversions checked, 0 wrong rows
T built from D (D = T xor Q), T = 1 five times: 1 0 1 0 1

Cheat box

Traps and GATE patterns

Connections

The excitation table is the central tool when designing counters and state machines: the flip-flop input equations are exactly the excitation of the required state transitions. Registers use the D flip-flop because its excitation is trivial, see registers and shift registers. The simplification step is the K-map with don't cares.

PYQs

Consider a 3-bit counter, designed using T flip-flops,
as shown below :

Assuming the initial state of the counter given by
PQR as 000, what are the next three states?

Self-check

Revision card

References