kszonek's profile - activity

You need to remap topic name on at least one of the nodes, and give deffirent names to them. Easiest way is use launch file:

<launch>
    <node name="hokuyo0" pkg="hokuyo_node" type="hokuyo_node">
        <param name="port" type="string" value="/dev/ttyACM0" />
        <remap from="scan" to="scan0" />
    </node>
    <node name="hokuyo1" pkg="hokuyo_node" type="hokuyo_node">
        <param name="port" type="string" value="/dev/ttyACM1" />
        <remap from="scan" to="scan1" />
    </node>
</launch>

Did you reload udev rules after adding new ones? Are you sure rules were propertly added? There is still something wrong with permissions.

Post output of ls -la /dev/ttyUSB* and groups

First you need to be in dialout group, then make sure tty is owned by this group.

To add yourself to group:

gpasswd -a yourUserName dialout

Then relog / restart X server / reboot to make sure

udev rule:

ATTRS{idProduct}=="6001",ATTRS{idVendor}=="0403",MODE="666",GROUP="dialout"

There is no way to eliminate drift, but there are some things you can always do. Dont know what kind of gyro you are using, but for raw sensor you can:

• compensate with calibration, collect some amount of samples while gyro is as stady as possible and avarage of measurment use as calibration value (it will change with temperature and/or voltage, depending on the sensor)
• use magnetometer for Z axis and/or accelerometers for XY, but it makes it INS and gets more complicated (and more expensive)
• if robot is not moving, you can detect no signals from wheels at all. That makes odometry way more reliable than in motion, so you can disregard gyro readings. It may improve Z accurqacy if robot is in stop for a long time. It will mess things up if you roatate robot without moving the wheels though.
• SLAM algoritms may help, if you plan to use Kinect, thats the way. Read about rgbdslam and Kinect, materials on it are all over the web (including ros wiki and ros answers)

Run pwd in directory you created package in and add it to ROS_PACKAGE_PATH. I strongly advise you to learn more about software development under Linux. Since you have problems at the very begining, I cant imagine what will happen later.

I see you are new to Linux too. echo $ROS_PACKAGE_PATH lists you all paths. Try cd /home/turtlebot/ros/ros-pkg and then create your package.

You shouldnt post an anwer to ask question - it is not a forum, use comments. Where do you create this ne package? In this directory added to ROS path? It should work then, without need to edit manifest.

Try:

export ROS_PACKAGE_PATH=$ROS_PACKAGE_PATH:/home/turtlebot/ros/ros-pkg

Otherwise it will remove previous paths.

Calling spinOnce() inside of callback is a bad idea.

@Chris: as mentioned already by domhege, your publisher is being destroyed at the end of a chattercallback function, since it is declared within it. Your publisher is NOT class member.

About the spinning, let me edit my answer, since this comment is already too long.

There is a slight difference betwean ros::spin() and ros::spinOnce(). First blocks the program and allows ros callbacks to handle node work, when second one releases after doing all ros related stuff. It allows you to do code in main function letting ros do it work.

Does image load if you dont use $(find lsi_node) ?

Try loading:

img = cvLoadImage("herramientas.jpg", CV_LOAD_IMAGE_COLOR);

and put herramientas.jpg into ~/.ros directory. If it works you can change working directory to $(find lsi_node) for this node with your launch file.

$(find lsi_node) in code code may not work as wanted, bacause it is not a launch file. You could try to work with:

 `rospack find lsi_node`

It is not a forum, one should avoid posting questions as answers. Better start your own question rather than digging up this old thread. You can post a link if questions are similar.

Try:

ls -l /dev/ttyACM*

maybe you have more than one device connected to your computer that uses ACM driver. If so run:

rosrun hokuyo_node hokuyo_node _port:=/dev/ttyACMx

Edit:

By default, hokuyo_node assumes that you have connected with USB, which uses ACM. As tfoote wrote in the comment:

rosrun hokuyo_node hokuyo_node _port:=/dev/ttyUSB0

should do the trick.

There is no direct way to do this, but fell free to write a patch :) You are not the only one annoyed be this popup.

Good practise is not to close rviz at all, only after work with the robot. If you need to restart rviz for some reason, it means there is something wrong with your code or rviz itself (happens too). I use to close rviz from time to time when I am working on battery, it saves some power (opengl likes my cpu).

As a workaround: - ctrl+s and alt+f4 to speed things up, or - alt+tab and ctrl+c, when you don't want changes to be saved

I don't know of any better solution.

After publishing on topic you need to let the ROS spin, to make sure data is actually send on the topic. Calling "publish" doesn't put the data on the topic, so if you destroy publisher before the data is send, you lose the information stored in the buffer.

The best solution is to make your callback a class member and access data as a private variable of the class from function that is publishing this information. Quick code example:

int main (int argc, char **argv)
{
    ros::init (..);
    myClass myObject;

    while(ros::ok())
    {
        myObject.publishDataIfRecieved();
        ros::spinOnce();
    }

}

I will skip the class, but constructor should create both subscriber and publisher, callback should be part of a class, as well as the temporary data storage variable/structure and some boolean to indicate new data presence. For high frequency data you should provide some security for overwriting by callback not yet published data.

Also if you are not doing any computation an the data, you can just publish it inside the callback, using publisher that is already initialized as a class member, but you should avoid too much operation in your callback

Easier solution is global variable, as mentioned before, but it is not so elegant one.

EDIT:

ros::spinOnce() callend once in a while (as often as possible) will do the trick, but if you reallllly want to use ros::spin() instead, other solution is:

class myClass
{
    (...)
    public:
    myClass() { pub = (...); sub = (...) }

    private:
    ros::Publisher pub;
    ros::Subscriber sub;

    void chattercallback(...) { pub.publish(...); }
}

int main (int argc, char **argv)
{
    ros::init (..);
    myClass myObject;
    ros::spin();
}

Since boost 1.46.1 comes as an update in 10.04 (am I right?), you should make sure there are no leftovers from previous versions in the system, especially headers. If there are any, check if CMake doesn't added them to compiler command (-I/path/to/wrong/version/of/boost/headers).

Are you linking boost_regex while building ROS? If not try adding regex to CMakeLists.

What about calling soundhandle.playWave('/absolute/path/to/my_file.wav'), does it work?

This is totaly not ROS related. You should post it somewere else.

First you need to detect an object you are interested in - I assume you have already done this. Next step would be to publish tf transform for this particular object (line), you can find this tutorial useful:

http://www.ros.org/wiki/tf/Tutorials/Adding%20a%20frame%20%28C%2B%2B%29

Carrot example is really cool :) Of course you should publish tf /object with base /laser (or whatever, according to you detection method). In the part of the code that needs an input about object position place tf listener for transform from /object to /base_link, like in this tutorial:

http://www.ros.org/wiki/tf/Tutorials/Writing%20a%20tf%20listener%20%28C%2B%2B%29

Remember to setup your robot with tfs (in this case you are going to need /base_link and /laser frames).

One way is to write your own node that will publish fake data. Tutorial for odometry publisher can be found at:

http://www.ros.org/wiki/navigation/Tutorials/RobotSetup/Odom

It requires some changes, but will give you possibility to publish automaticly whatever you need, without any user input. Other option is to use turtlesim and move fake robot around with a teleop (using keyboard or joystick). It will publish odometry for you, so there is no need to wirte any additional code, but you need to keep interacting with robot to generate change in published position.

What do you mean by ssh to yourself? Is it "ssh localhost"? If so, then I guess you have ssh server installed.

Do you access remote mashine with hostname or IP? If hostname, try using IP address instead. You can get them with

ifconfig wlan0