Conception pour la testabilité PCB

Les bonnes décisions de DFT prises lors du routage du PCB réduisent directement le temps de test, le coût des fixations et les défauts échappés à l'ICT, au test fonctionnel et à la programmation in-situ. Une carte difficile à sonder est difficile à tester automatiquement. Ce guide couvre les décisions mécaniques et électriques qui rendent les tests automatisés avec OpenHTF et TofuPilot réalisables.

Ce que signifie la DFT pour les PCBA

La conception pour la testabilité (DFT) est l'ensemble des décisions de routage et de schéma qui rendent un PCBA observable et contrôlable pendant les tests de fabrication.

Directives de placement des points de test

Les points de test sont l'interface entre votre carte et la fixation de test. Chaque net que vous souhaitez sonder en ICT ou test fonctionnel en nécessite un.

Exigences physiques

Placez les points de test sur une grille de 100 mil dans la mesure du possible. Les fixations à lit de clous sont construites sur cette grille.

Quels nets nécessitent des points de test

Couvrez au minimum :

• Les rails d'alimentation (VCC, VBAT, VIO, toutes les sorties de régulateurs)
• La masse (une par domaine d'alimentation)
• Les E/S numériques des microcontrôleurs et FPGA
• Les chemins de signaux analogiques (entrée et sortie)
• Les broches de l'oscillateur à quartz
• Les lignes de reset
• Les bus de communication (UART TX/RX, SPI CS/CLK/MOSI/MISO, I2C SDA/SCL)
• Les interfaces de programmation et debug (SWDIO, SWDCLK, TDI, TDO, TMS, TCK)

Règles de placement

Placez les points de test côté primaire (côté composants) dans la mesure du possible. Les fixations double face sont coûteuses et ralentissent le temps de cycle. Si un net ne route que côté verso, ajoutez un via vers le dessus avec un point de test.

Ne recouvrez pas les vias des points de test avec du vernis épargne. Les vias recouverts de vernis sont courants pour la densité mais tuent l'accès ICT.

Erreurs DFT courantes et impact sur le coût des tests

Considérations sur le Boundary Scan (JTAG)

Le boundary scan JTAG (IEEE 1149.1) teste l'interconnexion et le fonctionnement de base des composants sans fixation à lit de clous.

Pour que le JTAG fonctionne en fabrication :

• Tous les composants compatibles JTAG doivent être dans la chaîne de scan (pas de broches TAP non connectées)
• Le TDO de chaque composant se connecte au TDI du suivant
• TMS et TCK sont partagés entre tous les composants
• TRST est tiré au niveau haut avec une résistance de 10k (actif bas)
• La chaîne doit être accessible via un connecteur ou des points de test

Incluez un connecteur ARM JTAG 10 broches ou JTAG 20 broches peuplé sur les cartes EVT. Dépeuplez le connecteur sur les versions de production mais conservez l'empreinte et les points de test.

Connecteurs de programmation et interfaces de debug

De nombreux microcontrôleurs ont des broches BOOT0/BOOT1 qui sélectionnent le mode de programmation. Celles-ci doivent être contrôlables depuis la fixation de test. Ajoutez un point de test sur BOOT0.

Comment la DFT permet les tests automatisés avec OpenHTF et TofuPilot

Avec des points de test, un accès JTAG et une interface de programmation contrôlable, vous pouvez construire une fixation qui pilote le DUT à travers une séquence de test complète sans intervention humaine.

import time
import subprocess
import serial
import openhtf as htf
from tofupilot.openhtf import TofuPilot


def program_firmware(test):
    """Flasher le firmware via SWD avec pyocd."""
    result = subprocess.run(
        ["pyocd", "flash", "--target", "stm32g431rb", "firmware.hex"],
        capture_output=True,
        text=True,
        timeout=30,
    )
    test.logger.info(result.stdout)
    if result.returncode != 0:
        test.logger.error(result.stderr)
        return htf.PhaseResult.STOP


@htf.measures(
    htf.Measurement("vcc_3v3")
    .in_range(minimum=3250, maximum=3350),
    htf.Measurement("vbat")
    .in_range(minimum=3500, maximum=4200),
)
def measure_power_rails(test):
    """Sonder les points de test VCC et VBAT avec un multimètre."""
    test.measurements.vcc_3v3 = 3312  # Remplacer par la lecture réelle du DMM * 1000
    test.measurements.vbat = 3850  # Remplacer par la lecture réelle du DMM * 1000


@htf.measures(
    htf.Measurement("uart_echo_ok").equals(True),
    htf.Measurement("uart_response_time")
    .in_range(minimum=0, maximum=100),
)
def test_uart_comms(test):
    """Envoyer une commande via UART, vérifier l'écho et le temps de réponse."""
    with serial.Serial("/dev/ttyUSB0", baudrate=115200, timeout=1) as port:
        port.write(b"PING\r
")
        t0 = time.monotonic()
        response = port.readline().decode().strip()
        elapsed_ms = (time.monotonic() - t0) * 1000

    test.measurements.uart_echo_ok = response == "PONG"
    test.measurements.uart_response_time = round(elapsed_ms, 1)


def main():
    test = htf.Test(
        program_firmware,
        measure_power_rails,
        test_uart_comms,
        test_name="PCBA Functional Test",
    )

    with TofuPilot(test):
        test.execute(test_start=lambda: input("Numéro de série : "))


if __name__ == "__main__":
    main()

Chaque phase correspond à un point de test ou une interface sur la carte. program_firmware utilise le SWD. measure_power_rails utilise les points de test sur VCC et VBAT. test_uart_comms utilise le connecteur UART.

Carte bien conçue vs carte mal conçue

Checklist DFT