Lwa4p Guide

Knowledge Base to set-up and initialize SCHUNK'S Lwa4p 6 DOF Robot arm

This repository includes and offers key information to install useful software to use the legacy Lwa4p robot as some of the official information sources are not available in 2022 (year of creation of this repository).

• Robot’s assembly and operation manual
• LWA Software for windows
• Robot set-up in Ubuntu 14.04 and ROS Indigo.

Robot's assembly and operation manual

The Lwa4p 6 DOF Robot lightweight articulated robot is mainly composed by three actuators, two ERB 145 and one ERB 115.

The operations and assembly manual .PDF file can be found in the "manual" directory as the Schunk_Powerball_LWA4P.PDF

Basic Robot information

Data	Desc.
ID	0306960
Number of axes	6
Max. load [kg]	3 to 6 (depending on deflection)
Weight [kg], without base with base	12, 15
Repeatability [mm]	±0.15
Position feedback	Pseudo-absolute position measuring
Drives	Brushless servomotors with permanent- magnet brake
Nominal voltage [VDC]	24.0 ± 5%
Nominal power current [A]	5
Max. current [A]	14
Interface	CAN bus (Protocol: CANopen CiA DS402:IEC61800-7-201), two lines are also provided for signals.

LWA Software for Windows

For basic testing SCHUNK used to provide a windows executable application. Before using the software it must be consulted witch CAN Open to USB adapter is being used and the driver must be installed to allow the software recognize the device.

More information of this software is adressed in the chapter 6 Commissioning in the operations and assembly manual.

SOFTWARE FILES 📂

The executable and files can in be acces in the LWA_Software directory inside this repository and contained in the CANopenToolsExt.

To run the software open the LWA_Tool.exe ⬅️

Some options for CAN - USB device:

• PCAN-USB - more info and drivers: PCAN-USB Manufacturer web page
• CAN-USB/2 - more info and drivers: CAN-USB/2 Manufacturer web page The driver installer can be found as Treiber Windows and contained in the can_usb2_win64_271.zip

Software disclaimer from SCHUNK ❗️❗️

This software is for demonstration purposes only!

The purpose of the program is to:

• Display basic configuration information of the nodes
• Allow for simple interactive movements of the nodes
• Permit basic recording of points for replay in point to point movements

The program does NOT:

• Check for internal or external collisions while moving
• Provide any kind of crtesian control
• Provide any kind of safety related functionality

Robot set-up in Ubuntu 14.04 and ROS Indigo.

The next section contains information from Ammar Najjar repo.

Choosing CAN Card/Driver

As lwa4p robot arm uses CAN-bus communication protocol, a CAN card is needed to connect to the arm. In another project, Bryant Pong used Peak pcan card from Peak, and according to sockercan interface wiki-page It could also be used the esd CAN cards with the Kernel driver.

Choosing Software Version

The next OS and ROS versions were selected according to the last update available of the SCHUNK Robots ROS package.

• Ubuntu-14.04-64bit.
• ROS-Indigo (the most recent update)
• Socketcan (ESD CAN card , sja1000 kernel driver)
• Bash shell.

Installing ROS Packages

To install ROS, follow the instructions for the installation mentioned in the wiki-page.

• As an administrator or a sudo user, add ROS repositories to the sourcelist and import the appropriate key:

sudo sh -c 'echo "deb http://packages.ros.org/ros/ubuntu $(lsb_release -sc) main" > /etc/apt/sources.list.d/ros-latest.list'

• Set up your keys

curl -s https://raw.githubusercontent.com/ros/rosdistro/master/ros.asc | sudo apt-key add -

• Make sure your Debian package index is up-to-date::

sudo apt-get update && sudo apt-get install dpkg

• Install ROS desktop:

sudo apt-get install ros-indigo-desktop-full

• Install other complementary packages:

sudo apt-get install -y git ros-indigo-libntcan ros-indigo-libpcan       \
        ros-indigo-controller-manager ros-indigo-controller-manager-msgs \
        ros-indigo-joint-limits-interface ros-indigo-cob-srvs            \
        ros-indigo-cob-control-mode-adapter ros-indigo-cob-dashboard     \
        ros-indigo-cob-command-gui libmuparser-dev python-rosinstall     \
        python-wstool

rosdep Initialization

rosdep enables you to easily install system dependencies for source you want to compile and is required to run some core components in ROS.
To initialize it:

sudo rosdep init
rosdep update --include-eol-distros

Note that the second command should be run as a normal user.

Environment Setup

In order to run any ROS command, ROS environment variables should be available, and this can be done by sourcing specific files:

echo "source /opt/ros/indigo/setup.bash" >> ~/.bashrc
source ~/.bashrc

Be careful to have that setup file sourced on every terminal you use for ROS, and if you are using screen or tmux, make sure that in every pane you open, every setup file is sourced, else you might get un-expected errors.

Catkin Workspace

• Create a directory for catkin workspace. Usually I just call it catkin_ws and place it in my home directory:

mkdir -p $HOME/catkin_ws/src
cd $HOME/catkin_ws/src
catkin_init_workspace

• Clone the needed packages from github source:

git clone https://github.com/ammarnajjar/ros_canopen.git -b no-lost-arbitration-handling
git clone https://github.com/ipa320/schunk_robots.git -b indigo_dev
cd ..

• Install the dependencies for those packages using:

rosdep install --from-paths src --ignore-src --rosdistro indigo -y

• Build catkin workspace:

catkin_make
echo "source $HOME/catkin_ws/devel/setup.bash" >> $HOME/.bashrc
source $HOME/catkin_ws/devel/setup.bash

CAN Interface

Setting up the CAN interface correctly came after some research in ros/socket_interface Connect the robot arm to can0 so the steps can be summarized in the following:

• Set the bitrate to 500k. This has to be done while the interface is down, so first turn it down, set the bitrate value, then turn it up again:

sudo ip link set dev can0 down
sudo ip link set can0 type can bitrate 500000
sudo ip link set dev can0 up

• Set the txqueue length to be between (15-20):

sudo ifconfig can0 txqueuelen 20

Notice that schunk_robots package uses can0 by default, so if you use a different interface such as can1 or can2, make sure to modify the configuration file lwa4p.yml in your schunk_robots package to make it use the matching CAN interface.

Moveit

To use moveit, I followed the steps mentioned in the docs. I chose the catkin workspace to be in my home directory:

IMPORTANT NOTE

It will be required to replace the files from the next repo before installing the dependency.

• git: {local-name: moveit_resources, uri: 'https://github.com/ros-planning/moveit_resources.git', version: master}

This is because in the https://raw.github.com/ros-planning/moveit_docs/indigo-devel/moveit.rosinstall is listed to use the master version which is updated with modern files that will not be recognized.

Manually download the https://github.com/ros-planning/moveit_resources/releases/tag/0.6.0 files and replace them in the moveit_resources directory before building.

mkdir -p $HOME/moveit/src
cd $HOME/moveit/src
wstool init .
wstool merge https://raw.github.com/ros-planning/moveit_docs/indigo-devel/moveit.rosinstall
wstool update
cd ..
rosdep install --from-paths src --ignore-src --rosdistro indigo -y
catkin_make
echo "source $HOME/moveit/devel/setup.bash" >> $HOME/.bashrc
source $HOME/moveit/devel/setup.bash

After the installation is complete, Use MoveIt Setup Assistant to generate the moveit configurations. Example set-up can be download in Moveit config github repo, with all its tweaks.
If you don't want to do it yourself, go to your src directory in catkin workspace and clone it:

git clone https://github.com/ammarnajjar/lwa4p_moveit_config.git

Then re-build again to be able to use it.

Initializing the Robot Arm

To initialize the robot arm, first launch the controller

roslaunch schunk_lwa4p robot.launch

then call the init service:

rosservice call /arm/driver/init

This should give the following output:

success: True
message: ''

Moving the Robot Arm

These are some options of demo resources to launch:

MoveIt! and rviz

• Launch rviz and use it to control the robot arm:

roslaunch lwa4p_movit_config demo.launch

COB Dashboard

The dahsboard can be configured modifying the .yaml files int the directory catkin_ws/src/schunk_robots/schunk_lwa4p/config

Files

• joint_configurations.yaml

• command_gui_buttons.yaml

• Launch the cob dashboard and use it to control the robot arm:

roslaunch schunk_lwa4p dashboard.launch

Python MoveIt commander interface

• Launch the test.py script and run the python commander for moveit, (moveit and rviz should be running first). Add the /scripts directory to the catkin workspace and copy the file from this respository /scripts/test.py

ANALIZE THE SCRIPT CONTENT FIRST ❗️❗️

Before running read the script to check movements and poses. Run at your own risk.

rosrun schunk_lwa4p test.py

Link/Joint 3D Files

For the dimensions configuration and approximation of the Robot Arm in real space, this repository contains the Robot's Arm .stl 3D mesh files for the joints/links in the 3D files folder.

Gazebo Schunk lwa4p ROS Robot simulator

Gazebo offers a simulation environment to check Robot's movements before the real life implementation, helping the user to avoid colisions and errors.

The Héctor´s Azpúrua ROS Package for the Robot Gazebo ROS Package repository is recomended, as with other ROS packages, is needed to building from source the package before installing.+

Install dependecies

$ cd ~/catkin_ws/src/
$ git clone https://github.com/h3ct0r/schunk_lwa4p_gazebo_sim
$ cd ~/catkin_ws
$ rosdep install --from-paths src -i -y
$ catkin_make

Run Gazebo

Open the terminal and type:

$ roslaunch schunk_lwa4p_moveit sim_gazebo.launch

Run Moveit!

Open the terminal and type:

$ roslaunch schunk_lwa4p_moveit demo.launch

Useful links

• Documentation of the class for the python moveit script Python moveit_commander move_group.MoveGroupCommander

• ROS Package for the Robot SCHUNK Robots ROS Package