RC G1 Guante táctil <unk> Configuración de Linux
Utilice el RC G1 Tactile Glove en Ubuntu, Debian o cualquier Linux moderno. La GUI del proveedor es solo Windows / macOS.
En Linux se habla con el guante directamente a través de la serie USB utilizando un protocolo binario documentado
Detección táctil Tiempo total: aproximadamente 45 minutos Dificultad: Intermedio Actualizado mayo 2026
** Probado en:** Ubuntu 22.04, Ubuntu 24.04, Debian 12, Fedora 40. Kernel 5.4 o más reciente tiene el controlador
Lo que lograrás
Al final de esta guía tendrá un pipeline de Linux en funcionamiento: el guante fluye a través de la serie USB o Bluetooth a un dispositivo estable
Pre-requisitos
- Hardware: RC G1 Táctil Guante, módulo de adquisición de datos (cargado), USB-A Bluetooth dongle o USB-A a cable USB-C cable de serie cableado.
- OS: cualquier distribución Linux en el kernel 5.4 o más reciente. Esta guía está escrita contra Ubuntu 22.04 / 24.04, Debian 12 y Fedora 40.
- Habilidades: cómodo con la concha,
T20 , y leer Python corto.
Los pasos
Confirme que el controlador del núcleo está presente
Los núcleos modernos de Linux (5.4+) agrupan
```bash
dmesg | tail -20
```
Deberías ver una línea como:
```bash
[ 1234.567890] usb 1-2: ch341-uart converter now attached to ttyUSB0
```
Si no lo ve, instale el paquete de módulos adicionales:
```bash
# Ubuntu / Debian
sudo apt install -y linux-modules-extra-$(uname -r)
# Fedora
sudo dnf install kernel-modules-extra
```
Luego desconecta, reconecta y vuelve a comprobar
Añadirte al grupo de diálogo
En Debian y Ubuntu, el dispositivo en serie es propiedad de
```bash
sudo usermod -aG dialout $USER
```
Luego log out y log back in, o ejecuta
```bash
serial.serialutil.SerialException: [Errno 13] Permission denied: '/dev/ttyUSB0'
```
En Fedora el grupo equivalente es
Instalar una regla determinista de udev (opcional pero recomendada)
Sin una regla udev, el núcleo asigna
```bash
sudo tee /etc/udev/rules.d/99-rc-g1-glove.rules >/dev/null <<'EOF'
# RC G1 Tactile Glove — CH340 serial (WCH 1a86:7523)
SUBSYSTEM=="tty", ATTRS{idVendor}=="1a86", ATTRS{idProduct}=="7523", MODE="0660", GROUP="dialout", SYMLINK+="rc-g1-glove-%n"
EOF
```
Recargar las reglas:
```bash
sudo udevadm control --reload-rules && sudo udevadm trigger
```
Ahora su dispositivo aparece como
emparejar por Bluetooth usando BlueZ (camino opcional)
Si prefieres usar el dongle inalámbrico en lugar de un cable USB, conecta el dongle en
```bash
sudo apt install -y screen
screen /dev/rc-g1-glove-0 921600
```
Dentro de la sesión
```bash
AT+SCAN=1
# → +SCAN=2,3C8A1F2E9A36,-1,23,JQ-RH_3C:8A:1F:2E:9A:36 ← copy this MAC
AT+CONN=3C8A1F2E9A36
# → OK (and then binary sensor data starts streaming — exit screen with Ctrl-A k)
```
El firmware anuncia uno de
** Nota BlueZ:** no necesita
Instalar dependencias de Python
La instalación en todo el sistema funciona, pero un virtualv mantiene las cosas ordenadas:
```bash
python3 -m venv ~/.venv/rc-g1
source ~/.venv/rc-g1/bin/activate
pip install pyserial numpy
```
Si prefiere una instalación del sistema:
```bash
python3 -m pip install --user pyserial numpy
```
Python 3.9 o más reciente es necesario.
- Escriba al lector
Crea
```python
#!/usr/bin/env python3
"""Minimal serial reader for the RC G1 Tactile Glove.
Frame format (per vendor protocol spec, v1.2):
[Header 4B: 0xAA 0x55 0x03 0x99]
[Packet seq 1B: 0x01 or 0x02]
[Sensor type 1B: 0x01=LH, 0x02=RH, 0x03=LF, 0x04=RF, 0x05=WB]
[Payload]
seq 0x01: 128 bytes — first 128 of 256 raw pressure values (8-bit ADC each)
seq 0x02: 144 bytes — last 128 pressure values + 16 bytes IMU (4 floats: w, x, y, z quaternion)
Two packets together = one full frame (256 pressure points, of which 162 are physically wired
to fabric sensors; the remaining slots read ~0 and can be masked). Wired streaming = 100 Hz,
Bluetooth = 30 Hz.
"""
import argparse, struct, sys, time
import serial
import numpy as np
HEADER = b"\xAA\x55\x03\x99"
SENSOR_NAMES = {0x01: "LH", 0x02: "RH", 0x03: "LF", 0x04: "RF", 0x05: "WB"}
def read_frame(port: serial.Serial):
# Sync to header
buf = b""
while True:
buf += port.read(1)
if buf.endswith(HEADER):
break
if len(buf) > 4096:
raise IOError("lost sync — no header in 4 KB")
seq, sensor = port.read(1), port.read(1)
if not seq or not sensor:
raise IOError("short read on header trailer")
seq, sensor = seq[0], sensor[0]
payload_len = 128 if seq == 0x01 else 144
payload = port.read(payload_len)
if len(payload) != payload_len:
raise IOError(f"short payload: got {len(payload)}/{payload_len}")
return seq, sensor, payload
def main():
ap = argparse.ArgumentParser()
ap.add_argument("--port", default="/dev/rc-g1-glove-0")
ap.add_argument("--baud", type=int, default=921600)
args = ap.parse_args()
with serial.Serial(args.port, args.baud, timeout=1) as port:
print(f"Reading from {args.port} @ {args.baud}…", file=sys.stderr)
half = None
t0, n = time.time(), 0
while True:
seq, sensor, payload = read_frame(port)
if seq == 0x01:
half = payload # stash first half
continue
if seq != 0x02 or half is None:
continue
# Combine the two halves
raw = np.frombuffer(half + payload[:128], dtype=np.uint8) # 256 pressure pts
imu = struct.unpack("<ffff", payload[128:144]) # quaternion w,x,y,z
n += 1
if n % 100 == 0:
hz = n / (time.time() - t0)
side = SENSOR_NAMES.get(sensor, hex(sensor))
peak = int(raw.max())
print(f"[{side}] frames={n} rate={hz:5.1f} Hz peak={peak:3d}/255 quat={imu}",
file=sys.stderr)
if __name__ == "__main__":
main()
```
¿Qué quieres decir ?
python3 reader.py --port /dev/rc-g1-glove-0
Debe ver una línea de estado cada 100 cuadros que muestre la velocidad de muestra. Preme un dedo y vea
(Opcional) ejecutarse como un servicio de sistema
Para las implementaciones sin cabeza
```bash
[Unit]
Description=RC G1 Tactile Glove reader (%i)
After=local-fs.target
[Service]
Type=simple
User=robotics
ExecStart=/home/robotics/.venv/rc-g1/bin/python /home/robotics/rc-g1-glove/reader.py --port /dev/%i
Restart=on-failure
RestartSec=2
[Install]
WantedBy=multi-user.target
```
Habilitar y iniciar:
```bash
sudo systemctl daemon-reload
sudo systemctl enable --now rc-g1-reader@rc-g1-glove-0.service
```
Sigue los registros:
```bash
journalctl -u rc-g1-reader@rc-g1-glove-0.service -f
```
La plantilla
Enlazar en la plataforma de datos RC
El lector imprime el estado a stderr y (en producción) escribe los marcos a stdout en cualquier formato que desee.
```bash
pip install centeros-cli
centeros auth login
python reader.py --port /dev/rc-g1-glove-0 | centeros stream --hardware rc-g1-tactile-glove --operator-id <you>
```
El CLI maneja la autenticación, retest, y carga en pedazos en el ingest WebSocket de la plataforma. Ver la [SDK quickstart]
Ejemplos de diseño de cuadros y ROS 2
El lector anterior produce, por cada marco completo, una matriz plana de valores de presión de 256 elementos
Para la integración de ROS 2, envuelve
** Verificación de la inteligencia de salida:** 100 Hz x (256 bytes de presión + 16 bytes IMU + 12 bytes de encuadre) = ~28 KB/s por mano. El CH340 a 921600 baud tiene ~115 KB/s de ancho de banda utilizable, por lo que la transmisión por cable de mano única utiliza aproximadamente una cuarta parte del enlace.
Solución de problemas
No aparece
Lector se ejecuta a 50 Hz en lugar de 100 Hz: usted está en Bluetooth (30 Hz nominal; algunos hosts miden ~50 Hz incluyendo retries).
Frames decode basura / IMU quaternion es NaN: verifique que el baud es
** Dos guantes conectados, sólo una corriente:** comprobar que la regla udev de la etapa 3 está produciendo dos enlaces simbólicos (
¿Qué hacer ahora?
Una vez que una sola mano esté transmitiendo de manera confiable, los próximos pasos de alto valor son: (1) calibrar la línea de base de presión por canal registrando 5 segundos de una mano ociosa y restando la media, (2) subir la segunda mano y verificar ambos flujos simultáneamente en la plataforma, y (3) grabar un conjunto de datos etiquetado utilizando el modo de episodio del CLI de los centeros