crtdrops
NOTA · ESPAÑOL ·

La báscula que era una Raspberry

Dos líneas de tiempo vistas desde la Mac, con su reloj, durante tres cortes de 5 segundos por software: el puerto USB de la Pi desaparece entre 5.4 y 5.6 segundos cada vez, y la aplicación queda sin poder pedir el peso entre 5.5 y 6.0 segundos.

Hace tiempo tuve que integrar una aplicación con una báscula comercial que se conectaba por un puerto serial USB. La idea era no depender siempre del aparato físico para avanzar con la integración.

Así que puse en su lugar una Raspberry Pi Zero 2 W en modo gadget USB: la Pi se presenta ante la computadora como un dispositivo serial, y la computadora no sabe que detrás hay una Raspberry. Ve un puerto, manda una P y recibe un peso.

No necesitábamos que la Raspberry pesara nada. Necesitábamos que hablara como una báscula.

Ese proyecto no tiene un error de la aplicación documentado que el emulador haya encontrado, y no voy a inventarlo. Lo que sí hice ahora fue volver a construir el emulador como lo haría hoy, correrlo en una Pi Zero 2 W de verdad y medir qué pasa cuando la báscula falla.

Todas las mediciones de esta nota son del 30 de octubre de 2026: una Raspberry Pi Zero 2 W (Raspberry Pi OS sobre Debian 13, kernel 6.18) en modo gadget, montada en un adaptador USB-A y conectada a un hub USB-C de una MacBook Pro (macOS 27). El protocolo es genérico, con la forma del de la báscula original, sin su marca. Las cifras son de este montaje: otra computadora, otro hub u otro sistema operativo tendrán otros números.

Lo que dice el protocolo, y lo que no

El protocolo documentado de la báscula es corto: serial a 9600 baudios, 8 bits, sin paridad, 1 bit de parada (9600 8N1). La computadora manda el carácter ASCII P y la báscula contesta el peso en ASCII. En la versión experimental tenía la forma +12.5.

Aquella versión, además, mandaba el peso sola cada 5 segundos, sin que se lo pidieran. Eso era para pruebas: no todos los modelos transmiten solos, y el emulador nuevo lo tiene como opción apagada.

Hay dos cosas que no tengo confirmadas del protocolo original: el terminador exacto de cada respuesta y si había campos adicionales. El emulador termina cada respuesta con \r\n. Es un supuesto mío, y lo marco así en el código.

Ese hueco importa más de lo que parece. El emulador verifica el comportamiento que modelamos, no lo que desconocemos del dispositivo original.

Tres capas

El emulador está separado en tres partes, cada una sin saber de las otras:

El modo de fallas tiene seis acciones: contestar normal, contestar tarde, no contestar, mandar media trama, mandar una trama con el formato roto y cerrar el puerto. Se piden con un guion o al azar con una semilla, para que una corrida se pueda repetir:

python3 emulador.py --puerto /dev/ttyGS0 --guion "normal*5,tardia:800,sin_respuesta,incompleta,invalida"

Todo es Python con la biblioteca estándar: corre en la Pi Zero sin instalar nada. Tiene 25 pruebas que no necesitan hardware; las de consulta ponen el emulador de un lado de un puerto virtual y la aplicación del otro.

Dos mediciones que no se mezclan

Hay dos tiempos distintos, y conviene no sumarlos ni restarlos:

Cada uno se mide con el reloj de su equipo. Con 1,000 consultas, una cada décima de segundo:

mediana p95 máximo
Emulador (Pi) 0.16 ms 0.29 ms 0.35 ms
Aplicación (Mac) 0.47 ms 0.66 ms 0.94 ms

Las 1,000 regresaron un peso válido. Ojo con lo que mide esto: es el emulador por USB, no una báscula. Una báscula real a 9600 baudios tardaría al menos unos 7 ms sólo en transmitir los 7 bytes de la trama, más lo que tarde en medir, que no conozco.

Cuando la báscula falla

Luego, 300 consultas con fallas al azar (semilla fija), con probabilidad de 10 % de respuesta tardía (800 ms), 5 % sin respuesta, 5 % de trama incompleta y 5 % de trama con el formato roto. La aplicación espera hasta 1 segundo.

El emulador Veces La aplicación vio Mediana (Mac)
normal 210 correcta 0.52 ms
tarde 41 correcta 800 ms
nada 21 sin respuesta 1.0 s
+12 13 incompleta 1.0 s
+1?.5 15 inválida 0.5 ms

Las 300 se clasificaron como lo que eran. Pero hay dos cosas que no se ven en un contador de errores.

Las 41 respuestas tardías cuentan como correctas. Si sólo cuentas aciertos, la báscula se ve perfecta. Lo que las delata es la latencia: las correctas tienen una mediana de 0.55 ms y un p95 de 800 ms.

Y una trama incompleta cuesta lo mismo que el silencio. En los dos casos esta aplicación espera el límite entero, porque lee hasta el terminador con un solo límite y no sabe si lo que falta viene en camino. La trama rota, en cambio, se detecta en medio milisegundo.

La desconexión

Desconectar una báscula de verdad es sacar el cable. Con la Pi eso tiene un problema: el mismo adaptador que lleva los datos le da la corriente. Si lo sacas, la Pi se apaga de golpe, y eso no es una báscula desconectada.

Tampoco sirve la acción del emulador que cierra su puerto: el enlace USB sigue arriba, y la computadora ve silencio, no un puerto que desaparece.

Así que probé de dos formas.

Con el cable, y una fuente aparte

Le puse una fuente al puerto de corriente de la Pi para que siguiera prendida y desenchufé el adaptador a mano. El primer desenchufe se vio bien: la Mac perdió el puerto. Pero al reconectar, la Mac ya no vio la Pi, y después tampoco el hub, en ningún puerto. Sin la Pi, el hub volvió a aparecer.

Lo más probable es que la Pi estuviera alimentando al hub al revés: en la Zero, el puerto de corriente y el de datos comparten la misma línea de 5 V. Sólo confirmé que la Pi era la que lo tumbaba; el mecanismo no lo comprobé, y no repetí la prueba para no arriesgar meterle voltaje al puerto de la Mac.

Hubo otro detalle: durante toda esa prueba, la Pi siguió diciendo que estaba conectada. En ese montaje, la Zero no se enteró de que la computadora se había ido.

Por software

Con la Pi alimentada otra vez sólo por el adaptador, un script le pide al controlador USB que suelte la línea 5 segundos y la retome. Para la Mac es un desenchufe: el puerto desaparece y vuelve. Tres cortes, con 20 segundos entre uno y otro.

La primera corrida tuvo una sorpresa. El cliente de prueba del laboratorio, el que hace de aplicación para medir, libró el primer corte y se cayó entero en el segundo.

En el primero, la primera llamada que notó que el puerto ya no estaba fue una lectura o una escritura, y ese error estaba cubierto. En el segundo fue la que vacía el búfer antes de preguntar. Esa llamada lanza otro tipo de error (termios.error) que no se parece a los demás, y nadie lo atrapaba. Que una aplicación sobreviva o no depende del instante exacto en que se va el cable.

def _termios(fn, *args):
    try:
        return fn(*args)
    except termios.error as e:
        raise OSError(*e.args) from e

Con eso, la segunda corrida libró los tres cortes. La Pi soltó la línea 5.0 s cada vez:

Corte 1 2 3
Mac sin puerto 5.59 s 5.65 s 5.44 s
Aplicación ciega 6.04 s 6.04 s 5.54 s
Pi: volver a estar configurada 0.36 s 0.43 s 0.22 s

Las dos primeras filas se miden con el reloj de la Mac; la tercera, con el de la Pi, desde que retoma la línea.

2,997 consultas correctas y tres marcadas como desconectadas, una por corte. La primera consulta después de cada regreso trajo el peso correcto.

Con cortes de 5 segundos, la aplicación queda ciega entre medio segundo y algo más de un segundo más que esos 5. Una parte es lo que tarda el USB en volver a presentarse. La otra es su propio intervalo de reintento, de medio segundo.

Esta vez la Pi sí se enteró de cada caída: el controlador USB pasó a «no conectado» y Linux le colgó el puerto al emulador. El controlador también marca cuándo la computadora la vuelve a reconocer. El emulador, leyendo su puerto, no lo sabe: lo reabre y espera.

Lo que no está en el protocolo

Hay detalles que ningún manual de báscula trae.

En macOS, el puerto se llamó cu.usbmodem1301, luego cu.usbmodem21301 y luego cu.usbmodem11301: cambió cuando desconecté todo y lo volví a armar, y cuando moví el hub a otra entrada de la Mac. En los tres cortes por software, en cambio, volvió con el mismo nombre. Una aplicación que guarda el nombre del puerto se rompe con algo tan simple como mover un cable.

En el proyecto original, abrir el puerto en macOS con screen falló con $TERM too long; se arregló con TERM=xterm. Las dificultades no siempre están en el protocolo. A veces están en las herramientas con las que lo pruebas.

Lo que no sabemos

Lo que haría

El emulador, el cliente, las pruebas y los datos de todas las corridas están en el repositorio.

Una buena simulación no reemplaza las pruebas con hardware real. Pero permite llegar a ellas con muchas menos incertidumbres.

Israel Negrete Lepe es ingeniero en electrónica. Veinticinco años haciendo que sistemas distintos funcionen juntos en condiciones reales: del sensor, el vehículo o la transacción al backend, los datos, la seguridad y la operación. Hoy, cada vez más, IA en el borde. Acepto proyectos por hora o por entrega: israel0negrete@gmail.com.