Difference Between FPGA and CPLD

CPLD (Complex Programmable Logic

Feature FPGA (Field Programmable Gate Array)
Device)

Low to medium (hundreds to a few High (hundreds of thousands to millions of

Logic Capacity
thousand gates) gates)

Coarse-grained, fixed interconnect, Fine-grained, flexible interconnect, logic blocks

Architecture
macrocells (LUTs, flip-flops)

Flexibility Less flexible, limited reconfigurability Highly flexible, extensive reconfigurability

Power
Low Higher, due to greater resources and complexity
Consumption

Higher, suited for complex and high-

Cost Lower, cost-effective for simple tasks
performance tasks

Instant-on (non-volatile memory, Requires configuration on power-up (volatile,

Startup Time
retains config) often SRAM-based)

Hardware Description Languages (VHDL,

Programming Logic equations, simple design tools
Verilog), advanced toolchains

Fast, predictable timing for simple Superior for parallel, high-speed, and complex
Performance
logic tasks

Control logic, glue logic, interface AI, DSP, high-speed networking, real-time
Best Use Cases
bridging processing

Abundant, includes dedicated RAM blocks and

Memory Limited, often uses EPROM/Flash
DSP units

Key Points of Differentiation

Logic Capacity & Complexity: FPGAs can implement much larger and more complex digital
systems than CPLDs, which are better for simpler, smaller logic functions [1] [2] [3] [4] .
Architecture: CPLDs use a fixed, coarse-grained structure with macrocells and a simple
interconnect, leading to predictable timing and fast operation for small designs. FPGAs use
a large array of small configurable logic blocks (CLBs) and a highly flexible routing structure,
allowing for very complex custom architectures [5] [2] [3] [6] .
Configuration & Power: CPLDs are non-volatile (retain configuration after power-off) and
start instantly, making them suitable for control and interface logic. FPGAs are typically
volatile (lose configuration when powered off) and require external memory to load their
configuration at startup [5] [7] [6] .
Programming & Design Entry: CPLDs are usually programmed with logic equations or
schematic entry, while FPGAs are programmed using hardware description languages (HDL)
 like VHDL or Verilog, providing greater design flexibility [2] [3] .
Application Suitability: CPLDs are ideal for glue logic, bus interfacing, and simple control
logic. FPGAs excel in applications requiring high-speed data processing, parallelism, and
complex computations, such as AI and signal processing [5] [1] [2] [3] .

Summary
CPLDs and FPGAs are both programmable logic devices but differ significantly in architecture,
capacity, flexibility, and application focus. CPLDs are best for simple, fast, and deterministic
logic tasks with low power and cost, while FPGAs are suited for complex, high-performance, and
highly configurable digital systems [5] [1] [2] [3] [6] .
⁂

Features of the Xilinx Spartan-2 Family FPGA

Logic Resources and Performance
Offers densities from 15,000 to 200,000 system gates, with up to 5,292 logic cells
depending on the device variant [8] [9] .
System clock rates supported up to approximately 200 MHz, enabling high-performance
digital designs [10] [9] .
Memory Architecture
Includes block RAM up to 56 Kbits and distributed RAM up to 75,264 bits, providing both
large and flexible on-chip memory options [8] [10] [9] .
Block RAM is organized in columns along the vertical edges of the chip, complementing the
distributed RAM within the CLBs [9] .
Configurable Logic Blocks (CLBs)
CLBs contain look-up tables (LUTs), flip-flops, and logic for implementing custom digital
functions [10] [9] .
Each LUT can function as a 4-input logic function, 16x1-bit synchronous RAM, or a 16-bit
shift register [9] .
Dedicated carry logic and fast carry chains support high-speed arithmetic operations and
efficient implementation of adders and multipliers [8] [9] .
Input/Output Capabilities
Supports up to 16 selectable I/O standards, making it versatile for interfacing with a wide
range of devices and systems [8] [10] [11] .
High maximum available user I/O pins (up to 284 in the largest device variant) [8] .
Clock Management
 Four Digital Delay Locked Loops (DLLs) provide advanced clock control and low-skew
global clock distribution for reliable timing across the device [8] [10] [11] .
Four primary low-skew global clock nets for distributing clock signals efficiently [11] .
Routing and Interconnect
Features a low-power, segmented routing architecture for predictable and fast interconnect,
ensuring successive design iterations meet timing requirements [11] [9] .
Programmable routing matrix and global routing resources distribute signals with high fanout
throughout the device [9] .
Additional Features
Fully PCI compliant, suitable for high-speed bus interfacing [12] [11] .
Unlimited reprogrammability, allowing in-field upgrades and rapid prototyping without
hardware replacement [12] [11] [9] .
Full readback capability for verification and observability [12] [11] .
IEEE 1149.1 compatible boundary scan logic for testing and debugging [12] [11] .
Supported by the Xilinx ISE development system for automated mapping, placement, and
routing [8] .
Designed for low cost and high volume applications, making it a cost-effective alternative to
ASICs [12] [9] .
Summary Table

Feature Spartan-2 Family Specification

System Gates 15,000 – 200,000

Logic Cells Up to 5,292

Block RAM Up to 56 Kbits

Distributed RAM Up to 75,264 bits

I/O Standards 16 selectable

DLLs (Clock Management) 4

Maximum User I/O Pins Up to 284

System Clock Rate Up to 200 MHz

Reprogrammability Unlimited

PCI Compliance Yes

Boundary Scan IEEE 1149.1

The Xilinx Spartan-2 family is recognized for its balance of performance, flexibility, and low cost,
making it suitable for a wide range of digital logic applications, from simple interfacing to
complex embedded systems [12] [11] [9] .
⁂
Fault Models Explained with Examples
Fault models are simplified representations of how faults (defects) in digital circuits affect circuit
behavior. They are essential for designing test strategies and evaluating the reliability of digital
systems. Here are some common fault models with examples:

1. Stuck-at Fault Model

Definition: Assumes a signal line or node in a circuit is permanently stuck at logic '0' (stuck-
at-0) or logic '1' (stuck-at-1), regardless of the intended value.
Example: If a wire supposed to carry a changing signal is stuck-at-0, it will always output
'0', causing incorrect circuit operation [13] [14] [15] .
Significance: Most widely used model in digital testing due to its simplicity and coverage of
many manufacturing defects.

2. Bridging Fault Model

Definition: Occurs when two normally separate signal lines are accidentally connected
(shorted), causing their signals to interfere.
Example: If line A and line B are bridged, the resulting signal may behave as A AND B or A
OR B, depending on the circuit, leading to erroneous outputs [13] [16] [15] .

3. Transistor Stuck-On/Stuck-Off Fault Model

Definition: Models faults at the transistor level where a transistor is always conducting
(stuck-on) or never conducting (stuck-off).
Example: In a CMOS gate, if the pull-down NMOS transistor is stuck-on, the output may
never reach logic '1' properly, causing logic errors [13] [14] .

4. Delay Fault Model

Definition: Represents faults that cause a signal transition to be slower than expected,
potentially leading to timing violations.
Types:
Gate Delay Fault: A specific gate transitions too slowly.
Path Delay Fault: A signal takes too long to propagate along a path.
Example: If a signal transition is delayed, a flip-flop may capture the wrong value at the
clock edge, causing functional errors in high-speed circuits [17] [16] .
5. Single Event Upset (SEU) / Bit-Flip Fault Model
Definition: A transient fault where a memory bit or flip-flop changes state unexpectedly,
often due to radiation or electrical noise.
Example: A memory cell intended to store '1' flips to '0' due to a cosmic ray, potentially
corrupting data or logic state [14] [18] .

6. Functional Fault Model

Definition: Represents faults that cause a circuit block to deviate from its intended function,
not necessarily tied to a specific physical defect.
Example: An arithmetic logic unit (ALU) that always outputs zero, regardless of inputs, due
to internal logic failure [13] [16] .

Summary Table
Fault Model Description Example Scenario

Stuck-at Fault Line stuck at '0' or '1' Output always '0' despite input changes

Bridging Fault Two lines shorted together Output behaves as A AND B or A OR B

Transistor Stuck-
Transistor always on or off Output cannot reach expected logic level
On/Off

Wrong value latched due to slow

Delay Fault Signal transition delayed
transition

Memory bit flips due to transient

Bit-Flip (SEU) Stored '1' becomes '0' after cosmic ray hit
event

Functional Fault Block deviates from intended function ALU always outputs zero

These models help engineers simulate, detect, and mitigate faults in digital systems, ensuring
higher reliability and robustness [13] [14] [16] [15] .
⁂

Design for Testability (DFT) and Its Implementation

Design for Testability (DFT) refers to a set of design techniques aimed at making hardware
products-especially integrated circuits (ICs)-easier and more cost-effective to test for
manufacturing defects and in-field faults [19] [20] [21] . The primary goal is to ensure that faults can
be detected, diagnosed, and corrected efficiently, thereby improving product quality, reducing
test time, and lowering overall costs [22] [21] [23] .
Key Features of DFT
Enhanced Controllability and Observability: DFT techniques improve the ability to control
and observe the internal states of a circuit, making it easier to apply tests and interpret
results [24] .
Facilitates Fault Detection: By embedding test features, DFT ensures that faults, even
those deep inside complex chips, can be detected reliably [22] [25] .
Reduces Test Time and Cost: DFT reduces the complexity and duration of test
development and execution, leading to cost savings [22] [21] .
Improves Product Quality: Early and effective fault detection leads to higher yield and
more reliable products [23] .

DFT Implementation Techniques

DFT methods are generally divided into two categories: ad hoc techniques and structured
techniques [26] [24] .

Ad Hoc Techniques
Partitioning: Divide large circuits into smaller, manageable blocks to simplify testing.
Test Point Insertion: Add control and observation points to improve access to internal
signals.
Design Guidelines: Avoid asynchronous logic, redundant logic, and combinational
feedback; use synchronous resets and good design practices [26] [24] .

Structured Techniques
Scan Path/Scan Chains: Insert additional logic so that flip-flops can be connected in a
chain, allowing test data to be shifted in and out for easy observation and control of internal
states [21] [26] [24] .
Partial Scan: Only a subset of flip-flops are included in scan chains to balance area
overhead and test coverage.
Built-In Self-Test (BIST): Incorporate hardware that enables the circuit to test itself, often
using pattern generators and response analyzers [21] [26] .
Boundary Scan (IEEE 1149.1/JTAG): Add logic around the periphery of the chip to test
interconnections and facilitate board-level testing [21] [26] .
Test Point Insertion (TPI): Systematically add logic to enhance controllability and
observability of hard-to-test nodes [24] .
Best Practices for DFT Implementation
Integrate DFT Early: Incorporate DFT features during the design phase, not as an
afterthought [23] .
Hierarchical DFT: Apply DFT at the module level and integrate at the top level for complex
designs [23] .
Optimize Scan Chains: Structure scan chains logically to minimize area and test time
overhead [23] .
Use Automated Tools: Employ industry-standard EDA tools for DFT insertion and
validation [23] .
Fault Simulation and Coverage Analysis: Use simulation to verify test effectiveness before
manufacturing [23] .

Conclusion
DFT is an essential aspect of modern VLSI and digital system design, ensuring that products are
testable, reliable, and cost-effective to manufacture. By using both ad hoc and structured
techniques, designers can significantly improve the ease and efficiency of testing, leading to
higher-quality electronic products [19] [20] [21] [23] .
⁂

Boundary Scan Test for Board Testing

Boundary scan, standardized as IEEE 1149.1 and commonly known as JTAG, is a technique used
to test interconnects (wiring) on printed circuit boards (PCBs) and inside integrated circuits (ICs)
without requiring physical test probes [27] [28] [29] . It is especially valuable for testing modern,
densely packed boards where traditional test access is limited.

Key Components and Architecture

Boundary Scan Cells: Each I/O pin of a boundary scan-capable device has a boundary
scan cell, forming a shift register (the boundary scan register) around the functional
logic [30] [29] .
Test Access Port (TAP): Consists of four main signals-Test Clock (TCK), Test Mode Select
(TMS), Test Data In (TDI), and Test Data Out (TDO)-plus an optional Test Reset (/TRST) [27]
[30] . These provide a standard interface for test operations.

TAP Controller: A state machine that controls the operation of the boundary scan logic,
determining when data is shifted in/out, captured, or updated [27] [31] .
Instruction Register: Selects the mode of operation (e.g., BYPASS, SAMPLE/PRELOAD,
EXTEST) [27] [31] .
Boundary Scan Register: A chain of boundary scan cells that allows serial access to all I/O
pins for testing purposes [27] [30] .
How Boundary Scan Works
1. Scan Chain Formation: Devices with boundary scan are connected in series via their TDI
and TDO pins, forming a scan chain that can be accessed from an edge connector on the
board [30] .
2. Test Data Loading: Test patterns (stimulus) are shifted into the boundary scan registers of
the devices through the scan chain [30] .
3. Test Execution: The loaded test data is applied to the device pins, stimulating the
interconnects between devices on the PCB [30] .
4. Response Capture: The response from the interconnects is captured by the input boundary
scan cells and shifted out for analysis [30] .
5. Instruction Control: The TAP controller and instruction register manage which operation is
performed (e.g., EXTEST for interconnect testing, SAMPLE/PRELOAD for capturing normal
operation data) [27] [31] .

Typical Boundary Scan Instructions

EXTEST: Used to test interconnects between devices by driving test data onto output pins
and capturing responses at input pins [27] [31] .
SAMPLE/PRELOAD: Allows sampling of normal operational data or preloading test data into
the boundary scan register [27] [31] .
BYPASS: Bypasses a device in the scan chain to speed up testing of other devices [27] [31] .

Advantages of Boundary Scan

No Physical Probing Required: Enables testing of dense boards where physical access is
limited [29] .
Standardized Interface: Only four or five signals required for any number of devices in the
chain [27] [30] .
Supports Debugging and In-System Programming: Can be used for debugging,
programming, and observing internal states [29] .

Summary Table
Component Function

Boundary Scan Cell Controls and observes I/O pins, forms scan register

TAP (TCK, TMS, TDI, TDO) Standard interface for test operations

TAP Controller Manages test logic states and data flow

Instruction Register Selects test operation mode

 Component Function

Boundary Scan Register Serial path for shifting test data in/out

Boundary scan/JTAG is now a fundamental method for board-level test and debugging, enabling
efficient detection and diagnosis of faults in complex electronic assemblies [27] [28] [29] .
⁂

Built-in Self-Test (BIST) Techniques

Built-in Self-Test (BIST) is a design-for-testability technique where testing functions are
integrated directly into the hardware, enabling a circuit to test itself without external test
equipment. BIST is widely used in VLSI and embedded systems to improve test coverage,
reduce test costs, and facilitate in-field diagnostics.

Key Components of BIST

1. Test Pattern Generator (TPG)
Generates test patterns to stimulate the Circuit Under Test (CUT).
Commonly implemented using a Linear Feedback Shift Register (LFSR) for pseudo-
random pattern generation [32] [33] [34] .
2. Response Analyzer (RA)
Analyzes the output responses from the CUT.
Often implemented as a Multiple Input Signature Register (MISR) or a signature
analyzer, which compresses the output into a compact signature for comparison with a
known good value [33] [34] .
3. BIST Controller
Controls the operation of the test process, including the activation and sequencing of
test patterns and response analysis [35] [34] .

General BIST Architecture Diagram

Below is a simplified diagram of a typical BIST architecture:

+---------------------+
| BIST Controller |
+---------------------+
|
v
+---------------------+ +---------------------+
| Test Pattern | | Output Response |
| Generator (LFSR) +-------> | Analyzer (MISR) |
+---------------------+ +---------------------+
| ^
 v |
+---------------------+ +---------------------+
| Circuit Under Test |-------->| Output from CUT |
| (CUT) | +---------------------+
+---------------------+

How BIST Works

1. Test Pattern Generation: The TPG (often an LFSR) generates a sequence of test patterns,
which are applied to the inputs of the CUT [32] [33] [34] .
2. Response Collection: The outputs of the CUT are captured and compressed by the
Response Analyzer (typically a MISR), resulting in a signature [33] [34] .
3. Signature Comparison: The final signature is compared with a reference (known good)
signature. A match indicates the circuit is fault-free, while a mismatch suggests a defect [33]
[35] [34] .

Types of BIST
Logic BIST (LBIST): Focuses on testing the logic circuits using pseudo-random patterns and
signature analysis [36] [34] .
Memory BIST (MBIST): Specifically targets memory blocks, generating patterns and
checking responses to identify faults in memory cells. MBIST may also include redundancy
management for faulty memory elements [36] .

Advantages of BIST
Enables self-testing without external equipment.
Increases test coverage, especially for hard-to-access internal nodes.
Reduces test time and cost.
Supports in-field and at-speed testing.

Example
Suppose a digital IC integrates a BIST engine:
The LFSR generates pseudo-random test vectors.
These vectors are applied to the logic under test.
The MISR collects and compresses the output responses.
At the end of the test, the MISR's signature is compared to a reference signature. If they
match, the circuit passes the test; otherwise, a fault is detected [33] [34] .
In summary:
BIST techniques embed test pattern generation, output response analysis, and control logic
within the circuit, allowing for autonomous, efficient, and thorough testing of digital systems [32]
[33] [34] .

Path Sensitizing in Testing

Path sensitizing is a fault detection technique used in digital circuit testing to determine
whether a specific fault (such as a stuck-at fault) can be observed at a circuit output. The
method involves activating a particular path from the fault site to a primary output, ensuring the
fault effect is propagated and observable.

Steps in Path Sensitization

1. Fault Sensitization (Excitation)
Apply input values to activate the fault, i.e., set the faulty node to the opposite value of
the fault. For example, for a stuck-at-0 fault, apply a logic '1' to the node [37] [38] .
2. Fault Propagation
Choose a path from the fault site to a primary output and assign values to intermediate
signals so the fault effect can travel along this path to the output [37] [38] .
3. Line Justification
Assign values to the remaining inputs so that all conditions required for fault excitation
and propagation are met, ensuring no conflicts arise [38] .

Example
Suppose a line in a digital circuit is stuck-at-0 (s-a-0):
Step 1: Apply a '1' to the faulty line (excitation).
Step 2: Set the values of logic gates along a path from this line to the output so the '1' can
propagate to the output (propagation).
Step 3: Assign values to other inputs so that the chosen path is active and no other paths
override the output (justification) [37] [38] .
If the output differs from the expected value in a fault-free circuit, the fault is detected.
Applications and Limitations
Path sensitization is widely used for detecting stuck-at, transition, and bridging faults [37] .
The method is powerful for diagnosing faults but may not always find a test for every fault,
especially in complex circuits, since only one path is sensitized at a time [39] [38] .

Summary Table
Step Description

Fault Sensitization Activate the fault by applying the opposite logic value

Fault Propagation Select and activate a path to propagate the fault effect to the output

Line Justification Assign remaining inputs to maintain propagation and avoid conflicts

Path sensitizing helps focus testing on specific circuit paths, making fault detection more
systematic and effective in digital systems [37] [38] .
⁂

VHDL Code for an 8-Input, 8-Output Tri-State Buffer

An 8-input, 8-output tri-state buffer allows each input bit to be transferred to its corresponding
output when enabled; otherwise, the output is set to high impedance ('Z'). This is commonly
used for bus interfacing and shared lines.
Below is a concise VHDL implementation for such a buffer, using a single enable signal for all bits
(active high):

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;

entity tri_state_buffer_8x8 is
Port (
data_in : in STD_LOGIC_VECTOR(7 downto 0);
enable : in STD_LOGIC;
data_out : out STD_LOGIC_VECTOR(7 downto 0)
);
end tri_state_buffer_8x8;

architecture Behavioral of tri_state_buffer_8x8 is

begin
data_out <= data_in when (enable = '1') else (others => 'Z');
end Behavioral;

When enable is '1', each bit of data_in appears on data_out.

When enable is '0', all outputs are set to high impedance ('Z'), effectively disconnecting the
buffer from the bus [40] [41] [42] .
If you need individual enables for each bit, you can use a generate statement or a process to
assign each bit accordingly [43] .

References to syntax and behavior:

1. https://www.tutorialspoint.com/difference-between-cpld-and-fpga
2. https://www.logic-fruit.com/blog/fpga/fpga-vs-cpld/
3. https://www.raypcb.com/difference-between-fpga-and-cpld/
4. https://www.scribd.com/document/727124681/Session-09-10-cpld-Fpga
5. https://www.microchipusa.com/industry-news/semiconductor-industry/cplds-vs-fpgas-understanding-t
he-differences-and-choosing-the-right-solution/
6. https://www.slideshare.net/slideshow/fpga-and-cpld-comparision/251960760
7. https://www.edaboard.com/threads/whats-the-main-difference-between-fpga-cpld.1899/
8. https://www.mouser.com/datasheet/2/903/ds001-1595278.pdf
9. https://hillmancurtis.com/xilinx-spartan-ii-fpga/
10. https://www.slideshare.net/slideshow/fpga-xc2s30/40236534
11. https://docs.rs-online.com/9cb8/0900766b801d6952.pdf
12. https://pccomponents.com/datasheets/XILIN-XC2S305VQ100I.pdf
13. https://chipedge.com/5-common-fault-models-in-vlsi/
14. http://lrc.acharyainstitutes.in:8080/jspui/bitstream/123456789/989/1/Fault Tolerant Techniques for
FPGAs_ A Review.pdf
15. https://www.slideshare.net/slideshow/fa-31428491/31428491
16. https://www.scribd.com/document/178439300/Fault-Modeling
17. https://www.sciencedirect.com/topics/engineering/fault-model
18. https://www.ijetch.org/papers/424-C049.pdf
19. https://www.melecs.com/en/design-for-testability
20. https://en.wikipedia.org/wiki/Design_for_testing
21. https://www.maven-silicon.com/blog/what-is-dft-in-vlsi-design/
22. https://chipedge.com/what-is-design-for-testability-and-why-is-it-important/
23. https://www.successbridge.co.in/dft-design-for-testability-in-vlsi-importance-techniques-and-best-pr
actices/
24. https://www.scribd.com/document/610735110/Design-for-Testability-notes
25. https://www.maven-silicon.com/blog/what-is-dft-in-vlsi/
26. https://www.rcet.org.in/uploads/academics/rohini_56020698437.pdf
27. https://www.goepel.com/en/embedded-jtag-solutions/support/ieee-1149-1
28. https://www.corelis.com/education/tutorials/boundary-scan/
29. https://en.wikipedia.org/wiki/Boundary_scan
30. https://fiona.dmcs.pl/~rkielbik/nid/IEEE_1149_JTAG_and_Boundary_Scan_Tutorial.pdf
31. https://www.xjtag.com/about-jtag/jtag-a-technical-overview/
32. https://www.rcet.org.in/uploads/academics/rohini_23766822143.pdf
33. https://www.slideshare.net/slideshow/bistpdf/257993048
34. https://vlsitutorials.com/logic-built-in-self-test-lbist/
35. https://www.kdkce.edu.in/pdf/RBK_8ETRX_CMOS_U6_Built in self test.pdf
36. https://semiengineering.com/knowledge_centers/test/built-in-self-test-bist/
37. https://www.youtube.com/watch?v=YvpUd1qeghQ
38. https://archive.nptel.ac.in/content/storage2/courses/106103116/handout/mod9.pdf
39. https://www.scribd.com/document/408376358/Path-Sensitization-1
40. https://startingelectronics.org/software/VHDL-CPLD-course/tut16-tri-state-buffer/
41. https://www.intel.com/content/www/us/en/support/programmable/support-resources/design-examples/
horizontal/v-prebus.html
42. https://www.edaboard.com/threads/vhdl-tristate-buffers.241464/
43. https://electronics.stackexchange.com/questions/178874/how-do-i-implement-a-tri-state-buffer-for-a-
vector-in-vhdl