John Hoare's profile - activity

Is it possible to have rosdep set-up a ubuntu ppa on your system as part of dependency validation?

Of course, if you have already added the PPA to your system, you can put a dependency on that package, but is there a way for rosdep to also add that ppa to your system as well?

(On newer ubuntu versions this is done by "sudo add-apt-repository ppa:user/ppa-name")

I am currently porting some of our code/infrastructure to electric from diamondback. When trying to launch my new electric stuff, I get a problem being able to launch one of our third party libraries (dynamixel_controllers) It looks like all the python programs in this package do not have the #!/usr/bin/python at the top of the files, and now they will not launch with the following error message:

If it is a script, you may be missing a '#!' declaration at the top.

I haven't changed anything related to this, and while I can add the #! to the top of each file, I'd rather not as it is an external library, and I don't want to be running our own fork of it. Is there something new to electric that I must do to launch python files?

[Update]

The specific file I'm attempting to run is the joint_trajectory_action_controller.py file from the dynamixel_controllers package. Should this be launched instead by the controller spawner or something? Here's the associated (failing) launch file:

<launch>
    <!-- Load joint names from yaml file -->
    <rosparam file="$(find cyton_arm_driver)/config/joint_controllers.yaml" command="load"/>

    <node name="cyton_joint_action_controller" pkg="dynamixel_controllers" type="joint_trajectory_action_controller.py" required="true">
        <param name="~controller_namespace" type="str" value=""/>
    </node>
</launch>

Has anyone implemented some sort of "standard" interface that you could code to, which could then generate both a standalone Node, and a Nodelet?

My main driver for this is that in my experience you can not unload a nodelet from the nodelet manager, or have the nodelet manager re-load the shared library that your nodelet lives in. For development, it's easier to build your code as a Node, and when you're comfortable that it is working, then change it to a nodelet.

Edit: It looks like as of Fuerte this is no longer true (although I haven't yet tried it out.) As long as a 1:1 mapping of library to nodelet is built, the nodelet manager (via pluginlib) should unload the library if all the nodelets in the library are no longer being used. (http://ros.org/reps/rep-0116.html) However, similar issues will occur if you are using two nodelets from the same library, and only want to modify one of them. (E.g. only shutting off one nodelet will not cause the shared library to be unloaded, and so the out of date version of the modified nodlet will be the one that the manager starts.)

I am trying to get Doxygen documentation generated for our internal project. Our project is a catkin workspace, with a lot of our own packages.

Right now, I have a script which will generate the documentation for each individual package, using rosdoc_lite. I am trying to understand how to expand this to use tags, and so each package properly cross-references each other.

My current attempt to do this (which isn't working correctly) is to run rosdoc_lite with the "-g" and "-o" flags to build the tag file, and output the code. Then I run rosdoc_lite a second time, with the "-t" switch that points to a yaml file that points to the output and generated tag files. My reasoning here is that the tag files need to first be generated, and then the second time all the cross-references can be generated.

However, this approach does not seem to work, and each package ends up not having the "Classes" tab on the top, and each package has the same set of namespaces that show up, which don't actually correspond to the local package.

Here's the excerpt from my script:

# First run through to generate tags for each package
for path in $PACKAGE_DIRS
do
  PACKAGE_NAME=`basename $path`
  echo "Package Name: $PACKAGE_NAME"
  echo "Path: $path"
  rosdoc_lite -g $OUTPUT_DIR/$PACKAGE_NAME/$PACKAGE_NAME.tag -o $OUTPUT_DIR/$PACKAGE_NAME $path
  echo "- docs_url: file://$OUTPUT_DIR/$PACKAGE_NAME/html" >> $TAG_YAML_FILE
  echo "  location: file://$OUTPUT_DIR/$PACKAGE_NAME/$PACKAGE_NAME.tag" >> $TAG_YAML_FILE
done

# Second run that should have cross references
for path in $PACKAGE_DIRS
do
  PACKAGE_NAME=`basename $path`
  echo "Package Name: $PACKAGE_NAME"
  echo "Path: $path"
  rosdoc_lite -t $TAG_YAML_FILE -o $OUTPUT_DIR/$PACKAGE_NAME $path
  echo "<li>$PACKAGE_NAME: <a href=\"$PACKAGE_NAME/html/index.html\">Code API</a>&nbsp;&nbsp;&nbsp;<a href=\"$PACKAGE_NAME/html/index-msg.html\">MSG API</a></li>" >> $INDEX_FILE
done

I think the best way to do what we want is to be able to provide your own pre-cache file specified in the package.xml https://cmake.org/cmake/help/v2.8.11/...

Thanks. We are going the route of placing the actual CMake project in a subdirectory. We will look at teaching catkin proper support possibly in the future.

It's likely that your user is not a part of the video group and so it does not have permission to open the video device.

http://ubuntuforums.org/showthread.ph...

Edit: I haven't used robot_upstart but perhaps it launches ROS as a different user than the one you are logging in with and it is not in the video group.

We want to build a pure CMake project in our catkin workspace, but we want it to be built with non default options.

Are there examples on how to do this or best practices to do this?

At first, I was imagining that you could add the CMake arguments to the package.xml that needs to be created for the package, but this doesn't look to be the case. Is there an example on how to do this, documentation seems to really be lacking for using catkin with pure cmake projects beyond stating that it is supported.

When there are several machines involved, how are timestamps created? It looks like to me that they're being generated by each machine's individual time, so if one machine is out of sync with another than all the messages will be in the past or the future. Is this actually the case or am I missing something, and how do people deal with this limitation?