Suivre le rendement cumulé

Le rendement final vous indique seulement si une unité a passé en fin de ligne. Le rendement cumulé (RTY, Rolled Throughput Yield) vous indique la probabilité qu'une unité passe chaque étape sans retouche ni retest. C'est la métrique qui expose les pertes cachées de l'usine.

Pourquoi le RTY compte plus que le rendement final

Le rendement final compte une unité comme « pass » même si elle a échoué trois fois avant que quelqu'un ne la retouche. Le RTY non. Il multiplie le rendement au premier passage de chaque étape du processus :

RTY = FPY₁ x FPY₂ x ... x FPYₙ

Considérez un processus en cinq étapes où chaque étape a un FPY de 95 %. Le rendement final pourrait afficher 99 % car la retouche rattrape la plupart des échecs. Mais le RTY raconte la vraie histoire :

RTY = 0,95 x 0,95 x 0,95 x 0,95 x 0,95 = 77,4 %

Cela signifie que près d'une unité sur 4 a nécessité une retouche quelque part. Chaque retouche coûte du temps, de la main-d'œuvre et des matériaux que le rendement final masque complètement.

Interprétation du RTY

La puissance du RTY est qu'il identifie précisément quelle étape tire l'ensemble de la ligne vers le bas. Si l'étape 3 a un FPY de 88 % tandis que les autres sont à 98 %, vous savez exactement où concentrer vos efforts.

Structurer vos tests pour le suivi du RTY

Chaque étape du processus devrait être une procédure de test distincte dans TofuPilot. Cela vous donne un FPY par étape qui alimente directement les calculs de RTY. Voici un test OpenHTF multi-phases représentant un processus d'assemblage de PCB avec des étapes distinctes :

# Étape 1 : Vérification du placement des composants SMT
import openhtf as htf
from openhtf.util import units
from tofupilot.openhtf import TofuPilot

@htf.measures(
    htf.Measurement("placement_offset_x")
        .in_range(minimum=-0.05, maximum=0.05)
        .with_units(units.MILLIMETRE),
    htf.Measurement("placement_offset_y")
        .in_range(minimum=-0.05, maximum=0.05)
        .with_units(units.MILLIMETRE),
    htf.Measurement("component_rotation")
        .in_range(minimum=-2.0, maximum=2.0),
)
def smt_placement_check(test):
    test.measurements.placement_offset_x = 0.02
    test.measurements.placement_offset_y = -0.01
    test.measurements.component_rotation = 0.5

def main():
    test = htf.Test(smt_placement_check)
    with TofuPilot(test):
        test.execute(test_start=lambda: "PCB-2024-0042")

if __name__ == "__main__":
    main()

# Étape 2 : Vérification du profil thermique de soudure par refusion
import openhtf as htf
from openhtf.util import units
from tofupilot.openhtf import TofuPilot

@htf.measures(
    htf.Measurement("peak_temperature")
        .in_range(minimum=235, maximum=250)
        .with_units(units.DEGREE_CELSIUS),
    htf.Measurement("time_above_liquidus")
        .in_range(minimum=60, maximum=120),
    htf.Measurement("cooling_rate")
        .in_range(maximum=3.0),
)
def reflow_profile_check(test):
    test.measurements.peak_temperature = 242
    test.measurements.time_above_liquidus = 85
    test.measurements.cooling_rate = 2.1

def main():
    test = htf.Test(reflow_profile_check)
    with TofuPilot(test):
        test.execute(test_start=lambda: "PCB-2024-0042")

if __name__ == "__main__":
    main()

# Étape 3 : Test fonctionnel après assemblage
import openhtf as htf
from openhtf.util import units
from tofupilot.openhtf import TofuPilot

@htf.measures(
    htf.Measurement("supply_voltage")
        .in_range(minimum=4.9, maximum=5.1)
        .with_units(units.VOLT),
    htf.Measurement("quiescent_current")
        .in_range(maximum=15.0)
        .with_units(units.AMPERE),
    htf.Measurement("clock_frequency")
        .in_range(minimum=7.99, maximum=8.01)
        .with_units(units.HERTZ),
)
def functional_check(test):
    test.measurements.supply_voltage = 5.02
    test.measurements.quiescent_current = 0.0113
    test.measurements.clock_frequency = 8003000

def main():
    test = htf.Test(functional_check)
    with TofuPilot(test):
        test.execute(test_start=lambda: "PCB-2024-0042")

if __name__ == "__main__":
    main()

Chaque procédure de test s'exécute indépendamment et téléverse les résultats dans TofuPilot avec le même numéro de série. TofuPilot relie les trois procédures à la même unité, vous donnant un historique complet du processus.

Suivre le RTY dans TofuPilot

Une fois que vos procédures de test téléversent les résultats, le tableau de bord TofuPilot vous fournit ce dont vous avez besoin pour calculer et suivre le RTY :

• Tendances de FPY par procédure montrent le rendement au premier passage pour chaque étape du processus au fil du temps. Vous pouvez repérer une dégradation sur une seule étape avant qu'elle n'affecte le rendement final.
• Diagrammes de Pareto des défaillances détaillent quelles mesures échouent le plus souvent à chaque étape, pour prioriser l'analyse des causes racines.
• Historique unitaire montre le parcours complet de tout numéro de série à travers toutes les procédures, y compris les retests. C'est la vérité terrain pour savoir si une unité est passée du premier coup à chaque étape.

Pas besoin de construire des calculs de RTY en Python. Structurez vos tests en procédures séparées, téléversez les résultats avec des numéros de série cohérents, et TofuPilot vous donne la visibilité par étape qui rend le RTY actionnable.

Bonnes pratiques pour un RTY précis

1. Une procédure par étape de processus. Ne combinez pas le placement SMT et la soudure par refusion dans un seul test. Des procédures séparées donnent des chiffres de FPY séparés.

2. Utilisez des numéros de série cohérents. Chaque procédure pour la même unité doit référencer le même numéro de série. C'est ainsi que TofuPilot relie l'ensemble de la chaîne de processus.

3. N'excluez pas les retests. Téléversez chaque exécution de test, y compris les échecs et les retests. Le RTY ne fonctionne que lorsque vous avez l'image complète.

4. Définissez les limites de mesure dans le code. Les limites définies dans OpenHTF sont directement intégrées dans l'analytique de TofuPilot. Ne comptez pas sur une analyse a posteriori pour déterminer le pass/fail.