This is an FPV drone disguised as an RC drift car. You even drive it with an RC car transmitter, making it extremely easy and fun to fly around. The airframe is fully 3D printed, and the electronics are standard off-the-shelf 5" miniquad parts. If you've successfully built one of my projects or a custom racing drone before, you should have no problem building this project. I'll be including a free download for all of the part files as well as comprehensive assembly instructions at the end of this article.
Motivation
Heavily inspired by the EjoWerks speeder project, I aimed to replicate this awesome flying FPV land speeder and implement the unique control logic myself using dRehmFlight VTOL. What makes this project special is that it takes a racing drone--something tricky to fly without prior training and practice--and makes it drive like an all-terrain drift car. Doing this took some very special and custom flight control code.

Control Allocation
Control allocation is a common topic in aerial robotics systems. It basically breaks down into the following question: how do you take your input commands into a system and remix them so you get the desired output response? In the case of an airplane, this could be the mapping between the pilot's stick input and the control surface deflections (i.e. stick moves one inch, ailerons deflect 5 degrees to provide a rolling motion). But not all systems have a simple 1-1 mapping of inputs to outputs like an airplane; a pure pitch in a drone, for example, requires the front two motors to spool up, and the rear two to spool down. This is control allocation.


This principle of control allocation can extend to the inputs into the actual closed loop control laws of an aerial robot, too. For example, let's assume you have a regular quadcopter and flight controller designed to provide basic roll angle, pitch angle, and yaw rate tracking. As the pilot, instead of controlling each of these axes as individual discrete channels, say you want a single steering input to be a mix of both a roll angle and yaw rate output, providing a nice, coordinated turn. To do this, you would take your single channel input, and map it out to the desired roll angle / yaw rate output combo as inputs to the discrete control axis channels in the flight controller. This is exactly what I did to provide steering control for this project: The single steering channel of the RC car controller was creatively mapped to the roll angle and yaw rate commands driving the flight controller's internal PID controllers.

Altitude Hold
Another trick that made this project possible was constraining the problem to a fixed altitude, so that the remaining throttle/brake channel of the RC car controller could be used for forward/reverse functionality instead of throttle to all of the main lift motors. A Lidar distance sensor provided the sensor measurement, and a simple PID controller created a stabilized output variable that could be assigned to the lift motors, so they react to maintain a constant altitude:
float alt_setpoint = 1.0; // meters
float kP_alt = 0.3;
float kI_alt = 0.35;
float kD_alt = 0.16;
float error_alt = alt_setpoint - alt_measured;
error_alt = constrain(error_alt, -alt_error_max, alt_error_max);
// this saturates the proportional term and rate of growth of the integral
alt_integral = alt_integral + error_alt*dt;
alt_integral = constrain(alt_integral, -alt_int_max, alt_int_max);
// saturate integral term to prevent wind up
alt_PID = 0.01*(kP_alt*error_alt + kI_alt*alt_integral - kD_alt*alt_rate_measured); // stabilized variable for altitude
alt_PID = constrain(alt_PID, 0.0, 0.4); // constrain so it can't command too much throttle
The Proportional term in this PID controller implementation acts proportionally to the error between the current measured altitude and the desired fixed altitude (setpoint). If the error becomes larger, this component of the controller has a stronger effect--spooling up the motors more or less so they more strongly drive the error toward zero.
The Derivative term, or damping term, of this PID controller acts proportionally to the rate of change of the altitude measurement (climb/descent rate). If the vehicle is ascending/descending very fast, this term will cause the PID output to change such that it isn't driving the vehicle toward the setpoint as aggressively. This helps dampen out oscillations typically caused by the P-term, which always dumbly tries to accelerate the vehicle toward the setpoint, even if the combined command and vehicle momentum will certainly cause it to overshoot.
Finally, the Integral term acts proportionally to the integrated error over time: this basically means that if there is a constant error that the P-term is not correcting, caused by a constant external force (ahem, gravity), the integral will slowly ramp up over time to drive the error toward zero. The key here is slowly (1-2s) rather than the P-term, which is much faster acting and does not have "memory" like the Integral term. Be careful to always constrain your Integral terms so that they don't spool up indefinitely, causing undesired and dangerous motor runaways. See: my hand from the video.
Conclusions
Even though this project comes across as a fun toy that a 5-year-old could fly, there's actually quite a bit of engineering and core aerial robotics principles buried in there that make it all possible.
Make Your Own!
I didn't want to just make this awesome project for myself--I want you to be able to make your own too. Below you'll find all of the 3D print files, complete parts list, and modified dRehmFlight VTOL code needed to complete this project. Just follow the Instructions.pdf in the download below and you'll be flying in no time.
Download the free .stl files and comprehensive assembly instructions:
Parts list
Component | Amazon Purchase Link |
---|---|
Radio System | |
Microcontroller (Teensy 4.0) | |
IMU (MPU6050) | |
LIDAR Distance Sensor | |
Motors (lift) | |
ESC (lift) | |
Motor (pusher) | |
ESC (pusher) | |
Propellers | |
Battery | |
FPV Transmitter | |
FPV Camera | |
FPV Antennas | |
Video Goggles | |
M3 Heat Set Inserts | |
Magnets | |
Foam Tape | |
3D Print Filament | |
Wire (24AWG) | |
Wire (18AWG) |
Note: These are affiliate links. I receive a small commission for each sale at no additional cost to you.
Code
Download the modified dRehmFlight VTOL code for this project on GitHub:

Cool project, would love to build one around autonomous missions