Comment migrer de WATS vers TofuPilot

Si vous évaluez une alternative à WATS, ce guide détaille le parcours de migration. Les déclencheurs courants incluent le coût (WATS Analytics à 297 EUR/mois par module), une préférence pour les workflows Python-first, ou la volonté de s'appuyer sur un framework de test open source plutôt que sur des convertisseurs de données propriétaires.

TofuPilot s'associe à OpenHTF (le framework de test open source de Google) pour vous fournir des données de test structurées, de l'analytique en temps réel et une API REST sans dépendance fournisseur côté exécution des tests.

Mapping des concepts

WATS et TofuPilot utilisent une terminologie différente pour des concepts similaires. Voici la correspondance :

Remplacer le convertisseur de données WATS

Avec WATS, vous utilisez généralement un convertisseur de données (TestStand, LabVIEW ou personnalisé) pour sérialiser les résultats de test et les envoyer à l'API WATS. Avec TofuPilot, vous écrivez votre logique de test dans OpenHTF et le SDK gère le reporting directement.

Voici un test typique qui remplacerait un workflow de convertisseur de données WATS :

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

@htf.measures(
    htf.Measurement("supply_voltage")
        .with_units(units.VOLT)
        .in_range(4.75, 5.25),
    htf.Measurement("clock_frequency")
        .with_units(units.HERTZ)
        .in_range(minimum=7.99e6),
    htf.Measurement("firmware_version"),
)
def power_and_clock_check(test):
    test.measurements.supply_voltage = 5.02
    test.measurements.clock_frequency = 8.00e6
    test.measurements.firmware_version = "v3.2.1"

@htf.measures(
    htf.Measurement("signal_amplitude")
        .with_units(units.VOLT)
        .in_range(0.9, 1.1),
    htf.Measurement("signal_thd")
        .in_range(maximum=0.05),
)
def signal_integrity_check(test):
    test.measurements.signal_amplitude = 1.01
    test.measurements.signal_thd = 0.03

def main():
    test = htf.Test(power_and_clock_check, signal_integrity_check)
    with TofuPilot(test):
        test.execute(test_start=lambda: "SN-10042")

if __name__ == "__main__":
    main()

Aucun convertisseur de données nécessaire. Le SDK TofuPilot sérialise l'enregistrement de test OpenHTF et le téléverse automatiquement. Chaque phase correspond à ce que WATS appelle une étape de test, et chaque mesure porte sa valeur, ses unités et ses limites.

Migration des données historiques

Vous avez probablement un historique de test dans WATS que vous souhaitez préserver. L'API REST de TofuPilot accepte les exécutions historiques avec des horodatages explicites, vous pouvez donc importer les données sans perdre le contexte chronologique.

D'abord, exportez vos données depuis WATS (export CSV ou API). Puis importez-les :

import csv
from datetime import datetime
from tofupilot import TofuPilotClient

client = TofuPilotClient()

with open("wats_export.csv") as f:
    reader = csv.DictReader(f)
    for row in reader:
        client.create_run(
            procedure_id="functional-test",
            unit_under_test={
                "serial_number": row["SerialNumber"],
                "part_number": row["PartNumber"],
            },
            run_passed=row["Status"] == "Passed",
            started_at=datetime.fromisoformat(row["StartTime"]),
            duration=float(row["Duration"]),
            steps=[
                {
                    "name": row["StepName"],
                    "step_passed": row["StepStatus"] == "Passed",
                    "measurements": [
                        {
                            "name": row["MeasurementName"],
                            "measured_value": float(row["Value"]),
                            "unit": row["Unit"],
                            "lower_limit": float(row["LowLimit"]) if row["LowLimit"] else None,
                            "upper_limit": float(row["HighLimit"]) if row["HighLimit"] else None,
                        }
                    ],
                }
            ],
        )

Pour les exports WATS complexes avec des étapes de test imbriquées, aplatissez-les dans la structure phase/mesure de TofuPilot. Chaque test de limite numérique WATS devient une mesure avec lower_limit et upper_limit.

Stratégie d'exécution en parallèle

Ne basculez pas d'un coup. Faites fonctionner les deux systèmes côte à côte pour valider la migration :

1. Semaine 1. Choisissez une station de test. Ajoutez l'intégration TofuPilot à ses tests tout en gardant le convertisseur de données WATS actif. Les deux systèmes reçoivent les mêmes données.
2. Semaine 2. Comparez les résultats dans les deux tableaux de bord. Vérifiez que les valeurs de mesure, les résultats pass/fail et l'attribution des stations correspondent.
3. Semaine 3. Si tout concorde, désactivez le convertisseur de données WATS sur cette station. Déployez sur la station suivante.
4. Répétez jusqu'à ce que toutes les stations rapportent uniquement à TofuPilot.

Conservez votre abonnement WATS actif pendant cette période. Vous pouvez exporter un snapshot final des données avant de résilier.

Ce que vous obtenez après la migration

Une fois que vos tests rapportent à TofuPilot, vous trouverez l'analytique sur tofupilot.app :

• Tendances FPY par station, produit et plage de dates.
• Cpk et cartes de contrôle pour chaque mesure, calculés automatiquement.
• Pareto des défaillances pour identifier vos principaux modes de défaillance.
• Histogrammes de mesures montrant la distribution par rapport aux limites.
• Traçabilité complète par numéro de série sur toutes les exécutions de test.
• API REST pour l'intégration avec votre MES, ERP ou outillage personnalisé.

Ceux-ci remplacent le module WATS Analytics. La différence est que votre couche d'exécution de test est désormais open source (OpenHTF), et vous n'êtes pas dépendant d'un framework de test propriétaire pour accéder à l'analytique.