Where hard-landing load factors come from for small UAS

Landing load factors for small UAS are often taken from manned-aircraft rules, left out entirely, or carried over from a previous project. None of those holds up when an auditor asks where the number came from. This post shows how to get a landing load factor from two things you can measure on your own aircraft, then checks the result against the one published standard that covers aircraft this size.

The frame is the Holybro X500 V2: 3.2 kg all-up, landing gear on the center body, made from 16 mm and 10 mm carbon tube with plastic tee connectors, 215 mm tall.

Why the manned-aircraft number doesn’t carry over

The landing condition in the FAA’s small-airplane airworthiness standard, 14 CFR Part 23 (section 23.473, in the text that applied before the 2017 rewrite), comes from a drop test. The European equivalents, EASA CS-23 for small aeroplanes and CS-VLA for very light aeroplanes, use the same approach. The descent velocity is set by a formula, V = 4.4 (W/S)^(1/4) ft/s, bounded between 7 and 10 ft/s, so 2.1 to 3.0 m/s. The gear is assumed to have a hydraulic shock absorber, and wing lift during the impact is taken as no more than two thirds of weight. So the resulting load factor has three assumptions baked in: a pilot’s botched flare, an oleo strut’s stroke, and a wing making lift at touchdown speed.

A multirotor with carbon legs breaks all three. The flight controller sets the descent rate, not a flare. There’s no shock absorber; the stroke is whatever the legs, feet, and center plates flex. And lift at touchdown is rotor thrust, which stays near full weight right up until the motors cut. The Part 23 landing load factor might be conservative for your aircraft or it might be a factor of five low, and you can’t tell which without doing the derivation.

The derivation

Two inputs: descent rate at touchdown, V, and how much the structure gives under a vertical load at the feet, written as either a stroke s or a stiffness k.

Energy going in is the aircraft’s kinetic energy at touchdown, ½ m V². During the stroke the motors are still carrying the weight, so gravity does no net work and we leave it out. That’s the same assumption the manned-aircraft codes make when they set lift equal to weight during the impact.

Energy absorbed by the gear is the area under its force-deflection curve. For a linear spring that peaks at F_peak over stroke s, the area is ½ F_peak × s. Writing that with an efficiency factor η so the formula also covers nonlinear gear:

with η = 0.5 for a linear spring (carbon legs, rubber feet), rising to about 0.65 for a hydraulic damper, which you don’t have. Solving for the gear load factor n_gear = F_peak / W:

With η = 0.5 this collapses to n_gear = V² / (g s).

If you know stiffness k instead of stroke, the same energy balance gives F_peak = V √(k m), so:

The two forms are equivalent. Use whichever input you can measure.

One more definition. n_gear is the ground reaction divided by weight, which is what the legs, the leg mounts, and on the X500 the center plates feel. The whole airframe is also decelerating under that reaction while thrust is still holding up the weight, so the inertia load factor on everything bolted to the frame (battery tray, payload, avionics) is n_z = n_gear + T/W, about n_gear + 1 at touchdown. The manned codes do the same thing with n = n_j + L/W. Both numbers matter, and they go into different parts of the model.

What the numbers look like

With η = 0.5, n_gear = V² / (g s), which doesn’t depend on mass at all. The mass shows up later when you convert to force.

The spread is the main result. Ten millimetres of total stroke is realistic for stiff carbon legs on a hard floor, and at 1 m/s that gives n_gear = 10. Fifty millimetres is what tall flexible legs or foam feet give you, and it brings the same landing down to 2. So the load factor depends on the gear as much as on the landing, and stiff gear on a small aircraft produces the highest values.

Two limits on the formula. As s gets small the number blows up, and in reality the foot, the floor, and local crushing of the tube end take over. The formula indicates that a rigid leg on a rigid floor has nowhere to put the energy and something will break or dent. Put compliance somewhere on purpose. The other limit is that the derivation assumes all four contact points touch at once, which they don’t.

The one-leg-first case

On a real landing one side touches first, on a slope or with a few degrees of roll. For a moment that side takes all the kinetic energy with only its own stiffness. In the stiffness form: if each leg has stiffness k_leg, the symmetric case has total stiffness 4 k_leg and the single-leg case has k_leg.

Divide the two and the single leg in the asymmetric case carries twice what it carries in the symmetric case. Total ground reaction is lower (half), but it’s all on one leg and one side of the frame. Annex B of NATO AEP-83, the Light Unmanned Aircraft Systems Airworthiness Requirements published under STANAG 4703, has the same condition for wheeled gear, called the one-wheel landing, where one main gear unit has to carry the reaction it would see in a level landing. For a multirotor this is the case that sizes the leg mount, and it’s often omitted.

Getting the stroke from a static run

You don’t need a drop test to get s or k. A static run with a unit load at one foot gives you the deflection at that foot, and k_leg is the load over that deflection. That picks up leg bending, the tee connectors, and center plate flex together, which is what you want because they all add to the stroke.

The sequence:

1. Apply 1 N vertically at one foot, with the frame held at the motor mounts. Read the deflection at the foot, δ.
2. k_leg = 1 N / δ. Add foot compliance by hand if the feet are soft; a rubber foot can double the stroke on stiff legs.
3. Choose V (next section). Compute F_leg = V √(k_leg m) for the one-leg case and F_leg = V √(4 k_leg m) / 4 for the symmetric case.
4. Apply the larger per-leg force as the landing case and rerun.

For the X500 we don’t have a measured k_leg yet, so we’ll use an assumed 1.5 N/mm per leg. At V = 1.5 m/s and m = 3.2 kg: one-leg F = 1.5 × √(1500 × 3.2) = 104 N; symmetric F per leg = 52 N. Stroke in the symmetric case is 35 mm and n_gear = 6.6. The unit-load run will show whether 1.5 N/mm is realistic for 10 mm tube on plastic tees.

Choosing the descent rate

The flight controller sets the descent rate. PX4’s final landing descent, MPC_LAND_SPEED, defaults to 0.7 m/s, and its maximum descent rate, MPC_Z_VEL_MAX_DN, defaults to 1 m/s. ArduCopter’s LAND_SPEED defaults to 50 cm/s, and its autonomous descent limit WPNAV_SPEED_DN defaults to 150 cm/s in the source. A normal landing is the land-speed number. A hard landing is a bad altitude estimate near the ground, a manual landing by a tired pilot, or the descent limit reached during a battery failsafe. A defensible design rate is the fastest descent the controller will allow, or two to three times the commanded landing rate, whichever is larger.

AEP-83 Annex B, for wheeled gear, ties drop height to wing loading. That formula is specific to wheeled manned aircraft and doesn’t apply to a multirotor, so use the controller number.

Checking against the standard

NATO AEP-83, the Light Unmanned Aircraft Systems Airworthiness Requirements (STANAG 4703), is the NATO airworthiness code for fixed-wing UAS under 150 kg and the closest thing to an authoritative reference at this size. It doesn’t cover multirotors, which is a gap worth stating. Three things from it are still worth quoting when you write up the landing case.

UL.6.2 asks for the worst combination of loads across all reasonably possible landing scenarios at maximum design weight, with Annex B as a reference for conventional gear only. The standard itself directs you to derive the number for your configuration rather than copy one.

Annex B uses a shock efficiency of 0.5 for tire, rubber, or spring gear, and 0.5 on the tire plus 0.65 on the strut for hydraulic gear. That’s the η above, and it confirms 0.5 for anything a multirotor is likely to have.

Annex B adds 0.67 to the wheel load factor to get the inertia load factor on concentrated masses, which is the manned-aircraft version of n_z = n_gear + T/W. For a multirotor, thrust at touchdown is closer to full weight than two thirds, so use n_gear + 1.

What to do with this

Get k_leg from a unit-load run. Pick V from your flight controller’s limits and write the choice down. Compute the one-leg-first force and run that. If the resulting load factor is high, the fix is almost always stroke: longer legs, softer feet, or a leg mount that’s compliant on purpose. Adding carbon to the legs makes the stroke smaller and the load factor higher, so it raises the load rather than lowering it.

Sources

1. NATO AEP-83 (STANAG 4703), Light Unmanned Aircraft Systems Airworthiness Requirements, Edition A Version 1, September 2014. Sections UL.6.2, Annex B (UL.GL.1 basic landing condition, UL.GL.2 one-wheel landing).

   https://assets.publishing.service.gov.uk/government/uploads/system/uploads/attachment_data/file/391827/20140916-STANAG-4703_AEP-83_A__1_.pdf

2. FAA 14 CFR 23.473, pre-Amendment 23-64 text, paragraphs (d) and (e) for the descent velocity formula and the two-thirds lift assumption.

   https://chanrobles.com/usa/uslaws/cfr/title14/14-1.0.1.3.10.3.75.43.php

3. PX4 Multicopter position mode parameters, MPC_LAND_SPEED and MPC_Z_VEL_MAX_DN.

   https://docs.px4.io

4. ArduPilot ArduCopter Land mode documentation for LAND_SPEED, and AC_WPNav.cpp for WPNAV_SPEED_DN.

   https://ardupilot.org/copter/docs/land-mode.htmlhttps://github.com/ArduPilot/ardupilot/blob/master/libraries/AC_WPNav/AC_WPNav.cpp

5. Holybro X500 V2 documentation.

   https://docs.holybro.com/drone-development-kit/px4-development-kit-x500v2