Product Introduction

Wuji Hand

Product Overview

Wuji Hand is a bionic dexterous hand with 20 active degrees of freedom developed by WUJI TECH, designed for various application scenarios such as scientific research, robot integration, and human-computer interaction.

Product Parameters

The Wuji Hand core technical parameters table covers structural design, drive control, load performance, dynamic response, and electrical characteristics for product selection, simulation modeling, and application integration.

Product Structural Features

This section introduces the overall structural design of Wuji Hand, communication and power interface layout, as well as the naming conventions and motion parameters of each degree of freedom, helping users understand the mechanical structure and usage specifications of the product.

Structural Schematic

Wuji Hand adopts a five-finger bionic structural design, with each finger containing multiple joints for flexible motion. The figure below shows the overall structure and main components:

• A to E in the figure correspond to:
  • A: Thumb
  • B: Index
  • C: Middle
  • D: Ring
  • E: Little
• Numbers 1 to 5 correspond to commonly used anatomical region identifications:
  • 1: Distal phalanges
  • 2: Intermediate phalanges
  • 3: Proximal phalanges
  • 4: Metacarpals
  • 5: Carpals

Wuji Hand DOF Configuration

The figure below shows the anatomical naming and corresponding positional relationships of each joint of Wuji Hand, helping users understand the functional positioning of each degree of freedom.

Numbers 1 to 6 in the figure correspond to:

• 1: CMC1
• 2: CMC2
• 3: MCP1
• 4: MCP2
• 5: PIP
• 6: DIP

DOF Motion Direction and Range

The four-finger structure is consistent, with a single finger full length of approximately 157 mm. The thumb module structure is slightly different, with a single finger full length of approximately 130 mm. The figure below uses the thumb and little finger as examples to illustrate the motion direction and angle range of each degree of freedom:

• Thumb
  • 1: Carpometacarpal abduction/adduction, motion range approximately 100°
  • 2: Carpometacarpal lateral swing, motion range approximately 80°
  • 3: Flexion/extension, motion range approximately 130°
  • 4: Flexion/extension, motion range approximately 130°
• Little Finger
  • 1: Flexion/extension, motion range approximately 125°
  • 2: Lateral swing, motion range approximately 60°
  • 3: Flexion/extension, motion range approximately 130°
  • 4: Flexion/extension, motion range approximately 130°

Communication and Power Interface Schematic

Wuji Hand achieves data communication with the host computer through a USB-C interface while supporting external power supply. The figure below shows the communication and power interface positions and connection methods of Wuji Hand:

• Numbers 1 to 3 in the figure are:
  • 1: USB data cable connection end (plugged into the dexterous hand device)
  • 2: USB data cable other end (connected to host computer or robot controller)
  • 3: XT30 power interface for external power supply

Product Electrical Characteristics

Pin Definition

Indicator Light Reference Table

An RGB status indicator sits on the lower back of the hand. It provides real-time feedback on power supply and system operation.

The meanings corresponding to each status are shown in the table below:

Indicator Light Color		Status Symbol	System Phase Description	Description
	No Light	OFF	Powered off/unpowered state	Power supply not connected or main power failure
	Blue Solid	Bootloader	Firmware update or bootloader	Device is in bootloader. If device is performing firmware upgrade, strictly prohibit power disconnection or cable reconnection to avoid system damage
	Green Flashing	Standby	Normal standby	Power supply normal, system normal, not connected to host computer or SDK
	Green Solid	Running	Normal operation	Power supply normal, system started, connected to host computer or SDK
	Yellow Solid	Warning	Device warning	System detected warnings such as high temperature, power fluctuation, and other non-fatal faults. Pause debugging and investigate the warning cause
	Red Flashing	Pre-fault	Fault warning	Warning of impending fault, such as temperature approaching overtemperature threshold
	Red Solid	Fault	Critical fault	Serious hardware/software fault (such as main MCU abnormality, communication out of sync, etc.). Disable immediately and troubleshoot via host computer (observe indicator light, terminal log, reset/factory restore)

Product Accessories Introduction

Product Accessories Table

Image	Name	Description
	12V 20A Power Adapter	Power supply
	Power Adapter AC Cable
	Impact-resistant Adapter	See Impact-resistant Adapter
	Direct-mount Adapter	Connects Wuji Hand to user equipment (such as robot arm flange)
	Toolkit	Hex wrench Pry bar: for separating the latched impact-resistant adapter
	Accessory Kit	Socket head cap screws: M4x6, M5x10, M6x10 XT30 female connector
	USB A to USB C Cable	For communication between host device and Wuji Hand
	Tactile Sensing Glove (Optional)	See Tactile Sensing Glove Whether it ships with Wuji Hand, and the left- or right-hand fit, depend on your order

Tactile Sensing Glove

The Tactile Sensing Glove is an optional tactile perception accessory for Wuji Hand. It targets research and engineering scenarios — sensing, data collection, human-machine interaction — and provides a unified hardware foundation for algorithm adaptation, simulation modeling, and multi-modal fusion.

• High sensing density: Full-palm uniformly distributed sensor array, more than 400 sensors, each independently capturing contact states, with super-resolution further enhancing perception
• High compliance: Fully flexible Nerve skin (flexible sensing skin) accommodates bending and stretching, forming a dynamic sensing array that conforms closely to objects

System Requirements

Glove Specifications

Connection

1. Connect the circle marker end of the bundled short data cable to the Brain Watch bridge port (circle marker). Route the other end around the inner wrist of Wuji Hand and connect it to the Wuji Hand communication port.
2. Use a USB-C (USB 2.0 or higher) data cable to connect to the PC — connect either USB-C end to the Brain Watch output port (triangle marker), and the other end to the PC.

Communication Interface

The product currently exposes a single communication interface, simplifying host integration.

Software Support

The official SDK provides full data access and device control, covering everything from algorithm validation to production deployment. See the SDK User Guide — Tactile Sensing Glove for the full API reference.

SDK interfaces

Two interfaces share a single backend and behave identically:

Core API capabilities

• Connection: connect() / disconnect() / is_connected(), with multi-device addressing by USB serial number
• Frame reading: blocking read_frame(timeout_ms) or callback-based start_streaming(callback) / stop_streaming()
• Device info: get_device_info() (serial / hardware / firmware version), get_fw_build(), get_handedness()
• Diagnostics: get_diagnostics() (uptime, frame count, CRC errors, drops, USB resets), reset_counters()
• Runtime config: get_sample_rate_hz() / set_sample_rate_hz() (1–120 Hz), set_streaming(enable)
• Time sync: get_device_time(), sync_host_epoch(host_unix_ns) for multi-device alignment
• Lifecycle: reset_device() for soft reset
• Error handling: USB disconnection triggers DisconnectCallback. C++ raises ConnectionLostError, and Python raises the corresponding exception

Joint operation

The tactile glove and Wuji Hand use independent USB transports and threads, so they can run in parallel within the same process (see example/joint_with_tactile.py) — enabling closed-loop scenarios such as tactile-driven motion control.

Impact-resistant Adapter

The impact-resistant adapter uses a twist-lock and slot locking structure to maintain a rigid connection under normal conditions. When subjected to external impact forces exceeding the safety threshold (such as robot arm loss of control or severe end-effector collision), Wuji Hand and the robot arm will trigger active separation to protect critical components (joints, motors, reducers, etc.) from damage. This design ensures improved reliability while minimizing maintenance and repair risks.

• Normal state: Twist-lock and set screws are tightened to ensure structural stability and prevent loosening due to daily vibration or minor impacts.
• Abnormal state: Automatically releases when exceeding the safety threshold, with Wuji Hand suspended by the safety chain to avoid secondary impact or falling hazards.

Installation and Removal

Installation Steps

Step 1: Remove the impact-resistant adapter from the packaging (left image), pull apart the four-claw latch and grooved flange (right image), remove the set screw and rotate the twist-lock counterclockwise to separate the upper and lower components.

Step 2: Use screws to connect the grooved flange to the user equipment (such as robot arm). The grooved flange provides two hole sizes, with matching screw sizes of M5×10 and M6×10. Use M4×6 screws to connect Wuji Hand to the four-claw latch.

Step 3: Insert the twist-lock into the four-claw latch and rotate clockwise until tight (gently pull the safety chain to verify the twist-lock will not slip out). Install the set screw. Align the four-claw latch with the positioning slot on the grooved flange, press down to latch, and the impact-resistant adapter installation is complete.

Precautions

Fastening Check

• Use recommended specification screws. Screws of insufficient length or incorrect specifications are strictly prohibited
• It is recommended to tighten screws in a diagonal sequence to ensure even flange surface contact
• If possible, configure a recommended torque wrench according to screw specifications to ensure tightening torque meets standards

Maintenance and Inspection

• After each installation or removal, check whether the safety chain and twist-lock are flexible, unworn, and whether the attachment points are loose
• If impact-resistant release is triggered during operation, check whether installation screws are loose and whether the twist-lock locking mechanism is intact before reinstallation

Wuji Hand Quick Start

A minimal getting-started example for Wuji Hand through wuji-sdk. The SDK exposes Wuji Hand as a USB device during scan. After connecting, enable the motors, subscribe to 20-joint positions, and use realtime_controller with LowPass to drive the index, middle, ring, and pinky fingers through one smooth clench-and-release cycle. For more usage, see Device Connection, Data Subscription Mechanism, and Common Data Types.

import asyncio
import math
import time
from wuji_sdk import SdkManager, TransportType, LowPass, JointCommand

async def main():
    manager = SdkManager.instance()
    usb_devices = [d for d in manager.scan() if d.transport_type == TransportType.Usb]
    if not usb_devices:
        print("No Wuji Hand found")
        return

    hand = manager.connect(sn=usb_devices[0].sn, device_name="wuji_hand")
    print(f"Connected: {hand.serial_number} ({hand.handedness_name()})")

    hand.enable()
    try:
        # Open the realtime controller before subscribing and publishing
        with hand.realtime_controller(LowPass(cutoff_hz=5.0)):
            # Subscribe to 5 joint state frames
            sub = hand.joint_states().subscribe()
            for _ in range(5):
                state = await sub.recv_async()
                joints = ", ".join(f"{p:+.3f}" for p in state.position[:4])
                print(f"[seq={state.header.seq}] joint[0..3]={joints}")
            initial_positions = list(state.position)
            sub.close()

            # Stream a cosine trajectory at 100 Hz — clench and release four fingers
            publisher = hand.joint_command().publish()
            update_period = 1.0 / 100.0
            duration_s = 4.0
            start = time.monotonic()
            while True:
                t = time.monotonic() - start
                if t >= duration_s:
                    break
                # y ramps smoothly from 0 up to 1.6 and back to 0
                y = (1 - math.cos(2 * math.pi * t / duration_s)) * 0.8
                target = [JointCommand(p, 0.0, 0.0) for p in initial_positions]
                # Index, middle, ring, and pinky fingers — J1, J3, J4 follow y
                for finger in range(1, 5):
                    base = finger * 4
                    target[base + 0] = JointCommand(y, 0.0, 0.0)
                    target[base + 2] = JointCommand(y, 0.0, 0.0)
                    target[base + 3] = JointCommand(y, 0.0, 0.0)
                publisher.send(target)
                time.sleep(update_period)
            publisher.close()
    finally:
        hand.disable()
        manager.disconnect(device_name="wuji_hand")

asyncio.run(main())

What You’ll See

The terminal prints the connection info followed by 5 joint state frames:

Connected: XXXXXX.YYMMDD.NNN (Left)
[seq=0] joint[0..3]=-0.097, -0.016, -0.012, -0.006
[seq=1] joint[0..3]=-0.095, -0.017, -0.012, -0.006
[seq=2] joint[0..3]=-0.093, -0.017, -0.012, -0.006
...
[seq=4] joint[0..3]=-0.091, -0.016, -0.012, -0.006

After the prints, the index, middle, ring, and pinky fingers clench and release smoothly over 4 seconds. When the example finishes, the motors disable and the joints relax under their natural load.

Wuji Hand C API

For initialization, memory management, and build instructions, see the C SDK Reference.

Connection and Whole-Hand Control

wuji_hand_connect_sn connects by USB serial number (equivalent to wuji_connect with kind SN). Control actions act on the whole hand and take no 20-joint mask:

// Scan first to discover devices and their USB serial numbers
WujiDiscovered* devs = NULL;
size_t count = 0;
wuji_scan(&devs, &count);

// Select the target Wuji Hand by device type (device_id == WUJI_DEVICE_TYPE_WUJI_HAND), then free the list after connecting
WujiDevice* dev = NULL;
for (size_t i = 0; i < count; i++) {
    if (devs[i].device_id == WUJI_DEVICE_TYPE_WUJI_HAND) {
        if (wuji_hand_connect_sn(devs[i].serial_number, "wuji_hand", &dev) != WUJI_STATUS_OK) {
            fprintf(stderr, "connect failed: %s\n", wuji_last_error());
            dev = NULL;
        }
        break;
    }
}
wuji_discovered_free(devs, count);

if (dev == NULL) {                            // No first-gen Hand found, or the connect failed
    return 1;
}

wuji_hand_enable(dev);                        // enable all 20 joints
wuji_hand_set_all_effort_limit(dev, 1.5f);    // effort limit (amps)

float pos[20];
wuji_hand_read_joint_state(dev, pos);         // 20-joint position snapshot

wuji_hand_disable(dev);
wuji_dev_disconnect(dev);
wuji_dev_release(dev);

Fault Handling and Device Information

wuji_hand_joint_label and wuji_hand_finger_name are static functions and don’t need a device connection.

Wuji SDK Data Types

HandJointStates

Real-time 20-joint state (the hand.joint_states().subscribe() frame). Joint order is finger-major: {left,right}_finger{1..5}_joint{1..4}.

{
  "header": { "seq": 42, "timestamp_us": 1709876543210, "frame_id": "" },
  "position": [0.001, -0.012, 0.087, 0.045, ...],
  "velocity": [],
  "effort": []
}

HandJointCommand

20-joint command frame. seq is client-incrementing so receivers can detect dropped frames.

TactileGloveFrame

A single pressure frame from the paired tactile glove, on a 24×32 grid.

Error Code Bitfield

Read joint diagnostics with hand.get_all_diagnostics() in Python or wuji_hand_get_all_diagnostics() in C. The returned error_code is a u32 bitfield, with one bit per fault condition. A value of 0 means no fault.

This field uses the first-generation Wuji Hand encoding. Check it bit by bit. Don’t pass it to WujiHand2.describe_error() or wuji_hand_2_describe_error().

Wuji Hand SDK Subscription

Wuji Hand Data Subscription

Wuji Hand product docs are archived. The subscription APIs are maintained on this page. The device connects over USB, exposed as wuji_sdk.WujiHand in Python and as the wuji_hand_* functions in C.

Subscribing to joint state

Receive real-time 20-joint position, with optional velocity and effort:

• Python

• C

sub = hand.joint_states().subscribe()
for _ in range(100):
    state = await sub.recv_async()
    print(f"seq={state.header.seq}, joint0={state.position[0]:+.3f}")
sub.close()

void on_state(WujiFrameKind kind, const WujiHandJointStates *frame, void *user) {
    if (kind != WUJI_FRAME_KIND_OK) return;
    printf("seq=%u, joint0=%+.3f\n", frame->header.seq, frame->position[0]);
}

WujiSub *sub = NULL;
wuji_hand_subscribe_joint_states(hand, on_state, NULL, &sub);
// ... after receiving in the background for a while
wuji_sub_close(sub);

In Python, hand.joint_states().subscribe() returns Subscription[HandJointStates]. In C the same data arrives as WujiHandJointStates, where position, velocity, and effort each carry their own length field.

Publishing joint commands (realtime control)

A realtime control session applies a lowpass filter to suppress high-frequency jitter. Inside the session, get a PUB handle and push exactly 20 joint commands (position / velocity / effort each). The command shape matches Wuji Hand 2, so control code is portable between Wuji Hand 2 and Wuji Hand:

• Python

• C

from wuji_sdk import JointCommand, LowPass

with hand.realtime_controller(LowPass(cutoff_hz=5.0)) as ctrl:
    publisher = hand.joint_command().publish()
    joints = [JointCommand(0.0, 0.0, 0.0)] * 20
    joints[0] = JointCommand(0.3, 0.0, 0.0)
    publisher.send(joints)
    print(ctrl.get_actual_position()[0], ctrl.get_actual_effort()[0])
    publisher.close()

WujiRealtimeController *ctrl = NULL;
WujiLowPass filter = { .cutoff_hz = 5.0 };
wuji_hand_realtime_controller_open(hand, filter, &ctrl);

WujiHandJointCommandPublisher *pub = NULL;
wuji_hand_joint_command_publish(hand, &pub);

WujiJointCommand joints[20] = {0};
joints[0].position = 0.3f;
wuji_hand_joint_command_publisher_send(pub, joints);

float actual_pos[20], actual_eff[20];
wuji_hand_realtime_controller_get_actual_position(ctrl, actual_pos);
wuji_hand_realtime_controller_get_actual_effort(ctrl, actual_eff);
printf("%.3f %.3f\n", actual_pos[0], actual_eff[0]);

wuji_hand_joint_command_publisher_close(pub);
wuji_hand_realtime_controller_close(ctrl);

For continuous control, send commands at a fixed rate (typically 100 Hz). The session handle reads back actual state at any time: actual position is 20 joint values in radians and actual effort is 20 joint values in amps, both read from a non-blocking cache, so control frequency is unaffected. You can share the session handle across threads without locking — for example, one thread streaming targets at a fixed rate while another polls actual positions.

In C, release both the publisher and the controller explicitly. wuji_hand_joint_command_publisher_close() and wuji_hand_realtime_controller_close() are NULL-safe, but skipping them leaks resources.

Effort limits

Set the torque limit on all 20 joints to the same amperage and read back a length-20 array:

• Python

• C

hand.set_all_effort_limit(1.5)
limits = hand.get_all_effort_limit()

wuji_hand_set_all_effort_limit(hand, 1.5f);

float limits[20];   // finger-major order
wuji_hand_get_all_effort_limit(hand, limits);

• Default is 1.5 A, suitable for most applications
• Valid range is 0.0 to 3.5 A — values above 3.5 are clamped to 3.5

Modifying the effort limit changes the maximum output capability of each joint. The firmware also reduces the effective limit based on joint temperature. For the full reference and risk notes, see Wuji Hand SDK Guide — joint_effort_limit.

Tactile sensing glove companion data

When a tactile sensing glove shares the USB bus and matches the hand’s handedness, the SDK auto-pairs it while connecting. Check the pairing status and subscribe to pressure frames:

• Python

• C

if hand.is_tactile_attached():
    tactile_sub = hand.tactile.subscribe_pressure_frame()
    frame = await tactile_sub.recv_async()
    print(f"max pressure: {max(frame.pressure):.2f}")
    tactile_sub.close()

void on_pressure(WujiFrameKind kind, const WujiTactileGloveFrame *frame, void *user) {
    if (kind != WUJI_FRAME_KIND_OK) return;
    float max = 0.0f;
    for (size_t i = 0; i < frame->pressure_len; i++) {
        if (frame->pressure[i] > max) max = frame->pressure[i];
    }
    printf("max pressure: %.2f\n", max);
}

bool attached = false;
wuji_hand_is_tactile_attached(hand, &attached);
if (attached) {
    WujiSub *tactile_sub = NULL;
    wuji_hand_subscribe_tactile_pressure_frame(hand, on_pressure, NULL, &tactile_sub);
    // ... after receiving in the background for a while
    wuji_sub_close(tactile_sub);
}

C adds three tactile info readers: wuji_hand_get_tactile_device_info (fills WujiTactileGloveDeviceInfo), wuji_hand_get_tactile_diagnostics (fills WujiTactileGloveDiagnostics), and wuji_hand_get_tactile_handedness (fills a uint8_t). On WUJI_STATUS_OK, the first two leave heap-owned fields in out. Release them with wuji_tactile_glove_device_info_free and wuji_tactile_glove_diagnostics_free respectively, and don’t free on a non-OK status. When the glove is missing or faulty, these calls return an error status — read the details with wuji_last_error().