What Is HALT and HASS Testing

What Is HALT and HASS Testing with TofuPilot

HALT (Highly Accelerated Life Test) pushes a product beyond its design limits to find failure modes early. HASS (Highly Accelerated Stress Screen) applies controlled stress during production to catch latent defects before they reach customers. This guide covers how both methods work, when to use each, and how to track stress test results with TofuPilot.

HALT: Find the Weak Spots

HALT is a design-phase test. You put prototype units in a chamber and ramp temperature and vibration until something breaks. The goal is not to simulate field conditions. The goal is to find the fundamental limits of your design.

A typical HALT profile includes:

Each time a failure occurs, you analyze the root cause, fix it if possible, and continue. HALT is iterative. A single HALT run typically uncovers 3 to 8 distinct failure modes.

HALT Output

HALT runs on 5 to 15 units during EVT or DVT. It's qualitative, not statistical. You're looking for failure modes, not predicting field life.

HASS: Screen Every Production Unit

HASS applies stress levels between the product's specification and the destruct limits found in HALT. It runs on every production unit (or a defined sample) to precipitate latent defects that would cause early field failures.

HASS stresses are derived from HALT. If HALT found a destruct limit at -60C, a HASS screen might cycle to -40C. The stress is high enough to catch latent defects but low enough to avoid damaging good units.

Proof of Screen (POS)

Before running HASS on production units, you validate the screen itself:

1. Run the HASS profile on units known to be good. Verify zero failures.
2. Seed units with known defects. Verify the screen catches them.
3. Document the detection rate. If the screen misses seeded defects, increase stress.

Prerequisites

• Python 3.10+
• OpenHTF installed (pip install openhtf)
• TofuPilot Python SDK installed (pip install tofupilot)

Step 1: Define Functional Check Phases

Both HALT and HASS require functional checks between stress cycles. These detect when a unit degrades or fails.

import openhtf as htf
from openhtf.util import units


@htf.measures(
    htf.Measurement("output_voltage_V")
    .in_range(
        minimum=3.0, maximum=3.6,
        marginal_minimum=3.1, marginal_maximum=3.5,
    )
    .with_units(units.VOLT),
    htf.Measurement("current_draw_mA")
    .in_range(minimum=40, maximum=65)
    .with_units(units.MILLIAMPERE),
)
def phase_electrical_check(test):
    """Verify core electrical parameters after stress cycle."""
    test.measurements.output_voltage_V = 3.29
    test.measurements.current_draw_mA = 51.3


@htf.measures(
    htf.Measurement("comms_loopback").equals("PASS"),
)
def phase_comms_check(test):
    """Verify communication interfaces still respond."""
    test.measurements.comms_loopback = "PASS"

Step 2: Log Each Cycle to TofuPilot

Run the functional check after each stress step. Each execution creates a new test run linked to the same serial number, building a degradation timeline.

from tofupilot.openhtf import TofuPilot

test = htf.Test(
    phase_electrical_check,
    phase_comms_check,
)

with TofuPilot(test):
    test.execute(test_start=lambda: input("Scan unit serial: "))

Step 3: Track Degradation in TofuPilot

TofuPilot tracks every run per serial number. Open the unit history to see:

• Measurement trends across stress cycles (voltage drift, current increase)
• Marginal results flagged before hard failures
• Control charts showing when a parameter trends toward a limit
• Failure analysis identifying which stress step causes the most failures

For HASS, the pass/fail result of the production screen feeds directly into yield tracking. TofuPilot shows HASS yield alongside your other production test stages.

When to Use HALT vs HASS vs ESS

HALT and HASS work as a pair. HALT defines the design margins. HASS uses those margins to build a production screen. Without HALT data, HASS stress levels are guesswork.