Designing with ROM and PLA

Definition

Designing with ROM and PLA is the method of implementing digital logic functions, including the combinational logic inside sequential circuits, using programmable memory-based devices where the desired Boolean expressions are realized by programming connections or storing truth-table values.

ROM

implements logic by storing a complete truth table: inputs are applied as addresses, and outputs are read from memory locations.

PLA

implements logic by programming both the AND plane and the OR plane, allowing optimized realization of sum-of-products expressions.

These devices are widely used in finite state machines, controllers, code converters, instruction decoding, and other digital systems where flexibility, regular structure, and ease of design are important.

Main Content

1. ROM-Based Logic Design

Structure and principle

: A ROM consists of a decoder, memory cells, and output lines. If there are n input variables, the ROM has 2^n possible addresses. Each address corresponds to one input combination, and the stored output bits represent the logic function values. In this way, any combinational function can be implemented by storing its truth table directly in ROM.

For example, if a circuit has 3 inputs and 2 outputs, a ROM with 3 address lines and 2 data output lines can store all 8 input combinations. This makes ROM especially suitable for implementing logic where the full truth table is available.

Use in sequential logic

: In sequential systems, ROM is often used to implement the next-state table and output table of a finite state machine (FSM). The present state bits and input bits together form the address, and the ROM outputs contain the next state and output values. This makes state machine design very systematic.

Example:
If a Moore machine has 2 present-state bits and 1 input bit, then 3 address lines are needed. The ROM stores the next state for each address. This removes the need to manually simplify state equations using gates.

Example idea of ROM usage in FSM design

Present State	Input	Next State	Output
00	0	01	0
00	1	10	1
01	0	01	0
01	1	11	1

The table above can be directly stored in ROM, where the address is formed by present-state bits and input bits.

2. PLA-Based Logic Design

Structure and principle

: A PLA contains a programmable AND array followed by a programmable OR array. Input variables and their complements are fed into the AND plane, where product terms are generated. These product terms are then selected and combined in the OR plane to form output expressions.

Unlike ROM, PLA does not store every possible minterm. Instead, it generates only the required product terms, which can make it more efficient when the logic expressions are not fully dense.

Use in minimizing logic

: PLA is highly useful when logic functions can be simplified into sum-of-products (SOP) form. Common product terms can be shared among multiple outputs, reducing hardware use.

Example:
Suppose:

F1 = AB + AC
F2 = AB + A'C

The product term AB is shared, so it can be generated once in the AND plane and used in both outputs. This sharing reduces the number of gates and interconnections.

Why PLA is important in sequential logic
In FSMs, the next-state and output equations are often derived in SOP form. PLA can implement these equations efficiently, especially when the number of distinct product terms is smaller than the number of minterms in a ROM-based design.

3. ROM vs PLA in Sequential Circuit Implementation

ROM characteristics

: ROM is simpler to use because it directly implements the truth table. It is easier to design, debug, and modify. However, it may waste memory because it stores outputs for all input combinations, including unused states or don’t-care conditions. For systems with many input variables, the memory size grows rapidly because ROM size increases exponentially with the number of address lines.

PLA characteristics

: PLA is more flexible in logic optimization because it uses only the needed product terms. It is usually smaller and more efficient than ROM when many logic terms can be shared. However, PLA design requires logic minimization and careful selection of product terms, so it can be more design-intensive than ROM.

Comparison example

If a sequential circuit has:

6 input/address lines for ROM, then the ROM needs 2^6 = 64 rows.
But if the same function can be expressed using 10 shared product terms, a PLA may require only those 10 terms rather than all 64 minterms.

This makes PLA preferable for optimized designs, while ROM is preferable for straightforward implementation.

Typical choice guidelines

Use ROM when the truth table is easy to define and design simplicity is important.
Use PLA when the logic can be minimized and shared product terms can reduce hardware.
In controllers and FSMs, both are common depending on speed, size, and design constraints.

Working / Process

1. Formulate the logic or state table

Start by writing the truth table or state transition table. For sequential circuits, include present state, input conditions, next state, and outputs. Identify the number of input bits and state bits needed.

2. Choose ROM or PLA and derive implementation form

For ROM: combine state bits and inputs to form address lines, then store next-state/output values in the memory table.
For PLA: minimize the next-state and output equations into SOP form, identify common product terms, and assign them to the programmable AND and OR planes.

3. Program the device and verify output

Load the ROM contents or program the PLA connections according to the derived table/equations. Then test the circuit for all possible input combinations, including unused or don’t-care states, to verify correct sequential behavior.

Simple ASCII visual for ROM-based FSM implementation

Present State + Inputs ---> Address Lines ---> ROM ---> Next State + Outputs
      Q1 Q0 + X1 X0                            [stored table]

Simple ASCII visual for PLA-based logic implementation

Inputs and complements ---> Programmable AND Plane ---> Product terms ---> Programmable OR Plane ---> Outputs

Advantages / Applications

Simplifies design of complex logic

: ROM and PLA reduce the need to build large circuits from many individual gates, making the design process more systematic and less error-prone.

Highly useful in sequential circuits

: They are ideal for implementing state machines, counters, controllers, sequence detectors, and output logic because the behavior can be directly mapped from tables or equations.

Easy to modify and optimize

: ROM designs can be changed by reprogramming contents, and PLA designs can be optimized by reducing common terms. This makes both devices practical for prototyping and educational design.

Common applications

Finite State Machines (Moore and Mealy machines)
Control units in processors and microprogrammed systems
Code converters and arithmetic logic blocks
Sequence detectors
Display drivers and decision logic
Embedded control and automation circuits

Summary

ROM designs logic by storing complete truth tables, making it simple and direct for sequential circuit implementation.
PLA designs logic using programmable AND and OR planes, making it more efficient when minimized SOP expressions are available.
Both are important tools in sequential logic for building FSMs, controllers, and other digital systems in a structured way.
Important terms to remember: ROM, PLA, truth table, sum-of-products, programmable AND plane, programmable OR plane, next-state logic, output logic, finite state machine.