Optimiser les stations de test

Comment optimiser les stations de test avec TofuPilot

Le temps de cycle d'une station de test limite directement le débit de production. Un test de 60 secondes sur deux stations signifie 120 unités par heure. Réduisez-le à 45 secondes et vous passez à 160 sans ajouter de matériel. Ce guide explique comment trouver les goulots d'étranglement, réduire le temps de cycle et suivre les performances des stations avec TofuPilot.

Où passe le temps

Un cycle typique de station de test se décompose en :

Les gains les plus importants proviennent généralement de la stabilisation des instruments et de l'acquisition des mesures, pas d'un code plus rapide.

Étape 1 : Mesurer votre référence

On ne peut pas optimiser ce qu'on ne mesure pas. OpenHTF enregistre automatiquement la durée de chaque phase. TofuPilot affiche ces durées dans la vue de performance des étapes de test.

import openhtf as htf
from openhtf.util import units


@htf.measures(
    htf.Measurement("supply_voltage_V")
    .in_range(minimum=4.9, maximum=5.1)
    .with_units(units.VOLT),
)
def phase_power_check(test):
    """Mesurer la tension d'alimentation après la mise sous tension."""
    test.measurements.supply_voltage_V = 5.01


@htf.measures(
    htf.Measurement("signal_amplitude_V")
    .in_range(minimum=1.8, maximum=2.2)
    .with_units(units.VOLT),
)
def phase_signal_check(test):
    """Mesurer l'amplitude du signal de sortie."""
    test.measurements.signal_amplitude_V = 2.01


@htf.measures(
    htf.Measurement("self_test_result").equals("PASS"),
)
def phase_firmware_self_test(test):
    """Exécuter l'auto-test firmware et vérifier le résultat."""
    test.measurements.self_test_result = "PASS"

Exécutez ceci sur 50 unités et examinez les durées de phase dans TofuPilot. La phase la plus longue est votre goulot d'étranglement.

Étape 2 : Réduire le temps de stabilisation des instruments

La stabilisation des instruments est souvent le gouffre de temps caché. L'auto-calibrage, la commutation d'impédance d'entrée et la stabilisation des filtres ajoutent des centaines de millisecondes par mesure.

Ne réduisez la précision que là où la marge de mesure le permet. Si votre limite est de 4,9 V à 5,1 V et que les unités mesurent 5,0 V avec une dispersion de 1 mV, vous avez de la marge pour réduire le NPLC.

Étape 3 : Optimiser la séquence de test

L'ordre des phases est important. Placez les tests qui échouent le plus rapidement en premier pour réduire le temps de cycle moyen sur les unités défectueuses.

from openhtf import PhaseResult


@htf.measures(
    htf.Measurement("power_good").equals("PASS"),
)
def phase_power_good(test):
    """Vérification rapide de l'alimentation. En cas d'échec, sauter tout le reste."""
    result = "PASS"
    test.measurements.power_good = result
    if result != "PASS":
        return PhaseResult.STOP

Étape 4 : Suivre les performances des stations

Connectez le test à TofuPilot et surveillez les métriques au niveau de la station dans le temps.

from tofupilot.openhtf import TofuPilot

test = htf.Test(
    phase_power_good,
    phase_power_check,
    phase_signal_check,
    phase_firmware_self_test,
)

with TofuPilot(test):
    test.execute(test_start=lambda: input("Scanner le numéro de série : "))

TofuPilot suit automatiquement les performances des stations. Ouvrez l'onglet Analytics pour voir :

• Débit par station (unités par heure)
• Décomposition de la durée par phase montrant où le temps est passé
• Rendement par station pour détecter les problèmes de fixture ou d'équipement
• Comparaison de stations pour identifier les stations sous-performantes

Liste de contrôle d'optimisation

L'optimisation des stations est itérative. Faites un changement, mesurez l'effet dans TofuPilot, puis passez au goulot d'étranglement suivant. Les petits gains se cumulent : cinq améliorations de 10 % donnent une station 40 % plus rapide.