ROS Index
|
rsm_additions package from robot_statemachine reporobot_statemachine rsm_additions rsm_core rsm_msgs rsm_rqt_plugins rsm_rviz_plugins |
ROS Distro
|
Package Summary
| Tags | No category tags. |
| Version | 1.1.3 |
| License | BSD |
| Build type | CATKIN |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/MarcoStb1993/robot_statemachine.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2021-03-15 |
| Dev Status | MAINTAINED |
| CI status | Continuous Integration |
| Released | RELEASED |
| Tags | No category tags. |
| Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Package Description
Additional Links
Maintainers
- Marco Steinbrink
Authors
- Marco Steinbrink
RSM Additions
Additions to the RSM including all mandatory plugin states and a plugin routine state. Also an additional service provider is included.
Documentation
This package implements plugins for the Calculate Goal State, the Navigation State and the Mapping State. Furthermore, the Reversing Routine State is an optional routine state plugin. The Additions Service Provider handles the data to be transferred between these plugins.
Calculate Goal State
The Calculate Goal State interfaces the ROS package explore lite, subscribes to it’s visualization topic that shows frontiers on a 2D map and extracts the closest frontier center point to the robot as navigation goal. Therefore, it retrieves the robot’s pose and calculates it’s distance to each of the frontier’s center points. Also, previously failed goals are disregarded as potential navigation goals. If it fails to find a suitable goal for exploration, it returns an error message and transitions back to the Idle State
To have explore lite running without directly sending
commands to the navigation stack, a mock action server
is constructed in the Additions Service Provider that leads
the exploration to believe the goals are accepted. Otherwise it does not start to to
calculate frontiers. Furthermore, explore lite
is launched with progress_timeout set to 3600 seconds which gives the robot ten hours
to move, otherwise the exploration stops and needs to be relaunched.
Navigation State
The Navigation State realizes an interface to the navigation ROS package. It forwards received goals to the navigation stack and also gets feedback from it regarding the progress. If it fails, the goal is added to the failed goals list. If it succeeds, the failed goal list will be reset.
When standing still for too long, it transitions to the Idle State. Reaching the goal will initiate a transition to the Mapping State or the particular routine state if there is one available. If not, Waypoint Following State is called. After reaching a navigation goal provided by RViz and if waypoint following has ended, it transitions to Idle State.
Reverse driving is realised by running two navigation stacks, one for forward driving and one for reverse driving. This is explained in more detail later. For reverse driving the robot also features a transform to a reverse base frame. When driving in reverse, all output command velocities are negated by the Additions Service Provider. If the reverse mode is activated or deactivated, the goal is cancelled and sent to the reverse navigation.
Mapping State
There are two mapping plugins included. The first state is just a dummy state while the latter is swiveling a simulated kinect camera from left to right around a revoluting joint.
Mapping Dummy State
The Mapping Dummy State is just transitioning back to the Calculate Goal State as specific mapping procedures are only relevant for the particular robot.
Kinect Mapping State
Swivels a kinect camera mounted on a joint revoluting around the z-axis from left to right and back to it’s centered position to map the surrounding area. This only works for the implemented Gazebo simulation as it publishes commands to the joint the kinect is mounted on.
Reversing Routine State
A Routine State called Reversing Routine is also include and toggles the reverse mode when the routine is executed. This means the robot is driving in reverse when it was going forward before and vice versa.
Additions Service Provider
This data handler class retrieved the frontiers published by explore lite for visualization, extracts each frontier’s center and republishes them as possible exploration goals. In case, the exploration mode is set to Interrupt, it is also checked if the current navigation goal is still in the list of exploration goals. If not, it is published that the goal is obsolete. A tolerance for comparing these positions can be set with a parameter.
Furthermore, goals that could not be reached during exploration, here named as failed goals, are saved and published. These serve as a way of blacklisting goals. This normally happens, when the navigation finishes.
For driving in reverse mode, the velocity commands issued by the reverse navigation stack are also subscribed to and republished with negated linear velocities. It also provides a service that is called when reverse mode should be activated. Since nothing needs to be changed in the configuration to change to reverse mode, this service just replies that it was successful.
If the kinect mapping is interrupted, a service is provided that moves the camera back to it’s centered position while the RSM is continuing.
Examples
An example to move a robot backwards and forwards with the navigation stack.
Reverse robot movement with navigation stack
The following code needs to be included in your launch file (or the nodes launched respectively) to allow the robot to navigate in forward and reverse depending on the set mode:
File truncated at 100 lines see the full file
Changelog for package rsm_additions
1.1.3 (2019-08-29)
- Added all dependencies to CMakeLists and package.xml, that were missing previously
- Contributors: MarcoStb1993
1.1.2 (2019-08-28)
1.1.1 (2019-08-05)
- added changelogs
- Fixed some dependencies for the new names
- Changed package names, this time for real
- Contributors: MarcoStb1993
Wiki Tutorials
Package Dependencies
| Deps | Name |
|---|---|
| roscpp | |
| actionlib | |
| actionlib_msgs | |
| pluginlib | |
| rsm_core | |
| rsm_msgs | |
| move_base_msgs | |
| visualization_msgs | |
| std_msgs | |
| std_srvs | |
| geometry_msgs | |
| sensor_msgs | |
| tf | |
| catkin |
System Dependencies
Dependant Packages
| Name | Deps |
|---|---|
| robot_statemachine |
Launch files
- launch/gazebo.launch
- Gazebo launch files for world and robot
-
- world_file [default: $(find husky_gazebo)/worlds/clearpath_playpen.world]
- robot_namespace [default: /]
- x [default: 0.0]
- y [default: 0.0]
- z [default: 0.0]
- yaw [default: 0.0]
- urdf_extras [default: $(optenv HUSKY_URDF_EXTRAS)]
- config_extras [default: $(eval optenv('HUSKY_CONFIG_EXTRAS', find('husky_control') + '/config/empty.yaml'))]
- launch/simulation_gazebo.launch
- Simulation of Husky UGV in Gazebo running Robot Statemachine with GMapping and Explore Lite
-
- world [default: $(find husky_gazebo)/worlds/clearpath_playpen.world]
- robot_frame [default: base_footprint]
- autonomy_cmd_vel_topic [default: /autonomy/cmd_vel]
- teleoperation_cmd_vel_topic [default: /teleoperation/cmd_vel]
- cmd_vel_topic [default: /cmd_vel]
- joystick_used [default: true]
- joystick_topic [default: /joy]
- calculate_goal_plugin [default: rsm::CalculateGoalState]
- navigation_plugin [default: rsm::NavigationState]
- mapping_plugin [default: rsm::KinectMappingState]
- waypoint_routines [default: ['Reversing']]
- rviz [default: false]
- joystick_used [default: $(arg joystick_used)]
- joystick_topic [default: $(arg joystick_topic)]
- launch/simulation_stdr.launch
- Simulation of Statemachine with GMapping and Frontier Exploration
-
- robot_frame [default: robot0]
- autonomy_cmd_vel_topic [default: /robot0/autonomy/cmd_vel]
- teleoperation_cmd_vel_topic [default: /robot0/teleoperation/cmd_vel]
- cmd_vel_topic [default: /robot0/cmd_vel]
- joystick_used [default: true]
- joystick_topic [default: /joy]
- calculate_goal_plugin [default: rsm::CalculateGoalState]
- navigation_plugin [default: rsm::NavigationState]
- mapping_plugin [default: rsm::MappingDummyState]
- waypoint_routines [default: ['Reversing']]
- rviz [default: false]
- joystick_used [default: $(arg joystick_used)]
- joystick_topic [default: $(arg joystick_topic)]
Messages
Services
Plugins
Recent questions tagged rsm_additions at Robotics Stack Exchange
|
|
rsm_additions package from robot_statemachine reporobot_statemachine rsm_additions rsm_core rsm_msgs rsm_rqt_plugins rsm_rviz_plugins |
ROS Distro
|
Package Summary
| Tags | No category tags. |
| Version | 1.1.3 |
| License | BSD |
| Build type | CATKIN |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/MarcoStb1993/robot_statemachine.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2021-03-15 |
| Dev Status | MAINTAINED |
| CI status | Continuous Integration |
| Released | RELEASED |
| Tags | No category tags. |
| Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Package Description
Additional Links
Maintainers
- Marco Steinbrink
Authors
- Marco Steinbrink
RSM Additions
Additions to the RSM including all mandatory plugin states and a plugin routine state. Also an additional service provider is included.
Documentation
This package implements plugins for the Calculate Goal State, the Navigation State and the Mapping State. Furthermore, the Reversing Routine State is an optional routine state plugin. The Additions Service Provider handles the data to be transferred between these plugins.
Calculate Goal State
The Calculate Goal State interfaces the ROS package explore lite, subscribes to it’s visualization topic that shows frontiers on a 2D map and extracts the closest frontier center point to the robot as navigation goal. Therefore, it retrieves the robot’s pose and calculates it’s distance to each of the frontier’s center points. Also, previously failed goals are disregarded as potential navigation goals. If it fails to find a suitable goal for exploration, it returns an error message and transitions back to the Idle State
To have explore lite running without directly sending
commands to the navigation stack, a mock action server
is constructed in the Additions Service Provider that leads
the exploration to believe the goals are accepted. Otherwise it does not start to to
calculate frontiers. Furthermore, explore lite
is launched with progress_timeout set to 3600 seconds which gives the robot ten hours
to move, otherwise the exploration stops and needs to be relaunched.
Navigation State
The Navigation State realizes an interface to the navigation ROS package. It forwards received goals to the navigation stack and also gets feedback from it regarding the progress. If it fails, the goal is added to the failed goals list. If it succeeds, the failed goal list will be reset.
When standing still for too long, it transitions to the Idle State. Reaching the goal will initiate a transition to the Mapping State or the particular routine state if there is one available. If not, Waypoint Following State is called. After reaching a navigation goal provided by RViz and if waypoint following has ended, it transitions to Idle State.
Reverse driving is realised by running two navigation stacks, one for forward driving and one for reverse driving. This is explained in more detail later. For reverse driving the robot also features a transform to a reverse base frame. When driving in reverse, all output command velocities are negated by the Additions Service Provider. If the reverse mode is activated or deactivated, the goal is cancelled and sent to the reverse navigation.
Mapping State
There are two mapping plugins included. The first state is just a dummy state while the latter is swiveling a simulated kinect camera from left to right around a revoluting joint.
Mapping Dummy State
The Mapping Dummy State is just transitioning back to the Calculate Goal State as specific mapping procedures are only relevant for the particular robot.
Kinect Mapping State
Swivels a kinect camera mounted on a joint revoluting around the z-axis from left to right and back to it’s centered position to map the surrounding area. This only works for the implemented Gazebo simulation as it publishes commands to the joint the kinect is mounted on.
Reversing Routine State
A Routine State called Reversing Routine is also include and toggles the reverse mode when the routine is executed. This means the robot is driving in reverse when it was going forward before and vice versa.
Additions Service Provider
This data handler class retrieved the frontiers published by explore lite for visualization, extracts each frontier’s center and republishes them as possible exploration goals. In case, the exploration mode is set to Interrupt, it is also checked if the current navigation goal is still in the list of exploration goals. If not, it is published that the goal is obsolete. A tolerance for comparing these positions can be set with a parameter.
Furthermore, goals that could not be reached during exploration, here named as failed goals, are saved and published. These serve as a way of blacklisting goals. This normally happens, when the navigation finishes.
For driving in reverse mode, the velocity commands issued by the reverse navigation stack are also subscribed to and republished with negated linear velocities. It also provides a service that is called when reverse mode should be activated. Since nothing needs to be changed in the configuration to change to reverse mode, this service just replies that it was successful.
If the kinect mapping is interrupted, a service is provided that moves the camera back to it’s centered position while the RSM is continuing.
Examples
An example to move a robot backwards and forwards with the navigation stack.
Reverse robot movement with navigation stack
The following code needs to be included in your launch file (or the nodes launched respectively) to allow the robot to navigate in forward and reverse depending on the set mode:
File truncated at 100 lines see the full file
Changelog for package rsm_additions
1.1.3 (2019-08-29)
- Added all dependencies to CMakeLists and package.xml, that were missing previously
- Contributors: MarcoStb1993
1.1.2 (2019-08-28)
1.1.1 (2019-08-05)
- added changelogs
- Fixed some dependencies for the new names
- Changed package names, this time for real
- Contributors: MarcoStb1993
Wiki Tutorials
Package Dependencies
| Deps | Name |
|---|---|
| roscpp | |
| actionlib | |
| actionlib_msgs | |
| pluginlib | |
| rsm_core | |
| rsm_msgs | |
| move_base_msgs | |
| visualization_msgs | |
| std_msgs | |
| std_srvs | |
| geometry_msgs | |
| sensor_msgs | |
| tf | |
| catkin |
System Dependencies
Dependant Packages
| Name | Deps |
|---|---|
| robot_statemachine |
Launch files
- launch/gazebo.launch
- Gazebo launch files for world and robot
-
- world_file [default: $(find husky_gazebo)/worlds/clearpath_playpen.world]
- robot_namespace [default: /]
- x [default: 0.0]
- y [default: 0.0]
- z [default: 0.0]
- yaw [default: 0.0]
- urdf_extras [default: $(optenv HUSKY_URDF_EXTRAS)]
- config_extras [default: $(eval optenv('HUSKY_CONFIG_EXTRAS', find('husky_control') + '/config/empty.yaml'))]
- launch/simulation_gazebo.launch
- Simulation of Husky UGV in Gazebo running Robot Statemachine with GMapping and Explore Lite
-
- world [default: $(find husky_gazebo)/worlds/clearpath_playpen.world]
- robot_frame [default: base_footprint]
- autonomy_cmd_vel_topic [default: /autonomy/cmd_vel]
- teleoperation_cmd_vel_topic [default: /teleoperation/cmd_vel]
- cmd_vel_topic [default: /cmd_vel]
- joystick_used [default: true]
- joystick_topic [default: /joy]
- calculate_goal_plugin [default: rsm::CalculateGoalState]
- navigation_plugin [default: rsm::NavigationState]
- mapping_plugin [default: rsm::KinectMappingState]
- waypoint_routines [default: ['Reversing']]
- rviz [default: false]
- joystick_used [default: $(arg joystick_used)]
- joystick_topic [default: $(arg joystick_topic)]
- launch/simulation_stdr.launch
- Simulation of Statemachine with GMapping and Frontier Exploration
-
- robot_frame [default: robot0]
- autonomy_cmd_vel_topic [default: /robot0/autonomy/cmd_vel]
- teleoperation_cmd_vel_topic [default: /robot0/teleoperation/cmd_vel]
- cmd_vel_topic [default: /robot0/cmd_vel]
- joystick_used [default: true]
- joystick_topic [default: /joy]
- calculate_goal_plugin [default: rsm::CalculateGoalState]
- navigation_plugin [default: rsm::NavigationState]
- mapping_plugin [default: rsm::MappingDummyState]
- waypoint_routines [default: ['Reversing']]
- rviz [default: false]
- joystick_used [default: $(arg joystick_used)]
- joystick_topic [default: $(arg joystick_topic)]
Messages
Services
Plugins
Recent questions tagged rsm_additions at Robotics Stack Exchange
|
|
rsm_additions package from robot_statemachine reporobot_statemachine rsm_additions rsm_core rsm_msgs rsm_rqt_plugins rsm_rviz_plugins |
ROS Distro
|
Package Summary
| Tags | No category tags. |
| Version | 1.1.3 |
| License | BSD |
| Build type | CATKIN |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/MarcoStb1993/robot_statemachine.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2021-03-15 |
| Dev Status | MAINTAINED |
| CI status | Continuous Integration |
| Released | RELEASED |
| Tags | No category tags. |
| Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Package Description
Additional Links
Maintainers
- Marco Steinbrink
Authors
- Marco Steinbrink
RSM Additions
Additions to the RSM including all mandatory plugin states and a plugin routine state. Also an additional service provider is included.
Documentation
This package implements plugins for the Calculate Goal State, the Navigation State and the Mapping State. Furthermore, the Reversing Routine State is an optional routine state plugin. The Additions Service Provider handles the data to be transferred between these plugins.
Calculate Goal State
The Calculate Goal State interfaces the ROS package explore lite, subscribes to it’s visualization topic that shows frontiers on a 2D map and extracts the closest frontier center point to the robot as navigation goal. Therefore, it retrieves the robot’s pose and calculates it’s distance to each of the frontier’s center points. Also, previously failed goals are disregarded as potential navigation goals. If it fails to find a suitable goal for exploration, it returns an error message and transitions back to the Idle State
To have explore lite running without directly sending
commands to the navigation stack, a mock action server
is constructed in the Additions Service Provider that leads
the exploration to believe the goals are accepted. Otherwise it does not start to to
calculate frontiers. Furthermore, explore lite
is launched with progress_timeout set to 3600 seconds which gives the robot ten hours
to move, otherwise the exploration stops and needs to be relaunched.
Navigation State
The Navigation State realizes an interface to the navigation ROS package. It forwards received goals to the navigation stack and also gets feedback from it regarding the progress. If it fails, the goal is added to the failed goals list. If it succeeds, the failed goal list will be reset.
When standing still for too long, it transitions to the Idle State. Reaching the goal will initiate a transition to the Mapping State or the particular routine state if there is one available. If not, Waypoint Following State is called. After reaching a navigation goal provided by RViz and if waypoint following has ended, it transitions to Idle State.
Reverse driving is realised by running two navigation stacks, one for forward driving and one for reverse driving. This is explained in more detail later. For reverse driving the robot also features a transform to a reverse base frame. When driving in reverse, all output command velocities are negated by the Additions Service Provider. If the reverse mode is activated or deactivated, the goal is cancelled and sent to the reverse navigation.
Mapping State
There are two mapping plugins included. The first state is just a dummy state while the latter is swiveling a simulated kinect camera from left to right around a revoluting joint.
Mapping Dummy State
The Mapping Dummy State is just transitioning back to the Calculate Goal State as specific mapping procedures are only relevant for the particular robot.
Kinect Mapping State
Swivels a kinect camera mounted on a joint revoluting around the z-axis from left to right and back to it’s centered position to map the surrounding area. This only works for the implemented Gazebo simulation as it publishes commands to the joint the kinect is mounted on.
Reversing Routine State
A Routine State called Reversing Routine is also include and toggles the reverse mode when the routine is executed. This means the robot is driving in reverse when it was going forward before and vice versa.
Additions Service Provider
This data handler class retrieved the frontiers published by explore lite for visualization, extracts each frontier’s center and republishes them as possible exploration goals. In case, the exploration mode is set to Interrupt, it is also checked if the current navigation goal is still in the list of exploration goals. If not, it is published that the goal is obsolete. A tolerance for comparing these positions can be set with a parameter.
Furthermore, goals that could not be reached during exploration, here named as failed goals, are saved and published. These serve as a way of blacklisting goals. This normally happens, when the navigation finishes.
For driving in reverse mode, the velocity commands issued by the reverse navigation stack are also subscribed to and republished with negated linear velocities. It also provides a service that is called when reverse mode should be activated. Since nothing needs to be changed in the configuration to change to reverse mode, this service just replies that it was successful.
If the kinect mapping is interrupted, a service is provided that moves the camera back to it’s centered position while the RSM is continuing.
Examples
An example to move a robot backwards and forwards with the navigation stack.
Reverse robot movement with navigation stack
The following code needs to be included in your launch file (or the nodes launched respectively) to allow the robot to navigate in forward and reverse depending on the set mode:
File truncated at 100 lines see the full file
Changelog for package rsm_additions
1.1.3 (2019-08-29)
- Added all dependencies to CMakeLists and package.xml, that were missing previously
- Contributors: MarcoStb1993
1.1.2 (2019-08-28)
1.1.1 (2019-08-05)
- added changelogs
- Fixed some dependencies for the new names
- Changed package names, this time for real
- Contributors: MarcoStb1993
Wiki Tutorials
Package Dependencies
| Deps | Name |
|---|---|
| roscpp | |
| actionlib | |
| actionlib_msgs | |
| pluginlib | |
| rsm_core | |
| rsm_msgs | |
| move_base_msgs | |
| visualization_msgs | |
| std_msgs | |
| std_srvs | |
| geometry_msgs | |
| sensor_msgs | |
| tf | |
| catkin |
System Dependencies
Dependant Packages
| Name | Deps |
|---|---|
| robot_statemachine |
Launch files
- launch/gazebo.launch
- Gazebo launch files for world and robot
-
- world_file [default: $(find husky_gazebo)/worlds/clearpath_playpen.world]
- robot_namespace [default: /]
- x [default: 0.0]
- y [default: 0.0]
- z [default: 0.0]
- yaw [default: 0.0]
- urdf_extras [default: $(optenv HUSKY_URDF_EXTRAS)]
- config_extras [default: $(eval optenv('HUSKY_CONFIG_EXTRAS', find('husky_control') + '/config/empty.yaml'))]
- launch/simulation_gazebo.launch
- Simulation of Husky UGV in Gazebo running Robot Statemachine with GMapping and Explore Lite
-
- world [default: $(find husky_gazebo)/worlds/clearpath_playpen.world]
- robot_frame [default: base_footprint]
- autonomy_cmd_vel_topic [default: /autonomy/cmd_vel]
- teleoperation_cmd_vel_topic [default: /teleoperation/cmd_vel]
- cmd_vel_topic [default: /cmd_vel]
- joystick_used [default: true]
- joystick_topic [default: /joy]
- calculate_goal_plugin [default: rsm::CalculateGoalState]
- navigation_plugin [default: rsm::NavigationState]
- mapping_plugin [default: rsm::KinectMappingState]
- waypoint_routines [default: ['Reversing']]
- rviz [default: false]
- joystick_used [default: $(arg joystick_used)]
- joystick_topic [default: $(arg joystick_topic)]
- launch/simulation_stdr.launch
- Simulation of Statemachine with GMapping and Frontier Exploration
-
- robot_frame [default: robot0]
- autonomy_cmd_vel_topic [default: /robot0/autonomy/cmd_vel]
- teleoperation_cmd_vel_topic [default: /robot0/teleoperation/cmd_vel]
- cmd_vel_topic [default: /robot0/cmd_vel]
- joystick_used [default: true]
- joystick_topic [default: /joy]
- calculate_goal_plugin [default: rsm::CalculateGoalState]
- navigation_plugin [default: rsm::NavigationState]
- mapping_plugin [default: rsm::MappingDummyState]
- waypoint_routines [default: ['Reversing']]
- rviz [default: false]
- joystick_used [default: $(arg joystick_used)]
- joystick_topic [default: $(arg joystick_topic)]
Messages
Services
Plugins
Recent questions tagged rsm_additions at Robotics Stack Exchange
|
|
rsm_additions package from robot_statemachine reporobot_statemachine rsm_additions rsm_core rsm_msgs rsm_rqt_plugins rsm_rviz_plugins |
ROS Distro
|
Package Summary
| Tags | No category tags. |
| Version | 1.1.3 |
| License | BSD |
| Build type | CATKIN |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/MarcoStb1993/robot_statemachine.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2021-03-15 |
| Dev Status | MAINTAINED |
| CI status | Continuous Integration |
| Released | RELEASED |
| Tags | No category tags. |
| Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Package Description
Additional Links
Maintainers
- Marco Steinbrink
Authors
- Marco Steinbrink
RSM Additions
Additions to the RSM including all mandatory plugin states and a plugin routine state. Also an additional service provider is included.
Documentation
This package implements plugins for the Calculate Goal State, the Navigation State and the Mapping State. Furthermore, the Reversing Routine State is an optional routine state plugin. The Additions Service Provider handles the data to be transferred between these plugins.
Calculate Goal State
The Calculate Goal State interfaces the ROS package explore lite, subscribes to it’s visualization topic that shows frontiers on a 2D map and extracts the closest frontier center point to the robot as navigation goal. Therefore, it retrieves the robot’s pose and calculates it’s distance to each of the frontier’s center points. Also, previously failed goals are disregarded as potential navigation goals. If it fails to find a suitable goal for exploration, it returns an error message and transitions back to the Idle State
To have explore lite running without directly sending
commands to the navigation stack, a mock action server
is constructed in the Additions Service Provider that leads
the exploration to believe the goals are accepted. Otherwise it does not start to to
calculate frontiers. Furthermore, explore lite
is launched with progress_timeout set to 3600 seconds which gives the robot ten hours
to move, otherwise the exploration stops and needs to be relaunched.
Navigation State
The Navigation State realizes an interface to the navigation ROS package. It forwards received goals to the navigation stack and also gets feedback from it regarding the progress. If it fails, the goal is added to the failed goals list. If it succeeds, the failed goal list will be reset.
When standing still for too long, it transitions to the Idle State. Reaching the goal will initiate a transition to the Mapping State or the particular routine state if there is one available. If not, Waypoint Following State is called. After reaching a navigation goal provided by RViz and if waypoint following has ended, it transitions to Idle State.
Reverse driving is realised by running two navigation stacks, one for forward driving and one for reverse driving. This is explained in more detail later. For reverse driving the robot also features a transform to a reverse base frame. When driving in reverse, all output command velocities are negated by the Additions Service Provider. If the reverse mode is activated or deactivated, the goal is cancelled and sent to the reverse navigation.
Mapping State
There are two mapping plugins included. The first state is just a dummy state while the latter is swiveling a simulated kinect camera from left to right around a revoluting joint.
Mapping Dummy State
The Mapping Dummy State is just transitioning back to the Calculate Goal State as specific mapping procedures are only relevant for the particular robot.
Kinect Mapping State
Swivels a kinect camera mounted on a joint revoluting around the z-axis from left to right and back to it’s centered position to map the surrounding area. This only works for the implemented Gazebo simulation as it publishes commands to the joint the kinect is mounted on.
Reversing Routine State
A Routine State called Reversing Routine is also include and toggles the reverse mode when the routine is executed. This means the robot is driving in reverse when it was going forward before and vice versa.
Additions Service Provider
This data handler class retrieved the frontiers published by explore lite for visualization, extracts each frontier’s center and republishes them as possible exploration goals. In case, the exploration mode is set to Interrupt, it is also checked if the current navigation goal is still in the list of exploration goals. If not, it is published that the goal is obsolete. A tolerance for comparing these positions can be set with a parameter.
Furthermore, goals that could not be reached during exploration, here named as failed goals, are saved and published. These serve as a way of blacklisting goals. This normally happens, when the navigation finishes.
For driving in reverse mode, the velocity commands issued by the reverse navigation stack are also subscribed to and republished with negated linear velocities. It also provides a service that is called when reverse mode should be activated. Since nothing needs to be changed in the configuration to change to reverse mode, this service just replies that it was successful.
If the kinect mapping is interrupted, a service is provided that moves the camera back to it’s centered position while the RSM is continuing.
Examples
An example to move a robot backwards and forwards with the navigation stack.
Reverse robot movement with navigation stack
The following code needs to be included in your launch file (or the nodes launched respectively) to allow the robot to navigate in forward and reverse depending on the set mode:
File truncated at 100 lines see the full file
Changelog for package rsm_additions
1.1.3 (2019-08-29)
- Added all dependencies to CMakeLists and package.xml, that were missing previously
- Contributors: MarcoStb1993
1.1.2 (2019-08-28)
1.1.1 (2019-08-05)
- added changelogs
- Fixed some dependencies for the new names
- Changed package names, this time for real
- Contributors: MarcoStb1993
Wiki Tutorials
Package Dependencies
| Deps | Name |
|---|---|
| roscpp | |
| actionlib | |
| actionlib_msgs | |
| pluginlib | |
| rsm_core | |
| rsm_msgs | |
| move_base_msgs | |
| visualization_msgs | |
| std_msgs | |
| std_srvs | |
| geometry_msgs | |
| sensor_msgs | |
| tf | |
| catkin |
System Dependencies
Dependant Packages
| Name | Deps |
|---|---|
| robot_statemachine |
Launch files
- launch/gazebo.launch
- Gazebo launch files for world and robot
-
- world_file [default: $(find husky_gazebo)/worlds/clearpath_playpen.world]
- robot_namespace [default: /]
- x [default: 0.0]
- y [default: 0.0]
- z [default: 0.0]
- yaw [default: 0.0]
- urdf_extras [default: $(optenv HUSKY_URDF_EXTRAS)]
- config_extras [default: $(eval optenv('HUSKY_CONFIG_EXTRAS', find('husky_control') + '/config/empty.yaml'))]
- launch/simulation_gazebo.launch
- Simulation of Husky UGV in Gazebo running Robot Statemachine with GMapping and Explore Lite
-
- world [default: $(find husky_gazebo)/worlds/clearpath_playpen.world]
- robot_frame [default: base_footprint]
- autonomy_cmd_vel_topic [default: /autonomy/cmd_vel]
- teleoperation_cmd_vel_topic [default: /teleoperation/cmd_vel]
- cmd_vel_topic [default: /cmd_vel]
- joystick_used [default: true]
- joystick_topic [default: /joy]
- calculate_goal_plugin [default: rsm::CalculateGoalState]
- navigation_plugin [default: rsm::NavigationState]
- mapping_plugin [default: rsm::KinectMappingState]
- waypoint_routines [default: ['Reversing']]
- rviz [default: false]
- joystick_used [default: $(arg joystick_used)]
- joystick_topic [default: $(arg joystick_topic)]
- launch/simulation_stdr.launch
- Simulation of Statemachine with GMapping and Frontier Exploration
-
- robot_frame [default: robot0]
- autonomy_cmd_vel_topic [default: /robot0/autonomy/cmd_vel]
- teleoperation_cmd_vel_topic [default: /robot0/teleoperation/cmd_vel]
- cmd_vel_topic [default: /robot0/cmd_vel]
- joystick_used [default: true]
- joystick_topic [default: /joy]
- calculate_goal_plugin [default: rsm::CalculateGoalState]
- navigation_plugin [default: rsm::NavigationState]
- mapping_plugin [default: rsm::MappingDummyState]
- waypoint_routines [default: ['Reversing']]
- rviz [default: false]
- joystick_used [default: $(arg joystick_used)]
- joystick_topic [default: $(arg joystick_topic)]
Messages
Services
Plugins
Recent questions tagged rsm_additions at Robotics Stack Exchange
|
|
rsm_additions package from robot_statemachine reporobot_statemachine rsm_additions rsm_core rsm_msgs rsm_rqt_plugins rsm_rviz_plugins |
ROS Distro
|
Package Summary
| Tags | No category tags. |
| Version | 1.1.3 |
| License | BSD |
| Build type | CATKIN |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/MarcoStb1993/robot_statemachine.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2021-03-15 |
| Dev Status | MAINTAINED |
| CI status | Continuous Integration |
| Released | RELEASED |
| Tags | No category tags. |
| Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Package Description
Additional Links
Maintainers
- Marco Steinbrink
Authors
- Marco Steinbrink
RSM Additions
Additions to the RSM including all mandatory plugin states and a plugin routine state. Also an additional service provider is included.
Documentation
This package implements plugins for the Calculate Goal State, the Navigation State and the Mapping State. Furthermore, the Reversing Routine State is an optional routine state plugin. The Additions Service Provider handles the data to be transferred between these plugins.
Calculate Goal State
The Calculate Goal State interfaces the ROS package explore lite, subscribes to it’s visualization topic that shows frontiers on a 2D map and extracts the closest frontier center point to the robot as navigation goal. Therefore, it retrieves the robot’s pose and calculates it’s distance to each of the frontier’s center points. Also, previously failed goals are disregarded as potential navigation goals. If it fails to find a suitable goal for exploration, it returns an error message and transitions back to the Idle State
To have explore lite running without directly sending
commands to the navigation stack, a mock action server
is constructed in the Additions Service Provider that leads
the exploration to believe the goals are accepted. Otherwise it does not start to to
calculate frontiers. Furthermore, explore lite
is launched with progress_timeout set to 3600 seconds which gives the robot ten hours
to move, otherwise the exploration stops and needs to be relaunched.
Navigation State
The Navigation State realizes an interface to the navigation ROS package. It forwards received goals to the navigation stack and also gets feedback from it regarding the progress. If it fails, the goal is added to the failed goals list. If it succeeds, the failed goal list will be reset.
When standing still for too long, it transitions to the Idle State. Reaching the goal will initiate a transition to the Mapping State or the particular routine state if there is one available. If not, Waypoint Following State is called. After reaching a navigation goal provided by RViz and if waypoint following has ended, it transitions to Idle State.
Reverse driving is realised by running two navigation stacks, one for forward driving and one for reverse driving. This is explained in more detail later. For reverse driving the robot also features a transform to a reverse base frame. When driving in reverse, all output command velocities are negated by the Additions Service Provider. If the reverse mode is activated or deactivated, the goal is cancelled and sent to the reverse navigation.
Mapping State
There are two mapping plugins included. The first state is just a dummy state while the latter is swiveling a simulated kinect camera from left to right around a revoluting joint.
Mapping Dummy State
The Mapping Dummy State is just transitioning back to the Calculate Goal State as specific mapping procedures are only relevant for the particular robot.
Kinect Mapping State
Swivels a kinect camera mounted on a joint revoluting around the z-axis from left to right and back to it’s centered position to map the surrounding area. This only works for the implemented Gazebo simulation as it publishes commands to the joint the kinect is mounted on.
Reversing Routine State
A Routine State called Reversing Routine is also include and toggles the reverse mode when the routine is executed. This means the robot is driving in reverse when it was going forward before and vice versa.
Additions Service Provider
This data handler class retrieved the frontiers published by explore lite for visualization, extracts each frontier’s center and republishes them as possible exploration goals. In case, the exploration mode is set to Interrupt, it is also checked if the current navigation goal is still in the list of exploration goals. If not, it is published that the goal is obsolete. A tolerance for comparing these positions can be set with a parameter.
Furthermore, goals that could not be reached during exploration, here named as failed goals, are saved and published. These serve as a way of blacklisting goals. This normally happens, when the navigation finishes.
For driving in reverse mode, the velocity commands issued by the reverse navigation stack are also subscribed to and republished with negated linear velocities. It also provides a service that is called when reverse mode should be activated. Since nothing needs to be changed in the configuration to change to reverse mode, this service just replies that it was successful.
If the kinect mapping is interrupted, a service is provided that moves the camera back to it’s centered position while the RSM is continuing.
Examples
An example to move a robot backwards and forwards with the navigation stack.
Reverse robot movement with navigation stack
The following code needs to be included in your launch file (or the nodes launched respectively) to allow the robot to navigate in forward and reverse depending on the set mode:
File truncated at 100 lines see the full file
Changelog for package rsm_additions
1.1.3 (2019-08-29)
- Added all dependencies to CMakeLists and package.xml, that were missing previously
- Contributors: MarcoStb1993
1.1.2 (2019-08-28)
1.1.1 (2019-08-05)
- added changelogs
- Fixed some dependencies for the new names
- Changed package names, this time for real
- Contributors: MarcoStb1993
Wiki Tutorials
Package Dependencies
| Deps | Name |
|---|---|
| roscpp | |
| actionlib | |
| actionlib_msgs | |
| pluginlib | |
| rsm_core | |
| rsm_msgs | |
| move_base_msgs | |
| visualization_msgs | |
| std_msgs | |
| std_srvs | |
| geometry_msgs | |
| sensor_msgs | |
| tf | |
| catkin |
System Dependencies
Dependant Packages
| Name | Deps |
|---|---|
| robot_statemachine |
Launch files
- launch/gazebo.launch
- Gazebo launch files for world and robot
-
- world_file [default: $(find husky_gazebo)/worlds/clearpath_playpen.world]
- robot_namespace [default: /]
- x [default: 0.0]
- y [default: 0.0]
- z [default: 0.0]
- yaw [default: 0.0]
- urdf_extras [default: $(optenv HUSKY_URDF_EXTRAS)]
- config_extras [default: $(eval optenv('HUSKY_CONFIG_EXTRAS', find('husky_control') + '/config/empty.yaml'))]
- launch/simulation_gazebo.launch
- Simulation of Husky UGV in Gazebo running Robot Statemachine with GMapping and Explore Lite
-
- world [default: $(find husky_gazebo)/worlds/clearpath_playpen.world]
- robot_frame [default: base_footprint]
- autonomy_cmd_vel_topic [default: /autonomy/cmd_vel]
- teleoperation_cmd_vel_topic [default: /teleoperation/cmd_vel]
- cmd_vel_topic [default: /cmd_vel]
- joystick_used [default: true]
- joystick_topic [default: /joy]
- calculate_goal_plugin [default: rsm::CalculateGoalState]
- navigation_plugin [default: rsm::NavigationState]
- mapping_plugin [default: rsm::KinectMappingState]
- waypoint_routines [default: ['Reversing']]
- rviz [default: false]
- joystick_used [default: $(arg joystick_used)]
- joystick_topic [default: $(arg joystick_topic)]
- launch/simulation_stdr.launch
- Simulation of Statemachine with GMapping and Frontier Exploration
-
- robot_frame [default: robot0]
- autonomy_cmd_vel_topic [default: /robot0/autonomy/cmd_vel]
- teleoperation_cmd_vel_topic [default: /robot0/teleoperation/cmd_vel]
- cmd_vel_topic [default: /robot0/cmd_vel]
- joystick_used [default: true]
- joystick_topic [default: /joy]
- calculate_goal_plugin [default: rsm::CalculateGoalState]
- navigation_plugin [default: rsm::NavigationState]
- mapping_plugin [default: rsm::MappingDummyState]
- waypoint_routines [default: ['Reversing']]
- rviz [default: false]
- joystick_used [default: $(arg joystick_used)]
- joystick_topic [default: $(arg joystick_topic)]
Messages
Services
Plugins
Recent questions tagged rsm_additions at Robotics Stack Exchange
|
|
rsm_additions package from robot_statemachine reporobot_statemachine rsm_additions rsm_core rsm_msgs rsm_rqt_plugins rsm_rviz_plugins |
ROS Distro
|
Package Summary
| Tags | No category tags. |
| Version | 1.1.3 |
| License | BSD |
| Build type | CATKIN |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/MarcoStb1993/robot_statemachine.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2021-03-15 |
| Dev Status | MAINTAINED |
| CI status | Continuous Integration |
| Released | RELEASED |
| Tags | No category tags. |
| Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Package Description
Additional Links
Maintainers
- Marco Steinbrink
Authors
- Marco Steinbrink
RSM Additions
Additions to the RSM including all mandatory plugin states and a plugin routine state. Also an additional service provider is included.
Documentation
This package implements plugins for the Calculate Goal State, the Navigation State and the Mapping State. Furthermore, the Reversing Routine State is an optional routine state plugin. The Additions Service Provider handles the data to be transferred between these plugins.
Calculate Goal State
The Calculate Goal State interfaces the ROS package explore lite, subscribes to it’s visualization topic that shows frontiers on a 2D map and extracts the closest frontier center point to the robot as navigation goal. Therefore, it retrieves the robot’s pose and calculates it’s distance to each of the frontier’s center points. Also, previously failed goals are disregarded as potential navigation goals. If it fails to find a suitable goal for exploration, it returns an error message and transitions back to the Idle State
To have explore lite running without directly sending
commands to the navigation stack, a mock action server
is constructed in the Additions Service Provider that leads
the exploration to believe the goals are accepted. Otherwise it does not start to to
calculate frontiers. Furthermore, explore lite
is launched with progress_timeout set to 3600 seconds which gives the robot ten hours
to move, otherwise the exploration stops and needs to be relaunched.
Navigation State
The Navigation State realizes an interface to the navigation ROS package. It forwards received goals to the navigation stack and also gets feedback from it regarding the progress. If it fails, the goal is added to the failed goals list. If it succeeds, the failed goal list will be reset.
When standing still for too long, it transitions to the Idle State. Reaching the goal will initiate a transition to the Mapping State or the particular routine state if there is one available. If not, Waypoint Following State is called. After reaching a navigation goal provided by RViz and if waypoint following has ended, it transitions to Idle State.
Reverse driving is realised by running two navigation stacks, one for forward driving and one for reverse driving. This is explained in more detail later. For reverse driving the robot also features a transform to a reverse base frame. When driving in reverse, all output command velocities are negated by the Additions Service Provider. If the reverse mode is activated or deactivated, the goal is cancelled and sent to the reverse navigation.
Mapping State
There are two mapping plugins included. The first state is just a dummy state while the latter is swiveling a simulated kinect camera from left to right around a revoluting joint.
Mapping Dummy State
The Mapping Dummy State is just transitioning back to the Calculate Goal State as specific mapping procedures are only relevant for the particular robot.
Kinect Mapping State
Swivels a kinect camera mounted on a joint revoluting around the z-axis from left to right and back to it’s centered position to map the surrounding area. This only works for the implemented Gazebo simulation as it publishes commands to the joint the kinect is mounted on.
Reversing Routine State
A Routine State called Reversing Routine is also include and toggles the reverse mode when the routine is executed. This means the robot is driving in reverse when it was going forward before and vice versa.
Additions Service Provider
This data handler class retrieved the frontiers published by explore lite for visualization, extracts each frontier’s center and republishes them as possible exploration goals. In case, the exploration mode is set to Interrupt, it is also checked if the current navigation goal is still in the list of exploration goals. If not, it is published that the goal is obsolete. A tolerance for comparing these positions can be set with a parameter.
Furthermore, goals that could not be reached during exploration, here named as failed goals, are saved and published. These serve as a way of blacklisting goals. This normally happens, when the navigation finishes.
For driving in reverse mode, the velocity commands issued by the reverse navigation stack are also subscribed to and republished with negated linear velocities. It also provides a service that is called when reverse mode should be activated. Since nothing needs to be changed in the configuration to change to reverse mode, this service just replies that it was successful.
If the kinect mapping is interrupted, a service is provided that moves the camera back to it’s centered position while the RSM is continuing.
Examples
An example to move a robot backwards and forwards with the navigation stack.
Reverse robot movement with navigation stack
The following code needs to be included in your launch file (or the nodes launched respectively) to allow the robot to navigate in forward and reverse depending on the set mode:
File truncated at 100 lines see the full file
Changelog for package rsm_additions
1.1.3 (2019-08-29)
- Added all dependencies to CMakeLists and package.xml, that were missing previously
- Contributors: MarcoStb1993
1.1.2 (2019-08-28)
1.1.1 (2019-08-05)
- added changelogs
- Fixed some dependencies for the new names
- Changed package names, this time for real
- Contributors: MarcoStb1993
Wiki Tutorials
Package Dependencies
| Deps | Name |
|---|---|
| roscpp | |
| actionlib | |
| actionlib_msgs | |
| pluginlib | |
| rsm_core | |
| rsm_msgs | |
| move_base_msgs | |
| visualization_msgs | |
| std_msgs | |
| std_srvs | |
| geometry_msgs | |
| sensor_msgs | |
| tf | |
| catkin |
System Dependencies
Dependant Packages
| Name | Deps |
|---|---|
| robot_statemachine |
Launch files
- launch/gazebo.launch
- Gazebo launch files for world and robot
-
- world_file [default: $(find husky_gazebo)/worlds/clearpath_playpen.world]
- robot_namespace [default: /]
- x [default: 0.0]
- y [default: 0.0]
- z [default: 0.0]
- yaw [default: 0.0]
- urdf_extras [default: $(optenv HUSKY_URDF_EXTRAS)]
- config_extras [default: $(eval optenv('HUSKY_CONFIG_EXTRAS', find('husky_control') + '/config/empty.yaml'))]
- launch/simulation_gazebo.launch
- Simulation of Husky UGV in Gazebo running Robot Statemachine with GMapping and Explore Lite
-
- world [default: $(find husky_gazebo)/worlds/clearpath_playpen.world]
- robot_frame [default: base_footprint]
- autonomy_cmd_vel_topic [default: /autonomy/cmd_vel]
- teleoperation_cmd_vel_topic [default: /teleoperation/cmd_vel]
- cmd_vel_topic [default: /cmd_vel]
- joystick_used [default: true]
- joystick_topic [default: /joy]
- calculate_goal_plugin [default: rsm::CalculateGoalState]
- navigation_plugin [default: rsm::NavigationState]
- mapping_plugin [default: rsm::KinectMappingState]
- waypoint_routines [default: ['Reversing']]
- rviz [default: false]
- joystick_used [default: $(arg joystick_used)]
- joystick_topic [default: $(arg joystick_topic)]
- launch/simulation_stdr.launch
- Simulation of Statemachine with GMapping and Frontier Exploration
-
- robot_frame [default: robot0]
- autonomy_cmd_vel_topic [default: /robot0/autonomy/cmd_vel]
- teleoperation_cmd_vel_topic [default: /robot0/teleoperation/cmd_vel]
- cmd_vel_topic [default: /robot0/cmd_vel]
- joystick_used [default: true]
- joystick_topic [default: /joy]
- calculate_goal_plugin [default: rsm::CalculateGoalState]
- navigation_plugin [default: rsm::NavigationState]
- mapping_plugin [default: rsm::MappingDummyState]
- waypoint_routines [default: ['Reversing']]
- rviz [default: false]
- joystick_used [default: $(arg joystick_used)]
- joystick_topic [default: $(arg joystick_topic)]
Messages
Services
Plugins
Recent questions tagged rsm_additions at Robotics Stack Exchange
|
|
rsm_additions package from robot_statemachine reporobot_statemachine rsm_additions rsm_core rsm_msgs rsm_rqt_plugins rsm_rviz_plugins |
ROS Distro
|
Package Summary
| Tags | No category tags. |
| Version | 1.1.3 |
| License | BSD |
| Build type | CATKIN |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/MarcoStb1993/robot_statemachine.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2021-03-15 |
| Dev Status | MAINTAINED |
| CI status | Continuous Integration |
| Released | RELEASED |
| Tags | No category tags. |
| Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Package Description
Additional Links
Maintainers
- Marco Steinbrink
Authors
- Marco Steinbrink
RSM Additions
Additions to the RSM including all mandatory plugin states and a plugin routine state. Also an additional service provider is included.
Documentation
This package implements plugins for the Calculate Goal State, the Navigation State and the Mapping State. Furthermore, the Reversing Routine State is an optional routine state plugin. The Additions Service Provider handles the data to be transferred between these plugins.
Calculate Goal State
The Calculate Goal State interfaces the ROS package explore lite, subscribes to it’s visualization topic that shows frontiers on a 2D map and extracts the closest frontier center point to the robot as navigation goal. Therefore, it retrieves the robot’s pose and calculates it’s distance to each of the frontier’s center points. Also, previously failed goals are disregarded as potential navigation goals. If it fails to find a suitable goal for exploration, it returns an error message and transitions back to the Idle State
To have explore lite running without directly sending
commands to the navigation stack, a mock action server
is constructed in the Additions Service Provider that leads
the exploration to believe the goals are accepted. Otherwise it does not start to to
calculate frontiers. Furthermore, explore lite
is launched with progress_timeout set to 3600 seconds which gives the robot ten hours
to move, otherwise the exploration stops and needs to be relaunched.
Navigation State
The Navigation State realizes an interface to the navigation ROS package. It forwards received goals to the navigation stack and also gets feedback from it regarding the progress. If it fails, the goal is added to the failed goals list. If it succeeds, the failed goal list will be reset.
When standing still for too long, it transitions to the Idle State. Reaching the goal will initiate a transition to the Mapping State or the particular routine state if there is one available. If not, Waypoint Following State is called. After reaching a navigation goal provided by RViz and if waypoint following has ended, it transitions to Idle State.
Reverse driving is realised by running two navigation stacks, one for forward driving and one for reverse driving. This is explained in more detail later. For reverse driving the robot also features a transform to a reverse base frame. When driving in reverse, all output command velocities are negated by the Additions Service Provider. If the reverse mode is activated or deactivated, the goal is cancelled and sent to the reverse navigation.
Mapping State
There are two mapping plugins included. The first state is just a dummy state while the latter is swiveling a simulated kinect camera from left to right around a revoluting joint.
Mapping Dummy State
The Mapping Dummy State is just transitioning back to the Calculate Goal State as specific mapping procedures are only relevant for the particular robot.
Kinect Mapping State
Swivels a kinect camera mounted on a joint revoluting around the z-axis from left to right and back to it’s centered position to map the surrounding area. This only works for the implemented Gazebo simulation as it publishes commands to the joint the kinect is mounted on.
Reversing Routine State
A Routine State called Reversing Routine is also include and toggles the reverse mode when the routine is executed. This means the robot is driving in reverse when it was going forward before and vice versa.
Additions Service Provider
This data handler class retrieved the frontiers published by explore lite for visualization, extracts each frontier’s center and republishes them as possible exploration goals. In case, the exploration mode is set to Interrupt, it is also checked if the current navigation goal is still in the list of exploration goals. If not, it is published that the goal is obsolete. A tolerance for comparing these positions can be set with a parameter.
Furthermore, goals that could not be reached during exploration, here named as failed goals, are saved and published. These serve as a way of blacklisting goals. This normally happens, when the navigation finishes.
For driving in reverse mode, the velocity commands issued by the reverse navigation stack are also subscribed to and republished with negated linear velocities. It also provides a service that is called when reverse mode should be activated. Since nothing needs to be changed in the configuration to change to reverse mode, this service just replies that it was successful.
If the kinect mapping is interrupted, a service is provided that moves the camera back to it’s centered position while the RSM is continuing.
Examples
An example to move a robot backwards and forwards with the navigation stack.
Reverse robot movement with navigation stack
The following code needs to be included in your launch file (or the nodes launched respectively) to allow the robot to navigate in forward and reverse depending on the set mode:
File truncated at 100 lines see the full file
Changelog for package rsm_additions
1.1.3 (2019-08-29)
- Added all dependencies to CMakeLists and package.xml, that were missing previously
- Contributors: MarcoStb1993
1.1.2 (2019-08-28)
1.1.1 (2019-08-05)
- added changelogs
- Fixed some dependencies for the new names
- Changed package names, this time for real
- Contributors: MarcoStb1993
Wiki Tutorials
Package Dependencies
| Deps | Name |
|---|---|
| roscpp | |
| actionlib | |
| actionlib_msgs | |
| pluginlib | |
| rsm_core | |
| rsm_msgs | |
| move_base_msgs | |
| visualization_msgs | |
| std_msgs | |
| std_srvs | |
| geometry_msgs | |
| sensor_msgs | |
| tf | |
| catkin |
System Dependencies
Dependant Packages
| Name | Deps |
|---|---|
| robot_statemachine |
Launch files
- launch/gazebo.launch
- Gazebo launch files for world and robot
-
- world_file [default: $(find husky_gazebo)/worlds/clearpath_playpen.world]
- robot_namespace [default: /]
- x [default: 0.0]
- y [default: 0.0]
- z [default: 0.0]
- yaw [default: 0.0]
- urdf_extras [default: $(optenv HUSKY_URDF_EXTRAS)]
- config_extras [default: $(eval optenv('HUSKY_CONFIG_EXTRAS', find('husky_control') + '/config/empty.yaml'))]
- launch/simulation_gazebo.launch
- Simulation of Husky UGV in Gazebo running Robot Statemachine with GMapping and Explore Lite
-
- world [default: $(find husky_gazebo)/worlds/clearpath_playpen.world]
- robot_frame [default: base_footprint]
- autonomy_cmd_vel_topic [default: /autonomy/cmd_vel]
- teleoperation_cmd_vel_topic [default: /teleoperation/cmd_vel]
- cmd_vel_topic [default: /cmd_vel]
- joystick_used [default: true]
- joystick_topic [default: /joy]
- calculate_goal_plugin [default: rsm::CalculateGoalState]
- navigation_plugin [default: rsm::NavigationState]
- mapping_plugin [default: rsm::KinectMappingState]
- waypoint_routines [default: ['Reversing']]
- rviz [default: false]
- joystick_used [default: $(arg joystick_used)]
- joystick_topic [default: $(arg joystick_topic)]
- launch/simulation_stdr.launch
- Simulation of Statemachine with GMapping and Frontier Exploration
-
- robot_frame [default: robot0]
- autonomy_cmd_vel_topic [default: /robot0/autonomy/cmd_vel]
- teleoperation_cmd_vel_topic [default: /robot0/teleoperation/cmd_vel]
- cmd_vel_topic [default: /robot0/cmd_vel]
- joystick_used [default: true]
- joystick_topic [default: /joy]
- calculate_goal_plugin [default: rsm::CalculateGoalState]
- navigation_plugin [default: rsm::NavigationState]
- mapping_plugin [default: rsm::MappingDummyState]
- waypoint_routines [default: ['Reversing']]
- rviz [default: false]
- joystick_used [default: $(arg joystick_used)]
- joystick_topic [default: $(arg joystick_topic)]
Messages
Services
Plugins
Recent questions tagged rsm_additions at Robotics Stack Exchange
|
|
rsm_additions package from robot_statemachine reporobot_statemachine rsm_additions rsm_core rsm_msgs rsm_rqt_plugins rsm_rviz_plugins |
ROS Distro
|
Package Summary
| Tags | No category tags. |
| Version | 1.1.3 |
| License | BSD |
| Build type | CATKIN |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/MarcoStb1993/robot_statemachine.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2021-03-15 |
| Dev Status | MAINTAINED |
| CI status | Continuous Integration |
| Released | RELEASED |
| Tags | No category tags. |
| Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Package Description
Additional Links
Maintainers
- Marco Steinbrink
Authors
- Marco Steinbrink
RSM Additions
Additions to the RSM including all mandatory plugin states and a plugin routine state. Also an additional service provider is included.
Documentation
This package implements plugins for the Calculate Goal State, the Navigation State and the Mapping State. Furthermore, the Reversing Routine State is an optional routine state plugin. The Additions Service Provider handles the data to be transferred between these plugins.
Calculate Goal State
The Calculate Goal State interfaces the ROS package explore lite, subscribes to it’s visualization topic that shows frontiers on a 2D map and extracts the closest frontier center point to the robot as navigation goal. Therefore, it retrieves the robot’s pose and calculates it’s distance to each of the frontier’s center points. Also, previously failed goals are disregarded as potential navigation goals. If it fails to find a suitable goal for exploration, it returns an error message and transitions back to the Idle State
To have explore lite running without directly sending
commands to the navigation stack, a mock action server
is constructed in the Additions Service Provider that leads
the exploration to believe the goals are accepted. Otherwise it does not start to to
calculate frontiers. Furthermore, explore lite
is launched with progress_timeout set to 3600 seconds which gives the robot ten hours
to move, otherwise the exploration stops and needs to be relaunched.
Navigation State
The Navigation State realizes an interface to the navigation ROS package. It forwards received goals to the navigation stack and also gets feedback from it regarding the progress. If it fails, the goal is added to the failed goals list. If it succeeds, the failed goal list will be reset.
When standing still for too long, it transitions to the Idle State. Reaching the goal will initiate a transition to the Mapping State or the particular routine state if there is one available. If not, Waypoint Following State is called. After reaching a navigation goal provided by RViz and if waypoint following has ended, it transitions to Idle State.
Reverse driving is realised by running two navigation stacks, one for forward driving and one for reverse driving. This is explained in more detail later. For reverse driving the robot also features a transform to a reverse base frame. When driving in reverse, all output command velocities are negated by the Additions Service Provider. If the reverse mode is activated or deactivated, the goal is cancelled and sent to the reverse navigation.
Mapping State
There are two mapping plugins included. The first state is just a dummy state while the latter is swiveling a simulated kinect camera from left to right around a revoluting joint.
Mapping Dummy State
The Mapping Dummy State is just transitioning back to the Calculate Goal State as specific mapping procedures are only relevant for the particular robot.
Kinect Mapping State
Swivels a kinect camera mounted on a joint revoluting around the z-axis from left to right and back to it’s centered position to map the surrounding area. This only works for the implemented Gazebo simulation as it publishes commands to the joint the kinect is mounted on.
Reversing Routine State
A Routine State called Reversing Routine is also include and toggles the reverse mode when the routine is executed. This means the robot is driving in reverse when it was going forward before and vice versa.
Additions Service Provider
This data handler class retrieved the frontiers published by explore lite for visualization, extracts each frontier’s center and republishes them as possible exploration goals. In case, the exploration mode is set to Interrupt, it is also checked if the current navigation goal is still in the list of exploration goals. If not, it is published that the goal is obsolete. A tolerance for comparing these positions can be set with a parameter.
Furthermore, goals that could not be reached during exploration, here named as failed goals, are saved and published. These serve as a way of blacklisting goals. This normally happens, when the navigation finishes.
For driving in reverse mode, the velocity commands issued by the reverse navigation stack are also subscribed to and republished with negated linear velocities. It also provides a service that is called when reverse mode should be activated. Since nothing needs to be changed in the configuration to change to reverse mode, this service just replies that it was successful.
If the kinect mapping is interrupted, a service is provided that moves the camera back to it’s centered position while the RSM is continuing.
Examples
An example to move a robot backwards and forwards with the navigation stack.
Reverse robot movement with navigation stack
The following code needs to be included in your launch file (or the nodes launched respectively) to allow the robot to navigate in forward and reverse depending on the set mode:
File truncated at 100 lines see the full file
Changelog for package rsm_additions
1.1.3 (2019-08-29)
- Added all dependencies to CMakeLists and package.xml, that were missing previously
- Contributors: MarcoStb1993
1.1.2 (2019-08-28)
1.1.1 (2019-08-05)
- added changelogs
- Fixed some dependencies for the new names
- Changed package names, this time for real
- Contributors: MarcoStb1993
Wiki Tutorials
Package Dependencies
| Deps | Name |
|---|---|
| roscpp | |
| actionlib | |
| actionlib_msgs | |
| pluginlib | |
| rsm_core | |
| rsm_msgs | |
| move_base_msgs | |
| visualization_msgs | |
| std_msgs | |
| std_srvs | |
| geometry_msgs | |
| sensor_msgs | |
| tf | |
| catkin |
System Dependencies
Dependant Packages
| Name | Deps |
|---|---|
| robot_statemachine |
Launch files
- launch/gazebo.launch
- Gazebo launch files for world and robot
-
- world_file [default: $(find husky_gazebo)/worlds/clearpath_playpen.world]
- robot_namespace [default: /]
- x [default: 0.0]
- y [default: 0.0]
- z [default: 0.0]
- yaw [default: 0.0]
- urdf_extras [default: $(optenv HUSKY_URDF_EXTRAS)]
- config_extras [default: $(eval optenv('HUSKY_CONFIG_EXTRAS', find('husky_control') + '/config/empty.yaml'))]
- launch/simulation_gazebo.launch
- Simulation of Husky UGV in Gazebo running Robot Statemachine with GMapping and Explore Lite
-
- world [default: $(find husky_gazebo)/worlds/clearpath_playpen.world]
- robot_frame [default: base_footprint]
- autonomy_cmd_vel_topic [default: /autonomy/cmd_vel]
- teleoperation_cmd_vel_topic [default: /teleoperation/cmd_vel]
- cmd_vel_topic [default: /cmd_vel]
- joystick_used [default: true]
- joystick_topic [default: /joy]
- calculate_goal_plugin [default: rsm::CalculateGoalState]
- navigation_plugin [default: rsm::NavigationState]
- mapping_plugin [default: rsm::KinectMappingState]
- waypoint_routines [default: ['Reversing']]
- rviz [default: false]
- joystick_used [default: $(arg joystick_used)]
- joystick_topic [default: $(arg joystick_topic)]
- launch/simulation_stdr.launch
- Simulation of Statemachine with GMapping and Frontier Exploration
-
- robot_frame [default: robot0]
- autonomy_cmd_vel_topic [default: /robot0/autonomy/cmd_vel]
- teleoperation_cmd_vel_topic [default: /robot0/teleoperation/cmd_vel]
- cmd_vel_topic [default: /robot0/cmd_vel]
- joystick_used [default: true]
- joystick_topic [default: /joy]
- calculate_goal_plugin [default: rsm::CalculateGoalState]
- navigation_plugin [default: rsm::NavigationState]
- mapping_plugin [default: rsm::MappingDummyState]
- waypoint_routines [default: ['Reversing']]
- rviz [default: false]
- joystick_used [default: $(arg joystick_used)]
- joystick_topic [default: $(arg joystick_topic)]
Messages
Services
Plugins
Recent questions tagged rsm_additions at Robotics Stack Exchange
|
|
rsm_additions package from robot_statemachine reporobot_statemachine rsm_additions rsm_core rsm_msgs rsm_rqt_plugins rsm_rviz_plugins |
ROS Distro
|
Package Summary
| Tags | No category tags. |
| Version | 1.1.3 |
| License | BSD |
| Build type | CATKIN |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/MarcoStb1993/robot_statemachine.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2021-03-15 |
| Dev Status | MAINTAINED |
| CI status | Continuous Integration |
| Released | RELEASED |
| Tags | No category tags. |
| Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Package Description
Additional Links
Maintainers
- Marco Steinbrink
Authors
- Marco Steinbrink
RSM Additions
Additions to the RSM including all mandatory plugin states and a plugin routine state. Also an additional service provider is included.
Documentation
This package implements plugins for the Calculate Goal State, the Navigation State and the Mapping State. Furthermore, the Reversing Routine State is an optional routine state plugin. The Additions Service Provider handles the data to be transferred between these plugins.
Calculate Goal State
The Calculate Goal State interfaces the ROS package explore lite, subscribes to it’s visualization topic that shows frontiers on a 2D map and extracts the closest frontier center point to the robot as navigation goal. Therefore, it retrieves the robot’s pose and calculates it’s distance to each of the frontier’s center points. Also, previously failed goals are disregarded as potential navigation goals. If it fails to find a suitable goal for exploration, it returns an error message and transitions back to the Idle State
To have explore lite running without directly sending
commands to the navigation stack, a mock action server
is constructed in the Additions Service Provider that leads
the exploration to believe the goals are accepted. Otherwise it does not start to to
calculate frontiers. Furthermore, explore lite
is launched with progress_timeout set to 3600 seconds which gives the robot ten hours
to move, otherwise the exploration stops and needs to be relaunched.
Navigation State
The Navigation State realizes an interface to the navigation ROS package. It forwards received goals to the navigation stack and also gets feedback from it regarding the progress. If it fails, the goal is added to the failed goals list. If it succeeds, the failed goal list will be reset.
When standing still for too long, it transitions to the Idle State. Reaching the goal will initiate a transition to the Mapping State or the particular routine state if there is one available. If not, Waypoint Following State is called. After reaching a navigation goal provided by RViz and if waypoint following has ended, it transitions to Idle State.
Reverse driving is realised by running two navigation stacks, one for forward driving and one for reverse driving. This is explained in more detail later. For reverse driving the robot also features a transform to a reverse base frame. When driving in reverse, all output command velocities are negated by the Additions Service Provider. If the reverse mode is activated or deactivated, the goal is cancelled and sent to the reverse navigation.
Mapping State
There are two mapping plugins included. The first state is just a dummy state while the latter is swiveling a simulated kinect camera from left to right around a revoluting joint.
Mapping Dummy State
The Mapping Dummy State is just transitioning back to the Calculate Goal State as specific mapping procedures are only relevant for the particular robot.
Kinect Mapping State
Swivels a kinect camera mounted on a joint revoluting around the z-axis from left to right and back to it’s centered position to map the surrounding area. This only works for the implemented Gazebo simulation as it publishes commands to the joint the kinect is mounted on.
Reversing Routine State
A Routine State called Reversing Routine is also include and toggles the reverse mode when the routine is executed. This means the robot is driving in reverse when it was going forward before and vice versa.
Additions Service Provider
This data handler class retrieved the frontiers published by explore lite for visualization, extracts each frontier’s center and republishes them as possible exploration goals. In case, the exploration mode is set to Interrupt, it is also checked if the current navigation goal is still in the list of exploration goals. If not, it is published that the goal is obsolete. A tolerance for comparing these positions can be set with a parameter.
Furthermore, goals that could not be reached during exploration, here named as failed goals, are saved and published. These serve as a way of blacklisting goals. This normally happens, when the navigation finishes.
For driving in reverse mode, the velocity commands issued by the reverse navigation stack are also subscribed to and republished with negated linear velocities. It also provides a service that is called when reverse mode should be activated. Since nothing needs to be changed in the configuration to change to reverse mode, this service just replies that it was successful.
If the kinect mapping is interrupted, a service is provided that moves the camera back to it’s centered position while the RSM is continuing.
Examples
An example to move a robot backwards and forwards with the navigation stack.
Reverse robot movement with navigation stack
The following code needs to be included in your launch file (or the nodes launched respectively) to allow the robot to navigate in forward and reverse depending on the set mode:
File truncated at 100 lines see the full file
Changelog for package rsm_additions
1.1.3 (2019-08-29)
- Added all dependencies to CMakeLists and package.xml, that were missing previously
- Contributors: MarcoStb1993
1.1.2 (2019-08-28)
1.1.1 (2019-08-05)
- added changelogs
- Fixed some dependencies for the new names
- Changed package names, this time for real
- Contributors: MarcoStb1993
Wiki Tutorials
Package Dependencies
| Deps | Name |
|---|---|
| roscpp | |
| actionlib | |
| actionlib_msgs | |
| pluginlib | |
| rsm_core | |
| rsm_msgs | |
| move_base_msgs | |
| visualization_msgs | |
| std_msgs | |
| std_srvs | |
| geometry_msgs | |
| sensor_msgs | |
| tf | |
| catkin |
System Dependencies
Dependant Packages
| Name | Deps |
|---|---|
| robot_statemachine |
Launch files
- launch/gazebo.launch
- Gazebo launch files for world and robot
-
- world_file [default: $(find husky_gazebo)/worlds/clearpath_playpen.world]
- robot_namespace [default: /]
- x [default: 0.0]
- y [default: 0.0]
- z [default: 0.0]
- yaw [default: 0.0]
- urdf_extras [default: $(optenv HUSKY_URDF_EXTRAS)]
- config_extras [default: $(eval optenv('HUSKY_CONFIG_EXTRAS', find('husky_control') + '/config/empty.yaml'))]
- launch/simulation_gazebo.launch
- Simulation of Husky UGV in Gazebo running Robot Statemachine with GMapping and Explore Lite
-
- world [default: $(find husky_gazebo)/worlds/clearpath_playpen.world]
- robot_frame [default: base_footprint]
- autonomy_cmd_vel_topic [default: /autonomy/cmd_vel]
- teleoperation_cmd_vel_topic [default: /teleoperation/cmd_vel]
- cmd_vel_topic [default: /cmd_vel]
- joystick_used [default: true]
- joystick_topic [default: /joy]
- calculate_goal_plugin [default: rsm::CalculateGoalState]
- navigation_plugin [default: rsm::NavigationState]
- mapping_plugin [default: rsm::KinectMappingState]
- waypoint_routines [default: ['Reversing']]
- rviz [default: false]
- joystick_used [default: $(arg joystick_used)]
- joystick_topic [default: $(arg joystick_topic)]
- launch/simulation_stdr.launch
- Simulation of Statemachine with GMapping and Frontier Exploration
-
- robot_frame [default: robot0]
- autonomy_cmd_vel_topic [default: /robot0/autonomy/cmd_vel]
- teleoperation_cmd_vel_topic [default: /robot0/teleoperation/cmd_vel]
- cmd_vel_topic [default: /robot0/cmd_vel]
- joystick_used [default: true]
- joystick_topic [default: /joy]
- calculate_goal_plugin [default: rsm::CalculateGoalState]
- navigation_plugin [default: rsm::NavigationState]
- mapping_plugin [default: rsm::MappingDummyState]
- waypoint_routines [default: ['Reversing']]
- rviz [default: false]
- joystick_used [default: $(arg joystick_used)]
- joystick_topic [default: $(arg joystick_topic)]
Messages
Services
Plugins
Recent questions tagged rsm_additions at Robotics Stack Exchange
|
|
rsm_additions package from robot_statemachine reporobot_statemachine rsm_additions rsm_core rsm_msgs rsm_rqt_plugins rsm_rviz_plugins |
ROS Distro
|
Package Summary
| Tags | No category tags. |
| Version | 1.1.3 |
| License | BSD |
| Build type | CATKIN |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/MarcoStb1993/robot_statemachine.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2021-03-15 |
| Dev Status | MAINTAINED |
| CI status | Continuous Integration |
| Released | RELEASED |
| Tags | No category tags. |
| Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Package Description
Additional Links
Maintainers
- Marco Steinbrink
Authors
- Marco Steinbrink
RSM Additions
Additions to the RSM including all mandatory plugin states and a plugin routine state. Also an additional service provider is included.
Documentation
This package implements plugins for the Calculate Goal State, the Navigation State and the Mapping State. Furthermore, the Reversing Routine State is an optional routine state plugin. The Additions Service Provider handles the data to be transferred between these plugins.
Calculate Goal State
The Calculate Goal State interfaces the ROS package explore lite, subscribes to it’s visualization topic that shows frontiers on a 2D map and extracts the closest frontier center point to the robot as navigation goal. Therefore, it retrieves the robot’s pose and calculates it’s distance to each of the frontier’s center points. Also, previously failed goals are disregarded as potential navigation goals. If it fails to find a suitable goal for exploration, it returns an error message and transitions back to the Idle State
To have explore lite running without directly sending
commands to the navigation stack, a mock action server
is constructed in the Additions Service Provider that leads
the exploration to believe the goals are accepted. Otherwise it does not start to to
calculate frontiers. Furthermore, explore lite
is launched with progress_timeout set to 3600 seconds which gives the robot ten hours
to move, otherwise the exploration stops and needs to be relaunched.
Navigation State
The Navigation State realizes an interface to the navigation ROS package. It forwards received goals to the navigation stack and also gets feedback from it regarding the progress. If it fails, the goal is added to the failed goals list. If it succeeds, the failed goal list will be reset.
When standing still for too long, it transitions to the Idle State. Reaching the goal will initiate a transition to the Mapping State or the particular routine state if there is one available. If not, Waypoint Following State is called. After reaching a navigation goal provided by RViz and if waypoint following has ended, it transitions to Idle State.
Reverse driving is realised by running two navigation stacks, one for forward driving and one for reverse driving. This is explained in more detail later. For reverse driving the robot also features a transform to a reverse base frame. When driving in reverse, all output command velocities are negated by the Additions Service Provider. If the reverse mode is activated or deactivated, the goal is cancelled and sent to the reverse navigation.
Mapping State
There are two mapping plugins included. The first state is just a dummy state while the latter is swiveling a simulated kinect camera from left to right around a revoluting joint.
Mapping Dummy State
The Mapping Dummy State is just transitioning back to the Calculate Goal State as specific mapping procedures are only relevant for the particular robot.
Kinect Mapping State
Swivels a kinect camera mounted on a joint revoluting around the z-axis from left to right and back to it’s centered position to map the surrounding area. This only works for the implemented Gazebo simulation as it publishes commands to the joint the kinect is mounted on.
Reversing Routine State
A Routine State called Reversing Routine is also include and toggles the reverse mode when the routine is executed. This means the robot is driving in reverse when it was going forward before and vice versa.
Additions Service Provider
This data handler class retrieved the frontiers published by explore lite for visualization, extracts each frontier’s center and republishes them as possible exploration goals. In case, the exploration mode is set to Interrupt, it is also checked if the current navigation goal is still in the list of exploration goals. If not, it is published that the goal is obsolete. A tolerance for comparing these positions can be set with a parameter.
Furthermore, goals that could not be reached during exploration, here named as failed goals, are saved and published. These serve as a way of blacklisting goals. This normally happens, when the navigation finishes.
For driving in reverse mode, the velocity commands issued by the reverse navigation stack are also subscribed to and republished with negated linear velocities. It also provides a service that is called when reverse mode should be activated. Since nothing needs to be changed in the configuration to change to reverse mode, this service just replies that it was successful.
If the kinect mapping is interrupted, a service is provided that moves the camera back to it’s centered position while the RSM is continuing.
Examples
An example to move a robot backwards and forwards with the navigation stack.
Reverse robot movement with navigation stack
The following code needs to be included in your launch file (or the nodes launched respectively) to allow the robot to navigate in forward and reverse depending on the set mode:
File truncated at 100 lines see the full file
Changelog for package rsm_additions
1.1.3 (2019-08-29)
- Added all dependencies to CMakeLists and package.xml, that were missing previously
- Contributors: MarcoStb1993
1.1.2 (2019-08-28)
1.1.1 (2019-08-05)
- added changelogs
- Fixed some dependencies for the new names
- Changed package names, this time for real
- Contributors: MarcoStb1993
Wiki Tutorials
Package Dependencies
| Deps | Name |
|---|---|
| roscpp | |
| actionlib | |
| actionlib_msgs | |
| pluginlib | |
| rsm_core | |
| rsm_msgs | |
| move_base_msgs | |
| visualization_msgs | |
| std_msgs | |
| std_srvs | |
| geometry_msgs | |
| sensor_msgs | |
| tf | |
| catkin |
System Dependencies
Dependant Packages
| Name | Deps |
|---|---|
| robot_statemachine |
Launch files
- launch/gazebo.launch
- Gazebo launch files for world and robot
-
- world_file [default: $(find husky_gazebo)/worlds/clearpath_playpen.world]
- robot_namespace [default: /]
- x [default: 0.0]
- y [default: 0.0]
- z [default: 0.0]
- yaw [default: 0.0]
- urdf_extras [default: $(optenv HUSKY_URDF_EXTRAS)]
- config_extras [default: $(eval optenv('HUSKY_CONFIG_EXTRAS', find('husky_control') + '/config/empty.yaml'))]
- launch/simulation_gazebo.launch
- Simulation of Husky UGV in Gazebo running Robot Statemachine with GMapping and Explore Lite
-
- world [default: $(find husky_gazebo)/worlds/clearpath_playpen.world]
- robot_frame [default: base_footprint]
- autonomy_cmd_vel_topic [default: /autonomy/cmd_vel]
- teleoperation_cmd_vel_topic [default: /teleoperation/cmd_vel]
- cmd_vel_topic [default: /cmd_vel]
- joystick_used [default: true]
- joystick_topic [default: /joy]
- calculate_goal_plugin [default: rsm::CalculateGoalState]
- navigation_plugin [default: rsm::NavigationState]
- mapping_plugin [default: rsm::KinectMappingState]
- waypoint_routines [default: ['Reversing']]
- rviz [default: false]
- joystick_used [default: $(arg joystick_used)]
- joystick_topic [default: $(arg joystick_topic)]
- launch/simulation_stdr.launch
- Simulation of Statemachine with GMapping and Frontier Exploration
-
- robot_frame [default: robot0]
- autonomy_cmd_vel_topic [default: /robot0/autonomy/cmd_vel]
- teleoperation_cmd_vel_topic [default: /robot0/teleoperation/cmd_vel]
- cmd_vel_topic [default: /robot0/cmd_vel]
- joystick_used [default: true]
- joystick_topic [default: /joy]
- calculate_goal_plugin [default: rsm::CalculateGoalState]
- navigation_plugin [default: rsm::NavigationState]
- mapping_plugin [default: rsm::MappingDummyState]
- waypoint_routines [default: ['Reversing']]
- rviz [default: false]
- joystick_used [default: $(arg joystick_used)]
- joystick_topic [default: $(arg joystick_topic)]
Messages
Services
Plugins
Recent questions tagged rsm_additions at Robotics Stack Exchange
|
|
rsm_additions package from robot_statemachine reporobot_statemachine rsm_additions rsm_core rsm_msgs rsm_rqt_plugins rsm_rviz_plugins |
ROS Distro
|
Package Summary
| Tags | No category tags. |
| Version | 1.1.3 |
| License | BSD |
| Build type | CATKIN |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/MarcoStb1993/robot_statemachine.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2021-03-15 |
| Dev Status | MAINTAINED |
| CI status | Continuous Integration |
| Released | RELEASED |
| Tags | No category tags. |
| Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Package Description
Additional Links
Maintainers
- Marco Steinbrink
Authors
- Marco Steinbrink
RSM Additions
Additions to the RSM including all mandatory plugin states and a plugin routine state. Also an additional service provider is included.
Documentation
This package implements plugins for the Calculate Goal State, the Navigation State and the Mapping State. Furthermore, the Reversing Routine State is an optional routine state plugin. The Additions Service Provider handles the data to be transferred between these plugins.
Calculate Goal State
The Calculate Goal State interfaces the ROS package explore lite, subscribes to it’s visualization topic that shows frontiers on a 2D map and extracts the closest frontier center point to the robot as navigation goal. Therefore, it retrieves the robot’s pose and calculates it’s distance to each of the frontier’s center points. Also, previously failed goals are disregarded as potential navigation goals. If it fails to find a suitable goal for exploration, it returns an error message and transitions back to the Idle State
To have explore lite running without directly sending
commands to the navigation stack, a mock action server
is constructed in the Additions Service Provider that leads
the exploration to believe the goals are accepted. Otherwise it does not start to to
calculate frontiers. Furthermore, explore lite
is launched with progress_timeout set to 3600 seconds which gives the robot ten hours
to move, otherwise the exploration stops and needs to be relaunched.
Navigation State
The Navigation State realizes an interface to the navigation ROS package. It forwards received goals to the navigation stack and also gets feedback from it regarding the progress. If it fails, the goal is added to the failed goals list. If it succeeds, the failed goal list will be reset.
When standing still for too long, it transitions to the Idle State. Reaching the goal will initiate a transition to the Mapping State or the particular routine state if there is one available. If not, Waypoint Following State is called. After reaching a navigation goal provided by RViz and if waypoint following has ended, it transitions to Idle State.
Reverse driving is realised by running two navigation stacks, one for forward driving and one for reverse driving. This is explained in more detail later. For reverse driving the robot also features a transform to a reverse base frame. When driving in reverse, all output command velocities are negated by the Additions Service Provider. If the reverse mode is activated or deactivated, the goal is cancelled and sent to the reverse navigation.
Mapping State
There are two mapping plugins included. The first state is just a dummy state while the latter is swiveling a simulated kinect camera from left to right around a revoluting joint.
Mapping Dummy State
The Mapping Dummy State is just transitioning back to the Calculate Goal State as specific mapping procedures are only relevant for the particular robot.
Kinect Mapping State
Swivels a kinect camera mounted on a joint revoluting around the z-axis from left to right and back to it’s centered position to map the surrounding area. This only works for the implemented Gazebo simulation as it publishes commands to the joint the kinect is mounted on.
Reversing Routine State
A Routine State called Reversing Routine is also include and toggles the reverse mode when the routine is executed. This means the robot is driving in reverse when it was going forward before and vice versa.
Additions Service Provider
This data handler class retrieved the frontiers published by explore lite for visualization, extracts each frontier’s center and republishes them as possible exploration goals. In case, the exploration mode is set to Interrupt, it is also checked if the current navigation goal is still in the list of exploration goals. If not, it is published that the goal is obsolete. A tolerance for comparing these positions can be set with a parameter.
Furthermore, goals that could not be reached during exploration, here named as failed goals, are saved and published. These serve as a way of blacklisting goals. This normally happens, when the navigation finishes.
For driving in reverse mode, the velocity commands issued by the reverse navigation stack are also subscribed to and republished with negated linear velocities. It also provides a service that is called when reverse mode should be activated. Since nothing needs to be changed in the configuration to change to reverse mode, this service just replies that it was successful.
If the kinect mapping is interrupted, a service is provided that moves the camera back to it’s centered position while the RSM is continuing.
Examples
An example to move a robot backwards and forwards with the navigation stack.
Reverse robot movement with navigation stack
The following code needs to be included in your launch file (or the nodes launched respectively) to allow the robot to navigate in forward and reverse depending on the set mode:
File truncated at 100 lines see the full file
Changelog for package rsm_additions
1.1.3 (2019-08-29)
- Added all dependencies to CMakeLists and package.xml, that were missing previously
- Contributors: MarcoStb1993
1.1.2 (2019-08-28)
1.1.1 (2019-08-05)
- added changelogs
- Fixed some dependencies for the new names
- Changed package names, this time for real
- Contributors: MarcoStb1993
Wiki Tutorials
Package Dependencies
| Deps | Name |
|---|---|
| roscpp | |
| actionlib | |
| actionlib_msgs | |
| pluginlib | |
| rsm_core | |
| rsm_msgs | |
| move_base_msgs | |
| visualization_msgs | |
| std_msgs | |
| std_srvs | |
| geometry_msgs | |
| sensor_msgs | |
| tf | |
| catkin |
System Dependencies
Dependant Packages
| Name | Deps |
|---|---|
| robot_statemachine |
Launch files
- launch/gazebo.launch
- Gazebo launch files for world and robot
-
- world_file [default: $(find husky_gazebo)/worlds/clearpath_playpen.world]
- robot_namespace [default: /]
- x [default: 0.0]
- y [default: 0.0]
- z [default: 0.0]
- yaw [default: 0.0]
- urdf_extras [default: $(optenv HUSKY_URDF_EXTRAS)]
- config_extras [default: $(eval optenv('HUSKY_CONFIG_EXTRAS', find('husky_control') + '/config/empty.yaml'))]
- launch/simulation_gazebo.launch
- Simulation of Husky UGV in Gazebo running Robot Statemachine with GMapping and Explore Lite
-
- world [default: $(find husky_gazebo)/worlds/clearpath_playpen.world]
- robot_frame [default: base_footprint]
- autonomy_cmd_vel_topic [default: /autonomy/cmd_vel]
- teleoperation_cmd_vel_topic [default: /teleoperation/cmd_vel]
- cmd_vel_topic [default: /cmd_vel]
- joystick_used [default: true]
- joystick_topic [default: /joy]
- calculate_goal_plugin [default: rsm::CalculateGoalState]
- navigation_plugin [default: rsm::NavigationState]
- mapping_plugin [default: rsm::KinectMappingState]
- waypoint_routines [default: ['Reversing']]
- rviz [default: false]
- joystick_used [default: $(arg joystick_used)]
- joystick_topic [default: $(arg joystick_topic)]
- launch/simulation_stdr.launch
- Simulation of Statemachine with GMapping and Frontier Exploration
-
- robot_frame [default: robot0]
- autonomy_cmd_vel_topic [default: /robot0/autonomy/cmd_vel]
- teleoperation_cmd_vel_topic [default: /robot0/teleoperation/cmd_vel]
- cmd_vel_topic [default: /robot0/cmd_vel]
- joystick_used [default: true]
- joystick_topic [default: /joy]
- calculate_goal_plugin [default: rsm::CalculateGoalState]
- navigation_plugin [default: rsm::NavigationState]
- mapping_plugin [default: rsm::MappingDummyState]
- waypoint_routines [default: ['Reversing']]
- rviz [default: false]
- joystick_used [default: $(arg joystick_used)]
- joystick_topic [default: $(arg joystick_topic)]
Messages
Services
Plugins
Recent questions tagged rsm_additions at Robotics Stack Exchange
|
|
rsm_additions package from robot_statemachine reporobot_statemachine rsm_additions rsm_core rsm_msgs rsm_rqt_plugins rsm_rviz_plugins |
ROS Distro
|
Package Summary
| Tags | No category tags. |
| Version | 1.1.3 |
| License | BSD |
| Build type | CATKIN |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/MarcoStb1993/robot_statemachine.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2021-03-15 |
| Dev Status | MAINTAINED |
| CI status | Continuous Integration |
| Released | RELEASED |
| Tags | No category tags. |
| Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Package Description
Additional Links
Maintainers
- Marco Steinbrink
Authors
- Marco Steinbrink
RSM Additions
Additions to the RSM including all mandatory plugin states and a plugin routine state. Also an additional service provider is included.
Documentation
This package implements plugins for the Calculate Goal State, the Navigation State and the Mapping State. Furthermore, the Reversing Routine State is an optional routine state plugin. The Additions Service Provider handles the data to be transferred between these plugins.
Calculate Goal State
The Calculate Goal State interfaces the ROS package explore lite, subscribes to it’s visualization topic that shows frontiers on a 2D map and extracts the closest frontier center point to the robot as navigation goal. Therefore, it retrieves the robot’s pose and calculates it’s distance to each of the frontier’s center points. Also, previously failed goals are disregarded as potential navigation goals. If it fails to find a suitable goal for exploration, it returns an error message and transitions back to the Idle State
To have explore lite running without directly sending
commands to the navigation stack, a mock action server
is constructed in the Additions Service Provider that leads
the exploration to believe the goals are accepted. Otherwise it does not start to to
calculate frontiers. Furthermore, explore lite
is launched with progress_timeout set to 3600 seconds which gives the robot ten hours
to move, otherwise the exploration stops and needs to be relaunched.
Navigation State
The Navigation State realizes an interface to the navigation ROS package. It forwards received goals to the navigation stack and also gets feedback from it regarding the progress. If it fails, the goal is added to the failed goals list. If it succeeds, the failed goal list will be reset.
When standing still for too long, it transitions to the Idle State. Reaching the goal will initiate a transition to the Mapping State or the particular routine state if there is one available. If not, Waypoint Following State is called. After reaching a navigation goal provided by RViz and if waypoint following has ended, it transitions to Idle State.
Reverse driving is realised by running two navigation stacks, one for forward driving and one for reverse driving. This is explained in more detail later. For reverse driving the robot also features a transform to a reverse base frame. When driving in reverse, all output command velocities are negated by the Additions Service Provider. If the reverse mode is activated or deactivated, the goal is cancelled and sent to the reverse navigation.
Mapping State
There are two mapping plugins included. The first state is just a dummy state while the latter is swiveling a simulated kinect camera from left to right around a revoluting joint.
Mapping Dummy State
The Mapping Dummy State is just transitioning back to the Calculate Goal State as specific mapping procedures are only relevant for the particular robot.
Kinect Mapping State
Swivels a kinect camera mounted on a joint revoluting around the z-axis from left to right and back to it’s centered position to map the surrounding area. This only works for the implemented Gazebo simulation as it publishes commands to the joint the kinect is mounted on.
Reversing Routine State
A Routine State called Reversing Routine is also include and toggles the reverse mode when the routine is executed. This means the robot is driving in reverse when it was going forward before and vice versa.
Additions Service Provider
This data handler class retrieved the frontiers published by explore lite for visualization, extracts each frontier’s center and republishes them as possible exploration goals. In case, the exploration mode is set to Interrupt, it is also checked if the current navigation goal is still in the list of exploration goals. If not, it is published that the goal is obsolete. A tolerance for comparing these positions can be set with a parameter.
Furthermore, goals that could not be reached during exploration, here named as failed goals, are saved and published. These serve as a way of blacklisting goals. This normally happens, when the navigation finishes.
For driving in reverse mode, the velocity commands issued by the reverse navigation stack are also subscribed to and republished with negated linear velocities. It also provides a service that is called when reverse mode should be activated. Since nothing needs to be changed in the configuration to change to reverse mode, this service just replies that it was successful.
If the kinect mapping is interrupted, a service is provided that moves the camera back to it’s centered position while the RSM is continuing.
Examples
An example to move a robot backwards and forwards with the navigation stack.
Reverse robot movement with navigation stack
The following code needs to be included in your launch file (or the nodes launched respectively) to allow the robot to navigate in forward and reverse depending on the set mode:
File truncated at 100 lines see the full file
Changelog for package rsm_additions
1.1.3 (2019-08-29)
- Added all dependencies to CMakeLists and package.xml, that were missing previously
- Contributors: MarcoStb1993
1.1.2 (2019-08-28)
1.1.1 (2019-08-05)
- added changelogs
- Fixed some dependencies for the new names
- Changed package names, this time for real
- Contributors: MarcoStb1993
Wiki Tutorials
Package Dependencies
| Deps | Name |
|---|---|
| roscpp | |
| actionlib | |
| actionlib_msgs | |
| pluginlib | |
| rsm_core | |
| rsm_msgs | |
| move_base_msgs | |
| visualization_msgs | |
| std_msgs | |
| std_srvs | |
| geometry_msgs | |
| sensor_msgs | |
| tf | |
| catkin |
System Dependencies
Dependant Packages
| Name | Deps |
|---|---|
| robot_statemachine |
Launch files
- launch/gazebo.launch
- Gazebo launch files for world and robot
-
- world_file [default: $(find husky_gazebo)/worlds/clearpath_playpen.world]
- robot_namespace [default: /]
- x [default: 0.0]
- y [default: 0.0]
- z [default: 0.0]
- yaw [default: 0.0]
- urdf_extras [default: $(optenv HUSKY_URDF_EXTRAS)]
- config_extras [default: $(eval optenv('HUSKY_CONFIG_EXTRAS', find('husky_control') + '/config/empty.yaml'))]
- launch/simulation_gazebo.launch
- Simulation of Husky UGV in Gazebo running Robot Statemachine with GMapping and Explore Lite
-
- world [default: $(find husky_gazebo)/worlds/clearpath_playpen.world]
- robot_frame [default: base_footprint]
- autonomy_cmd_vel_topic [default: /autonomy/cmd_vel]
- teleoperation_cmd_vel_topic [default: /teleoperation/cmd_vel]
- cmd_vel_topic [default: /cmd_vel]
- joystick_used [default: true]
- joystick_topic [default: /joy]
- calculate_goal_plugin [default: rsm::CalculateGoalState]
- navigation_plugin [default: rsm::NavigationState]
- mapping_plugin [default: rsm::KinectMappingState]
- waypoint_routines [default: ['Reversing']]
- rviz [default: false]
- joystick_used [default: $(arg joystick_used)]
- joystick_topic [default: $(arg joystick_topic)]
- launch/simulation_stdr.launch
- Simulation of Statemachine with GMapping and Frontier Exploration
-
- robot_frame [default: robot0]
- autonomy_cmd_vel_topic [default: /robot0/autonomy/cmd_vel]
- teleoperation_cmd_vel_topic [default: /robot0/teleoperation/cmd_vel]
- cmd_vel_topic [default: /robot0/cmd_vel]
- joystick_used [default: true]
- joystick_topic [default: /joy]
- calculate_goal_plugin [default: rsm::CalculateGoalState]
- navigation_plugin [default: rsm::NavigationState]
- mapping_plugin [default: rsm::MappingDummyState]
- waypoint_routines [default: ['Reversing']]
- rviz [default: false]
- joystick_used [default: $(arg joystick_used)]
- joystick_topic [default: $(arg joystick_topic)]
Messages
Services
Plugins
Recent questions tagged rsm_additions at Robotics Stack Exchange
|
|
rsm_additions package from robot_statemachine reporobot_statemachine rsm_additions rsm_core rsm_msgs rsm_rqt_plugins rsm_rviz_plugins |
ROS Distro
|
Package Summary
| Tags | No category tags. |
| Version | 1.1.3 |
| License | BSD |
| Build type | CATKIN |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/MarcoStb1993/robot_statemachine.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2021-03-15 |
| Dev Status | MAINTAINED |
| CI status | Continuous Integration |
| Released | RELEASED |
| Tags | No category tags. |
| Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Package Description
Additional Links
Maintainers
- Marco Steinbrink
Authors
- Marco Steinbrink
RSM Additions
Additions to the RSM including all mandatory plugin states and a plugin routine state. Also an additional service provider is included.
Documentation
This package implements plugins for the Calculate Goal State, the Navigation State and the Mapping State. Furthermore, the Reversing Routine State is an optional routine state plugin. The Additions Service Provider handles the data to be transferred between these plugins.
Calculate Goal State
The Calculate Goal State interfaces the ROS package explore lite, subscribes to it’s visualization topic that shows frontiers on a 2D map and extracts the closest frontier center point to the robot as navigation goal. Therefore, it retrieves the robot’s pose and calculates it’s distance to each of the frontier’s center points. Also, previously failed goals are disregarded as potential navigation goals. If it fails to find a suitable goal for exploration, it returns an error message and transitions back to the Idle State
To have explore lite running without directly sending
commands to the navigation stack, a mock action server
is constructed in the Additions Service Provider that leads
the exploration to believe the goals are accepted. Otherwise it does not start to to
calculate frontiers. Furthermore, explore lite
is launched with progress_timeout set to 3600 seconds which gives the robot ten hours
to move, otherwise the exploration stops and needs to be relaunched.
Navigation State
The Navigation State realizes an interface to the navigation ROS package. It forwards received goals to the navigation stack and also gets feedback from it regarding the progress. If it fails, the goal is added to the failed goals list. If it succeeds, the failed goal list will be reset.
When standing still for too long, it transitions to the Idle State. Reaching the goal will initiate a transition to the Mapping State or the particular routine state if there is one available. If not, Waypoint Following State is called. After reaching a navigation goal provided by RViz and if waypoint following has ended, it transitions to Idle State.
Reverse driving is realised by running two navigation stacks, one for forward driving and one for reverse driving. This is explained in more detail later. For reverse driving the robot also features a transform to a reverse base frame. When driving in reverse, all output command velocities are negated by the Additions Service Provider. If the reverse mode is activated or deactivated, the goal is cancelled and sent to the reverse navigation.
Mapping State
There are two mapping plugins included. The first state is just a dummy state while the latter is swiveling a simulated kinect camera from left to right around a revoluting joint.
Mapping Dummy State
The Mapping Dummy State is just transitioning back to the Calculate Goal State as specific mapping procedures are only relevant for the particular robot.
Kinect Mapping State
Swivels a kinect camera mounted on a joint revoluting around the z-axis from left to right and back to it’s centered position to map the surrounding area. This only works for the implemented Gazebo simulation as it publishes commands to the joint the kinect is mounted on.
Reversing Routine State
A Routine State called Reversing Routine is also include and toggles the reverse mode when the routine is executed. This means the robot is driving in reverse when it was going forward before and vice versa.
Additions Service Provider
This data handler class retrieved the frontiers published by explore lite for visualization, extracts each frontier’s center and republishes them as possible exploration goals. In case, the exploration mode is set to Interrupt, it is also checked if the current navigation goal is still in the list of exploration goals. If not, it is published that the goal is obsolete. A tolerance for comparing these positions can be set with a parameter.
Furthermore, goals that could not be reached during exploration, here named as failed goals, are saved and published. These serve as a way of blacklisting goals. This normally happens, when the navigation finishes.
For driving in reverse mode, the velocity commands issued by the reverse navigation stack are also subscribed to and republished with negated linear velocities. It also provides a service that is called when reverse mode should be activated. Since nothing needs to be changed in the configuration to change to reverse mode, this service just replies that it was successful.
If the kinect mapping is interrupted, a service is provided that moves the camera back to it’s centered position while the RSM is continuing.
Examples
An example to move a robot backwards and forwards with the navigation stack.
Reverse robot movement with navigation stack
The following code needs to be included in your launch file (or the nodes launched respectively) to allow the robot to navigate in forward and reverse depending on the set mode:
File truncated at 100 lines see the full file
Changelog for package rsm_additions
1.1.3 (2019-08-29)
- Added all dependencies to CMakeLists and package.xml, that were missing previously
- Contributors: MarcoStb1993
1.1.2 (2019-08-28)
1.1.1 (2019-08-05)
- added changelogs
- Fixed some dependencies for the new names
- Changed package names, this time for real
- Contributors: MarcoStb1993
Wiki Tutorials
Package Dependencies
| Deps | Name |
|---|---|
| roscpp | |
| actionlib | |
| actionlib_msgs | |
| pluginlib | |
| rsm_core | |
| rsm_msgs | |
| move_base_msgs | |
| visualization_msgs | |
| std_msgs | |
| std_srvs | |
| geometry_msgs | |
| sensor_msgs | |
| tf | |
| catkin |
System Dependencies
Dependant Packages
| Name | Deps |
|---|---|
| robot_statemachine |
Launch files
- launch/gazebo.launch
- Gazebo launch files for world and robot
-
- world_file [default: $(find husky_gazebo)/worlds/clearpath_playpen.world]
- robot_namespace [default: /]
- x [default: 0.0]
- y [default: 0.0]
- z [default: 0.0]
- yaw [default: 0.0]
- urdf_extras [default: $(optenv HUSKY_URDF_EXTRAS)]
- config_extras [default: $(eval optenv('HUSKY_CONFIG_EXTRAS', find('husky_control') + '/config/empty.yaml'))]
- launch/simulation_gazebo.launch
- Simulation of Husky UGV in Gazebo running Robot Statemachine with GMapping and Explore Lite
-
- world [default: $(find husky_gazebo)/worlds/clearpath_playpen.world]
- robot_frame [default: base_footprint]
- autonomy_cmd_vel_topic [default: /autonomy/cmd_vel]
- teleoperation_cmd_vel_topic [default: /teleoperation/cmd_vel]
- cmd_vel_topic [default: /cmd_vel]
- joystick_used [default: true]
- joystick_topic [default: /joy]
- calculate_goal_plugin [default: rsm::CalculateGoalState]
- navigation_plugin [default: rsm::NavigationState]
- mapping_plugin [default: rsm::KinectMappingState]
- waypoint_routines [default: ['Reversing']]
- rviz [default: false]
- joystick_used [default: $(arg joystick_used)]
- joystick_topic [default: $(arg joystick_topic)]
- launch/simulation_stdr.launch
- Simulation of Statemachine with GMapping and Frontier Exploration
-
- robot_frame [default: robot0]
- autonomy_cmd_vel_topic [default: /robot0/autonomy/cmd_vel]
- teleoperation_cmd_vel_topic [default: /robot0/teleoperation/cmd_vel]
- cmd_vel_topic [default: /robot0/cmd_vel]
- joystick_used [default: true]
- joystick_topic [default: /joy]
- calculate_goal_plugin [default: rsm::CalculateGoalState]
- navigation_plugin [default: rsm::NavigationState]
- mapping_plugin [default: rsm::MappingDummyState]
- waypoint_routines [default: ['Reversing']]
- rviz [default: false]
- joystick_used [default: $(arg joystick_used)]
- joystick_topic [default: $(arg joystick_topic)]
Messages
Services
Plugins
Recent questions tagged rsm_additions at Robotics Stack Exchange
|
|
rsm_additions package from robot_statemachine reporobot_statemachine rsm_additions rsm_core rsm_msgs rsm_rqt_plugins rsm_rviz_plugins |
ROS Distro
|
Package Summary
| Tags | No category tags. |
| Version | 1.1.3 |
| License | BSD |
| Build type | CATKIN |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/MarcoStb1993/robot_statemachine.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2021-03-15 |
| Dev Status | MAINTAINED |
| CI status | Continuous Integration |
| Released | RELEASED |
| Tags | No category tags. |
| Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Package Description
Additional Links
Maintainers
- Marco Steinbrink
Authors
- Marco Steinbrink
RSM Additions
Additions to the RSM including all mandatory plugin states and a plugin routine state. Also an additional service provider is included.
Documentation
This package implements plugins for the Calculate Goal State, the Navigation State and the Mapping State. Furthermore, the Reversing Routine State is an optional routine state plugin. The Additions Service Provider handles the data to be transferred between these plugins.
Calculate Goal State
The Calculate Goal State interfaces the ROS package explore lite, subscribes to it’s visualization topic that shows frontiers on a 2D map and extracts the closest frontier center point to the robot as navigation goal. Therefore, it retrieves the robot’s pose and calculates it’s distance to each of the frontier’s center points. Also, previously failed goals are disregarded as potential navigation goals. If it fails to find a suitable goal for exploration, it returns an error message and transitions back to the Idle State
To have explore lite running without directly sending
commands to the navigation stack, a mock action server
is constructed in the Additions Service Provider that leads
the exploration to believe the goals are accepted. Otherwise it does not start to to
calculate frontiers. Furthermore, explore lite
is launched with progress_timeout set to 3600 seconds which gives the robot ten hours
to move, otherwise the exploration stops and needs to be relaunched.
Navigation State
The Navigation State realizes an interface to the navigation ROS package. It forwards received goals to the navigation stack and also gets feedback from it regarding the progress. If it fails, the goal is added to the failed goals list. If it succeeds, the failed goal list will be reset.
When standing still for too long, it transitions to the Idle State. Reaching the goal will initiate a transition to the Mapping State or the particular routine state if there is one available. If not, Waypoint Following State is called. After reaching a navigation goal provided by RViz and if waypoint following has ended, it transitions to Idle State.
Reverse driving is realised by running two navigation stacks, one for forward driving and one for reverse driving. This is explained in more detail later. For reverse driving the robot also features a transform to a reverse base frame. When driving in reverse, all output command velocities are negated by the Additions Service Provider. If the reverse mode is activated or deactivated, the goal is cancelled and sent to the reverse navigation.
Mapping State
There are two mapping plugins included. The first state is just a dummy state while the latter is swiveling a simulated kinect camera from left to right around a revoluting joint.
Mapping Dummy State
The Mapping Dummy State is just transitioning back to the Calculate Goal State as specific mapping procedures are only relevant for the particular robot.
Kinect Mapping State
Swivels a kinect camera mounted on a joint revoluting around the z-axis from left to right and back to it’s centered position to map the surrounding area. This only works for the implemented Gazebo simulation as it publishes commands to the joint the kinect is mounted on.
Reversing Routine State
A Routine State called Reversing Routine is also include and toggles the reverse mode when the routine is executed. This means the robot is driving in reverse when it was going forward before and vice versa.
Additions Service Provider
This data handler class retrieved the frontiers published by explore lite for visualization, extracts each frontier’s center and republishes them as possible exploration goals. In case, the exploration mode is set to Interrupt, it is also checked if the current navigation goal is still in the list of exploration goals. If not, it is published that the goal is obsolete. A tolerance for comparing these positions can be set with a parameter.
Furthermore, goals that could not be reached during exploration, here named as failed goals, are saved and published. These serve as a way of blacklisting goals. This normally happens, when the navigation finishes.
For driving in reverse mode, the velocity commands issued by the reverse navigation stack are also subscribed to and republished with negated linear velocities. It also provides a service that is called when reverse mode should be activated. Since nothing needs to be changed in the configuration to change to reverse mode, this service just replies that it was successful.
If the kinect mapping is interrupted, a service is provided that moves the camera back to it’s centered position while the RSM is continuing.
Examples
An example to move a robot backwards and forwards with the navigation stack.
Reverse robot movement with navigation stack
The following code needs to be included in your launch file (or the nodes launched respectively) to allow the robot to navigate in forward and reverse depending on the set mode:
File truncated at 100 lines see the full file
Changelog for package rsm_additions
1.1.3 (2019-08-29)
- Added all dependencies to CMakeLists and package.xml, that were missing previously
- Contributors: MarcoStb1993
1.1.2 (2019-08-28)
1.1.1 (2019-08-05)
- added changelogs
- Fixed some dependencies for the new names
- Changed package names, this time for real
- Contributors: MarcoStb1993
Wiki Tutorials
Package Dependencies
| Deps | Name |
|---|---|
| roscpp | |
| actionlib | |
| actionlib_msgs | |
| pluginlib | |
| rsm_core | |
| rsm_msgs | |
| move_base_msgs | |
| visualization_msgs | |
| std_msgs | |
| std_srvs | |
| geometry_msgs | |
| sensor_msgs | |
| tf | |
| catkin |
System Dependencies
Dependant Packages
| Name | Deps |
|---|---|
| robot_statemachine |
Launch files
- launch/gazebo.launch
- Gazebo launch files for world and robot
-
- world_file [default: $(find husky_gazebo)/worlds/clearpath_playpen.world]
- robot_namespace [default: /]
- x [default: 0.0]
- y [default: 0.0]
- z [default: 0.0]
- yaw [default: 0.0]
- urdf_extras [default: $(optenv HUSKY_URDF_EXTRAS)]
- config_extras [default: $(eval optenv('HUSKY_CONFIG_EXTRAS', find('husky_control') + '/config/empty.yaml'))]
- launch/simulation_gazebo.launch
- Simulation of Husky UGV in Gazebo running Robot Statemachine with GMapping and Explore Lite
-
- world [default: $(find husky_gazebo)/worlds/clearpath_playpen.world]
- robot_frame [default: base_footprint]
- autonomy_cmd_vel_topic [default: /autonomy/cmd_vel]
- teleoperation_cmd_vel_topic [default: /teleoperation/cmd_vel]
- cmd_vel_topic [default: /cmd_vel]
- joystick_used [default: true]
- joystick_topic [default: /joy]
- calculate_goal_plugin [default: rsm::CalculateGoalState]
- navigation_plugin [default: rsm::NavigationState]
- mapping_plugin [default: rsm::KinectMappingState]
- waypoint_routines [default: ['Reversing']]
- rviz [default: false]
- joystick_used [default: $(arg joystick_used)]
- joystick_topic [default: $(arg joystick_topic)]
- launch/simulation_stdr.launch
- Simulation of Statemachine with GMapping and Frontier Exploration
-
- robot_frame [default: robot0]
- autonomy_cmd_vel_topic [default: /robot0/autonomy/cmd_vel]
- teleoperation_cmd_vel_topic [default: /robot0/teleoperation/cmd_vel]
- cmd_vel_topic [default: /robot0/cmd_vel]
- joystick_used [default: true]
- joystick_topic [default: /joy]
- calculate_goal_plugin [default: rsm::CalculateGoalState]
- navigation_plugin [default: rsm::NavigationState]
- mapping_plugin [default: rsm::MappingDummyState]
- waypoint_routines [default: ['Reversing']]
- rviz [default: false]
- joystick_used [default: $(arg joystick_used)]
- joystick_topic [default: $(arg joystick_topic)]
Messages
Services
Plugins
Recent questions tagged rsm_additions at Robotics Stack Exchange
|
|
rsm_additions package from robot_statemachine reporobot_statemachine rsm_additions rsm_core rsm_msgs rsm_rqt_plugins rsm_rviz_plugins |
ROS Distro
|
Package Summary
| Tags | No category tags. |
| Version | 1.1.3 |
| License | BSD |
| Build type | CATKIN |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/MarcoStb1993/robot_statemachine.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2021-03-15 |
| Dev Status | MAINTAINED |
| CI status | Continuous Integration |
| Released | RELEASED |
| Tags | No category tags. |
| Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Package Description
Additional Links
Maintainers
- Marco Steinbrink
Authors
- Marco Steinbrink
RSM Additions
Additions to the RSM including all mandatory plugin states and a plugin routine state. Also an additional service provider is included.
Documentation
This package implements plugins for the Calculate Goal State, the Navigation State and the Mapping State. Furthermore, the Reversing Routine State is an optional routine state plugin. The Additions Service Provider handles the data to be transferred between these plugins.
Calculate Goal State
The Calculate Goal State interfaces the ROS package explore lite, subscribes to it’s visualization topic that shows frontiers on a 2D map and extracts the closest frontier center point to the robot as navigation goal. Therefore, it retrieves the robot’s pose and calculates it’s distance to each of the frontier’s center points. Also, previously failed goals are disregarded as potential navigation goals. If it fails to find a suitable goal for exploration, it returns an error message and transitions back to the Idle State
To have explore lite running without directly sending
commands to the navigation stack, a mock action server
is constructed in the Additions Service Provider that leads
the exploration to believe the goals are accepted. Otherwise it does not start to to
calculate frontiers. Furthermore, explore lite
is launched with progress_timeout set to 3600 seconds which gives the robot ten hours
to move, otherwise the exploration stops and needs to be relaunched.
Navigation State
The Navigation State realizes an interface to the navigation ROS package. It forwards received goals to the navigation stack and also gets feedback from it regarding the progress. If it fails, the goal is added to the failed goals list. If it succeeds, the failed goal list will be reset.
When standing still for too long, it transitions to the Idle State. Reaching the goal will initiate a transition to the Mapping State or the particular routine state if there is one available. If not, Waypoint Following State is called. After reaching a navigation goal provided by RViz and if waypoint following has ended, it transitions to Idle State.
Reverse driving is realised by running two navigation stacks, one for forward driving and one for reverse driving. This is explained in more detail later. For reverse driving the robot also features a transform to a reverse base frame. When driving in reverse, all output command velocities are negated by the Additions Service Provider. If the reverse mode is activated or deactivated, the goal is cancelled and sent to the reverse navigation.
Mapping State
There are two mapping plugins included. The first state is just a dummy state while the latter is swiveling a simulated kinect camera from left to right around a revoluting joint.
Mapping Dummy State
The Mapping Dummy State is just transitioning back to the Calculate Goal State as specific mapping procedures are only relevant for the particular robot.
Kinect Mapping State
Swivels a kinect camera mounted on a joint revoluting around the z-axis from left to right and back to it’s centered position to map the surrounding area. This only works for the implemented Gazebo simulation as it publishes commands to the joint the kinect is mounted on.
Reversing Routine State
A Routine State called Reversing Routine is also include and toggles the reverse mode when the routine is executed. This means the robot is driving in reverse when it was going forward before and vice versa.
Additions Service Provider
This data handler class retrieved the frontiers published by explore lite for visualization, extracts each frontier’s center and republishes them as possible exploration goals. In case, the exploration mode is set to Interrupt, it is also checked if the current navigation goal is still in the list of exploration goals. If not, it is published that the goal is obsolete. A tolerance for comparing these positions can be set with a parameter.
Furthermore, goals that could not be reached during exploration, here named as failed goals, are saved and published. These serve as a way of blacklisting goals. This normally happens, when the navigation finishes.
For driving in reverse mode, the velocity commands issued by the reverse navigation stack are also subscribed to and republished with negated linear velocities. It also provides a service that is called when reverse mode should be activated. Since nothing needs to be changed in the configuration to change to reverse mode, this service just replies that it was successful.
If the kinect mapping is interrupted, a service is provided that moves the camera back to it’s centered position while the RSM is continuing.
Examples
An example to move a robot backwards and forwards with the navigation stack.
Reverse robot movement with navigation stack
The following code needs to be included in your launch file (or the nodes launched respectively) to allow the robot to navigate in forward and reverse depending on the set mode:
File truncated at 100 lines see the full file
Changelog for package rsm_additions
1.1.3 (2019-08-29)
- Added all dependencies to CMakeLists and package.xml, that were missing previously
- Contributors: MarcoStb1993
1.1.2 (2019-08-28)
1.1.1 (2019-08-05)
- added changelogs
- Fixed some dependencies for the new names
- Changed package names, this time for real
- Contributors: MarcoStb1993
Wiki Tutorials
Package Dependencies
| Deps | Name |
|---|---|
| roscpp | |
| actionlib | |
| actionlib_msgs | |
| pluginlib | |
| rsm_core | |
| rsm_msgs | |
| move_base_msgs | |
| visualization_msgs | |
| std_msgs | |
| std_srvs | |
| geometry_msgs | |
| sensor_msgs | |
| tf | |
| catkin |
System Dependencies
Dependant Packages
| Name | Deps |
|---|---|
| robot_statemachine |
Launch files
- launch/gazebo.launch
- Gazebo launch files for world and robot
-
- world_file [default: $(find husky_gazebo)/worlds/clearpath_playpen.world]
- robot_namespace [default: /]
- x [default: 0.0]
- y [default: 0.0]
- z [default: 0.0]
- yaw [default: 0.0]
- urdf_extras [default: $(optenv HUSKY_URDF_EXTRAS)]
- config_extras [default: $(eval optenv('HUSKY_CONFIG_EXTRAS', find('husky_control') + '/config/empty.yaml'))]
- launch/simulation_gazebo.launch
- Simulation of Husky UGV in Gazebo running Robot Statemachine with GMapping and Explore Lite
-
- world [default: $(find husky_gazebo)/worlds/clearpath_playpen.world]
- robot_frame [default: base_footprint]
- autonomy_cmd_vel_topic [default: /autonomy/cmd_vel]
- teleoperation_cmd_vel_topic [default: /teleoperation/cmd_vel]
- cmd_vel_topic [default: /cmd_vel]
- joystick_used [default: true]
- joystick_topic [default: /joy]
- calculate_goal_plugin [default: rsm::CalculateGoalState]
- navigation_plugin [default: rsm::NavigationState]
- mapping_plugin [default: rsm::KinectMappingState]
- waypoint_routines [default: ['Reversing']]
- rviz [default: false]
- joystick_used [default: $(arg joystick_used)]
- joystick_topic [default: $(arg joystick_topic)]
- launch/simulation_stdr.launch
- Simulation of Statemachine with GMapping and Frontier Exploration
-
- robot_frame [default: robot0]
- autonomy_cmd_vel_topic [default: /robot0/autonomy/cmd_vel]
- teleoperation_cmd_vel_topic [default: /robot0/teleoperation/cmd_vel]
- cmd_vel_topic [default: /robot0/cmd_vel]
- joystick_used [default: true]
- joystick_topic [default: /joy]
- calculate_goal_plugin [default: rsm::CalculateGoalState]
- navigation_plugin [default: rsm::NavigationState]
- mapping_plugin [default: rsm::MappingDummyState]
- waypoint_routines [default: ['Reversing']]
- rviz [default: false]
- joystick_used [default: $(arg joystick_used)]
- joystick_topic [default: $(arg joystick_topic)]
Messages
Services
Plugins
Recent questions tagged rsm_additions at Robotics Stack Exchange
|
|
rsm_additions package from robot_statemachine reporobot_statemachine rsm_additions rsm_core rsm_msgs rsm_rqt_plugins rsm_rviz_plugins |
ROS Distro
|
Package Summary
| Tags | No category tags. |
| Version | 1.1.3 |
| License | BSD |
| Build type | CATKIN |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/MarcoStb1993/robot_statemachine.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2021-03-15 |
| Dev Status | MAINTAINED |
| CI status | Continuous Integration |
| Released | RELEASED |
| Tags | No category tags. |
| Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Package Description
Additional Links
Maintainers
- Marco Steinbrink
Authors
- Marco Steinbrink
RSM Additions
Additions to the RSM including all mandatory plugin states and a plugin routine state. Also an additional service provider is included.
Documentation
This package implements plugins for the Calculate Goal State, the Navigation State and the Mapping State. Furthermore, the Reversing Routine State is an optional routine state plugin. The Additions Service Provider handles the data to be transferred between these plugins.
Calculate Goal State
The Calculate Goal State interfaces the ROS package explore lite, subscribes to it’s visualization topic that shows frontiers on a 2D map and extracts the closest frontier center point to the robot as navigation goal. Therefore, it retrieves the robot’s pose and calculates it’s distance to each of the frontier’s center points. Also, previously failed goals are disregarded as potential navigation goals. If it fails to find a suitable goal for exploration, it returns an error message and transitions back to the Idle State
To have explore lite running without directly sending
commands to the navigation stack, a mock action server
is constructed in the Additions Service Provider that leads
the exploration to believe the goals are accepted. Otherwise it does not start to to
calculate frontiers. Furthermore, explore lite
is launched with progress_timeout set to 3600 seconds which gives the robot ten hours
to move, otherwise the exploration stops and needs to be relaunched.
Navigation State
The Navigation State realizes an interface to the navigation ROS package. It forwards received goals to the navigation stack and also gets feedback from it regarding the progress. If it fails, the goal is added to the failed goals list. If it succeeds, the failed goal list will be reset.
When standing still for too long, it transitions to the Idle State. Reaching the goal will initiate a transition to the Mapping State or the particular routine state if there is one available. If not, Waypoint Following State is called. After reaching a navigation goal provided by RViz and if waypoint following has ended, it transitions to Idle State.
Reverse driving is realised by running two navigation stacks, one for forward driving and one for reverse driving. This is explained in more detail later. For reverse driving the robot also features a transform to a reverse base frame. When driving in reverse, all output command velocities are negated by the Additions Service Provider. If the reverse mode is activated or deactivated, the goal is cancelled and sent to the reverse navigation.
Mapping State
There are two mapping plugins included. The first state is just a dummy state while the latter is swiveling a simulated kinect camera from left to right around a revoluting joint.
Mapping Dummy State
The Mapping Dummy State is just transitioning back to the Calculate Goal State as specific mapping procedures are only relevant for the particular robot.
Kinect Mapping State
Swivels a kinect camera mounted on a joint revoluting around the z-axis from left to right and back to it’s centered position to map the surrounding area. This only works for the implemented Gazebo simulation as it publishes commands to the joint the kinect is mounted on.
Reversing Routine State
A Routine State called Reversing Routine is also include and toggles the reverse mode when the routine is executed. This means the robot is driving in reverse when it was going forward before and vice versa.
Additions Service Provider
This data handler class retrieved the frontiers published by explore lite for visualization, extracts each frontier’s center and republishes them as possible exploration goals. In case, the exploration mode is set to Interrupt, it is also checked if the current navigation goal is still in the list of exploration goals. If not, it is published that the goal is obsolete. A tolerance for comparing these positions can be set with a parameter.
Furthermore, goals that could not be reached during exploration, here named as failed goals, are saved and published. These serve as a way of blacklisting goals. This normally happens, when the navigation finishes.
For driving in reverse mode, the velocity commands issued by the reverse navigation stack are also subscribed to and republished with negated linear velocities. It also provides a service that is called when reverse mode should be activated. Since nothing needs to be changed in the configuration to change to reverse mode, this service just replies that it was successful.
If the kinect mapping is interrupted, a service is provided that moves the camera back to it’s centered position while the RSM is continuing.
Examples
An example to move a robot backwards and forwards with the navigation stack.
Reverse robot movement with navigation stack
The following code needs to be included in your launch file (or the nodes launched respectively) to allow the robot to navigate in forward and reverse depending on the set mode:
File truncated at 100 lines see the full file
Changelog for package rsm_additions
1.1.3 (2019-08-29)
- Added all dependencies to CMakeLists and package.xml, that were missing previously
- Contributors: MarcoStb1993
1.1.2 (2019-08-28)
1.1.1 (2019-08-05)
- added changelogs
- Fixed some dependencies for the new names
- Changed package names, this time for real
- Contributors: MarcoStb1993
Wiki Tutorials
Package Dependencies
| Deps | Name |
|---|---|
| roscpp | |
| actionlib | |
| actionlib_msgs | |
| pluginlib | |
| rsm_core | |
| rsm_msgs | |
| move_base_msgs | |
| visualization_msgs | |
| std_msgs | |
| std_srvs | |
| geometry_msgs | |
| sensor_msgs | |
| tf | |
| catkin |
System Dependencies
Dependant Packages
| Name | Deps |
|---|---|
| robot_statemachine |
Launch files
- launch/gazebo.launch
- Gazebo launch files for world and robot
-
- world_file [default: $(find husky_gazebo)/worlds/clearpath_playpen.world]
- robot_namespace [default: /]
- x [default: 0.0]
- y [default: 0.0]
- z [default: 0.0]
- yaw [default: 0.0]
- urdf_extras [default: $(optenv HUSKY_URDF_EXTRAS)]
- config_extras [default: $(eval optenv('HUSKY_CONFIG_EXTRAS', find('husky_control') + '/config/empty.yaml'))]
- launch/simulation_gazebo.launch
- Simulation of Husky UGV in Gazebo running Robot Statemachine with GMapping and Explore Lite
-
- world [default: $(find husky_gazebo)/worlds/clearpath_playpen.world]
- robot_frame [default: base_footprint]
- autonomy_cmd_vel_topic [default: /autonomy/cmd_vel]
- teleoperation_cmd_vel_topic [default: /teleoperation/cmd_vel]
- cmd_vel_topic [default: /cmd_vel]
- joystick_used [default: true]
- joystick_topic [default: /joy]
- calculate_goal_plugin [default: rsm::CalculateGoalState]
- navigation_plugin [default: rsm::NavigationState]
- mapping_plugin [default: rsm::KinectMappingState]
- waypoint_routines [default: ['Reversing']]
- rviz [default: false]
- joystick_used [default: $(arg joystick_used)]
- joystick_topic [default: $(arg joystick_topic)]
- launch/simulation_stdr.launch
- Simulation of Statemachine with GMapping and Frontier Exploration
-
- robot_frame [default: robot0]
- autonomy_cmd_vel_topic [default: /robot0/autonomy/cmd_vel]
- teleoperation_cmd_vel_topic [default: /robot0/teleoperation/cmd_vel]
- cmd_vel_topic [default: /robot0/cmd_vel]
- joystick_used [default: true]
- joystick_topic [default: /joy]
- calculate_goal_plugin [default: rsm::CalculateGoalState]
- navigation_plugin [default: rsm::NavigationState]
- mapping_plugin [default: rsm::MappingDummyState]
- waypoint_routines [default: ['Reversing']]
- rviz [default: false]
- joystick_used [default: $(arg joystick_used)]
- joystick_topic [default: $(arg joystick_topic)]
Messages
Services
Plugins
Recent questions tagged rsm_additions at Robotics Stack Exchange
|
|
rsm_additions package from robot_statemachine reporobot_statemachine rsm_additions rsm_core rsm_msgs rsm_rqt_plugins rsm_rviz_plugins |
ROS Distro
|
Package Summary
| Tags | No category tags. |
| Version | 1.1.3 |
| License | BSD |
| Build type | CATKIN |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/MarcoStb1993/robot_statemachine.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2021-03-15 |
| Dev Status | MAINTAINED |
| CI status | Continuous Integration |
| Released | RELEASED |
| Tags | No category tags. |
| Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Package Description
Additional Links
Maintainers
- Marco Steinbrink
Authors
- Marco Steinbrink
RSM Additions
Additions to the RSM including all mandatory plugin states and a plugin routine state. Also an additional service provider is included.
Documentation
This package implements plugins for the Calculate Goal State, the Navigation State and the Mapping State. Furthermore, the Reversing Routine State is an optional routine state plugin. The Additions Service Provider handles the data to be transferred between these plugins.
Calculate Goal State
The Calculate Goal State interfaces the ROS package explore lite, subscribes to it’s visualization topic that shows frontiers on a 2D map and extracts the closest frontier center point to the robot as navigation goal. Therefore, it retrieves the robot’s pose and calculates it’s distance to each of the frontier’s center points. Also, previously failed goals are disregarded as potential navigation goals. If it fails to find a suitable goal for exploration, it returns an error message and transitions back to the Idle State
To have explore lite running without directly sending
commands to the navigation stack, a mock action server
is constructed in the Additions Service Provider that leads
the exploration to believe the goals are accepted. Otherwise it does not start to to
calculate frontiers. Furthermore, explore lite
is launched with progress_timeout set to 3600 seconds which gives the robot ten hours
to move, otherwise the exploration stops and needs to be relaunched.
Navigation State
The Navigation State realizes an interface to the navigation ROS package. It forwards received goals to the navigation stack and also gets feedback from it regarding the progress. If it fails, the goal is added to the failed goals list. If it succeeds, the failed goal list will be reset.
When standing still for too long, it transitions to the Idle State. Reaching the goal will initiate a transition to the Mapping State or the particular routine state if there is one available. If not, Waypoint Following State is called. After reaching a navigation goal provided by RViz and if waypoint following has ended, it transitions to Idle State.
Reverse driving is realised by running two navigation stacks, one for forward driving and one for reverse driving. This is explained in more detail later. For reverse driving the robot also features a transform to a reverse base frame. When driving in reverse, all output command velocities are negated by the Additions Service Provider. If the reverse mode is activated or deactivated, the goal is cancelled and sent to the reverse navigation.
Mapping State
There are two mapping plugins included. The first state is just a dummy state while the latter is swiveling a simulated kinect camera from left to right around a revoluting joint.
Mapping Dummy State
The Mapping Dummy State is just transitioning back to the Calculate Goal State as specific mapping procedures are only relevant for the particular robot.
Kinect Mapping State
Swivels a kinect camera mounted on a joint revoluting around the z-axis from left to right and back to it’s centered position to map the surrounding area. This only works for the implemented Gazebo simulation as it publishes commands to the joint the kinect is mounted on.
Reversing Routine State
A Routine State called Reversing Routine is also include and toggles the reverse mode when the routine is executed. This means the robot is driving in reverse when it was going forward before and vice versa.
Additions Service Provider
This data handler class retrieved the frontiers published by explore lite for visualization, extracts each frontier’s center and republishes them as possible exploration goals. In case, the exploration mode is set to Interrupt, it is also checked if the current navigation goal is still in the list of exploration goals. If not, it is published that the goal is obsolete. A tolerance for comparing these positions can be set with a parameter.
Furthermore, goals that could not be reached during exploration, here named as failed goals, are saved and published. These serve as a way of blacklisting goals. This normally happens, when the navigation finishes.
For driving in reverse mode, the velocity commands issued by the reverse navigation stack are also subscribed to and republished with negated linear velocities. It also provides a service that is called when reverse mode should be activated. Since nothing needs to be changed in the configuration to change to reverse mode, this service just replies that it was successful.
If the kinect mapping is interrupted, a service is provided that moves the camera back to it’s centered position while the RSM is continuing.
Examples
An example to move a robot backwards and forwards with the navigation stack.
Reverse robot movement with navigation stack
The following code needs to be included in your launch file (or the nodes launched respectively) to allow the robot to navigate in forward and reverse depending on the set mode:
File truncated at 100 lines see the full file
Changelog for package rsm_additions
1.1.3 (2019-08-29)
- Added all dependencies to CMakeLists and package.xml, that were missing previously
- Contributors: MarcoStb1993
1.1.2 (2019-08-28)
1.1.1 (2019-08-05)
- added changelogs
- Fixed some dependencies for the new names
- Changed package names, this time for real
- Contributors: MarcoStb1993
Wiki Tutorials
Package Dependencies
| Deps | Name |
|---|---|
| roscpp | |
| actionlib | |
| actionlib_msgs | |
| pluginlib | |
| rsm_core | |
| rsm_msgs | |
| move_base_msgs | |
| visualization_msgs | |
| std_msgs | |
| std_srvs | |
| geometry_msgs | |
| sensor_msgs | |
| tf | |
| catkin |
System Dependencies
Dependant Packages
| Name | Deps |
|---|---|
| robot_statemachine |
Launch files
- launch/gazebo.launch
- Gazebo launch files for world and robot
-
- world_file [default: $(find husky_gazebo)/worlds/clearpath_playpen.world]
- robot_namespace [default: /]
- x [default: 0.0]
- y [default: 0.0]
- z [default: 0.0]
- yaw [default: 0.0]
- urdf_extras [default: $(optenv HUSKY_URDF_EXTRAS)]
- config_extras [default: $(eval optenv('HUSKY_CONFIG_EXTRAS', find('husky_control') + '/config/empty.yaml'))]
- launch/simulation_gazebo.launch
- Simulation of Husky UGV in Gazebo running Robot Statemachine with GMapping and Explore Lite
-
- world [default: $(find husky_gazebo)/worlds/clearpath_playpen.world]
- robot_frame [default: base_footprint]
- autonomy_cmd_vel_topic [default: /autonomy/cmd_vel]
- teleoperation_cmd_vel_topic [default: /teleoperation/cmd_vel]
- cmd_vel_topic [default: /cmd_vel]
- joystick_used [default: true]
- joystick_topic [default: /joy]
- calculate_goal_plugin [default: rsm::CalculateGoalState]
- navigation_plugin [default: rsm::NavigationState]
- mapping_plugin [default: rsm::KinectMappingState]
- waypoint_routines [default: ['Reversing']]
- rviz [default: false]
- joystick_used [default: $(arg joystick_used)]
- joystick_topic [default: $(arg joystick_topic)]
- launch/simulation_stdr.launch
- Simulation of Statemachine with GMapping and Frontier Exploration
-
- robot_frame [default: robot0]
- autonomy_cmd_vel_topic [default: /robot0/autonomy/cmd_vel]
- teleoperation_cmd_vel_topic [default: /robot0/teleoperation/cmd_vel]
- cmd_vel_topic [default: /robot0/cmd_vel]
- joystick_used [default: true]
- joystick_topic [default: /joy]
- calculate_goal_plugin [default: rsm::CalculateGoalState]
- navigation_plugin [default: rsm::NavigationState]
- mapping_plugin [default: rsm::MappingDummyState]
- waypoint_routines [default: ['Reversing']]
- rviz [default: false]
- joystick_used [default: $(arg joystick_used)]
- joystick_topic [default: $(arg joystick_topic)]
Messages
Services
Plugins
Recent questions tagged rsm_additions at Robotics Stack Exchange
|
|
rsm_additions package from robot_statemachine reporobot_statemachine rsm_additions rsm_core rsm_msgs rsm_rqt_plugins rsm_rviz_plugins |
ROS Distro
|
Package Summary
| Tags | No category tags. |
| Version | 1.2.1 |
| License | BSD |
| Build type | CATKIN |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/MarcoStb1993/robot_statemachine.git |
| VCS Type | git |
| VCS Version | melodic-devel |
| Last Updated | 2022-02-10 |
| Dev Status | MAINTAINED |
| CI status | Continuous Integration : 0 / 0 |
| Released | RELEASED |
| Tags | No category tags. |
| Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Package Description
Additional Links
Maintainers
- Marco Steinbrink
Authors
- Marco Steinbrink
RSM Additions
Additions to the RSM including all mandatory plugin states and a plugin routine state. Also an additional service provider is included.
Documentation
This package implements plugins for the Calculate Goal State, the Navigation State and the Mapping State. Furthermore, the Reversing Routine State is an optional routine state plugin. The Additions Service Provider handles the data to be transferred between these plugins.
Calculate Goal State
The Calculate Goal State interfaces the ROS package explore lite, subscribes to it’s visualization topic that shows frontiers on a 2D map and extracts the closest frontier center point to the robot as navigation goal. Therefore, it retrieves the robot’s pose and calculates it’s distance to each of the frontier’s center points. Also, previously failed goals are disregarded as potential navigation goals. If it fails to find a suitable goal for exploration, it returns an error message and transitions back to the Idle State
To have explore lite running without directly sending
commands to the navigation stack, a mock action server
is constructed in the Additions Service Provider that leads
the exploration to believe the goals are accepted. Otherwise it does not start to to
calculate frontiers. Furthermore, explore lite
is launched with progress_timeout set to 3600 seconds which gives the robot ten hours
to move, otherwise the exploration stops and needs to be relaunched.
Navigation State
The Navigation State realizes an interface to the navigation ROS package. It forwards received goals to the navigation stack and also gets feedback from it regarding the progress. If it fails, the goal is added to the failed goals list. If it succeeds, the failed goal list will be reset.
When standing still for too long, it transitions to the Idle State. Reaching the goal will initiate a transition to the Mapping State or the particular routine state if there is one available. If not, Waypoint Following State is called. After reaching a navigation goal provided by RViz and if waypoint following has ended, it transitions to Idle State.
Reverse driving is realised by running two navigation stacks, one for forward driving and one for reverse driving. This is explained in more detail later. For reverse driving the robot also features a transform to a reverse base frame. When driving in reverse, all output command velocities are negated by the Additions Service Provider. If the reverse mode is activated or deactivated, the goal is cancelled and sent to the reverse navigation.
Furthermore, if the robot got stuck during navigation and the respective parameter was set, reverse driving can be used to try to unstuck the robot.
Mapping State
There are two mapping plugins included. The first state is just a dummy state while the latter is swiveling a simulated Intel RealSense camera from left to right around a revoluting joint.
Mapping Dummy State
The Mapping Dummy State is just transitioning back to the Calculate Goal State as specific mapping procedures are only relevant for the particular robot.
RealSense Mapping State
Swivels an Intel RealSense camera mounted on a joint revoluting around the z-axis from left to right and back to it’s centered position to map the surrounding area. This only works for the implemented Gazebo simulation as it publishes commands to the joint the RealSense is mounted on.
Reversing Routine State
A Routine State called Reversing Routine is also include and toggles the reverse mode when the routine is executed. This means the robot is driving in reverse when it was going forward before and vice versa.
Additions Service Provider
This data handler class provides services for the calcualte goal, navigation, mapping and reversing routine states. The respective services are only initialised if the corresponding state is active.
It retrieves the frontiers published by explore lite for visualization, extracts each frontier’s center and republishes them as possible exploration goals. In case, the exploration mode is set to Interrupt, it is also checked if the current navigation goal is still in the list of exploration goals. If not, it is published that the goal is obsolete. A tolerance for comparing these positions can be set with a parameter.
Furthermore, goals that could not be reached during exploration, here named as failed goals, are saved and published. These serve as a way of blacklisting goals. This normally happens, when the navigation finishes.
For driving in reverse mode, the velocity commands issued by the reverse navigation stack are also subscribed to and republished with negated linear velocities. It also provides a service that is called when reverse mode should be activated. Since nothing needs to be changed in the configuration to change to reverse mode, this service just replies that it was successful.
If the Realsense mapping is interrupted, a service is provided that moves the camera back to it’s centered position while the RSM is continuing.
Gazebo To TF
This class mocks the robot’s localization in a simulated map by retrieving it directly from gazebo. This can be used to replace error prone odometry or SLAM if something else needs to be tested.
File truncated at 100 lines see the full file
Changelog for package rsm_additions
1.2.1 (2020-11-24)
- Add nav_msgs dependency
- Add nav msgs dependency
- Contributors: MarcoStb1993
1.2.0 (2020-11-04)
- Added parameter for navigation behavior on idle timer callback and gazeboToTf changed to ground plane
- Fixes for navigation idle timer
- Get Odom tf directly from gazebo instead of EKF
- Node to retrieve TF directly from gazebo
- Added reverse movement as unstuck behavior to navigation state
- Added params for idle timer and pose tolerance
- Compare pose to identify idling and state transition on goal obsolete
- Replaced simulated kinect with Intel RealSense to adapt to husky simulator melodic
- Clipped Kinect range to ignore laser scanner
- Now sets goal as finished only after completing mapping or routine state
- Fixed Kinect control joint name
- Exploration Goal Status is now published as a topic to prevent service deadlocks
- Removed failed goal services and added a publisher
- Added GoalCompleted service to give more detailed feedback over navigation completed status
- Added prefix to state name to identify autonomy behavior
- moved goalObsolete service to Additions and exploration completed goal out of navigation completed service
- Added navigation completed service call to goal obsolete callback
- Only publish exploration goals when explore_lite is used
- Additions Service Provider only subscribes and listens to services and topics for active plugins
- Added tutorial details for creating Calculate Goal and Navigation plugins
- Added services for handling completed navigation goals to remove the logic from the navigation plugin
- Link corrections in README
- Moved logic regarding explore_lite to AdditionsServiceProvider from ServiceProvider where they should belong
- Removed double maintainer tags
- Added joystick topic for teleoperation interrupt
- Properly reset shared_ptr to prevent errors on close
- Contributors: Marco Steinbrink, MarcoStb1993, marco
1.1.3 (2019-08-29)
- Added all dependencies to CMakeLists and package.xml, that were missing previously
- Contributors: MarcoStb1993
1.1.2 (2019-08-28)
1.1.1 (2019-08-05)
- added changelogs
- Fixed some dependencies for the new names
- Changed package names, this time for real
- Contributors: MarcoStb1993
Wiki Tutorials
Package Dependencies
| Deps | Name |
|---|---|
| roscpp | |
| actionlib | |
| actionlib_msgs | |
| pluginlib | |
| rsm_core | |
| rsm_msgs | |
| move_base_msgs | |
| visualization_msgs | |
| std_msgs | |
| std_srvs | |
| geometry_msgs | |
| sensor_msgs | |
| tf | |
| tf2 | |
| tf2_ros | |
| nav_msgs | |
| catkin |
System Dependencies
Dependant Packages
| Name | Deps |
|---|---|
| robot_statemachine |
Launch files
- launch/gazebo_husky.launch
- Gazebo launch files for world and Clearpath Robotics Husky robot
-
- world_file [default: $(find husky_gazebo)/worlds/clearpath_playpen.world]
- robot_namespace [default: /]
- x [default: 0.0]
- y [default: 0.0]
- z [default: 0.0]
- yaw [default: 0.0]
- urdf_extras [default: $(optenv HUSKY_URDF_EXTRAS)]
- config_extras [default: $(eval optenv('HUSKY_CONFIG_EXTRAS', find('husky_control') + '/config/empty.yaml'))]
- launch/gazebo_turtlebot3.launch
- Gazebo launch files for world and TurtleBot3 robot
-
- teleop_enabled [default: false]
- world_file [default: $(find turtlebot3_gazebo)/worlds/turtlebot3_world.world]
- robot_namespace [default: /]
- x [default: -2.0]
- y [default: -0.5]
- z [default: 0.0]
- yaw [default: 0.0]
- launch/simulation_husky.launch
- Simulation of Husky UGV in Gazebo running Robot Statemachine with GMapping and Explore Lite
-
- world [default: $(find husky_gazebo)/worlds/clearpath_playpen.world]
- robot_frame [default: base_footprint]
- autonomy_cmd_vel_topic [default: /autonomy/cmd_vel]
- teleoperation_cmd_vel_topic [default: /teleoperation/cmd_vel]
- cmd_vel_topic [default: /cmd_vel]
- joystick_used [default: true]
- joystick_topic [default: /joy]
- calculate_goal_plugin [default: rsm::CalculateGoalState]
- navigation_plugin [default: rsm::NavigationState]
- mapping_plugin [default: rsm::RealsenseMappingState]
- waypoint_routines [default: ['Reversing']]
- rviz [default: true]
- joystick_used [default: $(arg joystick_used)]
- joystick_topic [default: $(arg joystick_topic)]
- launch/simulation_stdr.launch
- Simulation of Statemachine with GMapping and Frontier Exploration
-
- robot_frame [default: robot0]
- autonomy_cmd_vel_topic [default: /robot0/autonomy/cmd_vel]
- teleoperation_cmd_vel_topic [default: /robot0/teleoperation/cmd_vel]
- cmd_vel_topic [default: /robot0/cmd_vel]
- joystick_used [default: true]
- joystick_topic [default: /joy]
- calculate_goal_plugin [default: rsm::CalculateGoalState]
- navigation_plugin [default: rsm::NavigationState]
- mapping_plugin [default: rsm::MappingDummyState]
- waypoint_routines [default: ['Reversing']]
- rviz [default: true]
- joystick_used [default: $(arg joystick_used)]
- joystick_topic [default: $(arg joystick_topic)]
- launch/simulation_turtlebot3.launch
- Simulation of TurtleBot3 in Gazebo running Robot Statemachine with GMapping and Explore Lite
-
- world [default: $(find turtlebot3_gazebo)/worlds/turtlebot3_world.world]
- teleop_enabled [default: false]
- robot_frame [default: base_footprint]
- autonomy_cmd_vel_topic [default: /autonomy/cmd_vel]
- teleoperation_cmd_vel_topic [default: /teleoperation/cmd_vel]
- cmd_vel_topic [default: /cmd_vel]
- joystick_used [default: true]
- joystick_topic [default: /joy]
- calculate_goal_plugin [default: rsm::CalculateGoalState]
- navigation_plugin [default: rsm::NavigationState]
- mapping_plugin [default: rsm::MappingDummyState]
- waypoint_routines [default: ['Reversing']]
- rviz [default: true]
- teleop_enabled [default: $(arg teleop_enabled)]
- joystick_used [default: $(arg joystick_used)]
- joystick_topic [default: $(arg joystick_topic)]
Messages
Services
Plugins
Recent questions tagged rsm_additions at Robotics Stack Exchange
|
|
rsm_additions package from robot_statemachine reporobot_statemachine rsm_additions rsm_core rsm_msgs rsm_rqt_plugins rsm_rviz_plugins |
ROS Distro
|
Package Summary
| Tags | No category tags. |
| Version | 1.1.3 |
| License | BSD |
| Build type | CATKIN |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/MarcoStb1993/robot_statemachine.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2021-03-15 |
| Dev Status | MAINTAINED |
| CI status | Continuous Integration |
| Released | RELEASED |
| Tags | No category tags. |
| Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Package Description
Additional Links
Maintainers
- Marco Steinbrink
Authors
- Marco Steinbrink
RSM Additions
Additions to the RSM including all mandatory plugin states and a plugin routine state. Also an additional service provider is included.
Documentation
This package implements plugins for the Calculate Goal State, the Navigation State and the Mapping State. Furthermore, the Reversing Routine State is an optional routine state plugin. The Additions Service Provider handles the data to be transferred between these plugins.
Calculate Goal State
The Calculate Goal State interfaces the ROS package explore lite, subscribes to it’s visualization topic that shows frontiers on a 2D map and extracts the closest frontier center point to the robot as navigation goal. Therefore, it retrieves the robot’s pose and calculates it’s distance to each of the frontier’s center points. Also, previously failed goals are disregarded as potential navigation goals. If it fails to find a suitable goal for exploration, it returns an error message and transitions back to the Idle State
To have explore lite running without directly sending
commands to the navigation stack, a mock action server
is constructed in the Additions Service Provider that leads
the exploration to believe the goals are accepted. Otherwise it does not start to to
calculate frontiers. Furthermore, explore lite
is launched with progress_timeout set to 3600 seconds which gives the robot ten hours
to move, otherwise the exploration stops and needs to be relaunched.
Navigation State
The Navigation State realizes an interface to the navigation ROS package. It forwards received goals to the navigation stack and also gets feedback from it regarding the progress. If it fails, the goal is added to the failed goals list. If it succeeds, the failed goal list will be reset.
When standing still for too long, it transitions to the Idle State. Reaching the goal will initiate a transition to the Mapping State or the particular routine state if there is one available. If not, Waypoint Following State is called. After reaching a navigation goal provided by RViz and if waypoint following has ended, it transitions to Idle State.
Reverse driving is realised by running two navigation stacks, one for forward driving and one for reverse driving. This is explained in more detail later. For reverse driving the robot also features a transform to a reverse base frame. When driving in reverse, all output command velocities are negated by the Additions Service Provider. If the reverse mode is activated or deactivated, the goal is cancelled and sent to the reverse navigation.
Mapping State
There are two mapping plugins included. The first state is just a dummy state while the latter is swiveling a simulated kinect camera from left to right around a revoluting joint.
Mapping Dummy State
The Mapping Dummy State is just transitioning back to the Calculate Goal State as specific mapping procedures are only relevant for the particular robot.
Kinect Mapping State
Swivels a kinect camera mounted on a joint revoluting around the z-axis from left to right and back to it’s centered position to map the surrounding area. This only works for the implemented Gazebo simulation as it publishes commands to the joint the kinect is mounted on.
Reversing Routine State
A Routine State called Reversing Routine is also include and toggles the reverse mode when the routine is executed. This means the robot is driving in reverse when it was going forward before and vice versa.
Additions Service Provider
This data handler class retrieved the frontiers published by explore lite for visualization, extracts each frontier’s center and republishes them as possible exploration goals. In case, the exploration mode is set to Interrupt, it is also checked if the current navigation goal is still in the list of exploration goals. If not, it is published that the goal is obsolete. A tolerance for comparing these positions can be set with a parameter.
Furthermore, goals that could not be reached during exploration, here named as failed goals, are saved and published. These serve as a way of blacklisting goals. This normally happens, when the navigation finishes.
For driving in reverse mode, the velocity commands issued by the reverse navigation stack are also subscribed to and republished with negated linear velocities. It also provides a service that is called when reverse mode should be activated. Since nothing needs to be changed in the configuration to change to reverse mode, this service just replies that it was successful.
If the kinect mapping is interrupted, a service is provided that moves the camera back to it’s centered position while the RSM is continuing.
Examples
An example to move a robot backwards and forwards with the navigation stack.
Reverse robot movement with navigation stack
The following code needs to be included in your launch file (or the nodes launched respectively) to allow the robot to navigate in forward and reverse depending on the set mode:
File truncated at 100 lines see the full file
Changelog for package rsm_additions
1.1.3 (2019-08-29)
- Added all dependencies to CMakeLists and package.xml, that were missing previously
- Contributors: MarcoStb1993
1.1.2 (2019-08-28)
1.1.1 (2019-08-05)
- added changelogs
- Fixed some dependencies for the new names
- Changed package names, this time for real
- Contributors: MarcoStb1993
Wiki Tutorials
Package Dependencies
| Deps | Name |
|---|---|
| roscpp | |
| actionlib | |
| actionlib_msgs | |
| pluginlib | |
| rsm_core | |
| rsm_msgs | |
| move_base_msgs | |
| visualization_msgs | |
| std_msgs | |
| std_srvs | |
| geometry_msgs | |
| sensor_msgs | |
| tf | |
| catkin |
System Dependencies
Dependant Packages
| Name | Deps |
|---|---|
| robot_statemachine |
Launch files
- launch/gazebo.launch
- Gazebo launch files for world and robot
-
- world_file [default: $(find husky_gazebo)/worlds/clearpath_playpen.world]
- robot_namespace [default: /]
- x [default: 0.0]
- y [default: 0.0]
- z [default: 0.0]
- yaw [default: 0.0]
- urdf_extras [default: $(optenv HUSKY_URDF_EXTRAS)]
- config_extras [default: $(eval optenv('HUSKY_CONFIG_EXTRAS', find('husky_control') + '/config/empty.yaml'))]
- launch/simulation_gazebo.launch
- Simulation of Husky UGV in Gazebo running Robot Statemachine with GMapping and Explore Lite
-
- world [default: $(find husky_gazebo)/worlds/clearpath_playpen.world]
- robot_frame [default: base_footprint]
- autonomy_cmd_vel_topic [default: /autonomy/cmd_vel]
- teleoperation_cmd_vel_topic [default: /teleoperation/cmd_vel]
- cmd_vel_topic [default: /cmd_vel]
- joystick_used [default: true]
- joystick_topic [default: /joy]
- calculate_goal_plugin [default: rsm::CalculateGoalState]
- navigation_plugin [default: rsm::NavigationState]
- mapping_plugin [default: rsm::KinectMappingState]
- waypoint_routines [default: ['Reversing']]
- rviz [default: false]
- joystick_used [default: $(arg joystick_used)]
- joystick_topic [default: $(arg joystick_topic)]
- launch/simulation_stdr.launch
- Simulation of Statemachine with GMapping and Frontier Exploration
-
- robot_frame [default: robot0]
- autonomy_cmd_vel_topic [default: /robot0/autonomy/cmd_vel]
- teleoperation_cmd_vel_topic [default: /robot0/teleoperation/cmd_vel]
- cmd_vel_topic [default: /robot0/cmd_vel]
- joystick_used [default: true]
- joystick_topic [default: /joy]
- calculate_goal_plugin [default: rsm::CalculateGoalState]
- navigation_plugin [default: rsm::NavigationState]
- mapping_plugin [default: rsm::MappingDummyState]
- waypoint_routines [default: ['Reversing']]
- rviz [default: false]
- joystick_used [default: $(arg joystick_used)]
- joystick_topic [default: $(arg joystick_topic)]