Qu'est-ce que le test en fin de ligne

Qu'est-ce que le test en fin de ligne avec TofuPilot

Le test en fin de ligne (EOL) est la dernière vérification fonctionnelle qu'une unité subit avant de quitter la ligne de production. Il détecte les défauts que les étapes précédentes du processus ont manqués et produit l'enregistrement de test prouvant que l'unité fonctionne. Ce guide couvre ce qu'implique le test EOL, comment construire un test EOL en Python et comment enregistrer automatiquement les résultats dans TofuPilot.

Ce que couvre le test en fin de ligne

Le test EOL valide qu'un produit fini respecte ses spécifications fonctionnelles. Il s'exécute après l'assemblage complet et avant le conditionnement.

Un test EOL typique vérifie :

Vérification	Exemple
Mise sous tension	L'unité consomme le courant attendu à la tension nominale
Communication	Le port série, I2C ou CAN bus répond correctement
Sortie capteur	Les lectures sont dans les limites calibrées
Réponse actionneur	Le moteur tourne, la vanne s'ouvre, le relais clique
Version firmware	Correspond à la version publiée
Sécurité	Le courant de fuite est inférieur au seuil réglementaire

Le test EOL est de type réussite/échec. Chaque unité suit la même séquence. L'objectif est la couverture et la rapidité, pas la caractérisation approfondie.

EOL vs autres étapes de test

Étape	Quand	Objectif
Inspection entrante	Avant l'assemblage	Vérifier les matières premières et composants
Test in-circuit (ICT)	Après le CMS	Vérifier les joints de soudure et le placement des composants
Test fonctionnel (FCT)	Après l'assemblage	Valider le comportement des sous-systèmes
Test en fin de ligne	Après l'assemblage final	Confirmer que le produit complet fonctionne
Audit qualité sortant	Après l'EOL	Vérification par échantillonnage pour l'expédition

Le test EOL est la dernière barrière. Si une unité échoue ici, elle part en reprise ou au rebut. Si elle réussit, elle est expédiée.

Prérequis

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

Étape 1 : Définir les phases de test

Chaque vérification EOL devient une phase OpenHTF. Gardez les phases courtes et indépendantes pour faciliter l'isolation des défaillances.

eol_test.py

import openhtf as htf
from openhtf.util import units


@htf.measures(
    htf.Measurement("supply_current_mA")
    .in_range(minimum=45, maximum=55)
    .with_units(units.MILLIAMPERE)
)
def phase_power_up(test):
    """Vérifier que l'unité consomme le courant attendu à 5V."""
    test.measurements.supply_current_mA = 50.2


@htf.measures(
    htf.Measurement("firmware_version").equals("2.4.1")
)
def phase_firmware_check(test):
    """Confirmer que le firmware correspond à la version publiée."""
    test.measurements.firmware_version = "2.4.1"


@htf.measures(
    htf.Measurement("sensor_reading")
    .in_range(minimum=2.8, maximum=3.3)
    .with_units(units.VOLT)
)
def phase_sensor_output(test):
    """Vérifier que le capteur embarqué lit dans les spécifications."""
    test.measurements.sensor_reading = 3.05

Étape 2 : Assembler et exécuter le test

Connectez les phases à un test et reliez TofuPilot. Chaque exécution est téléversée automatiquement.

eol_test.py

from tofupilot.openhtf import TofuPilot

test = htf.Test(
    phase_power_up,
    phase_firmware_check,
    phase_sensor_output,
)

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

Lorsque l'opérateur scanne un numéro de série, OpenHTF exécute les trois phases dans l'ordre. TofuPilot enregistre le résultat, les mesures et le statut réussite/échec.

Étape 3 : Suivre les résultats dans TofuPilot

TofuPilot suit automatiquement les résultats des tests EOL. Ouvrez l'onglet Analytics pour voir :

Le rendement au premier passage par équipe et par station
Les distributions de mesures avec superposition des limites
Le Pareto des défaillances montrant quelles phases échouent le plus souvent
La traçabilité des unités reliant chaque numéro de série à son enregistrement de test

Ces données alimentent directement les revues qualité et les audits clients sans reporting manuel.

Quand utiliser le test en fin de ligne

Le test EOL est pertinent lorsque :

Chaque unité doit être vérifiée individuellement avant l'expédition
Les exigences réglementaires ou client imposent des enregistrements de test par numéro de série
Le produit comporte plusieurs sous-systèmes qui interagissent après l'assemblage final
Les retours terrain doivent être traçables jusqu'aux données de test de production

Pour la production faible volume et forte variété, les tests EOL s'exécutent souvent sur une seule station avec un opérateur. Pour les lignes à haut volume, les stations EOL fonctionnent sans intervention avec des fixations automatisées.

Qu'est-ce que le test en fin de ligne