Rice Eclipse Rocketry · Avionics-Mechanical subteam · Aug 2025 to present
Four canards near the nose of the rocket, each driven by its own servo, that deflect in flight to correct pitch and roll. The flight computer decides the angles. The mechanical side is mine. I designed the canard actuation mechanism and its housing in Onshape, from the torque path to the module packaging, and I own the CAD on this page.
The module as built. Four canards on ball-bearing shafts in the top plate, servos and linkages in the printed cage below.
[placeholder: turnable 3D CAD] file: assets/afs/canard-mechanism.glb In Onshape: right-click the assembly tab, Export, format glTF, binary (.glb). Keep it under 20 MB. An exploded configuration as a second file (canard-mechanism-exploded.glb) would be a nice bonus.
Current iteration of the canard actuation mechanism. Drag to rotate, scroll to zoom.
[placeholder: annotated CAD diagram] file: assets/afs/cad-annotated.png Cropped from the design review slide: the mechanism with the connecting rod, servo, servo horn, fin horn, ball bearing, heat-set inserts, battery, and PCB compartment called out.
OpenRocket model. CG at 26.4 in, CP at 31.0 in, 1.45 cal. The AFS module is the dashed section behind the nose cone.
How it works
The flight computer reads the IMU and commands a deflection angle for each canard.
Each of the four canards has its own servo. The servo horn drives a connecting rod, and the rod drives a fin horn on the canard shaft. The servos are AGF-RC SA18 low-profile programmable digital servos, 250 oz-in.
Each canard shaft rides in a standard ball bearing in the top plate, so the servo only fights aerodynamic load, not friction. Threaded joints use heat-set inserts in the printed parts, and the fasteners are secured with Loctite.
The module stacks top to bottom: canard plate with bearings, servo cage, battery, then the PCB compartment for the flight computer. Composite or metal bulkheads close it off on either side, and the whole module fits inside a 3 in airframe.
The control law that produces those angles is mine. Attitude error to desired rate, PD to desired angular acceleration, Euler's equations with the inertia tensor to the required moment, then M = qSEδ solved for the four canard deflections.
[placeholder: OpenRocket diagram] file: assets/afs/openrocket-annotated.png Cropped from the design review slide: the rocket layout with the AFS module location and the flight numbers.
Where the module sits in the rocket, with the OpenRocket flight numbers.
The control derivation I created for the system, from attitude error to canard deflection, built from research with NASA and consulting NASA GNC alumni.
Design loads
The vehicle design point, from the OpenRocket model. 45 in long, 3.16 in diameter, 63.5 oz on the pad, flown on an I280DM-14 to 3,764 ft, 838 ft/s max velocity (Mach 0.75), 575 ft/s² max acceleration, stability 1.45 cal at Mach 0.3. Three of those numbers drove the mechanism.
Acceleration. 575 ft/s² is about 18 g. During the burn every part in the stack, the servo cage, the battery carriage, and the PCB floor, carries eighteen times its own weight, and so do the screws holding it together. That is the load the heat-set inserts and the aluminum load path are sized against.
Aerodynamic load. At Mach 0.75 the dynamic pressure is about 40 kPa, roughly 6 psi. A deflected canard turns that pressure into a hinge moment on its shaft, 0.24 N·m (about 34 oz-in) at full deflection by the MATLAB model, and that moment set the torque range the servos had to hold. It is how we landed on 250 oz-in servos, a 7x margin that still fit the budget, and it is why the canard shafts ride in ball bearings, so the servo spends its torque on aerodynamic load rather than friction. Backlash matters here too, because the correction itself is only two or three degrees.
Stability. 1.45 cal is deliberately low. A very stable rocket fights the canards and needs bigger deflections to move. A low margin gives the canards authority but leaves less room for error, so the mechanism has to position accurately and hold that position under load.
Validation
What I could check before the hardware flew, what the numbers said, and what is still unproven.
Validated
Canard loads. A MATLAB model of the canard as a flat trapezoidal fin (3 in root, 2 in tip, 1 in span) using finite-wing lift-line theory. At 250 m/s and 15° deflection, one canard sees 16.9 N of lift, 5.2 N of drag, and a 0.24 N·m hinge moment about its shaft. I reran the script and the numbers reproduce exactly.
Servo torque. 0.24 N·m is about 34 oz-in. The 250 oz-in servos we bought carry a 7x margin, before the factor of safety of 2 we applied to everything else. Result: the servos are not the weak link, and a smaller servo would have fit if the budget had pushed us there.
Structural margin. With the same loads, hand calcs on the connecting rod, fin horn, and canard shaft land between 100 kPa and 300 kPa against yields of 30 to 60 MPa for the printed PLA parts. The one number that actually matters is bending in the 1/4 in 6061 shaft, where the canard force acts about an inch off the bearing. That comes to 18.6 MPa against a 276 MPa yield, a 15x margin. Result: nothing in the load path was ever close to breaking, so materials were chosen for manufacturability and wear, not strength.
Linkage kinematics. A four-bar closure solve for each of the four servo positions, mapping servo arm angle to canard angle across the servo's travel and plotting the transmission ratio, so the flight computer knows how many servo degrees make one canard degree at each station.
Not yet validated
Closed-loop performance. The RocketPy flight simulation exists, with a fixed-time-step scheduler feeding the PD controller and a drag-versus-Mach study for the fin set, but the controller gains were never tuned in it and no run was recorded. So there is no simulated attitude-error number I can stand behind yet. The reason is simple. The team's time went to building and car-testing the hardware before the sim was finished.
[placeholder: ANSYS modal analysis of the housing, ANSYS Fluent canard loading at the design point, and the RocketPy disturbance run with the RMS attitude-error reduction. Rerun and add the numbers.]
Flight. The system has been car-top tested, not flown. Every load and margin above is a prediction until an instrumented flight measures it.
[placeholder] file: assets/afs/rocketpy-sim.png
RocketPy trajectory simulation of the AFS rocket, static wind.
[placeholder: modal result] file: assets/afs/modal-result.png Mode shape with the frequency callout visible.
First mode of the mechanism housing.
[placeholder: Fluent result] file: assets/afs/fluent-result.png Pressure or velocity contour at the Mach 0.8 condition with the canard deflected.
Fluent result at Mach 0.8.
Status
The canard system works. The flight computer reads the IMU and drives all four canards on the bench, and the full module has been tested on the car-top rig. Now we are waiting to test it in flight.
Car-top test of the AFS module. Onboard cameras and the live pitch and yaw feed from the flight computer.
What went wrong, and what comes next
What went wrong
Every performance number so far is a simulation number. The controller has been exercised against injected disturbances in a model, not in flight. Until the system flies on an instrumented vehicle, the result is a prediction. That is the honest gap in this project.
[add: the mechanism problem that took the longest, e.g. backlash in the torque path, servo stall under load, fit inside the airframe diameter]
[add: anything the modal or Fluent results forced you to redesign]
How I would improve it
Bench-test the loaded mechanism, not the free-swinging one. Servo torque and deflection accuracy under a representative aerodynamic load is the number that matters.
Measure the real first mode with an impact test and compare it to the ANSYS prediction before trusting the margin.
[add: one design change you already know you want]
Next steps
Fly it. An instrumented test flight with IMU logging to compare measured attitude error against the simulated reduction.
Hardware-in-the-loop testing so the flight computer drives the real servos against a simulated flight before launch day.
Push the design point closer to transonic. The I280 gets the vehicle to about Mach 0.75; the next question is what the canard loads, hinge moments, and flutter margin look like at Mach 0.9 and above. [confirm]