Guide de configuration des gants tactiles Juqiao

Le gant Juqiao est livré sous forme de gant en textile tissé avec un connecteur de câble plat au poignet. Le module d'acquisition est un petit boîtier PCB séparé qui gère la conversion analogique-numérique et la communication USB.

• Portez le gant comme vous le feriez avec un gant standard, avec le connecteur FPC positionné au niveau du poignet.
• Installez le câble ruban : Alignez le câble ruban FPC du connecteur du poignet du gant et enfoncez-le fermement dans le réceptacle ruban du module d'acquisition. Un léger clic indique un siège sécurisé. Si les nœuds affichent des valeurs nulles, le ruban n'est pas complètement inséré — voir Dépannage ci-dessous.
• Montez le module : Attachez ou velcroz le module d’acquisition à une dragonne ou à un support d’avant-bras afin qu’il n’interfère pas avec le mouvement du poignet pendant la téléopération.
• Connectez USB : Branchez le module d'acquisition sur votre PC hôte à l'aide du câble USB fourni.

Aucun SDK de fournisseur propriétaire n'est requis. Le module d'acquisition diffuse des paquets binaires encadrés sur un port série standard : pyserial est la seule dépendance.

Installez pyserial :

pip install pyserial

Vérifiez que le port série est 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

Confirmer la diffusion en direct (vérification d'intégrité) :

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

Vous devriez voir un flux de données binaires à la fréquence d'échantillonnage configurée par le module d'acquisition. Si le terminal est silencieux, vérifiez la connexion USB et le voyant du module : il doit clignoter à la fréquence d'échantillonnage.

Le module d'acquisition envoie des trames binaires de longueur fixe. Chaque trame commence par un délimiteur de début de 2 octets 0xAA 0x55, suivi d'un nombre de canaux N sur 1 octet, N × 2 octets de valeurs de pression big-endian sur 16 bits et d'une somme de contrôle CRC16 sur 2 octets. Longueur totale de la trame = 5 + 2N octets.

Lecteur d'images de base : imprime une liste de valeurs de pression par image :

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

Pressez différentes parties du gant et vérifiez que les valeurs des nœuds montent et descendent. Les 64 nœuds devraient répondre. Si une région ne montre aucune réponse, vérifiez à nouveau le positionnement du câble ruban au niveau du connecteur du gant et du module.

Les capteurs en tissu sont soumis à un décalage de base dû aux variations de température et aux compressions répétées. Calibrez au début de chaque session pour des lectures précises.

• Détendez le gant sur une surface plane sans aucune pression — ne le portez pas pendant l'étalonnage à moins que vous puissiez tenir votre main complètement immobile et détendue.
• Fenêtres : Ouvrez l'outil de configuration Juqiao, sélectionnez votre port COM, cliquez sur Connecter, puis accédez à Calibrer → Zéro. Toutes les lignes de base de nœuds sont définies sur les valeurs au repos actuelles.
• Linux/MacOS : Envoyez la commande zéro du logiciel conformément au document du protocole V2.3 ou appliquez une soustraction de base dans votre script de pont Python (capturez 50 images au repos et soustrayez la moyenne par 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 plateforme intrépide sur platform.roboticscenter.ai prend en charge le capteur Juqiao comme nœud tactile dans une session de téléopération. Les images de pression sont enregistrées de manière synchrone aux côtés des états des articulations du robot, des flux de caméra et d'autres modalités de capteur.

Séquence d'inscription :

• Démarrez une session téléop via POST /api/teleop/sessions/create-sdk avec device_type: "juqiao_textile_skin".
• Ouvrez la plateforme WebSocket à l'adresse /api/teleop/ws et envoyez la poignée de main d'inscription : role: "operator", device_type: "tactile_sensor", capabilities: ["tactile", "pressure_array", "telemetry"].
• A la réception type: "ready", commencez à transférer les trames de télémétrie JSONL à partir du lecteur série.

Émetteur JSONL pour le pont de plateforme :

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

Format de la trame de télémétrie envoyée à la plateforme WebSocket :

{
  "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
}

Couplage avec OpenArm ou DK1 : Dans une configuration de téléopération typique, trois processus distincts s'exécutent sur le PC hôte et chacun s'enregistre avec le même ID de session : le pont de commande du bras du robot, le pont série Juqiao et les ponts de caméra pour les vues du poignet et de la scène. La plateforme aligne temporellement tous les flux à l'aide du ts champ et archive un seul fichier JSONL d’épisode par démonstration. Pendant la lecture, le panneau GloveWorkbench restitue la carte thermique de pression tactile le long de la trajectoire de l'articulation du bras.

Pour une référence complète de l'API couvrant la création de session, la prise de contact WebSocket et le téléchargement d'épisodes, consultez le Référence de l'API du SDK de plateforme.

• Pas de périphérique série sous Linux : Courir sudo usermod -aG dialout $USER et déconnectez-vous/connectez-vous. Vérifiez avec lsusb que le module énumère. Sur les noyaux plus anciens, modprobe cdc_acm peut être nécessaire.
• Toutes les lectures de pression sont nulles : Déconnectez l'USB, réinstallez le ruban FPC aux deux extrémités (connecteur à gants et module), puis reconnectez-le. Vérifiez la LED du module : elle doit clignoter à la fréquence d'échantillonnage configurée.
• Grand décalage de la ligne de base sur les nœuds déchargés : Exécutez l’étalonnage du point zéro à température ambiante avant la séance. Laissez le gant se stabiliser pendant 1 à 2 minutes après l'avoir enfilé.
• Erreurs de synchronisation d'image/données tronquées : Confirmez que le débit en bauds est de 921600. Videz le tampon série à l'ouverture : ser.reset_input_buffer(). Utiliser read_until(HEADER) au démarrage pour resynchroniser plutôt que des lectures de longueur fixe.
• Les nœuds capteurs réagissent lentement ou semblent « collants » : Fléchissez doucement le gant sur toute son amplitude de mouvement plusieurs fois avant une séance. Des problèmes persistants peuvent indiquer une fatigue des fibres – contactez Juqiao Precision pour un remplacement.
• Le pont de plate-forme supprime les images à 200 Hz : Réduisez la fréquence d’échantillonnage à 100 Hz pour les sessions avec un seul gant. Pour les configurations bimanuelles, regroupez les deux gants dans un seul objet JSON par tick pour réduire de moitié le nombre de messages.