Edit a multi-waypoint relative trajectory after camera locate

Glue dispensing, sealing and screw-checking cells share one pattern: the camera finds the part, then the robot runs a multi-waypoint path across it. The pain arrives at the second revision, when one waypoint must move and the tempting move is to re-teach everything. Set the program up so the whole trajectory hangs off a single feature point saved at the camera-detected position, and an edit becomes one jog and one save. This guide gives you the program structure, the teach and edit procedures step by step, the arithmetic that shows why edits survive a re-locate, and a checklist before you release the program to production.

Store the path as offsets, not poses

Decide the storage rule before you write a single motion: every waypoint of the process path is a pose offset from one feature point, and that feature point is saved at the position the camera locate node reports. Nothing in the trajectory references the base frame directly. The controller then does the same arithmetic on every cycle:

Worked example: the locate finds the part at X_ref = 412.5 mm, Y_ref = 238.0 mm, rotated θ = 5° from the teach pose. A dispensing waypoint was taught at (+80.0, +20.0) mm from the feature. At 5°, cos θ = 0.9962 and sin θ = 0.0872, so:

x' = 80.0 × 0.9962 − 20.0 × 0.0872 = 77.95 mm, and 412.5 + 77.95 = 490.5 mm

y' = 80.0 × 0.0872 + 20.0 × 0.9962 = 26.90 mm, and 238.0 + 26.90 = 264.9 mm

Stored in base coordinates, the waypoint would still command 492.5, 258.0 mm — the teach-time position — and miss the bead by about 7 mm. Stored as an offset, the controller computes 490.5, 264.9 mm and the tool lands on the bead.

The single-point version of this — moving the tool to one detected frame — is laid out in move a robot relative to a vision-detected part frame; what follows extends it to a path of many waypoints.

The four pieces of the program

Four containers do all the work. Pendants name them differently — some call the feature point a user frame or a work object — but the roles are fixed:

1. Camera locate node with its snapshot position (profil1 in these examples). It fires at a fixed robot pose and returns the detected pose of the profile.
2. Master setup folder — plain motion instructions that carry the TCP from the locate result to the feature origin, orientation included.
3. Feature point (rTrajectoryRef here) — a saved pose you overwrite once per setup.
4. Relative trajectory folder — every waypoint defined from the feature point, one instruction per bead segment.

The trick is suppression, and the two folders take turns: master setup runs while the trajectory is suppressed, then they swap. That is what lets you drive the robot to a pose computed from a live camera result, save the feature point there, and only then edit the trajectory against it.

The locate layer itself is a smart camera or compact vision sensor reading the profile — the smart cameras category is the hardware class for the job.

Size the snapshot view first

Size the view before you teach profil1. The locate node fires at a fixed pose, so the feature must sit inside the field of view with margin at every expected part position:

For a 1/6-inch sensor — about 3.2 × 2.4 mm — with a 3 mm lens at a 240 mm working distance: FOV_w ≈ 3.2 mm × 240 mm / 3 mm = 256 mm and FOV_h ≈ 2.4 mm × 240 mm / 3 mm = 192 mm. A 140 × 70 mm glue path leaves about 58 mm of margin at the sides and 61 mm at top and bottom. At 0.3 MP — 640 × 480 pixels — the scale is 256 mm / 640 px = 0.4 mm per pixel, enough to hold a profile edge well inside a millimetre; gauging bead width is where you want more pixels.

The lens focal length calculator runs the same relation from the other side: give it the view and the working distance, it returns the focal length and filters the shop to lenses that deliver it.

The MV-SCA002M-03S-WBN-SR pairs a 3 mm lens with a 240 mm focus distance on a 1/6-inch sensor — compact locate hardware that matches the numbers above.

Teach the feature point once: the master-setup pass

What you need: the locate node configured and its snapshot position taught, an empty trajectory folder, and an empty pose variable for the feature point. Then:

1. Unsuppress the master setup folder and keep the relative trajectory folder suppressed.
2. Run the program once. The locate node fires at the snapshot position, and the master-setup motions drive the TCP to the detected object position, orientation included.
3. Suppress the master setup folder.
4. Unsuppress the relative trajectory folder.
5. Save the current TCP pose into the feature point — rTrajectoryRef, position and orientation, not just the X-Y-Z.
6. Define the relative trajectory: create each waypoint relative to the feature point, walking the bead in order.
7. Save. The production state is master setup suppressed and the trajectory unsuppressed.

If the locate node refuses to fire, the usual culprit is stream versus snapshot mode: vision locate works in teach but fails at run time walks through that failure.

Edit one waypoint: the same pass, one change

Editing is the same cycle with one insertion. To move waypoint 3 of 9 by 2.0 mm along the bead:

1. Unsuppress master setup and suppress the trajectory folder.
2. Run once so the robot sits at the detected position again, in the same part pocket as the original teach.
3. Suppress master setup and unsuppress the trajectory folder.
4. Re-save the feature point at the current TCP pose.
5. Correct only waypoint 3: type the new offset, or jog the tool to the corrected pose and save that waypoint relative to the feature point.
6. Run the full program — one cycle at reduced speed, then production speed.

The other eight waypoints never move, because they reference the same feature point you just re-saved.

Check the edit before production

Run this sequence before you release the program:

• One full cycle at 10 to 25% of program speed.
• Dispense on three to five parts and measure bead start and end against the part edge with calipers; log the deviation. With the 0.4 mm per pixel scale above, expect a spread well under a millimetre part to part once the mechanics are stiff.
• Run the master-setup pass on a second part from the same batch: the feature point moves by the part shift and the bead still lands in the same place on the part. That proves the offsets are live, not frozen.
• Confirm nobody jogged the camera or the snapshot position between runs. Why the robot must return to the snapshot position first explains what breaks when it moves.
• After a joint replacement or a camera remount, redo both passes: restore vision accuracy after a robot joint replacement covers the recovery.

Common mistakes

• Feature saved at the wrong pose. The bead shifts by the same vector on every part. Cause: the master-setup run never executed before the save. Redo the pass.
• Orientation skipped. Master setup ends over the right point at the wrong approach angle, so every waypoint lands rotated around the feature. Redo the pass with the taught orientation.
• One waypoint defined in base coordinates "just this once". It stops following the part. Redefine it relative to the feature point.
• Edit made in a copied program without re-saving the feature point. The offsets point at a stale reference. Run the pass in the copy before judging the result.
• Robot or camera jogged between locate and the master-setup run. The located pose is stale. Re-run the locate before the pass.
• Two parts, one snapshot position. The locate grabs whichever part it sees. Teach separate snapshot positions — teach two parts in one vision program: separate snapshot positions shows the pattern.

When one feature point is not enough

Stretch one reference too far and the structure starts fighting you:

• Parts on several planes. With a fixed height step, teach one snapshot position per plane and offset between them: one snapshot position for multiple planes: apply an offset gives the math. With mixed heights, split into one locate-and-trajectory per plane.
• Part variants batch to batch. Keep one taught model per variant instead of stretching one model over every size: teach one model per batch is the pattern.
• Not sure the locate can hold the feature at all? Run the feasibility checklist before you teach before writing any of the structure above.

Release checklist

Before the cell runs unattended:

• Snapshot position taught, its pose recorded, camera mounting tight.
• Locate tested on parts at both ends of the tolerance band, not just the nominal part.
• Feature point saved through the master-setup pass, orientation included.
• Every trajectory waypoint defined relative to the feature point, none in base coordinates.
• One reduced-speed cycle run clean, then one at production speed.
• Bead position measured on sample parts and the deviation logged with the program.
• Final save in the production state: master setup suppressed, trajectory unsuppressed.

Each line guards against a failure that shows up as a shifted bead, a crash, or a path that quietly stops following the part.

Build or rework the locate layer

If you are rebuilding the locate hardware along with the program, both sensors below are Fast Ethernet vision sensors with a global shutter and an M12 lens mount.

The shop camera finder filters by resolution, sensor format and mount, and the camera configurator pairs a sensor with a lens and mount for the working distance you sized above. A bench rig built on one of the camera stands makes the first snapshot-position teach and calibration quicker to set up and repeat. To talk the structure above through against your cell, contact us, or browse the procedure guides on the systems topic page.