Stuck-At Faults

Chapter 2 · Section 2.2 · Fault Models

Project thread — 2.1 built the fault list; here we put SA0/SA1 on the counter's nodes and generate the excite + propagate pattern that detects one.

1. Why Should I Learn This?

Stuck-at is the default vocabulary of manufacturing test — and excite + propagate is the reasoning behind every ATPG pattern.

• SA0 / SA1 — a node frozen to a constant, 2 faults per node.
• Detection = excite (drive the opposite value) and propagate (sensitize an observable path) — both, same pattern.
• A pattern detects iff good machine ≠ faulty machine at an observable point.
• High stuck-at coverage (~95–99%+, representative) is the first signoff bar.

2. Real Silicon Story — the fault you could excite but not propagate

A team saw a node's SA0 fault reported undetected, and assumed the ATPG tool was weak. Digging in, they found the pattern could excite the node to 1 — but every path from that node to an observable output was blocked by side-inputs held at non-controlling values. The fault was excited but not propagated: the good and faulty machines produced the same value at every observable point, so no pattern could distinguish them.

The node was buried behind logic whose observability was poor — a design/testability issue, not a tool weakness. Once scan (Chapter 3) added an observable capture point closer to the node, the same fault became easily detected. Lesson: detection needs both excite and propagate — a fault you can excite but not observe is undetected, and the fix is usually observability, bought with scan.

3. Factory Perspective — how each role reads a stuck-at fault

• What the test engineer sees: the stuck-at fault list and the patterns that detect each fault by excite + propagate; their metric is stuck-at coverage at acceptable test time.
• What the yield engineer sees: when parts fail specific stuck-at patterns, a diagnosis pointing at which node/region is defective — feeding physical failure analysis.
• What the RTL/DV engineer sees: that undetected stuck-at faults usually mean poor controllability/observability in their logic — a design signal to add scan/observe points (Chapters 4/6).
• What management cares about: stuck-at coverage is the headline signoff number in the quality plan — the first commitment tied to DPPM (1.5).

4. Concept — SA0/SA1, excite + propagate, collapsing

The model:

• Every node (gate input, gate output, net) may be stuck-at-0 or stuck-at-1 — held constant independent of the driving logic.
• Two faults per node. A netlist with N nodes has ~2N stuck-at faults before collapsing.

Detection = excite AND propagate (both, in one pattern):

• Excite (activate): set inputs so the faulty node should take the opposite value of the fault. For SA0, drive the node to 1 — now good = 1, faulty = 0: a difference exists at the node.
• Propagate (sensitize): hold the side-inputs along a path from the node to an observable output at their non-controlling values, so the difference travels to where you can measure it (a primary output or a scan flop).
• Detected iff good machine and faulty machine differ at an observable point. Excite without propagate → undetected (the story).

Fault collapsing — shrink the list, not the coverage:

• Equivalent faults produce identical behavior at outputs — e.g. any input SA0 of an AND gate is equivalent to the output SA0 (both force the output to 0). Keep one representative.
• Dominance: if every pattern detecting fault A also detects fault B, A dominates B; the list can drop the dominated one.
• Collapsing yields the collapsed fault list → fewer patterns for the same coverage (helps test time, 1.4).

Fault coverage vs test coverage (light — full in Ch6):

• Fault coverage = detected / (collapsed) faults.
• Test coverage additionally accounts for faults proven undetectable/untestable (2.5) — usually the higher, more honest signoff number.

The difference must reach an observable point over time — a waveform makes 'good vs faulty' concrete:

5. Mental Model — a stuck light switch you must prove is stuck

Imagine checking whether a light switch is jammed OFF (a node stuck-at-0).

• Excite: you must flip it to ON — if you never try to turn it on, a jammed-off switch looks identical to one you simply left off. You have to demand the opposite of the fault.
• Propagate: you must be able to see the light it controls — if the bulb is removed (unobservable) or another switch also forces it off (a controlling side-input masks it), flipping the switch tells you nothing.
• Detect: only when flipping the switch should change the light but doesn't do you know it's jammed — that's good ≠ faulty at something you can observe.

You can't detect a jam by staring at an off switch; you must command ON and watch a wired-up bulb. That's excite + propagate.

6. Working Example — a stuck-at pattern on the counter

Enumerate and detect a stuck-at fault on the project's counter:

// SystemVerilog — the counter under test (project thread); nodes carry stuck-at faults
module counter4 (input logic clk, rst_n, output logic [3:0] count);
  always_ff @(posedge clk)
    if (!rst_n) count <= 4'd0;
    else        count <= count + 4'd1;
endmodule

# Stuck-at detection — REPRESENTATIVE, SIMPLIFIED, tool-neutral:
# Target fault: count[0]  STUCK-AT-1
#   EXCITE   : force count[0] to 0  (e.g. reset -> count = 0000, so count[0] should be 0)
#   PROPAGATE: make count[0] OBSERVABLE (a primary output here, or a scan flop after Ch3)
#   GOOD machine  : count[0] = 0
#   FAULTY machine: count[0] = 1  (stuck-at-1)
#   OBSERVE  : count[0] reads 1 instead of 0  -> good != faulty -> DETECTED
#
# Target fault: rst_n STUCK-AT-1  (reset never asserts)
#   EXCITE   : assert reset (drive rst_n=0); good -> count clears to 0000
#   FAULTY   : rst_n stuck-at-1 -> reset ignored -> count keeps counting (not 0000)
#   OBSERVE  : count != 0000 after reset -> DETECTED

# Fault collapsing — REPRESENTATIVE:
#   AND gate y = a & b :  a-SA0  ==  b-SA0  ==  y-SA0   (all force y=0)  -> keep ONE representative
#   Collapsing shrinks the list (fewer patterns, SAME coverage) -> helps test time (1.4).

7. Industry Flow — where stuck-at sits

Stuck-at is the first structural test built on the scan-inserted netlist:

8. Debugging Session — a fault reported undetected

9. Common Mistakes

• Thinking exciting a fault detects it. You also need to propagate it to an observable point — both, one pattern.
• Blaming ATPG for undetected faults. Usually a controllability/observability (design) limit — fix with scan.
• Forgetting side-inputs mask faults. A controlling value on a path blocks propagation.
• Confusing fault collapsing with losing coverage. Collapsing removes equivalent faults — coverage is unchanged.
• Treating 100% stuck-at as fully tested. It misses timing/bridging defects (2.3/2.4) — stuck-at is a proxy.

10. Industry Best Practices

• Target excite + propagate explicitly — undetected faults almost always fail on propagation (observability).
• Collapse faults to cut pattern count and test time (1.4) without touching coverage.
• Treat undetected stuck-at as a testability signal — feed back to scan/observe decisions (Ch4/6).
• Report fault and test coverage — distinguish detected from proven-undetectable (2.5, Ch6).
• Set a stuck-at signoff bar (~95–99%+, representative) tied to the DPPM goal (1.5).

11. Senior Engineer Thinking

• Beginner: "The tool can't detect this fault — get a better tool."
• Senior: "Can I excite it? Yes. Can I propagate it to something observable? No — a side-input masks the path. That's an observability problem in the design, not the tool. I add a scan/observe point and it's detected. Detection is excite and propagate; 'undetected' usually means can't observe."

The senior reads 'undetected' as an observability cue and reaches for scan, not tool effort.

12. Silicon Impact

Stuck-at is where most of manufacturing test's defect-catching value comes from at the lowest cost — it's the cheap, high-correlation baseline, which is why stuck-at coverage is the first number on every signoff sheet and the first commitment tied to DPPM (1.5). The excite + propagate requirement is not a stuck-at detail — it's the engine of all ATPG (Chapter 5) and the reason scan exists (Chapter 3): a fault is only as detectable as the design is controllable and observable, so undetected stuck-at faults are a direct readout of testability debt in the RTL. Fault collapsing keeps the pattern count — and thus test time and cost (1.4) — down without sacrificing coverage. And the 2.1 caveat still governs: 100% stuck-at is 100% of the stuck-at model — real quality needs transition/delay (2.3) for timing defects and bridging/IDDQ (2.4) for shorts/leakage. For the RTL/DV engineer, the takeaway is concrete and actionable: every undetected stuck-at fault is an invitation to improve observability, and doing so early — in RTL and scan architecture — is what lets the part hit its stuck-at bar cheaply and, ultimately, meet its DPPM commitment.

13. Engineering Checklist

• Confirmed each target fault is both excitable and propagatable to an observable point.
• Ran fault collapsing to minimize pattern count (test time, 1.4).
• Treated undetected faults as observability signals → scan/observe fixes (Ch4/6).
• Reported fault coverage and test coverage distinctly (2.5, Ch6).
• Set the stuck-at signoff bar against the DPPM goal (1.5); planned other models for timing/shorts.

14. Try Yourself

1. Enumerate SA0/SA1 for 4 nodes of the counter (8 faults). Collapse the obvious equivalents.
2. For count[0] SA1, write the excite (force count[0]=0 via reset) and propagate (observe count[0]) steps.
3. For rst_n SA1, show the detection: assert reset, observe count ≠ 0000 in the faulty machine.
4. Construct a case where a fault is excited but not propagated (put a controlling value on a side-input) — confirm it's undetected.
5. Add an observe point and show the same fault becomes detected — the scan motivation for Chapter 3.

Reasoning is tool-neutral — pen and paper (or a free simulator for good/faulty responses) suffices. Real fault lists and coverage come from any ATPG flow (Chapters 5–6). No paid tool required.

15. Interview Perspective

• Weak: "A stuck-at fault is when a wire is stuck at 0 or 1."
• Good: "Each node is modeled SA0 or SA1; to detect it you set the opposite value and observe the effect."
• Senior: "The stuck-at model gives two faults per node — SA0/SA1, a node frozen independent of the driving logic. Detection needs both excite (drive the node to the fault's opposite value) and propagate (sensitize a path with non-controlling side-inputs so an observable output depends on it) — a pattern detects only when good and faulty machines differ at a measurable point. Fault collapsing merges equivalent faults to cut patterns without changing coverage. And it's a proxy — 100% stuck-at still misses timing and bridging defects, so it's the baseline, not the whole story."

16. Interview / Review Questions

17. Key Takeaways

• The stuck-at model freezes each node to a constant — SA0 or SA1, independent of the driving logic — giving two faults per node; it's the workhorse baseline.
• Detection needs both, in one pattern: excite (drive the node to the fault's opposite value) and propagate (sensitize a path with non-controlling side-inputs to an observable output) — a pattern detects iff good machine ≠ faulty machine at a measurable point.
• A fault you can excite but not observe is undetected — usually a controllability/observability limit in the design, fixed with scan (Chapter 3), not a stronger tool.
• Fault collapsing merges equivalent/dominated faults to cut pattern count and test time (1.4) without changing coverage; fault coverage (detected/list) differs from test coverage (accounts for undetectable, 2.5/Ch6).
• High stuck-at coverage (~95–99%+, representative) is the first signoff bar and first DPPM commitment — but it's a proxy that misses timing/bridging defects (2.3/2.4). Next: 2.3 — transition & delay faults (timing defects stuck-at can't see).

18. Quick Revision

Stuck-at — the workhorse model. Each NODE modeled SA0 / SA1 (frozen constant, independent of driven value) → 2 faults/node. DETECT = EXCITE (drive the opposite value) AND PROPAGATE (non-controlling side-inputs → observable output); detected iff good ≠ faulty at a measurable point. Excite-but-not-observe = undetected → fix with observability (scan), not a better tool. Fault collapsing merges equivalents → fewer patterns, SAME coverage (test-time win). High stuck-at coverage (~95–99%+, representative) = first signoff bar, but a PROXY (misses timing/bridging). Next: 2.3 — transition & delay faults.