Gérer la certification des opérateurs

Comment gérer la certification des opérateurs avec TofuPilot

Un nouvel opérateur exécute un test de travers et met au rebut trois cartes avant que quiconque ne s'en aperçoive. Cela arrive plus souvent qu'il ne le faudrait. La plupart des équipes suivent la certification des opérateurs dans des tableurs qui deviennent obsolètes le jour même de leur création.

TofuPilot vous permet de lier l'identité de l'opérateur à chaque exécution de test et d'imposer les exigences de certification au niveau de la station.

Pourquoi le suivi des opérateurs est important

Les industries réglementées l'exigent. L'ISO 13485 (dispositifs médicaux), l'AS9100 (aérospatiale) et l'IATF 16949 (automobile) imposent toutes que les opérateurs soient formés et qualifiés pour les tâches qu'ils effectuent. Mais même sans pression réglementaire, savoir qui a exécuté quel test est important quand vous investiguez une baisse de rendement.

Prérequis

Un compte TofuPilot
Python 3.8+ avec tofupilot installé
Une méthode d'authentification des opérateurs (scan de badge, connexion ou code-barres)

Étape 1 : Capturer l'identité de l'opérateur sur chaque exécution

L'approche la plus simple est d'enregistrer l'opérateur comme propriété de l'exécution :

operator_tracking.py

from tofupilot import TofuPilotClient

client = TofuPilotClient()

operator_id = input("Scannez le badge opérateur : ")

result = client.create_run(
    procedure_id="pcba-fct-v2",
    unit_under_test={
        "serial_number": dut_serial,
        "part_number": "PCB-100-R4",
    },
    run_passed=True,
    properties={
        "operator_id": operator_id,
        "operator_name": get_operator_name(operator_id),
        "station_id": "ST-04",
    },
)

Chaque exécution a désormais un opérateur associé. Vous pouvez filtrer et analyser par opérateur dans le tableau de bord TofuPilot.

Étape 2 : Construire une vérification de certification de l'opérateur

Avant d'autoriser l'exécution d'un test, vérifiez que l'opérateur est certifié pour cette procédure :

certification_check.py

import json
from pathlib import Path

# Données de certification (peuvent aussi provenir d'une API ou d'une base de données)
CERT_FILE = Path("operator_certs.json")

def load_certifications():
    """Charge les registres de certification des opérateurs."""
    if CERT_FILE.exists():
        return json.loads(CERT_FILE.read_text())
    return {}

def is_certified(operator_id: str, procedure_id: str) -> bool:
    """Vérifie si l'opérateur est certifié pour une procédure de test spécifique."""
    certs = load_certifications()
    operator = certs.get(operator_id, {})
    procedures = operator.get("certified_procedures", [])
    return procedure_id in procedures

def require_certification(operator_id: str, procedure_id: str):
    """Bloque l'exécution du test si l'opérateur n'est pas certifié."""
    if not is_certified(operator_id, procedure_id):
        raise PermissionError(
            f"L'opérateur {operator_id} n'est pas certifié pour {procedure_id}. "
            f"Contactez votre responsable de ligne."
        )

Exemple de fichier de certification :

operator_certs.json

{
  "OP-001": {
    "name": "Jane Chen",
    "certified_procedures": ["pcba-fct-v2", "motor-fct", "burn-in-48h"],
    "certification_date": "2026-01-15",
    "expiry_date": "2027-01-15"
  },
  "OP-002": {
    "name": "Mike Torres",
    "certified_procedures": ["pcba-fct-v2"],
    "certification_date": "2026-02-01",
    "expiry_date": "2027-02-01"
  }
}

Étape 3 : Intégrer à votre séquence de test

Connectez la vérification de certification au démarrage de votre test :

certified_test.py

import openhtf as htf
from tofupilot import TofuPilotClient
from certification_check import require_certification

PROCEDURE_ID = "pcba-fct-v2"

def test_start(test):
    """Scanne le badge opérateur et vérifie la certification avant le test."""
    operator_id = input("Scannez le badge opérateur : ")

    # Bloquer les opérateurs non certifiés
    require_certification(operator_id, PROCEDURE_ID)

    test.state["operator_id"] = operator_id
    test.dut_id = input("Scannez le numéro de série du DUT : ")

def main():
    test = htf.Test(
        functional_tests,
        power_tests,
    )

    test.add_output_callbacks(
        TofuPilotClient().as_openhtf_callback(
            procedure_id=PROCEDURE_ID,
        )
    )

    test.execute(test_start=htf.PhaseDescriptor.wrap(test_start))

Étape 4 : Suivre l'expiration des certifications

Les certifications expirent. Construisez une vérification simple qui avertit avant l'expiration et bloque après :

cert_expiry.py

from datetime import date, timedelta

def check_certification_status(operator_id: str, procedure_id: str):
    """Vérifie la validité de la certification avec avertissement anticipé."""
    certs = load_certifications()
    operator = certs.get(operator_id)

    if not operator:
        raise PermissionError(f"Opérateur inconnu : {operator_id}")

    if procedure_id not in operator.get("certified_procedures", []):
        raise PermissionError(
            f"{operator['name']} n'est pas certifié pour {procedure_id}"
        )

    expiry = date.fromisoformat(operator["expiry_date"])
    today = date.today()

    if today > expiry:
        raise PermissionError(
            f"Certification expirée le {expiry}. Recertification requise."
        )

    days_remaining = (expiry - today).days
    if days_remaining < 30:
        print(f"ATTENTION : La certification expire dans {days_remaining} jours")

    return True

Étape 5 : Analyser les performances des opérateurs

Avec les données d'opérateur sur chaque exécution, vous pouvez répondre aux questions importantes :

Rendement par opérateur : Un opérateur est-il systématiquement plus bas ? Il a peut-être besoin d'une formation complémentaire.
Durée de test par opérateur : Les opérateurs plus lents suivent peut-être les procédures plus soigneusement, ou ont des difficultés avec l'équipement.
Modes de défaillance par opérateur : Si un opérateur rencontre davantage un type de défaillance spécifique, vérifiez sa technique.

operator_analysis.py

from tofupilot import TofuPilotClient
from collections import defaultdict

client = TofuPilotClient()

runs = client.get_runs(
    procedure_id="pcba-fct-v2",
    limit=1000,
)

# Regrouper par opérateur
operator_stats = defaultdict(lambda: {"pass": 0, "fail": 0})

for run in runs:
    op = run.properties.get("operator_id", "unknown")
    if run.passed:
        operator_stats[op]["pass"] += 1
    else:
        operator_stats[op]["fail"] += 1

for op_id, stats in operator_stats.items():
    total = stats["pass"] + stats["fail"]
    fpy = stats["pass"] / total * 100
    print(f"Opérateur {op_id} : {fpy:.1f}% FPY ({total} exécutions)")

Notes de conformité réglementaire

Norme	Exigence	Solution TofuPilot
ISO 13485	Registres de formation documentés, évaluation des compétences	Identifiant opérateur sur chaque exécution, vérification de certification
AS9100	Personnel qualifié pour les tâches assignées	Porte de certification avant le test
IATF 16949	Efficacité de la formation évaluée	Analyse du rendement par opérateur
FDA 21 CFR 820	Formation du personnel documentée	Piste d'audit complète avec identité de l'opérateur

L'essentiel est que chaque exécution de test soit liée à un opérateur certifié, et que ce lien soit immuable dans votre historique de test.