The simulation showed a clean, collision-free approach to the pick, and the real robot swung its elbow through the bin on the way in. If you send vision-planned TCP poses to an industrial robot over a standard interface, and the executed path looks nothing like the simulated one, the pose itself is usually innocent: the arm reached a different inverse-kinematics branch. This page walks the fault in the order you should debug it — prove the pose arrived intact, find the waypoint where the posture flips, then pin the branch by teaching the pose or forcing a joint move in the planner — and works a numeric example that shows how far an elbow travels while the tool center point never moves.
Why does the robot follow a different path than the planned one?
Expect a joint-configuration branch change first: the vision system sent a TCP pose with no configuration flag, the controller resolved a different inverse-kinematics solution that lands on the identical pose, and the elbow swung through the bin on the way.
The handoff sends coordinates only. The planner simulated the path with its own choice of arm posture; the controller resolved the same pose independently when the program ran. With no posture data in the message, nothing ties the two choices together, and the collision lives in the intermediate links rather than in the pose — which is why the simulation looks clean while the real arm still hits the bin.
Two side checks are worth a minute. An offline validation only certifies the branch the simulator chose, which is exactly the gap described in why an offline path check passes while the robot still collides. And if the handoff was recently set up, run the 3D camera and robot integration checks before deeper kinematics work.
The chain you are about to debug starts at the camera that measured the part:
- Type
- Laser profiler
- Type
- Stereo / structured light
How do I confirm the received pose matches the planned pose?
Log the six planned values next to the six received values and compare digit for digit, with units: a full match here is what moves the search from the interface to the posture the controller chose.
Capture one line per waypoint: the planner's output on the left, the values the controller holds on the right. Repeat for the whole path once. A mismatch in digits, order, count or units is an interface fault and has to be fixed first, because no configuration check can rescue a pose that never arrived.
| Value | Planner sent | Controller holds | Reading |
|---|---|---|---|
| X | 512.348 mm | 512.348 mm | match |
| Y | -236.110 mm | -236.110 mm | match |
| Z | 415.000 mm | 415.000 mm | match |
| W | 30.000° | 0.5236 rad | unit mismatch |
| P | -12.500° | -12.500° | match |
| R | 5.000° | 5.000° | match |
The W row is 30 degrees arriving as 0.5236 radians — exactly 30 × π / 180. A Z of 0.4150 where 415.000 belongs is the same fault in millimetres versus metres; seven values where six belong means one side is sending a quaternion (w, x, y, z) while the other expects Euler angles. If bytes arrive shuffled or scaled, the EtherNet/IP byte-mapping guide for vision results shows how to line the fields up, and the same digit-for-digit log applies to sending part coordinates over a raw TCP socket.
Six values matching to the last digit across a full path repeat clears the interface — the branch selection becomes your prime suspect.
How can one TCP pose produce two different robot postures?
One TCP pose on a six-axis arm can be reached by up to eight different joint solutions; the planner simulated one of them, the controller picked another, and the elbow landed far away while the wrist ended in exactly the same spot.
The pose constrains where the tool ends up; it says nothing about how the arm folds to get there. Industrial six-axis arms group their solutions as elbow up or down, front or back, and wrist flip or no-flip. The elbow carries the largest swing, which is why bin collisions follow branch flips so often. In the plane of the two main links:
Worked example: let L1 = 400 mm and L2 = 450 mm, and place the wrist target at x = 600 mm, y = 250 mm from the shoulder axis. Then x² + y² = 360,000 + 62,500 = 422,500 mm², and L1² + L2² = 160,000 + 202,500 = 362,500 mm², so cos(q2) = 60,000 / 360,000 = 0.1667 and q2 = ±80.4°. Solving q1 for each sign puts the elbow at (374.8 mm, -139.7 mm) on one branch and (164.7 mm, 364.5 mm) on the other, while both wrists land at (600 mm, 250 mm). The two elbows sit √(210.1² + 504.2²) = √(44,142 + 254,218) = 546 mm apart, and the flipped elbow rides 504 mm lower. Put a bin rim anywhere near y = 0 mm along that arc, and the flipped branch drives the elbow about 140 mm underneath it — through the wall, at a pose that never moved.
Real arms add a wrist and joint limits, so the exact elbow positions shift, but the two-branch structure and the swing magnitude carry straight over. Redo this arithmetic once with your own link lengths and you will know your worst-case elbow swing before the first dry run.
How do I check the joint configuration at each waypoint?
Step the program to every waypoint on the pendant and read the configuration stored with each pose: on controllers that hold poses in position registers, the register carries a configuration field beside the coordinates, and that field is what separates the two postures.
- Export the planner's waypoint list for the failing path, expressed in the robot's frame, and keep it next to the pendant.
- Step the executed program to each waypoint in the fault region and write down the joint angles and the configuration flag at every stop.
- Open the position register that received the vision pose and read the configuration field stored beside the coordinates.
- Jog the robot to the same TCP from the posture you want, re-teach the pose, and read the register again — it now stores the configuration you taught. Compare it with the flag from step 3.
- Mark the waypoint where the flag flips: that is the collision waypoint, and it usually sits where a wrist axis crosses 0° or the arm approaches full stretch.
How do I fix the branch: teach the pose or pin it in the planner?
Pin the branch at the source: either re-teach the pose along the path so every waypoint stores its configuration, or insert a fixed-point joint move along the approach so the sequence of axis positions travels with the program.
Teaching is the robot-side fix. Jog to each vision pose along the posture you want, re-teach it, and the register stores the configuration you taught; the linear moves after it hold that branch as long as the path stays reachable. It fixes the executed program but not the source — poses re-sent by the planner still carry no flag, so a changed recipe can reintroduce the flip.
The planner-side fix is a joint move. A fixed-point move is a target defined in axis angles rather than as a pose: the segment above the bin is then followed in joint space, the arm arrives at that point with the posture you taught, and the linear approach after it inherits that posture instead of resolving the pose afresh. Keep the whole approach on one branch — a path that mixes branches mid-approach has to walk through a singularity to change them.
Both fixes are recipe edits on the host that serves the poses to the robot, not rewrites of the robot program:
- LAN ports
- 5+ LAN ports
- USB 3 ports
- 3-4 USB 3 ports
- Light outputs
- 4 built-in channels
- Memory
- 8 GB
When is the pose data itself at fault instead of the IK branch?
Treat a digit mismatch as an interface fault, not a kinematics fault: a value in metres where millimetres belong, an angle in radians where degrees belong, or seven values where six belong each moves the TCP before any branch is chosen.
Frame mismatches produce the same symptom with a different root. Coordinates that match digit for digit but were written for a different tool or base frame land the TCP somewhere else entirely, and the path can collide before any branch is chosen; a 100 mm tool-length difference alone puts 100 mm of error on every waypoint. Check the tool number and user frame the planner assumed against the ones the program uses.
If the poses were built from a point cloud, check the cloud's base plane first: aligning a point-cloud base plane to Z zero covers the upstream frame error that tilts every pose. A path that runs reversed or mirrored with correct coordinates points at the same class of fault — the wrong reference frame behind reversed robot picks walks that case in detail.
The order of operations: matching digits point at kinematics; mismatched digits point at the interface; a shifted path with matching digits points at frames. Fix in that order and re-run the digit log after every change.
What stops a wrong-branch collision from happening again?
Log the configuration flag with every pose you send, keep an explicit lift waypoint above the bin rim before any traverse, and dry-run every new or changed path at reduced speed with a safety-rated stop in reach.
- Digit-for-digit pose log on the first cycle of every new recipe: it separates interface faults from kinematics faults in one run.
- Configuration flag stored with every waypoint, planner side and robot side, so a flip shows up as a two-line diff.
- A lift waypoint raised one worst-case elbow swing above the bin rim before any traverse — compute that swing for your arm with the worked example's arithmetic.
- One branch per approach: no waypoint that sits within about 10° of a wrist-flip posture or near full stretch.
- Simulation that imports the controller's own configuration data, not just the poses.
- Reduced-speed dry run after every recipe change, cell clear, before the first production cycle.
The decision, case by case: values match digit for digit — the controller resolved a different branch, so compare configurations waypoint by waypoint and pin the branch by teaching or a joint move. Values differ — fix the interface mapping first, order and units before anything else. A shifted path with matching values — check tool and user frames before touching kinematics.
For the hardware end of the chain, the 3D sensors category covers the cameras that measure pick poses, and the vision controllers category covers the hosts that run the planner and its robot interface. If a branch problem survives all of this, contact us with the waypoint log and the register's configuration field — that pair usually settles it in one exchange. More robot-integration fixes live on the systems topic page.
Questions
Does a quaternion sign flip explain a different robot posture?
No. Negating every component of a unit quaternion gives the same tool orientation, so the sign carries no posture information. It also carries no joint-configuration flag, so the controller can still resolve either branch. The configuration field of the taught pose is the value that tells the two postures apart, so log that instead of the quaternion sign.
Can I avoid the ambiguity by sending joint targets instead of TCP poses?
Yes. Joint targets leave the controller nothing to resolve: the axes go where the numbers say. Once camera and robot are calibrated, many planners can output joint angles for the whole path. Where yours cannot, teach the intermediate poses on the pendant and store their configuration — that reproduces the same effect locally.
Which axis position warns me that a wrist flip is coming?
A wrist-pitch axis approaching 0° is the classic warning: near that posture the controller can reach the same TCP flipped or unflipped, and the flip spins the wrist rolls rapidly between waypoints. If a waypoint logs that axis within about 10° of zero, add an intermediate pose that keeps it away from the crossing.
Why is the failure intermittent across cycles?
Because the branch the controller resolves can change with tiny pose changes. A pick point that drifts a few tenths of a millimetre between captures can sit near the boundary where the solver switches branches, so one cycle runs clean and the next sweeps the bin. Logging the configuration flag per cycle makes the flip visible immediately.
Does improving camera-to-robot calibration remove the branch problem?
No. Calibration makes the pose numbers correct; a correct pose still has up to eight joint solutions on a six-axis arm. Good calibration still helps, because it removes pose errors that leave the solver hovering near a branch boundary, but the posture itself is fixed only by a configuration flag or joint data sent or taught with the pose.


