TofuPilot génère automatiquement des tableaux de bord KPI de fabrication à partir de vos données de test. Vous n'avez pas besoin de construire des rapports en Python ou de connecter des outils BI pour les métriques standards. Écrivez des tests bien structurés et les tableaux de bord se remplissent d'eux-mêmes.
KPI clés de fabrication
Voici les métriques qui comptent sur le plancher de production.
Le rendement au premier passage (FPY) est le pourcentage d'unités qui passent tous les tests du premier coup. C'est le meilleur indicateur de la santé du procédé. TofuPilot calcule le FPY par procédure, par station et sur l'ensemble de votre ligne.
Le débit mesure les unités testées par heure ou par équipe. Il vous indique si votre ligne atteint les objectifs de capacité. Les goulots d'étranglement apparaissent comme des baisses de débit sur des stations spécifiques.
Le Cpk (indice de capabilité du procédé) quantifie le centrage de vos mesures dans les limites de spécification. Un Cpk supérieur à 1,33 signifie que votre procédé a une marge confortable. En dessous de 1,0, vous produisez des pièces hors spécification.
Le temps de cycle est la durée de chaque test. C'est le dénominateur du débit et le premier élément à optimiser quand vous avez besoin de plus de capacité.
Le taux de défaillance par étape détaille où les défaillances surviennent. Un diagramme de Pareto des modes de défaillance vous indique exactement où investir l'effort d'ingénierie.
Structurer les tests pour des KPI complets
Chaque KPI ci-dessus provient de données que vos tests produisent déjà. L'essentiel est de structurer les tests pour que TofuPilot puisse tout extraire proprement.
import openhtf as htf
from openhtf.util import units
from tofupilot.openhtf import TofuPilot
@htf.measures(
htf.Measurement("boot_time")
.in_range(maximum=3.0),
htf.Measurement("firmware_version")
.with_allowed_values("2.4.1", "2.4.2"),
)
def firmware_validation(test):
"""Valider que le firmware démarre correctement."""
test.measurements.boot_time = 1.8
test.measurements.firmware_version = "2.4.1"
@htf.measures(
htf.Measurement("battery_voltage")
.with_units(units.VOLT)
.in_range(minimum=3.6, maximum=4.2),
htf.Measurement("charge_current")
.in_range(minimum=0.450, maximum=0.550)
.with_units(units.AMPERE),
htf.Measurement("discharge_capacity")
.in_range(minimum=2800),
)
def battery_test(test):
"""Tester la charge et la capacité de la batterie."""
test.measurements.battery_voltage = 3.95
test.measurements.charge_current = 0.502
test.measurements.discharge_capacity = 3050
@htf.measures(
htf.Measurement("touch_sensitivity_pct")
.in_range(minimum=85.0),
htf.Measurement("display_brightness")
.in_range(minimum=400, maximum=600),
htf.Measurement("pixel_defect_count")
.in_range(maximum=0),
)
def display_and_touch_test(test):
"""Vérifier les performances de l'écran et de l'écran tactile."""
test.measurements.touch_sensitivity_pct = 94.2
test.measurements.display_brightness = 520
test.measurements.pixel_defect_count = 0
@htf.measures(
htf.Measurement("speaker_thd_pct")
.in_range(maximum=1.0),
htf.Measurement("microphone_snr")
.in_range(minimum=60.0),
)
def audio_test(test):
"""Tester la qualité du haut-parleur et du microphone."""
test.measurements.speaker_thd_pct = 0.4
test.measurements.microphone_snr = 68.5
def main():
test = htf.Test(
firmware_validation,
battery_test,
display_and_touch_test,
audio_test,
)
with TofuPilot(test):
test.execute(test_start=lambda: "DEVICE-007")
if __name__ == "__main__":
main()Ce test fournit à TofuPilot tout ce dont il a besoin. Les mesures numériques avec limites alimentent les calculs de Cpk. La structure par phase alimente l'analyse des défaillances par étape. Les horodatages alimentent le débit et le temps de cycle. Les résultats pass/fail alimentent le FPY.
Ce qui rend les tests prêts pour les KPI
Trois éléments font la différence entre des tests qui produisent des tableaux de bord utiles et des tests qui n'en produisent pas.
Des mesures numériques avec limites. Chaque mesure qui a des limites in_range() bénéficie du suivi Cpk, des histogrammes et des cartes de contrôle. Les vérifications booléennes pass/fail conviennent pour les tests tout-ou-rien, mais elles n'alimentent pas l'analytique.
Des noms de phase cohérents. Si vous renommez une phase, TofuPilot la traite comme une nouvelle étape. Gardez des noms stables pour que les comparaisons historiques fonctionnent. Utilisez des noms descriptifs qui ont du sens dans un contexte de tableau de bord.
Des numéros de série uniques. L'identifiant du DUT connecte l'historique de test complet d'une unité entre les stations. Utilisez de vrais numéros de série, pas des valeurs fictives. Cela permet la traçabilité et le suivi des retests.
Visualiser les tableaux de bord dans TofuPilot
Le tableau de bord de TofuPilot affiche vos KPI en temps réel à mesure que les résultats de test sont téléversés. Vous y trouverez :
- Des tendances FPY dans le temps, filtrables par procédure, station ou plage de dates
- Des graphiques de débit montrant les unités par heure par station
- Des histogrammes de mesures et des valeurs Cpk pour chaque mesure numérique
- Des diagrammes de Pareto des défaillances classant les modes de défaillance par fréquence
- Des jauges de rendement pour un aperçu rapide
Les tableaux de bord personnalisés vous permettent de combiner des widgets pour des vues spécifiques. Créez un tableau de bord responsable de ligne avec FPY et débit, ou un tableau de bord ingénierie centré sur le Cpk et l'analyse des défaillances.
Maintenir la précision des tableaux de bord
Les tableaux de bord ne valent que par les données qui les alimentent. Faites passer chaque unité par le test, y compris les unités que vous savez déjà défectueuses. Sauter les unités connues comme mauvaises gonfle votre FPY.
Utilisez des procédures séparées pour le retest et le premier test. Cela maintient les calculs de FPY propres tout en suivant les résultats de retest. TofuPilot gère les deux et les affiche indépendamment.