Données de test de wafers

Données de test de wafers semi-conducteurs avec TofuPilot

Le test des semi-conducteurs se déroule en deux étapes : le test au niveau wafer (CP, circuit probe) et le test final (FT, composants encapsulés). Chaque étape génère des volumes massifs de données. TofuPilot stocke les résultats de test par puce et par composant avec toutes les données de mesure, permettant l'analyse de rendement, le mapping de bins et la traçabilité des lots.

Flux de test semi-conducteur

Fabrication wafer → Test wafer (CP) → Encapsulation → Test final (FT) → Binning → Expédition
                         ↓                                  ↓
                    TofuPilot                           TofuPilot
                 (données par puce)                (données par composant)

Test wafer (Circuit Probe)

Des sondes contactent chaque puce sur le wafer. Les tests incluent :

Test	Ce qu'il vérifie
Continuité/ouvertures	Connectivité des pads de bonding
Courant de fuite	Intégrité des jonctions et de l'oxyde
Paramétrique	Vth, Idsat, Rds(on), timing
Fonctionnel	Fonctionnement basique numérique/analogique

Test final (FT)

Après encapsulation, test paramétrique et fonctionnel complet à vitesse nominale.

Test	Ce qu'il vérifie
Paramétrique DC	Niveaux entrée/sortie, consommation
Paramétrique AC	Vitesse, temps de setup/hold, temps de montée/descente
Fonctionnel	Fonctionnement complet du composant à la fréquence cible
Burn-in (optionnel)	Filtrage de mortalité infantile

Enregistrement des données de test wafer

Résultats par puce

wafer_test.py

from tofupilot import TofuPilotClient

client = TofuPilotClient()

def log_die_test(wafer_id, die_x, die_y, measurements, bin_code):
    """Enregistrer les résultats de test pour une puce individuelle."""
    die_id = f"{wafer_id}-X{die_x}Y{die_y}"

    steps = [{
        "name": "Paramétrique",
        "step_type": "measurement",
        "status": bin_code == 1,  # Bin 1 = bonne puce
        "measurements": [
            {"name": "vth_mv", "value": measurements["vth"], "unit": "mV", "limit_low": 350, "limit_high": 450},
            {"name": "idsat_ua_um", "value": measurements["idsat"], "unit": "uA/um", "limit_low": 500, "limit_high": 700},
            {"name": "ioff_pa_um", "value": measurements["ioff"], "unit": "pA/um", "limit_high": 100},
            {"name": "rdson_mohm", "value": measurements["rdson"], "unit": "mohm", "limit_high": 50},
        ],
    }]

    client.create_run(
        procedure_id="WAFER-CP-TEST",
        unit_under_test={
            "serial_number": die_id,
            "part_number": "IC-POWER-MGMT-V3",
        },
        run_passed=bin_code == 1,
        steps=steps,
    )

# Tester toutes les puces d'un wafer
wafer_id = "LOT2025A-W07"
for x in range(20):
    for y in range(20):
        meas = probe_die(x, y)
        bin_code = classify_die(meas)
        log_die_test(wafer_id, x, y, meas, bin_code)

Résumé au niveau wafer

Après avoir testé toutes les puces, téléchargez un résumé au niveau wafer.

wafer_summary.py

# Résumé au niveau wafer
total_dies = 400
good_dies = 352
yield_pct = good_dies / total_dies * 100

client.create_run(
    procedure_id="WAFER-CP-SUMMARY",
    unit_under_test={
        "serial_number": "LOT2025A-W07",
        "part_number": "IC-POWER-MGMT-V3",
    },
    run_passed=yield_pct > 80,
    steps=[{
        "name": "Résumé wafer",
        "step_type": "measurement",
        "status": yield_pct > 80,
        "measurements": [
            {"name": "total_dies", "value": total_dies, "unit": "count"},
            {"name": "good_dies", "value": good_dies, "unit": "count"},
            {"name": "cp_yield_pct", "value": yield_pct, "unit": "%", "limit_low": 80},
            {"name": "bin1_count", "value": 352, "unit": "count"},
            {"name": "bin2_count", "value": 30, "unit": "count"},
            {"name": "bin3_count", "value": 18, "unit": "count"},
        ],
    }],
)

Mapping de bins

Le binning attribue chaque puce ou composant à une catégorie en fonction des résultats de test. Structure de bins courante :

Bin	Signification	Critères typiques
1	Bon, pleine spécification	Tous les paramétriques dans la spécification
2	Bon, déclassé	Paramétriques dans des limites élargies
3	Échec fonctionnel	Échec au test fonctionnel
4	Échec paramétrique	Un ou plusieurs paramétriques hors spécification
5	Échec de continuité	Ouverture ou court-circuit détecté
6	Échec de fuite	Courant de fuite de jonction excessif

Suivez les distributions de bins dans TofuPilot à travers les wafers, les lots et les périodes.

Analyse de rendement

Rendement wafer par wafer

Comparez le rendement CP à travers les wafers d'un lot.

Wafer	Total puces	Bonnes (Bin 1)	Rendement
W01	400	360	90,0 %
W02	400	355	88,8 %
W03	400	312	78,0 %
W04	400	358	89,5 %

W03 a un rendement significativement inférieur. Investiguez les problèmes de process au niveau wafer (comptage de particules, focus lithographique, uniformité de gravure).

Rendement lot par lot

Suivez le rendement à travers les lots de production pour surveiller la stabilité du process de fabrication.

lot_yield_tracking.py

from tofupilot import TofuPilotClient

client = TofuPilotClient()

# Récupérer tous les runs de résumé wafer
runs = client.get_runs(
    procedure_id="WAFER-CP-SUMMARY",
    limit=100,
)

# Regrouper par lot et calculer le rendement moyen
lot_yields = {}
for run in runs:
    serial = run["unit_under_test"]["serial_number"]
    lot = serial.split("-W")[0]  # Extraire l'ID du lot
    for step in run.get("steps", []):
        for m in step.get("measurements", []):
            if m["name"] == "cp_yield_pct":
                if lot not in lot_yields:
                    lot_yields[lot] = []
                lot_yields[lot].append(m["value"])

for lot, yields in sorted(lot_yields.items()):
    avg = sum(yields) / len(yields)
    print(f"{lot}: {avg:.1f}% rendement moyen ({len(yields)} wafers)")

Corrélation de rendement CP vers FT

Suivez le rendement aux deux étapes de test pour détecter les problèmes liés à l'encapsulation.

Lot	Rendement CP	Rendement FT	Perte FT/CP
LOT2025A	89,2 %	87,1 %	2,1 %
LOT2025B	91,0 %	88,5 %	2,5 %
LOT2025C	90,5 %	82,3 %	8,2 %

LOT2025C montre une perte excessive de rendement CP vers FT (8,2 % vs 2-3 % typiques). Cela pointe vers un problème d'encapsulation : défaillances de wire bonding, problèmes de collage de puce, ou sensibilité à l'humidité pendant l'assemblage.

Surveillance des distributions paramétriques

Suivez les distributions des paramètres critiques à travers la production pour détecter les dérives de process.

Paramètres clés à surveiller :

Paramètre	Pourquoi c'est important
Vth (tension de seuil)	Les décalages indiquent des problèmes d'oxyde de grille ou de dose d'implantation
Idsat (courant de saturation)	Indique la capacité de commande du transistor
Ioff (courant de fuite à l'état bloqué)	Affecte la consommation en veille, indicateur de contrôle du process
Rdson (résistance à l'état passant)	Critique pour les composants de puissance
Marges de timing	Classification par vitesse, binning en grades de vitesse

Les histogrammes de mesure de TofuPilot montrent la distribution de chaque paramètre à travers toutes les puces testées. Une distribution bimodale suggère deux conditions de process différentes. Une moyenne qui dérive suggère une dérive du process.

Traçabilité du composant au wafer

Quand un composant encapsulé tombe en panne sur le terrain, remontez la chaîne :

Numéro de série du composant → lot d'encapsulation
Lot d'encapsulation → ID du wafer
ID du wafer → position de la puce (X, Y)
Position de la puce → données de test CP originales

Toutes ces données sont dans TofuPilot, liées par les numéros de série. La puce était-elle marginale au test wafer ? Était-ce un composant Bin 2 (déclassé) vendu comme Bin 1 ? Les données répondent à ces questions.

Données de test de wafers