| 
      
        uav_random_direction package from swarm_behaviors reposwarm_behaviors_position swarm_behaviors_velocity swarm_behaviors uav_local_coverage uav_optimal_coverage uav_random_direction uav_simple_tracking ugv_random_walk | 
      
         ROS Distro
       | 
    
Package Summary
| Version | 1.3.0 | 
| License | Apache License 2.0 | 
| Build type | CATKIN | 
| Use | RECOMMENDED | 
Repository Summary
| Checkout URI | https://github.com/cpswarm/swarm_behaviors.git | 
| VCS Type | git | 
| VCS Version | kinetic-devel | 
| Last Updated | 2021-02-04 | 
| Dev Status | DEVELOPED | 
| Released | RELEASED | 
| Contributing | 
        
          Help Wanted (-)
        
         Good First Issues (-) Pull Requests to Review (-)  | 
    
Package Description
Additional Links
Maintainers
- Micha Sende
 
Authors
- Micha Sende
 
uav_random_direction
This package performs random direction coverage with an unmanned aerial vehicle (UAV). It is part of the swarm behaviors library.
Dependencies
This package depends on the following message definitions:
The following library packages of the swarm behaviors library are required:
- swarm_behaviors_position
 
The following packages of the swarm functions library are required:
- target_monitor (only if 
single_target=true) 
The following packages of the sensing and actuation library are required:
- area_provider
 - obstacle_detection
 
Further required packages are:
Execution
Run the launch file
roslaunch uav_random_direction uav_random_direction.launch
to launch the uav_random_direction node.
The launch file can be configured with following parameters:
- 
id(integer, default:1) The identifier (ID) of the CPS used for name spacing in simulation. - 
output(string, default:screen) Whether to show the program output (screen) or to write it to a log file (log). 
In the param subdirectory there is the parameter file uav_random_direction.yaml that allows to configure the behavior of the uav_random_direction node.
Nodes
uav_random_direction
The uav_random_direction performs coverage using the random direction algorithm. The random direction is a mathematical movement model, where an agent moves straight forward until it reaches an obstacle or the environment boundary. There, it changes its direction randomly into a direction that is clear of obstacles. When the parameter single_target is set to true, the UAV succeeds once a target has been found and returns the target ID and position.
Action Goal
- 
uav_coverage/goal(cpswarm_msgs/CoverageGoal) A goal that starts the random direction coverage behavior. It contains the altitude at which to operate. 
Action Result
- 
uav_coverage/result(cpswarm_msgs/CoverageResult) ID and position of the target that has been found. 
Subscribed Topics
- 
target_found(cpswarm_msgs/TargetPositionEvent) Position and ID of a target detected by the target monitor. Only subscribed whensingle_targetis set totrue. 
Services Called
- 
area/get_area(cpswarm_msgs/GetPoints) Get the area polygon. - 
obstacle_detection/get_clear_sector(cpswarm_msgs/GetSector) Get the circular sector that is clear of obstacles. 
Parameters
- 
~loop_rate(real, default:5.0) The frequency in Hz at which to run the control loops. - 
~queue_size(integer, default:1) The size of the message queue used for publishing and subscribing to topics. - 
~single_target(boolean, default:true) Whether the algorithm will succeed / terminate once a target has been found. - 
~margin(real, default:0.5) The distance in meter to keep to the environment boundary. - 
/rng_seed(integer, default:0) The seed used for random number generation. In the default case, a random seed is generated. 
Code API
Changelog for package uav_random_direction
1.3.0 (2020-01-03)
1.2.0 (2019-12-29)
- Changed: Refactor library structure
 - Changed: UAVs depart in different directions
 - Changed: Read RNG seed from parameter, use random seed otherwise
 - Changed: Return state aborted once coverage finishes
 - Changed: Check if movement was successful
 - Changed: Targets handled by swarm functions library
 - Fixed: Change direction when obstacle detected
 - Fixed: Correctly handle state of behavior algorithm
 - Fixed: Force C++11
 - Fixed: Returning of target
 - Contributors: Micha Sende
 
1.1.0 (2018-11-12)
- Fixed: Computation of sector occupied by obstacles and other UAVs
 - Contributors: Micha Sende
 
1.0.0 (2018-10-30)
- Initial release of uav_random_direction
 - Contributors: Micha Sende
 
Package Dependencies
System Dependencies
Dependant Packages
| Name | Deps | 
|---|---|
| swarm_behaviors | 
Launch files
- launch/uav_random_direction.launch
                
- 
                    
- id [default: 1]
 - output [default: log]
 
 
 
Messages
Services
Plugins
Recent questions tagged uav_random_direction at Robotics Stack Exchange
         
       | 
      
        uav_random_direction package from swarm_behaviors reposwarm_behaviors_position swarm_behaviors_velocity swarm_behaviors uav_local_coverage uav_optimal_coverage uav_random_direction uav_simple_tracking ugv_random_walk | 
      
         ROS Distro
       | 
    
Package Summary
| Version | 1.3.0 | 
| License | Apache License 2.0 | 
| Build type | CATKIN | 
| Use | RECOMMENDED | 
Repository Summary
| Checkout URI | https://github.com/cpswarm/swarm_behaviors.git | 
| VCS Type | git | 
| VCS Version | kinetic-devel | 
| Last Updated | 2021-02-04 | 
| Dev Status | DEVELOPED | 
| Released | RELEASED | 
| Contributing | 
        
          Help Wanted (-)
        
         Good First Issues (-) Pull Requests to Review (-)  | 
    
Package Description
Additional Links
Maintainers
- Micha Sende
 
Authors
- Micha Sende
 
uav_random_direction
This package performs random direction coverage with an unmanned aerial vehicle (UAV). It is part of the swarm behaviors library.
Dependencies
This package depends on the following message definitions:
The following library packages of the swarm behaviors library are required:
- swarm_behaviors_position
 
The following packages of the swarm functions library are required:
- target_monitor (only if 
single_target=true) 
The following packages of the sensing and actuation library are required:
- area_provider
 - obstacle_detection
 
Further required packages are:
Execution
Run the launch file
roslaunch uav_random_direction uav_random_direction.launch
to launch the uav_random_direction node.
The launch file can be configured with following parameters:
- 
id(integer, default:1) The identifier (ID) of the CPS used for name spacing in simulation. - 
output(string, default:screen) Whether to show the program output (screen) or to write it to a log file (log). 
In the param subdirectory there is the parameter file uav_random_direction.yaml that allows to configure the behavior of the uav_random_direction node.
Nodes
uav_random_direction
The uav_random_direction performs coverage using the random direction algorithm. The random direction is a mathematical movement model, where an agent moves straight forward until it reaches an obstacle or the environment boundary. There, it changes its direction randomly into a direction that is clear of obstacles. When the parameter single_target is set to true, the UAV succeeds once a target has been found and returns the target ID and position.
Action Goal
- 
uav_coverage/goal(cpswarm_msgs/CoverageGoal) A goal that starts the random direction coverage behavior. It contains the altitude at which to operate. 
Action Result
- 
uav_coverage/result(cpswarm_msgs/CoverageResult) ID and position of the target that has been found. 
Subscribed Topics
- 
target_found(cpswarm_msgs/TargetPositionEvent) Position and ID of a target detected by the target monitor. Only subscribed whensingle_targetis set totrue. 
Services Called
- 
area/get_area(cpswarm_msgs/GetPoints) Get the area polygon. - 
obstacle_detection/get_clear_sector(cpswarm_msgs/GetSector) Get the circular sector that is clear of obstacles. 
Parameters
- 
~loop_rate(real, default:5.0) The frequency in Hz at which to run the control loops. - 
~queue_size(integer, default:1) The size of the message queue used for publishing and subscribing to topics. - 
~single_target(boolean, default:true) Whether the algorithm will succeed / terminate once a target has been found. - 
~margin(real, default:0.5) The distance in meter to keep to the environment boundary. - 
/rng_seed(integer, default:0) The seed used for random number generation. In the default case, a random seed is generated. 
Code API
Changelog for package uav_random_direction
1.3.0 (2020-01-03)
1.2.0 (2019-12-29)
- Changed: Refactor library structure
 - Changed: UAVs depart in different directions
 - Changed: Read RNG seed from parameter, use random seed otherwise
 - Changed: Return state aborted once coverage finishes
 - Changed: Check if movement was successful
 - Changed: Targets handled by swarm functions library
 - Fixed: Change direction when obstacle detected
 - Fixed: Correctly handle state of behavior algorithm
 - Fixed: Force C++11
 - Fixed: Returning of target
 - Contributors: Micha Sende
 
1.1.0 (2018-11-12)
- Fixed: Computation of sector occupied by obstacles and other UAVs
 - Contributors: Micha Sende
 
1.0.0 (2018-10-30)
- Initial release of uav_random_direction
 - Contributors: Micha Sende
 
Package Dependencies
System Dependencies
Dependant Packages
| Name | Deps | 
|---|---|
| swarm_behaviors | 
Launch files
- launch/uav_random_direction.launch
                
- 
                    
- id [default: 1]
 - output [default: log]
 
 
 
Messages
Services
Plugins
Recent questions tagged uav_random_direction at Robotics Stack Exchange
         
       | 
      
        uav_random_direction package from swarm_behaviors reposwarm_behaviors_position swarm_behaviors_velocity swarm_behaviors uav_local_coverage uav_optimal_coverage uav_random_direction uav_simple_tracking ugv_random_walk | 
      
         ROS Distro
       | 
    
Package Summary
| Version | 1.3.0 | 
| License | Apache License 2.0 | 
| Build type | CATKIN | 
| Use | RECOMMENDED | 
Repository Summary
| Checkout URI | https://github.com/cpswarm/swarm_behaviors.git | 
| VCS Type | git | 
| VCS Version | kinetic-devel | 
| Last Updated | 2021-02-04 | 
| Dev Status | DEVELOPED | 
| Released | RELEASED | 
| Contributing | 
        
          Help Wanted (-)
        
         Good First Issues (-) Pull Requests to Review (-)  | 
    
Package Description
Additional Links
Maintainers
- Micha Sende
 
Authors
- Micha Sende
 
uav_random_direction
This package performs random direction coverage with an unmanned aerial vehicle (UAV). It is part of the swarm behaviors library.
Dependencies
This package depends on the following message definitions:
The following library packages of the swarm behaviors library are required:
- swarm_behaviors_position
 
The following packages of the swarm functions library are required:
- target_monitor (only if 
single_target=true) 
The following packages of the sensing and actuation library are required:
- area_provider
 - obstacle_detection
 
Further required packages are:
Execution
Run the launch file
roslaunch uav_random_direction uav_random_direction.launch
to launch the uav_random_direction node.
The launch file can be configured with following parameters:
- 
id(integer, default:1) The identifier (ID) of the CPS used for name spacing in simulation. - 
output(string, default:screen) Whether to show the program output (screen) or to write it to a log file (log). 
In the param subdirectory there is the parameter file uav_random_direction.yaml that allows to configure the behavior of the uav_random_direction node.
Nodes
uav_random_direction
The uav_random_direction performs coverage using the random direction algorithm. The random direction is a mathematical movement model, where an agent moves straight forward until it reaches an obstacle or the environment boundary. There, it changes its direction randomly into a direction that is clear of obstacles. When the parameter single_target is set to true, the UAV succeeds once a target has been found and returns the target ID and position.
Action Goal
- 
uav_coverage/goal(cpswarm_msgs/CoverageGoal) A goal that starts the random direction coverage behavior. It contains the altitude at which to operate. 
Action Result
- 
uav_coverage/result(cpswarm_msgs/CoverageResult) ID and position of the target that has been found. 
Subscribed Topics
- 
target_found(cpswarm_msgs/TargetPositionEvent) Position and ID of a target detected by the target monitor. Only subscribed whensingle_targetis set totrue. 
Services Called
- 
area/get_area(cpswarm_msgs/GetPoints) Get the area polygon. - 
obstacle_detection/get_clear_sector(cpswarm_msgs/GetSector) Get the circular sector that is clear of obstacles. 
Parameters
- 
~loop_rate(real, default:5.0) The frequency in Hz at which to run the control loops. - 
~queue_size(integer, default:1) The size of the message queue used for publishing and subscribing to topics. - 
~single_target(boolean, default:true) Whether the algorithm will succeed / terminate once a target has been found. - 
~margin(real, default:0.5) The distance in meter to keep to the environment boundary. - 
/rng_seed(integer, default:0) The seed used for random number generation. In the default case, a random seed is generated. 
Code API
Changelog for package uav_random_direction
1.3.0 (2020-01-03)
1.2.0 (2019-12-29)
- Changed: Refactor library structure
 - Changed: UAVs depart in different directions
 - Changed: Read RNG seed from parameter, use random seed otherwise
 - Changed: Return state aborted once coverage finishes
 - Changed: Check if movement was successful
 - Changed: Targets handled by swarm functions library
 - Fixed: Change direction when obstacle detected
 - Fixed: Correctly handle state of behavior algorithm
 - Fixed: Force C++11
 - Fixed: Returning of target
 - Contributors: Micha Sende
 
1.1.0 (2018-11-12)
- Fixed: Computation of sector occupied by obstacles and other UAVs
 - Contributors: Micha Sende
 
1.0.0 (2018-10-30)
- Initial release of uav_random_direction
 - Contributors: Micha Sende
 
Package Dependencies
System Dependencies
Dependant Packages
| Name | Deps | 
|---|---|
| swarm_behaviors | 
Launch files
- launch/uav_random_direction.launch
                
- 
                    
- id [default: 1]
 - output [default: log]
 
 
 
Messages
Services
Plugins
Recent questions tagged uav_random_direction at Robotics Stack Exchange
         
       | 
      
        uav_random_direction package from swarm_behaviors reposwarm_behaviors_position swarm_behaviors_velocity swarm_behaviors uav_local_coverage uav_optimal_coverage uav_random_direction uav_simple_tracking ugv_random_walk | 
      
         ROS Distro
       | 
    
Package Summary
| Version | 1.3.0 | 
| License | Apache License 2.0 | 
| Build type | CATKIN | 
| Use | RECOMMENDED | 
Repository Summary
| Checkout URI | https://github.com/cpswarm/swarm_behaviors.git | 
| VCS Type | git | 
| VCS Version | kinetic-devel | 
| Last Updated | 2021-02-04 | 
| Dev Status | DEVELOPED | 
| Released | RELEASED | 
| Contributing | 
        
          Help Wanted (-)
        
         Good First Issues (-) Pull Requests to Review (-)  | 
    
Package Description
Additional Links
Maintainers
- Micha Sende
 
Authors
- Micha Sende
 
uav_random_direction
This package performs random direction coverage with an unmanned aerial vehicle (UAV). It is part of the swarm behaviors library.
Dependencies
This package depends on the following message definitions:
The following library packages of the swarm behaviors library are required:
- swarm_behaviors_position
 
The following packages of the swarm functions library are required:
- target_monitor (only if 
single_target=true) 
The following packages of the sensing and actuation library are required:
- area_provider
 - obstacle_detection
 
Further required packages are:
Execution
Run the launch file
roslaunch uav_random_direction uav_random_direction.launch
to launch the uav_random_direction node.
The launch file can be configured with following parameters:
- 
id(integer, default:1) The identifier (ID) of the CPS used for name spacing in simulation. - 
output(string, default:screen) Whether to show the program output (screen) or to write it to a log file (log). 
In the param subdirectory there is the parameter file uav_random_direction.yaml that allows to configure the behavior of the uav_random_direction node.
Nodes
uav_random_direction
The uav_random_direction performs coverage using the random direction algorithm. The random direction is a mathematical movement model, where an agent moves straight forward until it reaches an obstacle or the environment boundary. There, it changes its direction randomly into a direction that is clear of obstacles. When the parameter single_target is set to true, the UAV succeeds once a target has been found and returns the target ID and position.
Action Goal
- 
uav_coverage/goal(cpswarm_msgs/CoverageGoal) A goal that starts the random direction coverage behavior. It contains the altitude at which to operate. 
Action Result
- 
uav_coverage/result(cpswarm_msgs/CoverageResult) ID and position of the target that has been found. 
Subscribed Topics
- 
target_found(cpswarm_msgs/TargetPositionEvent) Position and ID of a target detected by the target monitor. Only subscribed whensingle_targetis set totrue. 
Services Called
- 
area/get_area(cpswarm_msgs/GetPoints) Get the area polygon. - 
obstacle_detection/get_clear_sector(cpswarm_msgs/GetSector) Get the circular sector that is clear of obstacles. 
Parameters
- 
~loop_rate(real, default:5.0) The frequency in Hz at which to run the control loops. - 
~queue_size(integer, default:1) The size of the message queue used for publishing and subscribing to topics. - 
~single_target(boolean, default:true) Whether the algorithm will succeed / terminate once a target has been found. - 
~margin(real, default:0.5) The distance in meter to keep to the environment boundary. - 
/rng_seed(integer, default:0) The seed used for random number generation. In the default case, a random seed is generated. 
Code API
Changelog for package uav_random_direction
1.3.0 (2020-01-03)
1.2.0 (2019-12-29)
- Changed: Refactor library structure
 - Changed: UAVs depart in different directions
 - Changed: Read RNG seed from parameter, use random seed otherwise
 - Changed: Return state aborted once coverage finishes
 - Changed: Check if movement was successful
 - Changed: Targets handled by swarm functions library
 - Fixed: Change direction when obstacle detected
 - Fixed: Correctly handle state of behavior algorithm
 - Fixed: Force C++11
 - Fixed: Returning of target
 - Contributors: Micha Sende
 
1.1.0 (2018-11-12)
- Fixed: Computation of sector occupied by obstacles and other UAVs
 - Contributors: Micha Sende
 
1.0.0 (2018-10-30)
- Initial release of uav_random_direction
 - Contributors: Micha Sende
 
Package Dependencies
System Dependencies
Dependant Packages
| Name | Deps | 
|---|---|
| swarm_behaviors | 
Launch files
- launch/uav_random_direction.launch
                
- 
                    
- id [default: 1]
 - output [default: log]
 
 
 
Messages
Services
Plugins
Recent questions tagged uav_random_direction at Robotics Stack Exchange
         
       | 
      
        uav_random_direction package from swarm_behaviors reposwarm_behaviors_position swarm_behaviors_velocity swarm_behaviors uav_local_coverage uav_optimal_coverage uav_random_direction uav_simple_tracking ugv_random_walk | 
      
         ROS Distro
       | 
    
Package Summary
| Version | 1.3.0 | 
| License | Apache License 2.0 | 
| Build type | CATKIN | 
| Use | RECOMMENDED | 
Repository Summary
| Checkout URI | https://github.com/cpswarm/swarm_behaviors.git | 
| VCS Type | git | 
| VCS Version | kinetic-devel | 
| Last Updated | 2021-02-04 | 
| Dev Status | DEVELOPED | 
| Released | RELEASED | 
| Contributing | 
        
          Help Wanted (-)
        
         Good First Issues (-) Pull Requests to Review (-)  | 
    
Package Description
Additional Links
Maintainers
- Micha Sende
 
Authors
- Micha Sende
 
uav_random_direction
This package performs random direction coverage with an unmanned aerial vehicle (UAV). It is part of the swarm behaviors library.
Dependencies
This package depends on the following message definitions:
The following library packages of the swarm behaviors library are required:
- swarm_behaviors_position
 
The following packages of the swarm functions library are required:
- target_monitor (only if 
single_target=true) 
The following packages of the sensing and actuation library are required:
- area_provider
 - obstacle_detection
 
Further required packages are:
Execution
Run the launch file
roslaunch uav_random_direction uav_random_direction.launch
to launch the uav_random_direction node.
The launch file can be configured with following parameters:
- 
id(integer, default:1) The identifier (ID) of the CPS used for name spacing in simulation. - 
output(string, default:screen) Whether to show the program output (screen) or to write it to a log file (log). 
In the param subdirectory there is the parameter file uav_random_direction.yaml that allows to configure the behavior of the uav_random_direction node.
Nodes
uav_random_direction
The uav_random_direction performs coverage using the random direction algorithm. The random direction is a mathematical movement model, where an agent moves straight forward until it reaches an obstacle or the environment boundary. There, it changes its direction randomly into a direction that is clear of obstacles. When the parameter single_target is set to true, the UAV succeeds once a target has been found and returns the target ID and position.
Action Goal
- 
uav_coverage/goal(cpswarm_msgs/CoverageGoal) A goal that starts the random direction coverage behavior. It contains the altitude at which to operate. 
Action Result
- 
uav_coverage/result(cpswarm_msgs/CoverageResult) ID and position of the target that has been found. 
Subscribed Topics
- 
target_found(cpswarm_msgs/TargetPositionEvent) Position and ID of a target detected by the target monitor. Only subscribed whensingle_targetis set totrue. 
Services Called
- 
area/get_area(cpswarm_msgs/GetPoints) Get the area polygon. - 
obstacle_detection/get_clear_sector(cpswarm_msgs/GetSector) Get the circular sector that is clear of obstacles. 
Parameters
- 
~loop_rate(real, default:5.0) The frequency in Hz at which to run the control loops. - 
~queue_size(integer, default:1) The size of the message queue used for publishing and subscribing to topics. - 
~single_target(boolean, default:true) Whether the algorithm will succeed / terminate once a target has been found. - 
~margin(real, default:0.5) The distance in meter to keep to the environment boundary. - 
/rng_seed(integer, default:0) The seed used for random number generation. In the default case, a random seed is generated. 
Code API
Changelog for package uav_random_direction
1.3.0 (2020-01-03)
1.2.0 (2019-12-29)
- Changed: Refactor library structure
 - Changed: UAVs depart in different directions
 - Changed: Read RNG seed from parameter, use random seed otherwise
 - Changed: Return state aborted once coverage finishes
 - Changed: Check if movement was successful
 - Changed: Targets handled by swarm functions library
 - Fixed: Change direction when obstacle detected
 - Fixed: Correctly handle state of behavior algorithm
 - Fixed: Force C++11
 - Fixed: Returning of target
 - Contributors: Micha Sende
 
1.1.0 (2018-11-12)
- Fixed: Computation of sector occupied by obstacles and other UAVs
 - Contributors: Micha Sende
 
1.0.0 (2018-10-30)
- Initial release of uav_random_direction
 - Contributors: Micha Sende
 
Package Dependencies
System Dependencies
Dependant Packages
| Name | Deps | 
|---|---|
| swarm_behaviors | 
Launch files
- launch/uav_random_direction.launch
                
- 
                    
- id [default: 1]
 - output [default: log]
 
 
 
Messages
Services
Plugins
Recent questions tagged uav_random_direction at Robotics Stack Exchange
         
       | 
      
        uav_random_direction package from swarm_behaviors reposwarm_behaviors_position swarm_behaviors_velocity swarm_behaviors uav_local_coverage uav_optimal_coverage uav_random_direction uav_simple_tracking ugv_random_walk | 
      
         ROS Distro
       | 
    
Package Summary
| Version | 1.3.0 | 
| License | Apache License 2.0 | 
| Build type | CATKIN | 
| Use | RECOMMENDED | 
Repository Summary
| Checkout URI | https://github.com/cpswarm/swarm_behaviors.git | 
| VCS Type | git | 
| VCS Version | kinetic-devel | 
| Last Updated | 2021-02-04 | 
| Dev Status | DEVELOPED | 
| Released | RELEASED | 
| Contributing | 
        
          Help Wanted (-)
        
         Good First Issues (-) Pull Requests to Review (-)  | 
    
Package Description
Additional Links
Maintainers
- Micha Sende
 
Authors
- Micha Sende
 
uav_random_direction
This package performs random direction coverage with an unmanned aerial vehicle (UAV). It is part of the swarm behaviors library.
Dependencies
This package depends on the following message definitions:
The following library packages of the swarm behaviors library are required:
- swarm_behaviors_position
 
The following packages of the swarm functions library are required:
- target_monitor (only if 
single_target=true) 
The following packages of the sensing and actuation library are required:
- area_provider
 - obstacle_detection
 
Further required packages are:
Execution
Run the launch file
roslaunch uav_random_direction uav_random_direction.launch
to launch the uav_random_direction node.
The launch file can be configured with following parameters:
- 
id(integer, default:1) The identifier (ID) of the CPS used for name spacing in simulation. - 
output(string, default:screen) Whether to show the program output (screen) or to write it to a log file (log). 
In the param subdirectory there is the parameter file uav_random_direction.yaml that allows to configure the behavior of the uav_random_direction node.
Nodes
uav_random_direction
The uav_random_direction performs coverage using the random direction algorithm. The random direction is a mathematical movement model, where an agent moves straight forward until it reaches an obstacle or the environment boundary. There, it changes its direction randomly into a direction that is clear of obstacles. When the parameter single_target is set to true, the UAV succeeds once a target has been found and returns the target ID and position.
Action Goal
- 
uav_coverage/goal(cpswarm_msgs/CoverageGoal) A goal that starts the random direction coverage behavior. It contains the altitude at which to operate. 
Action Result
- 
uav_coverage/result(cpswarm_msgs/CoverageResult) ID and position of the target that has been found. 
Subscribed Topics
- 
target_found(cpswarm_msgs/TargetPositionEvent) Position and ID of a target detected by the target monitor. Only subscribed whensingle_targetis set totrue. 
Services Called
- 
area/get_area(cpswarm_msgs/GetPoints) Get the area polygon. - 
obstacle_detection/get_clear_sector(cpswarm_msgs/GetSector) Get the circular sector that is clear of obstacles. 
Parameters
- 
~loop_rate(real, default:5.0) The frequency in Hz at which to run the control loops. - 
~queue_size(integer, default:1) The size of the message queue used for publishing and subscribing to topics. - 
~single_target(boolean, default:true) Whether the algorithm will succeed / terminate once a target has been found. - 
~margin(real, default:0.5) The distance in meter to keep to the environment boundary. - 
/rng_seed(integer, default:0) The seed used for random number generation. In the default case, a random seed is generated. 
Code API
Changelog for package uav_random_direction
1.3.0 (2020-01-03)
1.2.0 (2019-12-29)
- Changed: Refactor library structure
 - Changed: UAVs depart in different directions
 - Changed: Read RNG seed from parameter, use random seed otherwise
 - Changed: Return state aborted once coverage finishes
 - Changed: Check if movement was successful
 - Changed: Targets handled by swarm functions library
 - Fixed: Change direction when obstacle detected
 - Fixed: Correctly handle state of behavior algorithm
 - Fixed: Force C++11
 - Fixed: Returning of target
 - Contributors: Micha Sende
 
1.1.0 (2018-11-12)
- Fixed: Computation of sector occupied by obstacles and other UAVs
 - Contributors: Micha Sende
 
1.0.0 (2018-10-30)
- Initial release of uav_random_direction
 - Contributors: Micha Sende
 
Package Dependencies
System Dependencies
Dependant Packages
| Name | Deps | 
|---|---|
| swarm_behaviors | 
Launch files
- launch/uav_random_direction.launch
                
- 
                    
- id [default: 1]
 - output [default: log]
 
 
 
Messages
Services
Plugins
Recent questions tagged uav_random_direction at Robotics Stack Exchange
         
       | 
      
        uav_random_direction package from swarm_behaviors reposwarm_behaviors_position swarm_behaviors_velocity swarm_behaviors uav_local_coverage uav_optimal_coverage uav_random_direction uav_simple_tracking ugv_random_walk | 
      
         ROS Distro
       | 
    
Package Summary
| Version | 1.3.0 | 
| License | Apache License 2.0 | 
| Build type | CATKIN | 
| Use | RECOMMENDED | 
Repository Summary
| Checkout URI | https://github.com/cpswarm/swarm_behaviors.git | 
| VCS Type | git | 
| VCS Version | kinetic-devel | 
| Last Updated | 2021-02-04 | 
| Dev Status | DEVELOPED | 
| Released | RELEASED | 
| Contributing | 
        
          Help Wanted (-)
        
         Good First Issues (-) Pull Requests to Review (-)  | 
    
Package Description
Additional Links
Maintainers
- Micha Sende
 
Authors
- Micha Sende
 
uav_random_direction
This package performs random direction coverage with an unmanned aerial vehicle (UAV). It is part of the swarm behaviors library.
Dependencies
This package depends on the following message definitions:
The following library packages of the swarm behaviors library are required:
- swarm_behaviors_position
 
The following packages of the swarm functions library are required:
- target_monitor (only if 
single_target=true) 
The following packages of the sensing and actuation library are required:
- area_provider
 - obstacle_detection
 
Further required packages are:
Execution
Run the launch file
roslaunch uav_random_direction uav_random_direction.launch
to launch the uav_random_direction node.
The launch file can be configured with following parameters:
- 
id(integer, default:1) The identifier (ID) of the CPS used for name spacing in simulation. - 
output(string, default:screen) Whether to show the program output (screen) or to write it to a log file (log). 
In the param subdirectory there is the parameter file uav_random_direction.yaml that allows to configure the behavior of the uav_random_direction node.
Nodes
uav_random_direction
The uav_random_direction performs coverage using the random direction algorithm. The random direction is a mathematical movement model, where an agent moves straight forward until it reaches an obstacle or the environment boundary. There, it changes its direction randomly into a direction that is clear of obstacles. When the parameter single_target is set to true, the UAV succeeds once a target has been found and returns the target ID and position.
Action Goal
- 
uav_coverage/goal(cpswarm_msgs/CoverageGoal) A goal that starts the random direction coverage behavior. It contains the altitude at which to operate. 
Action Result
- 
uav_coverage/result(cpswarm_msgs/CoverageResult) ID and position of the target that has been found. 
Subscribed Topics
- 
target_found(cpswarm_msgs/TargetPositionEvent) Position and ID of a target detected by the target monitor. Only subscribed whensingle_targetis set totrue. 
Services Called
- 
area/get_area(cpswarm_msgs/GetPoints) Get the area polygon. - 
obstacle_detection/get_clear_sector(cpswarm_msgs/GetSector) Get the circular sector that is clear of obstacles. 
Parameters
- 
~loop_rate(real, default:5.0) The frequency in Hz at which to run the control loops. - 
~queue_size(integer, default:1) The size of the message queue used for publishing and subscribing to topics. - 
~single_target(boolean, default:true) Whether the algorithm will succeed / terminate once a target has been found. - 
~margin(real, default:0.5) The distance in meter to keep to the environment boundary. - 
/rng_seed(integer, default:0) The seed used for random number generation. In the default case, a random seed is generated. 
Code API
Changelog for package uav_random_direction
1.3.0 (2020-01-03)
1.2.0 (2019-12-29)
- Changed: Refactor library structure
 - Changed: UAVs depart in different directions
 - Changed: Read RNG seed from parameter, use random seed otherwise
 - Changed: Return state aborted once coverage finishes
 - Changed: Check if movement was successful
 - Changed: Targets handled by swarm functions library
 - Fixed: Change direction when obstacle detected
 - Fixed: Correctly handle state of behavior algorithm
 - Fixed: Force C++11
 - Fixed: Returning of target
 - Contributors: Micha Sende
 
1.1.0 (2018-11-12)
- Fixed: Computation of sector occupied by obstacles and other UAVs
 - Contributors: Micha Sende
 
1.0.0 (2018-10-30)
- Initial release of uav_random_direction
 - Contributors: Micha Sende
 
Package Dependencies
System Dependencies
Dependant Packages
| Name | Deps | 
|---|---|
| swarm_behaviors | 
Launch files
- launch/uav_random_direction.launch
                
- 
                    
- id [default: 1]
 - output [default: log]
 
 
 
Messages
Services
Plugins
Recent questions tagged uav_random_direction at Robotics Stack Exchange
         
       | 
      
        uav_random_direction package from swarm_behaviors reposwarm_behaviors_position swarm_behaviors_velocity swarm_behaviors uav_local_coverage uav_optimal_coverage uav_random_direction uav_simple_tracking ugv_random_walk | 
      
         ROS Distro
       | 
    
Package Summary
| Version | 1.3.0 | 
| License | Apache License 2.0 | 
| Build type | CATKIN | 
| Use | RECOMMENDED | 
Repository Summary
| Checkout URI | https://github.com/cpswarm/swarm_behaviors.git | 
| VCS Type | git | 
| VCS Version | kinetic-devel | 
| Last Updated | 2021-02-04 | 
| Dev Status | DEVELOPED | 
| Released | RELEASED | 
| Contributing | 
        
          Help Wanted (-)
        
         Good First Issues (-) Pull Requests to Review (-)  | 
    
Package Description
Additional Links
Maintainers
- Micha Sende
 
Authors
- Micha Sende
 
uav_random_direction
This package performs random direction coverage with an unmanned aerial vehicle (UAV). It is part of the swarm behaviors library.
Dependencies
This package depends on the following message definitions:
The following library packages of the swarm behaviors library are required:
- swarm_behaviors_position
 
The following packages of the swarm functions library are required:
- target_monitor (only if 
single_target=true) 
The following packages of the sensing and actuation library are required:
- area_provider
 - obstacle_detection
 
Further required packages are:
Execution
Run the launch file
roslaunch uav_random_direction uav_random_direction.launch
to launch the uav_random_direction node.
The launch file can be configured with following parameters:
- 
id(integer, default:1) The identifier (ID) of the CPS used for name spacing in simulation. - 
output(string, default:screen) Whether to show the program output (screen) or to write it to a log file (log). 
In the param subdirectory there is the parameter file uav_random_direction.yaml that allows to configure the behavior of the uav_random_direction node.
Nodes
uav_random_direction
The uav_random_direction performs coverage using the random direction algorithm. The random direction is a mathematical movement model, where an agent moves straight forward until it reaches an obstacle or the environment boundary. There, it changes its direction randomly into a direction that is clear of obstacles. When the parameter single_target is set to true, the UAV succeeds once a target has been found and returns the target ID and position.
Action Goal
- 
uav_coverage/goal(cpswarm_msgs/CoverageGoal) A goal that starts the random direction coverage behavior. It contains the altitude at which to operate. 
Action Result
- 
uav_coverage/result(cpswarm_msgs/CoverageResult) ID and position of the target that has been found. 
Subscribed Topics
- 
target_found(cpswarm_msgs/TargetPositionEvent) Position and ID of a target detected by the target monitor. Only subscribed whensingle_targetis set totrue. 
Services Called
- 
area/get_area(cpswarm_msgs/GetPoints) Get the area polygon. - 
obstacle_detection/get_clear_sector(cpswarm_msgs/GetSector) Get the circular sector that is clear of obstacles. 
Parameters
- 
~loop_rate(real, default:5.0) The frequency in Hz at which to run the control loops. - 
~queue_size(integer, default:1) The size of the message queue used for publishing and subscribing to topics. - 
~single_target(boolean, default:true) Whether the algorithm will succeed / terminate once a target has been found. - 
~margin(real, default:0.5) The distance in meter to keep to the environment boundary. - 
/rng_seed(integer, default:0) The seed used for random number generation. In the default case, a random seed is generated. 
Code API
Changelog for package uav_random_direction
1.3.0 (2020-01-03)
1.2.0 (2019-12-29)
- Changed: Refactor library structure
 - Changed: UAVs depart in different directions
 - Changed: Read RNG seed from parameter, use random seed otherwise
 - Changed: Return state aborted once coverage finishes
 - Changed: Check if movement was successful
 - Changed: Targets handled by swarm functions library
 - Fixed: Change direction when obstacle detected
 - Fixed: Correctly handle state of behavior algorithm
 - Fixed: Force C++11
 - Fixed: Returning of target
 - Contributors: Micha Sende
 
1.1.0 (2018-11-12)
- Fixed: Computation of sector occupied by obstacles and other UAVs
 - Contributors: Micha Sende
 
1.0.0 (2018-10-30)
- Initial release of uav_random_direction
 - Contributors: Micha Sende
 
Package Dependencies
System Dependencies
Dependant Packages
| Name | Deps | 
|---|---|
| swarm_behaviors | 
Launch files
- launch/uav_random_direction.launch
                
- 
                    
- id [default: 1]
 - output [default: log]
 
 
 
Messages
Services
Plugins
Recent questions tagged uav_random_direction at Robotics Stack Exchange
         
       | 
      
        uav_random_direction package from swarm_behaviors reposwarm_behaviors_position swarm_behaviors_velocity swarm_behaviors uav_local_coverage uav_optimal_coverage uav_random_direction uav_simple_tracking ugv_random_walk | 
      
         ROS Distro
       | 
    
Package Summary
| Version | 1.3.0 | 
| License | Apache License 2.0 | 
| Build type | CATKIN | 
| Use | RECOMMENDED | 
Repository Summary
| Checkout URI | https://github.com/cpswarm/swarm_behaviors.git | 
| VCS Type | git | 
| VCS Version | kinetic-devel | 
| Last Updated | 2021-02-04 | 
| Dev Status | DEVELOPED | 
| Released | RELEASED | 
| Contributing | 
        
          Help Wanted (-)
        
         Good First Issues (-) Pull Requests to Review (-)  | 
    
Package Description
Additional Links
Maintainers
- Micha Sende
 
Authors
- Micha Sende
 
uav_random_direction
This package performs random direction coverage with an unmanned aerial vehicle (UAV). It is part of the swarm behaviors library.
Dependencies
This package depends on the following message definitions:
The following library packages of the swarm behaviors library are required:
- swarm_behaviors_position
 
The following packages of the swarm functions library are required:
- target_monitor (only if 
single_target=true) 
The following packages of the sensing and actuation library are required:
- area_provider
 - obstacle_detection
 
Further required packages are:
Execution
Run the launch file
roslaunch uav_random_direction uav_random_direction.launch
to launch the uav_random_direction node.
The launch file can be configured with following parameters:
- 
id(integer, default:1) The identifier (ID) of the CPS used for name spacing in simulation. - 
output(string, default:screen) Whether to show the program output (screen) or to write it to a log file (log). 
In the param subdirectory there is the parameter file uav_random_direction.yaml that allows to configure the behavior of the uav_random_direction node.
Nodes
uav_random_direction
The uav_random_direction performs coverage using the random direction algorithm. The random direction is a mathematical movement model, where an agent moves straight forward until it reaches an obstacle or the environment boundary. There, it changes its direction randomly into a direction that is clear of obstacles. When the parameter single_target is set to true, the UAV succeeds once a target has been found and returns the target ID and position.
Action Goal
- 
uav_coverage/goal(cpswarm_msgs/CoverageGoal) A goal that starts the random direction coverage behavior. It contains the altitude at which to operate. 
Action Result
- 
uav_coverage/result(cpswarm_msgs/CoverageResult) ID and position of the target that has been found. 
Subscribed Topics
- 
target_found(cpswarm_msgs/TargetPositionEvent) Position and ID of a target detected by the target monitor. Only subscribed whensingle_targetis set totrue. 
Services Called
- 
area/get_area(cpswarm_msgs/GetPoints) Get the area polygon. - 
obstacle_detection/get_clear_sector(cpswarm_msgs/GetSector) Get the circular sector that is clear of obstacles. 
Parameters
- 
~loop_rate(real, default:5.0) The frequency in Hz at which to run the control loops. - 
~queue_size(integer, default:1) The size of the message queue used for publishing and subscribing to topics. - 
~single_target(boolean, default:true) Whether the algorithm will succeed / terminate once a target has been found. - 
~margin(real, default:0.5) The distance in meter to keep to the environment boundary. - 
/rng_seed(integer, default:0) The seed used for random number generation. In the default case, a random seed is generated. 
Code API
Changelog for package uav_random_direction
1.3.0 (2020-01-03)
1.2.0 (2019-12-29)
- Changed: Refactor library structure
 - Changed: UAVs depart in different directions
 - Changed: Read RNG seed from parameter, use random seed otherwise
 - Changed: Return state aborted once coverage finishes
 - Changed: Check if movement was successful
 - Changed: Targets handled by swarm functions library
 - Fixed: Change direction when obstacle detected
 - Fixed: Correctly handle state of behavior algorithm
 - Fixed: Force C++11
 - Fixed: Returning of target
 - Contributors: Micha Sende
 
1.1.0 (2018-11-12)
- Fixed: Computation of sector occupied by obstacles and other UAVs
 - Contributors: Micha Sende
 
1.0.0 (2018-10-30)
- Initial release of uav_random_direction
 - Contributors: Micha Sende
 
Package Dependencies
System Dependencies
Dependant Packages
| Name | Deps | 
|---|---|
| swarm_behaviors | 
Launch files
- launch/uav_random_direction.launch
                
- 
                    
- id [default: 1]
 - output [default: log]
 
 
 
Messages
Services
Plugins
Recent questions tagged uav_random_direction at Robotics Stack Exchange
         
       | 
      
        uav_random_direction package from swarm_behaviors reposwarm_behaviors_position swarm_behaviors_velocity swarm_behaviors uav_local_coverage uav_optimal_coverage uav_random_direction uav_simple_tracking ugv_random_walk | 
      
         ROS Distro
       | 
    
Package Summary
| Version | 1.3.0 | 
| License | Apache License 2.0 | 
| Build type | CATKIN | 
| Use | RECOMMENDED | 
Repository Summary
| Checkout URI | https://github.com/cpswarm/swarm_behaviors.git | 
| VCS Type | git | 
| VCS Version | kinetic-devel | 
| Last Updated | 2021-02-04 | 
| Dev Status | DEVELOPED | 
| Released | RELEASED | 
| Contributing | 
        
          Help Wanted (-)
        
         Good First Issues (-) Pull Requests to Review (-)  | 
    
Package Description
Additional Links
Maintainers
- Micha Sende
 
Authors
- Micha Sende
 
uav_random_direction
This package performs random direction coverage with an unmanned aerial vehicle (UAV). It is part of the swarm behaviors library.
Dependencies
This package depends on the following message definitions:
The following library packages of the swarm behaviors library are required:
- swarm_behaviors_position
 
The following packages of the swarm functions library are required:
- target_monitor (only if 
single_target=true) 
The following packages of the sensing and actuation library are required:
- area_provider
 - obstacle_detection
 
Further required packages are:
Execution
Run the launch file
roslaunch uav_random_direction uav_random_direction.launch
to launch the uav_random_direction node.
The launch file can be configured with following parameters:
- 
id(integer, default:1) The identifier (ID) of the CPS used for name spacing in simulation. - 
output(string, default:screen) Whether to show the program output (screen) or to write it to a log file (log). 
In the param subdirectory there is the parameter file uav_random_direction.yaml that allows to configure the behavior of the uav_random_direction node.
Nodes
uav_random_direction
The uav_random_direction performs coverage using the random direction algorithm. The random direction is a mathematical movement model, where an agent moves straight forward until it reaches an obstacle or the environment boundary. There, it changes its direction randomly into a direction that is clear of obstacles. When the parameter single_target is set to true, the UAV succeeds once a target has been found and returns the target ID and position.
Action Goal
- 
uav_coverage/goal(cpswarm_msgs/CoverageGoal) A goal that starts the random direction coverage behavior. It contains the altitude at which to operate. 
Action Result
- 
uav_coverage/result(cpswarm_msgs/CoverageResult) ID and position of the target that has been found. 
Subscribed Topics
- 
target_found(cpswarm_msgs/TargetPositionEvent) Position and ID of a target detected by the target monitor. Only subscribed whensingle_targetis set totrue. 
Services Called
- 
area/get_area(cpswarm_msgs/GetPoints) Get the area polygon. - 
obstacle_detection/get_clear_sector(cpswarm_msgs/GetSector) Get the circular sector that is clear of obstacles. 
Parameters
- 
~loop_rate(real, default:5.0) The frequency in Hz at which to run the control loops. - 
~queue_size(integer, default:1) The size of the message queue used for publishing and subscribing to topics. - 
~single_target(boolean, default:true) Whether the algorithm will succeed / terminate once a target has been found. - 
~margin(real, default:0.5) The distance in meter to keep to the environment boundary. - 
/rng_seed(integer, default:0) The seed used for random number generation. In the default case, a random seed is generated. 
Code API
Changelog for package uav_random_direction
1.3.0 (2020-01-03)
1.2.0 (2019-12-29)
- Changed: Refactor library structure
 - Changed: UAVs depart in different directions
 - Changed: Read RNG seed from parameter, use random seed otherwise
 - Changed: Return state aborted once coverage finishes
 - Changed: Check if movement was successful
 - Changed: Targets handled by swarm functions library
 - Fixed: Change direction when obstacle detected
 - Fixed: Correctly handle state of behavior algorithm
 - Fixed: Force C++11
 - Fixed: Returning of target
 - Contributors: Micha Sende
 
1.1.0 (2018-11-12)
- Fixed: Computation of sector occupied by obstacles and other UAVs
 - Contributors: Micha Sende
 
1.0.0 (2018-10-30)
- Initial release of uav_random_direction
 - Contributors: Micha Sende
 
Package Dependencies
System Dependencies
Dependant Packages
| Name | Deps | 
|---|---|
| swarm_behaviors | 
Launch files
- launch/uav_random_direction.launch
                
- 
                    
- id [default: 1]
 - output [default: log]
 
 
 
Messages
Services
Plugins
Recent questions tagged uav_random_direction at Robotics Stack Exchange
         
       | 
      
        uav_random_direction package from swarm_behaviors reposwarm_behaviors_position swarm_behaviors_velocity swarm_behaviors uav_local_coverage uav_optimal_coverage uav_random_direction uav_simple_tracking ugv_random_walk | 
      
         ROS Distro
       | 
    
Package Summary
| Version | 1.3.0 | 
| License | Apache License 2.0 | 
| Build type | CATKIN | 
| Use | RECOMMENDED | 
Repository Summary
| Checkout URI | https://github.com/cpswarm/swarm_behaviors.git | 
| VCS Type | git | 
| VCS Version | kinetic-devel | 
| Last Updated | 2021-02-04 | 
| Dev Status | DEVELOPED | 
| Released | RELEASED | 
| Contributing | 
        
          Help Wanted (-)
        
         Good First Issues (-) Pull Requests to Review (-)  | 
    
Package Description
Additional Links
Maintainers
- Micha Sende
 
Authors
- Micha Sende
 
uav_random_direction
This package performs random direction coverage with an unmanned aerial vehicle (UAV). It is part of the swarm behaviors library.
Dependencies
This package depends on the following message definitions:
The following library packages of the swarm behaviors library are required:
- swarm_behaviors_position
 
The following packages of the swarm functions library are required:
- target_monitor (only if 
single_target=true) 
The following packages of the sensing and actuation library are required:
- area_provider
 - obstacle_detection
 
Further required packages are:
Execution
Run the launch file
roslaunch uav_random_direction uav_random_direction.launch
to launch the uav_random_direction node.
The launch file can be configured with following parameters:
- 
id(integer, default:1) The identifier (ID) of the CPS used for name spacing in simulation. - 
output(string, default:screen) Whether to show the program output (screen) or to write it to a log file (log). 
In the param subdirectory there is the parameter file uav_random_direction.yaml that allows to configure the behavior of the uav_random_direction node.
Nodes
uav_random_direction
The uav_random_direction performs coverage using the random direction algorithm. The random direction is a mathematical movement model, where an agent moves straight forward until it reaches an obstacle or the environment boundary. There, it changes its direction randomly into a direction that is clear of obstacles. When the parameter single_target is set to true, the UAV succeeds once a target has been found and returns the target ID and position.
Action Goal
- 
uav_coverage/goal(cpswarm_msgs/CoverageGoal) A goal that starts the random direction coverage behavior. It contains the altitude at which to operate. 
Action Result
- 
uav_coverage/result(cpswarm_msgs/CoverageResult) ID and position of the target that has been found. 
Subscribed Topics
- 
target_found(cpswarm_msgs/TargetPositionEvent) Position and ID of a target detected by the target monitor. Only subscribed whensingle_targetis set totrue. 
Services Called
- 
area/get_area(cpswarm_msgs/GetPoints) Get the area polygon. - 
obstacle_detection/get_clear_sector(cpswarm_msgs/GetSector) Get the circular sector that is clear of obstacles. 
Parameters
- 
~loop_rate(real, default:5.0) The frequency in Hz at which to run the control loops. - 
~queue_size(integer, default:1) The size of the message queue used for publishing and subscribing to topics. - 
~single_target(boolean, default:true) Whether the algorithm will succeed / terminate once a target has been found. - 
~margin(real, default:0.5) The distance in meter to keep to the environment boundary. - 
/rng_seed(integer, default:0) The seed used for random number generation. In the default case, a random seed is generated. 
Code API
Changelog for package uav_random_direction
1.3.0 (2020-01-03)
1.2.0 (2019-12-29)
- Changed: Refactor library structure
 - Changed: UAVs depart in different directions
 - Changed: Read RNG seed from parameter, use random seed otherwise
 - Changed: Return state aborted once coverage finishes
 - Changed: Check if movement was successful
 - Changed: Targets handled by swarm functions library
 - Fixed: Change direction when obstacle detected
 - Fixed: Correctly handle state of behavior algorithm
 - Fixed: Force C++11
 - Fixed: Returning of target
 - Contributors: Micha Sende
 
1.1.0 (2018-11-12)
- Fixed: Computation of sector occupied by obstacles and other UAVs
 - Contributors: Micha Sende
 
1.0.0 (2018-10-30)
- Initial release of uav_random_direction
 - Contributors: Micha Sende
 
Package Dependencies
System Dependencies
Dependant Packages
| Name | Deps | 
|---|---|
| swarm_behaviors | 
Launch files
- launch/uav_random_direction.launch
                
- 
                    
- id [default: 1]
 - output [default: log]
 
 
 
Messages
Services
Plugins
Recent questions tagged uav_random_direction at Robotics Stack Exchange
         
       | 
      
        uav_random_direction package from swarm_behaviors reposwarm_behaviors_position swarm_behaviors_velocity swarm_behaviors uav_local_coverage uav_optimal_coverage uav_random_direction uav_simple_tracking ugv_random_walk | 
      
         ROS Distro
       | 
    
Package Summary
| Version | 1.3.0 | 
| License | Apache License 2.0 | 
| Build type | CATKIN | 
| Use | RECOMMENDED | 
Repository Summary
| Checkout URI | https://github.com/cpswarm/swarm_behaviors.git | 
| VCS Type | git | 
| VCS Version | kinetic-devel | 
| Last Updated | 2021-02-04 | 
| Dev Status | DEVELOPED | 
| Released | RELEASED | 
| Contributing | 
        
          Help Wanted (-)
        
         Good First Issues (-) Pull Requests to Review (-)  | 
    
Package Description
Additional Links
Maintainers
- Micha Sende
 
Authors
- Micha Sende
 
uav_random_direction
This package performs random direction coverage with an unmanned aerial vehicle (UAV). It is part of the swarm behaviors library.
Dependencies
This package depends on the following message definitions:
The following library packages of the swarm behaviors library are required:
- swarm_behaviors_position
 
The following packages of the swarm functions library are required:
- target_monitor (only if 
single_target=true) 
The following packages of the sensing and actuation library are required:
- area_provider
 - obstacle_detection
 
Further required packages are:
Execution
Run the launch file
roslaunch uav_random_direction uav_random_direction.launch
to launch the uav_random_direction node.
The launch file can be configured with following parameters:
- 
id(integer, default:1) The identifier (ID) of the CPS used for name spacing in simulation. - 
output(string, default:screen) Whether to show the program output (screen) or to write it to a log file (log). 
In the param subdirectory there is the parameter file uav_random_direction.yaml that allows to configure the behavior of the uav_random_direction node.
Nodes
uav_random_direction
The uav_random_direction performs coverage using the random direction algorithm. The random direction is a mathematical movement model, where an agent moves straight forward until it reaches an obstacle or the environment boundary. There, it changes its direction randomly into a direction that is clear of obstacles. When the parameter single_target is set to true, the UAV succeeds once a target has been found and returns the target ID and position.
Action Goal
- 
uav_coverage/goal(cpswarm_msgs/CoverageGoal) A goal that starts the random direction coverage behavior. It contains the altitude at which to operate. 
Action Result
- 
uav_coverage/result(cpswarm_msgs/CoverageResult) ID and position of the target that has been found. 
Subscribed Topics
- 
target_found(cpswarm_msgs/TargetPositionEvent) Position and ID of a target detected by the target monitor. Only subscribed whensingle_targetis set totrue. 
Services Called
- 
area/get_area(cpswarm_msgs/GetPoints) Get the area polygon. - 
obstacle_detection/get_clear_sector(cpswarm_msgs/GetSector) Get the circular sector that is clear of obstacles. 
Parameters
- 
~loop_rate(real, default:5.0) The frequency in Hz at which to run the control loops. - 
~queue_size(integer, default:1) The size of the message queue used for publishing and subscribing to topics. - 
~single_target(boolean, default:true) Whether the algorithm will succeed / terminate once a target has been found. - 
~margin(real, default:0.5) The distance in meter to keep to the environment boundary. - 
/rng_seed(integer, default:0) The seed used for random number generation. In the default case, a random seed is generated. 
Code API
Changelog for package uav_random_direction
1.3.0 (2020-01-03)
1.2.0 (2019-12-29)
- Changed: Refactor library structure
 - Changed: UAVs depart in different directions
 - Changed: Read RNG seed from parameter, use random seed otherwise
 - Changed: Return state aborted once coverage finishes
 - Changed: Check if movement was successful
 - Changed: Targets handled by swarm functions library
 - Fixed: Change direction when obstacle detected
 - Fixed: Correctly handle state of behavior algorithm
 - Fixed: Force C++11
 - Fixed: Returning of target
 - Contributors: Micha Sende
 
1.1.0 (2018-11-12)
- Fixed: Computation of sector occupied by obstacles and other UAVs
 - Contributors: Micha Sende
 
1.0.0 (2018-10-30)
- Initial release of uav_random_direction
 - Contributors: Micha Sende
 
Package Dependencies
System Dependencies
Dependant Packages
| Name | Deps | 
|---|---|
| swarm_behaviors | 
Launch files
- launch/uav_random_direction.launch
                
- 
                    
- id [default: 1]
 - output [default: log]
 
 
 
Messages
Services
Plugins
Recent questions tagged uav_random_direction at Robotics Stack Exchange
         
       | 
      
        uav_random_direction package from swarm_behaviors reposwarm_behaviors_position swarm_behaviors_velocity swarm_behaviors uav_local_coverage uav_optimal_coverage uav_random_direction uav_simple_tracking ugv_random_walk | 
      
         ROS Distro
       | 
    
Package Summary
| Version | 1.3.0 | 
| License | Apache License 2.0 | 
| Build type | CATKIN | 
| Use | RECOMMENDED | 
Repository Summary
| Checkout URI | https://github.com/cpswarm/swarm_behaviors.git | 
| VCS Type | git | 
| VCS Version | kinetic-devel | 
| Last Updated | 2021-02-04 | 
| Dev Status | DEVELOPED | 
| Released | RELEASED | 
| Contributing | 
        
          Help Wanted (-)
        
         Good First Issues (-) Pull Requests to Review (-)  | 
    
Package Description
Additional Links
Maintainers
- Micha Sende
 
Authors
- Micha Sende
 
uav_random_direction
This package performs random direction coverage with an unmanned aerial vehicle (UAV). It is part of the swarm behaviors library.
Dependencies
This package depends on the following message definitions:
The following library packages of the swarm behaviors library are required:
- swarm_behaviors_position
 
The following packages of the swarm functions library are required:
- target_monitor (only if 
single_target=true) 
The following packages of the sensing and actuation library are required:
- area_provider
 - obstacle_detection
 
Further required packages are:
Execution
Run the launch file
roslaunch uav_random_direction uav_random_direction.launch
to launch the uav_random_direction node.
The launch file can be configured with following parameters:
- 
id(integer, default:1) The identifier (ID) of the CPS used for name spacing in simulation. - 
output(string, default:screen) Whether to show the program output (screen) or to write it to a log file (log). 
In the param subdirectory there is the parameter file uav_random_direction.yaml that allows to configure the behavior of the uav_random_direction node.
Nodes
uav_random_direction
The uav_random_direction performs coverage using the random direction algorithm. The random direction is a mathematical movement model, where an agent moves straight forward until it reaches an obstacle or the environment boundary. There, it changes its direction randomly into a direction that is clear of obstacles. When the parameter single_target is set to true, the UAV succeeds once a target has been found and returns the target ID and position.
Action Goal
- 
uav_coverage/goal(cpswarm_msgs/CoverageGoal) A goal that starts the random direction coverage behavior. It contains the altitude at which to operate. 
Action Result
- 
uav_coverage/result(cpswarm_msgs/CoverageResult) ID and position of the target that has been found. 
Subscribed Topics
- 
target_found(cpswarm_msgs/TargetPositionEvent) Position and ID of a target detected by the target monitor. Only subscribed whensingle_targetis set totrue. 
Services Called
- 
area/get_area(cpswarm_msgs/GetPoints) Get the area polygon. - 
obstacle_detection/get_clear_sector(cpswarm_msgs/GetSector) Get the circular sector that is clear of obstacles. 
Parameters
- 
~loop_rate(real, default:5.0) The frequency in Hz at which to run the control loops. - 
~queue_size(integer, default:1) The size of the message queue used for publishing and subscribing to topics. - 
~single_target(boolean, default:true) Whether the algorithm will succeed / terminate once a target has been found. - 
~margin(real, default:0.5) The distance in meter to keep to the environment boundary. - 
/rng_seed(integer, default:0) The seed used for random number generation. In the default case, a random seed is generated. 
Code API
Changelog for package uav_random_direction
1.3.0 (2020-01-03)
1.2.0 (2019-12-29)
- Changed: Refactor library structure
 - Changed: UAVs depart in different directions
 - Changed: Read RNG seed from parameter, use random seed otherwise
 - Changed: Return state aborted once coverage finishes
 - Changed: Check if movement was successful
 - Changed: Targets handled by swarm functions library
 - Fixed: Change direction when obstacle detected
 - Fixed: Correctly handle state of behavior algorithm
 - Fixed: Force C++11
 - Fixed: Returning of target
 - Contributors: Micha Sende
 
1.1.0 (2018-11-12)
- Fixed: Computation of sector occupied by obstacles and other UAVs
 - Contributors: Micha Sende
 
1.0.0 (2018-10-30)
- Initial release of uav_random_direction
 - Contributors: Micha Sende
 
Package Dependencies
System Dependencies
Dependant Packages
| Name | Deps | 
|---|---|
| swarm_behaviors | 
Launch files
- launch/uav_random_direction.launch
                
- 
                    
- id [default: 1]
 - output [default: log]
 
 
 
Messages
Services
Plugins
Recent questions tagged uav_random_direction at Robotics Stack Exchange
         
       | 
      
        uav_random_direction package from swarm_behaviors reposwarm_behaviors_position swarm_behaviors_velocity swarm_behaviors uav_local_coverage uav_optimal_coverage uav_random_direction uav_simple_tracking ugv_random_walk | 
      
         ROS Distro
       | 
    
Package Summary
| Version | 1.3.0 | 
| License | Apache License 2.0 | 
| Build type | CATKIN | 
| Use | RECOMMENDED | 
Repository Summary
| Checkout URI | https://github.com/cpswarm/swarm_behaviors.git | 
| VCS Type | git | 
| VCS Version | kinetic-devel | 
| Last Updated | 2021-02-04 | 
| Dev Status | DEVELOPED | 
| Released | RELEASED | 
| Contributing | 
        
          Help Wanted (-)
        
         Good First Issues (-) Pull Requests to Review (-)  | 
    
Package Description
Additional Links
Maintainers
- Micha Sende
 
Authors
- Micha Sende
 
uav_random_direction
This package performs random direction coverage with an unmanned aerial vehicle (UAV). It is part of the swarm behaviors library.
Dependencies
This package depends on the following message definitions:
The following library packages of the swarm behaviors library are required:
- swarm_behaviors_position
 
The following packages of the swarm functions library are required:
- target_monitor (only if 
single_target=true) 
The following packages of the sensing and actuation library are required:
- area_provider
 - obstacle_detection
 
Further required packages are:
Execution
Run the launch file
roslaunch uav_random_direction uav_random_direction.launch
to launch the uav_random_direction node.
The launch file can be configured with following parameters:
- 
id(integer, default:1) The identifier (ID) of the CPS used for name spacing in simulation. - 
output(string, default:screen) Whether to show the program output (screen) or to write it to a log file (log). 
In the param subdirectory there is the parameter file uav_random_direction.yaml that allows to configure the behavior of the uav_random_direction node.
Nodes
uav_random_direction
The uav_random_direction performs coverage using the random direction algorithm. The random direction is a mathematical movement model, where an agent moves straight forward until it reaches an obstacle or the environment boundary. There, it changes its direction randomly into a direction that is clear of obstacles. When the parameter single_target is set to true, the UAV succeeds once a target has been found and returns the target ID and position.
Action Goal
- 
uav_coverage/goal(cpswarm_msgs/CoverageGoal) A goal that starts the random direction coverage behavior. It contains the altitude at which to operate. 
Action Result
- 
uav_coverage/result(cpswarm_msgs/CoverageResult) ID and position of the target that has been found. 
Subscribed Topics
- 
target_found(cpswarm_msgs/TargetPositionEvent) Position and ID of a target detected by the target monitor. Only subscribed whensingle_targetis set totrue. 
Services Called
- 
area/get_area(cpswarm_msgs/GetPoints) Get the area polygon. - 
obstacle_detection/get_clear_sector(cpswarm_msgs/GetSector) Get the circular sector that is clear of obstacles. 
Parameters
- 
~loop_rate(real, default:5.0) The frequency in Hz at which to run the control loops. - 
~queue_size(integer, default:1) The size of the message queue used for publishing and subscribing to topics. - 
~single_target(boolean, default:true) Whether the algorithm will succeed / terminate once a target has been found. - 
~margin(real, default:0.5) The distance in meter to keep to the environment boundary. - 
/rng_seed(integer, default:0) The seed used for random number generation. In the default case, a random seed is generated. 
Code API
Changelog for package uav_random_direction
1.3.0 (2020-01-03)
1.2.0 (2019-12-29)
- Changed: Refactor library structure
 - Changed: UAVs depart in different directions
 - Changed: Read RNG seed from parameter, use random seed otherwise
 - Changed: Return state aborted once coverage finishes
 - Changed: Check if movement was successful
 - Changed: Targets handled by swarm functions library
 - Fixed: Change direction when obstacle detected
 - Fixed: Correctly handle state of behavior algorithm
 - Fixed: Force C++11
 - Fixed: Returning of target
 - Contributors: Micha Sende
 
1.1.0 (2018-11-12)
- Fixed: Computation of sector occupied by obstacles and other UAVs
 - Contributors: Micha Sende
 
1.0.0 (2018-10-30)
- Initial release of uav_random_direction
 - Contributors: Micha Sende
 
Package Dependencies
System Dependencies
Dependant Packages
| Name | Deps | 
|---|---|
| swarm_behaviors | 
Launch files
- launch/uav_random_direction.launch
                
- 
                    
- id [default: 1]
 - output [default: log]
 
 
 
Messages
Services
Plugins
Recent questions tagged uav_random_direction at Robotics Stack Exchange
         
       | 
      
        uav_random_direction package from swarm_behaviors reposwarm_behaviors_position swarm_behaviors_velocity swarm_behaviors uav_local_coverage uav_optimal_coverage uav_random_direction uav_simple_tracking ugv_random_walk | 
      
         ROS Distro
       | 
    
Package Summary
| Version | 1.3.0 | 
| License | Apache License 2.0 | 
| Build type | CATKIN | 
| Use | RECOMMENDED | 
Repository Summary
| Checkout URI | https://github.com/cpswarm/swarm_behaviors.git | 
| VCS Type | git | 
| VCS Version | kinetic-devel | 
| Last Updated | 2021-02-04 | 
| Dev Status | DEVELOPED | 
| Released | RELEASED | 
| Contributing | 
        
          Help Wanted (-)
        
         Good First Issues (-) Pull Requests to Review (-)  | 
    
Package Description
Additional Links
Maintainers
- Micha Sende
 
Authors
- Micha Sende
 
uav_random_direction
This package performs random direction coverage with an unmanned aerial vehicle (UAV). It is part of the swarm behaviors library.
Dependencies
This package depends on the following message definitions:
The following library packages of the swarm behaviors library are required:
- swarm_behaviors_position
 
The following packages of the swarm functions library are required:
- target_monitor (only if 
single_target=true) 
The following packages of the sensing and actuation library are required:
- area_provider
 - obstacle_detection
 
Further required packages are:
Execution
Run the launch file
roslaunch uav_random_direction uav_random_direction.launch
to launch the uav_random_direction node.
The launch file can be configured with following parameters:
- 
id(integer, default:1) The identifier (ID) of the CPS used for name spacing in simulation. - 
output(string, default:screen) Whether to show the program output (screen) or to write it to a log file (log). 
In the param subdirectory there is the parameter file uav_random_direction.yaml that allows to configure the behavior of the uav_random_direction node.
Nodes
uav_random_direction
The uav_random_direction performs coverage using the random direction algorithm. The random direction is a mathematical movement model, where an agent moves straight forward until it reaches an obstacle or the environment boundary. There, it changes its direction randomly into a direction that is clear of obstacles. When the parameter single_target is set to true, the UAV succeeds once a target has been found and returns the target ID and position.
Action Goal
- 
uav_coverage/goal(cpswarm_msgs/CoverageGoal) A goal that starts the random direction coverage behavior. It contains the altitude at which to operate. 
Action Result
- 
uav_coverage/result(cpswarm_msgs/CoverageResult) ID and position of the target that has been found. 
Subscribed Topics
- 
target_found(cpswarm_msgs/TargetPositionEvent) Position and ID of a target detected by the target monitor. Only subscribed whensingle_targetis set totrue. 
Services Called
- 
area/get_area(cpswarm_msgs/GetPoints) Get the area polygon. - 
obstacle_detection/get_clear_sector(cpswarm_msgs/GetSector) Get the circular sector that is clear of obstacles. 
Parameters
- 
~loop_rate(real, default:5.0) The frequency in Hz at which to run the control loops. - 
~queue_size(integer, default:1) The size of the message queue used for publishing and subscribing to topics. - 
~single_target(boolean, default:true) Whether the algorithm will succeed / terminate once a target has been found. - 
~margin(real, default:0.5) The distance in meter to keep to the environment boundary. - 
/rng_seed(integer, default:0) The seed used for random number generation. In the default case, a random seed is generated. 
Code API
Changelog for package uav_random_direction
1.3.0 (2020-01-03)
1.2.0 (2019-12-29)
- Changed: Refactor library structure
 - Changed: UAVs depart in different directions
 - Changed: Read RNG seed from parameter, use random seed otherwise
 - Changed: Return state aborted once coverage finishes
 - Changed: Check if movement was successful
 - Changed: Targets handled by swarm functions library
 - Fixed: Change direction when obstacle detected
 - Fixed: Correctly handle state of behavior algorithm
 - Fixed: Force C++11
 - Fixed: Returning of target
 - Contributors: Micha Sende
 
1.1.0 (2018-11-12)
- Fixed: Computation of sector occupied by obstacles and other UAVs
 - Contributors: Micha Sende
 
1.0.0 (2018-10-30)
- Initial release of uav_random_direction
 - Contributors: Micha Sende
 
Package Dependencies
System Dependencies
Dependant Packages
| Name | Deps | 
|---|---|
| swarm_behaviors | 
Launch files
- launch/uav_random_direction.launch
                
- 
                    
- id [default: 1]
 - output [default: log]
 
 
 
Messages
Services
Plugins
Recent questions tagged uav_random_direction at Robotics Stack Exchange
         
       | 
      
        uav_random_direction package from swarm_behaviors reposwarm_behaviors_position swarm_behaviors_velocity swarm_behaviors uav_local_coverage uav_optimal_coverage uav_random_direction uav_simple_tracking ugv_random_walk | 
      
         ROS Distro
       | 
    
Package Summary
| Version | 1.3.0 | 
| License | Apache License 2.0 | 
| Build type | CATKIN | 
| Use | RECOMMENDED | 
Repository Summary
| Checkout URI | https://github.com/cpswarm/swarm_behaviors.git | 
| VCS Type | git | 
| VCS Version | kinetic-devel | 
| Last Updated | 2021-02-04 | 
| Dev Status | DEVELOPED | 
| Released | RELEASED | 
| Contributing | 
        
          Help Wanted (-)
        
         Good First Issues (-) Pull Requests to Review (-)  | 
    
Package Description
Additional Links
Maintainers
- Micha Sende
 
Authors
- Micha Sende
 
uav_random_direction
This package performs random direction coverage with an unmanned aerial vehicle (UAV). It is part of the swarm behaviors library.
Dependencies
This package depends on the following message definitions:
The following library packages of the swarm behaviors library are required:
- swarm_behaviors_position
 
The following packages of the swarm functions library are required:
- target_monitor (only if 
single_target=true) 
The following packages of the sensing and actuation library are required:
- area_provider
 - obstacle_detection
 
Further required packages are:
Execution
Run the launch file
roslaunch uav_random_direction uav_random_direction.launch
to launch the uav_random_direction node.
The launch file can be configured with following parameters:
- 
id(integer, default:1) The identifier (ID) of the CPS used for name spacing in simulation. - 
output(string, default:screen) Whether to show the program output (screen) or to write it to a log file (log). 
In the param subdirectory there is the parameter file uav_random_direction.yaml that allows to configure the behavior of the uav_random_direction node.
Nodes
uav_random_direction
The uav_random_direction performs coverage using the random direction algorithm. The random direction is a mathematical movement model, where an agent moves straight forward until it reaches an obstacle or the environment boundary. There, it changes its direction randomly into a direction that is clear of obstacles. When the parameter single_target is set to true, the UAV succeeds once a target has been found and returns the target ID and position.
Action Goal
- 
uav_coverage/goal(cpswarm_msgs/CoverageGoal) A goal that starts the random direction coverage behavior. It contains the altitude at which to operate. 
Action Result
- 
uav_coverage/result(cpswarm_msgs/CoverageResult) ID and position of the target that has been found. 
Subscribed Topics
- 
target_found(cpswarm_msgs/TargetPositionEvent) Position and ID of a target detected by the target monitor. Only subscribed whensingle_targetis set totrue. 
Services Called
- 
area/get_area(cpswarm_msgs/GetPoints) Get the area polygon. - 
obstacle_detection/get_clear_sector(cpswarm_msgs/GetSector) Get the circular sector that is clear of obstacles. 
Parameters
- 
~loop_rate(real, default:5.0) The frequency in Hz at which to run the control loops. - 
~queue_size(integer, default:1) The size of the message queue used for publishing and subscribing to topics. - 
~single_target(boolean, default:true) Whether the algorithm will succeed / terminate once a target has been found. - 
~margin(real, default:0.5) The distance in meter to keep to the environment boundary. - 
/rng_seed(integer, default:0) The seed used for random number generation. In the default case, a random seed is generated. 
Code API
Changelog for package uav_random_direction
1.3.0 (2020-01-03)
1.2.0 (2019-12-29)
- Changed: Refactor library structure
 - Changed: UAVs depart in different directions
 - Changed: Read RNG seed from parameter, use random seed otherwise
 - Changed: Return state aborted once coverage finishes
 - Changed: Check if movement was successful
 - Changed: Targets handled by swarm functions library
 - Fixed: Change direction when obstacle detected
 - Fixed: Correctly handle state of behavior algorithm
 - Fixed: Force C++11
 - Fixed: Returning of target
 - Contributors: Micha Sende
 
1.1.0 (2018-11-12)
- Fixed: Computation of sector occupied by obstacles and other UAVs
 - Contributors: Micha Sende
 
1.0.0 (2018-10-30)
- Initial release of uav_random_direction
 - Contributors: Micha Sende
 
Package Dependencies
System Dependencies
Dependant Packages
| Name | Deps | 
|---|---|
| swarm_behaviors | 
Launch files
- launch/uav_random_direction.launch
                
- 
                    
- id [default: 1]
 - output [default: log]
 
 
 
Messages
Services
Plugins
Recent questions tagged uav_random_direction at Robotics Stack Exchange
         
       | 
      
        uav_random_direction package from swarm_behaviors reposwarm_behaviors_position swarm_behaviors_velocity swarm_behaviors uav_local_coverage uav_optimal_coverage uav_random_direction uav_simple_tracking ugv_random_walk | 
      
         ROS Distro
       | 
    
Package Summary
| Version | 1.3.0 | 
| License | Apache License 2.0 | 
| Build type | CATKIN | 
| Use | RECOMMENDED | 
Repository Summary
| Checkout URI | https://github.com/cpswarm/swarm_behaviors.git | 
| VCS Type | git | 
| VCS Version | kinetic-devel | 
| Last Updated | 2021-02-04 | 
| Dev Status | DEVELOPED | 
| Released | RELEASED | 
| Contributing | 
        
          Help Wanted (-)
        
         Good First Issues (-) Pull Requests to Review (-)  | 
    
Package Description
Additional Links
Maintainers
- Micha Sende
 
Authors
- Micha Sende
 
uav_random_direction
This package performs random direction coverage with an unmanned aerial vehicle (UAV). It is part of the swarm behaviors library.
Dependencies
This package depends on the following message definitions:
The following library packages of the swarm behaviors library are required:
- swarm_behaviors_position
 
The following packages of the swarm functions library are required:
- target_monitor (only if 
single_target=true) 
The following packages of the sensing and actuation library are required:
- area_provider
 - obstacle_detection
 
Further required packages are:
Execution
Run the launch file
roslaunch uav_random_direction uav_random_direction.launch
to launch the uav_random_direction node.
The launch file can be configured with following parameters:
- 
id(integer, default:1) The identifier (ID) of the CPS used for name spacing in simulation. - 
output(string, default:screen) Whether to show the program output (screen) or to write it to a log file (log). 
In the param subdirectory there is the parameter file uav_random_direction.yaml that allows to configure the behavior of the uav_random_direction node.
Nodes
uav_random_direction
The uav_random_direction performs coverage using the random direction algorithm. The random direction is a mathematical movement model, where an agent moves straight forward until it reaches an obstacle or the environment boundary. There, it changes its direction randomly into a direction that is clear of obstacles. When the parameter single_target is set to true, the UAV succeeds once a target has been found and returns the target ID and position.
Action Goal
- 
uav_coverage/goal(cpswarm_msgs/CoverageGoal) A goal that starts the random direction coverage behavior. It contains the altitude at which to operate. 
Action Result
- 
uav_coverage/result(cpswarm_msgs/CoverageResult) ID and position of the target that has been found. 
Subscribed Topics
- 
target_found(cpswarm_msgs/TargetPositionEvent) Position and ID of a target detected by the target monitor. Only subscribed whensingle_targetis set totrue. 
Services Called
- 
area/get_area(cpswarm_msgs/GetPoints) Get the area polygon. - 
obstacle_detection/get_clear_sector(cpswarm_msgs/GetSector) Get the circular sector that is clear of obstacles. 
Parameters
- 
~loop_rate(real, default:5.0) The frequency in Hz at which to run the control loops. - 
~queue_size(integer, default:1) The size of the message queue used for publishing and subscribing to topics. - 
~single_target(boolean, default:true) Whether the algorithm will succeed / terminate once a target has been found. - 
~margin(real, default:0.5) The distance in meter to keep to the environment boundary. - 
/rng_seed(integer, default:0) The seed used for random number generation. In the default case, a random seed is generated. 
Code API
Changelog for package uav_random_direction
1.3.0 (2020-01-03)
1.2.0 (2019-12-29)
- Changed: Refactor library structure
 - Changed: UAVs depart in different directions
 - Changed: Read RNG seed from parameter, use random seed otherwise
 - Changed: Return state aborted once coverage finishes
 - Changed: Check if movement was successful
 - Changed: Targets handled by swarm functions library
 - Fixed: Change direction when obstacle detected
 - Fixed: Correctly handle state of behavior algorithm
 - Fixed: Force C++11
 - Fixed: Returning of target
 - Contributors: Micha Sende
 
1.1.0 (2018-11-12)
- Fixed: Computation of sector occupied by obstacles and other UAVs
 - Contributors: Micha Sende
 
1.0.0 (2018-10-30)
- Initial release of uav_random_direction
 - Contributors: Micha Sende
 
Package Dependencies
System Dependencies
Dependant Packages
| Name | Deps | 
|---|---|
| swarm_behaviors | 
Launch files
- launch/uav_random_direction.launch
                
- 
                    
- id [default: 1]
 - output [default: log]
 
 
 
Messages
Services
Plugins
Recent questions tagged uav_random_direction at Robotics Stack Exchange
         
       | 
      
        uav_random_direction package from swarm_behaviors reposwarm_behaviors_position swarm_behaviors_velocity swarm_behaviors uav_local_coverage uav_optimal_coverage uav_random_direction uav_simple_tracking ugv_random_walk | 
      
         ROS Distro
       | 
    
Package Summary
| Version | 1.3.0 | 
| License | Apache License 2.0 | 
| Build type | CATKIN | 
| Use | RECOMMENDED | 
Repository Summary
| Checkout URI | https://github.com/cpswarm/swarm_behaviors.git | 
| VCS Type | git | 
| VCS Version | kinetic-devel | 
| Last Updated | 2021-02-04 | 
| Dev Status | DEVELOPED | 
| Released | RELEASED | 
| Contributing | 
        
          Help Wanted (-)
        
         Good First Issues (-) Pull Requests to Review (-)  | 
    
Package Description
Additional Links
Maintainers
- Micha Sende
 
Authors
- Micha Sende
 
uav_random_direction
This package performs random direction coverage with an unmanned aerial vehicle (UAV). It is part of the swarm behaviors library.
Dependencies
This package depends on the following message definitions:
The following library packages of the swarm behaviors library are required:
- swarm_behaviors_position
 
The following packages of the swarm functions library are required:
- target_monitor (only if 
single_target=true) 
The following packages of the sensing and actuation library are required:
- area_provider
 - obstacle_detection
 
Further required packages are:
Execution
Run the launch file
roslaunch uav_random_direction uav_random_direction.launch
to launch the uav_random_direction node.
The launch file can be configured with following parameters:
- 
id(integer, default:1) The identifier (ID) of the CPS used for name spacing in simulation. - 
output(string, default:screen) Whether to show the program output (screen) or to write it to a log file (log). 
In the param subdirectory there is the parameter file uav_random_direction.yaml that allows to configure the behavior of the uav_random_direction node.
Nodes
uav_random_direction
The uav_random_direction performs coverage using the random direction algorithm. The random direction is a mathematical movement model, where an agent moves straight forward until it reaches an obstacle or the environment boundary. There, it changes its direction randomly into a direction that is clear of obstacles. When the parameter single_target is set to true, the UAV succeeds once a target has been found and returns the target ID and position.
Action Goal
- 
uav_coverage/goal(cpswarm_msgs/CoverageGoal) A goal that starts the random direction coverage behavior. It contains the altitude at which to operate. 
Action Result
- 
uav_coverage/result(cpswarm_msgs/CoverageResult) ID and position of the target that has been found. 
Subscribed Topics
- 
target_found(cpswarm_msgs/TargetPositionEvent) Position and ID of a target detected by the target monitor. Only subscribed whensingle_targetis set totrue. 
Services Called
- 
area/get_area(cpswarm_msgs/GetPoints) Get the area polygon. - 
obstacle_detection/get_clear_sector(cpswarm_msgs/GetSector) Get the circular sector that is clear of obstacles. 
Parameters
- 
~loop_rate(real, default:5.0) The frequency in Hz at which to run the control loops. - 
~queue_size(integer, default:1) The size of the message queue used for publishing and subscribing to topics. - 
~single_target(boolean, default:true) Whether the algorithm will succeed / terminate once a target has been found. - 
~margin(real, default:0.5) The distance in meter to keep to the environment boundary. - 
/rng_seed(integer, default:0) The seed used for random number generation. In the default case, a random seed is generated. 
Code API
Changelog for package uav_random_direction
1.3.0 (2020-01-03)
1.2.0 (2019-12-29)
- Changed: Refactor library structure
 - Changed: UAVs depart in different directions
 - Changed: Read RNG seed from parameter, use random seed otherwise
 - Changed: Return state aborted once coverage finishes
 - Changed: Check if movement was successful
 - Changed: Targets handled by swarm functions library
 - Fixed: Change direction when obstacle detected
 - Fixed: Correctly handle state of behavior algorithm
 - Fixed: Force C++11
 - Fixed: Returning of target
 - Contributors: Micha Sende
 
1.1.0 (2018-11-12)
- Fixed: Computation of sector occupied by obstacles and other UAVs
 - Contributors: Micha Sende
 
1.0.0 (2018-10-30)
- Initial release of uav_random_direction
 - Contributors: Micha Sende
 
Package Dependencies
System Dependencies
Dependant Packages
| Name | Deps | 
|---|---|
| swarm_behaviors | 
Launch files
- launch/uav_random_direction.launch
                
- 
                    
- id [default: 1]
 - output [default: log]
 
 
 
Messages
Services
Plugins
Recent questions tagged uav_random_direction at Robotics Stack Exchange
         
       | 
      
        uav_random_direction package from swarm_behaviors reposwarm_behaviors_position swarm_behaviors_velocity swarm_behaviors uav_local_coverage uav_optimal_coverage uav_random_direction uav_simple_tracking ugv_random_walk | 
      
         ROS Distro
       | 
    
Package Summary
| Version | 1.3.0 | 
| License | Apache License 2.0 | 
| Build type | CATKIN | 
| Use | RECOMMENDED | 
Repository Summary
| Checkout URI | https://github.com/cpswarm/swarm_behaviors.git | 
| VCS Type | git | 
| VCS Version | kinetic-devel | 
| Last Updated | 2021-02-04 | 
| Dev Status | DEVELOPED | 
| Released | RELEASED | 
| Contributing | 
        
          Help Wanted (-)
        
         Good First Issues (-) Pull Requests to Review (-)  | 
    
Package Description
Additional Links
Maintainers
- Micha Sende
 
Authors
- Micha Sende
 
uav_random_direction
This package performs random direction coverage with an unmanned aerial vehicle (UAV). It is part of the swarm behaviors library.
Dependencies
This package depends on the following message definitions:
The following library packages of the swarm behaviors library are required:
- swarm_behaviors_position
 
The following packages of the swarm functions library are required:
- target_monitor (only if 
single_target=true) 
The following packages of the sensing and actuation library are required:
- area_provider
 - obstacle_detection
 
Further required packages are:
Execution
Run the launch file
roslaunch uav_random_direction uav_random_direction.launch
to launch the uav_random_direction node.
The launch file can be configured with following parameters:
- 
id(integer, default:1) The identifier (ID) of the CPS used for name spacing in simulation. - 
output(string, default:screen) Whether to show the program output (screen) or to write it to a log file (log). 
In the param subdirectory there is the parameter file uav_random_direction.yaml that allows to configure the behavior of the uav_random_direction node.
Nodes
uav_random_direction
The uav_random_direction performs coverage using the random direction algorithm. The random direction is a mathematical movement model, where an agent moves straight forward until it reaches an obstacle or the environment boundary. There, it changes its direction randomly into a direction that is clear of obstacles. When the parameter single_target is set to true, the UAV succeeds once a target has been found and returns the target ID and position.
Action Goal
- 
uav_coverage/goal(cpswarm_msgs/CoverageGoal) A goal that starts the random direction coverage behavior. It contains the altitude at which to operate. 
Action Result
- 
uav_coverage/result(cpswarm_msgs/CoverageResult) ID and position of the target that has been found. 
Subscribed Topics
- 
target_found(cpswarm_msgs/TargetPositionEvent) Position and ID of a target detected by the target monitor. Only subscribed whensingle_targetis set totrue. 
Services Called
- 
area/get_area(cpswarm_msgs/GetPoints) Get the area polygon. - 
obstacle_detection/get_clear_sector(cpswarm_msgs/GetSector) Get the circular sector that is clear of obstacles. 
Parameters
- 
~loop_rate(real, default:5.0) The frequency in Hz at which to run the control loops. - 
~queue_size(integer, default:1) The size of the message queue used for publishing and subscribing to topics. - 
~single_target(boolean, default:true) Whether the algorithm will succeed / terminate once a target has been found. - 
~margin(real, default:0.5) The distance in meter to keep to the environment boundary. - 
/rng_seed(integer, default:0) The seed used for random number generation. In the default case, a random seed is generated. 
Code API
Changelog for package uav_random_direction
1.3.0 (2020-01-03)
1.2.0 (2019-12-29)
- Changed: Refactor library structure
 - Changed: UAVs depart in different directions
 - Changed: Read RNG seed from parameter, use random seed otherwise
 - Changed: Return state aborted once coverage finishes
 - Changed: Check if movement was successful
 - Changed: Targets handled by swarm functions library
 - Fixed: Change direction when obstacle detected
 - Fixed: Correctly handle state of behavior algorithm
 - Fixed: Force C++11
 - Fixed: Returning of target
 - Contributors: Micha Sende
 
1.1.0 (2018-11-12)
- Fixed: Computation of sector occupied by obstacles and other UAVs
 - Contributors: Micha Sende
 
1.0.0 (2018-10-30)
- Initial release of uav_random_direction
 - Contributors: Micha Sende
 
Package Dependencies
System Dependencies
Dependant Packages
| Name | Deps | 
|---|---|
| swarm_behaviors | 
Launch files
- launch/uav_random_direction.launch
                
- 
                    
- id [default: 1]
 - output [default: log]