Build Your Own Thrust Vectored Rockets For Vertical Landings Like SpaceX | World Defense

Build Your Own Thrust Vectored Rockets For Vertical Landings Like SpaceX

Oct 1, 2019
181 8
If you love rockets, you can’t help but notice that real space launch vehicles lift off the pad slowly,but model rockets zip up like darts. That’s how I became obsessed with using thrust vector control (TVC) — gimbaling the rocket motor — instead of fins to keep model rockets upright, so they can launch, and land, far more realistically.


I started out from scratch in rocketry; I’m all self-taught. After graduating with a degree in audio engineering from Berklee College of Music in 2014, I saw what SpaceX and other aerospace companies were going for with propulsive landing technology and I was hooked. I knew I wanted to get into rocketry to get a job at one of these companies, and I wasn’t in a position to pay for another college degree. I figured instead I could demonstrate what I was teaching myself by propulsively landing a model rocket the same way SpaceX landed the Falcon 9. It was a literal “shower idea.”

I started BPS in 2015 with the goal of achieving vertical takeoff and vertical landing (VTVL) of a scale model Falcon 9 rocket. This would require me to solve two tough problems — thrust-vectored flight and propulsive landings — using solid-fuel hobby rocket motors.

I picked up a few textbooks (I strongly recommend Rocket Propulsion Elements by George Sutton and Structures by J.E. Gordon), found a few good YouTube tutorials for coding and mechanical design, and got to work experimenting.

BPS has produced a lot of rocketry flight computers. Like maybe way too many. Here they are in chronological order.
I naïvely thought it would take four months. My first ten launches were failures. But the eleventh succeeded, and the successes accelerated after that. After four years of hard work, crashes, and iterative designs, I’m now achieving beautiful thrust-vectored launches of several rockets, including my 1:48-scale Falcon Heavy — three cores! — that you can watch on my YouTube channel.

And after some very near misses, I’m confident my Echo rocket will stick the vertical landing in 2019. Rather than attempt to throttle a solid-fuel motor, I’m firing the entire retro motor —also TVC’ed —at the precise time and altitude to enable a soft touchdown. It hasn’t been easy.


Of course this technology is still not mature, and it’s my hope that the advanced model rocketry community will build upon what I’ve done. In 2017, I began selling my Signal flight computer board and TVC motor mount together in a kit. After getting user feedback, the computer was redesigned from the ground up to include Bluetooth — Mission Control from your phone! is now a proper company and a full-time job for me, funded through flight computer sales, the Patreon page, YouTube ad revenue, and sponsorships.

This kit is for advanced rocketeers. If you don’t have experience with scratch-built rockets, I recommend you hone your skills first with an Estes ready-to-fly kit and seek advice from fellow rocketeers at the National Association of Rocketry Facebook Group and the Rocketry Subreddit.

And if you’ve got some experience, I hope you’ll give it a try! I’ve even shared a scale model of the Rocket Lab Electron you can build using my tutorials.


Model rockets have fins and launch quickly, but real space launch vehicles don’t; they actively aim — vector — their rocket exhaust to steer the rocket. With thrust vectoring, your model rockets can slowly ascend and build speed like the real thing, instead of leaving your sight in seconds.


The Signal R2 flight computer runs a high-speed control loop, prioritizing functions depending on the progress of the flight. Thrust vectoring draws considerable current, so once burnout is detected, Signal centers and locks the vectoring mount. Focus is then set on detecting apogee and triggering pyro events. It needs at least 8V; 9V alkalines or 11.1V LiPos recommended.


Developed over three years of iterative design, the thrust vector control motor mount is made from 3D printed PLA material.

It uses two 9g servos, geared down for higher accuracy. The assembly can gimbal a motor ±5 degrees on each axis, X and Y. Though the mount will work with up to 40N of force, it works best with lower impulse motors, especially those with long burn times.


The flight software tracks vehicle flight dynamics while the rocket is powered on. Signal looks for cues to shift system states at liftoff, burnout, apogee, and landing. This makes operation simple — once the settings file is configured for flight, just turn on the flight computer and it automatically enters Pad-idle mode. Signal can detect launch in under 10ms. Once detected, thrust vectoring is activated, in-flight abort is armed, and high-frequency data logging begins.


In-flight data logging takes place at 40Hz. Vectoring output, vehicle orientation, altitude, velocity, acceleration, and several other data points are recorded using a custom protocol to a high-speed flash chip. Upon landing detection, Signal creates a new CSV file on the microSD card, dumping flight data into it. Once the data is verified to match, the flash chip is cleared and Signal is ready to fly again. A 1GB card can store hundreds of flights. Flight settings are programmable in a settings file on the card.


Signal is configured using an app on an iOS or Android smartphone.

The app helps the user configure TVC sensitivity, parachute deployment altitudes, the abort system, ground testing, rocket tuning, and more. My goal is to put Mission Control in your pocket.

Build your own scale model Rocket Lab Electron by following the “Build Signal R2” tutorials at the YouTube channel, and try it out!


When I started building my Signal TVC kits in spring 2017, I put my propulsive landing project on hold. This past year I got back to it: I started drop-testing my experimental Echo rocket from a drone and began a new YouTube series, “Landing Model Rockets.”

The series explains my entire process, from selecting motors, to planning the flight profile, to developing a new control board for propulsive landing. It comes in two flavors: Blip, a DIY version using breakout boards and through-hole components; and Blop, a lighter, surface-mount PCB. Both are based on the powerful MK20DX256VLH7 processor that’s used in the Teensy 3.2 microcontroller, with a Bosch BMP280 barometric pressure sensor and InvenSense MPU-6050 inertial measurement unit (IMU). For now I’m sharing these experimental boards with my Patreon supporters.

So how can you land with solid rocket motors if you can’t throttle them? It’s all about timing! If the flight profile is fairly well known and the legs are built to withstand small hops and drops, the motor can be fired at just the right time to slow the vehicle down for a soft landing. As the rocket nears the ground, the microcontroller reads the barometric altimeter and fires the retro motor.

Four landing legs deploy by rubber band,

and the rocket lands upright. In theory.

Turns out vertical landing is super hard! As the rocket slows to a near-hover, horizontal drift becomes an issue. I’m already deep in the weeds programming the math necessary to control for this. I’m also experimenting with a tiny LIDAR sensor for really precise rangefinding to the ground.

After several very near misses (watch them on YouTube), I refuse to not stick the landing in 2019! Follow me on Twitter to stay up to date.
Oct 1, 2019
181 8

Myself, the Falcon Heavy model, and Tim Dodd, The Everyday Astronaut
In December 2017, I set out to build a 1/48 scale model of the SpaceX Falcon Heavy rocket as a technology demonstrator for, to showcase the advancement that’s now possible at the model scale. As usual, I underestimated it as a four-month job! I finally launched it in November of last year.

Flacon Heavy model – Flight 1
Each of the three cores carries a flight computer, parachute deployment system, and TVC assembly. The upper stage flies with thrust vector control as well, and it carries a 3D-printed sports car — no Falcon Heavy model would be complete without one.

An early CAD render of the vehicle
The Falcon Heavy flight computers are upgraded versions of Signal (see page 32). Each computer has MEMS gyroscopes and accelerometers for sensing movement and orientation on the rocket, the same kind of sensors found in most smartphones. A barometric pressure sensor determines the rocket’s altitude above the ground.

On each flight computer, a 48MHz Cortex M0 processor reads the flight sensors at 400Hz and logs 31 channels of data to a flash chip, 40 times per second. Every second that Falcon Heavy is in the air, 4,960 points of data are recorded onboard — never too much data.

The flight computers don’t communicate with each other during flight; the sensors and software are accurate enough that it’s not required for short flights. None of the flight settings are hard-coded; depending on the flight profile, they can all be changed using the Signal iOS/Android app.

The flight software is written in C++, the iOS app in Swift, and the Android app in Java. Flight guidance is computed using quaternions, a complex number system for 3D orientation and rotation that’s more computationally efficient than other methods (see for a wonderful introduction).


The attachment points at the top of each side core slide down a ramp on the center core, giving them a bit of clearance during stage separation. This passive setup keeps things very simple during flight, but the cores are usually bolted together while the vehicle is on the ground. All three cores are also connected at the base of the vehicle using a slightly simpler thrust plate.

The side cores remain attached to the vehicle by maintaining a slightly higher net thrust force than the center core/upper stage. As soon as the center core produces more net thrust than the side cores, it will pull away and the stages will separate. For flexibility, each side core also has a slot for a small separation motor; I haven’t needed to use sep motors on flights so far, but they may be helpful later down the road.

The center core of the Falcon Heavy model goes through two boost phases during flight. During the first phase, the side cores are attached. Right around side core burnout,
the center core lights a second motor, and
the second boost phase begins. These two rocket motors are mounted on top of each other in the center core’s thrust vectoring mount. When the second motor ignites, the lower, spent motor, is ejected. This same technique, called hot staging, is used to control ascent and propulsive landing motors in other rockets.

The rocket motors in each stage of the Falcon Heavy model can be gimbaled ±5 degrees in any direction. Because the side cores are not firing directly through the vehicle’s center of mass, they can be used not just for pitch and yaw, but roll control as well. Each multi-core flight runs a roll program which usually targets 20 degrees of positive roll, executed at 30–40 degrees per second.

Launching the Falcon Heavy model requires a bit of forethought. The center core motor has a slight thrust spike at ignition, after which the amount of force produced slowly tapers off. At liftoff, the side cores must have a greater net thrust than the center core. Because of this, the center core is lit at T–1 second while the vehicle is still held on the pad by the launch clamps. At T–0 the side cores are lit, and at T+0.25 the beast is released.

Also, do I even have to say it? Of course those boosters are gonna land! The propulsive landing test program is isolated from the Falcon Heavy program right now, but the two will merge as the success rate for both programs increases.


After five iterations, Launch Pad 2.0 was redesigned from the ground up to support both single- and three-core rockets. With 8 total launch clamps, and an easily modifiable iron flame trench, Pad 2.0 is my most flexible platform yet. My Impulse launch computer, based on an Atmel ATSAMD21 microcontroller, has plenty of inputs and outputs to support add-ons like load cells, wireless communications, and any other peripheral that communicates through I2C or SPI.


» Fine-tuning the TVC — I continue to launch the Signal R2 board on my new Scout D1 rocket to improve the tuning feature in the software.

» Slow-burning propellant — Most model rocket motors burn just 3–7 seconds, not long enough to simulate real space vehicle launches. I’ve been working with Aerotech to develop long-burning motors such as their new G11 and G8ST that burns for almost 18 seconds!

» High-powered rockets — I’ve been getting involved in the HPR community, where amateur rocket flights go miles high and safety is a lot more important. So I’m now developing the Arc dual deploy board: 2 pyro channels for firing main and drogue chutes, barometric altimeter up to 100,000 feet, multi-speed data logging, and Bluetooth for smartphone configuration.

» Reaction control system (RCS) — One more thing: Rather than attempt TVC on high-power motors, I’m developing a reaction control system — six little cold-gas thrusters near the top of the rocket to improve stability

— and of course a new Relay RCS board to run it.

Build Your Own Thrust Vectored Rockets For Vertical Landings Like SpaceX | Make: