Contrôler les soudures sans les détruire

Une soudure de puissance est une résistance d'une fraction de milliohm, et une soudure défectueuse en fait quelques milliohms. Ce guide montre comment mesurer cet écart sur chaque unité par une chute de tension 4 fils à courant modéré, la comparer à une référence établie sur une unité étalon, et enregistrer chaque soudure comme une mesure avec limites dans une procédure TofuPilot.

Pourquoi mesurer la chute de tension

Une soudure de résistance R parcourue par un courant I fait chuter une tension V = I × R. La méthode consiste à imposer un courant connu dans la soudure et à mesurer cette tension directement à ses bornes. Avec des valeurs d'exemple pour un fil de forte section soudé sur une pastille d'ESC :

La chute est calculée par V = I × R et la chaleur par P = I² × R. Deux propriétés rendent ce niveau de courant adapté à la production :

• Le signal est grand. 2 mV contre 20 mV, c'est un facteur dix, bien au-dessus de la résolution d'un voltmètre différentiel précis.
• Le test ne modifie pas la soudure. Quelques dizaines de milliwatts ne produisent aucun échauffement mesurable, la mesure est donc non destructive et répétable.

Un moniteur de puissance INA228, utilisé comme voltmètre différentiel sur son entrée shunt, dispose d'un ADC 20 bits avec un LSB de 312,5 nV sur la gamme ±163,84 mV. Une chute de 2 mV représente 6 400 LSB. Pour de faibles volumes, un multimètre de table 6,5 digits avec compensation d'offset est une alternative.

Pourquoi pas un rodage à fort courant

Faire passer le courant de vol complet, ou plus, dans les soudures pour faire céder les plus faibles est parfois proposé comme tri. Ce n'est pas une pratique industrielle :

La mesure non destructive détecte le défaut par sa résistance, sans solliciter la soudure. Les contraintes mécaniques et thermiques relèvent d'une étape de déverminage (ESS) maîtrisée, suivie d'une nouvelle mesure identique.

Prérequis

• Le CLI TofuPilot installé sur le poste de test
• Un gabarit Kelvin : une source de courant constant (quelques ampères), un multiplexeur à relais ou à MOSFET pour sélectionner la soudure, et un voltmètre différentiel comme l'INA228, pilotés par un microcontrôleur sur un port série
• Une unité étalon, dont les soudures ont été validées par micro-section ou par un long historique terrain, et un lot d'unités de production réputées bonnes
• Le fil de chaque soudure accessible par le gabarit : testez avant le montage des moteurs et du connecteur batterie, ou via des connecteurs d'accouplement

Étape 1 : construire le gabarit Kelvin

La mesure Kelvin utilise deux paires de contacts séparées. L'une transporte le courant (force), l'autre mesure la tension (mesure). La paire de mesure ne transporte presque aucun courant, la résistance de contact de ses pointes n'apparaît donc pas dans la lecture.

Pour un fil soudé sur une pastille :

Le courant ne traverse alors que le fil, la soudure et le cuivre de la pastille, jamais l'étage de puissance de l'ESC. La lecture couvre exactement ce qui se trouve entre les deux contacts de mesure, leur position doit donc être identique sur chaque unité : des pointes à ressort (pogo pins) dans un nid usiné ou imprimé en 3D apportent cette répétabilité. Vérifiez le courant nominal des pointes de force ; on met plusieurs pointes en parallèle ou une pince quand une seule ne suffit pas.

Étape 2 : écrire le plug du gabarit

Dans cet exemple, le microcontrôleur du gabarit accepte quatre commandes ASCII sur la liaison série : SEL <channel>, CUR <amps>, I? (courant mesuré en ampères) et V? <samples> (tension de mesure moyennée en microvolts). Le protocole est celui de votre firmware ; adaptez le plug en conséquence.

import serialclass KelvinFixture:    def __init__(self, port, baudrate=115200):        self._ser = serial.Serial(port, baudrate, timeout=2)    def _query(self, command):        self._ser.write((command + "").encode())        reply = self._ser.readline().decode().strip()        if not reply or reply.startswith("ERR"):            raise RuntimeError(f"Fixture command {command!r} failed: {reply!r}")        return reply    def select(self, channel):        self._query(f"SEL {channel}")    def set_current(self, amps):        self._query(f"CUR {amps:.3f}")    def read_current(self):        return float(self._query("I?"))    def read_sense_uv(self, samples):        return float(self._query(f"V? {samples}"))    def __del__(self):        # Ne jamais laisser la source de courant active entre deux runs.        try:            self._query("CUR 0")        except Exception:            pass        self._ser.close()

Ajoutez la dépendance série à la procédure :

pyserial>=3.5

Étape 3 : écrire la phase de mesure

Une seule fonction mesure n'importe quelle soudure. Le canal vient du bloc with: de la phase, le YAML déclare donc une phase par soudure et réutilise le même code.

import timeSETTLE_S = 0.05def measure_joint(kelvin, measurements, log, channel, current_a=4.0, samples=64):    kelvin.select(channel)    # Lecture à courant nul : la f.é.m. thermoélectrique aux contacts et    # l'offset de l'amplificateur sont de l'ordre du microvolt, comme le signal.    kelvin.set_current(0.0)    time.sleep(SETTLE_S)    offset_uv = kelvin.read_sense_uv(samples)    kelvin.set_current(current_a)    try:        time.sleep(SETTLE_S)        loaded_uv = kelvin.read_sense_uv(samples)        actual_a = kelvin.read_current()    finally:        kelvin.set_current(0.0)    drop_mv = (loaded_uv - offset_uv) / 1000.0    measurements.drop_mv = drop_mv    measurements.resistance_mohm = drop_mv / actual_a  # mV / A = mΩ    log.info(f"Channel {channel}: {drop_mv:.3f} mV at {actual_a:.3f} A")

Soustraire la lecture à courant nul élimine les offsets qui ne dépendent pas du courant. Diviser par le courant mesuré, et non par la consigne, retire la tolérance de la source de courant de la résistance.

Étape 4 : déclarer la procédure

name: ESC Power Joint Screeningversion: 1.0.0execution:  workers: 1plugs:  - name: Kelvin Fixture    key: kelvin    python: plugs.kelvin:KelvinFixture    scope: station    with:      port: "COM4"setup:  - name: Fixture Reference Check    key: fixture_check    python: phases.joints:measure_joint    with:      channel: 15    measurements:      - name: Reference Shunt Resistance        key: resistance_mohm        unit: mΩ        validators:          - operator: ">="            expected_value: 0.98          - operator: "<="            expected_value: 1.02main:  - name: Battery Positive Joint    key: joint_bat_pos    python: phases.joints:measure_joint    with:      channel: 0    measurements:      - name: Voltage Drop        key: drop_mv        unit: mV        validators:          - operator: ">="            expected_value: 0.5          - operator: "<="            expected_value: 3.0      - name: Joint Resistance        key: resistance_mohm        unit: mΩ  - name: Battery Negative Joint    key: joint_bat_neg    python: phases.joints:measure_joint    with:      channel: 1    measurements:      - name: Voltage Drop        key: drop_mv        unit: mV        validators:          - operator: ">="            expected_value: 0.5          - operator: "<="            expected_value: 3.0      - name: Joint Resistance        key: resistance_mohm        unit: mΩ  - name: Motor 1 Phase A Joint    key: joint_m1_a    python: phases.joints:measure_joint    with:      channel: 2    measurements:      - name: Voltage Drop        key: drop_mv        unit: mV        validators:          - operator: ">="            expected_value: 0.5          - operator: "<="            expected_value: 4.0      - name: Joint Resistance        key: resistance_mohm        unit: mΩ

Un ESC 4-en-1 compte deux soudures batterie et douze soudures de phase moteur. Ajoutez une phase par soudure, avec son canal et ses limites. Les points importants de ce fichier :

• execution: workers: 1 exécute les phases l'une après l'autre. Sans cela, les phases sans depends_on démarrent en parallèle et se disputeraient le multiplexeur.
• La phase de setup mesure un shunt de précision de 1,000 mΩ monté sur le gabarit, sur le canal 15. Des pointes usées ou un fil de mesure desserré font échouer ce contrôle avant qu'une seule unité ne soit jugée.
• scope: station garde le port série ouvert d'une unité à l'autre.
• Les limites sont propres à chaque soudure. Les pastilles batterie et de phase n'ont pas la même géométrie de cuivre, leurs références diffèrent donc. Les valeurs indiquées sont des exemples pour un courant de test de 4 A.
• Une limite basse détecte une lecture proche de zéro, signe de pointes de mesure qui se touchent ou qui ne touchent pas la pièce.

Étape 5 : fixer les limites à partir d'une unité étalon

Les limites viennent des données, en deux passes :

1. Répétabilité du gabarit. Mesurez l'unité étalon 30 fois, en la retirant et en la remettant en place à chaque fois. La dispersion de chaque soudure correspond au bruit de mesure du gabarit. Une étude R&R avec plusieurs opérateurs formalise cette étape.
2. Référence de production. Mesurez chaque soudure sur un lot d'unités réputées bonnes, 30 ou plus. Pour chaque soudure, calculez la moyenne et l'écart-type de la chute de tension.

Un point de départ courant est une limite haute à la moyenne de référence plus un nombre fixe d'écarts-types, ou un rapport fixe à l'unité étalon (par exemple 1,5 fois sa valeur). Ce sont deux règles d'exemple : le facteur dépend de l'écart entre la population défectueuse et la population saine sur votre produit. Une fois la production lancée, affinez les limites avec la méthode de Définir des limites de mesure à partir des données de production.

Mesurez à nouveau l'unité étalon au début de chaque équipe. Une dérive de ses lectures est un problème de gabarit, pas de soudure.

Étape 6 : analyser les résultats dans TofuPilot

Lancez la procédure avec tofupilot run pendant le développement, puis déployez-la sur le poste. Chaque run enregistre la chute de tension et la résistance de chaque soudure avec le numéro de série de l'unité. Dans le dashboard :

Les raisons pour lesquelles ces soudures cèdent sur le terrain, et les changements de procédé qui l'évitent, sont traités dans Pourquoi les soudures d'ESC cèdent en vol. Une mesure statique ne trouve pas toutes les fissures : ajoutez la mesure sous flexion décrite dans Détecter les contacts intermittents en production.

Pièges courants

Mesure 2 fils. La résistance de contact d'une pointe à ressort est typiquement de quelques dizaines de milliohms, plus que la soudure. Sans contacts de mesure séparés, la lecture suit l'usure des pointes.

Ignorer l'offset à courant nul. La f.é.m. thermoélectrique aux contacts entre métaux différents ajoute des microvolts indépendants du courant. Mesurez à courant nul et soustrayez.

Diviser par la consigne de courant. Une source spécifiée à 1 % décale chaque résistance de 1 %. Mesurez le courant réel.

Des phases en parallèle sur un seul gabarit. Sans workers: 1 ou des depends_on enchaînés, deux phases peuvent sélectionner des canaux différents en même temps.

Une seule limite pour toutes les soudures. Les pastilles batterie et de phase ont des références différentes. Une limite commune est trop large pour l'une et trop serrée pour l'autre.

Des contacts de mesure placés différemment sur chaque unité. La lecture inclut le cuivre entre les contacts de mesure. Fixez leur position avec un nid rigide.

Augmenter le courant pour avoir plus de signal. Au-delà de quelques ampères, les pointes de force chauffent et s'usent, et la soudure commence à chauffer. Moyennez plus d'échantillons à la place.

Points clés

• Une chute de tension 4 fils à quelques ampères distingue une soudure de 0,5 mΩ d'une soudure de 5 mΩ sans la solliciter.
• Les contacts de force et de mesure doivent être séparés, les contacts de mesure au plus près du ménisque et à position fixe.
• Soustrayez la lecture à courant nul et divisez par le courant mesuré.
• Vérifiez le gabarit sur un shunt de référence dans une phase de setup avant de mesurer des unités.
• Fixez des limites par soudure à partir de la répétabilité du gabarit et d'une référence d'unités saines, puis affinez-les avec les données de production.
• Le rodage à fort courant est destructif, dangereux et ne produit aucune donnée. Ce n'est pas un tri.