Mani's profile - activity

There are not many runtime performance monitoring solutions for ROS. You can look at the following tools:

• rqt_top It's similar to top for ROS nodes running locally on your machine. It requires a graphical desktop environment to run since it only monitors the local machine it is running on.
• drums I wrote this tool two years ago. It should do what you are looking for both at host and process level. The documentation is far from perfect, but I may be able to assist you get it to run on your machine. You can log the data both to rosbag and to a time series database.
• arni This is similar to drums but with better documentation. The main difference is drums does not rely on ROS for gathering the statistics and also implements its own light-weight publish/subscribe middleware to collect and store the performance metrics. Unlike drums, arni comes with some fault recovery mechanisms built-in.

@Kathir No. I am not working on this. But I know at least one research group is working to provide Gazebo simulation for Parrot Bebop drones. It's not been released yet.

At the moment the state publishing rate is limited to 5Hz by the firmware.

the camera_info topic

Could you please add the type of the message you are trying to visualize? Does it have a header? If not, rqt_plot is not able to infer the time (the x-axis).

According to ROS REP-3, ROS Kinetic Kame will not be available on Ubuntu 16.10 as a binary. You can try to install ROS from source. I guess support for Ubuntu 16.10 will be added to the next release of ROS (Lunar)

In your listener() function, Lat and Lon are being accessed prior to any initialisation. If you remove the two print statements before rospy.spin(), your code should work fine.

Since _ROS Indigo_ there is builtin support for topic statistics in ROS. Based on the documentation, these are the metrics that are collected:

• Period of messages by all publishers (average, maximum, standard deviation)
• Age of messages, based on header timestamp (average, maximum, standard deviation)
• Number of dropped messages
• Traffic volume (Bytes)

To enable this feature, the /enable_statistics parameter needs to be set to true.

There are some tools that enable higher level analysis, visualisation and diagnostics based on topic statistics:

• rqt_graph (Visualisation of topic statistics)
• rosprofiler (Profiler and Visualisation based on topic statistics)
• arni (Visualisation and Fault Detection/Mitigation based on topic statistics and a custom process and host level monitor)

There is also a tool called Drums that collects fine-grained statistics about hosts, processes and network sockets that are part of a running ROS computation graph independent of the builtin data from ROS topic statistics. (Disclaimer: I am the author of Drums and the documentation is far from perfect at the moment).

Hi,

I am having an issue where by I am unable to connect to the AR Drone camera when the drone is connected through ROS using the ardrone_autonomy ardrone.launch.

I think the issue is due to the fact that I am trying to access the drone camera through the ip address with OpenCV and Python while connected through ardrone_autonomy. Below is a code snippet of how I am accomplishing this.

{

video_capture = cv2.VideoCapture()

video_capture.open('tcp://192.168.1.1:5555')

vidWidth = video_capture.get(cv2.CAP_PROP_FRAME_WIDTH)

vidHeight = video_capture.get(cv2.CAP_PROP_FRAME_HEIGHT)

}

As you can see that I am using the IP address for the camera. This works perfectly when the drone is not connected through ros which is essentially like a webcam. My end goal is for tracking and navigation through the use of images received from the camera using OpenCV which means I will have to issue movement commands(cmd_vel) which requires a connection through ardrone_autonomy based on the images received and processed by OpenCV.

Is there anyway I can accomplish this by using the IP camera from the drone while connected to ROS?

Thanks for any help!

If your ultimate goal is to use ROS and ardrone_autonomy to control the drone, I suggest that you capture the images through the ROS API as well (e.g. subscribe to the camera topic in your node), then use the cv_bridge package to convert the ROS image data type (sensor_msgs::Image) to cv::Mat. The following tutorial shows how to perform that in C++: Converting between ROS images and OpenCV images (C++)

You can fuse two sources of odometry together with a Kalman filter, which if configured properly will improve your base odometry. robot_localization package provide a very nice and easy-to-integrate EKF implementation: http://wiki.ros.org/robot_localization

You are welcome. It is going to be a rewarding process. Good luck! (PS. If this answer solved your issue, it would be great if you mark it as correct)

You are welcome. I am glad it worked. One thing you can do is to post your full solution online (i.e. as a Github gist) and provide a link in your question for future reference.

I think you need to modify your CMakeLists.txt to find_package rostest so the linker can link the test executable to all required libraries.

if (CATKIN_ENABLE_TESTING)
  find_package(rostest REQUIRED)
  add_rostest_gtest(utest test/utest.cpp)
  target_link_libraries(utest ${catkin_LIBRARIES})
endif()

Also make sure that in the package.xml file you add a test dependency to rostest : <test_depend>rostest</test_depend>

More information can be found here: Configuring rostest — catkin 0.6.18 documentation

@errolflynn Have you had any progress on this?

Many of the problems with incorrect compiler flags on non x86_64 platform have been solved in the latest SDK from Parrot (3.10.1). I maintain a slightly patched (and leaner) version of parrot_arsdk here which compiles fine on i386 and 32-bit arm architectures. This patched version is released as an standalone binary and you can install it by running sudo apt-get install ros-VERSION-parrot-arsdk on your pi or C2 (assuming ROS repositories are setup correctly).

As of today, the released version is at version 3.9.x. The 3.10.x release will come out during the next ROS release (sync) cycle. You can get it from ROS shadow-fixed repositories.

At the moment bebop_autonomy does not use this version of parrot_arsdk. Instead it builds it inline during compilation. This will change soon. To see an example of how to force bebop_autonomy to use the packaged parrot_arsdk, take a look at the following branch of bebop_autonomy : https://github.com/AutonomyLab/bebop_... . Specifically the changes in bebop_driver/package.xml and bebop_driver/CMakeLists.txt.

I've update the driver to support SDK 3.10.x and firmware 3.9. I can confirm that you can now disable video stabilisation using dynamic reconfigure. The corresponding ROS parameter is ~PictureSettingsVideoStabilizationModeMode.

The code has been merged into the main branch of bebop_autonomy.

You might be able to re-use many components of the current turtlebot packages, essentially replacing the base driver with create_autonomy, update the description files and tweak the launch/configuration files.

You are welcome. Now that the base is working, you need to pretty much go through all the tutorials regarding how to setup your custom robot, setting up its kinematic (TF) tree and how to do gmapping/amcl and how to navigate your robot with the ROS navigation stack.

You can take a look at AutonomyLab/create_autonomy: ROS driver for iRobot Create 1 and 2. . According to its REAME, it may support the 600 series.

I have not used systemd myself for this task, but I've used the following method in a fairly similar situation to wrap roslaunch.

Change /usr/local/bin/runslam.sh to:

#!/usr/bin/env bash
bash -c "source /path/to/catkin_ws/devel/setup.bash && roslaunch runslam slam.launch"

Update: The driver has been update to support SDK 3.10.x and firmware 3.9. It should work fine with your drone now.

bebop_autonomy needs to be updated to work with the latest firmware released by Parrot for Bebop drones. I will start working on it later this week and hopefully will release a new version as soon as possible.