Static Thrust Is Not Cruise Performance: Building a Fixed-Wing Propulsion Envelope from AT2814 Data

A static thrust table is useful evidence, but it is not a cruise-performance map. The distinction matters whenever a motor and propeller are used as the pusher on a fixed-wing UAV or during the wing-borne phase of a VTOL mission. At zero airspeed, the propeller operates at zero advance ratio. In forward flight, its inflow, blade angle of attack, thrust coefficient, torque coefficient, and efficiency all change. A spreadsheet that equates a static gram-of-thrust row with cruise thrust can therefore look precise while answering the wrong question.

This article develops a data pipeline around the randomly selected UNITED UAV T-MOTOR AT2814 KV1200 fixed-wing pusher motor. The manufacturer's AT2814 page publishes voltage, current, electrical power, RPM, torque, static thrust, thrust per watt, and terminal motor-surface temperature for several propellers. That is enough to audit electrical and mechanical boundaries and to reject bad combinations. It is not enough to predict cruise without an airspeed-dependent propeller map.

No UNITED UAV flight test, wind-tunnel test, or calibrated thrust-stand test was performed for this article. Manufacturer rows are identified as source data. The airframe and mission values below are explicit examples used to demonstrate the method, not claims about a production aircraft. Any flight release needs evidence from the exact installed motor, propeller, ESC, battery, cooling path, airframe, firmware, and operating environment.

Commercial disclosure: UNITED UAV Official publishes this article and sells the linked motor. The workflow is intended to remain useful if a different motor or supplier is selected.

The aircraft asks for thrust at airspeed, not static grams

In steady, level fixed-wing flight, thrust balances drag. NASA's drag equation expresses drag as dynamic pressure multiplied by reference area and drag coefficient. A preliminary aircraft model often expands the coefficient into a zero-lift term and a lift-dependent term:

CD = CD0 + k × CL²

With lift approximately equal to weight in level flight, the corresponding drag estimate is:

D = q × S × CD0 + k × W² / (q × S)

where q = 0.5 × rho × V², S is the declared wing reference area, W is weight, rho is air density, and V is true airspeed. The model is only as credible as its coefficients and reference conventions. CD0, span efficiency, wing area, mass, and density must carry provenance. Wind-tunnel or flight-identification data should replace illustrative assumptions as soon as they exist.

This framing immediately exposes a common category error. A multirotor hover calculation begins with weight divided by lifting rotors. A fixed-wing cruise calculation begins with aircraft drag at a flight condition. The pusher does not normally support the aircraft's weight directly; the wing does. During climb, the propulsion system must provide both the power associated with drag and the rate of increase of potential energy. During acceleration, it must additionally supply excess thrust. During VTOL transition, neither a pure hover model nor a steady fixed-wing model is sufficient.

For an illustrative 1.35 kg airframe, assume a 0.34 m² wing, CD0 = 0.035, aspect ratio 7.5, span efficiency 0.8, and sea-level density 1.225 kg/m³. These are teaching inputs, not measured properties. At 18 m/s, the simple polar produces about 2.50 N of drag. The mechanical power delivered to useful propulsive work in level flight would be at least D × V, approximately 45 W, before accounting for propeller efficiency, motor/ESC loss, installation effects, and control activity.

During a 3 m/s climb, the potential-energy rate alone is approximately W × climb_rate, or about 40 W. The shaft-power requirement is therefore not obtained by looking for 1.35 kg in a static thrust table. It comes from the drag polar, climb requirement, airspeed, propulsive efficiency, drivetrain efficiency, and margins. Each input must be tied to an operating condition.

Advance ratio is the missing coordinate

Propeller data are commonly organized by advance ratio:

J = V / (n × D)

where V is forward speed, n is revolutions per second, and D is propeller diameter. A static bench point has V = 0, so J = 0. A fixed-wing cruise point does not.

Consider the manufacturer's published full-command rows for the AT2814 KV1200. With an APC 9×6 propeller, the table reports 12,788 RPM at 14.46 V. At 18 m/s, that RPM and diameter correspond to an advance ratio of roughly 0.37. The APC 10×5.5 row reports 12,029 RPM at 14.37 V, corresponding to roughly 0.35 at the same airspeed. Those values are not small perturbations around a static point; they identify a different propeller operating condition.

Without thrust and power coefficients across advance ratio—or a validated wind-tunnel, dynamometer, or flight-derived map—the static table cannot tell us cruise thrust, cruise torque, or propulsive efficiency. Scaling static thrust by voltage, RPM squared, or throttle percentage does not restore the missing inflow physics. A responsible model should represent that state as unknown, not fill it with a convenient extrapolation.

Preserve the published boundary data

The manufacturer's current specification for the long-shaft KV1200 identifies a 108 g motor including cable, 26 mΩ internal resistance, 12N14P configuration, 5 mm input and output shaft diameters, 3–4S LiPo range, 1.8 A idle current at 10 V, 55 A peak current for 180 seconds, and 800 W maximum power for 180 seconds. These are motor-level, duration-qualified figures. They are not continuous ratings for the ESC, battery, connector, or installed aircraft.

Representative KV1200 source rows are:

Supply / propeller	Command	Voltage	Current	Input power	RPM	Torque	Static thrust	Listed surface temperature
4S / APC 9×6	75%	14.78 V	30.26 A	447.22 W	11,085	0.289 N·m	1,611 g	85 °C
4S / APC 9×6	90%	14.54 V	45.13 A	656.04 W	12,479	0.379 N·m	2,044 g	85 °C
4S / APC 9×6	100%	14.46 V	49.57 A	716.86 W	12,788	0.402 N·m	2,152 g	85 °C
4S / APC 10×5.5	75%	14.72 V	33.92 A	499.21 W	10,615	0.324 N·m	1,982 g	97 °C
4S / APC 10×5.5	80%	14.64 V	38.94 A	569.96 W	11,052	0.355 N·m	2,169 g	97 °C
4S / APC 10×5.5	100%	14.37 V	54.64 A	785.36 W	12,029	0.436 N·m	2,616 g	97 °C
3S / APC 10×5.5	100%	10.90 V	35.83 A	390.52 W	10,077	0.285 N·m	1,767 g	66 °C
3S / APC 11×5.5	100%	10.80 V	41.64 A	449.82 W	9,503	0.332 N·m	2,044 g	82 °C

The source states that the temperature is motor surface temperature after three minutes at 100% command. It does not assign that temperature independently to every partial-command row. Store it as a terminal test-condition observation for the configuration, not as a temperature measured at 75% or 90%. Sensor placement, emissivity, airflow, starting temperature, and ambient temperature are not fully specified in the displayed rows, so the values cannot be converted into a universal thermal model.

Basic arithmetic should be automated. In the 4S 10×5.5 full-command row, 14.37 V multiplied by 54.64 A is about 785.4 W, consistent with the listed 785.36 W after rounding. The row is only 0.36 A below the motor's published 55 A / 180-second current figure and only 14.64 W below the published 800 W / 180-second power figure. That is boundary evidence, not usable design margin. Battery sag, sensor error, propeller tolerance, a denser atmosphere, cooling differences, or an ESC timing change can move the installed point.

Compare configurations at a declared static condition

Static data are still valuable when used for a static requirement: launch checks, restrained ground tests, low-speed transition screening, or source-data quality control. Comparisons must be made at the same thrust and within one measured curve.

For example, the 4S 9×6 row reports 2,044 g at 90% and 656.04 W. The 4S 10×5.5 curve brackets the same static thrust between 1,982 g at 499.21 W and 2,169 g at 569.96 W. Linear interpolation within that narrow source interval gives roughly 522.7 W at 2,044 g. Under those particular static bench conditions, the larger propeller needs about 20% less listed input power at that target.

That result is useful but deliberately narrow. It does not prove lower cruise energy. It does not resolve propeller clearance, noise, vibration, control response, launch behavior, forward-flight efficiency, or the much hotter published terminal surface-temperature value for the 10×5.5 configuration. It also does not turn linear interpolation into a physical law. The interpolation should retain its two bracketing rows and refuse targets outside the measured interval.

The right conclusion is “this combination deserves the next test at the defined operating condition,” not “this propeller is 20% more efficient in flight.”

Use a data contract that keeps unlike evidence separate

Every observation should identify both its configuration and evidence class. A minimum propulsion record includes:

• motor model and winding;
• propeller manufacturer, diameter, pitch, material, and revision;
• ESC model, firmware, timing, and switching settings;
• battery chemistry, cell count, state of charge, temperature, and loaded voltage;
• command, RPM, voltage, current, electrical measurement boundary, torque, and thrust;
• airspeed, air density, angle of attack, and installation state;
• sensor IDs, calibration dates, sample windows, and uncertainty;
• source type such as manufacturer_static, local_static, wind_tunnel, or flight_identified;
• raw-data URI, checksum, test procedure revision, and reviewer.

Do not merge rows simply because the column names match. A manufacturer static row and a flight-identified cruise row have different authority, conditions, and uncertainty. A value copied from a page is not a measurement made by your team. An absent airspeed must be null with a reason such as static_test, never silently encoded as zero unless the source explicitly establishes zero inflow.

A configuration fingerprint can be generated from normalized identity fields. If the motor winding, propeller revision, ESC firmware, or measurement boundary changes, the fingerprint must change. That prevents a dashboard from averaging incompatible tests into a reassuring but meaningless trend.

Audit the source rows and mission model in code

The following dependency-free Python example performs three bounded jobs. It checks electrical power consistency, derives shaft power from published torque and RPM, and interpolates static power only within a matching curve. Separately, it evaluates an illustrative drag polar and reports advance ratio. It never converts static thrust into cruise thrust.

from dataclasses import dataclass
from math import isfinite, pi, sqrt


@dataclass(frozen=True)
class StaticPoint:
    propeller: str
    diameter_in: float
    command_pct: float
    voltage_v: float
    current_a: float
    input_power_w: float
    rpm: float
    torque_nm: float
    thrust_g: float


def audit_point(point: StaticPoint) -> dict:
    numbers = (
        point.diameter_in,
        point.command_pct,
        point.voltage_v,
        point.current_a,
        point.input_power_w,
        point.rpm,
        point.torque_nm,
        point.thrust_g,
    )
    if not point.propeller or not all(isfinite(value) for value in numbers):
        raise ValueError("invalid static point")
    if min(numbers) <= 0 or point.command_pct > 100:
        raise ValueError("non-positive value or command above 100%")

    recomputed_input_w = point.voltage_v * point.current_a
    power_error = abs(recomputed_input_w - point.input_power_w)
    power_error_fraction = power_error / point.input_power_w
    if power_error_fraction > 0.015:
        raise ValueError("input power disagrees with voltage times current")

    shaft_power_w = point.torque_nm * 2 * pi * point.rpm / 60
    if shaft_power_w > point.input_power_w * 1.02:
        raise ValueError("shaft power exceeds plausible electrical input")

    diameter_m = point.diameter_in * 0.0254
    tip_speed_mps = pi * diameter_m * point.rpm / 60
    return {
        "propeller": point.propeller,
        "recomputed_input_w": recomputed_input_w,
        "shaft_power_w": shaft_power_w,
        "drive_efficiency": shaft_power_w / point.input_power_w,
        "static_tip_mach_at_340_3_mps": tip_speed_mps / 340.3,
    }


def interpolate_static_power(points: list[StaticPoint], target_thrust_g: float) -> dict:
    if not isfinite(target_thrust_g) or target_thrust_g <= 0:
        raise ValueError("target thrust must be positive and finite")
    if len(points) < 2:
        raise ValueError("at least two source points are required")
    for point in points:
        audit_point(point)

    identities = {(p.propeller, p.diameter_in) for p in points}
    if len(identities) != 1:
        raise ValueError("mixed propeller curves cannot be interpolated")

    ordered = sorted(points, key=lambda p: p.thrust_g)
    bracket = next(
        ((a, b) for a, b in zip(ordered, ordered[1:])
         if a.thrust_g <= target_thrust_g <= b.thrust_g),
        None,
    )
    if bracket is None:
        raise ValueError("target would require extrapolation")

    low, high = bracket
    fraction = (
        (target_thrust_g - low.thrust_g)
        / (high.thrust_g - low.thrust_g)
    )

    def lerp(a: float, b: float) -> float:
        return a + fraction * (b - a)

    return {
        "propeller": low.propeller,
        "target_static_thrust_g": target_thrust_g,
        "input_power_w": lerp(low.input_power_w, high.input_power_w),
        "current_a": lerp(low.current_a, high.current_a),
        "command_pct": lerp(low.command_pct, high.command_pct),
        "bracket_g": [low.thrust_g, high.thrust_g],
        "evidence": "interpolated_manufacturer_static",
    }


def drag_polar(mass_kg: float, airspeed_mps: float, rho: float,
               wing_area_m2: float, cd0: float,
               aspect_ratio: float, span_efficiency: float) -> dict:
    values = (mass_kg, airspeed_mps, rho, wing_area_m2,
              cd0, aspect_ratio, span_efficiency)
    if not all(isfinite(value) and value > 0 for value in values):
        raise ValueError("drag-polar inputs must be positive and finite")
    if span_efficiency > 1:
        raise ValueError("span efficiency must not exceed 1")

    weight_n = mass_kg * 9.80665
    dynamic_pressure_pa = 0.5 * rho * airspeed_mps ** 2
    k = 1 / (pi * aspect_ratio * span_efficiency)
    parasite_drag_n = dynamic_pressure_pa * wing_area_m2 * cd0
    induced_drag_n = (
        k * weight_n ** 2 / (dynamic_pressure_pa * wing_area_m2)
    )
    drag_n = parasite_drag_n + induced_drag_n
    return {
        "drag_n": drag_n,
        "parasite_drag_n": parasite_drag_n,
        "induced_drag_n": induced_drag_n,
        "useful_level_flight_power_w": drag_n * airspeed_mps,
        "evidence": "illustrative_airframe_model",
    }


def advance_ratio(airspeed_mps: float, rpm: float, diameter_in: float) -> float:
    if min(airspeed_mps, rpm, diameter_in) < 0 or rpm == 0 or diameter_in == 0:
        raise ValueError("invalid advance-ratio inputs")
    revolutions_per_second = rpm / 60
    diameter_m = diameter_in * 0.0254
    return airspeed_mps / (revolutions_per_second * diameter_m)


prop_10x55 = [
    StaticPoint("APC 10x5.5", 10, 75, 14.72, 33.92,
                499.21, 10615, 0.324, 1982),
    StaticPoint("APC 10x5.5", 10, 80, 14.64, 38.94,
                569.96, 11052, 0.355, 2169),
    StaticPoint("APC 10x5.5", 10, 100, 14.37, 54.64,
                785.36, 12029, 0.436, 2616),
]

print(audit_point(prop_10x55[-1]))
print(interpolate_static_power(prop_10x55, target_thrust_g=2044))
print(drag_polar(
    mass_kg=1.35,
    airspeed_mps=18,
    rho=1.225,
    wing_area_m2=0.34,
    cd0=0.035,
    aspect_ratio=7.5,
    span_efficiency=0.8,
))
print({
    "advance_ratio_at_18_mps": advance_ratio(18, 12029, 10),
    "static_table_advance_ratio": 0.0,
})

The program should report approximately 549 W of shaft power and 70% electrical-to-shaft efficiency for the full-command 4S 10×5.5 row, subject to the published torque and electrical measurement boundaries. It should interpolate approximately 523 W and 35.6 A at 2,044 g static thrust. The illustrative airframe model should return about 2.50 N drag and 45 W of useful level-flight power at 18 m/s. The reported advance ratio should be about 0.35, while every static table row remains at zero.

Those outputs are intentionally not merged into a cruise-current prediction. Doing so would require a propeller map as a function of advance ratio, Reynolds number, and possibly blade angle and installation condition. The code preserves the gap instead of laundering an assumption into a result.

Convert the model into explicit gates

A useful screening service returns more than a ranked list. It returns failed constraints and missing evidence. For this class of propulsion decision, sensible gates include:

1. Identity gate. Exact motor winding, propeller, ESC hardware and firmware, supply, and source revision are known.
2. Arithmetic gate. Voltage-current power, torque-RPM shaft power, units, monotonicity, and duplicate rows pass validation.
3. Static-envelope gate. Takeoff or low-speed static requirements fall inside measured brackets; no extrapolation is used.
4. Electrical gate. Continuous and transient current, power, connector, cable, distribution, and battery limits have duration-aware margin.
5. Dynamic-propeller gate. Required cruise and climb advance ratios are covered by trusted propeller coefficients or a representative test.
6. Thermal gate. The installed system completes the intended duty cycle at the hot operating condition without exceeding approved limits or retaining an unacceptable positive temperature slope.
7. Mechanical gate. Shaft, fasteners, propeller retention, balance, clearance, mount stiffness, and vibration meet the airframe acceptance criteria.
8. Control gate. Command headroom, transition behavior, RPM response, governor or ESC behavior, and fault handling are verified with the flight-control configuration.

If the dynamic-propeller map is missing, the correct state is requires_dynamic_test. The system may still be suitable, but the evidence does not yet support a cruise claim. This distinction is important for automated selection tools: “no qualifying candidate” and “insufficient data” are different outcomes and should lead to different engineering work.

Design the dynamic test around the missing coordinate

The next test should add controlled airspeed, not repeat more static points. A wind-tunnel or propeller dynamometer setup should measure thrust and torque across the intended combinations of RPM and inflow speed. Convert observations to nondimensional thrust and power coefficients, record advance ratio, and preserve air density, temperature, pressure, propeller geometry, and uncertainty.

For an installed pusher, test installation effects. The fuselage, wing, tail, motor mount, cooling inlet, and propeller clearance can change inflow and efficiency. A tractor-propeller map is not automatically transferable to a pusher location. A VTOL transition adds changing angle of attack, possible lift-rotor wake interaction, and rapidly changing demand. The test matrix should cover the actual operating corridor rather than a single nominal cruise point.

Synchronize electrical, mechanical, and aerodynamic measurements. Voltage and current averaged over one window cannot be paired with thrust and torque from another during a ramp. Record raw timestamps and the exact aggregation method. Repeat points in randomized order or revisit baselines to expose heating, battery depletion, and sensor drift.

Propeller testing is hazardous. Use a suitably engineered enclosure, guarded and restrained hardware, an exclusion zone, remote observation, and an independent emergency power disconnect. Analysis code must remain outside the flight-critical or emergency-control path.

Treat limits as time-dependent

The manufacturer's 55 A and 800 W values are labeled for 180 seconds. A mission model must therefore integrate duration as well as amplitude. Store each segment with its start condition, expected current and power distribution, duration, and recovery interval. A three-second launch burst, a sixty-second climb, and twenty minutes of cruise are not interchangeable merely because their peak current is similar.

Thermal state carries between segments. The motor entering a go-around after a long climb is not at the same initial temperature as a cold bench unit. ESC and battery temperature also alter loss and protection behavior. A useful model propagates temperature or, before such a model is validated, requires representative sequence testing.

Do not infer a continuous limit from the fact that one source row is below a 180-second maximum. The 4S 10×5.5 full-command row nearly consumes the published transient current and power limits and carries a listed 97 °C terminal surface temperature under the source procedure. It is a boundary point for validation, not a cruise target.

Close the loop with flight telemetry

After ground and dynamic qualification, flight data should be traceable to the same configuration fingerprint. Record true or calibrated airspeed where available, RPM, motor command, pack and ESC voltage, current, motor and ESC temperature, altitude, ambient estimates, battery state, aircraft mass configuration, and flight mode. Preserve controller saturation and transition-state flags; otherwise high current caused by a control problem can be mistaken for normal propulsion demand.

Compare measured power against the mission model by segment and by advance-ratio region. A persistent residual may indicate an inaccurate drag polar, propeller-map error, airspeed bias, installation loss, mass mismatch, or drivetrain degradation. Do not immediately tune a correction factor to erase it. Diagnose which boundary or assumption is wrong and retain the pre-correction evidence.

Operational monitoring should compare like configurations and conditions. Useful signals include increasing current at matched airspeed and mass, declining RPM at matched voltage and command, growing vibration, reduced climb excess power, rising temperature slope, and repeated ESC protection events. Missing telemetry must be flagged as missing; zero is a real value.

What the AT2814 data can and cannot decide

The published AT2814 KV1200 table can support source-data validation, static combination screening, motor/ESC/battery boundary checks, approximate shaft-power reconciliation, tip-speed checks, and definition of the next test. It reveals that the 4S 10×5.5 full-command point is very close to the motor's published 180-second current and power figures. It also shows a substantial static input-power difference between 9×6 and 10×5.5 combinations near 2,044 g of thrust.

It cannot establish cruise thrust, cruise efficiency, range, endurance, climb rate, hot-day continuous capability, pusher-installation loss, transition behavior, or aircraft suitability by itself. Those outputs require airframe aerodynamics, advance-ratio-dependent propeller data, installed electrical and thermal evidence, and flight validation.

That boundary is the core engineering result. Professional propulsion software should make valid deductions easy, invalid extrapolations impossible, and missing evidence visible. A static table becomes useful not when it is treated as a complete answer, but when it is integrated into a mission-specific evidence chain with explicit refusal rules.