jdorich's profile - activity

Sorry, I meant the " #include <ros ros.h="">" and those

Where do you include the ROS headers?

you only need to use the spin() or spinOnce() if you have subscribed to a topic. The loop_rate.sleep() performs the delay you require in this situation.

Great! See updated answer. I forgot that you could set standalone as an arg rather than loading a standalone nodelet manager.

Yes, if you just need the depth at a single coordinate in the depth image, this will work fine.

Is there a reason you are not using "openni_launch openni.launch" similar to here: https://github.com/turtlebot/turtlebot/blob/hydro-devel/turtlebot_bringup/launch/3dsensor.launch

This function should do the trick and accounts for many cases, such as endianness and the raw and rectified depth image.

Of course, if you know the endianness of your system (and the image endianness doesn't change) as well as which depth image you are subscribed to (raw or rect) then this can be simplified a lot.

Note: the function returns the depth in millimeters.

typedef union U_FloatParse {
    float float_data;
    unsigned char byte_data[4];
} U_FloatConvert;

int ReadDepthData(unsigned int height_pos, unsigned int width_pos, sensor_msgs::ImageConstPtr depth_image)
{
    // If position is invalid
    if ((height_pos >= depth_image->height) || (width_pos >= depth_image->width))
        return -1;
    int index = (height_pos*depth_image->step) + (width_pos*(depth_image->step/depth_image->width));
    // If data is 4 byte floats (rectified depth image)
    if ((depth_image->step/depth_image->width) == 4) {
        U_FloatConvert depth_data;
        int i, endian_check = 1;
        // If big endian
        if ((depth_image->is_bigendian && (*(char*)&endian_check != 1)) ||  // Both big endian
           ((!depth_image->is_bigendian) && (*(char*)&endian_check == 1))) { // Both lil endian
            for (i = 0; i < 4; i++)
                depth_data.byte_data[i] = depth_image->data[index + i];
            // Make sure data is valid (check if NaN)
            if (depth_data.float_data == depth_data.float_data)
                return int(depth_data.float_data*1000);
            return -1;  // If depth data invalid
        }
        // else, one little endian, one big endian
        for (i = 0; i < 4; i++) 
            depth_data.byte_data[i] = depth_image->data[3 + index - i];
        // Make sure data is valid (check if NaN)
        if (depth_data.float_data == depth_data.float_data)
            return int(depth_data.float_data*1000);
        return -1;  // If depth data invalid
    }
    // Otherwise, data is 2 byte integers (raw depth image)
   int temp_val;
   // If big endian
   if (depth_image->is_bigendian)
       temp_val = (depth_image->data[index] << 8) + depth_image->data[index + 1];
   // If little endian
   else
       temp_val = depth_image->data[index] + (depth_image->data[index + 1] << 8);
   // Make sure data is valid (check if NaN)
   if (temp_val == temp_val)
       return temp_val;
   return -1;  // If depth data invalid
}

Hopefully this helps.

I believe you can run the pointcloud_to_laserscan for any Sensor_msgs/PointCloud2 data by the following (in this case I've matched what you have put above for the vrep):

<launch>
  <!-- Fake Laser Standalone nodelet-->
  <node pkg="nodelet" type="nodelet" name="vrep_laser" args="standalone pointcloud_to_laserscan/CloudToScan" respawn="true">
    <param name="output_frame_id" value="/vrep_frame"/>
    <param name="min_height" value="-0.15"/>
    <param name="max_height" value="0.15"/>
    <remap from="cloud" to="/vrep/PointCloud2"/>
  </node> 

</launch>

Adjust the "output_frame_id", "min_height", and "max_height" as necessary for the vrep Sensor_msgs/PointCloud2 data.

This tutorial has information on nodelets and running standalone nodelets and this turtlebot file shows an example for how to run the pointcloud_to_laserscan nodelet. The code I have above follow these.

Hopefully this helps.

Agreed, lsusb probably wouldn't have returned that Kinect's were connected if that was the issue. Take a look at the bottom half of the answer by dan in this answer: http://answers.ros.org/question/9252/openni_camera-compiling-problem/ The USB permissions might be wrong or libusb issue.

you may just need to adjust some parameters. The pointcloud_to_laserscan essentially just takes a horizontal slice from the point cloud and makes that the "laser scan". The points in the point cloud could be out of that height range.

In the callback

current_position = data.current_pos

should do the trick. Also note, that this:

rospy.Subscriber("/joint6_controller/state", current_pos, callback)

should be this:

rospy.Subscriber("/joint6_controller/state", JointState, callback)

The dynamixel controller Joint State message documentation is here. If you want to access any other member, just call "data.[member name goes here]".

Hope this helps.

You could use ros::Rate()

ros::NodeHandle n;
ros::Publisher cmd_pub = n.advertise<geometry_msgs::twist>("/cmd_vel", 1000);
ros::Rate loop_rate(2);

while (ros::ok()) {
    cmd_pub.publish(msg);
    loop_rate.sleep();
}

The "loop_rate" input is a frequency in Hertz so you can adjust that as needed. See this tutorial for more details.

To edit it:

vi ~/.bashrc

and add that line. You could also use (as SaiHV answered)

gedit ~/.bashrc".

Make sure to

source ~/.bashrc

after editing it.

I'm out of ideas. Those are all the issues that I've ran into with the Kinect. The issue is ROS detecting the Kinect it seems though.

Try: "killall XnSensorServer" then "roslaunch openni_launch openni.launch" and see if you get the same error as before.

Try running the command "lsusb" on the computer that the Kinect is plugged into. There should be three USB devices listed that are associated with the Kinect.

If you are using "openni_launch"

roslaunch openni_launch openni_launch

with rgb_camera_info_url and depth_camera_info_url arguments. See openni_launch documentation: http:// wiki.ros.org/openni_launch#Arguments

This ROS answer (http://answers.ros.org/question/33779/how-do-i-link-an-executable-with-library-in-other-package/) covers all the things you have to do.

When you launch "turtlebot_bringup 3dsensor.launch", does it report any errors

I believe in ROS fuerte a breaker (breaker 1 possibly?) had to be enabled to have the turtlebot base power the kinect, but I'm not sure if this is the case in groovy and later. Also, the Kinect doesn't work with USB3.0 so make sure it is plugged into a 2.0 port.

See this ROS answer. You have to export cflags and lflags in package a in your case mentioned.

Do you mean that the depends are not put into the manifest?