NOTE: This is still a work in progress
For my final engineering capstone my friends and I are building a system for deploying and reintegrating a swarm of UAVs. The system consists of a dodecacopter called the "carrier drone" and six custom built and designed quadcopters called "swarm drones".
These six swarm drones are held inside a mechanism on the carrier drone and then carried to a mission location and dropped. The drone's will automatically catch themselves and perform the mission. Once done they return to the carrier drones landing location and autonomously precision land back into the vehicle.
Below a simplified demonstration of this system can be seen.
The carrier drone mentioned before can be seen flying autonomously during a field test below.
This project is being worked on by my friends and I seen below:
There are three primary systems to software: flight control, swarm communication, and mission path planning.
Heavy focus has been placed on flight control as that is the most vital aspect of this system and required at completion of the project. Swarm communication and mission path planning are extra goals added on.
For controlling the drones PX4 and RTPS are used along with ROS2. A basic library
companion_computing is being developed for easily sending commands to the vehicle, such as positions and velocities. There are also fundamental actions:
takeoff, land, arm, disarm, kill, precision land, and drop.
The last two are in heavy development and testing. They are custom implemented into
companion_computing and the PX4 flight stack itself.
The image below shows the flight control being run on two of our custom drones: carrier drone and swarm drone. The carrier drone is an octocopter derived from our custom SolidWorks model and that is being built for field testing. The swarm drones are the smaller vehicles and are our main platforms for testing and development. In the image they can be seen taking off, moving to coordinates, and landing.
The two largest tasks developed for this project are drop mode and precision landing which will be discussed in the next few sections.
This mode was implemented in the PX4-Autopilot flight stack and our
companion_computing. It uses RTPS to communicate between the two. Drop mode focuses on catching the drone after it drops from the carrier drone shown before. This requires the drone to be in a state where it is unarmed while falling and transitioning to a hover state after it reaches a certain velocity.
This has been tested in simulation and on the field, both seen below. There are plans to test a drop from the carrier drone in the near future.
This action is meant to precisely land our swarm drones inside the carrier drone using ArUco markers. The swarm drones are meant to land inside and then be carried off.
Below shows a simulation of the precision landing on top of the carrier drone.
Our missions primarily focus around search and rescue. We are developing decision making logic, using behavior trees, and path planning algorithms to facilitate searching of areas.
Behavior trees are the foundation to all missions we perform. They provide a simple and dynamic way to construct our missions safely and efficiently. We use the library
BehaviorTree.CPP and constructed our own action nodes for controlling the vehicle using ROS2.
The below video shows an example of the precision land behavior tree running with the visualizer
Currently, a work in progress.
Outside of software a lot of work has been done by my friends who are mechanical and electrical. Slight additions were added by Josh and I, such as a lot of the testing and setup for sensors and the flight controller. I had a heavy hand in connecting the PX4 flight controller to our onboard computer and establishing appropriate parameters.
Here's our most recent report submitted for Northeastern University's capstone class.