La plupart des équipes hardware commencent par suivre les résultats de test dans Excel ou Google Sheets. Cela fonctionne un temps, puis ça ne fonctionne plus. Vous perdez la visibilité en temps réel, ne pouvez pas gérer les accès simultanés et la saisie manuelle introduit des erreurs qui s'accumulent avec le temps.
TofuPilot remplace ce workflow par une collecte de données de test structurée et automatisée. Vous continuez à écrire vos tests en Python, et TofuPilot gère le stockage, l'analytique et la traçabilité.
Le modèle tableur
Un journal de test Excel typique ressemble à ceci :
| Numéro de série | Date | Opérateur | Résultat | Tension (V) | Courant (A) | Firmware | Notes |
|---|---|---|---|---|---|---|---|
| SN-001 | 2025-01-15 | Alice | PASS | 3,31 | 0,52 | v2.1 | |
| SN-002 | 2025-01-15 | Bob | FAIL | 3,58 | 0,89 | v2.1 | Dépassement de limite de courant |
| SN-003 | 2025-01-16 | Alice | PASS | 3,29 | 0,48 | v2.1 |
Ce format pose de vrais problèmes à grande échelle :
- Pas d'accès simultané. Deux opérateurs ne peuvent pas enregistrer des résultats en même temps sans risquer des écrasements ou des conflits de fusion.
- Pas de validation. Rien n'empêche quelqu'un de saisir « PSAS » au lieu de « PASS » ou de mettre la tension dans la colonne du courant.
- Pas d'analytique. Calculer le FPY, le Cpk ou les tendances de défaillance nécessite des formules fragiles ou des tableaux croisés dynamiques qui cassent quand la structure du tableur change.
- Pas d'historique. Quand quelqu'un modifie une cellule, la valeur originale est perdue. Vous n'avez pas de piste d'audit.
L'équivalent OpenHTF + TofuPilot
Voici le même test exprimé sous forme de test OpenHTF avec intégration TofuPilot. Chaque exécution est automatiquement structurée, validée et stockée.
import openhtf as htf
from openhtf.util import units
from tofupilot.openhtf import TofuPilot
@htf.measures(
htf.Measurement("voltage").with_units(units.VOLT).in_range(3.1, 3.5),
htf.Measurement("current").with_units(units.AMPERE).in_range(maximum=0.7),
)
def power_supply_check(test):
voltage = 3.31 # Lire depuis votre instrument
current = 0.52
test.measurements.voltage = voltage
test.measurements.current = current
def main():
test = htf.Test(power_supply_check)
with TofuPilot(test):
test.execute(test_start=lambda: "SN-001")
if __name__ == "__main__":
main()Chaque exécution capture automatiquement le numéro de série, le résultat pass/fail, chaque mesure avec ses limites, les horodatages et l'identité de la station de test. Pas de saisie manuelle. Pas d'erreurs de copier-coller.
Ce qui change quand vous basculez
| Fonctionnalité | Excel / Google Sheets | TofuPilot |
|---|---|---|
| Saisie des données | Manuelle, sujette aux erreurs | Automatique depuis le code de test |
| Accès simultané | Verrouillage de fichier, conflits de fusion | Multi-utilisateur, multi-station par défaut |
| Validation des mesures | Aucune | Limites appliquées au moment du test |
| FPY et tendances de rendement | Formules manuelles | Tableau de bord intégré, temps réel |
| Cpk et SPC | Nécessite des macros personnalisées | Cartes de contrôle automatiques |
| Analyse des défaillances | Filtrage manuel | Pareto des défaillances, analyse détaillée par station |
| Piste d'audit | Pas d'historique | Historique complet des révisions par exécution |
| Recherche et filtrage | Ctrl+F | Filtrer par numéro de série, station, date, résultat, lot |
| Accès API | Aucun | API REST pour les intégrations |
Conserver vos données existantes
Si vous avez des données de test historiques dans des tableurs que vous souhaitez préserver, vous pouvez les importer via l'API REST de TofuPilot. Structurez chaque ligne comme une exécution de test avec des mesures et envoyez-la via POST à l'API.
import csv
from tofupilot import TofuPilotClient
client = TofuPilotClient()
with open("test_results.csv") as f:
reader = csv.DictReader(f)
for row in reader:
client.create_run(
procedure_id="power-board-test",
unit_under_test={"serial_number": row["Serial Number"]},
run_passed=row["Result"] == "PASS",
steps=[
{
"name": "power_supply_check",
"step_passed": row["Result"] == "PASS",
"measurements": [
{
"name": "voltage",
"measured_value": float(row["Voltage (V)"]),
"unit": "V",
"lower_limit": 3.1,
"upper_limit": 3.5,
},
{
"name": "current",
"measured_value": float(row["Current (A)"]),
"unit": "A",
"upper_limit": 0.7,
},
],
}
],
)Exécutez cela une fois pour importer votre historique, puis passez tous les nouveaux tests au workflow OpenHTF.
Ce que vous obtenez dans le tableau de bord
Une fois que vos tests rapportent à TofuPilot, ouvrez le tableau de bord sur tofupilot.app. Vous y trouverez :
- Tendances FPY entre les stations et les périodes, calculées automatiquement.
- Histogrammes de mesures avec Cpk et cartes de contrôle pour chaque mesure que vous définissez.
- Pareto des défaillances montrant quelles mesures échouent le plus souvent et sur quelles stations.
- Débit par station pour voir quelles lignes fonctionnent et lesquelles sont inactives.
- Traçabilité complète par numéro de série, avec chaque exécution de test, mesure et révision liées.
Ce sont les analyses que vous construiriez autrement avec des tableaux croisés dynamiques, des macros VBA ou des scripts personnalisés. Elles se mettent à jour en temps réel à mesure que de nouvelles exécutions arrivent.
Exécuter les deux systèmes en parallèle
Vous n'êtes pas obligé de basculer du jour au lendemain. Un parcours de migration pratique :
- Choisissez une station de test et ajoutez l'intégration TofuPilot à ses tests OpenHTF.
- Faites fonctionner les deux systèmes pendant une semaine. Continuez à enregistrer dans le tableur pendant que TofuPilot collecte les mêmes données automatiquement.
- Comparez les résultats pour gagner en confiance que rien n'est perdu.
- Déployez sur les stations restantes une fois que vous êtes satisfait.
Le tableur reste comme sauvegarde jusqu'à ce que vous soyez prêt à le retirer. Aucune donnée n'est en danger pendant la transition.