Armer Driver

Armer aims to provide an interface layer between the hardware drivers of a robotic arm giving the user control in several ways:

In addition to a multiple control method layer, Armer is designed to be a compatability layer allowing the user to use the same code across different robotic platforms. Armer supports control for physical and simulated arms giving users the ability to develop even without access to a physical manipulator.

Below is a gif of 3 different simulated arms moving with the same cartesian velocity commands.

Requirements

Several ROS action servers, topics and services are set up by Armer to enable this functionality. A summary of these can be found here.

Armer is built on the Python Robotics Toolbox (RTB) and requires a URDF loaded RTB model to calculate the required movement kinematics, RTB comes with browser based simulator Swift which Armer uses as an out of the box simulator.

Due to these supporting packages using Armer with a manipulator will require several requirements:

Software requirements

Python >= 3.6
ROS Noetic - RoboStack can also be used (see below)
Robotics Toolbox for Python
QCR repos
Chrome browser (for using Swift sim)

Robot specific requirements

ROS drivers with joint group velocity controllers (ros_control)
Robotics Toolbox model or URDF (loaded as a robot_description parameter)

Installation

Linux (Ubuntu 20.04)

Copy and paste the following code snippet into a terminal to create a new catkin workspace and install Armer to it. Note this script will also add the workspace to be sourced every time a bash terminal is opened. If RoboStack is preferred, please follow the steps in the next section

# Install pip 
sudo apt install python3-pip

# Make the workspace and clone armer and armer_msgs packages
mkdir -p ~/armer_ws/src && cd ~/armer_ws/src 
git clone https://github.com/qcr/armer.git && git clone https://github.com/qcr/armer_msgs 

# Install all required packages
pip install -r ~/armer_ws/src/armer/requirements.txt
cd .. && rosdep install --from-paths src --ignore-src -r -y 

# Make and source the workspace 
catkin_make 
echo "source ~/armer_ws/devel/setup.bash" >> ~/.bashrc 
source ~/armer_ws/devel/setup.bash
echo "Installation complete!"

macOS and Windows (10/11)

To enable easy use of ROS on these operating systems, it is recommended to use RoboStack; note that ROS 1 (noetic) is recommended at this stage. Please ensure you have mamba installed before proceeding. Please follow all required steps for the RoboStack install (as per their instructions) to enable the smoothest setup on your particular OS.

# --- Mamba Environment Setup --- #
# Create and activate a new robostack (ros-env) environment
mamba create -n ros-env ros-noetic-desktop python=3.9 -c robostack-staging -c conda-forge --no-channel-priority --override-channels
mamba activate ros-env

# Install some compiler packages
mamba install compilers cmake pkg-config make ninja

# FOR WINDOWS: Install the Visual Studio command prompt - if you use Visual Studio 2022
mamba install vs2022_win-64

# --- ARMer Setup --- #
# Make the armer workspace and clone in armer and armer_msgs packages
# FOR LINUX/MACOS
mkdir -p ~/armer_ws/src && cd ~/armer_ws/src 
# FOR WINDOWS: Assumes you are in the home folder
mkdir armer_ws\src && cd armer_ws\src
# Clone in armer and armer_msgs
git clone https://github.com/qcr/armer.git && git clone https://github.com/qcr/armer_msgs 
# Install all required packages (into ros-env) - from current directory
# FOR LINUX/MACOS
pip install -r armer/requirements.txt
# FOR WINDOWS
pip install -r armer\requirements.txt
# Enter armer_ws folder and run rosdep commands
cd .. && rosdep init && rosdep update && rosdep install --from-paths src --ignore-src -r -y 

# Make and source the workspace (including environment)
catkin_make 

# --- Default Activation of Environment --- #
# FOR LINUX 
echo "mamba activate ros-env" >> ~/.bashrc

# FOR MACOS
echo "mamba activate ros-env" >> ~/.bash_profile

# --- Workspace Source --- #
source ~/armer_ws/devel/setup.bash

Supported Arms

Armer relies on the manipulator's ROS driver to communicate with the low level hardware so the the ROS drivers must be started along side Armer. NOTE: the below packages are required for control of a real robot - see below for simulation usage instructions

Currently Armer driver has packages that launches Armer and the target manipulator's drivers are bundled together. If your arm model has a hardware package, control should be a fairly plug and play experience. (An experience we are still working on so please let us know if it isn't.). Below are the github pages to arms with hardware packages. Install directions can be found on their respective pages.

[Available] Franka Panda: https://github.com/qcr/armer_panda
[Available] Universal Robot (UR3/UR5/UR10/UR10e): https://github.com/qcr/armer_ur
[In Progress] UFactory XArm (6): https://github.com/qcr/armer_xarm
[In Progress] ABB IRB6700: https://github.com/qcr/armer_abb

For more information on setting up manipulators not listed here see the Armer documentation, Supported Arms.

Usage

The Armer interface can be launched with the following command for simulation (note, please replace USER with your own username):

# Example is using the panda_sim.yaml. Note, please update the below path if the install directory is different
roslaunch armer armer.launch config:=/home/$USER/armer_ws/src/armer/cfg/panda_sim.yaml

Alternatively, the Armer interface can be launched for a real robot using the following command (Note that this can also support simulation if you wish via the sim parameter):

# Note this example launches the panda model in simulation mode (assumes you have this package cloned, see above)
roslaunch armer_panda robot_bringup.launch sim:=true

After launching, an arm can be controlled in several ways. Some quick tutorials can be referenced below:

For more information and examples see the Armer documentation

qcr / armer

readme