Week 22 · Coding Period

Upstream, and onto the board

The implementation is complete and now lives in AGL. Every piece of the demo, from the Flutter app to the on-device perception node, is pushed upstream. The full image is built for the Jetson Orin Nano, and the board is on the bench for bring-up. The focus for the next few days is clear, complete documentation.

MILESTONE  The whole implementation is in AGL. Two changes are merged and two more are up for review, so the entire demo, including the perception node that runs on the device, can be built from AGL's own tree with no out-of-tree pieces.

1. Everything is upstream

Over the course of the project the demo grew from a loose set of scripts into a set of proper AGL recipes. As of this week all of that work is submitted to meta-agl-devel:

The two review changes are stacked, the node recipe first and the wiring on top, so continuous integration builds them together. Once they land, anyone can build the complete, self-computing demo from a clean checkout.

2. The pipeline it ships

This is the result those recipes produce: the dashboard inside a built AGL image, with the perception node running on-target. The point cloud is in blue and the green boxes over it are the live detections, computed on the device from the raw cloud and published over rosbridge. The chips read the point count, the objects found this tick, the view rate, and a live link.

The AGL LiDAR dashboard: a blue top-down point cloud with green 3D detection boxes computed live by the on-device node, plus forward and aerial camera panels. Header chips read 454 pts, 11 obj, 25 Hz, LIVE.
The demo the upstream recipes build: live, on-device perception feeding the HMI. Verified in a built AGL image on the emulated target.

3. Onto the hardware

The same image is now built for the real embedded target. The agl-ivi-demo-flutter image for the Jetson Orin Nano, with the demo and the perception node baked in, builds cleanly and produces a flashable bundle.

A Jetson Orin Nano developer kit on a desk next to a laptop, wired with jumper leads to the recovery header, a USB-C cable to the laptop, and the power lead, set up for flashing.
The Jetson Orin Nano on the bench, wired for bring-up: the recovery jumper on the button header, USB-C to the laptop, and power. The built image is on the laptop, ready to flash.

Flashing and bringing the demo up on the board display is the immediate next step. That is the one thing still to confirm on real hardware: a clean build is not the same as a clean first boot, and the usual embedded unknowns are the display bring-up and the compositor. Until the board boots into the running demo, the honest claim is that the image builds into a flashable artifact and the pipeline is proven on an AGL image, not that it is verified on the Jetson.

4. What is next

Links

← Week 19
Final Report →