UFACTORY | 850 review

Robotic Manipulators (RM) represent an iconic symbol in the world of robotics, driving substantial growth across industries. The adoption of RMs has become a cornerstone for large organizations, not only for the enhancement of efficiency but also for the expansion of their operational capacities. The application spectrum of RMs within industries encompasses a wide array of functions, including sorting systems, assembly lines, fabrication, welding, painting, and precision metal machining, among others. Beyond industrial applications, RMs have found their place in the commercial and domestic sectors, contributing to tasks such as inventory management, surgical procedures, and everyday task assistance, thereby illustrating their versatile impact on modern society.

Today, we delve into the UF850 robotic arm, crafted by UFACTORY . You can explore the technical specifications of this remarkable arm on the MYBOTSHOP UF-850 website. The UF850 stands out as an exceptional, cost-effective, and lightweight robotic arm, offering a wide array of features, including versatile multi-input/output ports and a switchable AC/DC control box. One particularly alluring aspect is its construction from carbon fiber. It's worth noting that all UF850 packages are open source. For comprehensive guidance, you can access the UF850 manuals through the following links.

• UF-850 User Manuals

For the gripper manuals:

• Gripper Manual
• ORGANIC grippers
• Vacuum grippers

The download to the software interface are available at:

• Windows
• Mac
• Linux\Ubuntu

The download to the software development kits are available at:

• Python SDK
• C++ SDK

The 3D models for the robotic arms are available at:

• xARM5
• xArm6
• xARM7
• UF850
• AC control box
• DC control box
• Gripper
• Vacuum gripper

Finally, the ROS control packages are available at:

• ROS
• ROS2

UF850 ROS Installation (Ubuntu 20.04) for Real Robot

1. The first step to using ROS with the UF850 is the installation of ROS noetic in to your computer system. To this follow the steps provided in ROS-noetic .

2. The next step is to create a catkin workspace via:

   • mkdir ros_ws
   • cd ros_ws
   • mkdir src
   • cd src

3. The next step is to clone the UF850 ROS via:

   • git clone https://github.com/xArm-Developer/xarm_ros.git --recursive
   • cd xarm_ros
   • git pull
   • git submodule sync
   • git submodule update --init --remote

4. Update the dependencies of the package.

   • rosdep update
   • rosdep check --from-paths . --ignore-src --rosdistro noetic
   • Incase of dependencies not available, simply run
     • rosdep install --from-paths . --ignore-src --rosdistro noetic -y

5. Build and source the package:

   • catkin_make
     • Incase some ros packages are missing run sudo apt-get install ros-noetic- package_name
   • source ~/ros_ws/devel/setup.bash

6. Run rviz via:

   • roslaunch uf_robot_moveit_config uf850_moveit_realmove.launch robot_ip:=192.168.1.***
     • The ip will be written in the backside of the UF850 control box .

• An in-depth explanation is available at the native repository of UF850 ROS of how to run the robotic arm in simulation.

Demo ROS Moveit Control

MoveIt is an open-source motion planning framework designed for controlling robotic arms and other robotic systems. It's particularly popular in the field of robotics, especially for robots with multiple degrees of freedom (DOF). MoveIt simplifies the process of motion planning and control, making it easier to control robotic arms accurately and safely. Here's an overview of how MoveIt works and how you can use it to control a robotic arm:

1. Robot Description:

   • You start by providing a description of your robotic arm's kinematics and physical characteristics. This description is usually in the form of a URDF (Unified Robot Description Format) file, which defines the robot's joint structure, links, and other relevant details.

2. Configuration Package: - MoveIt requires a configuration package that contains various configuration files, such as joint limits, kinematic solvers, and collision checking settings specific to your robotic arm. You may need to customize these configurations to match your robot's specifications.

3. ROS integration:

   • MoveIt is typically used in conjunction with ROS (Robot Operating System), a popular framework for building robotic systems. You'll need to integrate MoveIt with your ROS workspace and ensure that you have the necessary ROS packages and dependencies installed.

4. Planning scene:

   • MoveIt creates a planning scene that represents the current state of the robot and its environment. This includes information about obstacles, the robot's joint positions, and any goal positions you want the arm to reach.

5. Motion planning:

   • You can use MoveIt's motion planning algorithms to generate collision-free trajectories for your robotic arm. These algorithms take into account the robot's kinematics, joint limits, and the current environment to plan a path from the robot's current position to a desired end-effector position.

6. Visualization:

   • MoveIt provides visualization tools to help you visualize planned trajectories, validate them for collisions, and adjust them if necessary. Visualization can be vital for debugging and understanding the robot's planned movements.

7. Execution: - Once a motion plan is generated, you can execute it on the robotic arm. This often involves interfacing with the robot's low-level controllers or hardware drivers to send joint commands that follow the planned trajectory.

8. Sensors and feedback:

   • If your robotic arm is equipped with sensors (eg, force/torque sensors, vision systems), MoveIt can be integrated to use this feedback for tasks like grasping objects or adjusting movements based on real-time information.

9. Customization:

   • Depending on your specific application, you may need to customize MoveIt for tasks like object manipulation, picking and placing objects, or optimizing trajectories for efficiency or speed.

10. Testing and safety:

    • Before deploying your robotic arm in a real-world environment, it's crucial to thoroughly test your control system in simulation to ensure safety and functionality.

MoveIt simplifies the process of motion planning and control for robotic arms, making it easier to develop applications for various industries, such as manufacturing, healthcare, and research. It's a versatile tool for enabling robots to perform complex tasks with precision and reliability.

To perform a demonstration execution, you can utilize the provided Python script to simulate the robot's movement at four distinct locations. To run the demo, it is essential to initiate the robot's drivers in a separate terminal. You can achieve this by executing the 'uf_robot_moveit_config.launch' file located within the 'uf_robot_moveit_config' package.

#!/usr/bin/env python3
"""
Moveit Client: The client that provides goal for the robotic arms in this case being uf850.
"""
import sys
import copy

import rospy
import moveit_commander
import moveit_msgs.msg
import geometry_msgs.msg
import numpy as np

from math import pi
from std_msgs.msg import String
from moveit_commander.conversions import pose_to_list

def all_close(goal, actual, tolerance):
  """
  Convenience method for testing if a list of values are within a tolerance of their counterparts in another list
  @param: goal       A list of floats, a Pose or a PoseStamped
  @param: actual     A list of floats, a Pose or a PoseStamped
  @param: tolerance  A float
  @returns: bool
  """
  all_equal = True
  if type(goal) is list:
    for index in range(len(goal)):
      if abs(actual[index] - goal[index]) > tolerance:
        return False

  elif type(goal) is geometry_msgs.msg.PoseStamped:
    return all_close(goal.pose, actual.pose, tolerance)

  elif type(goal) is geometry_msgs.msg.Pose:
    return all_close(pose_to_list(goal), pose_to_list(actual), tolerance)
  return True

class ManipulatorMoveit(object):

  def __init__(self, manipulator_group_name):
    super(ManipulatorMoveit, self).__init__()

    moveit_commander.roscpp_initialize(sys.argv)
    robot = moveit_commander.RobotCommander()
    scene = moveit_commander.PlanningSceneInterface()

    group_name = manipulator_group_name
    group = moveit_commander.MoveGroupCommander(group_name)
    group.allow_replanning(True)
    group.set_max_velocity_scaling_factor(1.0)
    group.set_max_acceleration_scaling_factor(1.0)
    group.set_planner_id("TRRT")
 
    display_trajectory_publisher = rospy.Publisher('/move_group/display_planned_path',
                                                   moveit_msgs.msg.DisplayTrajectory,
                                                   queue_size=20)

    planning_frame = group.get_planning_frame()
    eef_link = group.get_end_effector_link()
    group_names = robot.get_group_names()

    # Misc variables
    self.box_name = ''
    self.robot = robot
    self.scene = scene
    self.group = group
    self.display_trajectory_publisher = display_trajectory_publisher
    self.planning_frame = planning_frame
    self.eef_link = eef_link
    self.group_names = group_names
  
  def go_to_pose_goal(self, x =0.0, y =0.0, z =0.0, R=0.0 , P=180.0, Y=-180.0, frame='link_eef'):

    R, P, Y = R*((22/7)/180), P*((22/7)/180), Y*((22/7)/180)

    q1 = np.sin(R/2) * np.cos(P/2) * np.cos(Y/2) - np.cos(R/2) * np.sin(P/2) * np.sin(Y/2)
    q2 = np.cos(R/2) * np.sin(P/2) * np.cos(Y/2) + np.sin(R/2) * np.cos(P/2) * np.sin(Y/2)
    q3 = np.cos(R/2) * np.cos(P/2) * np.sin(Y/2) - np.sin(R/2) * np.sin(P/2) * np.cos(Y/2)
    q4 = np.cos(R/2) * np.cos(P/2) * np.cos(Y/2) + np.sin(R/2) * np.sin(P/2) * np.sin(Y/2)

    group = self.group
    group.clear_pose_targets()

    pose_goal = geometry_msgs.msg.Pose()
    
    pose_goal.orientation.x = q1
    pose_goal.orientation.y = q2
    pose_goal.orientation.z = q3
    pose_goal.orientation.w = q4

    pose_goal.position.x = x
    pose_goal.position.y = y
    pose_goal.position.z = z

    group.set_start_state(self.robot.get_current_state())
    
    group.set_pose_target(pose_goal, frame) # original
    # group.set_joint_value_target(pose_goal, frame, False) # approximate 
    group.go(wait=True)
    group.stop()
    group.clear_pose_targets()

    current_pose = self.group.get_current_pose().pose
    return all_close(pose_goal, current_pose, 0.05)

def main():

    uf850 = ManipulatorMoveit('uf850')
    
    # Arm control
    for i in range(1):

      # Planner execution
       result = uf850.go_to_pose_goal(x =0.500, y =0.10,  z =0.20, R=0 , P=180, Y=0)
       result = uf850.go_to_pose_goal(x =0.500, y =0.10,  z =0.100, R=0 , P=180, Y=0)
       result = uf850.go_to_pose_goal(x =0.500, y =-0.40, z =0.100, R=0 , P=180, Y=0)
       result = uf850.go_to_pose_goal(x =0.500, y =-0.50, z =0.05, R=0 , P=180, Y=0)

if __name__ == '__main__':
  rospy.init_node('move_group_python_interface', anonymous=True)
  main()

Comparative Analysis

	xARM6	UF850	UR5e
Model
Company	UFACTORY	UFACTORY	UNIVERSAL ROBOTS
surgery	Host PC	Host PC	Host PC | Teach counterpart
ROS control	Plug & play	Plug & play	Configuration required
I/O ports	Multi	Multi	Multi
Sensor integration	Available	Available	Available
Software development	Quick & straight forward	Quick & straight forward	Substantial configuration required
Pricing	Low	Mid	High
Payload	5kg	5kg	5kg
Reach	700mm	850mm	850mm
Degrees of freedom	6	6	6
Repeatability	±0.1mm	±0.02mm	±0.03mm
Maximum Speed	1 m/s	1 m/s	1 m/s
Weight(robot arm only)	12.2kg	20kg	20.6kg

Discussion

The UF850 robotic arm, as revealed in the comparison, is a notable contender in the world of robotic automation. With a competitive 850 mm reach and exceptional repeatability at ±0.02 mm, it stands out as a precise and versatile option for various applications. Operating via a host PC with plug-and-play ROS control, the UF850 offers a seamless integration experience. Its moderate pricing falls between the more budget-friendly xARM6 and the premium UR5e, making it an appealing choice for businesses seeking a balance between cost and performance. Additionally, UF850 boasts multi I/O ports, sensor integration capabilities, and a 5 kg payload, further enhancing its adaptability for a wide range of tasks. Overall, the UF850 combines a robust set of features, making it a compelling option for those looking for a dependable robotic arm with a favorable balance of specifications and cost-effectiveness.

Disclaimer

This is an informational blog. Any views or opinions represented in this blog are for informational purposes do not represent those of people, institutions or organizations that the owner may or may not be associated with in professional or personal capacity, unless explicitly stated.

Any views or opinions are not intended to malign any religion, ethnic group, club, organization, company, or individual.

The owner of this blog makes no representations as to the accuracy or completeness of any information on this site or found by following any link on this site.

The owner will not be liable for any errors or omissions in this information nor for the availability of this information. The owner will not be liable for any losses, injuries, or damages from the display or use of this information.

Downloadable files and images

Any downloadable file, including but not limited to pdfs, docs, jpegs, pngs, is provided at the user's own risk. The owner will not be liable for any losses, injuries, or damages resulting from a corrupted or damaged file.

Comments

Comments are welcome. However, the blog owner reserves the right to edit or delete any comments submitted to this blog without notice due to :

• Comments deemed to be spam or questionable spam.

• Comments including profanity.

• Comments containing language or concepts that could be considered offensive.

• Comments containing hate speech, credible threats, or direct attacks on an individual or group.

The blog owner is not responsible for the content in comments. This blog disclaimer is subject to change at any time. Furthermore, the reader acknowledges and agrees that any information or materials provided by MYBOTSHOP GmbH are for R&D purposes only. Any kind of services are provided "AS IS" and without any representation or warranty of any kind, express or implied, including but not limited to any warranty of merchantability, fitness for a particular purpose, non-infringement, or any other warranty. MYBOTSHOP GmbH shall not be liable for any damages, including but not limited to direct, indirect, special, incidental, or consequential damages, arising out of or in connection with the use or inability to use the information or materials provided. This limitation on liability shall apply regardless of the form of action,

Contact : Incase of any issues, typos, or suggestions please contact support@mybotshop.de