Device Parameters & Calibration

Reading Parameters

Read device properties through the semantic API:

sn = glove.sn().get()                # Serial number
version = glove.version().get()      # Firmware version
hand_side = glove.hand_side().get()  # Hand side ("left" or "right")
ip = glove.ip().get()                # IP address
port = glove.port().get()            # Data port

Writing Parameters

Some parameters support writing:

glove.ip().set("192.168.1.100")     # Change IP address
glove.port().set(50001)             # Change data port

Device Operations

Parameter persistence, reboot, and other device operations vary by product. For Wuji Glove, see Wuji Glove device operations.

SDK User Management

When several operators share the same device, calibration and local parameters from one operator overwrite another's. The SDK keeps a local user profile per operator at ~/.wuji/sdk/users/<user_id>/, isolating each user's parameter and calibration files.

Without a named user, parameter files and tactile calibration land in ~/.wuji/sdk/params/ and ~/.wuji/sdk/tactile/ directly, and pose calibration isn't available at all. Create a named user when you need to isolate by operator, or when you need pose calibration:

from wuji_sdk import SdkManager

manager = SdkManager.instance()

# Create a user
alice = manager.create_user("Alice", description="right-hand operator")

# Switch to a specific user
manager.switch_user(alice["user_id"])

# Inspect the current user
print(manager.current_user())

# List all users
for user in manager.list_users():
    marker = "*" if user["is_default"] else " "
    print(f"{marker} {user['display_name']} ({user['user_id']})")

# Switch back to the default user
manager.switch_to_default_user()

Switching reloads calibration parameters for connected devices immediately, no reconnect needed. Deleting the current user automatically switches back to the default user.

User Data Export and Import

Pack everything an SDK user owns into a single zip file to back it up or move it to another host. A bundle holds the user's hand calibration models, the tactile model for each device, and the latest complete tactile calibration run.

# Export: write everything the user owns into one zip file
report = manager.export_user_data(alice["user_id"], "alice.zip")
print(report["out_path"], report["device_sns"])

# Preview: validate a bundle and list its contents without writing anything
preview = manager.preview_user_data("alice.zip")
print(preview["owner_display_name"], preview["created_at"])
for component in preview["components"]:
    print(component["name"], component["state"], component.get("reason"))

# Import: restore the bundle to the user who created it
result = manager.import_user_data("alice.zip")
print(result["owner_user_id"], result["imported_at"])

All three methods return a report dict whose components list the state of each component:

Import behavior:

• The owner recorded in the bundle is created if it doesn't exist, and the current user stays the same
• Every present component that isn't skipped is written and overwrites that user's existing file
• Skipping wins over writing: a skipped component is never written and never overwrites an existing file, and its state in the report is skipped. Hand models are skipped this way when the owner is the default user (which doesn't load local hand calibration), while the other components are still written
• Validation (path safety, size caps, sha256, data format, and owner id) finishes before anything is written. Any failure raises an exception and leaves no file behind

Tactile Data Paths

The tactile model is trained in Wuji Studio tactile contact calibration. Models and calibration data are scoped by SDK user and device serial number:

model/ holds the trained tactile model (contact.safetensors and contact.npz), and calibration-data/ holds the raw calibration runs, one subdirectory per run. A complete run has one data file per guided motion, 4 in total. Export takes the latest complete run only.

sn = "WG1JA00XXXXXXXXX"

print(manager.tactile_dir(alice["user_id"], sn))
print(manager.tactile_model_paths(alice["user_id"], sn))  # dir / safetensors / npz
print(manager.tactile_run_dir(alice["user_id"], sn))

Calibration

Calibration fits the SDK's algorithms to a specific physical device. The results are written to SDK-local parameter and model files and loaded automatically when the device subscribes to them.

Calibration files are scoped by the current SDK user first, then split into three resource types:

Parameter files and the tactile directory are still keyed by device serial number. The tactile directory holds the trained model under model/ and the latest calibration run under calibration-data/.

The pose hand URDF is stored per SDK user and hand side only (such as left_hand.urdf / right_hand.urdf), without the serial number or hand-profile dimension, so any device of the same side under the same user shares one model. The default user has no pose hand model at all: calibration and import never write one, and real-time IK always falls back to the built-in default. For Wuji Glove specifics, see Wuji Glove Calibration.

Switching the SDK user reloads the matching files for connected devices automatically, no reconnect required.

For Wuji Glove, see Wuji Glove Calibration for the calibration procedure and APIs.

Available Parameters

For Wuji Glove, see Wuji Glove available parameters.

Listing All Resources

List all available resources, parameters, and topics on a device:

# All resources
for res in glove.resources():
    print(res.path)

# Read/write parameters
for param in glove.params():
    print(param.path)

# Subscribable topics
for topic in glove.topics():
    print(topic.path)