CODE · AUTONOMOUS

Visual Path Planning

The middle pillar of how we code: VEXcode teaches, Path Planner visualizes, the drive library competes. This is the "visualize" step — designing an autonomous route on a screen instead of guessing numbers in code.

Writing an autonomous routine as a wall of driveFor(24); turnTo(90); calls means guessing distances and angles, then re-running the robot over and over to tune them. A path planner lets you draw the route on a picture of the field, see it before you ever deploy, and export a file your code follows. It turns a blind tuning loop into a visual design problem.

Where it fits

Path planning is one stage in a pipeline. Each tool does one job well:

Teaches
VEXcode / EZ
Learn the language and basic movement. Where everyone starts.
Visualizes
Path Planner
Design the route on the field. Preview and export a path file.
Competes
Drive Library
Read the path file and follow it accurately on the real field.

The tool: PATH.JERRYIO

The path planner most V5RC teams use is PATH.JERRYIO — a free, web-based editor. It lets you design, preview, and simulate driving routes for skills and autonomous, then generate a path file the robot reads. If you have used a design tool like Figma, the click-and-drag interaction will feel familiar.

One detail that makes it click into V5RC cleanly: it uses the same coordinate system as the V5 GPS sensor — the field origin is at the center, Y increases toward north and X toward east, and a VRC field is 12 feet square with 2-foot tiles. So the coordinates you see in the planner match how the field is actually measured.

The workflow

1
Design the path. Open the editor, drop control points on the field where you want the robot to go, and drag to shape the curve and headings between them. You are drawing the route, not computing it.
2
Preview it. Step through the route on screen to check it clears obstacles and reaches scoring positions before you ever touch the robot.
3
Export a path file. Generate a file in the format your drive library expects. Defining a path purely in code is impractical, so the planner produces a readable path file instead.
4
Follow it in code. Import or reference the path file, then call your library's follow function to make the robot travel the designed path during the autonomous period. The planner creates the path; the library reads and follows it.
How it actually moves
The robot follows the exported path using a path-following algorithm — most commonly pure pursuit, which needs odometry to know where the robot is. The planner is responsible for creating the path file; the library is responsible for reading it and following it. That division is why path planning sits between coding and the drive library, not inside either one.

When to reach for it

Path planning earns its place when a routine has several waypoints, curves, or a skills run where hand-tuned straight-line moves get tedious and brittle. For a two-move autonomous, plain coded movements are fine — learn those first on the first auton exercises. Reach for the planner once the route gets complex enough that seeing it beats guessing it.

It is also the natural tool for designing a one-minute driver-skills route, since you can lay out and share the whole run visually.

Prerequisite
Path following only works if the robot knows its position. Before path planning pays off, get odometry working — tracking wheels or IMU + motor encoders feeding a position estimate. A beautiful path is useless to a robot that cannot tell where it is.

Our take

In the Spartan model, Path Planner is the visualize step: it bridges learning to compete. You learn movement in VEXcode, you see the route in the planner, and the drive library executes it. None of the three replaces the others — they hand off to each other. A programmer who can plan a path visually, then trust the library to follow it, spends tuning time on strategy instead of on guessing numbers.

Odometry → Build an odom pod → Sensor-based autonomous → First auton exercises → Build your own drive library →
External References
PATH.JERRYIO — the editor ↗ PATH.JERRYIO documentation ↗
A thinking aid, not notebook text. RECF EN4 prohibits AI-generated content in engineering notebooks and code — if you write about path planning in your notebook, write it in your own words from your own runs.