La báscula que era una Raspberry
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:
- Transporte: abrir un puerto serial y mover bytes. Sirve igual para
/dev/ttyGS0en la Pi, para el puerto que ve la computadora y para un puerto virtual en las pruebas. Por el gadget USB los 9600 baudios no se aplican: el puerto se configura así porque es lo que la aplicación espera abrir, pero los bytes viajan a la velocidad del USB. - Protocolo: la
Py la trama+12.5. Nada más. - Comportamiento: qué peso hay y cómo se porta la báscula: peso fijo o que fluctúa, y un modo de fallas.
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:
- El del emulador: en la Pi, desde que recibe la
Phasta que la respuesta terminó de salir. - El de la aplicación: en la computadora, desde antes de mandar la
Phasta recibir la respuesta completa. Incluye el USB, el hub y la lectura del sistema operativo.
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
- El terminador y los campos adicionales del protocolo original.
- La desconexión física del cable, medida de verdad. Hace falta un adaptador que corte la corriente y deje pasar los datos.
- Windows: cómo se llama el puerto COM, si pide controlador y si cambia al reconectar. El proyecto original lo contemplaba, pero no lo tengo documentado, y aquí no lo medí.
- Otros hubs, otros cables, otras computadoras. Todo esto es un solo montaje.
Lo que haría
- Separar transporte, protocolo y comportamiento desde el primer día. Así el mismo motor sirve para otra interfaz u otro protocolo.
- Probar la reconexión, los tiempos límite y la validación del lado de la aplicación, con un modo de fallas que se pueda repetir.
- Medir aparte al emulador y a la aplicación, cada uno con su reloj.
- No guardar el nombre del puerto: buscarlo cada vez que se abre.
- Tratar cualquier error del puerto como una desconexión, no sólo los que ya conoces.
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.