M1-T10: NVIDIA Jetson platforms for autonomous UAVs

Learning objectives

After this lesson, you should be able to:

• State the selection criteria for an onboard computer: compute, memory, power, mass, I/O and software support.
• Use vendor documentation for specifications without relying on remembered numbers.
• Use power modes and monitoring tools to measure utilisation.
• Build a mass, power and thermal budget for the module including carrier board and cooling.

Conceptual explanation

NVIDIA’s Jetson family consists of system-on-modules combining ARM CPU cores, a GPU, memory and hardware encoders and accelerators, with a carrier board providing connectors (camera, Ethernet, USB, UART, CAN). Product generations and their specifications change; the vendor’s module datasheets and the JetPack release notes are the authority for the numbers, and this track deliberately does not quote them.

Engineering intuition

Compute is not one number. A perception pipeline mixes CPU-bound steps (feature tracking, estimation), GPU-bound steps (neural networks, dense stereo) and memory-bound steps (point-cloud processing), and its real cost is set by whichever resource saturates first, often memory bandwidth or CPU cores feeding the GPU. A module with more peak operations may be no faster for your pipeline. Measure, in the power mode you will fly in, with the full pipeline running and the cameras attached, and add margin: thermal throttling under a closed airframe at a hot ambient is the usual surprise.

Mathematical formulation

Power-limited operation: the thermal budget is the dissipated power times the thermal resistance from die to air, and the module throttles when the die temperature reaches its limit:

Flight-time cost of the payload: every watt consumed reduces endurance, and every gram of module, carrier, heatsink and extra battery reduces it again through hover power (lesson M1-T2). The marginal cost can be estimated from the hover power per kilogram: $\Delta P$ ≈ (dP/dm) $\Delta m$ with $P\propto m^{3/2}$, so dP/dm = 1.5 P/m.

$R_{\text{die}\to \text{case}}$, $R_{\text{case}\to \text{air}}$

thermal resistances (°C/W): from the vendor’s thermal design guide and your cooling arrangement.

$T_{\text{limit}}$

the throttle threshold from the vendor documentation.

Architecture and data flow

Tools on JetPack that matter: nvpmodel selects the power mode (cores and clocks), jetson_clocks pins clocks high for benchmarking, and tegrastats prints CPU, GPU, memory, temperature and power per interval. Their exact output format varies between releases: parse defensively and check the format on your version. Camera inputs reach the module via CSI, USB or Ethernet depending on the carrier; synchronisation hardware (trigger, PPS or PTP) is a carrier-board feature to check at selection time.

Real-world UAV applications

• Running stereo VIO or LIO and a detector on a 1–2 kg vehicle.
• Comparing modules for a fixed pipeline by measured frame rate and power.
• Deriving the power mode to fly in from the measured mission load.
• Budgeting airflow in an enclosed airframe.

Implementation example

This runs as shown: a defensive parser for tegrastats-style lines (the sample line is synthetic and for illustration; check the output format of your JetPack version) and a per-run summary that reports peak and mean utilisation, the numbers a compute budget needs.

import re, statistics as st

SAMPLE = [  # synthetic lines in the general style of tegrastats output (the format differs between releases: verify on yours)
    "RAM 3120/7620MB (lfb 4x4MB) CPU [45%@1420,60%@1420,38%@1420,41%@1420] GR3D_FREQ 62% cpu@52.5C gpu@50.0C",
    "RAM 3180/7620MB (lfb 4x4MB) CPU [52%@1420,71%@1420,44%@1420,49%@1420] GR3D_FREQ 78% cpu@54.0C gpu@52.0C",
    "RAM 3205/7620MB (lfb 3x4MB) CPU [48%@1420,66%@1420,40%@1420,43%@1420] GR3D_FREQ 71% cpu@55.5C gpu@53.0C",
]

def parse(line):
    ram = re.search(r"RAM (\d+)/(\d+)MB", line); cpu = re.search(r"CPU \[(.*?)\]", line); gpu = re.search(r"GR3D_FREQ (\d+)%", line)
    temps = [float(x) for x in re.findall(r"@(\d+\.?\d*)C", line)]
    return {"ram_used": int(ram.group(1)), "ram_total": int(ram.group(2)),
            "cpu": [int(x) for x in re.findall(r"(\d+)%@", cpu.group(1))] if cpu else [], "gpu": int(gpu.group(1)) if gpu else None, "tmax": max(temps) if temps else None}

rows = [parse(l) for l in SAMPLE]
cpu_peak = max(max(r["cpu"]) for r in rows); cpu_mean = st.mean(st.mean(r["cpu"]) for r in rows)
print(f"RAM peak {max(r['ram_used'] for r in rows)} MB of {rows[0]['ram_total']}; CPU peak core {cpu_peak}%, mean {cpu_mean:.0f}%; GPU peak {max(r['gpu'] for r in rows)}%; hottest sensor {max(r['tmax'] for r in rows)} C")
assert rows[0]["ram_total"] == 7620 and len(rows[0]["cpu"]) == 4 and max(r["gpu"] for r in rows) == 78 and abs(max(r["tmax"] for r in rows) - 55.5) < 1e-9
assert cpu_peak == 71 and 0.4 < max(r["ram_used"] for r in rows) / rows[0]["ram_total"] < 0.5          # a RAM headroom check for the compute budget

Common engineering mistakes

Failure modes

Debugging approach

1. Log tegrastats at 1 Hz throughout test flights with the full pipeline.
2. Correlate frame drops with CPU, GPU and temperature.
3. Run in the final enclosure at worst-case ambient.
4. Compare latency percentiles in each power mode (lesson M7-T6).

Practical exercises

1. Extend the parser to extract power rails if your tegrastats prints them.
2. Estimate the flight-time cost of 15 $W$ and 250 $g$ for a 2 kg vehicle with 150 $W$ hover power.
3. Compile the per-node CPU, GPU and RAM use of your own pipeline into a table.
4. Define a pass criterion for “thermal margin” and a test that checks it.

Interview questions

Write an answer in your own words, then reveal the model answer. Nothing is sent anywhere.

References and further reading

Primary papers, official documentation and standards. Each claim above that is specific to a tool or version points here.

• NVIDIA Jetson modules (specifications by module)
• NVIDIA Jetson Linux developer guide (nvpmodel, tegrastats, power and thermal)
• NVIDIA Jetson downloads: datasheets and thermal design guides

What’s next