Build the image — then ship the imager to a $50 board.
Synthetic Aperture Radar turns a small antenna on a moving platform into a virtual one kilometres long: fly a track, fire chirped pulses, and the motion synthesizes an aperture that resolves the ground far finer than the real antenna ever could. The raw returns are an unfocused blur; focusing is what turns them into an image. This program builds that whole chain — and then does the part MATLAB needs a second toolbox for: it emits the focusing kernel as memory-safe Rust and cross-compiles it to a commodity ARM processor, bit-for-bit equivalent to the model.
Resolution comes from the chirp, not the pulse length.
A radar's range resolution would normally need an impossibly short pulse. SAR cheats with a long linear-FM chirp and pulse compression: matched-filter the echo against the transmitted chirp and a long, low-power pulse collapses to a sharp peak whose width is set by the bandwidth, c/(2·B) — here 0.875 m on a 150 MHz chirp. The sidelobes of that compressed peak sit at −13 dB, and windowing trades them down to −42 dB at the cost of a slightly wider mainlobe.
A point on the ground is a smear in the raw image.
As the platform flies past a target, the round-trip range traces a hyperbola — so a single bright point spreads across many pulses and many range bins. The raw phase history is a textured blur in which nothing is recognizable. All the information is there; it's just not focused. Synthetic-aperture processing is what collapses every target's hyperbolic signature back to a point.
An unknown phase error blurs it — autofocus finds it.
Focusing assumes you know the platform's track exactly. Real motion has errors, and an unknown phase error across the aperture defocuses the image just like an out-of-focus camera. Autofocus recovers it from the data itself: search for the phase correction that maximizes image sharpness, apply it, and the blurred peak snaps back to its focused width — no external measurement of the error required.
The focusing kernel becomes memory-safe Rust on commodity ARM.
Forming the image is half the story; deploying the imager is the other half. The deterministic per-pixel backprojection kernel is emitted as portable `#![no_std]` Rust, verified bit-for-bit against the Julia reference in software-in-the-loop (a relative error of 5×10⁻¹¹ in f32), cross-compiled to `aarch64-unknown-none` — the Raspberry Pi-class ARM that's the most widely-deployed 64-bit processor on earth — and bound to an in-toto attestation for supply-chain provenance. This is the autopilot→Rust firmware story (memory-safe Rust, not C, the answer to Embedded Coder) one compute tier up: from a microcontroller control loop to an edge-compute imaging kernel.
Every number re-derived at sign-off.
The V&V notebook rebuilds the chain from scratch and re-derives each requirement, printing a PASS/FAIL board.
| Result | Requirement | |
|---|---|---|
| Range resolution vs c/2B | 0.875 m (12.5%) | R-01 < 15% |
| Azimuth focusing gain | >500× | R-02 ≥ 15× |
| Sidelobes (rect / Hamming) | −13.5 / −42 dB | R-03 ≤ −13 dB |
| SIL Rust-vs-Julia (f32) | 5e-11 | R-04 ≤ 1e-6 |
| Cross-compile + attest | aarch64 + in-toto | R-05 |
Simulated phase history, a real deployable kernel.
The raw data is simulated point-target and scene phase history, not real airborne or satellite returns; the geometry is stripmap and the focuser is backprojection (the gold standard and the natural codegen target — not the RDA/ω-k pipelines of a production processor). The de-risk surfaced the program's central lesson the honest way: at C-band the aperture under-sampled the azimuth phase and threw an ambiguity off-target, so the program runs at L-band where the sampling is unambiguous. The codegen is the hand-emitted no_std kernel with software-in-the-loop verification and an aarch64 cross-compile — not the GIR signal-block emitter, which targets streaming control loops, not batch imaging; running on a specific board needs a HAL (out of scope, same caveat as the autopilot). What's real and re-runnable: the full focusing chain, the >500× gain, the sidelobe budget, the bit-exact SIL, and the attested aarch64 kernel crate.
Form your own image — and deploy the imager.
Book a walkthrough and we'll set up your radar geometry, focus your scene, and generate and verify the deployable Rust kernel for your target hardware live.