file_path
stringlengths 20
207
| content
stringlengths 5
3.85M
| size
int64 5
3.85M
| lang
stringclasses 9
values | avg_line_length
float64 1.33
100
| max_line_length
int64 4
993
| alphanum_fraction
float64 0.26
0.93
|
|---|---|---|---|---|---|---|
AndreiVoica/P10-MAP/src/kuka_moveit_configuration/launch/warehouse_settings.launch.xml | <launch>
<!-- Set the parameters for the warehouse and run the mongodb server. -->
<!-- The default DB port for moveit (not default MongoDB port to avoid potential conflicts) -->
<arg name="moveit_warehouse_port" default="33829" />
<!-- The default DB host for moveit -->
<arg name="moveit_warehouse_host" default="localhost" />
<!-- Set parameters for the warehouse -->
<param name="warehouse_port" value="$(arg moveit_warehouse_port)"/>
<param name="warehouse_host" value="$(arg moveit_warehouse_host)"/>
<param name="warehouse_exec" value="mongod" />
<param name="warehouse_plugin" value="warehouse_ros_mongo::MongoDatabaseConnection" />
</launch>
| 681 | XML | 39.117645 | 99 | 0.688693 |
AndreiVoica/P10-MAP/src/kuka_moveit_configuration/launch/trajectory_execution.launch.xml | <launch>
<!-- This file makes it easy to include the settings for trajectory execution -->
<!-- Flag indicating whether MoveIt! is allowed to load/unload or switch controllers -->
<arg name="moveit_manage_controllers" default="true"/>
<param name="moveit_manage_controllers" value="$(arg moveit_manage_controllers)"/>
<!-- When determining the expected duration of a trajectory, this multiplicative factor is applied to get the allowed duration of execution -->
<param name="trajectory_execution/allowed_execution_duration_scaling" value="1.2"/> <!-- default 1.2 -->
<!-- Allow more than the expected execution time before triggering a trajectory cancel (applied after scaling) -->
<param name="trajectory_execution/allowed_goal_duration_margin" value="0.5"/> <!-- default 0.5 -->
<!-- Allowed joint-value tolerance for validation that trajectory's first point matches current robot state -->
<param name="trajectory_execution/allowed_start_tolerance" value="0.01"/> <!-- default 0.01 -->
<!-- Load the robot specific controller manager; this sets the moveit_controller_manager ROS parameter -->
<arg name="moveit_controller_manager" default="kuka_kr3r540" />
<include file="$(find kuka_moveit_configuration)/launch/$(arg moveit_controller_manager)_moveit_controller_manager.launch.xml" />
</launch>
| 1,342 | XML | 60.045452 | 145 | 0.729508 |
AndreiVoica/P10-MAP/src/kuka_moveit_configuration/launch/ompl_planning_pipeline.launch.xml | <launch>
<!-- OMPL Plugin for MoveIt! -->
<arg name="planning_plugin" value="ompl_interface/OMPLPlanner" />
<!-- The request adapters (plugins) used when planning with OMPL.
ORDER MATTERS -->
<arg name="planning_adapters" value="default_planner_request_adapters/AddTimeParameterization
default_planner_request_adapters/FixWorkspaceBounds
default_planner_request_adapters/FixStartStateBounds
default_planner_request_adapters/FixStartStateCollision
default_planner_request_adapters/FixStartStatePathConstraints" />
<arg name="start_state_max_bounds_error" value="0.1" />
<param name="planning_plugin" value="$(arg planning_plugin)" />
<param name="request_adapters" value="$(arg planning_adapters)" />
<param name="start_state_max_bounds_error" value="$(arg start_state_max_bounds_error)" />
<rosparam command="load" file="$(find kuka_moveit_configuration)/config/ompl_planning.yaml"/>
</launch>
| 970 | XML | 41.21739 | 95 | 0.714433 |
AndreiVoica/P10-MAP/src/kuka_moveit_configuration/config/simple_moveit_controllers.yaml | controller_list:
- name: arm_controller
action_ns: follow_joint_trajectory
type: FollowJointTrajectory
default: True
joints:
- joint_a1
- joint_a2
- joint_a3
- joint_a4
- joint_a5
- joint_a6 | 244 | YAML | 19.416665 | 38 | 0.590164 |
AndreiVoica/P10-MAP/src/kuka_moveit_configuration/config/chomp_planning.yaml | planning_time_limit: 10.0
max_iterations: 200
max_iterations_after_collision_free: 5
smoothness_cost_weight: 0.1
obstacle_cost_weight: 1.0
learning_rate: 0.01
smoothness_cost_velocity: 0.0
smoothness_cost_acceleration: 1.0
smoothness_cost_jerk: 0.0
ridge_factor: 0.0
use_pseudo_inverse: false
pseudo_inverse_ridge_factor: 1e-4
joint_update_limit: 0.1
collision_clearance: 0.2
collision_threshold: 0.07
use_stochastic_descent: true
enable_failure_recovery: false
max_recovery_attempts: 5
| 487 | YAML | 24.684209 | 38 | 0.794661 |
AndreiVoica/P10-MAP/src/kuka_moveit_configuration/config/stomp_planning.yaml | stomp/arm:
group_name: arm
optimization:
num_timesteps: 60
num_iterations: 40
num_iterations_after_valid: 0
num_rollouts: 30
max_rollouts: 30
initialization_method: 1 # [1 : LINEAR_INTERPOLATION, 2 : CUBIC_POLYNOMIAL, 3 : MININUM_CONTROL_COST]
control_cost_weight: 0.0
task:
noise_generator:
- class: stomp_moveit/NormalDistributionSampling
stddev: [0.05, 0.05, 0.05, 0.05, 0.05, 0.05]
cost_functions:
- class: stomp_moveit/CollisionCheck
collision_penalty: 1.0
cost_weight: 1.0
kernel_window_percentage: 0.2
longest_valid_joint_move: 0.05
noisy_filters:
- class: stomp_moveit/JointLimits
lock_start: True
lock_goal: True
- class: stomp_moveit/MultiTrajectoryVisualization
line_width: 0.02
rgb: [255, 255, 0]
marker_array_topic: stomp_trajectories
marker_namespace: noisy
update_filters:
- class: stomp_moveit/PolynomialSmoother
poly_order: 6
- class: stomp_moveit/TrajectoryVisualization
line_width: 0.05
rgb: [0, 191, 255]
error_rgb: [255, 0, 0]
publish_intermediate: True
marker_topic: stomp_trajectory
marker_namespace: optimized | 1,264 | YAML | 31.435897 | 106 | 0.631329 |
AndreiVoica/P10-MAP/src/kuka_moveit_configuration/config/kinematics.yaml | arm:
kinematics_solver: kdl_kinematics_plugin/KDLKinematicsPlugin
kinematics_solver_search_resolution: 0.005
kinematics_solver_timeout: 0.005 | 147 | YAML | 35.999991 | 62 | 0.816327 |
AndreiVoica/P10-MAP/src/kuka_moveit_configuration/config/gazebo_controllers.yaml | # Publish joint_states
joint_state_controller:
type: joint_state_controller/JointStateController
publish_rate: 100
| 119 | YAML | 22.999995 | 51 | 0.806723 |
AndreiVoica/P10-MAP/src/kuka_moveit_configuration/config/joint_limits.yaml | # joint_limits.yaml allows the dynamics properties specified in the URDF to be overwritten or augmented as needed
# For beginners, we downscale velocity and acceleration limits.
# You can always specify higher scaling factors (<= 1.0) in your motion requests. # Increase the values below to 1.0 to always move at maximum speed.
default_velocity_scaling_factor: 0.1
default_acceleration_scaling_factor: 0.1
# Specific joint properties can be changed with the keys [max_position, min_position, max_velocity, max_acceleration]
# Joint limits can be turned off with [has_velocity_limits, has_acceleration_limits]
joint_limits:
joint_a1:
has_velocity_limits: true
max_velocity: 9.250245035569947
has_acceleration_limits: false
max_acceleration: 0
joint_a2:
has_velocity_limits: true
max_velocity: 9.232791743050003
has_acceleration_limits: false
max_acceleration: 0
joint_a3:
has_velocity_limits: true
max_velocity: 9.389871375729493
has_acceleration_limits: false
max_acceleration: 0
joint_a4:
has_velocity_limits: true
max_velocity: 10.47197551196598
has_acceleration_limits: false
max_acceleration: 0
joint_a5:
has_velocity_limits: true
max_velocity: 10.47197551196598
has_acceleration_limits: false
max_acceleration: 0
joint_a6:
has_velocity_limits: true
max_velocity: 13.96263401595464
has_acceleration_limits: false
max_acceleration: 0 | 1,447 | YAML | 35.199999 | 150 | 0.744299 |
AndreiVoica/P10-MAP/src/kuka_moveit_configuration/config/fake_controllers.yaml | controller_list:
- name: fake_arm_controller
#type: $(arg fake_execution_type)
joints:
- joint_a1
- joint_a2
- joint_a3
- joint_a4
- joint_a5
- joint_a6
#initial: # Define initial robot poses per group
# - group: arm
# pose: down | 280 | YAML | 20.615383 | 49 | 0.575 |
AndreiVoica/P10-MAP/src/kuka_moveit_configuration/config/ros_controllers.yaml | arm_controller:
type: effort_controllers/JointTrajectoryController
joints:
- joint_a1
- joint_a2
- joint_a3
- joint_a4
- joint_a5
- joint_a6
gains:
joint_a1:
p: 100
d: 1
i: 1
i_clamp: 1
joint_a2:
p: 100
d: 1
i: 1
i_clamp: 1
joint_a3:
p: 100
d: 1
i: 1
i_clamp: 1
joint_a4:
p: 100
d: 1
i: 1
i_clamp: 1
joint_a5:
p: 100
d: 1
i: 1
i_clamp: 1
joint_a6:
p: 100
d: 1
i: 1
i_clamp: 1
#Robot_IP: "192.168.1.15"
Robot_Port: 7000 | 617 | YAML | 13.372093 | 52 | 0.442464 |
AndreiVoica/P10-MAP/src/kuka_moveit_configuration/config/controller.yaml |
controller_joint_names:
- joint_a1
- joint_a2
- joint_a3
- joint_a4
- joint_a5
- joint_a6
#Publish all joint states
joint_state_controller:
type: joint_state_controller/JointStateController
publish_rate: 100
# Joint trajectory controller
position_trajectory_controller:
type: "position_controllers/JointGroupPositionController"
joints:
- joint_a1
- joint_a2
- joint_a3
- joint_a4
- joint_a5
- joint_a6
# Joint trajectory controller
arm_controller:
type: "position_controllers/JointTrajectoryController"
joints:
- joint_a1
- joint_a2
- joint_a3
- joint_a4
- joint_a5
- joint_a6
state_publish_rate: 100 # Defaults to 50
action_monitor_rate: 100 # Defaults to 20
controller_list:
- name: "/move_group/arm_controller"
action_ns: follow_joint_trajectory
type: FollowJointTrajectory
joints:
- joint_a1
- joint_a2
- joint_a3
- joint_a4
- joint_a5
- joint_a6
Robot_Port: 7000
| 1,017 | YAML | 18.576923 | 59 | 0.653884 |
AndreiVoica/P10-MAP/src/kuka_moveit_configuration/config/controller2.yaml | controller_joint_names:
- joint_a1
- joint_a2
- joint_a3
- joint_a4
- joint_a5
- joint_a6
#Publish all joint states
joint_state_controller:
type: joint_state_controller/JointStateController
publish_rate: 100
# Joint trajectory controller
position_trajectory_controller:
type: "position_controllers/JointGroupPositionController"
joints:
- joint_a1
- joint_a2
- joint_a3
- joint_a4
- joint_a5
- joint_a6
# Joint trajectory controller
arm_controller:
type: "position_controllers/JointTrajectoryController"
joints:
- joint_a1
- joint_a2
- joint_a3
- joint_a4
- joint_a5
- joint_a6
state_publish_rate: 100 # Defaults to 50
action_monitor_rate: 100 # Defaults to 20
controller_list:
- name: "/move_group/arm_controller"
action_ns: follow_joint_trajectory
type: FollowJointTrajectory
joints:
- joint_a1
- joint_a2
- joint_a3
- joint_a4
- joint_a5
- joint_a6
Robot_IP: "192.168.1.12"
Robot_Port: 7000
| 1,041 | YAML | 19.038461 | 59 | 0.654179 |
AndreiVoica/P10-MAP/src/kuka_kr4_support/config/opw_parameters_kr4r600.yaml | #
# Parameters for use with IK solvers which support OPW (Ortho-Parallel Wrist)
# kinematic configurations, as described in the paper "An Analytical Solution
# of the Inverse Kinematics Problem of Industrial Serial Manipulators with an
# Ortho-parallel Basis and a Spherical Wrist" by Mathias Brandstötter, Arthur
# Angerer, and Michael Hofbaur (Proceedings of the Austrian Robotics Workshop
# 2014, 22-23 May, 2014, Linz, Austria).
#
# The moveit_opw_kinematics_plugin package provides such a solver.
#
opw_kinematics_geometric_parameters:
a1: 0.0
a2: -0.02
b: 0.0
c1: 0.33
c2: 0.29
c3: 0.31
c4: 0.075
opw_kinematics_joint_offsets: [0.0, deg(-90.0), 0.0, 0.0, 0.0, 0.0]
opw_kinematics_joint_sign_corrections: [-1, 1, 1, -1, 1, -1]
| 772 | YAML | 35.809522 | 77 | 0.703368 |
AndreiVoica/P10-MAP/src/kuka_ros_open_comm/package.xml | <package format="1">
<name>kuka_ros_open_comm</name>
<version>0.12.0</version>
<description>KUKA ROS Open Communication Library.</description>
<maintainer email="[email protected]">Aytaç Kahveci</maintainer>
<license>BSD</license>
<author>Aytaç Kahveci</author>
<buildtool_depend>catkin</buildtool_depend>
<build_depend>roscpp</build_depend>
<run_depend>roscpp</run_depend>
</package>
| 417 | XML | 23.588234 | 73 | 0.726619 |
AndreiVoica/P10-MAP/src/kuka_ros_open_comm/include/kuka_ros_open_comm/KRLAxis.h | /* @author Aytaç Kahveci */
#ifndef KRLAXIS_H
#define KRLAXIS_H
#include <kuka_ros_open_comm/KRLVariable.h>
#include <vector>
#include <string>
#include <map>
#include <stdexcept>
#include <sstream>
#include <algorithm>
/**
* Represents a Axis Struct variable from the KRL language
*
* @author Aytac Kahveci
*/
class KRLAxis
{
public:
template<typename Out>
void split(const std::string &s, char delim, Out result) {
std::stringstream ss;
ss.str(s);
std::string item;
while (std::getline(ss, item, delim)) {
*(result++) = item;
}
}
std::vector<std::string> split(const std::string &s, char delim) {
std::vector<std::string> elems;
split(s, delim, std::back_inserter(elems));
return elems;
}
static inline std::string <rim(std::string &s) {
s.erase(s.begin(), std::find_if(s.begin(), s.end(), std::not1(std::ptr_fun<int, int>(std::isspace))));
return s;
}
static inline std::string &rtrim(std::string &s) {
s.erase(std::find_if(s.rbegin(), s.rend(), std::not1(std::ptr_fun<int, int>(std::isspace))).base(), s.end());
return s;
}
static inline std::string &trim(std::string &s) {
return ltrim(rtrim(s));
}
private:
std::string name_;
long readTime_;
int id_;
KRLVariable *krl_var_;
std::vector<std::string> nodes_;
public:
std::map<std::string, double> map_;
KRLAxis(){}
KRLAxis(std::string name, std::vector<std::string> nodes = {"A1", "A2", "A3", "A4", "A5", "A6"})
{
krl_var_ = new KRLVariable(name);
id_ = krl_var_->getId();
name_ = krl_var_->getName();
nodes_ = nodes;
for(std::string str : nodes)
{
map_.insert(std::pair<std::string,double>(str, 0.0));
}
}
~KRLAxis()
{
delete krl_var_;
}
std::vector<std::string> getNodes()
{
return nodes_;
}
void setA1ToA6(std::vector<double> values) {
if (values.size() != 6) {
throw std::invalid_argument("The number of values should be exatly 6!");
}
setA1(values[0]);
setA2(values[1]);
setA3(values[2]);
setA4(values[3]);
setA5(values[4]);
setA6(values[5]);
}
void setA1(double d)
{
map_["A1"] = d;
}
void setA2(double d)
{
map_["A2"] = d;
}
void setA3(double d)
{
map_["A3"] = d;
}
void setA4(double d)
{
map_["A4"] = d;
}
void setA5(double d)
{
map_["A5"] = d;
}
void setA6(double d)
{
map_["A6"] = d;
}
/**
* Get a double array representation of this object
*
* @return a new double array with the values contained in this struct
*/
std::vector<double> asArray()
{
std::vector<double> arr;
arr.resize(this->getNodes().size());
for (int i = 0; i < arr.size(); i++)
{
arr[i] = map_[this->getNodes()[i]];
}
return arr;
}
std::vector<double> asArrayA1ToA6()
{
std::vector<double> arr = {map_["A1"], map_["A2"], map_["A3"], map_["A4"], map_["A5"], map_["A6"]};
return arr;
}
void setValue(std::string str, std::string obj)
{
std::string::size_type sz;
double db = std::stod(obj, &sz);
map_[str] = db;
}
std::map<std::string, double> getValue()
{
return map_;
}
std::string getStringValue()
{
std::string sb="";
sb.append("{");
unsigned int i = 0;
for(std::string str : nodes_)
{
if(map_.count(str) > 0)
{
double get = map_[str];
map_.erase(map_.find(str));
sb.append(str).append(" ").append(std::to_string(get));
if(!map_.empty() && (i != map_.size()))
{
sb.append(", ");
}
}
}
sb.append("}");
return sb;
}
void setValueFromString(std::string strValue)
{
std::string substring;
if(strValue.find(":") != std::string::npos)
{
std::vector<std::string> split_ = split(strValue,':');
std::string trim_ = trim(split_[1]);
substring = trim_.substr(0, trim_.find('}'));
}
else
{
std::string trim_ = trim(strValue);
substring = trim_.substr(1, trim_.size() - 1);
}
std::vector<std::string> split1 = split(substring,',');
for(std::string n : split1)
{
trim(n);
std::vector<std::string> split2 = split(n, ' ');
setValue(split2[0], split2[1]);
}
}
void update(int id, std::string strValue, long readTime)
{
if( id_ != id)
{
throw std::runtime_error("The returned id does not match the variable id! Should not happen...");
}
readTime_ = readTime;
setValueFromString(strValue);
}
std::vector<unsigned char> getReadCommand()
{
return krl_var_->getReadCommand();
}
std::vector<unsigned char> getWriteCommand()
{
return krl_var_->getWriteCommand(getStringValue());
}
};
#endif
| 5,401 | C | 22.284483 | 118 | 0.495094 |
AndreiVoica/P10-MAP/src/kuka_ros_open_comm/include/kuka_ros_open_comm/KRLVariable.h | /* @author Aytaç Kahveci */
#ifndef KRLVARIABLE_H
#define KRLVARIABLE_H
#include <string>
#include <atomic>
#include <vector>
#include <stdexcept>
class KRLVariable
{
public:
int id_;
std::string name_;
long readTime_ = -1;
public:
KRLVariable(){}
KRLVariable(std::string name)
{
static std::atomic<std::uint32_t> atomicInt { 0 };
name_ = name;
id_ = atomicInt.fetch_add(1, std::memory_order_relaxed);
}
~KRLVariable(){}
int getId()
{
return id_;
}
std::string getName()
{
return name_;
}
long getReadTimeNano()
{
return readTime_;
}
long getReadTimeMillis()
{
return readTime_ / 1000000;
}
double getReadTimeSec()
{
return ((double) readTime_ / 1000000000);
}
std::vector<unsigned char> getReadCommand()
{
std::vector<unsigned char> cmd(name_.c_str(), name_.c_str() + name_.size());
std::vector<unsigned char> header;
std::vector<unsigned char> block;
int varnamelen = cmd.size();
unsigned char hbyte, lbyte;
hbyte = (varnamelen & 0xff00) >> 8;
lbyte = (varnamelen & 0x00ff);
block.push_back(0);
block.push_back(hbyte);
block.push_back(lbyte);
block.insert(block.end(),cmd.begin(),cmd.end());
int blocklength = block.size();
hbyte = ((blocklength & 0xff00) >> 8);
lbyte = (blocklength & 0x00ff);
unsigned char hbytemsg = ((id_ & 0xff00) >> 8);
unsigned char lbytemsg = (id_ & 0x00ff);
header.push_back(hbytemsg);
header.push_back(lbytemsg);
header.push_back(hbyte);
header.push_back(lbyte);
block.insert(block.begin(), header.begin(), header.end());
return block;
}
/*
* The write command. This is what's actually beeing sent to the robot.
* It's a implementation of the OpenShowVar c++ source
* @return the write command
*/
std::vector<unsigned char> getWriteCommand(std::string val)
{
std::vector<unsigned char> cmd(name_.c_str(), name_.c_str() + name_.size());
std::vector<unsigned char> value(val.c_str(), val.c_str() + val.size());
std::vector<unsigned char> header;
std::vector<unsigned char> block;
int varnamelen = cmd.size();
unsigned char hbyte, lbyte;
hbyte = (varnamelen & 0xff00) >> 8;
lbyte = (varnamelen & 0x00ff);
block.push_back((unsigned char) 1);
block.push_back(hbyte);
block.push_back(lbyte);
block.insert(block.end(),cmd.begin(),cmd.end());
int vallen = value.size();
hbyte = (vallen & 0xff00) >> 8;
lbyte = (vallen & 0x00ff);
block.push_back(hbyte);
block.push_back(lbyte);
block.insert(block.end(),value.begin(),value.end());
int blocklength = block.size();
hbyte = ((blocklength & 0xff00) >> 8);
lbyte = (blocklength & 0x00ff);
unsigned char hbytemsg = (id_ & 0xff00) >> 8;
unsigned char lbytemsg = (id_ & 0x00ff);
header.push_back(hbytemsg);
header.push_back(lbytemsg);
header.push_back(hbyte);
header.push_back(lbyte);
block.insert(block.begin(), header.begin(), header.end());
return block;
}
};
#endif
| 3,431 | C | 23.340425 | 85 | 0.556689 |
AndreiVoica/P10-MAP/src/kuka_ros_open_comm/include/kuka_ros_open_comm/KRLE6Pos.h | /* @author Aytaç Kahveci */
#ifndef KRLE6POS_H
#define KRLE6POS_H
#include <kuka_ros_open_comm/KRLFrame.h>
#include <kuka_ros_open_comm/KRLPos.h>
#include <vector>
#include <string>
#include <stdexcept>
class KRLE6Pos : public KRLPos
{
public:
KRLE6Pos(){}
KRLE6Pos(std::string name, std::vector<std::string> nodes = {"X", "Y", "Z", "A", "B", "C", "E1", "E2", "E3", "E4", "E5", "E6", "S", "T"})
:KRLPos(name, nodes)
{
}
~KRLE6Pos(){}
void setE1ToE6(std::vector<double> values)
{
if(values.size() != 6)
{
throw std::invalid_argument("The number of values should be exactly 6!");
}
setE1(values[0]);
setE2(values[1]);
setE3(values[2]);
setE4(values[3]);
setE5(values[4]);
setE6(values[5]);
}
double getE1()
{
return map_["E1"];
}
double getE2()
{
return map_["E2"];
}
double getE3()
{
return map_["E3"];
}
double getE4()
{
return map_["E4"];
}
double getE5()
{
return map_["E5"];
}
double getE6()
{
return map_["E6"];
}
KRLE6Pos setE1(double d)
{
map_.at(getNodes()[6]) = d;
return *this;
}
KRLE6Pos setE2(double d)
{
map_.at(getNodes()[7]) = d;
return *this;
}
KRLE6Pos setE3(double d)
{
map_.at(getNodes()[8]) = d;
return *this;
}
KRLE6Pos setE4(double d)
{
map_.at(getNodes()[9]) = d;
return *this;
}
KRLE6Pos setE5(double d)
{
map_.at(getNodes()[10]) = d;
return *this;
}
KRLE6Pos setE6(double d)
{
map_.at(getNodes()[11]) = d;
return *this;
}
std::vector<double> asArrayE1ToE6()
{
std::vector<double> arr_ = {map_["E1"], map_["E2"],map_["E3"],map_["E4"],map_["E5"],map_["E6"]};
return arr_;
}
};
#endif
| 1,970 | C | 15.991379 | 141 | 0.479695 |
AndreiVoica/P10-MAP/src/kuka_ros_open_comm/include/kuka_ros_open_comm/kuka_client.h | /* @author Aytaç Kahveci */
#ifndef KUKA_ClIENT_H
#define KUKA_ClIENT_H
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <netdb.h>
#include <iostream>
#include <chrono>
#include <stdio.h>
#include <string>
#include <string.h>
#include <ros/ros.h>
#include <netinet/tcp.h>
namespace kuka_hw_interface
{
class kukaClient
{
public:
kukaClient(){}
kukaClient(char* host, int port)
{
sockfd_ = socket(AF_INET, SOCK_STREAM, 0);
if(sockfd_ < 0)
{
ROS_ERROR("ERROR creating a socket");
}
server = gethostbyname(host);
if(server == NULL)
{
ROS_ERROR("ERROR No such host");
}
memset((char*)&serverAddr_, 0, sizeof(serverAddr_));
memcpy((char*)&serverAddr_.sin_addr.s_addr, (char*)server->h_addr, server->h_length);
serverAddr_.sin_port = htons(port);
serverAddr_.sin_family = AF_INET;
if((connect(sockfd_, (struct sockaddr*)&serverAddr_, sizeof(serverAddr_))) < 0)
{
ROS_ERROR("ERROR connecting to the server");
}
}
~kukaClient()
{
close(sockfd_);
}
template <class T>
void readVariable(T *var)
{
std::vector<unsigned char> buffer = var->getReadCommand();
std::vector<unsigned char>::iterator next = buffer.begin();
while (next != buffer.end())
{
int n = send(sockfd_, &(*next), std::distance(next, buffer.end()), 0);
if (n == -1)
{
ROS_ERROR_STREAM("ERROR in readVariable function");
break; // ERROR
}
next += n;
}
char head[7];
int rec=0;
while(rec < sizeof(head))
{
n = recv(sockfd_, &head, sizeof(head)-rec, 0);
if(n < 0)
{
ROS_ERROR_STREAM("ERROR reading header from server");
}
rec += n;
}
char block[getInt(head,2)-3];
rec=0;
while(rec < sizeof(block))
{
n = recv(sockfd_, &block, sizeof(block)-rec, 0);
if(n < 0)
{
ROS_ERROR_STREAM("ERROR reading block from server");
}
rec += n;
}
std::vector<unsigned char> data;
for(char c : head)
{
data.push_back(c);
}
for(char c : block)
{
data.push_back(c);
}
int id = getInt(head, 0);
std::string strValue = "";
for (int i=0; i<data.size(); i++)
{
strValue += data[7+i];
}
ROS_INFO_STREAM("Received value: "<< strValue);
ROS_INFO_STREAM("Received id: "<< id);
var->update(id, strValue, 1);
}
template <class T>
void writeVariable(T *var)
{
std::vector<unsigned char> buffer = var->getWriteCommand();
std::vector<unsigned char>::iterator it = buffer.begin();
while(it != buffer.end())
{
if((n = send(sockfd_, &(*it), std::distance(it,buffer.end()),0)) < 0)
{
ROS_ERROR_STREAM("ERROR in writeVariable function");
break;
}
it += n;
}
char head[7];
int rec=0;
while(rec < sizeof(head))
{
n = recv(sockfd_, &head, sizeof(head)-rec, 0);
if(n < 0)
{
ROS_ERROR_STREAM("ERROR reading header from server");
}
rec += n;
}
char block[getInt(head,2)-3];
rec=0;
while(rec < sizeof(block))
{
n = recv(sockfd_, &block, sizeof(block)-rec, 0);
if(n < 0)
{
ROS_ERROR_STREAM("ERROR reading block from server");
}
rec += n;
}
std::vector<unsigned char> data;
for(char c : head)
{
data.push_back(c);
}
for(char c : block)
{
data.push_back(c);
}
int id = getInt(head, 0);
std::string strValue = "";
for (int i=0; i<data.size(); i++)
{
strValue += data[7+i];
}
ROS_INFO_STREAM("Received value in writeVariable function: "<< strValue);
ROS_INFO_STREAM("Received id in writeVariable function: "<< id);
}
int getInt(char* bytes, int off)
{
int a = (((bytes[off] << 8) & 0xFF00) | (bytes[off + 1] & 0xFF));
return a;
}
private:
int sockfd_, n;
hostent *server;
sockaddr_in serverAddr_, clientAddr_;
};
}
#endif
| 5,282 | C | 28.679775 | 97 | 0.424839 |
AndreiVoica/P10-MAP/src/kuka_ros_open_comm/include/kuka_ros_open_comm/KRLPos.h | /* @author Aytaç Kahveci */
#ifndef KRLPOS_H
#define KRLPOS_H
#include <kuka_ros_open_comm/KRLFrame.h>
#include <vector>
#include <string>
/**
* Represents a Real variable from the KRL language
*/
class KRLPos : public KRLFrame
{
public:
KRLPos(){}
KRLPos(std::string name, std::vector<std::string> nodes = {"X", "Y", "Z", "A", "B", "C", "S", "T"})
: KRLFrame(name, nodes)
{
}
~KRLPos(){}
double getS()
{
return map_["S"];
}
double getT()
{
return map_["T"];
}
void setS(double d)
{
map_.at("S") = d;
}
void setT(double d)
{
map_.at("T") = d;
}
std::vector<double> asArrayXToC()
{
std::vector<double> arr = {map_["X"], map_["Y"], map_["Z"],map_["A"], map_["B"], map_["C"]};
return arr;
}
};
#endif
| 846 | C | 14.125 | 103 | 0.49409 |
AndreiVoica/P10-MAP/src/kuka_ros_open_comm/include/kuka_ros_open_comm/KRLInt.h | /* @author Aytaç Kahveci */
#ifndef KRLINT_H
#define KRLINT_H
#include <kuka_ros_open_comm/KRLVariable.h>
#include <string>
class KRLInt
{
private:
std::string name_;
int id_;
long readTime_;
KRLVariable* krl_var_;
public:
int value_ = (int) NULL;
KRLInt(std::string name)
{
krl_var_ = new KRLVariable(name);
name_ = krl_var_->getName();
id_ = krl_var_->getId();
}
~KRLInt()
{
delete krl_var_;
}
int getValue()
{
return value_;
}
std::string getStringValue()
{
return std::to_string(value_);
}
void setValue(int value)
{
value_ = value;
}
void update(int id, std::string strValue, long readTime)
{
if( id_ != id)
{
throw std::runtime_error("The returned id does not match the variable id! Should not happen...");
}
readTime_ = readTime;
setValueFromString(strValue);
}
std::vector<unsigned char> getReadCommand()
{
return krl_var_->getReadCommand();
}
std::vector<unsigned char> getWriteCommand()
{
return krl_var_->getWriteCommand(getStringValue());
}
private:
void setValueFromString(std::string strValue)
{
std::string::size_type sz;
value_ = std::stoi(strValue, &sz);
}
};
#endif
| 1,356 | C | 17.337838 | 108 | 0.560472 |
AndreiVoica/P10-MAP/src/kuka_ros_open_comm/include/kuka_ros_open_comm/KRLEnum.h | /* @author Aytaç Kahveci */
#ifndef KRLENUM_H
#define KRLENUM_H
#include <kuka_ros_open_comm/KRLVariable.h>
#include <string>
class KRLEnum
{
private:
std::string name_;
int id_;
long readTime_;
KRLVariable* krl_var_;
public:
std::string value_ = (std::string) NULL;
KRLEnum(std::string name)
{
krl_var_ = new KRLVariable(name);
}
~KRLEnum()
{
delete krl_var_;
}
std::string getValue()
{
return value_;
}
std::string getStringValue()
{
return value_;
}
void setValue(std::string value)
{
value_ = value;
}
void update(int id, std::string strValue, long readTime)
{
if( id_ != id)
{
throw std::runtime_error("The returned id does not match the variable id! Should not happen...");
}
readTime_ = readTime;
setValueFromString(strValue);
}
std::vector<unsigned char> getReadCommand()
{
return krl_var_->getReadCommand();
}
std::vector<unsigned char> getWriteCommand()
{
return krl_var_->getWriteCommand(getStringValue());
}
private:
void setValueFromString(std::string strValue)
{
value_ = strValue;
}
};
#endif
| 1,261 | C | 16.774648 | 108 | 0.570975 |
AndreiVoica/P10-MAP/src/kuka_ros_open_comm/include/kuka_ros_open_comm/KRLReal.h | /* @author Aytaç Kahveci */
#ifndef KRLREAL_H
#define KRLREAL_H
#include <kuka_ros_open_comm/KRLVariable.h>
#include <string>
class KRLReal
{
private:
std::string name_;
int id_;
long readTime_;
KRLVariable* krl_var_;
public:
double value_ = (double) NULL;
KRLReal(){}
KRLReal(std::string name)
{
krl_var_ = new KRLVariable(name);
name_ = krl_var_->getName();
id_ = krl_var_->getId();
}
~KRLReal()
{
delete krl_var_;
}
double getValue()
{
return value_;
}
std::string getStringValue()
{
return std::to_string(value_);
}
void update(int id, std::string strValue, long readTime)
{
if( id_ != id)
{
throw std::runtime_error("The returned id does not match the variable id! Should not happen...");
}
readTime_ = readTime;
setValueFromString(strValue);
}
std::vector<unsigned char> getReadCommand()
{
return krl_var_->getReadCommand();
}
std::vector<unsigned char> getWriteCommand()
{
return krl_var_->getWriteCommand(getStringValue());
}
void setValue(double value)
{
value_ = value;
}
private:
void setValueFromString(std::string strValue)
{
std::string::size_type sz;
value_ = std::stod(strValue, &sz);
}
};
#endif
| 1,394 | C | 17.355263 | 108 | 0.56241 |
AndreiVoica/P10-MAP/src/kuka_ros_open_comm/include/kuka_ros_open_comm/KRLStruct.h | /* @author Aytaç Kahveci */
#ifndef KRLSTRUCT_H
#define KRLSTRUCT_H
#include <string>
#include <vector>
#include <map>
#include <sstream>
#include <algorithm>
template <class T>
class KRLStruct
{
public:
KRLStruct(){}
KRLStruct(std::vector<std::string> nodes)
{
nodes_ = nodes;
}
~KRLStruct(){}
/**
* The nodes
* @return the name of the variables that this struct contains
*/
std::vector<std::string> getNodes()
{
return nodes_;
}
};
#endif
| 518 | C | 12.307692 | 66 | 0.596525 |
AndreiVoica/P10-MAP/src/kuka_ros_open_comm/include/kuka_ros_open_comm/KRLE6Axis.h | /* @author Aytaç Kahveci */
#ifndef KRLE6AXIS_H
#define KRLE6AXIS_H
#include <kuka_ros_open_comm/KRLAxis.h>
#include <vector>
#include <string>
#include <stdexcept>
/**
* Represents a E6Axis struct variable from the KRL language
*
* @author Aytac Kahveci
*/
class KRLE6Axis : public KRLAxis
{
public:
KRLE6Axis(){}
KRLE6Axis(std::string name ,std::vector<std::string> nodes = {"A1", "A2", "A3", "A4", "A5", "A6", "E1", "E2", "E3", "E4", "E5", "E6"})
:KRLAxis(name,nodes)
{
}
~KRLE6Axis(){}
void setE1ToE6(std::vector<double> values)
{
if (values.size() != 6)
{
throw std::invalid_argument("The number of values should be exatly 6!");
}
setE1(values[0]);
setE2(values[1]);
setE3(values[2]);
setE4(values[3]);
setE5(values[4]);
setE6(values[5]);
}
void setE1(double d)
{
map_.at(getNodes()[6]) = d;
}
void setE2(double d)
{
map_.at(getNodes()[7]) = d;
}
void setE3(double d)
{
map_.at(getNodes()[8]) = d;
}
void setE4(double d)
{
map_.at(getNodes()[9]) = d;
}
void setE5(double d)
{
map_.at(getNodes()[10]) = d;
}
void setE6(double d)
{
map_.at(getNodes()[11]) = d;
}
std::vector<double> asArrayE1ToE6()
{
std::vector<double> arr {map_["E1"], map_["E2"],map_["E3"],map_["E4"],map_["E5"],map_["E6"]};
return arr;
}
};
#endif
| 1,526 | C | 17.178571 | 138 | 0.509174 |
AndreiVoica/P10-MAP/src/kuka_ros_open_comm/include/kuka_ros_open_comm/KRLFrame.h | /* @author Aytaç Kahveci */
#ifndef KRLFRAME_H
#define KRLFRAME_H
#include <kuka_ros_open_comm/KRLVariable.h>
#include <string>
#include <vector>
#include <map>
#include <stdexcept>
#include <algorithm>
#include <iostream>
#include <sstream>
/**
* Represents a Frame struct variable from the KRL language
*
* @author Aytaç Kahveci
*/
class KRLFrame
{
public:
template<typename Out>
void split(const std::string &s, char delim, Out result) {
std::stringstream ss;
ss.str(s);
std::string item;
while (std::getline(ss, item, delim)) {
*(result++) = item;
}
}
std::vector<std::string> split(const std::string &s, char delim) {
std::vector<std::string> elems;
split(s, delim, std::back_inserter(elems));
return elems;
}
static inline std::string <rim(std::string &s) {
s.erase(s.begin(), std::find_if(s.begin(), s.end(), std::not1(std::ptr_fun<int, int>(std::isspace))));
return s;
}
static inline std::string &rtrim(std::string &s) {
s.erase(std::find_if(s.rbegin(), s.rend(), std::not1(std::ptr_fun<int, int>(std::isspace))).base(), s.end());
return s;
}
static inline std::string &trim(std::string &s) {
return ltrim(rtrim(s));
}
private:
std::string name_;
long readTime_;
int id_;
KRLVariable *krl_variable_;
std::vector<std::string> nodes_;
public:
std::map<std::string, double> map_;
KRLFrame(){}
KRLFrame(std::string name, std::vector<std::string> nodes = {"X", "Y", "Z", "A", "B", "C"})
{
krl_variable_ = new KRLVariable(name);
id_ = krl_variable_->getId();
name_ = krl_variable_->getName();
nodes_ = nodes;
for(std::string str : nodes_)
{
map_.insert(std::pair<std::string,double>(str, 0.0));
}
}
~KRLFrame()
{}
std::vector<std::string> getNodes()
{
return nodes_;
}
double getX() {
return map_["X"];
}
double getY() {
return map_["Y"];
}
double getZ() {
return map_["Z"];
}
double getA() {
return map_["A"];
}
double getB() {
return map_["B"];
}
double getC() {
return map_["C"];
}
KRLFrame setX(double d) {
map_[getNodes()[0]] = d;
return *this;
}
KRLFrame setY(double d) {
map_[getNodes()[1]] = d;
return *this;
}
KRLFrame setZ(double d) {
map_[getNodes()[2]] = d;
return *this;
}
KRLFrame setA(double d) {
map_[getNodes()[3]] = d;
return *this;
}
KRLFrame setB(double d) {
map_[getNodes()[4]] = d;
return *this;
}
KRLFrame setC(double d) {
map_[getNodes()[5]] = d;
return *this;
}
void setXToZ(std::vector<double> values)
{
if(values.size() != 3)
{
throw std::invalid_argument("The number of values should be exatly 3!");
}
setX(values[0]);
setY(values[1]);
setZ(values[2]);
}
void setAToC(std::vector<double> values)
{
if(values.size() != 3)
{
throw std::invalid_argument("The number of values should be exactly 3!");
}
setA(values[0]);
setB(values[1]);
setC(values[2]);
}
std::vector<double> asArray() {
std::vector<double> arr;
arr.resize(getNodes().size());
for (int i = 0; i < arr.size(); i++) {
arr[i] = map_[getNodes()[i]];
}
return arr;
}
std::vector<double> asArrayXToZ() {
std::vector<double> arr = {map_["X"], map_["Y"], map_["Z"]};
return arr;
}
std::vector<double> asArrayAToC() {
std::vector<double> arr = {map_["A"], map_["B"], map_["C"]};
return arr;
}
void setValue(std::string str, std::string obj) {
std::string::size_type sz;
double db = std::stod(obj, &sz);
map_[str] = db;
}
std::map<std::string, double> getValue() {
return map_;
}
std::string getStringValue()
{
std::string sb;
sb.append("{");
unsigned int i = 0;
for(std::string str : nodes_)
{
if(map_.count(str) > 0)
{
double get = map_[str];
map_.erase(map_.find(str));
sb.append(str).append(" ").append(std::to_string(get));
if(!map_.empty() && (i != map_.size()))
{
sb.append(", ");
}
}
}
sb.append("}");
return sb;
}
void setValueFromString(std::string strValue)
{
std::string substring;
if(strValue.find(":") != std::string::npos)
{
std::vector<std::string> split_ = split(strValue,':');
std::string trim_ = trim(split_[1]);
substring = trim_.substr(0, trim_.find('}'));
}
else
{
std::string trim_ = trim(strValue);
substring = trim_.substr(1, trim_.size() - 1);
}
std::vector<std::string> split1 = split(substring,',');
for(std::string n : split1)
{
trim(n);
std::vector<std::string> split2 = split(n, ' ');
setValue(split2[0], split2[1]);
}
}
void update(int id, std::string strValue, long readTime)
{
if( id_ != id)
{
throw std::runtime_error("The returned id does not match the variable id! Should not happen...");
}
readTime_ = readTime;
setValueFromString(strValue);
}
std::vector<unsigned char> getReadCommand()
{
return krl_variable_->getReadCommand();
}
std::vector<unsigned char> getWriteCommand()
{
return krl_variable_->getWriteCommand(getStringValue());
}
};
#endif
| 5,987 | C | 22.030769 | 117 | 0.498079 |
AndreiVoica/P10-MAP/src/kr3_config_pipette/package.xml | <package>
<name>kr3_config_pipette</name>
<version>0.3.0</version>
<description>
An automatically generated package with all the configuration and launch files for using the kuka_kr3r540 with the MoveIt Motion Planning Framework
</description>
<author email="[email protected]">Andrei Voica</author>
<maintainer email="[email protected]">Andrei Voica</maintainer>
<license>BSD</license>
<url type="website">http://moveit.ros.org/</url>
<url type="bugtracker">https://github.com/ros-planning/moveit/issues</url>
<url type="repository">https://github.com/ros-planning/moveit</url>
<buildtool_depend>catkin</buildtool_depend>
<run_depend>moveit_ros_move_group</run_depend>
<run_depend>moveit_fake_controller_manager</run_depend>
<run_depend>moveit_kinematics</run_depend>
<run_depend>moveit_planners</run_depend>
<run_depend>moveit_ros_visualization</run_depend>
<run_depend>moveit_setup_assistant</run_depend>
<run_depend>moveit_simple_controller_manager</run_depend>
<run_depend>joint_state_publisher</run_depend>
<run_depend>joint_state_publisher_gui</run_depend>
<run_depend>robot_state_publisher</run_depend>
<run_depend>rviz</run_depend>
<run_depend>tf2_ros</run_depend>
<run_depend>xacro</run_depend>
<!-- The next 2 packages are required for the gazebo simulation.
We don't include them by default to prevent installing gazebo and all its dependencies. -->
<!-- <run_depend>joint_trajectory_controller</run_depend> -->
<!-- <run_depend>gazebo_ros_control</run_depend> -->
<!-- This package is referenced in the warehouse launch files, but does not build out of the box at the moment. Commented the dependency until this works. -->
<!-- <run_depend>warehouse_ros_mongo</run_depend> -->
<run_depend>kuka_kr3_support</run_depend>
</package>
| 1,834 | XML | 42.690475 | 160 | 0.731734 |
AndreiVoica/P10-MAP/src/kr3_config_pipette/launch/sensor_manager.launch.xml | <launch>
<!-- This file makes it easy to include the settings for sensor managers -->
<!-- Params for 3D sensors config -->
<rosparam command="load" file="$(find kr3_config_pipette)/config/sensors_3d.yaml" />
<!-- Params for the octomap monitor -->
<!-- <param name="octomap_frame" type="string" value="some frame in which the robot moves" /> -->
<param name="octomap_resolution" type="double" value="0.025" />
<param name="max_range" type="double" value="5.0" />
<!-- Load the robot specific sensor manager; this sets the moveit_sensor_manager ROS parameter -->
<arg name="moveit_sensor_manager" default="kuka_kr3r540" />
<include file="$(dirname)/$(arg moveit_sensor_manager)_moveit_sensor_manager.launch.xml" />
</launch>
| 751 | XML | 40.777776 | 100 | 0.680426 |
AndreiVoica/P10-MAP/src/kr3_config_pipette/launch/kuka_kr3r540_moveit_sensor_manager.launch.xml | <launch>
</launch>
| 20 | XML | 4.249999 | 9 | 0.6 |
AndreiVoica/P10-MAP/src/kr3_config_pipette/launch/fake_moveit_controller_manager.launch.xml | <launch>
<!-- execute the trajectory in 'interpolate' mode or jump to goal position in 'last point' mode -->
<arg name="fake_execution_type" default="interpolate" />
<!-- Set the param that trajectory_execution_manager needs to find the controller plugin -->
<param name="moveit_controller_manager" value="moveit_fake_controller_manager/MoveItFakeControllerManager"/>
<!-- The rest of the params are specific to this plugin -->
<rosparam subst_value="true" file="$(find kr3_config_pipette)/config/fake_controllers.yaml"/>
</launch>
| 548 | XML | 41.230766 | 110 | 0.729927 |
AndreiVoica/P10-MAP/src/kr3_config_pipette/launch/stomp_planning_pipeline.launch.xml | <launch>
<!-- Stomp Plugin for MoveIt -->
<arg name="planning_plugin" value="stomp_moveit/StompPlannerManager" />
<arg name="start_state_max_bounds_error" value="0.1" />
<arg name="jiggle_fraction" value="0.05" />
<!-- The request adapters (plugins) used when planning. ORDER MATTERS! -->
<arg name="planning_adapters"
default="default_planner_request_adapters/LimitMaxCartesianLinkSpeed
default_planner_request_adapters/AddTimeParameterization
default_planner_request_adapters/FixWorkspaceBounds
default_planner_request_adapters/FixStartStateBounds
default_planner_request_adapters/FixStartStateCollision
default_planner_request_adapters/FixStartStatePathConstraints" />
<param name="planning_plugin" value="$(arg planning_plugin)" />
<param name="request_adapters" value="$(arg planning_adapters)" />
<param name="start_state_max_bounds_error" value="$(arg start_state_max_bounds_error)" />
<param name="jiggle_fraction" value="$(arg jiggle_fraction)" />
<rosparam command="load" file="$(find kr3_config_pipette)/config/stomp_planning.yaml"/>
</launch>
| 1,168 | XML | 47.708331 | 91 | 0.699486 |
AndreiVoica/P10-MAP/src/kr3_config_pipette/launch/pilz_industrial_motion_planner_planning_pipeline.launch.xml | <launch>
<!-- The request adapters (plugins) used when planning. ORDER MATTERS! -->
<arg name="planning_adapters" default="" />
<param name="planning_plugin" value="pilz_industrial_motion_planner::CommandPlanner" />
<param name="request_adapters" value="$(arg planning_adapters)" />
<!-- Define default planner (for all groups) -->
<param name="default_planner_config" value="PTP" />
<!-- MoveGroup capabilities to load for this pipeline, append sequence capability -->
<param name="capabilities" value="pilz_industrial_motion_planner/MoveGroupSequenceAction
pilz_industrial_motion_planner/MoveGroupSequenceService" />
</launch>
| 685 | XML | 41.874997 | 95 | 0.691971 |
AndreiVoica/P10-MAP/src/kr3_config_pipette/launch/simple_moveit_controller_manager.launch.xml | <launch>
<!-- Define the MoveIt controller manager plugin to use for trajectory execution -->
<param name="moveit_controller_manager" value="moveit_simple_controller_manager/MoveItSimpleControllerManager" />
<!-- Load controller list to the parameter server -->
<rosparam file="$(find kr3_config_pipette)/config/simple_moveit_controllers.yaml" />
<rosparam file="$(find kr3_config_pipette)/config/ros_controllers.yaml" />
</launch>
| 443 | XML | 48.333328 | 115 | 0.747178 |
AndreiVoica/P10-MAP/src/kr3_config_pipette/launch/chomp_planning_pipeline.launch.xml | <launch>
<arg name="start_state_max_bounds_error" default="0.1" />
<arg name="jiggle_fraction" default="0.05" />
<!-- The request adapters (plugins) used when planning. ORDER MATTERS! -->
<arg name="planning_adapters"
default="default_planner_request_adapters/LimitMaxCartesianLinkSpeed
default_planner_request_adapters/AddTimeParameterization
default_planner_request_adapters/ResolveConstraintFrames
default_planner_request_adapters/FixWorkspaceBounds
default_planner_request_adapters/FixStartStateBounds
default_planner_request_adapters/FixStartStateCollision
default_planner_request_adapters/FixStartStatePathConstraints"
/>
<param name="planning_plugin" value="chomp_interface/CHOMPPlanner" />
<param name="request_adapters" value="$(arg planning_adapters)" />
<param name="start_state_max_bounds_error" value="$(arg start_state_max_bounds_error)" />
<param name="jiggle_fraction" value="$(arg jiggle_fraction)" />
<rosparam command="load" file="$(find kr3_config_pipette)/config/chomp_planning.yaml" />
</launch>
| 1,157 | XML | 51.636361 | 91 | 0.696629 |
AndreiVoica/P10-MAP/src/kr3_config_pipette/launch/ros_control_moveit_controller_manager.launch.xml | <launch>
<!-- Define MoveIt controller manager plugin -->
<param name="moveit_controller_manager" value="moveit_ros_control_interface::MoveItControllerManager" />
</launch>
| 175 | XML | 34.199993 | 105 | 0.754286 |
AndreiVoica/P10-MAP/src/kr3_config_pipette/launch/ompl-chomp_planning_pipeline.launch.xml | <launch>
<!-- load OMPL planning pipeline, but add the CHOMP planning adapter. -->
<include file="$(find kr3_config_pipette)/launch/ompl_planning_pipeline.launch.xml">
<arg name="planning_adapters"
default="default_planner_request_adapters/LimitMaxCartesianLinkSpeed
default_planner_request_adapters/AddTimeParameterization
default_planner_request_adapters/FixWorkspaceBounds
default_planner_request_adapters/FixStartStateBounds
default_planner_request_adapters/FixStartStateCollision
default_planner_request_adapters/FixStartStatePathConstraints
chomp/OptimizerAdapter"
/>
</include>
<!-- load chomp config -->
<rosparam command="load" file="$(find kr3_config_pipette)/config/chomp_planning.yaml" />
<!-- override trajectory_initialization_method: Use OMPL-generated trajectory -->
<param name="trajectory_initialization_method" value="fillTrajectory"/>
</launch>
| 1,020 | XML | 47.619045 | 90 | 0.688235 |
AndreiVoica/P10-MAP/src/kr3_config_pipette/launch/planning_pipeline.launch.xml | <launch>
<!-- This file makes it easy to include different planning pipelines;
It is assumed that all planning pipelines are named XXX_planning_pipeline.launch -->
<arg name="pipeline" default="ompl" />
<include ns="$(arg pipeline)" file="$(dirname)/$(arg pipeline)_planning_pipeline.launch.xml" />
</launch>
| 327 | XML | 28.818179 | 97 | 0.69419 |
AndreiVoica/P10-MAP/src/kr3_config_pipette/launch/warehouse_settings.launch.xml | <launch>
<!-- Set the parameters for the warehouse and run the mongodb server. -->
<!-- The default DB port for moveit (not default MongoDB port to avoid potential conflicts) -->
<arg name="moveit_warehouse_port" default="33829" />
<!-- The default DB host for moveit -->
<arg name="moveit_warehouse_host" default="localhost" />
<!-- Set parameters for the warehouse -->
<param name="warehouse_port" value="$(arg moveit_warehouse_port)"/>
<param name="warehouse_host" value="$(arg moveit_warehouse_host)"/>
<param name="warehouse_exec" value="mongod" />
<param name="warehouse_plugin" value="warehouse_ros_mongo::MongoDatabaseConnection" />
</launch>
| 675 | XML | 38.764704 | 97 | 0.694815 |
AndreiVoica/P10-MAP/src/kr3_config_pipette/launch/trajectory_execution.launch.xml | <launch>
<!-- This file summarizes all settings required for trajectory execution -->
<!-- Define moveit controller manager plugin: fake, simple, or ros_control -->
<arg name="moveit_controller_manager" />
<arg name="fake_execution_type" default="interpolate" />
<!-- Flag indicating whether MoveIt is allowed to load/unload or switch controllers -->
<arg name="moveit_manage_controllers" default="true"/>
<param name="moveit_manage_controllers" value="$(arg moveit_manage_controllers)"/>
<!-- When determining the expected duration of a trajectory, this multiplicative factor is applied to get the allowed duration of execution -->
<param name="trajectory_execution/allowed_execution_duration_scaling" value="1.2"/> <!-- default 1.2 -->
<!-- Allow more than the expected execution time before triggering a trajectory cancel (applied after scaling) -->
<param name="trajectory_execution/allowed_goal_duration_margin" value="0.5"/> <!-- default 0.5 -->
<!-- Allowed joint-value tolerance for validation that trajectory's first point matches current robot state -->
<param name="trajectory_execution/allowed_start_tolerance" value="0.01"/> <!-- default 0.01 -->
<!-- We use pass_all_args=true here to pass fake_execution_type, which is required by fake controllers, but not by real-robot controllers.
As real-robot controller_manager.launch files shouldn't be required to define this argument, we use the trick of passing all args. -->
<include file="$(dirname)/$(arg moveit_controller_manager)_moveit_controller_manager.launch.xml" pass_all_args="true" />
</launch>
| 1,609 | XML | 66.083331 | 145 | 0.73151 |
AndreiVoica/P10-MAP/src/kr3_config_pipette/launch/ompl_planning_pipeline.launch.xml | <launch>
<!-- The request adapters (plugins) used when planning with OMPL. ORDER MATTERS! -->
<arg name="planning_adapters"
default="default_planner_request_adapters/LimitMaxCartesianLinkSpeed
default_planner_request_adapters/AddTimeParameterization
default_planner_request_adapters/ResolveConstraintFrames
default_planner_request_adapters/FixWorkspaceBounds
default_planner_request_adapters/FixStartStateBounds
default_planner_request_adapters/FixStartStateCollision
default_planner_request_adapters/FixStartStatePathConstraints"
/>
<arg name="start_state_max_bounds_error" default="0.1" />
<arg name="jiggle_fraction" default="0.05" />
<param name="planning_plugin" value="ompl_interface/OMPLPlanner" />
<param name="request_adapters" value="$(arg planning_adapters)" />
<param name="start_state_max_bounds_error" value="$(arg start_state_max_bounds_error)" />
<param name="jiggle_fraction" value="$(arg jiggle_fraction)" />
<rosparam command="load" file="$(find kr3_config_pipette)/config/ompl_planning.yaml"/>
</launch>
| 1,166 | XML | 45.679998 | 91 | 0.69554 |
AndreiVoica/P10-MAP/src/kr3_config_pipette/config/simple_moveit_controllers.yaml | controller_list:
- name: arm_controller
action_ns: follow_joint_trajectory
type: FollowJointTrajectory
default: True
joints:
- joint_a1
- joint_a2
- joint_a3
- joint_a4
- joint_a5
- joint_a6 | 244 | YAML | 19.416665 | 38 | 0.590164 |
AndreiVoica/P10-MAP/src/kr3_config_pipette/config/chomp_planning.yaml | planning_time_limit: 10.0
max_iterations: 200
max_iterations_after_collision_free: 5
smoothness_cost_weight: 0.1
obstacle_cost_weight: 1.0
learning_rate: 0.01
smoothness_cost_velocity: 0.0
smoothness_cost_acceleration: 1.0
smoothness_cost_jerk: 0.0
ridge_factor: 0.0
use_pseudo_inverse: false
pseudo_inverse_ridge_factor: 1e-4
joint_update_limit: 0.1
collision_clearance: 0.2
collision_threshold: 0.07
use_stochastic_descent: true
enable_failure_recovery: false
max_recovery_attempts: 5
| 487 | YAML | 24.684209 | 38 | 0.794661 |
AndreiVoica/P10-MAP/src/kr3_config_pipette/config/stomp_planning.yaml | stomp/arm:
group_name: arm
optimization:
num_timesteps: 60
num_iterations: 40
num_iterations_after_valid: 0
num_rollouts: 30
max_rollouts: 30
initialization_method: 1 # [1 : LINEAR_INTERPOLATION, 2 : CUBIC_POLYNOMIAL, 3 : MININUM_CONTROL_COST]
control_cost_weight: 0.0
task:
noise_generator:
- class: stomp_moveit/NormalDistributionSampling
stddev: [0.05, 0.05, 0.05, 0.05, 0.05, 0.05]
cost_functions:
- class: stomp_moveit/CollisionCheck
collision_penalty: 1.0
cost_weight: 1.0
kernel_window_percentage: 0.2
longest_valid_joint_move: 0.05
noisy_filters:
- class: stomp_moveit/JointLimits
lock_start: True
lock_goal: True
- class: stomp_moveit/MultiTrajectoryVisualization
line_width: 0.02
rgb: [255, 255, 0]
marker_array_topic: stomp_trajectories
marker_namespace: noisy
update_filters:
- class: stomp_moveit/PolynomialSmoother
poly_order: 6
- class: stomp_moveit/TrajectoryVisualization
line_width: 0.05
rgb: [0, 191, 255]
error_rgb: [255, 0, 0]
publish_intermediate: True
marker_topic: stomp_trajectory
marker_namespace: optimized
stomp/hand:
group_name: hand
optimization:
num_timesteps: 60
num_iterations: 40
num_iterations_after_valid: 0
num_rollouts: 30
max_rollouts: 30
initialization_method: 1 # [1 : LINEAR_INTERPOLATION, 2 : CUBIC_POLYNOMIAL, 3 : MININUM_CONTROL_COST]
control_cost_weight: 0.0
task:
noise_generator:
- class: stomp_moveit/NormalDistributionSampling
stddev: []
cost_functions:
- class: stomp_moveit/CollisionCheck
collision_penalty: 1.0
cost_weight: 1.0
kernel_window_percentage: 0.2
longest_valid_joint_move: 0.05
noisy_filters:
- class: stomp_moveit/JointLimits
lock_start: True
lock_goal: True
- class: stomp_moveit/MultiTrajectoryVisualization
line_width: 0.02
rgb: [255, 255, 0]
marker_array_topic: stomp_trajectories
marker_namespace: noisy
update_filters:
- class: stomp_moveit/PolynomialSmoother
poly_order: 6
- class: stomp_moveit/TrajectoryVisualization
line_width: 0.05
rgb: [0, 191, 255]
error_rgb: [255, 0, 0]
publish_intermediate: True
marker_topic: stomp_trajectory
marker_namespace: optimized | 2,497 | YAML | 31.025641 | 106 | 0.632759 |
AndreiVoica/P10-MAP/src/kr3_config_pipette/config/kinematics.yaml | arm:
kinematics_solver: kdl_kinematics_plugin/KDLKinematicsPlugin
kinematics_solver_search_resolution: 0.005
kinematics_solver_timeout: 0.005 | 147 | YAML | 35.999991 | 62 | 0.816327 |
AndreiVoica/P10-MAP/src/kr3_config_pipette/config/gazebo_controllers.yaml | # Publish joint_states
joint_state_controller:
type: joint_state_controller/JointStateController
publish_rate: 50
| 118 | YAML | 22.799995 | 51 | 0.805085 |
AndreiVoica/P10-MAP/src/kr3_config_pipette/config/joint_limits.yaml | # joint_limits.yaml allows the dynamics properties specified in the URDF to be overwritten or augmented as needed
# For beginners, we downscale velocity and acceleration limits.
# You can always specify higher scaling factors (<= 1.0) in your motion requests. # Increase the values below to 1.0 to always move at maximum speed.
default_velocity_scaling_factor: 0.1
default_acceleration_scaling_factor: 0.1
# Specific joint properties can be changed with the keys [max_position, min_position, max_velocity, max_acceleration]
# Joint limits can be turned off with [has_velocity_limits, has_acceleration_limits]
joint_limits:
joint_a1:
has_velocity_limits: true
max_velocity: 9.250245035569947
has_acceleration_limits: false
max_acceleration: 0
joint_a2:
has_velocity_limits: true
max_velocity: 9.232791743050003
has_acceleration_limits: false
max_acceleration: 0
joint_a3:
has_velocity_limits: true
max_velocity: 9.389871375729493
has_acceleration_limits: false
max_acceleration: 0
joint_a4:
has_velocity_limits: true
max_velocity: 10.47197551196598
has_acceleration_limits: false
max_acceleration: 0
joint_a5:
has_velocity_limits: true
max_velocity: 10.47197551196598
has_acceleration_limits: false
max_acceleration: 0
joint_a6:
has_velocity_limits: true
max_velocity: 13.96263401595464
has_acceleration_limits: false
max_acceleration: 0 | 1,447 | YAML | 35.199999 | 150 | 0.744299 |
AndreiVoica/P10-MAP/src/kr3_config_pipette/config/fake_controllers.yaml | controller_list:
- name: fake_arm_controller
type: $(arg fake_execution_type)
joints:
- joint_a1
- joint_a2
- joint_a3
- joint_a4
- joint_a5
- joint_a6
- name: fake_hand_controller
type: $(arg fake_execution_type)
joints:
[]
initial: # Define initial robot poses per group
- group: arm
pose: down | 365 | YAML | 20.529411 | 48 | 0.583562 |
AndreiVoica/P10-MAP/src/kr3_config_pipette/config/ros_controllers.yaml | arm_controller:
type: effort_controllers/JointTrajectoryController
joints:
- joint_a1
- joint_a2
- joint_a3
- joint_a4
- joint_a5
- joint_a6
gains:
joint_a1:
p: 100
d: 1
i: 1
i_clamp: 1
joint_a2:
p: 100
d: 1
i: 1
i_clamp: 1
joint_a3:
p: 100
d: 1
i: 1
i_clamp: 1
joint_a4:
p: 100
d: 1
i: 1
i_clamp: 1
joint_a5:
p: 100
d: 1
i: 1
i_clamp: 1
joint_a6:
p: 100
d: 1
i: 1
i_clamp: 1 | 573 | YAML | 13.35 | 52 | 0.425829 |
AndreiVoica/P10-MAP/src/kuka_config_multiple/package.xml | <package>
<name>kuka_config_multiple</name>
<version>0.3.0</version>
<description>
An automatically generated package with all the configuration and launch files for using the kuka_multiple_arms with the MoveIt Motion Planning Framework
</description>
<author email="[email protected]">Andrei Voica</author>
<maintainer email="[email protected]">Andrei Voica</maintainer>
<license>BSD</license>
<url type="website">http://moveit.ros.org/</url>
<url type="bugtracker">https://github.com/ros-planning/moveit/issues</url>
<url type="repository">https://github.com/ros-planning/moveit</url>
<buildtool_depend>catkin</buildtool_depend>
<run_depend>moveit_ros_move_group</run_depend>
<run_depend>moveit_fake_controller_manager</run_depend>
<run_depend>moveit_kinematics</run_depend>
<run_depend>moveit_planners</run_depend>
<run_depend>moveit_ros_visualization</run_depend>
<run_depend>moveit_setup_assistant</run_depend>
<run_depend>moveit_simple_controller_manager</run_depend>
<run_depend>joint_state_publisher</run_depend>
<run_depend>joint_state_publisher_gui</run_depend>
<run_depend>robot_state_publisher</run_depend>
<run_depend>rviz</run_depend>
<run_depend>tf2_ros</run_depend>
<run_depend>xacro</run_depend>
<!-- The next 2 packages are required for the gazebo simulation.
We don't include them by default to prevent installing gazebo and all its dependencies. -->
<!-- <run_depend>joint_trajectory_controller</run_depend> -->
<!-- <run_depend>gazebo_ros_control</run_depend> -->
<!-- This package is referenced in the warehouse launch files, but does not build out of the box at the moment. Commented the dependency until this works. -->
<!-- <run_depend>warehouse_ros_mongo</run_depend> -->
<run_depend>kuka_multiple_arms</run_depend>
</package>
| 1,844 | XML | 42.92857 | 160 | 0.732646 |
AndreiVoica/P10-MAP/src/kuka_config_multiple/launch/sensor_manager.launch.xml | <launch>
<!-- This file makes it easy to include the settings for sensor managers -->
<!-- Params for 3D sensors config -->
<rosparam command="load" file="$(find kuka_config_multiple)/config/sensors_3d.yaml" />
<!-- Params for the octomap monitor -->
<!-- <param name="octomap_frame" type="string" value="some frame in which the robot moves" /> -->
<param name="octomap_resolution" type="double" value="0.025" />
<param name="max_range" type="double" value="5.0" />
<!-- Load the robot specific sensor manager; this sets the moveit_sensor_manager ROS parameter -->
<arg name="moveit_sensor_manager" default="kuka_multiple_arms" />
<include file="$(dirname)/$(arg moveit_sensor_manager)_moveit_sensor_manager.launch.xml" />
</launch>
| 759 | XML | 41.22222 | 100 | 0.682477 |
AndreiVoica/P10-MAP/src/kuka_config_multiple/launch/fake_moveit_controller_manager.launch.xml | <launch>
<!-- execute the trajectory in 'interpolate' mode or jump to goal position in 'last point' mode -->
<arg name="fake_execution_type" default="interpolate" />
<!-- Set the param that trajectory_execution_manager needs to find the controller plugin -->
<param name="moveit_controller_manager" value="moveit_fake_controller_manager/MoveItFakeControllerManager"/>
<!-- The rest of the params are specific to this plugin -->
<rosparam subst_value="true" file="$(find kuka_config_multiple)/config/fake_controllers.yaml"/>
</launch>
| 550 | XML | 41.384612 | 110 | 0.730909 |
AndreiVoica/P10-MAP/src/kuka_config_multiple/launch/stomp_planning_pipeline.launch.xml | <launch>
<!-- Stomp Plugin for MoveIt -->
<arg name="planning_plugin" value="stomp_moveit/StompPlannerManager" />
<arg name="start_state_max_bounds_error" value="0.1" />
<arg name="jiggle_fraction" value="0.05" />
<!-- The request adapters (plugins) used when planning. ORDER MATTERS! -->
<arg name="planning_adapters"
default="default_planner_request_adapters/LimitMaxCartesianLinkSpeed
default_planner_request_adapters/AddTimeParameterization
default_planner_request_adapters/FixWorkspaceBounds
default_planner_request_adapters/FixStartStateBounds
default_planner_request_adapters/FixStartStateCollision
default_planner_request_adapters/FixStartStatePathConstraints" />
<param name="planning_plugin" value="$(arg planning_plugin)" />
<param name="request_adapters" value="$(arg planning_adapters)" />
<param name="start_state_max_bounds_error" value="$(arg start_state_max_bounds_error)" />
<param name="jiggle_fraction" value="$(arg jiggle_fraction)" />
<rosparam command="load" file="$(find kuka_config_multiple)/config/stomp_planning.yaml"/>
</launch>
| 1,170 | XML | 47.791665 | 91 | 0.7 |
AndreiVoica/P10-MAP/src/kuka_config_multiple/launch/pilz_industrial_motion_planner_planning_pipeline.launch.xml | <launch>
<!-- The request adapters (plugins) used when planning. ORDER MATTERS! -->
<arg name="planning_adapters" default="" />
<param name="planning_plugin" value="pilz_industrial_motion_planner::CommandPlanner" />
<param name="request_adapters" value="$(arg planning_adapters)" />
<!-- Define default planner (for all groups) -->
<param name="default_planner_config" value="PTP" />
<!-- MoveGroup capabilities to load for this pipeline, append sequence capability -->
<param name="capabilities" value="pilz_industrial_motion_planner/MoveGroupSequenceAction
pilz_industrial_motion_planner/MoveGroupSequenceService" />
</launch>
| 685 | XML | 41.874997 | 95 | 0.691971 |
AndreiVoica/P10-MAP/src/kuka_config_multiple/launch/simple_moveit_controller_manager.launch.xml | <launch>
<!-- Define the MoveIt controller manager plugin to use for trajectory execution -->
<param name="moveit_controller_manager" value="moveit_simple_controller_manager/MoveItSimpleControllerManager" />
<!-- Load controller list to the parameter server -->
<rosparam file="$(find kuka_config_multiple)/config/simple_moveit_controllers.yaml" />
<rosparam file="$(find kuka_config_multiple)/config/ros_controllers.yaml" />
</launch>
| 447 | XML | 48.777772 | 115 | 0.749441 |
AndreiVoica/P10-MAP/src/kuka_config_multiple/launch/chomp_planning_pipeline.launch.xml | <launch>
<arg name="start_state_max_bounds_error" default="0.1" />
<arg name="jiggle_fraction" default="0.05" />
<!-- The request adapters (plugins) used when planning. ORDER MATTERS! -->
<arg name="planning_adapters"
default="default_planner_request_adapters/LimitMaxCartesianLinkSpeed
default_planner_request_adapters/AddTimeParameterization
default_planner_request_adapters/ResolveConstraintFrames
default_planner_request_adapters/FixWorkspaceBounds
default_planner_request_adapters/FixStartStateBounds
default_planner_request_adapters/FixStartStateCollision
default_planner_request_adapters/FixStartStatePathConstraints"
/>
<param name="planning_plugin" value="chomp_interface/CHOMPPlanner" />
<param name="request_adapters" value="$(arg planning_adapters)" />
<param name="start_state_max_bounds_error" value="$(arg start_state_max_bounds_error)" />
<param name="jiggle_fraction" value="$(arg jiggle_fraction)" />
<rosparam command="load" file="$(find kuka_config_multiple)/config/chomp_planning.yaml" />
</launch>
| 1,159 | XML | 51.72727 | 92 | 0.697153 |
AndreiVoica/P10-MAP/src/kuka_config_multiple/launch/ros_control_moveit_controller_manager.launch.xml | <launch>
<!-- Define MoveIt controller manager plugin -->
<param name="moveit_controller_manager" value="moveit_ros_control_interface::MoveItControllerManager" />
</launch>
| 175 | XML | 34.199993 | 105 | 0.754286 |
AndreiVoica/P10-MAP/src/kuka_config_multiple/launch/ompl-chomp_planning_pipeline.launch.xml | <launch>
<!-- load OMPL planning pipeline, but add the CHOMP planning adapter. -->
<include file="$(find kuka_config_multiple)/launch/ompl_planning_pipeline.launch.xml">
<arg name="planning_adapters"
default="default_planner_request_adapters/LimitMaxCartesianLinkSpeed
default_planner_request_adapters/AddTimeParameterization
default_planner_request_adapters/FixWorkspaceBounds
default_planner_request_adapters/FixStartStateBounds
default_planner_request_adapters/FixStartStateCollision
default_planner_request_adapters/FixStartStatePathConstraints
chomp/OptimizerAdapter"
/>
</include>
<!-- load chomp config -->
<rosparam command="load" file="$(find kuka_config_multiple)/config/chomp_planning.yaml" />
<!-- override trajectory_initialization_method: Use OMPL-generated trajectory -->
<param name="trajectory_initialization_method" value="fillTrajectory"/>
</launch>
| 1,024 | XML | 47.809522 | 92 | 0.689453 |
AndreiVoica/P10-MAP/src/kuka_config_multiple/launch/planning_pipeline.launch.xml | <launch>
<!-- This file makes it easy to include different planning pipelines;
It is assumed that all planning pipelines are named XXX_planning_pipeline.launch -->
<arg name="pipeline" default="ompl" />
<include ns="$(arg pipeline)" file="$(dirname)/$(arg pipeline)_planning_pipeline.launch.xml" />
</launch>
| 327 | XML | 28.818179 | 97 | 0.69419 |
AndreiVoica/P10-MAP/src/kuka_config_multiple/launch/kuka_multiple_arms_moveit_sensor_manager.launch.xml | <launch>
</launch>
| 20 | XML | 4.249999 | 9 | 0.6 |
AndreiVoica/P10-MAP/src/kuka_config_multiple/launch/warehouse_settings.launch.xml | <launch>
<!-- Set the parameters for the warehouse and run the mongodb server. -->
<!-- The default DB port for moveit (not default MongoDB port to avoid potential conflicts) -->
<arg name="moveit_warehouse_port" default="33829" />
<!-- The default DB host for moveit -->
<arg name="moveit_warehouse_host" default="localhost" />
<!-- Set parameters for the warehouse -->
<param name="warehouse_port" value="$(arg moveit_warehouse_port)"/>
<param name="warehouse_host" value="$(arg moveit_warehouse_host)"/>
<param name="warehouse_exec" value="mongod" />
<param name="warehouse_plugin" value="warehouse_ros_mongo::MongoDatabaseConnection" />
</launch>
| 675 | XML | 38.764704 | 97 | 0.694815 |
AndreiVoica/P10-MAP/src/kuka_config_multiple/launch/trajectory_execution.launch.xml | <launch>
<!-- This file summarizes all settings required for trajectory execution -->
<!-- Define moveit controller manager plugin: fake, simple, or ros_control -->
<arg name="moveit_controller_manager" />
<arg name="fake_execution_type" default="interpolate" />
<!-- Flag indicating whether MoveIt is allowed to load/unload or switch controllers -->
<arg name="moveit_manage_controllers" default="true"/>
<param name="moveit_manage_controllers" value="$(arg moveit_manage_controllers)"/>
<!-- When determining the expected duration of a trajectory, this multiplicative factor is applied to get the allowed duration of execution -->
<param name="trajectory_execution/allowed_execution_duration_scaling" value="1.2"/> <!-- default 1.2 -->
<!-- Allow more than the expected execution time before triggering a trajectory cancel (applied after scaling) -->
<param name="trajectory_execution/allowed_goal_duration_margin" value="0.5"/> <!-- default 0.5 -->
<!-- Allowed joint-value tolerance for validation that trajectory's first point matches current robot state -->
<param name="trajectory_execution/allowed_start_tolerance" value="0.01"/> <!-- default 0.01 -->
<!-- We use pass_all_args=true here to pass fake_execution_type, which is required by fake controllers, but not by real-robot controllers.
As real-robot controller_manager.launch files shouldn't be required to define this argument, we use the trick of passing all args. -->
<include file="$(dirname)/$(arg moveit_controller_manager)_moveit_controller_manager.launch.xml" pass_all_args="true" />
</launch>
| 1,609 | XML | 66.083331 | 145 | 0.73151 |
AndreiVoica/P10-MAP/src/kuka_config_multiple/launch/ompl_planning_pipeline.launch.xml | <launch>
<!-- The request adapters (plugins) used when planning with OMPL. ORDER MATTERS! -->
<arg name="planning_adapters"
default="default_planner_request_adapters/LimitMaxCartesianLinkSpeed
default_planner_request_adapters/AddTimeParameterization
default_planner_request_adapters/ResolveConstraintFrames
default_planner_request_adapters/FixWorkspaceBounds
default_planner_request_adapters/FixStartStateBounds
default_planner_request_adapters/FixStartStateCollision
default_planner_request_adapters/FixStartStatePathConstraints"
/>
<arg name="start_state_max_bounds_error" default="0.1" />
<arg name="jiggle_fraction" default="0.05" />
<param name="planning_plugin" value="ompl_interface/OMPLPlanner" />
<param name="request_adapters" value="$(arg planning_adapters)" />
<param name="start_state_max_bounds_error" value="$(arg start_state_max_bounds_error)" />
<param name="jiggle_fraction" value="$(arg jiggle_fraction)" />
<rosparam command="load" file="$(find kuka_config_multiple)/config/ompl_planning.yaml"/>
</launch>
| 1,168 | XML | 45.759998 | 91 | 0.696062 |
AndreiVoica/P10-MAP/src/kuka_config_multiple/config/simple_moveit_controllers.yaml | controller_list:
- name: kr3_1_arm_controller
action_ns: follow_joint_trajectory
type: FollowJointTrajectory
default: True
joints:
- kr3_1_joint_a1
- kr3_1_joint_a2
- kr3_1_joint_a3
- kr3_1_joint_a4
- kr3_1_joint_a5
- kr3_1_joint_a6
- name: kr3_1_hand_controller
action_ns: follow_joint_trajectory
type: FollowJointTrajectory
default: True
joints:
- kr3_1_schunk_joint_left
- kr3_1_schunk_joint_right
- name: kr3_2_arm_controller
action_ns: follow_joint_trajectory
type: FollowJointTrajectory
default: True
joints:
- kr3_2_joint_a1
- kr3_2_joint_a2
- kr3_2_joint_a3
- kr3_2_joint_a4
- kr3_2_joint_a5
- kr3_2_joint_a6
- name: kr3_2_hand_controller
action_ns: follow_joint_trajectory
type: FollowJointTrajectory
default: True
joints:
- kr3_2_schunk_joint_left
- kr3_2_schunk_joint_right
- name: kr3_3_arm_controller
action_ns: follow_joint_trajectory
type: FollowJointTrajectory
default: True
joints:
- kr3_3_joint_a1
- kr3_3_joint_a2
- kr3_3_joint_a3
- kr3_3_joint_a4
- kr3_3_joint_a5
- kr3_3_joint_a6
- name: kr3_4_arm_controller
action_ns: follow_joint_trajectory
type: FollowJointTrajectory
default: True
joints:
- kr3_4_joint_a1
- kr3_4_joint_a2
- kr3_4_joint_a3
- kr3_4_joint_a4
- kr3_4_joint_a5
- kr3_4_joint_a6
- name: kr4_5_arm_controller
action_ns: follow_joint_trajectory
type: FollowJointTrajectory
default: True
joints:
- kr4_5_joint_a1
- kr4_5_joint_a2
- kr4_5_joint_a3
- kr4_5_joint_a4
- kr4_5_joint_a5
- kr4_5_joint_a6
- name: kr4_5_hand_controller
action_ns: follow_joint_trajectory
type: FollowJointTrajectory
default: True
joints:
- kr4_5_schunk_joint_left
- kr4_5_schunk_joint_right | 1,960 | YAML | 24.467532 | 38 | 0.612245 |
AndreiVoica/P10-MAP/src/kuka_config_multiple/config/chomp_planning.yaml | planning_time_limit: 10.0
max_iterations: 200
max_iterations_after_collision_free: 5
smoothness_cost_weight: 0.1
obstacle_cost_weight: 1.0
learning_rate: 0.01
smoothness_cost_velocity: 0.0
smoothness_cost_acceleration: 1.0
smoothness_cost_jerk: 0.0
ridge_factor: 0.0
use_pseudo_inverse: false
pseudo_inverse_ridge_factor: 1e-4
joint_update_limit: 0.1
collision_clearance: 0.2
collision_threshold: 0.07
use_stochastic_descent: true
enable_failure_recovery: false
max_recovery_attempts: 5
| 487 | YAML | 24.684209 | 38 | 0.794661 |
AndreiVoica/P10-MAP/src/kuka_config_multiple/config/kinematics.yaml | kr3_1_arm:
kinematics_solver: kdl_kinematics_plugin/KDLKinematicsPlugin
kinematics_solver_search_resolution: 0.005
kinematics_solver_timeout: 0.005
kr3_2_arm:
kinematics_solver: kdl_kinematics_plugin/KDLKinematicsPlugin
kinematics_solver_search_resolution: 0.005
kinematics_solver_timeout: 0.005
kr3_3_arm:
kinematics_solver: kdl_kinematics_plugin/KDLKinematicsPlugin
kinematics_solver_search_resolution: 0.005
kinematics_solver_timeout: 0.005
kr3_4_arm:
kinematics_solver: kdl_kinematics_plugin/KDLKinematicsPlugin
kinematics_solver_search_resolution: 0.005
kinematics_solver_timeout: 0.005
kr4_5_arm:
kinematics_solver: kdl_kinematics_plugin/KDLKinematicsPlugin
kinematics_solver_search_resolution: 0.005
kinematics_solver_timeout: 0.005 | 769 | YAML | 37.499998 | 62 | 0.806242 |
AndreiVoica/P10-MAP/src/kuka_config_multiple/config/gazebo_controllers.yaml | # Publish joint_states
joint_state_controller:
type: joint_state_controller/JointStateController
publish_rate: 50
| 118 | YAML | 22.799995 | 51 | 0.805085 |
AndreiVoica/P10-MAP/src/kuka_config_multiple/config/fake_controllers.yaml | controller_list:
- name: fake_kr3_1_arm_controller
type: $(arg fake_execution_type)
joints:
- kr3_1_joint_a1
- kr3_1_joint_a2
- kr3_1_joint_a3
- kr3_1_joint_a4
- kr3_1_joint_a5
- kr3_1_joint_a6
- name: fake_kr3_1_hand_controller
type: $(arg fake_execution_type)
joints:
- kr3_1_schunk_joint_left
- kr3_1_schunk_joint_right
- name: fake_kr3_2_arm_controller
type: $(arg fake_execution_type)
joints:
- kr3_2_joint_a1
- kr3_2_joint_a2
- kr3_2_joint_a3
- kr3_2_joint_a4
- kr3_2_joint_a5
- kr3_2_joint_a6
- name: fake_kr3_2_hand_controller
type: $(arg fake_execution_type)
joints:
- kr3_2_schunk_joint_left
- kr3_2_schunk_joint_right
- name: fake_kr3_3_arm_controller
type: $(arg fake_execution_type)
joints:
- kr3_3_joint_a1
- kr3_3_joint_a2
- kr3_3_joint_a3
- kr3_3_joint_a4
- kr3_3_joint_a5
- kr3_3_joint_a6
- name: fake_kr3_3_hand_controller
type: $(arg fake_execution_type)
joints:
[]
- name: fake_kr3_4_arm_controller
type: $(arg fake_execution_type)
joints:
- kr3_4_joint_a1
- kr3_4_joint_a2
- kr3_4_joint_a3
- kr3_4_joint_a4
- kr3_4_joint_a5
- kr3_4_joint_a6
- name: fake_kr3_4_hand_controller
type: $(arg fake_execution_type)
joints:
[]
- name: fake_kr4_5_arm_controller
type: $(arg fake_execution_type)
joints:
- kr4_5_joint_a1
- kr4_5_joint_a2
- kr4_5_joint_a3
- kr4_5_joint_a4
- kr4_5_joint_a5
- kr4_5_joint_a6
- name: fake_kr4_5_hand_controller
type: $(arg fake_execution_type)
joints:
- kr4_5_schunk_joint_left
- kr4_5_schunk_joint_right
initial: # Define initial robot poses per group
- group: kr3_1_hand
pose: kr3_1_open
- group: kr3_2_hand
pose: kr3_2_open
- group: kr4_5_hand
pose: kr4_5_open | 1,952 | YAML | 24.697368 | 48 | 0.578381 |
AndreiVoica/P10-MAP/src/kuka_config_multiple/config/ros_controllers.yaml | kr3_1_arm_controller:
type: effort_controllers/JointTrajectoryController
joints:
- kr3_1_joint_a1
- kr3_1_joint_a2
- kr3_1_joint_a3
- kr3_1_joint_a4
- kr3_1_joint_a5
- kr3_1_joint_a6
gains:
kr3_1_joint_a1:
p: 100
d: 1
i: 1
i_clamp: 1
kr3_1_joint_a2:
p: 100
d: 1
i: 1
i_clamp: 1
kr3_1_joint_a3:
p: 100
d: 1
i: 1
i_clamp: 1
kr3_1_joint_a4:
p: 100
d: 1
i: 1
i_clamp: 1
kr3_1_joint_a5:
p: 100
d: 1
i: 1
i_clamp: 1
kr3_1_joint_a6:
p: 100
d: 1
i: 1
i_clamp: 1
kr3_1_hand_controller:
type: effort_controllers/JointTrajectoryController
joints:
- kr3_1_schunk_joint_left
- kr3_1_schunk_joint_right
gains:
kr3_1_schunk_joint_left:
p: 100
d: 1
i: 1
i_clamp: 1
kr3_1_schunk_joint_right:
p: 100
d: 1
i: 1
i_clamp: 1
kr3_2_arm_controller:
type: effort_controllers/JointTrajectoryController
joints:
- kr3_2_joint_a1
- kr3_2_joint_a2
- kr3_2_joint_a3
- kr3_2_joint_a4
- kr3_2_joint_a5
- kr3_2_joint_a6
gains:
kr3_2_joint_a1:
p: 100
d: 1
i: 1
i_clamp: 1
kr3_2_joint_a2:
p: 100
d: 1
i: 1
i_clamp: 1
kr3_2_joint_a3:
p: 100
d: 1
i: 1
i_clamp: 1
kr3_2_joint_a4:
p: 100
d: 1
i: 1
i_clamp: 1
kr3_2_joint_a5:
p: 100
d: 1
i: 1
i_clamp: 1
kr3_2_joint_a6:
p: 100
d: 1
i: 1
i_clamp: 1
kr3_2_hand_controller:
type: effort_controllers/JointTrajectoryController
joints:
- kr3_2_schunk_joint_left
- kr3_2_schunk_joint_right
gains:
kr3_2_schunk_joint_left:
p: 100
d: 1
i: 1
i_clamp: 1
kr3_2_schunk_joint_right:
p: 100
d: 1
i: 1
i_clamp: 1
kr3_3_arm_controller:
type: effort_controllers/JointTrajectoryController
joints:
- kr3_3_joint_a1
- kr3_3_joint_a2
- kr3_3_joint_a3
- kr3_3_joint_a4
- kr3_3_joint_a5
- kr3_3_joint_a6
gains:
kr3_3_joint_a1:
p: 100
d: 1
i: 1
i_clamp: 1
kr3_3_joint_a2:
p: 100
d: 1
i: 1
i_clamp: 1
kr3_3_joint_a3:
p: 100
d: 1
i: 1
i_clamp: 1
kr3_3_joint_a4:
p: 100
d: 1
i: 1
i_clamp: 1
kr3_3_joint_a5:
p: 100
d: 1
i: 1
i_clamp: 1
kr3_3_joint_a6:
p: 100
d: 1
i: 1
i_clamp: 1
kr3_4_arm_controller:
type: effort_controllers/JointTrajectoryController
joints:
- kr3_4_joint_a1
- kr3_4_joint_a2
- kr3_4_joint_a3
- kr3_4_joint_a4
- kr3_4_joint_a5
- kr3_4_joint_a6
gains:
kr3_4_joint_a1:
p: 100
d: 1
i: 1
i_clamp: 1
kr3_4_joint_a2:
p: 100
d: 1
i: 1
i_clamp: 1
kr3_4_joint_a3:
p: 100
d: 1
i: 1
i_clamp: 1
kr3_4_joint_a4:
p: 100
d: 1
i: 1
i_clamp: 1
kr3_4_joint_a5:
p: 100
d: 1
i: 1
i_clamp: 1
kr3_4_joint_a6:
p: 100
d: 1
i: 1
i_clamp: 1
kr4_5_arm_controller:
type: effort_controllers/JointTrajectoryController
joints:
- kr4_5_joint_a1
- kr4_5_joint_a2
- kr4_5_joint_a3
- kr4_5_joint_a4
- kr4_5_joint_a5
- kr4_5_joint_a6
gains:
kr4_5_joint_a1:
p: 100
d: 1
i: 1
i_clamp: 1
kr4_5_joint_a2:
p: 100
d: 1
i: 1
i_clamp: 1
kr4_5_joint_a3:
p: 100
d: 1
i: 1
i_clamp: 1
kr4_5_joint_a4:
p: 100
d: 1
i: 1
i_clamp: 1
kr4_5_joint_a5:
p: 100
d: 1
i: 1
i_clamp: 1
kr4_5_joint_a6:
p: 100
d: 1
i: 1
i_clamp: 1
kr4_5_hand_controller:
type: effort_controllers/JointTrajectoryController
joints:
- kr4_5_schunk_joint_left
- kr4_5_schunk_joint_right
gains:
kr4_5_schunk_joint_left:
p: 100
d: 1
i: 1
i_clamp: 1
kr4_5_schunk_joint_right:
p: 100
d: 1
i: 1
i_clamp: 1 | 4,216 | YAML | 16.004032 | 52 | 0.481262 |
AndreiVoica/P10-MAP/src/kuka_hw_axis/README.md | kuka_hw_axis package allows controlling Kuka robot in joint space.
| 68 | Markdown | 33.499983 | 67 | 0.808824 |
AndreiVoica/P10-MAP/src/kuka_hw_axis/src/kuka_hw_axis_interface_main.cpp | /* @author Aytaç Kahveci */
#include <kuka_hw_axis/kuka_hardware_interface.h>
#include <unistd.h>
int main(int argc, char **argv)
{
ROS_INFO_STREAM_NAMED("hardware_axis_interface", "Starting hardware interface...");
ros::init(argc, argv, "kuka_hardware_axis_interface");
ros::AsyncSpinner spinner(1);
spinner.start();
ros::NodeHandle nh;
kuka_hw_interface::kukaHardwareInterface robot;
ros::Time timestamp;
timestamp = ros::Time::now();
ros::Rate loop_rate(10);
robot.start();
controller_manager::ControllerManager controller_manager(&robot, nh);
sleep(1);
while(ros::ok())
{
ros::Duration period = ros::Time::now() - timestamp;
robot.read();
timestamp = ros::Time::now();
controller_manager.update(timestamp, period);
robot.write();
//usleep(100);
loop_rate.sleep();
}
spinner.stop();
ROS_INFO_STREAM_NAMED("hardware_axis_interface", "Shutting down.");
return 0;
}
| 1,007 | C++ | 21.4 | 87 | 0.622642 |
AndreiVoica/P10-MAP/src/kuka_hw_axis/src/kuka_hw_interface_axis.cpp | /* @author Aytaç Kahveci */
#include <kuka_hw_axis/kuka_hardware_interface.h>
#include <math.h>
#define PI 3.14159
#include <stdexcept>
namespace kuka_hw_interface
{
kukaHardwareInterface::kukaHardwareInterface()
{
pos_ = new double[6]{0, 0, 0, 0, 0, 0};
vel_ = new double[6]{0, 0, 0, 0, 0, 0};
eff_ = new double[6]{0, 0, 0, 0, 0, 0};
cmd_pos_ = new double[6]{0, 0, 0, 0, 0, 0};
last_cmd_pos_ = new double[6]{0, 0, 0, 0, 0, 0};
cmd_vel_ = new double[6]{0, 0, 0, 0, 0, 0};
cmd_eff_ = new double[6]{0, 0, 0, 0, 0, 0};
registerInterface(&joint_state_interface_);
registerInterface(&position_joint_interface_);
if(!nh_.getParam("controller_joint_names", joint_names_))
{
ROS_ERROR("Couldn't find required parameter 'controller_joint_names' on the parameter server.");
throw std::runtime_error("Couldn't find required parameter 'controller_joint_names' on the parameter server.");
}
for(size_t i=0; i<n_dof_; ++i)
{
joint_state_interface_.registerHandle(hardware_interface::JointStateHandle(joint_names_[i], &pos_[i], &vel_[i], &eff_[i]));
position_joint_interface_.registerHandle(hardware_interface::JointHandle(joint_state_interface_.getHandle(joint_names_[i]), &cmd_pos_[i]));
}
ROS_INFO_STREAM_NAMED("hardware_interface", "Loaded kuka_hardware_interface");
}
kukaHardwareInterface::~kukaHardwareInterface()
{
delete [] pos_;
delete [] vel_;
delete [] eff_;
delete [] cmd_pos_;
delete [] cmd_vel_;
delete [] cmd_eff_;
delete axisAct;
delete myAxis;
}
void kukaHardwareInterface::read()
{
client_->readVariable<KRLE6Axis>(axisAct);
for(size_t i=0; i<n_dof_; i++)
{
pos_[i] = axisAct->asArrayA1ToA6()[i]*PI/180;
}
}
void kukaHardwareInterface::write()
{
bool changes_pos=false;
for(std::size_t i=0; i<n_dof_; i++)
{
if(last_cmd_pos_[i]!=cmd_pos_[i])
{
last_cmd_pos_[i]= cmd_pos_[i];
changes_pos = true;
}
}
if(changes_pos)
{
myAxis->setA1ToA6({cmd_pos_[0]*180/PI,cmd_pos_[1]*180/PI,cmd_pos_[2]*180/PI,cmd_pos_[3]*180/PI,cmd_pos_[4]*180/PI,cmd_pos_[5]*180/PI});
client_->writeVariable<KRLAxis>(myAxis);
ROS_INFO_STREAM("POSSENDED "<< 0<<": "<< cmd_pos_[0]);
ROS_INFO("SEND POS!");
}
}
void kukaHardwareInterface::start()
{
std::string host_;
if(!nh_.getParam("Robot_IP",host_))
{
ROS_ERROR_STREAM("Couldn't find required parameter 'Robot_IP' on the parameter server");
throw std::runtime_error("Couldn't find required parameter 'Robot_IP' on the parameter server");
}
hostName_ = new char[host_.length() + 1];
strcpy(hostName_,host_.c_str());
if(!nh_.getParam("Robot_Port",port_))
{
ROS_ERROR_STREAM("Couldn't find required parameter 'Robot_Port' on the parameter server");
throw std::runtime_error("Couldn't find required parameter 'Robot_Port' on the parameter server");
}
client_ = new kukaClient(hostName_,port_);
ROS_INFO_STREAM_NAMED("kuka_hardware_interface", "Got connection from robot");
axisAct = new KRLE6Axis("$AXIS_ACT",{"A1", "A2", "A3", "A4", "A5", "A6", "E1", "E2", "E3", "E4", "E5", "E6"});
myAxis = new KRLAxis("MYAXIS");
}
}
| 3,637 | C++ | 35.38 | 151 | 0.550179 |
AndreiVoica/P10-MAP/src/kuka_hw_axis/include/kuka_hw_axis/kuka_hardware_interface.h | /* @author Aytaç Kahveci */
#ifndef KUKA_HARDWARE_INTERFACE_H
#define KUKA_HARDWARE_INTERFACE_H
#include <vector>
#include <string>
//ROS
#include <ros/ros.h>
//ros_control
#include <hardware_interface/joint_command_interface.h>
#include <hardware_interface/joint_state_interface.h>
#include <hardware_interface/robot_hw.h>
#include <realtime_tools/realtime_publisher.h>
#include <controller_manager/controller_manager.h>
#include <kuka_ros_open_comm/KRLAxis.h>
#include <kuka_ros_open_comm/KRLE6Axis.h>
//Timers
#include <chrono>
//KUKA CrossCommClient
#include <kuka_ros_open_comm/kuka_client.h>
namespace kuka_hw_interface
{
class kukaHardwareInterface : public hardware_interface::RobotHW
{
private:
ros::NodeHandle nh_;
unsigned int n_dof_ = 6;
std::vector<std::string> joint_names_;
double *pos_;
double *vel_;
double *eff_;
double *cmd_pos_;
double *last_cmd_pos_;
double *cmd_vel_;
double *cmd_eff_;
hardware_interface::JointStateInterface joint_state_interface_;
hardware_interface::PositionJointInterface position_joint_interface_;
ros::Duration control_period_;
double loop_hz_;
kukaClient* client_;
char *hostName_;
int port_;
public:
kukaHardwareInterface();
~kukaHardwareInterface();
void read();
void write();
void start();
KRLE6Axis *axisAct;
KRLAxis *myAxis;
};
} // namespace kuka_hw_interface
#endif
| 1,549 | C | 20.830986 | 77 | 0.649451 |
AndreiVoica/P10-MAP/src/kuka_hw_axis/config/hardware_controllers.yaml | #Publish all joint states
joint_state_controller:
type: joint_state_controller/JointStateController
publish_rate: 100
# Joint trajectory controller
position_trajectory_controller:
type: "position_controllers/JointGroupPositionController"
joints:
- joint_a1
- joint_a2
- joint_a3
- joint_a4
- joint_a5
- joint_a6
# Joint trajectory controller
arm_controller:
type: "position_controllers/JointTrajectoryController"
joints:
- joint_a1
- joint_a2
- joint_a3
- joint_a4
- joint_a5
- joint_a6
#state_publish_rate: 50 # Defaults to 50
#action_monitor_rate: 20 # Defaults to 20
Robot_IP: "192.168.1.15"
Robot_Port: 7000 #7001
| 690 | YAML | 19.939393 | 59 | 0.694203 |
AndreiVoica/P10-MAP/src/kuka_hw_axis/config/controller_joint_names.yaml | controller_joint_names:
- joint_a1
- joint_a2
- joint_a3
- joint_a4
- joint_a5
- joint_a6
| 114 | YAML | 13.374998 | 23 | 0.54386 |
AndreiVoica/P10-MAP/src/kuka_hw_axis/config/hardware_controllers2.yaml | #Publish all joint states
joint_state_controller:
type: joint_state_controller/JointStateController
publish_rate: 100
# Joint trajectory controller
position_trajectory_controller:
type: "position_controllers/JointGroupPositionController"
joints:
- kr3_2_joint_a1
- kr3_2_joint_a2
- kr3_2_joint_a3
- kr3_2_joint_a4
- kr3_2_joint_a5
- kr3_2_joint_a6
# Joint trajectory controller
arm_controller:
type: "position_controllers/JointTrajectoryController"
joints:
- kr3_2_joint_a1
- kr3_2_joint_a2
- kr3_2_joint_a3
- kr3_2_joint_a4
- kr3_2_joint_a5
- kr3_2_joint_a6
#state_publish_rate: 50 # Defaults to 50
#action_monitor_rate: 20 # Defaults to 20
# Robot_IP: "192.168.1.12"
Robot_Port: 7000 #7001
| 764 | YAML | 22.181818 | 59 | 0.689791 |
AndreiVoica/P10-MAP/src/isaac_moveit/scripts/kuka_combined_joints_publisher_backup.py | #!/usr/bin/env python
# Copyright (c) 2021-2022, NVIDIA CORPORATION. All rights reserved.
#
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
import rospy
from sensor_msgs.msg import JointState
joints_dict = {}
def joint_states_callback(message):
joint_commands = JointState()
joint_commands.header = message.header
for i, name in enumerate(message.name):
# Storing arm joint names and positions
joints_dict[name] = message.position[i]
# if name == "joint_left":
# # Adding additional panda_finger_joint2 state info (extra joint used in isaac sim)
# # panda_finger_joint2 mirrors panda_finger_joint1
# joints_dict["joint_right"] = message.position[i]
joint_commands.name = joints_dict.keys()
joint_commands.position = joints_dict.values()
# Publishing combined message containing all arm and finger joints
pub.publish(joint_commands)
return
if __name__ == "__main__":
rospy.init_node("kuka_combined_joints_publisher")
pub = rospy.Publisher("/joint_command", JointState, queue_size=1)
rospy.Subscriber("/joint_command_desired", JointState, joint_states_callback, queue_size=1)
rospy.spin()
| 1,525 | Python | 30.142857 | 96 | 0.712787 |
AndreiVoica/P10-MAP/src/isaac_moveit/scripts/kuka_combined_joints_publisher.py | #!/usr/bin/env python
# Copyright (c) 2021-2022, NVIDIA CORPORATION. All rights reserved.
#
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
import sys
import copy
import time
import rospy
import moveit_commander
import moveit_msgs.msg
import geometry_msgs.msg
from geometry_msgs.msg import Pose, PoseArray, Quaternion
import math
from math import pi, tau, dist, fabs, cos
from moveit_commander.conversions import pose_to_list
from sensor_msgs.msg import JointState
from std_msgs.msg import String
from tf.transformations import euler_from_quaternion, quaternion_from_euler
# import dynamic_reconfigure.client
class kuka_combined_joints_publisher:
def __init__(self):
self.joints_dict = {}
self.joint_request = JointState()
self.pose_request = Pose()
moveit_commander.roscpp_initialize(sys.argv)
self.robot = moveit_commander.RobotCommander()
self.robot_joints = self.robot.get_joint_names()
self.scene = moveit_commander.PlanningSceneInterface()
# Default group name
self.group_name = "kr3_1_arm"
self.move_group = moveit_commander.MoveGroupCommander(self.group_name)
self.eef_link = self.move_group.get_end_effector_link()
self.move_group.allow_replanning(True)
self.display_trajectory_publisher = rospy.Publisher(
"/move_group/display_planned_path",
moveit_msgs.msg.DisplayTrajectory,
queue_size=20,
)
# # IP reconfiguration TEST
# rospy.init_node('dynamic_reconfigurator', anonymous=True)
# self.client = dynamic_reconfigure.client.Client("/move_group")
# Initialize ROS node
rospy.init_node("kuka_combined_joints_publisher")
# Publisher for joint commands
self.pub = rospy.Publisher("/joint_command", JointState, queue_size=1)
# TBD, publish joints only for selected move group
self.pub_test = rospy.Publisher("/arm_controller/command", JointState, queue_size=1)
# Control from Rviz
rospy.Subscriber("/joint_command_desired", JointState, self.joint_states_callback, queue_size=1)
# Control each robot from Isaac (1st select group, then get joint states)
rospy.Subscriber("/joint_move_group_isaac", String, self.select_move_group, queue_size=1)
rospy.Subscriber("/joint_command_isaac", JointState, self.go_to_joint_states_callback_isaac, queue_size=1)
rospy.Subscriber("/pose_command_isaac", Pose, self.go_to_pose_callback_isaac, queue_size=1)
rospy.Subscriber("/cartesian_path_command_isaac", PoseArray, self.go_to_cartesian_path_callback_isaac, queue_size=10)
# Rviz Control
def joint_states_callback(self, message):
rospy.loginfo("Rviz message: %s", message)
joint_commands = JointState()
joint_commands.header = message.header
for i, name in enumerate(message.name):
# Storing arm joint names and positions
self.joints_dict[name] = message.position[i]
# if name == "joint_left":
# # Adding additional panda_finger_joint2 state info (extra joint used in isaac sim)
# # panda_finger_joint2 mirrors panda_finger_joint1
# joints_dict["joint_right"] = message.position[i]
joint_commands.name = self.joints_dict.keys()
joint_commands.position = self.joints_dict.values()
# Publishing combined message containing all arm and finger joints
self.pub.publish(joint_commands)
self.pub_test.publish(joint_commands)
rospy.loginfo("joint commands Rviz: %s", joint_commands)
return
def select_move_group(self, message):
rospy.loginfo("Robot joints: %s", self.robot_joints)
self.group_name = message.data
self.move_group = moveit_commander.MoveGroupCommander(self.group_name)
self.eef_link = self.move_group.get_end_effector_link()
if self.eef_link == "":
eef_name = self.group_name.split('_')[0] + '_' + self.group_name.split('_')[1]
self.eef_link = eef_name + "_link_6"
rospy.loginfo("End effector link: %s", self.eef_link)
# params = { 'Robot_IP' : '192.168.1.1'}
# config = self.client.update_configuration(params)
rospy.loginfo("Selected move group: %s", self.group_name)
return
def go_to_joint_states_callback_isaac(self, message):
rospy.loginfo("Message topic: %s", message)
# Get current joint positions
joint_goal = self.move_group.get_current_joint_values()
rospy.loginfo("Joint goal1: %s", joint_goal)
# Get requested joint positions
joint_goal = message.position
rospy.loginfo("Joint goal2: %s", joint_goal)
# Go to requested joint positions
self.move_group.go(joint_goal, wait=True)
rospy.loginfo("Joint goal3: %s", joint_goal)
# self.move_group.stop()
# for i, name in enumerate(message.name):
# # Storing arm joint names and positions
# self.joints_dict[name] = joint_goal[i]
# rospy.loginfo("Joint joints dict: %s", self.joints_dict)
# # Creating joint command message
# joint_commands = JointState()
# joint_commands.header = message.header
# joint_commands.name = self.joints_dict.keys()
# joint_commands.position = self.joints_dict.values()
# # Publishing combined message containing all arm and finger joints
# self.pub.publish(joint_commands)
# Clearing joint dictionary
#self.joints_dict = {}
# Variable to test if joint positions are within tolerance
current_joints = self.move_group.get_current_joint_values()
return self.all_close(joint_goal, current_joints, 0.01)
def go_to_cartesian_path_callback_isaac(self, message):
# Set a list of waypoints for the Cartesian path
waypoints = message.poses
rospy.loginfo("Cartesian path waypoints: %s", waypoints)
# Set the start state to the current state
self.move_group.set_start_state_to_current_state()
# Compute the Cartesian path
(plan, fraction) = self.move_group.compute_cartesian_path(waypoints, # waypoint poses
0.02, # eef_step
0.0) # jump_threshold
# Execute the plan
self.move_group.execute(plan, wait=True)
def go_to_pose_callback_isaac(self, message):
target_pose = Pose()
target_pose = message
rospy.loginfo("Target pose: %s", target_pose)
self.move_group.set_pose_target(target_pose, self.eef_link) # Reference from end-effector link (gripper base_link)
# [0,0,0,1] Sets the orientation of the end-effector link to robot base_link (world)
# Pose orientation is given in quaternions with this shape: (w,x,y,z)
self.move_group.go(target_pose, wait=True)
current_joints = self.move_group.get_current_joint_values()
return #self.all_close(target_pose, current_joints, 0.01)
def all_close(self, goal, actual, tolerance):
"""
Convenience method for testing if the values in two lists are within a tolerance of each other.
For Pose and PoseStamped inputs, the angle between the two quaternions is compared (the angle
between the identical orientations q and -q is calculated correctly).
@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
"""
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 self.all_close(goal.pose, actual.pose, tolerance)
elif type(goal) is geometry_msgs.msg.Pose:
x0, y0, z0, qx0, qy0, qz0, qw0 = pose_to_list(actual)
x1, y1, z1, qx1, qy1, qz1, qw1 = pose_to_list(goal)
# Euclidean distance
d = dist((x1, y1, z1), (x0, y0, z0))
# phi = angle between orientations
cos_phi_half = fabs(qx0 * qx1 + qy0 * qy1 + qz0 * qz1 + qw0 * qw1)
return d <= tolerance and cos_phi_half >= cos(tolerance / 2.0)
return True
if __name__ == "__main__":
kuka_combined_joints_publisher()
try:
rospy.spin()
except KeyboardInterrupt:
print("Shutting down")
""" What I send:
header:
seq: 170
stamp:
secs: 3010
nsecs: 716823688
frame_id: "base_link"
name:
- joint_a1
- joint_a2
- joint_a3
- joint_a4
- joint_a5
- joint_a6
position: [0.686481519975468, -2.3677175964755364, 2.5781044455248914, 2.145352880856928, 1.9185556285919494, -5.372349182452595]
velocity: []
effort: []
"""
""" What I get:
header:
seq: 45 <-- Several messages, not only one
stamp:
secs: 315
nsecs: 450016452
frame_id: "world"
name:
- kr3_1_joint_a1
- kr3_1_joint_a2
- kr3_1_joint_a3
- kr3_1_joint_a4
- kr3_1_joint_a5
- kr3_1_joint_a6
- kr3_1_schunk_joint_left
- kr3_1_schunk_joint_right
- kr3_2_joint_a1
- kr3_2_joint_a2
- kr3_2_joint_a3
- kr3_2_joint_a4
- kr3_2_joint_a5
- kr3_2_joint_a6
- kr3_2_schunk_joint_left
- kr3_2_schunk_joint_right
- kr3_3_joint_a1
- kr3_3_joint_a2
- kr3_3_joint_a3
- kr3_3_joint_a4
- kr3_3_joint_a5
- kr3_3_joint_a6
- kr3_4_joint_a1
- kr3_4_joint_a2
- kr3_4_joint_a3
- kr3_4_joint_a4
- kr3_4_joint_a5
- kr3_4_joint_a6
- kr4_5_joint_a1
- kr4_5_joint_a2
- kr4_5_joint_a3
- kr4_5_joint_a4
- kr4_5_joint_a5
- kr4_5_joint_a6
- kr4_5_schunk_joint_left
- kr4_5_schunk_joint_right
position: [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -0.8726288771072731, -1.0000287031046116, -0.785433093176108, -1.5708897833434887, 8.03748164791614e-05, 1.0472336069120263, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
velocity: []
effort: []
"""
"""
position:
x: 0.6
y: 0.49601638140176374
z: 0.3
orientation:
x: 0.0
y: 0.0
z: 0.707
w: 0.707
"""
| 10,945 | Python | 30.635838 | 289 | 0.617725 |
AndreiVoica/P10-MAP/src/kuka_hw_cart/README.md | kuka_hw_cart package allows controlling Kuka robot in cartesian space.
| 71 | Markdown | 34.999983 | 70 | 0.830986 |
AndreiVoica/P10-MAP/src/kuka_hw_cart/src/kuka_hardware_interface_cart.cpp | /* @author Aytaç Kahveci */
#include <kuka_hw_cart/kuka_hardware_interface_cart.h>
#include <stdexcept>
namespace kuka_hw_interface
{
kukaHardwareInterface::kukaHardwareInterface()
{
pos_ = new double[6]{0, 0, 0, 0, 0, 0};
vel_ = new double[6]{0, 0, 0, 0, 0, 0};
eff_ = new double[6]{0, 0, 0, 0, 0, 0};
cmd_pos_ = new double[6]{0, 0, 0, 0, 0, 0};
last_cmd_pos_ = new double[6]{0, 0, 0, 0, 0, 0};
cmd_vel_ = new double[6]{0, 0, 0, 0, 0, 0};
cmd_eff_ = new double[6]{0, 0, 0, 0, 0, 0};
registerInterface(&joint_state_interface_);
registerInterface(&position_joint_interface_);
if(!nh_.getParam("controller_joint_names", joint_names_))
{
ROS_ERROR("Couldn't find required parameter 'controller_joint_names' on the parameter server.");
throw std::runtime_error("Couldn't find required parameter 'controller_joint_names' on the parameter server.");
}
for(size_t i=0; i<n_dof_; ++i)
{
joint_state_interface_.registerHandle(hardware_interface::JointStateHandle(joint_names_[i], &pos_[i], &vel_[i], &eff_[i]));
position_joint_interface_.registerHandle(hardware_interface::JointHandle(joint_state_interface_.getHandle(joint_names_[i]), &cmd_pos_[i]));
}
ROS_INFO_STREAM_NAMED("hardware_interface", "Loaded kuka_hardware_interface");
}
kukaHardwareInterface::~kukaHardwareInterface()
{
delete [] pos_;
delete [] vel_;
delete [] eff_;
delete [] cmd_pos_;
delete [] cmd_vel_;
delete [] cmd_eff_;
delete posAct;
delete myPos;
}
void kukaHardwareInterface::read()
{
client_->readVariable<KRLPos>(posAct);
for(size_t i=0; i<n_dof_; i++)
{
pos_[i] = posAct->asArrayXToC()[i];
}
}
void kukaHardwareInterface::write()
{
bool changes_pos=false;
for(std::size_t i=0; i<n_dof_; i++)
{
if(last_cmd_pos_[i]!=cmd_pos_[i])
{
last_cmd_pos_[i]= cmd_pos_[i];
changes_pos = true;
}
}
if(changes_pos)
{
myPos->setXToZ({cmd_pos_[0], cmd_pos_[1], cmd_pos_[2]});
myPos->setAToC({cmd_pos_[3],cmd_pos_[4],cmd_pos_[5]});
client_->writeVariable<KRLPos>(myPos);
ROS_INFO_STREAM("POSSENDED "<< 0<<": "<< cmd_pos_[0]);
ROS_INFO("SEND POS!");
}
}
void kukaHardwareInterface::start()
{
std::string host_;
if(!nh_.getParam("Robot_IP",host_))
{
ROS_ERROR_STREAM("Couldn't find required parameter 'Robot_IP' on the parameter server");
throw std::runtime_error("Couldn't find required parameter 'Robot_IP' on the parameter server");
}
hostName_ = new char[host_.length() + 1];
strcpy(hostName_,host_.c_str());
if(!nh_.getParam("Robot_Port",port_))
{
ROS_ERROR_STREAM("Couldn't find required parameter 'Robot_Port' on the parameter server");
throw std::runtime_error("Couldn't find required parameter 'Robot_Port' on the parameter server");
}
client_ = new kukaClient(hostName_,port_);
ROS_INFO_STREAM_NAMED("kuka_hardware_interface", "Got connection from robot");
//Define variables that will be read from KUKAVARPROXY and write to KUKAVARPROXY
posAct = new KRLPos("$POS_ACT");
myPos = new KRLPos("MYPOS");
}
}
| 3,582 | C++ | 34.475247 | 151 | 0.551926 |
AndreiVoica/P10-MAP/src/kuka_hw_cart/src/kuka_hardware_interface_cart_main_node.cpp | /* @author Aytaç Kahveci */
#include <kuka_hw_cart/kuka_hardware_interface_cart.h>
#include <kuka_ros_open_comm/KRLPos.h>
#include <kuka_ros_open_comm/KRLE6Pos.h>
#include <unistd.h>
int main(int argc, char **argv)
{
ROS_INFO_STREAM_NAMED("hardware_interface", "Starting hardware interface...");
ros::init(argc, argv, "kuka_hardware_interface");
ros::AsyncSpinner spinner(1);
spinner.start();
ros::NodeHandle nh;
kuka_hw_interface::kukaHardwareInterface robot;
ros::Time timestamp;
timestamp = ros::Time::now();
ros::Rate loop_rate(100);
controller_manager::ControllerManager controller_manager(&robot, nh);
robot.start();
sleep(1);
while(ros::ok())
{
ros::Duration period = ros::Time::now() - timestamp;
robot.read();
timestamp = ros::Time::now();
controller_manager.update(timestamp, period);
robot.write();
//usleep(100);
loop_rate.sleep();
}
spinner.stop();
ROS_INFO_STREAM_NAMED("hardware_interface", "Shutting down.");
return 0;
}
| 1,078 | C++ | 21.957446 | 82 | 0.630798 |
AndreiVoica/P10-MAP/src/kuka_hw_cart/include/kuka_hw_cart/kuka_hardware_interface_cart.h | /* @author Aytaç Kahveci */
#ifndef KUKA_HARDWARE_INTERFACE_H
#define KUKA_HARDWARE_INTERFACE_H
#include <vector>
#include <string>
//ROS
#include <ros/ros.h>
//ros_control
#include <hardware_interface/joint_command_interface.h>
#include <hardware_interface/joint_state_interface.h>
#include <hardware_interface/robot_hw.h>
#include <realtime_tools/realtime_publisher.h>
#include <controller_manager/controller_manager.h>
#include <kuka_ros_open_comm/KRLPos.h>
#include <kuka_ros_open_comm/KRLE6Pos.h>
//Timers
#include <chrono>
//KUKA CrossCommClient
#include <kuka_ros_open_comm/kuka_client.h>
namespace kuka_hw_interface
{
class kukaHardwareInterface : public hardware_interface::RobotHW
{
private:
ros::NodeHandle nh_;
unsigned int n_dof_ = 6;
std::vector<std::string> joint_names_;
double *pos_;
double *vel_;
double *eff_;
double *cmd_pos_;
double *last_cmd_pos_;
double *cmd_vel_;
double *cmd_eff_;
hardware_interface::JointStateInterface joint_state_interface_;
hardware_interface::PositionJointInterface position_joint_interface_;
ros::Duration control_period_;
double loop_hz_;
kukaClient* client_;
char *hostName_;
int port_;
public:
kukaHardwareInterface();
~kukaHardwareInterface();
void read();
void write();
void start();
KRLPos *posAct;
KRLPos *myPos;
};
} // namespace kuka_hw_interface
#endif
| 1,541 | C | 20.71831 | 77 | 0.647631 |
AndreiVoica/P10-MAP/src/kuka_hw_cart/config/hardware_controllers.yaml | #Publish all joint states
joint_state_controller:
type: joint_state_controller/JointStateController
publish_rate: 100
# Joint trajectory controller
position_trajectory_controller:
type: "position_controllers/JointGroupPositionController"
joints:
- joint_a1
- joint_a2
- joint_a3
- joint_a4
- joint_a5
- joint_a6
state_publish_rate: 100 # Defaults to 50
action_monitor_rate: 100 # Defaults to 20
Robot_IP: "192.168.1.15"
Robot_Port: 7000 #7001
| 482 | YAML | 20.954545 | 59 | 0.719917 |
AndreiVoica/P10-MAP/src/kuka_hw_cart/config/controller_joint_names.yaml | controller_joint_names:
- joint_a1
- joint_a2
- joint_a3
- joint_a4
- joint_a5
- joint_a6
| 114 | YAML | 13.374998 | 23 | 0.54386 |
AndreiVoica/P10-MAP/src/kuka_hw_cart/config/hardware_controllers2.yaml | #Publish all joint states
joint_state_controller:
type: joint_state_controller/JointStateController
publish_rate: 100
# Joint trajectory controller
position_trajectory_controller:
type: "position_controllers/JointGroupPositionController"
joints:
- joint_a1
- joint_a2
- joint_a3
- joint_a4
- joint_a5
- joint_a6
state_publish_rate: 100 # Defaults to 50
action_monitor_rate: 100 # Defaults to 20
Robot_IP: "192.168.1.14"
Robot_Port: 7000 #7001
| 482 | YAML | 20.954545 | 59 | 0.719917 |
AndreiVoica/P10-MAP/src/kr3_config_dispenser/package.xml | <package>
<name>kr3_config_dispenser</name>
<version>0.3.0</version>
<description>
An automatically generated package with all the configuration and launch files for using the kuka_kr3r540 with the MoveIt Motion Planning Framework
</description>
<author email="[email protected]">Andrei Voica</author>
<maintainer email="[email protected]">Andrei Voica</maintainer>
<license>BSD</license>
<url type="website">http://moveit.ros.org/</url>
<url type="bugtracker">https://github.com/ros-planning/moveit/issues</url>
<url type="repository">https://github.com/ros-planning/moveit</url>
<buildtool_depend>catkin</buildtool_depend>
<run_depend>moveit_ros_move_group</run_depend>
<run_depend>moveit_fake_controller_manager</run_depend>
<run_depend>moveit_kinematics</run_depend>
<run_depend>moveit_planners</run_depend>
<run_depend>moveit_ros_visualization</run_depend>
<run_depend>moveit_setup_assistant</run_depend>
<run_depend>moveit_simple_controller_manager</run_depend>
<run_depend>joint_state_publisher</run_depend>
<run_depend>joint_state_publisher_gui</run_depend>
<run_depend>robot_state_publisher</run_depend>
<run_depend>rviz</run_depend>
<run_depend>tf2_ros</run_depend>
<run_depend>xacro</run_depend>
<!-- The next 2 packages are required for the gazebo simulation.
We don't include them by default to prevent installing gazebo and all its dependencies. -->
<!-- <run_depend>joint_trajectory_controller</run_depend> -->
<!-- <run_depend>gazebo_ros_control</run_depend> -->
<!-- This package is referenced in the warehouse launch files, but does not build out of the box at the moment. Commented the dependency until this works. -->
<!-- <run_depend>warehouse_ros_mongo</run_depend> -->
<run_depend>kuka_kr3_support</run_depend>
</package>
| 1,836 | XML | 42.738094 | 160 | 0.732026 |
AndreiVoica/P10-MAP/src/kr3_config_dispenser/launch/sensor_manager.launch.xml | <launch>
<!-- This file makes it easy to include the settings for sensor managers -->
<!-- Params for 3D sensors config -->
<rosparam command="load" file="$(find kr3_config_dispenser)/config/sensors_3d.yaml" />
<!-- Params for the octomap monitor -->
<!-- <param name="octomap_frame" type="string" value="some frame in which the robot moves" /> -->
<param name="octomap_resolution" type="double" value="0.025" />
<param name="max_range" type="double" value="5.0" />
<!-- Load the robot specific sensor manager; this sets the moveit_sensor_manager ROS parameter -->
<arg name="moveit_sensor_manager" default="kuka_kr3r540" />
<include file="$(dirname)/$(arg moveit_sensor_manager)_moveit_sensor_manager.launch.xml" />
</launch>
| 753 | XML | 40.888887 | 100 | 0.681275 |
AndreiVoica/P10-MAP/src/kr3_config_dispenser/launch/kuka_kr3r540_moveit_sensor_manager.launch.xml | <launch>
</launch>
| 20 | XML | 4.249999 | 9 | 0.6 |
AndreiVoica/P10-MAP/src/kr3_config_dispenser/launch/fake_moveit_controller_manager.launch.xml | <launch>
<!-- execute the trajectory in 'interpolate' mode or jump to goal position in 'last point' mode -->
<arg name="fake_execution_type" default="interpolate" />
<!-- Set the param that trajectory_execution_manager needs to find the controller plugin -->
<param name="moveit_controller_manager" value="moveit_fake_controller_manager/MoveItFakeControllerManager"/>
<!-- The rest of the params are specific to this plugin -->
<rosparam subst_value="true" file="$(find kr3_config_dispenser)/config/fake_controllers.yaml"/>
</launch>
| 550 | XML | 41.384612 | 110 | 0.730909 |
AndreiVoica/P10-MAP/src/kr3_config_dispenser/launch/stomp_planning_pipeline.launch.xml | <launch>
<!-- Stomp Plugin for MoveIt -->
<arg name="planning_plugin" value="stomp_moveit/StompPlannerManager" />
<arg name="start_state_max_bounds_error" value="0.1" />
<arg name="jiggle_fraction" value="0.05" />
<!-- The request adapters (plugins) used when planning. ORDER MATTERS! -->
<arg name="planning_adapters"
default="default_planner_request_adapters/LimitMaxCartesianLinkSpeed
default_planner_request_adapters/AddTimeParameterization
default_planner_request_adapters/FixWorkspaceBounds
default_planner_request_adapters/FixStartStateBounds
default_planner_request_adapters/FixStartStateCollision
default_planner_request_adapters/FixStartStatePathConstraints" />
<param name="planning_plugin" value="$(arg planning_plugin)" />
<param name="request_adapters" value="$(arg planning_adapters)" />
<param name="start_state_max_bounds_error" value="$(arg start_state_max_bounds_error)" />
<param name="jiggle_fraction" value="$(arg jiggle_fraction)" />
<rosparam command="load" file="$(find kr3_config_dispenser)/config/stomp_planning.yaml"/>
</launch>
| 1,170 | XML | 47.791665 | 91 | 0.7 |
AndreiVoica/P10-MAP/src/kr3_config_dispenser/launch/pilz_industrial_motion_planner_planning_pipeline.launch.xml | <launch>
<!-- The request adapters (plugins) used when planning. ORDER MATTERS! -->
<arg name="planning_adapters" default="" />
<param name="planning_plugin" value="pilz_industrial_motion_planner::CommandPlanner" />
<param name="request_adapters" value="$(arg planning_adapters)" />
<!-- Define default planner (for all groups) -->
<param name="default_planner_config" value="PTP" />
<!-- MoveGroup capabilities to load for this pipeline, append sequence capability -->
<param name="capabilities" value="pilz_industrial_motion_planner/MoveGroupSequenceAction
pilz_industrial_motion_planner/MoveGroupSequenceService" />
</launch>
| 685 | XML | 41.874997 | 95 | 0.691971 |
AndreiVoica/P10-MAP/src/kr3_config_dispenser/launch/simple_moveit_controller_manager.launch.xml | <launch>
<!-- Define the MoveIt controller manager plugin to use for trajectory execution -->
<param name="moveit_controller_manager" value="moveit_simple_controller_manager/MoveItSimpleControllerManager" />
<!-- Load controller list to the parameter server -->
<rosparam file="$(find kr3_config_dispenser)/config/simple_moveit_controllers.yaml" />
<rosparam file="$(find kr3_config_dispenser)/config/ros_controllers.yaml" />
</launch>
| 447 | XML | 48.777772 | 115 | 0.749441 |
AndreiVoica/P10-MAP/src/kr3_config_dispenser/launch/chomp_planning_pipeline.launch.xml | <launch>
<arg name="start_state_max_bounds_error" default="0.1" />
<arg name="jiggle_fraction" default="0.05" />
<!-- The request adapters (plugins) used when planning. ORDER MATTERS! -->
<arg name="planning_adapters"
default="default_planner_request_adapters/LimitMaxCartesianLinkSpeed
default_planner_request_adapters/AddTimeParameterization
default_planner_request_adapters/ResolveConstraintFrames
default_planner_request_adapters/FixWorkspaceBounds
default_planner_request_adapters/FixStartStateBounds
default_planner_request_adapters/FixStartStateCollision
default_planner_request_adapters/FixStartStatePathConstraints"
/>
<param name="planning_plugin" value="chomp_interface/CHOMPPlanner" />
<param name="request_adapters" value="$(arg planning_adapters)" />
<param name="start_state_max_bounds_error" value="$(arg start_state_max_bounds_error)" />
<param name="jiggle_fraction" value="$(arg jiggle_fraction)" />
<rosparam command="load" file="$(find kr3_config_dispenser)/config/chomp_planning.yaml" />
</launch>
| 1,159 | XML | 51.72727 | 92 | 0.697153 |
AndreiVoica/P10-MAP/src/kr3_config_dispenser/launch/ros_control_moveit_controller_manager.launch.xml | <launch>
<!-- Define MoveIt controller manager plugin -->
<param name="moveit_controller_manager" value="moveit_ros_control_interface::MoveItControllerManager" />
</launch>
| 175 | XML | 34.199993 | 105 | 0.754286 |
AndreiVoica/P10-MAP/src/kr3_config_dispenser/launch/ompl-chomp_planning_pipeline.launch.xml | <launch>
<!-- load OMPL planning pipeline, but add the CHOMP planning adapter. -->
<include file="$(find kr3_config_dispenser)/launch/ompl_planning_pipeline.launch.xml">
<arg name="planning_adapters"
default="default_planner_request_adapters/LimitMaxCartesianLinkSpeed
default_planner_request_adapters/AddTimeParameterization
default_planner_request_adapters/FixWorkspaceBounds
default_planner_request_adapters/FixStartStateBounds
default_planner_request_adapters/FixStartStateCollision
default_planner_request_adapters/FixStartStatePathConstraints
chomp/OptimizerAdapter"
/>
</include>
<!-- load chomp config -->
<rosparam command="load" file="$(find kr3_config_dispenser)/config/chomp_planning.yaml" />
<!-- override trajectory_initialization_method: Use OMPL-generated trajectory -->
<param name="trajectory_initialization_method" value="fillTrajectory"/>
</launch>
| 1,024 | XML | 47.809522 | 92 | 0.689453 |
AndreiVoica/P10-MAP/src/kr3_config_dispenser/launch/planning_pipeline.launch.xml | <launch>
<!-- This file makes it easy to include different planning pipelines;
It is assumed that all planning pipelines are named XXX_planning_pipeline.launch -->
<arg name="pipeline" default="ompl" />
<include ns="$(arg pipeline)" file="$(dirname)/$(arg pipeline)_planning_pipeline.launch.xml" />
</launch>
| 327 | XML | 28.818179 | 97 | 0.69419 |
AndreiVoica/P10-MAP/src/kr3_config_dispenser/launch/warehouse_settings.launch.xml | <launch>
<!-- Set the parameters for the warehouse and run the mongodb server. -->
<!-- The default DB port for moveit (not default MongoDB port to avoid potential conflicts) -->
<arg name="moveit_warehouse_port" default="33829" />
<!-- The default DB host for moveit -->
<arg name="moveit_warehouse_host" default="localhost" />
<!-- Set parameters for the warehouse -->
<param name="warehouse_port" value="$(arg moveit_warehouse_port)"/>
<param name="warehouse_host" value="$(arg moveit_warehouse_host)"/>
<param name="warehouse_exec" value="mongod" />
<param name="warehouse_plugin" value="warehouse_ros_mongo::MongoDatabaseConnection" />
</launch>
| 675 | XML | 38.764704 | 97 | 0.694815 |
AndreiVoica/P10-MAP/src/kr3_config_dispenser/launch/trajectory_execution.launch.xml | <launch>
<!-- This file summarizes all settings required for trajectory execution -->
<!-- Define moveit controller manager plugin: fake, simple, or ros_control -->
<arg name="moveit_controller_manager" />
<arg name="fake_execution_type" default="interpolate" />
<!-- Flag indicating whether MoveIt is allowed to load/unload or switch controllers -->
<arg name="moveit_manage_controllers" default="true"/>
<param name="moveit_manage_controllers" value="$(arg moveit_manage_controllers)"/>
<!-- When determining the expected duration of a trajectory, this multiplicative factor is applied to get the allowed duration of execution -->
<param name="trajectory_execution/allowed_execution_duration_scaling" value="1.2"/> <!-- default 1.2 -->
<!-- Allow more than the expected execution time before triggering a trajectory cancel (applied after scaling) -->
<param name="trajectory_execution/allowed_goal_duration_margin" value="0.5"/> <!-- default 0.5 -->
<!-- Allowed joint-value tolerance for validation that trajectory's first point matches current robot state -->
<param name="trajectory_execution/allowed_start_tolerance" value="0.01"/> <!-- default 0.01 -->
<!-- We use pass_all_args=true here to pass fake_execution_type, which is required by fake controllers, but not by real-robot controllers.
As real-robot controller_manager.launch files shouldn't be required to define this argument, we use the trick of passing all args. -->
<include file="$(dirname)/$(arg moveit_controller_manager)_moveit_controller_manager.launch.xml" pass_all_args="true" />
</launch>
| 1,609 | XML | 66.083331 | 145 | 0.73151 |
AndreiVoica/P10-MAP/src/kr3_config_dispenser/launch/ompl_planning_pipeline.launch.xml | <launch>
<!-- The request adapters (plugins) used when planning with OMPL. ORDER MATTERS! -->
<arg name="planning_adapters"
default="default_planner_request_adapters/LimitMaxCartesianLinkSpeed
default_planner_request_adapters/AddTimeParameterization
default_planner_request_adapters/ResolveConstraintFrames
default_planner_request_adapters/FixWorkspaceBounds
default_planner_request_adapters/FixStartStateBounds
default_planner_request_adapters/FixStartStateCollision
default_planner_request_adapters/FixStartStatePathConstraints"
/>
<arg name="start_state_max_bounds_error" default="0.1" />
<arg name="jiggle_fraction" default="0.05" />
<param name="planning_plugin" value="ompl_interface/OMPLPlanner" />
<param name="request_adapters" value="$(arg planning_adapters)" />
<param name="start_state_max_bounds_error" value="$(arg start_state_max_bounds_error)" />
<param name="jiggle_fraction" value="$(arg jiggle_fraction)" />
<rosparam command="load" file="$(find kr3_config_dispenser)/config/ompl_planning.yaml"/>
</launch>
| 1,168 | XML | 45.759998 | 91 | 0.696062 |
AndreiVoica/P10-MAP/src/kr3_config_dispenser/config/simple_moveit_controllers.yaml | controller_list:
- name: arm_controller
action_ns: follow_joint_trajectory
type: FollowJointTrajectory
default: True
joints:
- joint_a1
- joint_a2
- joint_a3
- joint_a4
- joint_a5
- joint_a6 | 244 | YAML | 19.416665 | 38 | 0.590164 |
AndreiVoica/P10-MAP/src/kr3_config_dispenser/config/chomp_planning.yaml | planning_time_limit: 10.0
max_iterations: 200
max_iterations_after_collision_free: 5
smoothness_cost_weight: 0.1
obstacle_cost_weight: 1.0
learning_rate: 0.01
smoothness_cost_velocity: 0.0
smoothness_cost_acceleration: 1.0
smoothness_cost_jerk: 0.0
ridge_factor: 0.0
use_pseudo_inverse: false
pseudo_inverse_ridge_factor: 1e-4
joint_update_limit: 0.1
collision_clearance: 0.2
collision_threshold: 0.07
use_stochastic_descent: true
enable_failure_recovery: false
max_recovery_attempts: 5
| 487 | YAML | 24.684209 | 38 | 0.794661 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.