Le vrai coût de la non-qualité en électronique

Chaque unité défectueuse a un prix, et ce prix augmente à mesure que le défaut progresse dans la chaîne. Le coût de la non-qualité (COPQ) capture tout ce que vous dépensez parce que quelque chose n'a pas été bien fabriqué du premier coup. Pour la plupart des fabricants d'électronique, le COPQ représente entre 15 % et 25 % du chiffre d'affaires. La majeure partie est invisible.

Ce que le COPQ inclut

Le COPQ se divise en deux catégories : les défaillances internes (détectées avant l'expédition) et les défaillances externes (détectées par le client).

Coûts des défaillances internes

Ceux-ci surviennent à l'intérieur de votre usine. Ils sont douloureux mais contrôlables.

Coûts des défaillances externes

Ceux-ci surviennent après l'expédition du produit. C'est là que résident les vrais dégâts.

La règle 1-10-100

Cette règle, issue de la littérature sur le management de la qualité, met un ratio sur le moment où vous détectez un défaut :

• 1 $ pour la prévention. Concevoir le test, valider le processus, définir les limites. Un test OpenHTF bien écrit avec des limites de mesure appropriées ne coûte presque rien par unité à exécuter.
• 10 $ pour la détection. Détecter le défaut sur la ligne. Vous avez déjà dépensé en matière et main-d'œuvre, mais vous pouvez retoucher ou mettre au rebut avant l'expédition. C'est là que les stations de test prouvent leur valeur.
• 100 $ pour la défaillance. Le défaut atteint le client. Vous payez maintenant les retours, le service sur site, le traitement des garanties, et la confiance qui ne se facture pas.

Les ratios varient selon l'industrie. Pour les dispositifs médicaux, les coûts de défaillance externe peuvent atteindre 1 000 fois les coûts de prévention si l'on tient compte des conséquences réglementaires. En électronique grand public, c'est plus proche du modèle 1-10-100. Le principe reste le même : détectez plus tôt, payez moins.

La place de la couverture de test

La couverture de test est votre outil principal pour convertir les problèmes à 100 $ en problèmes à 10 $, et les problèmes à 10 $ en investissements à 1 $.

Les lacunes de couverture coûtent cher

Prenons un fabricant d'enceintes Bluetooth qui n'effectue qu'un test fonctionnel final. Il vérifie la sortie audio et l'appairage. Ce qu'il ne détecte pas :

• Les soudures froides qui passent à température ambiante mais échouent après cyclage thermique
• Les cellules de batterie avec une capacité légèrement faible qui meurent prématurément sur le terrain
• Le désaccord d'impédance d'antenne qui cause des problèmes de portée dans certaines orientations

Chaque lacune est une défaillance terrain en attente. Ajouter des tests ciblés à des étapes antérieures comble ces lacunes.

Structurer les tests pour détecter les défauts tôt

Une stratégie de test bien structurée pousse la détection en amont. Voici à quoi cela ressemble pour un module capteur IoT :

# Inspection d'entrée : détecter les problèmes de composants avant l'assemblage
import openhtf as htf
from tofupilot.openhtf import TofuPilot

@htf.measures(
    htf.Measurement("crystal_frequency")
        .in_range(minimum=31.990, maximum=32.010),
    htf.Measurement("sensor_ic_id_register")
        .equals(0xB5),
    htf.Measurement("flash_chip_capacity_mb")
        .equals(16),
)
def incoming_component_check(test):
    test.measurements.crystal_frequency = 32.001
    test.measurements.sensor_ic_id_register = 0xB5
    test.measurements.flash_chip_capacity_mb = 16

def main():
    test = htf.Test(incoming_component_check)
    with TofuPilot(test):
        test.execute(test_start=lambda: "IOT-2024-4401")

if __name__ == "__main__":
    main()

# Test post-assemblage : valider la qualité de soudure et le fonctionnement de base
import openhtf as htf
from openhtf.util import units
from tofupilot.openhtf import TofuPilot

@htf.measures(
    htf.Measurement("supply_current_sleep")
        .in_range(maximum=0.000050)
        .with_units(units.AMPERE),
    htf.Measurement("supply_current_active")
        .in_range(minimum=0.015, maximum=0.035)
        .with_units(units.AMPERE),
    htf.Measurement("i2c_sensor_ack")
        .equals(True),
    htf.Measurement("spi_flash_read_write_ok")
        .equals(True),
)
def post_assembly_validation(test):
    test.measurements.supply_current_sleep = 0.000028
    test.measurements.supply_current_active = 0.0243
    test.measurements.i2c_sensor_ack = True
    test.measurements.spi_flash_read_write_ok = True

def main():
    test = htf.Test(post_assembly_validation)
    with TofuPilot(test):
        test.execute(test_start=lambda: "IOT-2024-4401")

if __name__ == "__main__":
    main()

# Calibration finale et test fonctionnel
import openhtf as htf
from openhtf.util import units
from tofupilot.openhtf import TofuPilot

@htf.measures(
    htf.Measurement("temperature_accuracy")
        .in_range(minimum=-0.5, maximum=0.5)
        .with_units(units.DEGREE_CELSIUS),
    htf.Measurement("humidity_accuracy_pct")
        .in_range(minimum=-3.0, maximum=3.0),
    htf.Measurement("ble_rssi_at_1m")
        .in_range(minimum=-55, maximum=-35),
    htf.Measurement("battery_voltage")
        .in_range(minimum=3.0, maximum=4.2)
        .with_units(units.VOLT),
    htf.Measurement("ota_update_success")
        .equals(True),
)
def final_calibration_test(test):
    test.measurements.temperature_accuracy = 0.12
    test.measurements.humidity_accuracy_pct = -1.4
    test.measurements.ble_rssi_at_1m = -42
    test.measurements.battery_voltage = 3.85
    test.measurements.ota_update_success = True

def main():
    test = htf.Test(final_calibration_test)
    with TofuPilot(test):
        test.execute(test_start=lambda: "IOT-2024-4401")

if __name__ == "__main__":
    main()

Trois étapes de test, chacune détectant une classe de défaut différente. L'inspection d'entrée détecte les mauvais composants avant de les souder (correction la moins coûteuse). Le test post-assemblage détecte les défauts de procédé avant de gaspiller l'effort de calibration. Le test final détecte les problèmes au niveau système avant l'expédition.

Utiliser TofuPilot pour suivre les coûts de qualité

Vous ne pouvez pas réduire le COPQ sans le mesurer. TofuPilot vous fournit la base de données :

• FPY par procédure montre votre rendement au premier passage à chaque étape de test. Une baisse du FPY au post-assemblage signifie que votre procédé génère de la retouche. C'est le coût de défaillance interne qui grimpe.
• Analyse de Pareto des défaillances classe les mesures qui échouent le plus souvent. Cela vous indique où investir en prévention. Si 60 % des échecs sont liés à la soudure, c'est un signal clair pour améliorer votre profil de refusion ou le dépôt de pâte.
• Tendances de rendement dans le temps révèlent si la qualité s'améliore ou se dégrade. Une tendance à la baisse lente du FPY signifie que le COPQ augmente avant que quiconque ne le remarque dans les rapports financiers.
• Traçabilité unitaire relie les défaillances terrain aux données de test. Quand un client retourne une unité, vous pouvez extraire son historique de test complet et voir si elle a passé de justesse ou présentait des anomalies dans les spécifications mais proches des limites.

Réduire le COPQ en pratique

Le chemin d'un COPQ élevé à un COPQ bas suit un schéma prévisible :

1. Instrumentez votre procédé. Ajoutez des tests à chaque étape majeure de fabrication. Téléversez tout dans TofuPilot avec des numéros de série et des noms de mesure cohérents.
2. Identifiez les plus grandes pertes. Utilisez le Pareto des défaillances pour trouver les 3 principaux modes de défaillance. Ils représentent généralement 60 à 80 % de vos défaillances internes.
3. Poussez la détection en amont. Si le test final détecte un défaut, demandez-vous si un test antérieur aurait pu le détecter avant qu'une valeur supplémentaire ne soit ajoutée à l'unité.
4. Resserrez les limites de manière proactive. Utilisez les données Cpk de TofuPilot pour identifier les mesures qui passent techniquement mais dérivent vers les limites. Resserrer les contrôles de procédé avant que les échecs ne surviennent, c'est de la prévention, la catégorie la moins coûteuse.
5. Mesurez le résultat. Suivez l'amélioration du FPY dans le temps. Chaque point de pourcentage de FPY gagné se traduit directement par moins de rebut, moins de retouche et moins de défaillances terrain.