This page details the progress I have made in developing an autonomous Thrust Vector Controlled Model Rocket. This project was inspired by Joe Barnard at BPS Space, with his launching and landing of model rockets, as well as my own interest in Aerospace & Controls Engineering. It is a continuation of a project that began last summer (2024), where I designed the first prototype of a gimbal mount and ran a couple of tests while firing a motor. Link. All the work shown here was done over this summer (2025).
- Overview
- CAD
- Avionics
- Gimbal Mount
- Servo Characterization
- Experimental Tests
- Computational Fluid Dynamics
- 6DoF Simulation in MATLAB
- Control Algorithm
- Parachute Ejection & Recovery System
- Launch Pad
The goal of this project was to design, simulate, and build a finless rocket capable of stabilizing itself through thrust vectoring. This project integrates mechanical design, electronics, control theory, simulation, and experimental testing into a single system. Unfortunately, as the summer came to a close, I fell short of a first launch attempt by a couple of weeks. However, I made significant progress towards the eventual goal of launch and stable flight. Here's an overview of key accomplishments from this project so far:
- Finalized design of gimbal mount and decreased thrust vector step size down to 0.2 degrees compared with the first prototype's step size of 0.75 degrees.
- Designed and assembled a custom flight computer Printed Circuit Board (PCB) consisting of a micro controller, Inertial Measurement Unit, Barometer Module, Data Storage, LoRa telemetry, and a MOSFET pyro channel.
- Used Solidworks CAD to design the rocket from scratch, integrating 3D printed mounts and other subsystems on the rocket.
- Developed a piston ejection system using 4Fg Black Powder for reliable deployment of parachutes.
- Designed and built a parachute to safely recover the vehicle during descent.
- Designed a custom Launch Pad with servo-driven quick-release Clamps, ignition circuit, and a custom Launch Pad PCB capable of controlling systems and transceiving radio commands.
- Computationally estimated and experimentally measured the rocket's Center of Gravity and Moment of Inertia about its lateral axes.
- Experimentally measured and analyzed servo motor hysteresis, latency, and response lag to accurately model gimbal mount dynamics.
- Formulated a nonlinear state-space representation of the rocket's rotational and translational dynamics in MATLAB.
- Built a full 6DoF state-space model of the rocket in MATLAB, integrating aerodynamic forces & moments, thrust vectoring, and environmental factors.
- Used Ansys Fluent's Computational Fluid Dynamics to determine lift and drag coefficients, aerodynamic moments, and center of pressure at various angles of attack to be used in 6DoF Simulation.
- Developed the structure of a Simulink Model integrating the 6DoF MATLAB function, a cascading PID Loop, and servo dynamics for accurate simulation and tuning of controller.
- Performed preliminary tuning and adjustment of PID gains of both inner and outer loops.
- Used C++ to program fundamental systems and tests of the Flight Computer, Launch Pad Computer, and Ground Station.
Everything that was physically built was designed in Solidworks CAD beforehand. This includes the rocket, launch pad, and test stand.
Link To Onshape CAD Model of Rocket
Link To Onshape CAD Model of Launch Pad
There were two custom Printed Circuit Boards built for this project. The first was for the flight computer and the second was for the launch pad computer.
The flight computer consisted of a Teensy 4.0 Microcontroller, 5V and 3.3V Pololu Buck Converters, BNO085 Inertial Measurement Unit, BMP388 Barometer, SPI Flash SD, RFM95W Radio Transceiver, LED, Buzzer, external micro SD breakout, screw terminals for servo outputs, and a MOSFET circuit for a pyrotechnic ignition channel. I2C communication was primarily used for simplicity, though SPI communication was used for some devices.
The Launch Pad Computer consisted of a Teensy 4.0 Microcontroller, 5V Pololu Buck Converter, RFM95W Radio Transceiver, LEDs, Buzzer, 6 screw terminals for servo control (extra 2 for redundancy), 3 MOSFET circuits connected to Igniter Channels (2 extra channels for redundancy as well).
Having a robust gimbal mount that can effectively vector thrust is key to the success of this project, which is why I spent an entire summer dedicated just to it. The gimbal mount is controlled by two servo motors each connected to linkage mechanisms. There are two "loops". The inner loop is connected to the rocket motor case at a pivot, allowing the inner servo motor to rotate the motor case back and forth. The entire inner loop is connected to the outer loop by a pivot. The servo motor on the outer loop moves the inner loop back and forth in a direction perpendicular to the inner servo to allow vectoring in two directions. This mount has maximum and minimum vector angles of 4.5 degrees in both the pitch and yaw directions.
While the final design of the gimbal mount is the same as the first prototypes in terms of how it vectors the thrust, these were some key changes made to improve the overall design:
- Shortened distance between control horn pivot and linkage connection.
- Increased distance between linkage connection and motor case/inner loop pivot.
- Increased support on inner and outer loops for more rigidity.
These three changes increased servo resolution and decreased flex in the mount. For more info, look at "Old TVC Mount Issues" folder. Link to Onshape CAD for Gimbal Mount
In order to accurately represent the dynamics of the gimbal mount I needed an in depth understanding of how it moves when I command it to certain angles. This was one part of the project I hadn't anticipated needing to do, but as I began developing the Simulink Model, I realized it was very important. There are four characteristics of the servo I needed to understand it's dynamics:
- Hysteresis (servos behave differently when commanded in different directions)
- Latency (how much time it takes for the servo to begin moving once the command is called)
- Response Lag (How long it takes for the servo to move to it's final position once the command is called)
To accurately model this, I ran multiple tests increasing the servo angle from -22 to +22 degrees (max range of gimbal mount, corresponds to ~4.5 degrees actual) and decreasing from +22 to -22 degrees. I recorded the commanded angles and true angles and plotted them on graphs using MATLAB. I repeated this several times for both pitch and yaw axes. I then fitted a polynomial to the data.
To find these two values I used a camera to capture the motion of the gimbal mount. When I sent the signal to the servo motor, I simultaneously turned on the LED on the Flight Computer, so I could visually record the time stamp when command sent. From there I recorded the time stamp where the gimbal mount began moving (Latency) and recorded the time stamp where the gimbal mount stopped it's movement (Response Lag). I counted the number of frames between these three time stamps and divided by the frame rate to get the actual time. I repeated this for multiple tests to get several values at different angles.
To further understand the system, two important values needed to be found: the Center of Gravity and the Moment of Inertia about the lateral axes. I had estimated these values using Solidworks CG locator by overwriting the material density, finding the CG of each individual part, and finding their distance from the nose tip. However, the physical tests account for additional fasteners, glue, and wires that I didn't account for in the calculation, making it more accurate.
Finding the center of gravity was relatively simple. I hung a string and created a loop for the rocket to be placed. I shifted the rocket around until it was able to balance by itself and labeled that point the CG.
To find the Moment of Inertia I used the Bifilar Pendulum Test. I hung two lines and attached them to the rocket 40 inches apart and centered about the CG, and recorded those measurements. I then rotated the rocket and started a timer as soon as I let go. After 10 oscillations, I recorded the time, to get the period of oscillation, and repeated this for multiple tests. From there, I could derive the Moment of Inertia from the mass of hte rocket, the length of the string, the distance between the two points, and the period time. I assumed the rocket to be symmetric about the longitudinal axis, so I only found one moment of inertia and used the same values for both Iy and Iz (pitch & yaw axes). I didn't find the roll Moment of Inertia as I could only control Pitcha and Yaw with Thrust Vectoring, and there wouldn't be any significant torques acting to roll the rocket. I still estimated it through a calculation, to be used in the 6DoF simulation.
Used Ansys Fluent CFD to deteremine coefficients of forces, moments, and the location of center of pressure at various angles of attack. Generated lift, drag, and moment coefficient curves across 0-90 degrees angle of attack. This data along with estimations for the aerodynamic damping derivative (derived from CFD results) was implemented into the MATLAB 6DoF function. For Lift and Drag Coefficients, Ansys was used to find the magnitude of these forces at 40m/s, which could then be used to solve for Cd x ReferenceArea and Cl x ReferenceArea rather than needing to calculate both Cd/Cl and reference area at different angles of attack. The static moment was normalized for velocity and CP location relative to CG. The center of pressure was defined from the nose tip and was calculated through dividing the static moment by the normal force to get the distance from CG.
Developed the equations for state space estimation and built a six-degree-of-freedom function in MATLAB to compute the time derivative of the rocket's 6DoF state. The state equation was formulated using quaternions and angular velocity for rotational motion, as well as inertial position and velocity to represent the rocket's translational motion. The choice of using quaternions over traditional euler angles was to prevent gimbal lock in the simulation. This function uses control inputs (vector angles), thrust data, aerodynamic data, and environmental conditions to estimate the translational and rotational acceleration. Aerodynamic forces and moments are computed in the body reference frame, then transformed into the inertial frame to integrate the full equations of motion. This simulation is fundamental to the development of the control algorithm and generation of flight profiles. Here's the code for the 6DoF function: Rocket6DoF
To develop the control algorithm I used Simulink to create a closed-loop model that integrates the 6DoF simulation from above and servo dynamics. The controller is structured as a cascaded PI-PID controller. The outer PI loop computes error based on attitude, and then outputs a desired angular rate. The inner loop then uses that output and the measured actual angular rate to calculate the error and generates commanded pitch and yaw outputs. The decision to use a PI rather than PID controller for the outer loop was based off the fact that the derivative of attitude error is angular rate, which is already being regulated in the inner loop. These commands then pass through a section that encapsulates the experimentally derived servo dynamics to feed the true thrust vector angles back into the process section. These were the Simulink Blocks used to model servo dynamics:
- Dead Zone: Very small changes to servo angle will not result in any change in servo position.
- Saturation: Maximum and minimum gimbal angles.
- Rate Limiter: Rising and falling slew rate of servo motor (maximum angular rate of motor).
- Transport Delay: Modeled servo latency
- Transfer Function: Used for servo response lag (the time to move from initial to final position)
- True Gimbal Function: Determines whether servo is moving up or down, and uses servo hysteresis data to ouput actual gimbal
- Zero-Order Hold: Models refresh rate of Inertial Measurement Unit (400hz)
Controller Tuning Strategy: I have already completed preliminary tuning of this control algorithm, but some refinement is still needed. I started with the inner loop and then moved onto the outer loop, once the angular velocity showed convergence. The general strategy I used to tune both loops was to start with low Proportional gain and increase until I saw adequate response. If there were large-amplitude oscillations I increased the derivative gain, until it was less severe. If there was any steady-state offset I increased the integral gain. For both loops, I tuned one axis at a time, independently of one another. After, I modified the gains slightly when incorporating pitch and yaw together. In the future, I plan to add derivative filtering to the inner PID loop to prevent sharp spikes in commanded angles, and reduce the noise in the servo outputs.
Example output including angular velocity, quaternions, desired pitch rate, commanded pitch rate. These scopes are what allowed visual tuning of the gains. There's significant noise in the commanded pitch angle showing the need for derivative filtering.
The parachute ejection system on the TVC model rocket is a custom built piston ejection device. At the bottom of this system is the piston canister bulkhead. It is what stores the FFFFg black powder and the e-matches used to ignite it. The high pressure created by the ignition gases pushes out the piston cap, which in turn also pushes out the shock cord, parachute, and nosecone. This ejection method is significantly more reliable and easier to implement than a mechanical deployment device. It's also a lot lighter, helping with total mass reduction. The electronics are very simple, only requiring a single MOSFET pyro channel. For recovery, the parachute was designed for a 1kg rocket (actual mass is ~850g) to land at a velocity of 4m/s. It's made of ripstop nylon fabric, which is very strong and ligthweight. Attached to the shroud lines is a swivel to reduce the chances of lines tangling. Here's a video of the parachute ejection test: Ejection Test
The custom designed launch pad is composed of a spring loaded clamp release mechanism, a custom launch pad computer, and ignition circuit. In the secured position, the four clamps lock down onto the rocket's launch pad mount. Shortly after rocket motor ignition, the servo motors rotate and hit the release arms out from underneath the clamps, allowing the springs to snap downward. This design ensures the clamps retract quickly and remain out of the rocket's path. Here's a video releasing the launch clamps: Launch Clamp Test
