Crazyswarm2

Crazyswarm2 is a ROS 2 stack designed for controlling aerial robot teams. It is a ROS 2 port of the original Crazyswarm project and supports Bitcraze AB flight computers, including:

• Crazyflie 2.1(+)
• Crazyflie 2.1 Brushless
• Flapper Nimble+
• Custom drones built using Crazyflie Bolt

It is open-source under the MIT license.

The Crazyswarm2 (Crazyflie ROS 2) project is organized into several specialized packages:

• crazyflie/: Contains the Crazyflie server nodes and the crazyflies.yaml configuration file.
• crazyflie_py/: A Python library that wraps ROS 2 services and topics to facilitate connection with the Crazyflie server nodes.
• crazyflie_examples/: Contains practical examples of using the Crazyflie ROS 2 package.
• crazyflie_interfaces/: Defines all custom ROS 2 messages (msgs) and services (srvs) used in the project.
• crazyflie_sim/: Contains the simulator for software-in-the-loop (SIL) testing.

The pycrazyswarm module (located in /ros_ws/src/crazyswarm/scripts) is the primary high-level interface for the Crazyswarm platform. Most research projects can be implemented by writing pycrazyswarm scripts and modifying configuration files without needing to modify the underlying Crazyswarm codebase.

The API is designed to be hardware-agnostic. For every class in pycrazyswarm.crazyflie, there is an identically named class in pycrazyswarm.crazyflieSim. Because the APIs are identical, you can write your logic once and switch between real hardware and simulation seamlessly.

A setpoint is a collection of desired values for some or all of a quadrotor's states that the feedback controller is tasked to achieve.

Depending on the application, a setpoint might include:

• Position only (e.g., x, y, z)
• Position, velocity, and acceleration
• Other state combinations required for specific maneuvers.

Crazyswarm uses piecewise polynomials for quadrotor trajectory planning. A piecewise polynomial is a function composed of multiple polynomial segments defined over specific time intervals.

In Crazyswarm, these are specifically implemented as degree-7 polynomials with 4-dimensional vector-valued outputs:

1. x (position)
2. y (position)
3. z (position)
4. yaw angle

Because quadrotors possess the property of differential flatness, computing these four values allows the system to derive all other necessary states, such as attitude, acceleration, and angular velocity. For trajectory planning, these polynomials must be smooth (continuous and differentiable) to ensure stable flight.

The Crazyflie server supports three distinct backends depending on your hardware or simulation needs:

1. cpp: Uses crazyflie-link-cpp at the lowest layer. Best for high-performance requirements.
2. cflib: Based on crazyflie-lib-python. Handles logging, parameters, and command sending.
3. sim: A software-in-the-loop (SIL) simulator that behaves like a regular backend, providing the same ROS 2 topics and services as the hardware backends.

Crazyswarm uses a mirroring pattern to allow seamless testing. For every hardware-facing class in pycrazyswarm.crazyflie, there is a corresponding simulation class in pycrazyswarm.crazyflieSim with the exact same method signatures and properties.

• pycrazyswarm.crazyflie.Crazyflie: Used for controlling real Crazyflie hardware.
• pycrazyswarm.crazyflieSim.CrazyflieSim: Used for testing scripts in a 3D simulation environment.

Because the APIs are identical, you can develop and debug your swarm logic in simulation before deploying to physical drones.

Crazyswarm exposes selected Crazyflie firmware modules to Python scripts via pycrazyswarm bindings. These bindings are generated from C header files using SWIG.

If a firmware module's core functionality has no dependencies on ARM or FreeRTOS, it can be compiled for x86 and tested/debugged on a PC using these bindings. This is particularly useful for implementing and testing new firmware modules in a simulated environment.