Programming Variable Place Points in Robot Pick and Place

Problem: One Pick Point, Many Place Points

The classic pick-and-place cell has a fixed pick location (feeder, conveyor stop, nest) and a place location that must change on every cycle - a tray of pockets, a carton grid, a pallet layer, or a test fixture with N positions. Teaching every place waypoint by hand does not scale: a 6 x 4 x 3 pattern is 72 taught poses, and a single change to pack pitch means re-teaching all of them.

Two implementation strategies solve this, and the choice drives everything downstream (cycle time, recovery behavior, how a technician changes formats):

1. Pattern / palletizing wizard - the robot's programming environment generates the sequence internally from a few taught corner points and counts.
2. Computed pose offsets - you keep a single taught reference pose and add a calculated X/Y/Z offset from an index counter in program logic.

Choosing Between a Wizard and Computed Offsets

Rule of thumb: if the pattern is fixed for the life of the machine and the operator only ever re-teaches the pallet corners after a fixture bump, use the wizard. If part size changes with product, or a PLC owns the recipe, use computed offsets and expose the parameters as variables.

Pattern Math: Index to Cartesian Offset

Every variable-place scheme reduces to converting a single integer counter into a 3D offset. Use a zero-based index i that runs 0 .. (Nx*Ny*Nz - 1):

col   = i mod Nx
row   = (i div Nx) mod Ny
layer = i div (Nx * Ny)

dX = col   * pitchX
dY = row   * pitchY
dZ = layer * pitchZ        ; layer height = part height + interleave/slip sheet

Place pose = reference pose (position 0,0,0 of the pattern) translated by dX, dY, dZ expressed in the pallet frame, not the robot base frame. This distinction is the single most common source of skewed patterns: if you add the offset in base coordinates while the pallet sits at an angle, the rows walk off the pallet as the index grows.

Serpentine (boustrophedon) order

To minimize travel, reverse alternate rows:

IF (row mod 2) = 1 THEN
    col = (Nx - 1) - col
END_IF

Four-corner interpolation for out-of-square pallets

When the pallet or tray cannot be assumed square, teach four corner points P1 (origin), P2 (end of X row), P3 (far corner), P4 (end of Y column) and interpolate with normalized parameters. Guard the divisions when a count equals 1:

u = (Nx > 1) ? col / (Nx - 1) : 0.0
v = (Ny > 1) ? row / (Ny - 1) : 0.0

P = (1-u)*(1-v)*P1 + u*(1-v)*P2 + u*v*P3 + (1-u)*v*P4
P.z = P.z + layer * pitchZ

This bilinear form absorbs small rotations and non-parallel sides of the pallet without requiring a perfectly aligned fixture. Orientation (rotation of the TCP) is normally held constant from the reference pose - interpolating orientation across corners is rarely wanted and can produce wrist flips.

Step-by-Step Implementation

Prerequisites

• TCP correctly defined and payload/CoG entered for the gripper plus the heaviest part. Pattern math is exact; a wrong TCP shifts every computed point.
• A taught, verified pick pose with clean approach and retract vectors.
• Physical pallet/tray located repeatably (hard stops, dowel pins, or a vision offset). Computed patterns assume the fixture returns to the same place.
• Measured pitches. Do not trust the drawing - measure pocket-to-pocket centres on the actual tray and account for stack-up across the full run, not just one pitch.

Procedure

1. Define the pallet frame/feature. Create a coordinate feature aligned with the tray so that +X runs along columns and +Y along rows. All offsets are applied in this frame.
2. Teach the reference pose. Jog to position index 0 with a part actually in the gripper and the part fully seated. Record it as the pattern origin.
3. Teach the remaining corner(s) if using interpolation, or enter the pitches if using pure grid math.
4. Create the loop. Structure the body as: move to approach (place pose offset by a clearance in pallet -Z, typically 25-75 mm depending on part height and interference), linear move down to place, open gripper, dwell for the gripper's stated actuation time, linear retract to approach, then move to the pick pose via a safe transit waypoint.
5. Derive approach and retract from the computed pose, never from a separately taught fixed point. If the approach is a fixed waypoint while the place point moves, the vertical entry vector tilts and the part will drag on pocket walls at the far end of the pattern.
6. Increment and store the index only after a successful place (gripper open confirmed, part-present sensor cleared). Storing before the move causes a skipped pocket after a fault.
7. Test the pattern boundary. When i reaches Nx*Ny*Nz, stop the loop, signal "pallet full" to the PLC/HMI, and reset i to 0 only on an explicit operator or PLC acknowledge - never automatically.

Interfacing With a PLC or HMI

For format changes and traceability, keep the robot dumb and the recipe in the controller. A minimal exchange over the robot's fieldbus (EtherNet/IP, PROFINET, Modbus TCP - whichever the controller supports) looks like this:

Verification and Commissioning

1. Dry-run at reduced speed with no part. Step the index manually to the four extreme corners (0, Nx-1, Nx*(Ny-1), Nx*Ny-1) of the bottom layer and the top layer. These are where reach, singularity and wrist-flip problems appear first.
2. Check joint configuration continuity. Confirm the arm does not change elbow/wrist configuration part-way through a row. If it does, add an intermediate joint-space waypoint or rotate the pallet frame so the whole pattern stays in one configuration.
3. Measure real placements. Place actual parts in indices 0, mid-pattern and last, then measure centre-to-centre with calipers. Cumulative pitch error over 6 columns is the usual culprit for the last pocket missing.
4. Verify the top layer clearance. Approach height must clear the tallest already-placed part, plus gripper fingers, plus any interleave sheet.
5. Fault-recovery test. E-stop mid-place, release, and resume. Confirm the robot returns to the same index rather than skipping or repeating. Repeat with a full controller power cycle to prove index retention.
6. Boundary test. Force the index to the final value and confirm the pattern-complete handshake fires and the loop does not roll over into an off-pallet coordinate.
7. Speed ramp. Only after geometry is proven, raise speed/acceleration in steps and re-check part seating - inertia at the retract can lift or tip a freshly placed part.

Common Failure Modes

When a Wizard Is Not Enough

Move to computed offsets when any of these apply: multiple product formats share one cell; the last layer is routinely short-filled; pockets must be skipped based on an inspection result; the pallet position is corrected by vision each cycle; or the pattern is not a rectangular grid (circular, staggered/brick-bond, or nested layouts). Staggered layouts in particular are simple in code - offset alternate rows by half a pitch:

IF (row mod 2) = 1 THEN
    dX = col * pitchX + (pitchX / 2.0)
END_IF

For circular patterns, replace the Cartesian grid with polar math and rotate the TCP about the pallet Z axis by the same angle if the part must stay radially aligned - but confirm the added rotation does not exceed the wrist joint range at the extremes.

FAQ