> ## Documentation Index
> Fetch the complete documentation index at: https://docs.wuji.tech/llms.txt
> Use this file to discover all available pages before exploring further.
# Quick Start
This page splits into three sections by what's on hand: simulation check needs no device, real-device run covers the full path from unboxing to a firmware upgrade, and cross-product teleoperation brings in Wuji Hand 2. Each section stands on its own, so skip to the next one when the prerequisites don't apply.
## Before You Start
| What's on hand | Where to start | Approximate time |
| - | - | - |
| No device yet | [Simulation Check](#simulation-check) | 10 minutes |
| One Wuji Glove | [Real-Device Run](#real-device-run) | 30 minutes |
| Wuji Glove plus Wuji Hand 2 | Finish the real-device run, then [Cross-Product Teleoperation](#cross-product-teleoperation) | 45 minutes |
You need Ubuntu 22.04 or later and Python 3.10 or later.
## Simulation Check
This section needs Git, Python, and any URDF viewer. No device required.
Wuji Glove ships a 21-DOF hand skeleton model for checking frames, joints, and data mapping:
```bash theme={null}
git clone https://github.com/wuji-technology/wuji-description.git
cd wuji-description
pip install urdf-viz
urdf-viz glove/body/urdf/right.urdf
```
Once the window opens, confirm the skeleton is complete with no missing meshes and that it has 21 joints.
For the left-hand model, EMF module STL files, the transmitter cover STEP, and what each of the three mounting attachments is for, see [Coordinate Frames and Models](/en/docs/wuji-glove/hardware-integration#coordinate-frames-and-models).
**Done when**: the skeleton model renders correctly with all 21 revolute joints.
A model that loads confirms the assets and the visualization path work. Tactile, EMF, and IMU data need a connected device, so continue with the next section.
## Real-Device Run
This section needs one Wuji Glove, the data acquisition board, the supplied cables, and an Ubuntu host.
### Step 1: Unboxing Check
Check everything in the box against the [package contents](/en/docs/wuji-glove/introduction#package-contents): the USB-C to USB-C cable, the USB-C to Ethernet power adapter, the USB-A to USB-C cable, and the Ethernet cable.
### Step 2: Install the Software
```bash theme={null}
pip install wuji-sdk
curl -fsSL https://get.wuji.tech/cli | bash
```
The Wuji SDK reads glove data from code, and the Wuji CLI scans devices, runs calibration, and runs health checks from a terminal. For installation and environment requirements, see the [Wuji SDK quick start](/en/docs/wuji-sdk/quick-start/) and [Wuji CLI installation](/en/docs/wuji-cli/getting-started/#installation).
### Step 3: Connect the Data Acquisition Board
Use the USB-C to USB-C cable to connect the data acquisition board to the USB-C to Ethernet power adapter.
Pay attention to the **orientation** of the USB-C to USB-C cable. Both ends of the cable have a **white rectangular label (shown as a blue block in the image below)** on the same side to help you quickly identify the correct orientation. If the cable is inserted with the label side up into the data acquisition board, it must also be inserted with the label side up into the USB-C to Ethernet power adapter, otherwise it will only provide power without data transmission.
### Step 4: Connect Ethernet and Power
Use the USB-C to Ethernet power adapter to connect the Ethernet cable and power cable. For the power cable, we recommend a USB-A to USB-C cable. After connecting, check that the data acquisition board indicator looks normal.
### Step 5: Configure Computer Network
Verify the computer and glove are on the same network segment (default segment is 192.168.1.x). The first three octets of the IP address must match, and set the subnet mask to 255.255.255.0. The default IP is 192.168.1.100 for the left hand and 192.168.1.101 for the right hand. Avoid assigning these addresses to the computer to prevent conflicts.
Pick either method:
| Method | Best for | After a reboot |
| - | - | - |
| [Graphical interface](#method-1-graphical-interface) | Ubuntu desktop | Persists |
| [Command line](#method-2-command-line) | Headless systems or remote terminals | Lost |
The following example connects to the right-hand glove. Adjust the IP address based on the target glove.
#### Method 1: Graphical Interface
1. Open **Settings** and go to **Network**
2. Click the gear icon in the **Wired** row
3. Switch to the **IPv4** tab and select **Manual** for **IPv4 Method**
4. Under **Addresses**, enter Address `192.168.1.50` and Netmask `255.255.255.0`
5. Click **Apply**
6. Run `ping 192.168.1.101` in a terminal to confirm connectivity
#### Method 2: Command Line
Replace the interface name in the commands with your actual interface name. An address set this way is lost after a system reboot.
**1. Identify the network interface name**
```bash theme={null}
ip link show
```
Find the Ethernet interface name, for example `eth0`, `enp3s0`, or `eno1`.
**2. Verify the Ethernet cable is connected**
```bash theme={null}
ethtool eth0 | grep "Link detected"
```
The output should show `Link detected: yes`.
**3. Clear existing IP addresses**
```bash theme={null}
sudo ip addr flush dev eth0
```
This command removes all existing IP addresses from the interface. If the interface is being used for other network connections, they'll be disconnected.
**4. Set a static IP and subnet mask**
```bash theme={null}
sudo ip addr add 192.168.1.50/24 dev eth0
```
`/24` corresponds to a subnet mask of `255.255.255.0`.
**5. Bring up the interface**
```bash theme={null}
sudo ip link set eth0 up
```
**6. Verify the IP and subnet mask**
```bash theme={null}
ip addr show eth0
```
Confirm the output contains `inet 192.168.1.50/24`.
**7. Test connectivity**
```bash theme={null}
# Right-hand glove example
ping 192.168.1.101
```
If connecting to the left-hand glove, use `ping 192.168.1.100` instead. Receiving a response indicates a successful connection.
### Step 6: Wear the Wuji Glove
Put on the Wuji Glove and adjust the position of the data acquisition board using the arm strap.
When putting on or removing the glove, apply force at the palm area. Do not pull on the wrist area.
When removing the glove, apply force on the fabric at the fingertips. Do not pull on the EMF modules or the back of the hand.
**Important: After wearing, before connecting to software, ensure:**
* Keep fingers slightly bent in a natural, relaxed state
* Do not cross the fingertip EMF modules, do not make a fist
**Safety Guidelines:**
* Avoid use in humid environments
* Do not over-bend the sensor areas
* Store in a dry, cool place
### Step 7: Install the Tracker (Optional)
To use an external Tracker for spatial tracking, peel back the soft cover on the EMF transmitter module on the back of the glove and mount the Tracker on the exposed mounting plate.
Different Tracker models need different adapters. For adapter STEP files and assembly notes, see [Attachment STEP Files](/en/docs/wuji-glove/hardware-integration#attachment-step).
### Step 8: Confirm the Device Is Online
```bash theme={null}
wuji devices
wuji ping
wuji doctor
```
`wuji devices` lists the devices on the same subnet, `wuji ping` returns device type, serial number, firmware version, and IP, and `wuji doctor` runs a health check that locates EMF disconnections along with tactile dead points, rows, and columns.
When the list comes back empty, check that the device has power and that the host sits on the same subnet as the glove.
### Step 9: Connect to the Device and Check the State
```python theme={null}
from wuji_sdk import SdkManager
manager = SdkManager.instance()
glove = manager.auto_connect(device_name="glove")
print(glove.sn().get()) # serial number
print(glove.version().get()) # firmware version
print(glove.hand_side().get()) # hand side
```
With several devices on the subnet, use `manager.connect(sn="")` instead. For connecting by address, by handedness, and other options, see [device connection in the Wuji SDK](/en/docs/wuji-sdk/device-connection/).
Only one client holds the glove connection at a time. When `wuji viz` or another SDK script already holds the same glove, this connection can't be established, so exit the running client and try again. See [Free Up an Occupied Device Connection](/en/docs/wuji-glove/maintenance#free-up-an-occupied-device-connection).
The indicator light on the data acquisition board tracks the connection. Yellow very slow flash means the host is connected but not pulling data, and cyan heartbeat means data is streaming. Red fast flash means the Ethernet link is down, and red solid means a sensor hardware fault. For how to handle each state, see [Connection States and the Indicator Light](/en/docs/wuji-glove/maintenance#connection-states-and-the-indicator-light).
### Step 10: Run the Calibration
Hand model calibration is isolated per user, and the Default user can't run it. Create a named profile, switch to it, then calibrate:
```bash theme={null}
wuji user create operator --switch
wuji calib hand-model
```
Before calibrating, keep fingers slightly bent and relaxed, without crossing the fingertip modules or making a fist. The calibration output saves to the current user profile and takes effect right away, producing the left- and right-hand models for that user.
Calibration drives the accuracy of joint angles, skeleton, and fingertip poses. For contact detection, also run [tactile calibration](/en/docs/wuji-cli/tactile-calibration/). For full parameters and error handling, see [Wuji CLI hand model calibration](/en/docs/wuji-cli/hand-model-calibration/).
### Step 11: Get the First Data Frame
```bash theme={null}
wuji sub tactile --count 1
wuji sub emf_poses --count 1
wuji sub imu_data/palm --count 1
```
`--count 1` exits after one full frame arrives. To read data in an application, connect to the glove with the Wuji SDK and subscribe to `tactile`, `emf_poses`, or `hand_skeleton`.
When tactile values read all 0 or -1, EMF confidence runs low, or the IMU drifts continuously, see [Troubleshooting](/en/docs/wuji-glove/troubleshooting).
For what each stream means and its structure, frames, and timestamps, see [SDK Data Reference](/en/docs/wuji-glove/sdk-data-reference).
To check the data visually, run `wuji viz` and view the hand skeleton, EMF receivers, tactile point cloud, and raw tactile matrix in your browser. For the full command, see [Live Visualization](/en/docs/wuji-cli/visualization/).
### Step 12: Stop and Take Off the Glove
Once reading finishes, disconnect to free the glove for other clients:
```python theme={null}
manager.disconnect_all()
```
When taking the glove off, apply force on the fabric at the finger pads and don't pull on the EMF modules or the back of the hand. Store it in a dry, cool place and avoid folding the sensor areas. For the full requirements, see [Storage and Environment](/en/docs/wuji-glove/maintenance#storage-and-environment).
### Step 13: Upgrade the Firmware
Once the first data frame arrives, upgrade the firmware to the latest version:
```bash theme={null}
wuji upgrade --check
wuji upgrade --type wuji_glove
```
`--check` is read-only and lists which devices have a firmware update. `--type wuji_glove` upgrades every glove in scope to its own latest version, and each device reboots into the new firmware once flashing finishes. For the full scope and action options, see [Wuji CLI firmware upgrade](/en/docs/wuji-cli/firmware-upgrade/).
The calibration interfaces have minimum firmware and SDK versions. For the pairing, see the component version table in [Release Notes](/en/release-notes).
**Done when**: the device is online, the health check passes, hand model calibration completes, at least one valid frame arrives with a timestamp and handedness, and the firmware is up to date.
## Cross-Product Teleoperation
This section needs one Wuji Glove that has finished the real-device run, plus one Wuji Hand 2 that has finished its [quick start](/en/docs/wuji-hand/latest/quick-start/) with all 20 joints online. Both devices sit on the same subnet and share the same handedness.
Once the glove is on, it streams hand keypoints continuously. Retargeting converts them into 20 joint angles and sends them to the hand, which follows the finger motion in real time.
### Confirm Both Devices Are Online
```bash theme={null}
wuji devices
wuji ping
```
The list should show both `wuji_hand_2` and `wuji_glove`. Check the serial numbers, firmware versions, and handedness. With other devices of the same type on the subnet, note the target serial number for the next step.
### Run the Teleoperation Example
The full retargeting and teleoperation implementation lives in the Wuji SDK repository examples and updates together with the interface:
```bash theme={null}
git clone https://github.com/wuji-technology/wuji-sdk.git
cd wuji-sdk/examples/python/retargeting
pip install wuji-sdk numpy
python 1.teleop_real.py
```
The example lists the SDK users first. On a first run, press Enter to keep the default user. For how the choice affects the hand model, see [Choose the SDK user for teleop](/en/docs/wuji-sdk/retargeting/#choose-the-sdk-user-for-teleop).
The example runs against a right-hand assembly by default. For a left-hand assembly, change the `SIDE` constant at the top of the script.
The example scans and connects to the device it finds. With several hands on the subnet, confirm the target device first so you don't drive one someone else is using.
### Complete a Cross-Product Motion
1. Clear the hand's workspace and confirm nobody is touching it.
2. Put the glove on with fingers relaxed and slightly curled.
3. Run the example, starting with slow, small motions.
4. Watch whether motion stays continuous, directions match, and no error code fires.
5. Press Ctrl+C to stop. On exit, the example disables the hand and disconnects.
Stop right away on an abnormal pose, a communication break, or an error code, then work through [Troubleshooting](/en/docs/wuji-glove/troubleshooting).
For retargeting parameters, input format, and frame conventions, see [hand retargeting in the Wuji SDK](/en/docs/wuji-sdk/retargeting/). For hand-tracking frame conventions and timestamp alignment, see [SDK Data Reference](/en/docs/wuji-glove/sdk-data-reference).
**Done when**: glove data keeps updating and the hand follows the finger motion under control.
This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.
