Guía de Configuración del Guante Táctil Juqiao

El guante Juqiao se envía como un guante de tela tejido con un conector de cable plano en la muñeca. El módulo de adquisición es un pequeño recinto de PCB separado que maneja la conversión de analógico a digital y la comunicación USB.

• Usa el guante como lo harías con un guante estándar, con el conector FPC posicionado en la muñeca.
• Asiente el cable de cinta: Alinee el cable de cinta FPC del conector de la muñeca del guante y presiónelo firmemente en el receptáculo de cinta del módulo de adquisición. Un clic suave indica un asiento seguro. Si los nodos muestran lecturas cero, la cinta no está completamente asentada — consulte la solución de problemas a continuación.
• Monte el módulo: Sujete o use velcro para fijar el módulo de adquisición a una correa de muñeca o soporte de antebrazo para que no interfiera con el movimiento de la muñeca durante la teleoperación.
• Conecte USB: Conecte el módulo de adquisición a su PC host utilizando el cable USB suministrado.

No se requiere SDK de proveedor propietario. El módulo de adquisición transmite paquetes binarios enmarcados a través de un puerto serial estándar — pyserial es la única dependencia.

Instalar pyserial:

pip install pyserial

Verifique que el puerto serial sea visible:

# Linux
ls /dev/ttyUSB* /dev/ttyACM*

# macOS
ls /dev/tty.usbserial-*

# Or use pyserial's port listing tool
python -m serial.tools.list_ports

Confirme la transmisión en vivo (verificación de cordura):

# Replace /dev/ttyUSB0 with your port; 921600 is the default baud rate
python -m serial.tools.miniterm /dev/ttyUSB0 921600

Debería ver un flujo de datos binarios a la tasa de muestreo configurada del módulo de adquisición. Si la terminal está en silencio, verifique la conexión USB y el LED del módulo — debería parpadear a la tasa de muestreo.

El módulo de adquisición envía marcos binarios de longitud fija. Cada marco comienza con un delimitador de inicio de 2 bytes 0xAA 0x55, seguido de un conteo de canales de 1 byte N, N × 2 bytes de valores de presión de 16 bits en big-endian, y un checksum CRC16 de 2 bytes. Longitud total del marco = 5 + 2N bytes.

Lector de marcos básico — imprime una lista de valores de presión por marco:

import serial, struct, time

BAUD = 921600
PORT = "/dev/ttyUSB0"   # /dev/tty.usbserial-* on macOS, COMx on Windows
HEADER = b"\xaa\x55"

def read_frame(ser: serial.Serial, n_channels: int) -> list[int] | None:
    # Sync to frame header
    buf = ser.read(2)
    if buf != HEADER:
        ser.read_until(HEADER[-1:])
        return None
    raw = ser.read(1 + n_channels * 2 + 2)
    n = raw[0]
    if n != n_channels:
        return None
    pressures = list(struct.unpack_from(f">{n}H", raw, 1))
    # CRC check omitted for brevity — validate in production
    return pressures

with serial.Serial(PORT, BAUD, timeout=0.1) as ser:
    N = 64   # number of sensing nodes — confirm from spec doc
    while True:
        frame = read_frame(ser, N)
        if frame:
            print(frame)   # list of N 16-bit pressure values

Aprieta diferentes partes del guante y verifica que los valores de los nodos suban y bajen. Los 64 nodos deberían responder. Si una región no muestra respuesta, revisa la conexión del cable plano tanto en el conector del guante como en el módulo.

Los sensores de tela están sujetos a un desplazamiento de línea base por variación de temperatura y compresión repetida. Calibra al inicio de cada sesión para lecturas precisas.

• Relaja el guante sobre una superficie plana sin presión aplicada — no lo uses durante la calibración a menos que puedas mantener tu mano completamente quieta y relajada.
• Windows: Abre la herramienta de configuración Juqiao, selecciona tu puerto COM, haz clic Conectar, luego navega a Calibrar → Cero. Todos los valores de línea base de los nodos se establecen en los valores de reposo actuales.
• Linux / macOS: Envía el comando de cero del software según el documento del protocolo V2.3, o aplica una sustracción de línea base en tu script de puente de Python (captura 50 marcos en reposo y resta la media por canal).

# Simple software baseline subtraction (Linux/macOS alternative)
import serial, struct, numpy as np

BAUD, PORT, N = 921600, "/dev/ttyUSB0", 64
HEADER = b"\xaa\x55"

def read_frame(ser):
    ser.read_until(HEADER)
    raw = ser.read(1 + N * 2 + 2)
    return list(struct.unpack_from(f">{N}H", raw, 1))

with serial.Serial(PORT, BAUD, timeout=0.1) as ser:
    ser.reset_input_buffer()
    baseline = np.mean([read_frame(ser) for _ in range(50)], axis=0)
    print("Baseline captured. Starting calibrated stream...")
    while True:
        frame = read_frame(ser)
        if frame:
            calibrated = np.maximum(0, np.array(frame) - baseline)
            print(calibrated.astype(int).tolist())

La Plataforma Sin Miedo en platform.roboticscenter.ai soporta el sensor Juqiao como un nodo táctil en una sesión de teleoperación. Los marcos de presión se registran de manera sincrónica junto con los estados de las articulaciones del robot, flujos de cámara y otras modalidades de sensor.

Secuencia de registro:

• Iniciar una sesión de teleop a través de POST /api/teleop/sessions/create-sdk estafa device_type: "juqiao_textile_skin".
• Abrir el WebSocket de la plataforma en /api/teleop/ws y enviar el apretón de manos de registro: role: "operator", device_type: "tactile_sensor", capabilities: ["tactile", "pressure_array", "telemetry"].
• Al recibir type: "ready", comenzar a reenviar marcos de telemetría JSONL desde el lector serial.

Emisor JSONL para el puente de la plataforma:

import serial, struct, time, json, sys

PORT = "/dev/ttyUSB0"
BAUD = 921600
N_CHANNELS = 64
HEADER = b"\xaa\x55"

def read_frame(ser):
    buf = ser.read_until(HEADER)
    if not buf.endswith(HEADER):
        return None
    raw = ser.read(1 + N_CHANNELS * 2 + 2)
    pressures = list(struct.unpack_from(f">{N_CHANNELS}H", raw, 1))
    return pressures

with serial.Serial(PORT, BAUD, timeout=0.05) as ser:
    while True:
        frame = read_frame(ser)
        if frame:
            record = {
                "ts": int(time.time() * 1000),
                "device": "juqiao_textile_skin",
                "variant": "high_frequency_v2.3",
                "pressures": frame,   # flat list, N_CHANNELS values
                "n_channels": N_CHANNELS
            }
            print(json.dumps(record), flush=True)  # JSONL for platform bridge

Formato de marco de telemetría enviado al WebSocket de la plataforma:

{
  "type": "telemetry",
  "member_id": "juqiao-glove-right",
  "device": "juqiao_textile_skin",
  "variant": "high_frequency_v2.3",
  "pressures": [0, 512, 1024, ...],   // flat array, N_CHANNELS 16-bit values
  "n_channels": 64,
  "ts": 1743680400123                  // Unix millisecond timestamp
}

Emparejamiento con OpenArm o DK1: En una configuración típica de teleoperación, tres procesos separados se ejecutan en la PC host y cada uno se registra con el mismo ID de sesión — el puente de control del brazo robótico, el puente serial Juqiao y los puentes de cámara para vistas de muñeca y escena. La plataforma alinea temporalmente todos los flujos utilizando el ts campo y archiva un único archivo JSONL por demostración. Durante la reproducción, el panel GloveWorkbench renderiza el mapa de calor de presión táctil junto con la trayectoria de las articulaciones del brazo.

Para una referencia completa de la API que cubre la creación de sesiones, el apretón de manos de WebSocket y la descarga de episodios, consulte el Referencia de API del SDK de la plataforma.

• No hay dispositivo serial en Linux: Ejecutar sudo usermod -aG dialout $USER y cerrar sesión/iniciar sesión. Verifique con lsusb que el módulo enumere. En núcleos más antiguos, modprobe cdc_acm puede ser necesario.
• Todas las lecturas de presión son cero: Desconecte USB, vuelva a colocar el cable FPC en ambos extremos (conector de guante y módulo), luego vuelva a conectar. Verifique el LED del módulo: debería parpadear a la tasa de muestreo configurada.
• Gran desplazamiento de línea base en nodos no cargados: Realice la calibración del punto cero a temperatura ambiente antes de la sesión. Permita que el guante se estabilice durante 1-2 minutos después de ponérselo.
• Errores de sincronización de tramas / datos distorsionados: Confirme que la velocidad en baudios sea 921600. Vacíe el búfer serial al abrir: ser.reset_input_buffer(). Use read_until(HEADER) al inicio para resincronizar en lugar de lecturas de longitud fija.
• Los nodos de sensor responden lentamente o se sienten "pegajosos": Flexione suavemente el guante a través de su rango completo de movimiento varias veces antes de una sesión. Problemas persistentes pueden indicar fatiga de fibra: contacte a Juqiao Precision para un reemplazo.
• El puente de la plataforma pierde tramas a 200 Hz: Reduzca la tasa de muestreo a 100 Hz para sesiones de guante único. Para configuraciones bimanuales, agrupe ambos guantes en un solo objeto JSON por tick para reducir a la mitad el conteo de mensajes.