Optimal Pathfinding in Robotics for FRC

Autonomous Period
Group Members

Avaneesh Choragudi
Yash Gandhi
Dhruvsai Dhulipudi

Abstract

This project explores optimal navigation for autonomous robots during the 15-second
autonomous phase of the First Robotics Competition (FRC). Robots are tasked with scoring
game elements ("notes") at specific locations, facing challenges from multiple robots sharing the
field and avoiding collisions. We represent the field as a weighted graph, with edges depicting
potential routes and associated movement costs, while nodes denote important sites such as
scoring positions, barriers, and start points. Pathfinding algorithms—A*, Dijkstra's, and
Conflict-Based Search (CBS)—are implemented to determine efficient routes. We evaluate the
algorithms on speed, path quality, and collision prevention. Results indicate that integrating
graph theory with multi-agent systems significantly enhances autonomous navigation and
scoring strategies.

1. Introduction

FRC is a high school robotics competition where teams build robots to complete specific
objectives. Each match begins with a 15-second autonomous period when robots operate
without human input to collect and score game items, called "notes," positioned across the field.
Effective pathfinding during this short window is crucial for maximizing points while avoiding
obstacles that block direct paths.

Beyond scoring, strategic path planning is essential for safe navigation among multiple robots
sharing the field, where overlapping routes can create challenges. This project studies graph
theory algorithms—A*, Dijkstra’s, and Conflict-Based Search (CBS)—to address these issues.
By modeling the FRC field as a weighted graph of key points, we aim to find the most efficient
strategies for navigation and scoring in autonomous mode.
2. Methodology

Algorithms Used

To determine optimal paths, we applied three main algorithms: A*, Dijkstra’s, and
Conflict-Based Search (CBS). Each algorithm comes with unique advantages, making them
suitable for different aspects of autonomous navigation in FRC.

1. A*: Finds the shortest path by considering the actual cost to reach a node and
estimating the cost to the goal (g(n) + h(n)). We used Euclidean distance as the
heuristic, guiding the algorithm efficiently toward the goal.

2. Dijkstra’s Algorithm: Dijkstra's is a popular algorithm to compute the shortest distance

from a source to each node in a network. It contrasts with A* in that Dijkstra's algorithm
does not utilize heuristics at all, thus making it slower for large fields but more accurate
in path determination if precise movement needs to be done. In FRC, Dijkstra's is useful
for short-spanning scenarios where precision takes priority over speed.
3. Conflict-Based Search (CBS): Handles multi-agent pathfinding by detecting and
resolving conflicts like robot-robot or robot-obstacle collisions. It adjusts paths with
constraints to avoid overlaps, ensuring smoother, coordinated navigation.
3. Weighted Graphs

Graphical Representation of the Field:

In FRC, the field can be represented as a weighted, directed graph for better robot
navigation. Nodes represent features like starting points, scoring zones, obstacles, and key
waypoints, while edges denote possible paths with associated costs (like time, # of notes, and
efficiency). Costs depend on factors such as distance, time, or path difficulty—shorter,
obstacle-free routes have low costs, whereas routes with obstacles such as the stage have
higher costs. This model helps pathfinding algorithms choose optimal routes for efficient travel.
The complexity increases with varying robot heights, as taller robots may face overhead
restrictions that require alternative routes. Shorter robots can navigate tighter spaces, making
robot-specific pathfinding crucial for strategy.
4. Analysis of Graphs with A* and Dijkstra’s Algorithms:

Algorithm Efficiency:

A*: A* is fast and efficient; hence, it will be more suitable when the robot needs to travel over
long distances and more open spaces on the field. The heuristic aspect enables A* to prefer
those paths which most likely lead directly to the goal without wasting its effort on multiple
explorations in different directions. However, A* tends to perform less well in situations involving
multiple robots since it lacks an embedded conflict resolution mechanism.

FRC Environment Application:

1. Initial Pathfinding: At the start of the autonomous period, each robot is executing the A*
algorithm in determining an initial path from the starting position to the nearest note or
scoring point.
2. A Heuristic for Decisions: In A, the heuristic changes regarding field details. One aims
to see the Euclidean distance in the case of being able to make straight-line movements.
If obstacles need to be taken into account, a weighted distance heuristic would be
obtained, where the weighting is on the difficulty of traversing a given area.
3. Path Optimization: A* ensures that the robots avoid less efficient paths. By calculating,
at each node, the total estimated cost via g(n) + h(n), it allows them to get to scoring
points as fast as they can and maximize the contribution within this short period of time
in autonomous mode.

—---------------------------------------------------------------------------------------------------------------------------

Dijkstra's Algorithm- Dijkstra's is slower compared to A* to cover larger fields because it does
not prioritize the goal but explores all possible paths. It yields optimal, precise paths for
short-range tasks and is, therefore, very helpful in tighter spaces. Within smaller ranges of
motion where a high degree of path accuracy is needed, Dijkstra's would be the best choice.

FRC Setting Execution:

1. Complex Navigation: The algorithm runs when a robot has to move between closely
positioned scoring points or navigate through tight spaces filled with complex obstacles,
guaranteeing the shortest path.
2. Accuracy over speed: The Dijkstra's is used when one needs to sacrifice speed for
accuracy, like when placing a robot close to other game-related stuff or aligning it
precisely for scoring.
3. Integration: The algorithm operates at a local scale, where small portions of the field
need to be addressed by fine-tuned navigation.

Use Case Example: In case a robot has to go and pick up a game piece which is only a few
nodes away, or with obstacles, Dijkstra's Algorithm provides the shortest and most precise
roads for avoiding maximum deviation and optimal placement
5. Multi-Agent Navigation, and Search for Conflict Prevention
CBS: CBS provides the necessary constraint-based layer of decision-making for multi-agent
navigation; that is, decision-making for collision avoidance by robots. It is computationally very
expensive, hence slowing down with more robots and conflicts. In FRC, CBS is very useful but
only in a limited fashion due to these expenses.

Application of Conflict-Based Search

FRC Use Cases:

1. Initial Path Calculation: Each robot first runs A* to perform an independent calculation
of its path. Subsequently, CBS examines the set of paths for two or more robots visiting
the same node at the same time.
2. Addressing the Computation-demands: While addressing the computational intensity
of CBS, constraints are prioritized in terms of critical conflict points to reduce excessive
recalculations.

Symmetry-breaking: This addresses the problem of if robots, by default, select the same, or
too-similar, paths if left to their own accord, leading to conflicts or inefficiencies.
Symmetry-breaking assigns robots different initial movements or position offsets such that they
move on divergent paths and, therefore, reduce overlap to an absolute minimum. For example,
one robot initially veers left, while another, right.

● Unique "Lanes" or Zone Assignment: Assign distinct "lanes" or zones of motion to

each robot with respect to particular goals or about the general layout of the playing
field.
○ Role-Based Lanes: Assign lanes based on the expected role of the robots
during the first few seconds of the autonomous movement(primary scorer,
supporter, etc.). This will avoid robots attempting the same objective.
○ Mid-path adjustments: For instance, when multiple robots have to arrive at a
given location, one can be prioritized over the other in taking a more direct path
while its partner takes another route that avoids potential traffic.
Example Field Implementation of all 3 working together

Consider three robots should travel around the FRC field to pick up notes
positioned at:
- Robot A utilizes A* to efficiently find a path to a faraway note.
- Robot B uses Dijkstra's to navigate around the cluster of closely grouped notes beside
its starting position.
- Robot C runs the path from its initial A* run but then creates a conflict with Robot B. CBS
recognizes this and adds a constraint to Robot C's that forces it to reroute slightly to
avoid Robot B's path.

Comparative Table

6. Discussion

Challenges and Observations

A number of challenges were realized with the implementation of these algorithms. A*

was easy to operate with individual robots but could not be effectively used in multi-agent
contexts since they would have conflicts with other robots. For multi-agent pathfinding, while
CBS was an effective solution, the computational demands made real-time performance difficult,
at best, when the number of robots started growing. Dijkstra's fell a little short regarding the
speed at which large fields could be navigated.

Potential Improvements

Future enhancements could include a hybrid approach that utilizes A* when performing
the initial pathfinding, switching to CBS only in case of a conflict. Real-time adjustments through
sensor data will provide improved dynamic path recalibration to permit better adaptation of
robots to ever-changing conditions.
7. Conclusions

The described project illustrated that graph-based algorithms can reinforce autonomous
robot navigation in competitive robotics. A* and Dijkstra's proved to be potential pathfinders for
single robots, whereas multi-robot coordination was indispensable with CBS. To sum up, the
combination of the described algorithms is a very promising approach toward the optimization of
robot performance at FRC.

8. References

1. Skiena, S. S. (2008). The Algorithm Design Manual. Springer.

2. Russell, S., & Norvig, P. (2016). Artificial Intelligence: A Modern Approach (3rd Edition).
Pearson.
3. First Robotics Competition. (n.d.). FRC Game Manual.
4. Graph-based Path Planning for Mobile Robots - David T. Wooden
5. Graph-Based Multi-Robot Path Finding and Planning- Hang Ma
This code uses Python’s heapq for efficient priority queue management and can be adapted
with different heuristics, such as Euclidean or Manhattan distances, for the FRC field.

Conflict-Based Search (CBS) Code Snippet