Dio Eraclea's profile - activity

Hi! I have a very simple problem, but I just cannot understand how to solve it. I need to transfer three coordinates between two nodes. One node is talker, which defines the coordinates and send it to other node, which is listener. Listener waits for the coordinates, make some operations with them and send it to navigation stack, which operates the robot in stage. I have read the tutorial about simple publisher and subscriber, but there the string is used and I just do not know, how to change it to float without problems. I tried to use ros services, but they do not create a topic, while working, also I was unable to make it normal working too. It seems to me, that after receiving the message, the program stuck in a callback sub-program and the main part of the program just cannot receive the data. I can be mistaken, as my knowledge in programming is too small. Below is the code of my node that I want to make the listener. Now I enter the coordinates when the node is started, but it is not convenient. I just want to know what I should add (and where) to make this none subscribed to some topic (for example "coordinates"), and being able to receive X, Y and Theta coordinates. The part of publisher node also would be useful for me. I would like to understand the principle. Help me please!

 #include "ros/ros.h"
 #include "move_base_msgs/MoveBaseAction.h"
 #include "actionlib/client/simple_action_client.h"
 #include "tf/transform_datatypes.h"

typedef actionlib::SimpleActionClient<move_base_msgs::movebaseaction> MoveBaseClient;

using namespace std;

int main(int argc, char** argv) {

if (argc < 2) {
    ROS_ERROR("You must specify leader robot id.");
    return -1;
}

if (argc < 3) {
    ROS_ERROR("You must specify X coordinate.");
    return -1;
}

if (argc < 4) {
    ROS_ERROR("You must specify Y coordinate.");
    return -1;
}

    //ROS_INFO(argv[2]);

char *robot_id = argv[1];

ros::init(argc, argv, "test_goals");
ros::NodeHandle nh;

    double goal_x, goal_y, goal_theta;
    if (!nh.getParam("goal_x", goal_x)){
    char *x = argv[2];
    goal_x = atof(x);}
if (!nh.getParam("goal_y", goal_y)){
    char *y = argv[3];
    goal_y = atof(y);}
if (!nh.getParam("goal_theta", goal_theta))
    goal_theta = 0;


// Create the string "robot_X/move_base"
string move_base_str = "/robot_";
move_base_str += robot_id;
move_base_str += "/move_base";

// create the action client
MoveBaseClient ac(move_base_str, true);

// Wait for the action server to become available
ROS_INFO("Waiting for the move_base action server");
ac.waitForServer(ros::Duration(5));

ROS_INFO("Connected to move base server");

// Send a goal to move_base
move_base_msgs::MoveBaseGoal goal;
goal.target_pose.header.frame_id = "map";
goal.target_pose.header.stamp = ros::Time::now();

goal.target_pose.pose.position.x = goal_x;//
goal.target_pose.pose.position.y = goal_y;//

// Convert the Euler angle to quaternion
double radians = goal_theta * (M_PI/180);//
tf::Quaternion quaternion;
quaternion = tf::createQuaternionFromYaw(radians);

geometry_msgs::Quaternion qMsg;
tf::quaternionTFToMsg(quaternion, qMsg);
goal.target_pose.pose.orientation = qMsg;

ROS_INFO("Sending goal to robot no. %s: x = %f, y = %f, theta = 0", robot_id, goal_x, goal_y);
ac.sendGoal(goal);

// Wait for the action to return
ac.waitForResult();

if (ac.getState() == actionlib::SimpleClientGoalState::SUCCEEDED)
    ROS_INFO("Robot ...

Hi!

I want to simulate a robot in stage_ros with only odometry information and without using laser scanner for localization. I want to use navigation stack with Lego Mindstorms in the future (they have no laser scanner). I read some information about how to exclude laser from the simulation and so I deleted it from observation_sources.

According to the graph, navigation really stopped using base_laser, but unexpected problem appeared - the robot started to hit the obstacles. The map is very simple - just the rectangular of 8 x 4 meters with the two walls in the middle.

The robot should pass through the gap between the walls. Without the walls navigation is perfect, so it is not the localisation error, probably. I tried to watch what is happening in Rviz. It shows that global plan is almost good, and in the beginning robot starts moving according to it. But shortly after that, the robot is going like through the short cut - through the wall.

Here is base_local_planner_params.yaml:

TrajectoryPlannerROS:
  #Set the acceleration limits of the robot
  acc_lim_th: 3.2 
  acc_lim_x: 2.5
  acc_lim_y: 2.5
  #Set the velocity limits of the robot
  max_vel_x: 0.65
  min_vel_x: 0.1
  max_rotational_vel: 1.0
  min_in_place_rotational_vel: 0.4
  #The velocity the robot will command when trying to escape from a stuck situation
  escape_vel: -0.1
  #For this example, we'll use a holonomic robot
  holonomic_robot: true
  #Since we're using a holonomic robot, we'll set the set of y velocities it will sample
  y_vels: [-0.3, -0.1, 0.1, -0.3]
  #Set the tolerance on achieving a goal
  xy_goal_tolerance: 0.1
  yaw_goal_tolerance: 0.05
  #We'll configure how long and with what granularity we'll forward simulate trajectories
  sim_time: 1.7
  sim_granularity: 0.025
  vx_samples: 3
  vtheta_samples: 20
  #Parameters for scoring trajectories
  goal_distance_bias: 0.8
  path_distance_bias: 0.6
  occdist_scale: 0.01
  heading_lookahead: 0.325
  #We'll use the Dynamic Window Approach to control instead of Trajectory Rollout for this example
  dwa: true
  #How far the robot must travel before oscillation flags are reset
  oscillation_reset_dist: 0.05
  #Eat up the plan as the robot moves along it
  prune_plan: true

Here is costmap_common_params.yaml:

#For this example we'll configure the costmap in voxel-grid mode
map_type: voxel #Voxel grid specific parameters
origin_z: 0.0
z_resolution: 0.2
z_voxels: 10
unknown_threshold: 9
mark_threshold: 0
transform_tolerance: 0.3 #Set the tolerance we're willing to have for tf transforms
obstacle_range: 2.5 #Obstacle marking parameters // in wiki - global filtering parameters
max_obstacle_height: 2.0
raytrace_range: 3.0
footprint: [[-0.325, -0.325], [-0.325, 0.325], [0.325, 0.325], [0.46, 0.0], [0.325, -0.325]]#The footprint of the robot and associated padding
footprint_padding: 0.01
inflation_radius: 0.35 #Cost function parameters
cost_scaling_factor: 10.0
lethal_cost_threshold: 100 #The cost at which a cell is considered an obstacle when a map is read from the map_server

Here is global_costmap_params.yaml

global_costmap:
  #Set the global and robot frames for the costmap
  global_frame: /map
  robot_base_frame: base_link
  #Set the ...