Infrastructure de test hardware avec TofuPilot

L'infrastructure de test est tout ce qui se trouve entre le script de test de l'ingénieur et les données qui pilotent les décisions qualité. Instruments, montages, stations, frameworks logiciels, pipelines de données. TofuPilot se place au centre comme le socle de données, connectant vos stations de test aux tableaux de bord, à l'analytique et à la traçabilité.

À quoi ressemble une infrastructure de test hardware

Un système de test de production comporte plusieurs couches :

┌────────────────────────────────────────────┐
│              TofuPilot (Cloud)              │
│  Tableaux de bord · Analytique · Traçabilité│
├────────────────────────────────────────────┤
│           Couche framework de test          │
│  OpenHTF · pytest · Python personnalisé    │
├────────────────────────────────────────────┤
│           Couche instruments                │
│  Multimètres · Oscilloscopes · Alimentations│
│  DAQs · Analyseurs de spectre · Charges    │
├────────────────────────────────────────────┤
│           Couche montages                   │
│  Montages à pogo pins · Faisceaux de câbles│
│  Actionneurs pneumatiques · Enceintes therm.│
├────────────────────────────────────────────┤
│           DUT (Dispositif sous test)        │
└────────────────────────────────────────────┘

Chaque couche a ses propres préoccupations. TofuPilot gère la couche supérieure : collecter, stocker et analyser les données qui remontent de la pile de test.

Architecture de station

Une station de test bien conçue sépare les responsabilités :

Composant	Responsabilité	Outils
Logique de test	Quoi tester et dans quel ordre	OpenHTF, pytest, Python personnalisé
Contrôle des instruments	Communication avec les équipements de test	PyVISA, python-ivi, drivers constructeur
Contrôle du montage	Engagement/désengagement du DUT	GPIO, série, contrôleurs pneumatiques
Capture de données	Enregistrement des mesures	Client TofuPilot
Interface opérateur	Scanner le numéro de série, afficher les résultats	Interface OpenHTF, GUI personnalisée

Configuration minimale d'une station

minimal_station.py

from tofupilot import TofuPilotClient
import pyvisa

# Couche instruments
rm = pyvisa.ResourceManager()
dmm = rm.open_resource("TCPIP::192.168.1.10::INSTR")
psu = rm.open_resource("TCPIP::192.168.1.11::INSTR")

# Logique de test
def run_functional_test(serial_number):
    psu.write("OUTP ON")
    vcc = float(dmm.query("MEAS:VOLT:DC?"))
    current = float(dmm.query("MEAS:CURR:DC?"))
    psu.write("OUTP OFF")

    passed = 3.25 <= vcc <= 3.35 and 30 <= current <= 60

    # Capture de données
    client = TofuPilotClient()
    client.create_run(
        procedure_id="BOARD-FUNCTIONAL",
        unit_under_test={"serial_number": serial_number},
        run_passed=passed,
        steps=[{
            "name": "Power Rails",
            "step_type": "measurement",
            "status": 3.25 <= vcc <= 3.35,
            "measurements": [
                {"name": "vcc_3v3", "value": vcc, "unit": "V", "limit_low": 3.25, "limit_high": 3.35},
                {"name": "idle_current_ma", "value": current * 1000, "unit": "mA", "limit_low": 30, "limit_high": 60},
            ],
        }],
    )
    return passed

# Interface opérateur
while True:
    serial = input("Scanner le numéro de série (ou 'q' pour quitter) : ")
    if serial.lower() == "q":
        break
    result = run_functional_test(serial)
    print(f"{'PASS' if result else 'FAIL'}")

Passer d'une station à plusieurs

Stations identiques

Lorsque vous ajoutez des stations pour le même test, gardez le code de test identique sur toutes les stations. Utilisez le même identifiant de procédure. TofuPilot distingue les stations automatiquement.

station_config.py

import socket

# Identification de la station
STATION_ID = socket.gethostname()  # Chaque PC de station a un nom d'hôte unique

# Même code de test, même procédure, station différente
client.create_run(
    procedure_id="BOARD-FUNCTIONAL",
    unit_under_test={"serial_number": serial},
    run_passed=passed,
    steps=steps,
)
# TofuPilot suit quelle station a exécuté chaque test

Différentes étapes de test

Les flux de production ont généralement plusieurs étapes de test. Chaque étape a sa propre procédure.

Ligne d'assemblage :
  Stations 1-4 : ICT (Test in-circuit)          → procédure : "ICT-V2"
  Stations 5-6 : Test fonctionnel               → procédure : "FUNC-TEST-V3"
  Station 7 :    Déverminage (burn-in)           → procédure : "BURN-IN-24H"
  Stations 8-10 : Test final                     → procédure : "FINAL-TEST-V2"

TofuPilot relie toutes les étapes de test pour un numéro de série donné, créant un historique de test de fabrication complet.

Gestion des instruments

Types d'instruments courants

Instrument	Ce qu'il mesure	Interface
Multimètre numérique (DMM)	Tension, courant, résistance	GPIB, LAN, USB
Oscilloscope	Formes d'onde, timing	LAN, USB
Alimentation	(Fournit l'alimentation, mesure la sortie)	GPIB, LAN, USB
DAQ (Acquisition de données)	Multi-voies analogiques/numériques	USB, PCIe
Analyseur de spectre	Contenu fréquentiel	GPIB, LAN
Charge électronique	(Simule les conditions de charge)	Série, LAN
Enceinte climatique	Température, humidité	Série, LAN

Patterns de connexion aux instruments

instrument_pool.py

import pyvisa

class InstrumentPool:
    """Gérer les connexions aux instruments pour une station de test."""

    def __init__(self):
        self.rm = pyvisa.ResourceManager()
        self._instruments = {}

    def get(self, name, address):
        if name not in self._instruments:
            self._instruments[name] = self.rm.open_resource(address)
        return self._instruments[name]

    def close_all(self):
        for inst in self._instruments.values():
            inst.close()

# Utilisation
pool = InstrumentPool()
dmm = pool.get("dmm", "TCPIP::192.168.1.10::INSTR")
psu = pool.get("psu", "TCPIP::192.168.1.11::INSTR")

Surveillance de l'infrastructure

Votre infrastructure de test est elle-même quelque chose qui nécessite un suivi. Les tableaux de bord de TofuPilot révèlent la santé de l'infrastructure :

Indicateur	Ce qu'il indique
FPY par station	Santé du matériel de la station
Temps de cycle par station	Performance des instruments/montages
Variance des mesures par station	Qualité des contacts du montage
Disponibilité par station	Fiabilité du PC/logiciel de test

Quand le FPY d'une station baisse alors que les autres restent stables, le problème vient de la station, pas du produit. Investiguer le montage, les instruments et le câblage.

Bonnes pratiques d'infrastructure

Pratique	Pourquoi
Versionner votre code de test	Savoir exactement quel test a été exécuté sur chaque unité
Utiliser le même identifiant de procédure sur les stations identiques	Permet la comparaison inter-stations
Stocker les dates de calibration des instruments	Savoir quand la calibration pourrait affecter les résultats
Garder les montages aussi simples que possible	Moins de pièces mobiles = moins de modes de défaillance
Surveiller le temps de cycle	C'est un indicateur de santé gratuit
Séparer la logique de test des drivers d'instruments	Changer d'instruments sans réécrire les tests
Utiliser des connexions instruments par IP	Plus fiable que l'USB pour la production

Ce que TofuPilot gère vs ce que vous gérez

TofuPilot gère	Vous gérez
Stockage et indexation des données	Code et logique de test
Tableaux de bord et analytique	Drivers d'instruments
Traçabilité et recherche	Conception et maintenance des montages
Calculs de rendement	Installation matérielle des stations
Tendances des mesures	Connectivité réseau
Comparaison inter-stations	Formation des opérateurs

TofuPilot est la couche données. Vous apportez la couche test. Ensemble, ils forment une infrastructure de test complète.

Infrastructure de test hardware avec TofuPilot