Gestion des données de test pour l'électronique

Chaque test matériel produit des données. Tensions, résultats réussite/échec, numéros de série, horodatages, identifiants opérateur. La question n'est pas de savoir si vous avez des données. C'est de savoir si vous pouvez les retrouver, leur faire confiance et agir en conséquence six mois plus tard.

Ce guide explique comment structurer, stocker et interroger les données de test électronique avec TofuPilot pour obtenir une traçabilité automatique, un suivi du rendement et un contrôle du processus sans rien construire vous-même.

Ce que signifie la gestion des données de test

La gestion des données de test est la pratique consistant à organiser les résultats de test pour qu'ils soient interrogeables, traçables et utiles dans le temps. Voici les questions auxquelles elle doit répondre :

Si votre système actuel ne peut pas répondre à ces six questions, vous avez un problème de données, pas un problème de test.

Pourquoi les tableurs et systèmes de fichiers échouent à grande échelle

La plupart des équipes commencent avec des exports CSV ou des lecteurs partagés. Cela fonctionne pour 10 unités. Cela s'effondre à 1 000.

Le problème fondamental : les fichiers plats n'imposent pas de relations entre les unités, les exécutions, les étapes et les mesures. Sans ces relations, chaque requête est un script ponctuel.

Le modèle de données de test

TofuPilot organise les données de test dans une hiérarchie qui correspond directement au fonctionnement des tests matériels :

Chaque exécution est liée à une procédure, une unité et optionnellement une station. Les étapes et mesures s'imbriquent dans les exécutions. Cette structure permet d'interroger dans toutes les directions : « montrez-moi toutes les exécutions pour cette unité », « montrez-moi toutes les mesures pour cette étape sur 10 000 exécutions », ou « montrez-moi le rendement par station pour cette procédure ».

Comment TofuPilot structure automatiquement les données de test

Si vous utilisez OpenHTF, TofuPilot capture la structure complète du test (phases, mesures, limites, pièces jointes) sans aucun code supplémentaire. Il suffit d'envelopper votre test avec TofuPilot :

import openhtf as htf
from openhtf.util import units
from tofupilot.openhtf import TofuPilot


@htf.measures(
    htf.Measurement("rail_3v3").in_range(3.13, 3.47).with_units(units.VOLT),
)
def measure_3v3_rail(test):
    voltage = read_voltage("3V3_RAIL")
    test.measurements.rail_3v3 = voltage


@htf.measures(
    htf.Measurement("rail_5v").in_range(4.75, 5.25).with_units(units.VOLT),
)
def measure_5v_rail(test):
    voltage = read_voltage("5V_RAIL")
    test.measurements.rail_5v = voltage


@htf.measures(
    htf.Measurement("current_draw").in_range(0.05, 0.5).with_units(units.AMPERE),
)
def measure_current_draw(test):
    current = read_current("VIN")
    test.measurements.current_draw = current


def main():
    test = htf.Test(
        measure_3v3_rail,
        measure_5v_rail,
        measure_current_draw,
        procedure_id="FCT_PowerBoard_v2",
    )

    with TofuPilot(test):
        test.execute(test_start=lambda: "SN-0042")


if __name__ == "__main__":
    main()

Ce simple wrapper TofuPilot(test) envoie l'exécution complète (phases, mesures, limites, unités, résultat, durée) à TofuPilot. Pas de code de sérialisation, pas d'appels API, pas de gestion de fichiers.

Utiliser le client Python directement

Vous n'utilisez pas OpenHTF ? Le client Python TofuPilot vous permet d'enregistrer des données de test structurées depuis n'importe quel framework de test ou script personnalisé :

from tofupilot import TofuPilotClient

client = TofuPilotClient()

client.create_run(
    procedure_id="FCT_PowerBoard_v2",
    unit_under_test={"serial_number": "SN-0042"},
    run_passed=True,
    steps=[
        {
            "name": "measure_3v3_rail",
            "step_passed": True,
            "measurements": [
                {
                    "name": "rail_3v3",
                    "measured_value": 3.28,
                    "units": "V",
                    "lower_limit": 3.13,
                    "upper_limit": 3.47,
                }
            ],
        },
        {
            "name": "measure_5v_rail",
            "step_passed": True,
            "measurements": [
                {
                    "name": "rail_5v",
                    "measured_value": 5.01,
                    "units": "V",
                    "lower_limit": 4.75,
                    "upper_limit": 5.25,
                }
            ],
        },
        {
            "name": "measure_current_draw",
            "step_passed": True,
            "measurements": [
                {
                    "name": "current_draw",
                    "measured_value": 0.12,
                    "units": "A",
                    "lower_limit": 0.05,
                    "upper_limit": 0.5,
                }
            ],
        },
    ],
)

Même modèle de données, même capacité d'interrogation. Le client gère la validation, le regroupement et les tentatives de renvoi.

Analyses intégrées

TofuPilot calcule automatiquement le FPY, le Cpk et les diagrammes de Pareto des défaillances à partir de vos données de test. Ouvrez l'onglet Analytique sur n'importe quelle procédure pour voir les tendances de rendement, ou créez un Rapport personnalisé pour une analyse inter-procédures.

Rendement au premier passage (FPY) affiche le pourcentage d'unités qui réussissent dès la première tentative, tracé dans le temps. Vous pouvez filtrer par station, plage de dates ou révision d'unité. Une chute soudaine du FPY vous indique que quelque chose a changé : un nouveau lot de composants, un problème de montage ou une régression du script de test.

Capabilité du processus (Cpk) est calculée par mesure à travers toutes les exécutions. TofuPilot trace la distribution des mesures par rapport à vos limites de spécification et calcule automatiquement Cp et Cpk. Un Cpk inférieur à 1,33 signifie que votre processus est trop proche des limites.

Pareto des défaillances classe les étapes de test par nombre d'échecs pour que vous puissiez vous concentrer d'abord sur le principal contributeur. TofuPilot construit ce graphique pour n'importe quelle procédure, sur n'importe quelle période.

Rapports personnalisés vous permettent de combiner FPY, Cpk et données de défaillance sur plusieurs procédures en une seule vue. Utilisez-les pour les revues qualité hebdomadaires ou pour comparer le rendement entre les lignes de production.

Comparaison : approches de la gestion des données de test

Le constat est clair. Vous pouvez tout construire vous-même, et beaucoup d'équipes l'ont fait. Mais chaque heure passée sur l'infrastructure de test est une heure non consacrée au produit que vous testez réellement.