pablocesar's profile - activity

The error message while trying to make the package:

+++ processing catkin package: 'mongodb_store'
-- ==> add_subdirectory(mongodb_store)
-- Using these message generators: gencpp;genlisp;genpy
CMake Error at mongodb_store/cmake/FindMongoClient.cmake:72 (message):
  MongoClient not found.
Call Stack (most recent call first):
  mongodb_store/CMakeLists.txt:9 (find_package)

The line 9 in the CMakeLists.txt:

find_package(MongoClient REQUIRED)

Hi chopin1998@gmail. I created together with a colleague a package for having the launch files and config files regardi

Hi chopin1998@gmail. I created together with a colleague a package for having the launch files and config files regardi

Hello HannesIII,

As rbbg told you, MoveIt is indeed one of the two possible ways to go (up to date), the other way is a lot more robust than MoveIt, it is call Descartes, based on the requirements of your project, like which kind of objects you'll be dealing with (shape, size and material), it could be more convenient and more stable to do the moving around the object while scanning it using Descartes. Of course, check the existing documentation of both (MoveIt and Descartes) and decide which fits you the best. Success with your project.

Honestly, so far I can't find any problem with the way that you are calling your service. Assuming that there is not a problem with your service configuration (which based on the error message it is recognized by ROS), then I only can start guessing what could be the problem.

Did you try to call it in this way:

rosservice call /mynode/myservice "data: some text"

in any case, you should try to call it without the space in between the two words, just to check if it is the reason of the error ;-)

 rosservice call /mynode/myservice "some_text"

Could you provide more info. like the image of your terminal, and also the javascript code just to be sure that it is indeed the same as the one in the tutorial.

If I understood your question, it seems to me that you are looking to this problem from the wrong perspective, you can solve it even with the use of simple topics and services without having to use Actionlib (which is a bit more powerful and complicated).

Have you asked yourself how does a mobile robot navigates or plans a path? (if not, please search for it). It is not difficult, just create a structured architecture where your nodes communicate with each-other (publish/subscribe pattern), where there must be a node that plans your path and a node that takes care of the odometry (position), so, the node that senses the location (odometry) must be publishing the position all the time. In the path planner node, use an if statement inside the listener subscribed to the topic that is publishing the odometry (odom_pose) to make sure that you will generate the new goal only when odom_pose is close enough to the previous goal_pose.

A better question could be more helpful.

Hi, just search for differential drive info.

Example: (the video is OK, but, it is kind of slow)

https://chess.eecs.berkeley.edu/eecs149/documentation/differentialDrive.pdf

https://www.youtube.com/watch?v=aE7RQNhwnPQ

http://rossum.sourceforge.net/papers/DiffSteer/DiffSteer.html

If you are done with the theory, then, look at this package and to some of the projects that are using it: http://wiki.ros.org/diff_drive_controller

There is a package that seems to be what you are asking for: http://wiki.ros.org/differential_drive

For learning the core of wheeled mobile robots I recommend you to read chapter 3 of this book: http://www.robotee.com/EBooks/Introduction_to_Autonomous_Mobile_Robots.pdf

BE AWARE: That Innok Robotics has actually two types of mobile robots (http://wiki.ros.org/Robots/Innok-Heros), one is differential (Innok Heros 223) and the other one is an over-constrained mobile robot (Innok Heros 444) that is used mostly for outdoor purposes and "behaves" like a tank in terms of its way of turning (look at: http://www-personal.umich.edu/~johannb/Papers/paper95.pdf).

Sorry, it is actually my mistake (a basic one, I guess I'm sleepy) for being using a vector as an array, for vectors it is indeed vector.size() for getting the size of it, thanks!

Hello all,

Why is the ROS services response of a vector of type: geometry_msgs/PoseStamped[] poses, creates automatically a vector that holds 24 places in it?. For example, the service is defined like this:

---
geometry_msgs/PoseStamped[] poses

Then the service call back is used in this way:

bool generate_robot_targets_service(robot_pick_place::GenerateRobotTargets::Request  &req, robot_pick_place::GenerateRobotTargets::Response &res){
             std::cout << " The size of the pose vector is:  " << sizeof(res.poses) << std::endl;//prints: The s...: 24
             return true;
}

That's just an example, but I cant understand why it does start with those 24 "poses" (mostly garbage), I try to use the .erase() method of a vector on it, to delete the "poses" and it gives a core dumped error (like always). I could create a new vector of the same type (pointer) and assign it to the res.poses vector to clean it, but, that's not the point, Why are there 24 "poses" every time the service is called?.

Any idea of this kind of behaviour?.

Hi guys,

I can't explain what is happening, maybe it is just my compiler, or my ROS version, but every time that I want to use the response vector poses (of type geometry_msgs/PoseStamped[]) it has 24 places, so if I ask for the size before assigning any value to it:

bool generate_robot_targets_service(robot_pick_place::GenerateRobotTargets::Request  &req, robot_pick_place::GenerateRobotTargets::Response &res){    
        int poses_size = sizeof(res.poses);
        std::cout << "The size of poses is:  " << poses_size << std::endl;//shows: The size of poses is: 24
        return true;
}

poses_size is equal to 24. Why? I try to delete the 24 ? (whatever they are) using the erase() vector method and it gives a core dumped error (like always). I could try creating a vector pointer and assigning it to the res.poses to point to the new memory, but still, Why does it start with 24 positions filled with garbage?

Any idea is welcome, please comment.

You "use" Rosbridge, but you show the images different than what I normally do:

std_msgs::Header h;
h.stamp = ros::Time::now();
.....
cv_bridge::CvImage cv_ptr(h, sensor_msgs::image_encodings::BGR8, img);
cv::imshow(OPENCV_WINDOW_IMAGE,cv_ptr.image);//cv::imshow(WINDOW,cv_ptr.image); for you

Sorry, but your solution takes too much time to be solved in an easy way (too many lines of code), I hope someone else will do ;-)

ROS-I brings the rich world of developed solutions (ROS packages) and the ones in research to be integrated to the industrial robots (manipulators), the main issue that ROS has is a lack of reliability and safety concern. Those are basically the main points in which ROS-I is working together with the robot vendors, industry can't afford having a robot that suddenly behave in an unexpected manner. Pros of ROS-I:

• Let's developers create solutions that are cross robot, so no matter the brand, the same solution will run for any ROS-I compatible robot.
• You can integrate the robot capabilities to existing solutions (ROS packages) that enhance the capabilities and functionalities of the robot in the production line: Like object recognition, point cloud, et c.
• Brings the open-source way of development (community) to the industrial robots, letting industries be less dependent on a specific vendor.
• Programming a tasks becomes totally independent of the vendor specific OS.

Cons of ROS-I:

• It is not reliable yet.
• takes too much time to prepare and perform the same high level movements (like welding) that a robot can perform while being easily program with its own vendor programming interface.
• Industry requires a reliable and precise robot that can perform the same movement more than 10.000 times without ever having weird behaviours. So far, MoveIt is not able to guarantee that this won't happen, Descartes gives some hopes in this aspect, giving to the user more control in the way that the robot must move, but is too clumsy to use, so, for creating a task, it is not as fast as using the vendor way of programming the robot.

At the end is a matter of a few moths (I hope) to make ROS-I reliable, user friendly and safe enough to take all vendor OS out of the market. (I'm also working on this, look at: https://github.com/fontysrobotics/rob... )

Mehdi answer your question in a relatively proper way, I just want to add the 3D transformation concept that you must understand to be able to clarify your mind. You need always to have a reference to be able to measure any movement or rotation, remember that movements are relative (relativity) to another frame. Each frame knows its own world (3D components - values: x,y,z, roll, pitch, yaw) of the objects that are placed in it, for instance, your robot is placed in the map-world frame, which means that the map-world knows where your robot is located, but your robot has a 3D shape, so it can have stuff on it, like a camera or an arm, then you need a frame in the "centroid" (close to it ;-)) of the robot to be able to transform the exact position of the camera or arm in the map-world frame, so you know the camera position relatively to the centroid of the robot (base_link) and because the world knows where the robot (base_link) is in it's own coordinates, then it knows where the camera is located. But then the robot moves, how does the map-world or robot knows where the heck it is moving?, it needs another frame from which the robot moves relatively to. That's the work of the odom frame, it is placed in the map-world frame and represent the initial position of the robot (base_link) at the beginning of the scene. If the robot moves, it does it relatively to the odom frame, so the map-world use the odom frame to calculate the robot position in its own frame ( see image: http://library.isr.ist.utl.pt/docs/ro... ).

There is more about 3D transformations (matrix transformations) and the mathematics behind it. ( https://www.youtube.com/watch?v=NsiJN... , https://www.youtube.com/watch?v=gdoI2... ), but don't waist your time getting overwhelmed (no need for a headache).

You can find more in the TF overwiew ( http://wiki.ros.org/tf/Overview/Trans... )

ROS architecture brings several advantages, like being able to reuse the work or research (packages) developed by others. if you read a bit more about ROS ( http://wiki.ros.org/ROS/Introduction , http://wiki.ros.org/ROS/Technical%20O... ) way of working you will understand that you might be able to publish/subscribe (topics) or receive/response (services) to most running nodes, so, you should now identify how to subscribe your Arduino+QT to the:

Pos_pub  = rospy.Publisher('imu/HeadingTrue', Pose2D)
PosD_pub = rospy.Publisher('imu/HeadingTrue_degree', Pose2D)
Imu_pub = rospy.Publisher('imu/data', Imu)

topics (the topics are the first parameter inside the parenthesis ;-)). So, be aware of structuring your design, your ROS master must be running somewhere and all external nodes must be connected to it.

The Arduino has I/O pins to communicate to and from, but, you can't run ROS in an Arduino, so you must connect the Arduino to the "OS" where ROS Master is running and get the info from the messages. There is a package that does the trick for using Arduino with ROS ( http://wiki.ros.org/rosserial_arduino... ), just reed it and look at some projects in github that have use this package.

For QT, I don't see any problem if it is running in a device that can run ROS (Ubuntu). Qt is broadly used by the ROS (c++) community, so you can find plenty of info for configuring it for listening to ROS topics ( http://wiki.ros.org/qt_create/Tutoria... ).

Thanks for providing more info, it is not difficult to set up the project that you have in mind, please, structure your project architecture and start implementing it, if you still have doubts, then start from the basics, reed: https://www.intorobotics.com/ros-tuto...

I think there are several ways to solve this situation, I guess the master is running in the robot, you can have ROS installed in your laptop and then connect to the master running in the robot to "control" it. If you use Rosbridge is mainly if you want to access the data through the internet (or network), could you be more specific in your question?, so people can give to you a better advice.

Hi, I would like to hide an existing robot model in Rviz from my running node (c++), I don't want to be checking and unchecking the visual enable option in the RobotModel, I would like to do it dynamically. Is there any way to update the visual of a link or robot when it is being shown in Rviz from the running node that is publishing the TF link values.

I installed all the needed dependencies for running the MoveIt visual tools demo: visual_tools_demo.launch.

It seems that the figures are published, but they are nor showed in rviz.

The error message that I receive seems to be that the message published type is not the same as the listener is waiting for, but it is debatable, see the attached image Terminal.​

This is the error:

[ERROR] [1460471289.382908506]: Client [/rviz_myuser_8324064928412942903] wants topic /moveit_visual_tools to have datatype/md5sum [visualization_msgs/Marker/18326976df9d29249efc939e00342cde], but our version has [visualization_msgs/MarkerArray/90da67007c26525f655c1c269094e39f]. Dropping connection.

This is the error image (/upfiles/14604709696160995.png)

The rviz config image