Navigation in ROS2 - Versionsgeschichte

Ajay Paul am 9. Januar 2023 um 22:54 Uhr

2023-01-09T22:54:03Z

← Nächstältere Version		Version vom 9. Januar 2023, 22:54 Uhr
Zeile 66:		Zeile 66:
	Example of YAML File of the Map.		Example of YAML File of the Map.

	image: ~~turtlebot_area~~.pgm		image: alphabot_area.pgm
	mode: trinary		mode: trinary
	resolution: 0.05		resolution: 0.05

Ajay Paul: /* Obstacle Avoidance in ROS2 */

2023-01-09T15:30:08Z

Obstacle Avoidance in ROS2

← Nächstältere Version		Version vom 9. Januar 2023, 15:30 Uhr
Zeile 309:		Zeile 309:

	==== <big>Obstacle Avoidance in ROS2</big> ====		==== <big>Obstacle Avoidance in ROS2</big> ====
			A Costmap is a grid-based, 2D representation of barriers detected by a robot. Information regarding the obstructions the sensors detected is contained in each grid cell. The price of the cell could be unspecified, zero, full, or inflated. Different hues represent the likelihood of running into an obstruction. The controllers, planners, and recoveries use this information to compute their jobs in a safe and effective manner. Costmaps come in two varieties: global and local. The barriers on the static map are used to build a Global Costmap. It is the map the planner uses to create the long-term course. New barriers found by the robot over a limited area surrounding it are used to generate a Local Costmap. It is used by the controller to create the short-term path and avoid moving impediments. While the Local Costmap is utilized to avoid dynamic obstacles that are not on the map, the Global Costmap assists in avoiding known obstacles that are on the map. The Local Costmap only covers the area immediately surrounding the robot, but the Global Costmap encompasses the entire map. As the robot goes throughout the area, the Local Costmap rolls over the Global Costmap, which is static over the map.

Ajay Paul: /* Path Planning in ROS2 */

2023-01-09T15:27:42Z

Path Planning in ROS2

← Nächstältere Version		Version vom 9. Januar 2023, 15:27 Uhr
Zeile 307:		Zeile 307:

	In A* mode (use astar = true), Asearch 's algorithm applies a heuristic to expand the potential field in the direction of the objective, making it quicker to locate a potential path. However, Asearch 's process is not guaranteed to find the shortest path.		In A* mode (use astar = true), Asearch 's algorithm applies a heuristic to expand the potential field in the direction of the objective, making it quicker to locate a potential path. However, Asearch 's process is not guaranteed to find the shortest path.

			==== <big>Obstacle Avoidance in ROS2</big> ====

Ajay Paul: /* Path Planning in ROS2 */

2023-01-09T15:24:38Z

Path Planning in ROS2

← Nächstältere Version		Version vom 9. Januar 2023, 15:24 Uhr
Zeile 301:		Zeile 301:
	h) Use RVIZ to provide the initial robot location.		h) Use RVIZ to provide the initial robot location.
	i) Launch the path planner with the new launch file created.		i) Launch the path planner with the new launch file created.

			'''The Nav2Fn_Planner'''

			A plugin for the Nav2 Planner Server is the Nav2Fn. It can determine the route between two points using either the A* or Dijkstra's methods. If use astar is set to false in Dijkstra mode, the search algorithm will always locate the shortest path.

			In A* mode (use astar = true), Asearch 's algorithm applies a heuristic to expand the potential field in the direction of the objective, making it quicker to locate a potential path. However, Asearch 's process is not guaranteed to find the shortest path.

Ajay Paul: /* Path Planning in ROS2 */

2023-01-09T15:22:12Z

Path Planning in ROS2

← Nächstältere Version		Version vom 9. Januar 2023, 15:22 Uhr
Zeile 245:		Zeile 245:

	1. nav2_map_server node<br>		1. nav2_map_server node<br>
	2. nav2_amcl node		2. nav2_amcl node<br>

			To launch path planning, You need to launch four more nodes:

			* planner node
			* controller node
			* manager of recovery behaviors node
			* behavior tree navigator node
			* nav2_lifecycle_manager node to manage the nodes.

			1. Launch of the planner <br>

			The Global Planner in ROS1 is the same as the ROS Nav2 planner. Its job is to determine a route from point A to point B for the robot. The calculated route avoids the known barriers marked on the map. The robot immediately builds the path computation after receiving a 2d Goal Pose. The planner can also access a representation of the entire environment and sensor data that has been buffered into it (i.e., Global Costmap ).

			The fields you need to indicate in the node launch are:

			* The package nav2_planner provides the controller
			* The executable is called planner_server
			* The parameters it requires are:
			* The yaml file that contains all the configuration parameters of the node

			2. Launch of the controller

			The Local Planner in ROS1 is the same as the ROS Nav2 controller. Its primary duty is to plan a reactive path from the current location to a few meters in the future (until the range of the sensors). Then, while attempting to adhere to the overall plan, it constructs a route to avoid the dynamic impediments (which do not appear on the map but can be spotted with the help of sensor data). Additionally, it is responsible for creating the wheel's orders, which direct the robot to follow the trajectory. There are only two local planners accessible in ROS2 at the moment:

			* dwb_controller : generally used with differential drive robots
			* TEB Controller : generally used with car-like robots

			3. Launch of the navigation coordinator

			The node that calculates path planning and the node that creates wheel commands to follow that path have both been seen before. The node that coordinates the node that makes the request to the path planner node for a path and then makes the request to the controller to move the robot along it comes next. Bt navigator is the name of that node.

			4. Launch of the recoveries_server

			What happens if the robot is unable to locate a reliable route to the specified goal? What if the robot becomes impassed in the midst and is unable to proceed? The robot uses recovery behaviors in these scenarios. Behavior trees are used to call these straightforward, predefined actions, which typically resolve the issue. The node in charge of carrying out the recovery behaviors is recoveries server. For instance, when it thinks the robot is stuck, the bt navigator will contact the recoveries server.

			Currently, there are three recovery behaviors available in Nav2:

			* spin - performs an in-place rotation by a given angle
			* backup - performs a linear translation by a given distance
			* wait - brings the robot to a stationary state

			In the config file, you should indicate which ones of those behaviors you want to load, so they will be ready to be called by the bt_navigator.

			a) Create a new package in ros2_ws workspace named path_planner_server .
			b) Create launch & config directory at ros2_ws/src/path_planner_server
			c) Write a launch file to launch the path planner with the name pathplanner.launch.py where all the path planner nodes are properly launched
			d) Create a YAML file for each node that requires it in the config directory. You can use the config files shown above.
			e) Compile this new path planner package. Remember to modify the setup.py appropriately. Remember to source the new install.
			f) Launch the localization system from the previous lesson.
			g) Open RVIZ:
			* Also, load the localization_rviz_config file. Then add the Path display and configure it for the /plan topic
			* configure the Path display with Line Style: Billboards and then provide a Line Width of 0.05
			* Save this RVIZ configuration inside the ros2_ws/src directory with the name pathplanning_rviz_config .
			h) Use RVIZ to provide the initial robot location.
			i) Launch the path planner with the new launch file created.

Ajay Paul: /* Path Planning in ROS2 */

2023-01-09T15:17:58Z

Path Planning in ROS2

← Nächstältere Version		Version vom 9. Januar 2023, 15:17 Uhr
Zeile 244:		Zeile 244:
	Prior to launching the path planning system, you need to run the following nodes:		Prior to launching the path planning system, you need to run the following nodes:

	1. nav2_map_server node		1. nav2_map_server node<br>
	2. nav2_amcl node		2. nav2_amcl node

Ajay Paul: /* Path Planning in ROS2 */

2023-01-09T15:17:48Z

Path Planning in ROS2

← Nächstältere Version		Version vom 9. Januar 2023, 15:17 Uhr
Zeile 240:		Zeile 240:

	Planning a path from Point A to Point B while avoiding potential pitfalls is known as path planning. You will launch numerous nodes in order to start Path Planning. Additionally, certain additional nodes are needed for path planning.		Planning a path from Point A to Point B while avoiding potential pitfalls is known as path planning. You will launch numerous nodes in order to start Path Planning. Additionally, certain additional nodes are needed for path planning.
			REQUIREMENTS

			Prior to launching the path planning system, you need to run the following nodes:

			1. nav2_map_server node
			2. nav2_amcl node

Ajay Paul: /* Localization of a Robot in an Environment */

2023-01-09T15:17:20Z

Localization of a Robot in an Environment

← Nächstältere Version		Version vom 9. Januar 2023, 15:17 Uhr
Zeile 224:		Zeile 224:
	Set the robot's starting position on the map. To locate the robot in the environment, click on the 2D pose estimate. Then, click on the map point that represents the robot's actual position in the simulation. The entire AMCL system will start localizing the robot after the Pose Estimate is set. It will then begin publishing the transform between the map and the odom. The system as a whole goes live!		Set the robot's starting position on the map. To locate the robot in the environment, click on the 2D pose estimate. Then, click on the map point that represents the robot's actual position in the simulation. The entire AMCL system will start localizing the robot after the Pose Estimate is set. It will then begin publishing the transform between the map and the odom. The system as a whole goes live!

	[[Datei:Amcl.png\|mini\|800px\|Localization of the robot in ~~construct~~ ]]<br>		[[Datei:Amcl.png\|mini\|800px\|Localization of the robot in RVIZ ]]<br>

	Save this RVIZ configuration in the ros2_ws/src directory as localizer_rviz_confi.		Save this RVIZ configuration in the ros2_ws/src directory as localizer_rviz_confi.

Ajay Paul: /* Localization of a Robot in an Environment */

2023-01-09T15:16:24Z

Localization of a Robot in an Environment

← Nächstältere Version		Version vom 9. Januar 2023, 15:16 Uhr
Zeile 224:		Zeile 224:
	Set the robot's starting position on the map. To locate the robot in the environment, click on the 2D pose estimate. Then, click on the map point that represents the robot's actual position in the simulation. The entire AMCL system will start localizing the robot after the Pose Estimate is set. It will then begin publishing the transform between the map and the odom. The system as a whole goes live!		Set the robot's starting position on the map. To locate the robot in the environment, click on the 2D pose estimate. Then, click on the map point that represents the robot's actual position in the simulation. The entire AMCL system will start localizing the robot after the Pose Estimate is set. It will then begin publishing the transform between the map and the odom. The system as a whole goes live!

	[[Datei:Amcl.png\|mini\|800px\|]]<br>		[[Datei:Amcl.png\|mini\|800px\|Localization of the robot in construct ]]<br>

	Save this RVIZ configuration in the ros2_ws/src directory as localizer_rviz_confi.		Save this RVIZ configuration in the ros2_ws/src directory as localizer_rviz_confi.

Ajay Paul: /* Localization of a Robot in an Environment */

2023-01-09T15:14:19Z

Localization of a Robot in an Environment

← Nächstältere Version		Version vom 9. Januar 2023, 15:14 Uhr
Zeile 227:		Zeile 227:

	Save this RVIZ configuration in the ros2_ws/src directory as localizer_rviz_confi.		Save this RVIZ configuration in the ros2_ws/src directory as localizer_rviz_confi.

			'''About robot localization'''

			The robot is localized when you know its (x, y, ) in the corresponding map (for 2D localization):
			* x is the x position of the robot in the map frame
			* y is the y position of the robot in the map frame
			* θ is the orientation of the robot in the map frame

			The Adaptive Monte Carlo Localization method is used by the AMCL package to compute the (x, y) of the robot after using the static map. Particles are used in the Adaptive Monte Carlo method to locate the robot. Like the actual robot, these particles have their own coordinates, orientation values, and assigned weight. The absolute difference between the robot's actual stance and the pose that particular particle anticipated is what is referred to as the weight value (). The weight of the particle specifies the stance of the robot more precisely as it increases in size. Every time the robot moves across the environment and provides fresh sensor data, the particles are re-sampled. The particles with high weights survive each resample whereas the particles with low weights disappear. The particles will converge and evaluate an estimate of the robot's stance following numerous iterations of the AMCL algorithm. As a result, depending on the information from the sensor, this algorithm calculates the robot's orientation and location. You require an AMCL node that has been properly setup if you want to locate the robot accurately in its surroundings. The settings for tuning AMCL to customize the algorithm for your particular situation are listed below.

			==== <big>Path Planning in ROS2</big> ====

			Planning a path from Point A to Point B while avoiding potential pitfalls is known as path planning. You will launch numerous nodes in order to start Path Planning. Additionally, certain additional nodes are needed for path planning.