Analyser les performances des étapes

Un test qui échoue vous dit que quelque chose s'est mal passé. L'analyse au niveau des étapes vous dit exactement où. TofuPilot décompose chaque exécution par phase pour que vous puissiez identifier précisément quelles étapes échouent le plus, lesquelles prennent le plus de temps et quelles mesures sont les plus proches de leurs limites.

Pourquoi l'analyse au niveau des étapes est importante

Les taux de pass/fail globaux masquent les problèmes. Un test avec 95 % de FPY semble correct jusqu'à ce que vous découvriez qu'une phase représente 80 % de toutes les défaillances. Sans données au niveau des étapes, vous devinez où concentrer vos efforts d'amélioration.

L'analyse par étape répond à trois questions : Quelles phases ont le taux de réussite le plus bas ? Quelles mesures ont le Cpk le plus bas ? Quelles étapes prennent le plus de temps ?

Structurer les tests pour de bonnes données par étape

Chaque phase OpenHTF devient une étape dans TofuPilot. Nommez vos phases clairement et gardez chacune centrée sur un seul domaine fonctionnel. Cela rend l'analyse pertinente.

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

@htf.measures(
    htf.Measurement("input_voltage")
    .with_units(units.VOLT)
    .in_range(minimum=11.5, maximum=12.5),
    htf.Measurement("input_current")
    .with_units(units.AMPERE)
    .in_range(maximum=2.0),
)
def power_input_check(test):
    """Vérifier que l'entrée d'alimentation est dans les spécifications."""
    test.measurements.input_voltage = 12.03
    test.measurements.input_current = 1.45

@htf.measures(
    htf.Measurement("reg_3v3_output")
    .with_units(units.VOLT)
    .in_range(minimum=3.25, maximum=3.35),
    htf.Measurement("reg_5v_output")
    .with_units(units.VOLT)
    .in_range(minimum=4.90, maximum=5.10),
    htf.Measurement("reg_ripple")
    .in_range(maximum=50.0),
)
def voltage_regulator_test(test):
    """Tester tous les régulateurs de tension embarqués."""
    test.measurements.reg_3v3_output = 3.30
    test.measurements.reg_5v_output = 4.98
    test.measurements.reg_ripple = 22.4

@htf.measures(
    htf.Measurement("i2c_ack_received").with_allowed_values(True),
    htf.Measurement("spi_loopback_ok").with_allowed_values(True),
    htf.Measurement("uart_baud_error_pct")
    .in_range(maximum=2.0),
)
def communication_bus_test(test):
    """Vérifier les interfaces I2C, SPI et UART."""
    test.measurements.i2c_ack_received = True
    test.measurements.spi_loopback_ok = True
    test.measurements.uart_baud_error_pct = 0.8

@htf.measures(
    htf.Measurement("wifi_rssi")
    .in_range(minimum=-70, maximum=-20),
    htf.Measurement("bluetooth_pair_time")
    .in_range(maximum=5.0),
)
def wireless_connectivity_test(test):
    """Tester les connexions WiFi et Bluetooth."""
    test.measurements.wifi_rssi = -45
    test.measurements.bluetooth_pair_time = 2.3

@htf.measures(
    htf.Measurement("flash_write_speed")
    .in_range(minimum=10.0),
    htf.Measurement("flash_read_speed")
    .in_range(minimum=20.0),
    htf.Measurement("eeprom_verify_ok").with_allowed_values(True),
)
def memory_test(test):
    """Vérifier les performances de lecture/écriture de la flash et de l'EEPROM."""
    test.measurements.flash_write_speed = 14.2
    test.measurements.flash_read_speed = 28.7
    test.measurements.eeprom_verify_ok = True

def main():
    test = htf.Test(
        power_input_check,
        voltage_regulator_test,
        communication_bus_test,
        wireless_connectivity_test,
        memory_test,
    )
    with TofuPilot(test):
        test.execute(test_start=lambda: "BOARD-042")

if __name__ == "__main__":
    main()

Ce test comporte cinq phases distinctes, chacune couvrant un sous-système différent. TofuPilot suit les taux de réussite, les distributions de mesures et les temps d'exécution pour chacune indépendamment.

Trouver vos étapes les plus faibles

Dans la vue d'analyse par étape de TofuPilot, triez les phases par taux de réussite pour trouver les maillons faibles. Une phase avec un taux de réussite de 92 % dans un test à cinq phases domine vos pertes de rendement global.

Examinez les mesures au sein de cette phase. Une mesure avec un Cpk inférieur à 1,0 signifie que la variation de votre procédé est trop large pour les spécifications. Soit vous resserrez le procédé, soit vous élargissez les spécifications si le produit peut le tolérer.

Identifier les étapes lentes

Les données de temps par étape révèlent les goulots d'étranglement. Si votre test de connectivité sans fil prend 8 secondes sur un total de 12 secondes, c'est là qu'il faut concentrer la réduction du temps de cycle.

Correctifs courants pour les étapes lentes : réduire le nombre de tentatives, paralléliser les mesures indépendantes, ou optimiser la communication avec les instruments (requêtes par lots au lieu de lectures séquentielles).

Utiliser les données par étape pour prioriser

Combinez le taux de réussite, le Cpk et le temps d'exécution en une liste priorisée. Une étape qui échoue souvent et s'exécute lentement est la cible à plus fort impact. Une étape avec un Cpk élevé et une exécution rapide ne nécessite aucune attention.

L'analytique des mesures de TofuPilot affiche tout cela par phase. Consultez-la chaque semaine pour vérifier si vos améliorations de procédé font réellement évoluer les chiffres.