En el prototipo de laboratorio, tú soldabas un cabezal de pines metálicos macho (Header) a la placa para conectar tu ST-Link. En producción, soldar un componente de 5 centavos que el cliente nunca va a usar es desperdiciar dinero y espacio. En lugar del cabezal, el Arquitecto deja simples círculos planos de cobre expuesto (sin máscara antisoldante) en la parte inferior de la placa base: los Test Pads (TP).
Para conectarse a esos círculos planos sin soldar, se construye un Test Fixture o Jig. Es una estructura mecánica (generalmente de acrílico CNC) llena de Pogo Pins (Agujas retráctiles con resorte). Cuando colocas la placa y bajas una palanca mecánica, las agujas presionan firmemente los círculos de cobre, estableciendo contacto eléctrico perfecto en 1 segundo.
El protocolo Serial Wire Debug (SWD) del STM32 solo requiere 5 señales: VCC, GND, SWDIO, SWCLK, NRST. Las placas industriales no se fabrican de una en una, sino en Paneles (ej. 4 placas unidas por "Mouse Bites"). El Jig de programación está diseñado para que, al bajar la palanca, 20 Pogo Pins toquen las 4 placas simultáneamente. Un script automático inyectará el código en los 4 cerebros al mismo tiempo usando 4 programadores independientes conectados a un hub USB.
Paso 1: Diseño de Test Pads (KiCad).
En el editor de PCB, elimina el cabezal de plástico negro de pines. Agrega *Test Pads* circulares de 1.5mm de diámetro en la capa inferior de cobre (`B.Cu`), desenmascarados (sin tinta verde encima). Etiquétalos claramente en la capa de serigrafía (Silkscreen) para el diseñador del Jig.
Paso 2: Manufactura del Test Fixture (Jig).
Exportas un archivo `.dxf` desde KiCad con las posiciones X/Y exactas de tus Test Pads. Envíalo a un taller de corte láser. Cortarán bloques de acrílico y perforarán los huecos exactos. Allí insertarás los Pogo Pins (Agujas con resortes). Cuando colocas tu placa sobre la cama de acrílico y bajas la palanca articulada, las agujas tocan el cobre sin necesidad de una sola gota de soldadura.
Los operadores de la línea de ensamble no deben abrir IDEs complejos de programación. Solo deben colocar la placa, bajar la palanca y presionar un gran botón físico o la barra espaciadora en la computadora. Escribiremos un script en Python que utilice la utilidad de línea de comandos STM32_Programmer_CLI para quemar, verificar y bloquear el chip en 5 segundos.
#!/usr/bin/env python3
# =========================================================================
# prod_flash_jig.py - Sistema Automatizado de Inyección de Firmware
# Ejecuta el borrado, carga del Golden Master y aseguramiento (RDP Nivel 1).
# =========================================================================
import subprocess
import time
import sys
# Rutas y Archivos
CLI_PATH = "C:\\Program Files\\STMicroelectronics\\STM32Cube\\STM32CubeProgrammer\\bin\\STM32_Programmer_CLI.exe"
FIRMWARE_BIN = "C:\\Production\\Releases\\Mobagas_v1.0.0_Golden.bin"
FLASH_START_ADDR = "0x08000000"
def run_command(command_list, description):
"""Ejecuta un comando en la terminal y verifica el éxito."""
print(f"\n[>>>] {description}...")
try:
result = subprocess.run(command_list, capture_output=True, text=True, check=True)
print("[ OK ] Operación Exitosa.")
return True
except subprocess.CalledProcessError as e:
print(f"[ERROR] Falló la operación: {description}")
print(e.stdout) # Mostrar el error crudo del ST-Link
return False
def flash_and_secure_board():
"""Ejecuta la secuencia industrial completa."""
start_time = time.time()
print("========================================")
print(" INICIANDO SECUENCIA DE PRODUCCIÓN ")
print("========================================")
# 1. Borrado Masivo (Limpiar el chip de fábrica)
# Comando: STM32_Programmer_CLI -c port=SWD -e all
cmd_erase = [CLI_PATH, "-c", "port=SWD", "-e", "all"]
if not run_command(cmd_erase, "Borrado Masivo (Mass Erase)"): return False
# 2. Descargar Binario y Verificar
# Comando: STM32_Programmer_CLI -c port=SWD -w "archivo.bin" 0x08000000 -v
cmd_flash = [CLI_PATH, "-c", "port=SWD", "-w", FIRMWARE_BIN, FLASH_START_ADDR, "-v"]
if not run_command(cmd_flash, f"Escribiendo y Verificando {FIRMWARE_BIN}"): return False
# 3. Bloqueo Criptográfico (Option Bytes - RDP Level 1)
# Comando: STM32_Programmer_CLI -c port=SWD -ob RDP=0xBB
# 0xAA = RDP Nivel 0 (Abierto), 0xBB = RDP Nivel 1 (Seguro), 0xCC = RDP Nivel 2 (Brick)
cmd_lock = [CLI_PATH, "-c", "port=SWD", "-ob", "RDP=0xBB"]
if not run_command(cmd_lock, "Aplicando Blindaje de Propiedad Intelectual (RDP 1)"): return False
# 4. Reseteo por Hardware para iniciar el firmware
cmd_reset = [CLI_PATH, "-c", "port=SWD", "-rst"]
run_command(cmd_reset, "Reiniciando Tarjeta (Hardware Reset)")
elapsed = time.time() - start_time
print("========================================")
print(f" [ EXITO ] TARJETA LISTA EN {elapsed:.2f} SEGUNDOS ")
print("========================================")
return True
if __name__ == "__main__":
while True:
input("\n[!] Coloque la PCB en el Jig, baje la palanca y presione [ENTER] para quemar...")
success = flash_and_secure_board()
if success:
# Aquí podrías encender un LED Verde físico por GPIO o reproducir un sonido
print("\n*** RETIRE LA PLACA. PASE A LA SIGUIENTE. ***")
else:
# Emitir sonido de error. Desechar o revisar la placa.
print("\n*** [ALERTA] FALLA DE PROGRAMACIÓN. DESCARTAR PLACA. ***")
Objetivo del día: Transición a Manufactura Escalonable y Eficiencia en Tiempos de Ciclo.
El diseño de un producto no termina en la ingeniería de sus circuitos, sino en la ingeniería de su propia manufactura. Si diseñas una placa que cuesta $20 dólares fabricar pero cuesta $10 dólares programar y probar porque requiere manipulación manual intensiva, tu margen de ganancia desaparece. En el mundo industrial, el Tiempo de Ciclo (Takt Time) lo es todo.
Al diseñar los **Test Pads (TP)** en KiCad y ensamblar la **Cama de Agujas (Pogo Pins)**, eliminaste por completo la necesidad de soldaduras manuales temporales o cables frágiles. Al escribir el script de automatización en Python, extrajiste la complejidad del "Flasheo" de las manos del operador de ensamblaje. El operador simplemente coloca el panel de tarjetas, baja una palanca mecánica y presiona un botón. En 5 segundos exactos, el procesador ARM se borra, se escribe el código de calibración de metrología, se verifica bit a bit contra la corrupción de datos, y se sella criptográficamente en Nivel 1. Estás preparado para producir 100, 1,000 o 10,000 máquinas sin que el cuello de botella sea el teclado de tu computadora.
STM32_Programmer_CLI u OpenOCD, "envueltas" en scripts de Python o Bash.