Suivre numéros de série et assemblages

La plupart des produits matériels contiennent des sous-assemblages, chacun avec son propre numéro de série. La fonctionnalité sub_units de TofuPilot vous permet d'enregistrer quels composants ont été intégrés dans quelle unité parente, vous offrant une traçabilité complète de la nomenclature depuis un seul script de test.

Pourquoi le suivi des sous-assemblages est important

Un produit fini peut contenir une carte d'alimentation, un module de calcul et un réseau de capteurs. Chacun possède son propre numéro de série et son propre historique de tests. Lorsqu'une défaillance terrain pointe vers un composant spécifique, vous devez savoir quelles unités parentes contiennent ce composant.

C'est une pratique standard pour la traçabilité IPC-1782 et une exigence dans les industries réglementées. TofuPilot lie automatiquement les numéros de série parent et enfant lorsque vous les incluez dans vos exécutions de tests.

Enregistrer les numéros de série des sous-unités

Utilisez le paramètre sub_units dans TofuPilot pour déclarer quels composants ont été installés dans le DUT lors de l'assemblage.

test_assembly.py

# Enregistrement des numéros de série des sous-assemblages lors du test d'assemblage final
import openhtf as htf
from tofupilot.openhtf import TofuPilot

@htf.measures(
    htf.Measurement("system_power_on").in_range(minimum=1, maximum=1),
    htf.Measurement("communication_check").in_range(minimum=1, maximum=1),
)
def system_integration_test(test):
    test.measurements.system_power_on = 1
    test.measurements.communication_check = 1

def main():
    test = htf.Test(system_integration_test)
    with TofuPilot(
        test,
        sub_units=[
            {"serial_number": "PSU-2026-0441"},
            {"serial_number": "CPU-2026-1187"},
            {"serial_number": "SNS-2026-0893"},
        ],
    ):
        test.execute(test_start=lambda: "ASSY-2026-0072")

if __name__ == "__main__":
    main()

Après le téléchargement de ce test, la page d'unité TofuPilot pour ASSY-2026-0072 affiche trois sous-assemblages liés. Cliquez sur n'importe quel numéro de série de sous-unité pour voir son propre historique de tests.

Scanner les numéros de série des sous-unités pendant l'assemblage

En pratique, les opérateurs scannent les numéros de série des composants à mesure qu'ils les installent. Vous pouvez les collecter dans une phase OpenHTF et les transmettre à TofuPilot.

test_scan_subunits.py

# L'opérateur scanne les numéros de série des sous-assemblages pendant l'assemblage
import openhtf as htf
from openhtf.util import units
from tofupilot.openhtf import TofuPilot

# Stockage des numéros de série scannés au niveau du module
scanned_sub_units = []

@htf.measures(
    htf.Measurement("psu_serial"),
    htf.Measurement("cpu_serial"),
)
def scan_components(test):
    psu = input("Scanner le numéro de série PSU : ")
    cpu = input("Scanner le numéro de série CPU : ")

    test.measurements.psu_serial = psu
    test.measurements.cpu_serial = cpu

    scanned_sub_units.append({"serial_number": psu})
    scanned_sub_units.append({"serial_number": cpu})

@htf.measures(
    htf.Measurement("power_rail_5v").in_range(minimum=4.8, maximum=5.2).with_units(units.VOLT),
    htf.Measurement("power_rail_3v3").in_range(minimum=3.1, maximum=3.5).with_units(units.VOLT),
)
def power_validation(test):
    test.measurements.power_rail_5v = 5.02
    test.measurements.power_rail_3v3 = 3.31

def main():
    test = htf.Test(scan_components, power_validation)
    with TofuPilot(test, sub_units=scanned_sub_units):
        test.execute(test_start=lambda: input("Scanner le numéro de série de l'assemblage : "))

if __name__ == "__main__":
    main()

Assemblages multi-niveaux

Pour les produits avec des assemblages imbriqués (un module dans une carte, dans un châssis), testez chaque niveau séparément avec ses propres sous-unités. TofuPilot construit la hiérarchie automatiquement.

test_nested_assembly.py

# Tester un module, puis tester la carte qui le contient
import openhtf as htf
from tofupilot.openhtf import TofuPilot

@htf.measures(
    htf.Measurement("module_self_test").in_range(minimum=1, maximum=1),
)
def module_test(test):
    test.measurements.module_self_test = 1

@htf.measures(
    htf.Measurement("board_communication").in_range(minimum=1, maximum=1),
)
def board_test(test):
    test.measurements.board_communication = 1

def main():
    # Premièrement : tester le module seul
    module_serial = "MOD-2026-0551"
    t1 = htf.Test(module_test)
    with TofuPilot(t1):
        t1.execute(test_start=lambda: module_serial)

    # Deuxièmement : tester la carte, en déclarant le module comme sous-unité
    board_serial = "BRD-2026-0112"
    t2 = htf.Test(board_test)
    with TofuPilot(t2, sub_units=[{"serial_number": module_serial}]):
        t2.execute(test_start=lambda: board_serial)

if __name__ == "__main__":
    main()

Dans le tableau de bord de TofuPilot, la recherche par numéro de série de la carte affiche le module comme sous-unité. La recherche par numéro de série du module affiche ses propres résultats de test ainsi que la carte parente dans laquelle il a été installé.

Cas d'utilisation de la traçabilité de nomenclature

Une fois que les liens de sous-assemblage existent dans TofuPilot, vous pouvez répondre aux questions qui comptent en production :

Investigation de défaillance terrain. Un module capteur tombe en panne sur le terrain. Recherchez son numéro de série pour trouver chaque unité parente contenant le même type de module du même lot de production.
Rappel de composant. Un fournisseur signale un lot de condensateurs. Si vos phases de test enregistrent les numéros de lot des composants comme mesures, vous pouvez tracer quels assemblages les ont utilisés.
Rendement par composant. Le tableau de bord de TofuPilot affiche le FPY ventilé par dimension. Si un lot spécifique de sous-assemblage cause des défaillances, vous le verrez dans les données.

Visualiser les liens de sous-assemblage

Ouvrez la page de n'importe quelle unité dans TofuPilot pour voir son arborescence de sous-assemblage. La page affiche :

Les composants enfants directs avec leurs numéros de série
L'historique de test propre à chaque enfant (cliquez pour le consulter)
L'assemblage parent, si cette unité est elle-même un sous-composant
Toutes les exécutions de test pour l'unité, à travers chaque étape de production

Cela offre aux ingénieurs qualité et aux auditeurs un point unique pour tracer n'importe quel composant à travers la hiérarchie complète du produit.