Get current pose as Transform2D.

Get next "received" frame.

Register a pre-built tool (for config-based tools like VESC blowers).

RLE encode: produces `[count:u8][value:u8]` pairs.

Save the current map (keyframes + edges) to a binary file. Uses atomic write (temp file + rename) for crash safety.

Send a CAN frame as SLCAN over serial

Send SLCAN OK response

Serialize tracked obstacles to binary.

Set a simple goal (for testing without dispatch).

Write the buffer to the LED strip

Smooth a path using Catmull-Rom interpolation. For each pair of consecutive waypoints, generates interpolated points using the Catmull-Rom spline thr

Start a recovery behavior.

Generate 2D DXF flat pattern for laser cutting Simple 4-bend layout (vertical walls only): ```text ┌─────────────────────┐ │ BOTTOM │ │

Build CAN frame for this command.

Train the behavioral cloning policy and export to JSON. Loads the demonstration dataset, splits into train/validation, trains the MLP with MS

Transform a point from child frame to parent frame.

Process incoming command. Returns true if should be processed.

Back-project a depth map to 3D points in rover body frame, classified as ground or obstacle. Coordinate frames: - Camera: Z-forward, X-right, Y-down

Get the LED buffer without updating.

Cancel current task.

Catmull-Rom spline evaluation at parameter t in [0, 1] between p1 and p2.

Clear the current goal and path.

Get the command address (MCU IP + command port).

Compute autonomous control output given current state and goal Returns the twist command and metadata about the computation.

Compute cost-based speed scaling factor by sampling points from robot to lookahead. Returns a factor in [min_cost_speed_fraction, 1.0] where lower va

Get number of registered tools.

Create T-slot profile (to be subtracted from bar)

Downsample a point cloud with custom configuration.

Initialize GStreamer (safe to call multiple times). Note: This can hang on Jetson with NVIDIA plugins if the registry is not properly initialized. Th

Estimate local covariance matrices for each point using SVD of k-nearest neighbors.

Generate LiDAR geometry Livox Mid-360 representation: - 65×65×60mm total dimensions - Rectangular base with hemispherical scanning window - Window is

Generate VESC geometry

Run inference to get an action from a structured observation. This is the primary entry point for the control loop. It flattens the observation into

Get the LED command for the current mode.

Lookup transform from child frame to parent frame.

Build CAN ID for a tool message.

Create a scan simulating a box room viewed from a given sensor position. Room walls at x=±5, y=±5. Points include floor (z≈0) and multiple elevation

Convert a twist command to wheel velocities (rad/s). For a skid-steer robot: - Left wheels: (v - ω × L/2) / r - Right wheels: (v + ω × L/2) / r Wher

Parse a forwarded command JSON value into a `types::Command`. The depot dispatch service sends commands as `{"type": "estop"}`, `{"type": "set_mode",

Parse a GSV NMEA sentence

Try to parse a complete VESC UART packet from the buffer. Returns `Some((payload, bytes_consumed))` if a complete packet is found, or `None` if more

Get the EKF pose covariance as a plain 3x3 array (for watch channels).

Predict step: propagate state and covariance forward by dt seconds. Motion model: `F = [[1, dt], [0, 1]]` (constant velocity)

Parse a COMM_GET_VALUES response and push synthesized CAN STATUS frames. The COMM_GET_VALUES response is ~70 bytes. We extract key fields at known of

Raytrace a line, marking cells as free and the endpoint as occupied.

Release operator status (on disconnect or explicit release).

RLE decode: expands `[count:u8][value:u8]` pairs back to flat data.

Compute rotation matrix from Euler angles (roll, pitch, yaw). Convention: R = Rz(yaw) * Ry(pitch) * Rx(roll)

Get current mechanical RPM (ERPM / pole_pairs).

Get current mechanical RPM (ERPM / pole_pairs).

Save sessions database to disk

Generate a LiDAR scan from the given pose. # Arguments `world` - The simulated world to ray-cast against `x` - Rover X position in world frame `y` -

Send a single u8 parameter and drain the ACK.

Send a message to a specific rover

Set a new goal and plan path.

Subscribe to dispatch events

Convert to a Pose struct.

Update last activity timestamp (called on any valid command from operator).

Update with classified 3D points from one or more cameras. Projects all points to 2D (ground plane) and runs ICP against the previous frame. Returns

SLAM pose update with scan-match covariance.

Upload a file via SCP

Voxel downsample a point cloud. Returns centroids per voxel cell.

Convert world coordinates to grid cell.

Get the active tool.

Add hoverboard wheels - mounted to bottom frame rail via through-hole axle

Get filtered battery voltage (smoothed to reduce noise).

Build a duty cycle command frame (without sending).

Build payload for work mode parameter configuration (convenience wrapper).

Get cell index from grid coordinates.

Check if a circle (rover footprint) collides with any obstacle. Uses conservative AABB check.

Clear all active alerts matching source+source_id+message pattern

Compute control output to follow the path. # Arguments `path` - Path to follow `pose` - Current robot pose `costmap` - Costmap for obstacle checking

Compute a hybrid initial guess combining odometry translation with IMU yaw. Uses odometry for (x, y) translation and the pre-integrated IMU delta for

Compute soft-max weights from costs.

Get a reference to the config.

CRC16-CCITT (poly 0x1021, init 0x0000) — standard VESC CRC.

Set the description.

Auto-detect available cameras on the system. Uses lightweight filesystem scanning for V4L2 devices to avoid GStreamer initialization overhead (which

Downsample a point cloud using voxel grid filtering. Each voxel cell keeps the point with highest reflectivity (most visible). Points are sampled uni

Drain a single ACK response (non-blocking, best-effort).

Expand bounds to include a new point

Export weights and biases for the Rust policy JSON format. Iterates through the Sequential modules, extracts weight matrices and bias

Force into e-stop (for critical safety).