Category: Prithu’s Status Reports

I spent the final week of our project robustifying the planner as much as possible to get ready for our demo on Monday. I experimented with what to do when the planner is unable to find a path for one (or a few) of the robots. No planner is perfect and this is always a possibility. One option I tried was to sample start points within a certain radius of the robot and try planning from those samples until a plan is found. This puts more of a burden on our controller. Unfortunately, this wasn’t able to work properly. The final (and much cleaner) solution was to reassign that robot’s task to a different one if it was not able to find a plan. This sacrifices a bit of efficiency for robustness but is fine since it’s rare for a path to be uncomputable. I also made some small bug fixes to the dynamic collision checking and post-dropoff motions. Finally, I worked with Saral and Omkar to plan our final demo and film a few videos that we can show as a backup in case something goes wrong on Monday.

This past week I worked on putting the final touches on the planner code. The task planner heuristic was modified to better assign pallets to the robots that are closest to them. I also worked on some bug fixes related to static collision checks with non-moving robots. As a team we spent a lot of time working together on getting ready for the final presentation and demo as well as performing final integration tests/fixes.

As a team, this past week our overarching goal was to get multiple robots operating on the field simultaneously. To accomplish this, several modifications needed to be made to the planner.  These included: fixing the planner heuristics for a more optimal path, restricting the buffer for the robot’s approach angle to the pallet on pickup, modifying the collision checker to be more efficient, and updating the robot collision radius. We also added the robot’s functionality to process several pallet pick-up rounds for situations where there are more pallets than robots on the field.

I had a major scholarship interview scheduled for today so basically, all of my week was dedicated to mock interviews and other prep for it. As a result, I wasn’t able to get any work done for our Capstone project.

This past week we met on Saturday to work on getting the robot to properly follow a path from the path planner, pick up, and drop off the pallet. Through this process, I found several bugs that needed to be addressed. 1) The collision checking being performed was extremely inefficient and was causing the planner to take much longer than expected. 2) The planner did not have the ability to turn counter-clockwise. 3) A straight-line runway was needed as the robot was approaching the pallet to prevent it from turning too close to it and bumping. 4) New costs were assigned to differentiate between turning and going straight and encourage the robot to drive in a straight line rather than turn. All of these bugs were fixed and implemented for the demo on Monday.

This past week, most of my work was around the integration of the motion planner into the rest of the system. Since the motion planner was written in C++ for efficiency I had to use the Pybind11 library to allow Python to call the planner functions. The entire team also met this week to work on integrating all parts of the system together (CV, controller, planner) and were able to get the robot moving. We had some issues with the controller and planner related to path following and turn radius constraints that we are going to work on fixing when we meet again tomorrow.

This past week (before fall break) I was away in New York to attend an event with CMU Leadership. Most of my time was dedicated to writing portions of the Design Report. Specifically, I focused on sections related to the motion planner and the use-case/design requirements. I know there were some concerns regarding the clarity of our explanation of the planning algorithms so my top priority was to have the information presented in an easy-to-understand in-depth way. In addition to working on this document, I also started the process of integrating the planner (C++) with the rest of the codebase (Python) using a library called Pybind11 which allows you to call C++ functions from Python.

This past week, my main focus was writing the robot’s task and motion planner. The current version of the algorithm works by assigning priorities to each robot and then precomputing the paths for all the robots so that they don’t collide. This works by planning in (x, y, theta, time). The map was discretized into a 2D grid where each box is 1cm x 1cm. This resolution can be changed as needed based on the planning time. The planner also takes into account the physical constraints of the robot (collision footprint, turn-radius constraints). Here is a picture of the result of planning for two robots. Paths to the pallet and from the pallet to the drop-off zone are planned at the same time.

This week, most of my time was dedicated to researching and designing the algorithm that we will use for motion planning. After looking at various multi-agent motion planning papers (including one’s using dynamic planning), I ended up using a derivative of an algorithm that assigns each robot a priority and plans in space-time configuration space. In this way, we are able to pre-compute the robot paths such that they don’t result in a collision. Once a robot has completed its task, it is assigned the lowest priority and plans around the other robots in a similar way. I have started writing out this algorithm, and I plan to have a proof-of-concept done by tomorrow (Sunday) EOD. In addition to this, I worked with Omkar and Saral on the design presentation that Omkar will be presenting next week.