Juqiao Tactile Glove Setup Guide

The Juqiao glove ships as a woven textile glove with a ribbon cable connector at the wrist. The acquisition module is a separate small PCB enclosure that handles analog-to-digital conversion and USB communication.

• Wear the glove as you would a standard glove, with the FPC connector positioned at the wrist.
• Seat the ribbon cable: Align the FPC ribbon cable from the glove's wrist connector and press it firmly into the acquisition module's ribbon receptacle. A faint click indicates a secure seat. If nodes show zero readings, the ribbon is not fully seated — see Troubleshooting below.
• Mount the module: Clip or velcro the acquisition module to a wrist strap or forearm mount so it does not interfere with wrist motion during teleoperation.
• Connect USB: Plug the acquisition module into your host PC using the supplied USB cable.

No proprietary vendor SDK is required. The acquisition module streams framed binary packets over a standard serial port — pyserial is the only dependency.

Install pyserial:

pip install pyserial

Verify the serial port is 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

Confirm live streaming (sanity check):

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

You should see a stream of binary data at the acquisition module's configured sample rate. If the terminal is silent, check the USB connection and the module LED — it should pulse at the sample rate.

The acquisition module sends fixed-length binary frames. Each frame begins with a 2-byte start delimiter 0xAA 0x55, followed by a 1-byte channel count N, N × 2 bytes of big-endian 16-bit pressure values, and a 2-byte CRC16 checksum. Total frame length = 5 + 2N bytes.

Basic frame reader — prints a list of pressure values per frame:

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

Squeeze different parts of the glove and verify that node values rise and fall. All 64 nodes should respond. If a region shows no response, re-check the ribbon cable seating at both the glove connector and the module.

Fabric sensors are subject to baseline offset from temperature variation and repeated compression. Calibrate at the start of each session for accurate readings.

• Relax the glove on a flat surface with no pressure applied — do not wear it during calibration unless you can hold your hand completely still and relaxed.
• Windows: Open the Juqiao configuration tool, select your COM port, click Connect, then navigate to Calibrate → Zero. All node baselines are set to the current resting values.
• Linux / macOS: Send the software zero command per the V2.3 protocol document, or apply a baseline subtraction in your Python bridge script (capture 50 frames at rest and subtract the mean per channel).

# 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())

The Fearless Platform at platform.roboticscenter.ai supports the Juqiao sensor as a tactile node in a teleoperation session. Pressure frames are recorded synchronously alongside robot joint states, camera streams, and other sensor modalities.

Registration sequence:

• Start a teleop session via POST /api/teleop/sessions/create-sdk with device_type: "juqiao_textile_skin".
• Open the platform WebSocket at /api/teleop/ws and send the registration handshake: role: "operator", device_type: "tactile_sensor", capabilities: ["tactile", "pressure_array", "telemetry"].
• On receiving type: "ready", begin forwarding JSONL telemetry frames from the serial reader.

JSONL emitter for the platform bridge:

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

Telemetry frame format sent to the platform 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
}

Pairing with OpenArm or DK1: In a typical teleoperation setup, three separate processes run on the host PC and each register with the same session ID — the robot arm control bridge, the Juqiao serial bridge, and camera bridges for wrist and scene views. The platform time-aligns all streams using the ts field and archives a single episode JSONL file per demonstration. During playback, the GloveWorkbench panel renders the tactile pressure heatmap alongside the arm's joint trajectory.

For a full API reference covering session creation, WebSocket handshake, and episode download, see the Platform SDK API Reference.

• No serial device on Linux: Run sudo usermod -aG dialout $USER and log out/in. Verify with lsusb that the module enumerates. On older kernels, modprobe cdc_acm may be needed.
• All pressure readings are zero: Disconnect USB, reseat the FPC ribbon at both ends (glove connector and module), then reconnect. Check the module LED — it should pulse at the configured sample rate.
• Large baseline offset on unloaded nodes: Run zero-point calibration at room temperature before the session. Allow the glove to stabilize for 1–2 minutes after putting it on.
• Frame sync errors / garbled data: Confirm baud rate is 921600. Flush the serial buffer on open: ser.reset_input_buffer(). Use read_until(HEADER) at startup to resync rather than fixed-length reads.
• Sensor nodes respond slowly or feel "sticky": Gently flex the glove across its full range of motion several times before a session. Persistent issues may indicate fiber fatigue — contact Juqiao Precision for replacement.
• Platform bridge drops frames at 200 Hz: Reduce sample rate to 100 Hz for single-glove sessions. For bimanual setups, batch both gloves into a single JSON object per tick to halve message count.