Install the Digital Net, calibrate it, and go live.

• Every point in the work area is seen by at least two cameras, from directions at least ~30° apart. One view gives a direction, not a position.
• Neighbouring cameras overlap. Calibration chains cameras together through markers they both see.
• Start with 8 cameras on a ring for a cell up to about 12 × 8 m; go to 12–16 for long aisles, tall racks or heavy occlusion.
• Avoid pointing straight into windows or skylights. Keep lighting steady; global-shutter sensors handle motion, not glare.
• Mark the robot's routes and stations on your sketch. You'll use them for the first golden run in step 08.

1. Mount each camera about 4.5 m up on the ceiling or a truss, on a rigid bracket. Lower mounts see less floor; higher mounts lose resolution on small markers.
2. Aim at robot working height (about 0.6 m above the floor) at the far side of the work area, so the field of view crosses the cell.
3. Run shielded Cat6A to the PoE+ switch. One cable carries power, video and the PTP clock.
4. Enable PTP (IEEE 1588) on the switch and cameras so every frame is time-stamped on the same clock. Unsynced frames break triangulation on moving robots.
5. Write down each camera's position and aim point in metres from your floor origin. That becomes the rig file in step 06.

# on a trusted machine: CA, edge client and cloud server certs
./scripts/gen_mtls_certs.sh

# on the edge node
export ORBITAL_MTLS_CERT=/etc/aria/edge-client.pem
export ORBITAL_MTLS_KEY=/etc/aria/edge-client.key
export ORBITAL_MTLS_CA=/etc/aria/orbital-ca.pem

# ROS 2 Humble+: lock down who can command robots
ros2 security create_keystore /etc/aria/sros2_keystore
ros2 security create_enclave /etc/aria/sros2_keystore /aria_safety_halt
export ROS_SECURITY_ENABLE=true ROS_SECURITY_STRATEGY=Enforce

• Use your facility ID everywhere. The same ID goes on calibration, map and run uploads, and it names the site in the console.
• Leave ARIA_CV_MODE at sim until calibration passes in step 05, then switch to aruco for the live camera path.
• check_hardware_gate.py lists what's green in software and which steps still need the floor. Keep its output in your install log.

1. Tape floor markers so every camera sees at least two and neighbouring cameras share at least one.
2. Pick an origin marker and tape-measure its floor position, then measure one anchor marker a few metres away. Two known points fix scale and heading.
3. Capture each camera (or walk a handheld pass) and export one JSON per view into captures/.
4. Solve and upload, then fix what the report names. Re-run until it prints Rig is clean.

1. Write the rig file from step 02: each camera's ID, focal length, resolution, mounted position and aim point, in metres. Check it against the poses calibration solved.
2. Park a pallet in an aisle as a test obstacle.
3. Run the mapper and upload. It exits 1 if too many points disagree, which almost always means a camera moved: go back to step 05.
4. Check the console map: the pallet shows as grey blocked cells, and a robot sent down that aisle routes around it.

# rig.json
{"cameras": [
  {"id": "dn-1", "fx": 1100, "width": 1920, "height": 1200,
   "position": [19.5, 7.5, 4.5], "look_at": [13.5, 7.5, 0.6]},
  ...
]}

python3 scripts/map_from_cameras.py rig.json frames.json \
  --upload "$ORBITAL_CLOUD_URL" --facility "$ARIA_FACILITY_ID"

1. Mount a 15 cm ArUco tag flat on each robot's top plate, centred, with an ID not used by any floor marker. Record the marker-to-robot map.
2. Put robots on VLAN 20 and confirm the edge node reaches them (ROS 2 DDS, gRPC or the OEM's REST API).
3. Onboard the fleet in the console with Onboard robot API. Grant only the scopes you want Orbital to use: telemetry, state, velocity, E-Stop, mission, map.
4. Switch the edge to live cameras and run the latency bench. Waypoint injection must hold p95 ≤ 100 ms at 10 Hz.

export ARIA_CV_MODE=aruco
export ARIA_ARUCO_MARKER_MAP=/etc/aria/marker_map.json
export ARIA_UNITREE_HARDWARE=1   # per-OEM adapter

python3 -c "
from fleet_adapters import get_adapter
from aria_edge.latency_bench import LatencyBench
a = get_adapter('Unitree', 'rbt-01', use_hardware=True)
print(LatencyBench(hz=10, samples=30).run(a).as_dict())"

1. Pick one repeatable task between two marked stations, for example Aisle AB → Dock.
2. Run it once cleanly. The first complete run with no safety halts becomes the task's golden run in the console's Validation panel; you can promote a different one.
3. Alternate conditions, baseline (robot's own SLAM) then Orbital correction, at least 10 complete runs each.
4. Generate the results sheet. It refuses simulator runs and flags thin samples, so a sheet that exits 0 is safe to quote.
5. Export the runs as training data once the task is stable.

python3 scripts/lab_report.py --url "$ORBITAL_CLOUD_URL" \
  --site "SF lab, rbt-01" --latency bench.json \
  --calibration marker_map.json --out results.md

python3 scripts/export_dataset.py --url "$ORBITAL_CLOUD_URL" \
  --task "Aisle AB → Dock" --out dataset/

DAY-ONE SUCCESS

• Camera and robot VLANs cannot reach the public internet
• Rig calibration exits 0 and the console's Rig Calibration panel reads clean
• A test pallet shows as blocked cells and robots route around it
• Each robot's tag is tracked on the console map
• Waypoint injection p95 ≤ 100 ms at 10 Hz
• A golden run exists for the first task