equipment

UFactory xArm 6 Robot Arm

Public Made by Adom

by adom

UFACTORY's 6-axis, 5 kg, 700 mm collaborative arm: specs, base bolt pattern, manuals, a per-link GLB digital twin with kinematics, and AI skills for the Python SDK, web UI and ROS 2.

robot-armcobotufactoryxarmxarm-6digital-twinpython-sdkros2moveit
Overview Files Skills Discover Packages Releases Dependencies Issues Breadcrumbs Pull Requests Activity
main
ufactory-xarm-6 / README.md
History Download
John Lauer UFactory xArm 6: specs, mounting, docs, digital twin, skills 2add613 4d ago

UFactory xArm 6 Robot Arm

A 6-axis collaborative arm from UFACTORY with a 5 kg payload and 700 mm reach. This page collects the specs, the official manuals, a ready-to-use digital twin (per-link GLBs plus a kinematics file), and AI skills for driving the arm from Python, the browser and ROS 2.

Key specs

All values are from the UFACTORY xArm Hardware Manual (1305 model, V2.6.0, chapter 8) and the UFACTORY product page, unless noted.

Spec xArm 6
Model code XI1305
Degrees of freedom 6 (all revolute)
Payload 5 kg
Reach 700 mm
Repeatability ±0.1 mm
Max joint speed 180 °/s
Max TCP speed 1 m/s
Arm weight (arm only) 12.5 kg
Base footprint Ø126 mm
Mounting any direction (floor, wall, ceiling); set the mount angle in UFACTORY Studio
End flange DIN ISO 9409-1-A50/63, M5 × 6
Materials aluminium, carbon fibre
Ambient temperature 0 to 50 °C
Cleanroom ISO Class 5
IP rating not stated in the manual or product page
Arm supply 24 V DC, 20.8 A (typical 200 W, 500 W supply recommended)
Control box AC: 100 to 240 V AC, 50/60 Hz, 3.9 kg, 285 × 135 × 101 mm. DC: 24 to 72 V DC, 2.6 kg, 262 × 160 × 76 mm
Control box I/O 8 CI + 8 DI, 8 CO + 8 DO, 2 AI, 2 AO, 1 × RS-485 master
Robot link Ethernet (UFACTORY private TCP, Modbus TCP)
Programming UFACTORY Studio (browser), Python SDK, C++ SDK, ROS / ROS 2

Joint ranges

Joint Hardware range (manual) Range in the ROS 2 model (xarm_ros2)
J1 ±360° ±178.2°
J2 −117° to +116° −117.97° to +120.0°
J3 −219° to +10° −178.2° to +11.0°
J4 ±360° ±178.2°
J5 −97° to +180° −97.0° to +178.2°
J6 ±360° ±178.2°

The ROS 2 description clamps the continuous joints to ±0.99π, which is what motion planners and the twin below use. Plan with the tighter set unless you know you need the full hardware range.

Base mounting

xArm 6 base bolt pattern, top view in the robot base frame

The base is a Ø126 mm round flange held down by five M5 socket-head cap screws on a Ø110 mm bolt circle. Each hole is Ø5.5 mm through a 10 mm flange with a Ø9 × 5.5 mm counterbore, so the screw heads sit below the flange top; the screw needs 4.5 mm of flange grip plus the thread engagement in your plate. The holes sit at 0°, ±60° and ±120° from the base +X axis, and the sixth position (180°) is left empty on the cable-connector side. Two Ø5 mm locating holes (+0.006/+0.024, 8 mm deep, one round and one slotted) sit at X = −10 mm, Y = ±55 mm for dowel pins, so the arm goes back on in exactly the same place.

Hole centres in the base frame (mm): (55.0, 0), (27.5, ±47.63), (−27.5, ±47.63). The drawing above is redrawn from the manual's section 2.2.3.1 "Robot Base Mounting"; which side carries the round pin and which the slot follows the manual's view direction, so check it against the UFACTORY STEP model before you machine a plate.

UFACTORY's installation rules: the mounting surface must be rigid and vibration-free, and must withstand at least 10 times the base joint's full torque and 5 times the arm's weight. A safety assessment is required every time the arm is installed. The arm ships with a clamp-style mounting tool for table edges.

Documents and downloads

UFACTORY's documents are not licensed for redistribution, so this page links to them on ufactory.cc.

Document Link
Product page and spec table ufactory.cc/xarm-collaborative-robot
xArm Hardware Manual V2.6.0 (1305 model): safety, installation, mounting drawing, electrical I/O, specs PDF · online
xArm Developer Manual V2.0.1: Modbus TCP protocol, report ports, error codes PDF
UFACTORY Studio User Manual V2.8.2: web UI, settings, safety features PDF
xArm 6 (XI1305) 3D model (STEP) zip
xArm 6 movable SolidWorks model zip
AC control box 3D model zip
Mounting tool 3D model zip
All downloads ufactory.cc/download
Firmware release notes docs.releasenote.ufactory.cc
Browser simulator xarm6.sim.ufactory.cc

The models/ folder holds a ready-to-animate twin of the xArm 6, converted from UFACTORY's open-source ROS 2 description.

File What it is
link_base.glb … link6.glb one mesh per URDF link, each in its own link frame (white shell and grey joint covers as separate materials)
xarm6_home.glb the whole arm baked at the zero pose, for a static preview
kinematics.json the joint chain: parent link, origin xyz (mm), origin rpy (rad), axis, limits (deg), home pose and TCP
LICENSE-xarm_ros2.txt the BSD-3-Clause licence the meshes and kinematics come under

Conventions:

  • Units are millimetres, Z is up. The vertex data is the URDF data × 1000; no extra transform is needed.
  • Each child link's pose is parent × Translate(origin_xyz_mm) × RPY(origin_rpy) × RotZ(q), where RPY is URDF fixed-axis (R = Rz(yaw) · Ry(pitch) · Rx(roll)). Every joint axis is +Z of its own frame.
  • Zero pose (all joints 0°): upper arm up, forearm forward, flange pointing down. The flange centre is at (207, 0, 112) mm in the base frame, which matches what the SDK's get_position() reports at zero.
  • Base frame: the origin is the centre of the base's bottom face; +X is the direction the arm reaches at zero; the cable connectors face −X. J2's axis is 267 mm above the mounting face.
  • TCP: the link6 origin is the flange face, +Z out of the flange. Add your tool offset there. No gripper is included.
  • glTF loaders that convert +Y-up to their own space (Babylon.js, three.js) add a root rotation; parent the links under a Z-up root and undo that root transform so each link stays in its authored frame.

Forward kinematics in a few lines of Python (the full script is skills/xarm-twin/fk.py):

from fk import fk
import json
kin = json.load(open("models/kinematics.json"))
pose = fk(kin, [0, 0, 0, 0, 0, 0])["link6"]   # 4x4, mm
print(pose[:3, 3])                             # [207. 0. 112.]

Source: xArm-Developer/xarm_ros2 at commit 62936f7, xarm_description (the xarm6_1305 visual meshes and xarm6_default_kinematics.yaml). Copyright (c) 2018 UFACTORY Inc., BSD-3-Clause; the licence travels with the files in models/.

Controlling the arm

1. UFACTORY Studio in the browser

The control box serves its own web UI, UFACTORY Studio, on port 18333. Put your PC on the same subnet as the control box and open:

http://<arm-ip>:18333

Studio covers jogging (Live Control), Blockly programs, trajectory recording, the end-effector, TCP and payload settings, and the safety settings below. The factory IP is on a label on the control box (192.168.1.xxx). If the IP is lost, short RI0 to GND on the control box with the power off, power up and wait for the beep: the IP resets to 192.168.1.111 (Hardware Manual 3.4.5).

2. Python SDK quick start

pip install xarm-python-sdk

from xarm.wrapper import XArmAPI

arm = XArmAPI("192.168.1.xxx")          # connects to the control box
arm.clean_warn(); arm.clean_error()
arm.motion_enable(enable=True)           # energise the servos
arm.set_mode(0)                          # 0 = position control
arm.set_state(state=0)                   # 0 = ready to move

arm.set_servo_angle(angle=[0, -30, -60, 0, 90, 0], speed=30, wait=True)   # joints, deg, deg/s
code, pose = arm.get_position()          # [x, y, z, roll, pitch, yaw], mm and deg
arm.set_position(x=300, y=0, z=250, roll=180, pitch=0, yaw=0, speed=100, wait=True)  # mm/s
code, joints = arm.get_servo_angle()

arm.disconnect()

The calls you will use most:

Call What it does
XArmAPI(ip, is_radian=False) connect; angles default to degrees, lengths are always mm
motion_enable(True) enable all servos (also needed after an e-stop)
set_mode(m) 0 position, 1 servo (streaming set_servo_angle_j), 2 joint teach (hand-guiding), 4 joint velocity, 5 Cartesian velocity, 6/7 online trajectory
set_state(s) 0 move, 3 pause, 4 stop
set_servo_angle(angle=[...], speed, mvacc, wait) joint move
set_position(x, y, z, roll, pitch, yaw, speed, wait, relative) linear Cartesian move
get_position() / get_servo_angle() read the TCP pose / joint angles; both return (code, values)
emergency_stop() software stop: set_state(4), then re-enable; does not clear errors and is not a substitute for the hardware e-stop
clean_error() / clean_warn() clear error and warning codes; afterwards call motion_enable(True) and set_state(0) yourself
set_collision_sensitivity(0..5) 0 disables collision detection; higher is more sensitive
set_reduced_mode(True) turn on the speed and range limits configured for reduced mode
set_gripper_mode(0), set_gripper_enable(True), set_gripper_position(pos, wait=True) UFACTORY xArm Gripper in position mode; pos runs from about 0 (closed) to 850 (open)

Every call returns a code; 0 means success. The API reference and error codes are in the SDK repo, along with numbered examples.

3. C++ SDK

xArm-Developer/xArm-CPLUS-SDK (BSD-3-Clause) mirrors the Python API (XArmAPI, motion_enable, set_mode, set_state, set_servo_angle, set_position) for xArm 5/6/7, Lite 6 and the 850.

4. ROS 2 and MoveIt 2

xArm-Developer/xarm_ros2 has one branch per ROS 2 distribution (humble, jazzy, rolling, plus older foxy and galactic). Clone the branch that matches your ROS install.

ros2 launch xarm_description xarm6_rviz_display.launch.py                         # view the model
ros2 launch xarm_moveit_config xarm6_moveit_fake.launch.py                        # MoveIt, simulated arm
ros2 launch xarm_moveit_config xarm6_moveit_realmove.launch.py robot_ip:=<arm-ip> # MoveIt, real arm
ros2 launch xarm_api xarm6_driver.launch.py robot_ip:=<arm-ip>                    # driver services only

Add add_gripper:=true to include the xArm Gripper model. ROS 1 users have xarm_ros.

Network ports on the control box

Port Use Source
18333 UFACTORY Studio web UI (HTTP) Studio User Manual 3.2
502 SDK and command channel: UFACTORY private TCP and standard Modbus TCP Developer Manual 2.1.2, Studio Manual 7.2.6
504 G-code over TCP (firmware 2.2.0 and later) Studio User Manual 6.4
30001 automatic state report, "normal", 5 Hz Developer Manual 2.1.6
30002 automatic state report, "rich" (adds arm type, joint count and more), 5 Hz Developer Manual 2.1.6
30003 automatic state report, "develop" (joints, pose, joint torques, F/T), 100 Hz Developer Manual 2.1.6

UFACTORY recommends a wired link. A Wi-Fi hop between the PC and the router works but adds delay and packet loss.

Safety

  • Hardware e-stop. Pressing the red button on the control box decelerates the arm, clears queued commands and cuts arm power within 300 ms. The arm sags slightly as the brakes catch. To recover: twist the button to release it, then re-enable from Studio or motion_enable(True). UFACTORY notes the e-stop is not a risk-reduction measure in itself.
  • Collision detection. Set the sensitivity from 0 (off) to 5. It relies on the payload, TCP offset and mount angle being set correctly; wrong values cause false trips or missed collisions. Collision rebound (back off after contact) and self-collision prevention are separate switches in Studio.
  • Safety boundary. A Cartesian box the TCP must stay inside; the arm stops if the TCP leaves it.
  • Reduced mode. Lower limits on TCP speed, joint speed and joint range, switchable from Studio, the SDK, or a control box input.
  • Manual (teach) mode gravity-compensates the arm for hand-guiding; teach sensitivity is 1 to 5.
  • Before any motion: keep people out of the 700 mm reach plus the tool, set payload and TCP, start at low speed with wait=True, and keep someone within reach of the e-stop.
  • Releasing a joint brake lets that joint fall; support the arm first.

Talk to the AI

Install the skills below, then try:

  • "xarm connect to the arm at 192.168.1.xxx and read the joint angles"
  • "move the xArm to joints 0, -30, -60, 0, 90, 0 at 20 deg/s and wait"
  • "xarm jog the TCP 50 mm up in Z, then return"
  • "xarm clear error and re-enable the arm"
  • "xarm twin load the xArm 6 GLBs in a Z-up scene and pose it from these joint angles"
  • "xarm forward kinematics where is the flange for joints 30, 10, -40, 0, 60, 0?"
  • "xarm mounting plate draw the bolt pattern for an adapter plate"

Skills

The skills/ folder carries AI skills for this arm.

Skill What it's for
xarm-control connect, enable, move, read state, gripper, error recovery and safe-motion rules with the Python SDK
xarm-twin load the per-link GLBs, compose the joint chain, forward kinematics, mount the twin on a plate

Licence

The meshes and kinematics in models/ are derived from UFACTORY's xarm_ros2 and stay under its BSD-3-Clause licence (Copyright (c) 2018 UFACTORY Inc.). The bolt-pattern diagram, the text and the skills on this page are Adom's, MIT. UFACTORY's PDFs and CAD files are linked, not copied. xArm and UFACTORY are trademarks of UFACTORY.