Stage 13 · Lesson 14/16

Robot Perception, Planning & Manipulation · Lesson 14

Pick-and-Place Planning

Est. 60–75 min

Why

Why this lesson matters

A full pick-and-place task is a chain: pick (Lesson 13), carry the object to the place area, choose a place pose for the object, work out the matching gripper pose, lower, release, and retreat. Every link uses the same world model, and the held object is part of the robot while it is carried. If any link fails — the place pose is out of reach, the wrist cannot turn that far, a finger would hit a neighbour — the planner must try another candidate, just as the grasp planner did in Lesson 12.

In the code lab you will convert “where the object should be” into “where the gripper must go”, test place candidates on a shelf with a cup on it, pick the one that needs the least wrist turning, and see why release height and retreat direction matter. On the bench, your UNO will run a guarded place: turn the wrist, lower fast then slow, open the jaw just above the shelf, and retreat straight up.

Concept

Pick, carry, place, release, retreat

1. The task as a chain of stages

The MoveIt Task Constructor tutorial builds the same chain: a “move to place” connect stage, then a place container with generate place pose, open hand, forbid collision (hand, object), detach object and retreat — and finally return home.
StageWhat happensPlanner / check
Pick (Lesson 13)pre-grasp, approach, close, attach, liftgrasp candidates, straight-line moves
Move to placecarry the object to above the place areafree-space planner, held object checked for collisions
Generate place posecandidate poses for the OBJECT on the target surfacereach, wrist limits, support, room for fingers
Lower / releasecome down to the surface, open the handslow near contact; then hand–object contact no longer allowed
Detachthe object belongs to the world againworld model updated
Retreatmove the hand away from the placed objectstraight-line move, away first

2. Object pose → gripper pose

You usually know where the object should end up (“on the shelf mark, square to the edge”). The robot, however, moves the gripper. The link between them is the grasp offset: where the gripper holds the object, measured in the object’s own frame. If the grasp was 1 cm from the box centre, then gripper pose = object pose × grasp offset. Forget the offset and the box lands exactly 1 cm away from the mark — Riya’s first mistake. MoveIt solves this by remembering how the object was attached during the pick and computing inverse kinematics for the place pose with that attachment.

A large yellow robot arm in the foreground of a bright laboratory, with a second yellow arm and white lab instruments in the background
A lab automation cell at the US National Center for Advancing Translational Sciences: the arm in front takes assay plates from incubators and places them at transfer stations or hands them to the second arm — pick-and-place, all day long.Photo: National Center for Advancing Translational Sciences from Bethesda, MD · Public domain · Source: Wikimedia Commons · resized, converted to WebP

3. Place candidates and checks

Like grasps, places are generated, filtered and ranked. Generate: a few spots on the target surface, each with a few object yaws. Filter: can the arm reach the gripper pose? Can the wrist turn that far? Is the whole object footprint on the support (not hanging over the edge)? Is there room for the open fingers beside neighbours? Rank: least wrist turning, shortest carry, farthest from neighbours — whatever matters for your cell.

4. Release gently, retreat away first

If the jaw opens while the object is still above the surface, it falls. Neglecting air resistance, an object dropped from height d lands at v = √(2·g·d): from 2 cm that is already about 0.63 m/s — enough to bounce or tip a light box. So lower until the object is (almost) touching, then open. After opening, the fingers are only a few millimetres from the object, so the first move must be away (straight up for a top-down place); only then move sideways.

Visual

Visualise it: one pick-and-place task

One task, many phases: pick, carry, place, release, retreat. Step through the phases and reset. (Educational simulation.)

Interactive · Pick-and-place planner · Educational

Approach grasp liftPick and place
ApproachGraspLiftTransitPlaceRetreat

Ready — step through Approach → Retreat.

Educational pick/place — not MoveIt task constructor / not industrial cell planner.

Code lab

Code lab: plan a place on a crowded shelf

place_planning_lab.py is a top view of the desk (cm, degrees). A 2-link arm (15 cm + 12 cm, with a 1 cm safety band at both ends of its reach) carries the 3 × 6 cm eraser box from Lesson 12. The grasp is 1 cm from the box centre along its long side. The shelf spans x 12–22, y −8 to 8, and a cup of radius 2.5 cm stands at (18, 6.5). The wrist can turn ±80°. All sizes are example numbers.

place_planning_lab.py · Python
"""Pick-and-place planning lab (Stage 13, Lesson 14) - plain Python, no libraries.

Top view of a desk (x, y in cm, yaw in degrees). The eraser box from Lesson 12
(3 x 6 cm) is picked with a top-down parallel gripper and must be placed on a
shelf. We work out where the GRIPPER must go for a wanted OBJECT pose, check
place candidates, and see why release height and retreat matter.
All sizes are EXAMPLE numbers.
"""
import math

L1, L2 = 15.0, 12.0
REACH = (abs(L1 - L2) + 1, L1 + L2 - 1)   # 1 cm safety band at both ends
WRIST = 80.0                              # wrist yaw limit after folding (deg)
BOX_W, BOX_L = 3.0, 6.0                   # grasp across the 3 cm width
FINGER, CLEAR, PAD = 1.0, 0.5, 1.2        # finger thickness, opening clearance, finger width
SHELF = (12.0, 22.0, -8.0, 8.0)           # support area x0, x1, y0, y1
CUP = ((18.0, 6.5), 2.5)                  # a cup already on the shelf


def compose(a, b):
    """pose a followed by pose b (2D: x, y, yaw)."""
    ax, ay, at = a; bx, by, bt = b
    c, s = math.cos(math.radians(at)), math.sin(math.radians(at))
    return (ax + c*bx - s*by, ay + s*bx + c*by, at + bt)


def inverse(p):
    x, y, t = p
    c, s = math.cos(math.radians(t)), math.sin(math.radians(t))
    return (-(c*x + s*y), -(-s*x + c*y), -t)


def fold(deg):
    deg = (deg + 180) % 360 - 180
    if deg > 90: deg -= 180
    if deg < -90: deg += 180
    return deg


def corners(pose):
    out = []
    for dx, dy in ((-BOX_W/2, -BOX_L/2), (BOX_W/2, -BOX_L/2), (BOX_W/2, BOX_L/2), (-BOX_W/2, BOX_L/2)):
        out.append(compose(pose, (dx, dy, 0))[:2])
    return out


print('1. Object pose -> gripper pose (the grasp offset matters)')
# grasp found in Lesson 12, written in the OBJECT frame: 1 cm along the box's long axis,
# fingers squeezing across the width (gripper yaw = object yaw)
grasp_in_obj = (0.0, 1.0, 0.0)
target_obj = (16.0, -2.0, 0.0)
right = compose(target_obj, grasp_in_obj)
print(f'   want the box at {target_obj}; grasp offset in the object frame {grasp_in_obj}')
print(f'   gripper must go to ({right[0]:.1f}, {right[1]:.1f}, yaw {right[2]:.0f})')
for yaw in (0, 90):
    t = (16.0, -2.0, float(yaw))
    g = compose(t, grasp_in_obj)
    wrong_obj = compose((t[0], t[1], t[2]), inverse(grasp_in_obj))  # where the box ends up if we send the gripper to t
    err = math.hypot(wrong_obj[0] - t[0], wrong_obj[1] - t[1])
    print(f'   object yaw {yaw:3d}: gripper ({g[0]:5.1f}, {g[1]:5.1f}); forgetting the offset puts the box {err:.1f} cm off target')
back = compose(compose(target_obj, grasp_in_obj), inverse(grasp_in_obj))
print(f'   check: gripper pose x inverse(grasp) = ({back[0]:.1f}, {back[1]:.1f}, {back[2]:.0f}) = object pose\n')


def check_place(obj):
    g = compose(obj, grasp_in_obj)
    r = math.hypot(g[0], g[1])
    if not (REACH[0] <= r <= REACH[1]):
        return None, f'out of reach (r {r:.1f} cm)'
    wy = fold(g[2])
    if abs(wy) > WRIST:
        return None, f'wrist limit (needs yaw {wy:+.0f})'
    x0, x1, y0, y1 = SHELF
    if not all(x0 <= cx <= x1 and y0 <= cy <= y1 for cx, cy in corners(obj)):
        return None, 'overhangs the shelf edge'
    # fingers beside the long faces, at the grasp point, pre-opened by CLEAR
    for side in (-1, 1):
        off = side * (BOX_W/2 + CLEAR/2 + FINGER/2)
        f = compose(g, (off, 0.0, 0))
        (cx, cy), cr = CUP
        if math.hypot(f[0] - cx, f[1] - cy) < cr + max(FINGER, PAD)/2 + 0.3:
            return None, 'finger hits the cup'
    (cx, cy), cr = CUP
    if any(math.hypot(px - cx, py - cy) < cr + 0.3 for px, py in corners(obj)):
        return None, 'box overlaps the cup'
    return g, 'OK'


print('2. Place candidates on the shelf (x 12-22, y -8..8) with a cup at (18, 6.5)')
spots = [(16.0, -2.0), (17.0, 3.5), (14.0, 4.0), (20.5, -1.0), (28.0, 0.0)]
ok = []
for x, y in spots:
    for yaw in (0, 45, 90):
        g, why = check_place((x, y, float(yaw)))
        print(f'   box at ({x:4.1f}, {y:4.1f}) yaw {yaw:3d}: {why}')
        if g:
            ok.append(((x, y, yaw), g))
print(f'   -> {len(ok)} of {len(spots)*3} candidates usable\n')

print('3. Choose: least wrist turning from the pick (picked at gripper yaw +30)')
PICK_YAW = 30.0
best = min(ok, key=lambda c: abs(fold(c[1][2]) - PICK_YAW))
for (obj, g) in ok:
    print(f'   box {obj}: wrist turn {abs(fold(g[2]) - PICK_YAW):4.0f} deg')
print(f'   -> chosen {best[0]}\n')

print('4. Release height: open the jaw this high above the shelf')
g = 9.81
for h in (0.0, 0.5, 2.0, 5.0):
    v = math.sqrt(2 * g * h / 100)
    print(f'   {h:3.1f} cm -> box lands at {v:.2f} m/s')
print('   -> lower until the box touches (force drop / sensor), then open.\n')

print('5. Retreat after releasing: open first, then go up')
finger_gap = BOX_W/2 + CLEAR/2   # finger inner face distance from the box centre after opening
print(f'   jaw open by {CLEAR} cm -> each finger {CLEAR/2:.2f} cm from the box face')
SIDE_STEP = 1.0  # cm the arm would slide sideways on its way back
for move in ('up first', 'sideways first'):
    room = CLEAR/2
    hit = move == 'sideways first' and SIDE_STEP > room
    print(f'   {move:<15} -> ' + (f'finger drags the box ({SIDE_STEP} cm slide, only {room} cm of room)' if hit else 'clear'))

Output (run with python3 place_planning_lab.py)

1. Object pose -> gripper pose (the grasp offset matters)
   want the box at (16.0, -2.0, 0.0); grasp offset in the object frame (0.0, 1.0, 0.0)
   gripper must go to (16.0, -1.0, yaw 0)
   object yaw   0: gripper ( 16.0,  -1.0); forgetting the offset puts the box 1.0 cm off target
   object yaw  90: gripper ( 15.0,  -2.0); forgetting the offset puts the box 1.0 cm off target
   check: gripper pose x inverse(grasp) = (16.0, -2.0, 0) = object pose

2. Place candidates on the shelf (x 12-22, y -8..8) with a cup at (18, 6.5)
   box at (16.0, -2.0) yaw   0: OK
   box at (16.0, -2.0) yaw  45: OK
   box at (16.0, -2.0) yaw  90: wrist limit (needs yaw +90)
   box at (17.0,  3.5) yaw   0: finger hits the cup
   box at (17.0,  3.5) yaw  45: finger hits the cup
   box at (17.0,  3.5) yaw  90: wrist limit (needs yaw +90)
   box at (14.0,  4.0) yaw   0: finger hits the cup
   box at (14.0,  4.0) yaw  45: overhangs the shelf edge
   box at (14.0,  4.0) yaw  90: wrist limit (needs yaw +90)
   box at (20.5, -1.0) yaw   0: OK
   box at (20.5, -1.0) yaw  45: overhangs the shelf edge
   box at (20.5, -1.0) yaw  90: wrist limit (needs yaw +90)
   box at (28.0,  0.0) yaw   0: out of reach (r 28.0 cm)
   box at (28.0,  0.0) yaw  45: out of reach (r 27.3 cm)
   box at (28.0,  0.0) yaw  90: out of reach (r 27.0 cm)
   -> 3 of 15 candidates usable

3. Choose: least wrist turning from the pick (picked at gripper yaw +30)
   box (16.0, -2.0, 0): wrist turn   30 deg
   box (16.0, -2.0, 45): wrist turn   15 deg
   box (20.5, -1.0, 0): wrist turn   30 deg
   -> chosen (16.0, -2.0, 45)

4. Release height: open the jaw this high above the shelf
   0.0 cm -> box lands at 0.00 m/s
   0.5 cm -> box lands at 0.31 m/s
   2.0 cm -> box lands at 0.63 m/s
   5.0 cm -> box lands at 0.99 m/s
   -> lower until the box touches (force drop / sensor), then open.

5. Retreat after releasing: open first, then go up
   jaw open by 0.5 cm -> each finger 0.25 cm from the box face
   up first        -> clear
   sideways first  -> finger drags the box (1.0 cm slide, only 0.25 cm of room)

Try it: step through Approach → Grasp → Lift → Retreat. Then do it again in your head for the place: move to place → lower → open → retreat up. (Educational simulation, not a real motion planner.)

Interactive · Pick-and-place planner · Educational

Approach grasp liftPick and place
ApproachGraspLiftTransitPlaceRetreat

Ready — step through Approach → Retreat.

Educational pick/place — not MoveIt task constructor / not industrial cell planner.

Bench build: a guarded place on the UNO

place_executor.ino is the second half of Lesson 13’s pick. The PC (or you, in the Serial Monitor) sends P <yaw>, for example P 45. The UNO refuses yaws beyond ±80°, turns the wrist, then lowers using the HC-SR04 that looks down from the gripper: fast while the box is more than 4 cm above the shelf, slow inside that zone, and it opens the jaw when the box bottom is 0.5 cm above the shelf. Then it retreats straight up, and only then turns the wrist back. The abort button lifts the arm at any time.

Safety: never power the three servos from a GPIO pin or the UNO 5 V pin — together they can draw far more current than the board can supply; use a separate 5–6 V supply with a common ground. Set LIFT_DOWN_MAX so the empty gripper can never reach the shelf, and keep fingers out of the jaw while testing.
PartConnectionNote
Wrist servosignal → D10WRIST_CENTRE = servo angle for yaw 0; check ±80° does not hit end stops
Lift servosignal → D9LIFT_UP and LIFT_DOWN_MAX measured with the gripper empty
Gripper servosignal → D6JAW_HOLD from Lesson 13; JAW_RELEASE opens only a little
Servo supplyred → +5–6 V, brown → supply GNDseparate supply; supply GND joined to UNO GND
HC-SR04 (on the gripper, looking down)VCC 5 V, TRIG → D7, ECHO → D8, GNDmeasure BOX_BELOW_CM (sensor to box bottom); range starts at 2 cm
Abort buttonD3 → button → GNDINPUT_PULLUP
place_executor.ino · Arduino C++
// Stage 13 - Lesson 14: Pick-and-Place Planning - place executor (Arduino UNO)
// The PC plans the place (where, which yaw). The UNO does the careful part:
// turn the wrist, lower fast then slow, release just above the shelf, retreat UP first.
// Serial (115200):  "P <yaw>"  e.g. "P 45"   -> place at that wrist yaw
//                   "H"                       -> go home (up, wrist 0, jaw closed on part)
// Wiring:
//   Wrist servo signal  -> D10   Lift servo signal -> D9   Jaw servo signal -> D6
//   Servo power: separate 5-6 V supply (NOT the UNO 5V pin), grounds joined
//   HC-SR04 on the gripper, looking down: TRIG -> D7, ECHO -> D8, VCC 5V, GND
//   Abort button D3 -> GND (INPUT_PULLUP)
// All angles and distances are EXAMPLE values - measure your own arm.
#include <Servo.h>

const int WRIST_PIN = 10, LIFT_PIN = 9, JAW_PIN = 6;
const int TRIG_PIN = 7, ECHO_PIN = 8, ABORT_PIN = 3;

const int WRIST_CENTRE = 90;     // servo angle for yaw 0
const int WRIST_LIMIT = 80;      // allowed yaw -80..+80
const int LIFT_UP = 40, LIFT_DOWN_MAX = 140;   // servo angles (bigger = lower)
const int JAW_HOLD = 60, JAW_RELEASE = 75;     // open just a little to release

const float BOX_BELOW_CM = 3.0;  // box bottom is this far below the sensor
const float SLOW_ZONE_CM = 4.0;  // slow down when the box is this close to the shelf
const float RELEASE_CM = 0.5;    // open the jaw when the box is this high

Servo wrist, lift, jaw;
int liftPos = LIFT_UP;

float readCm() {
  digitalWrite(TRIG_PIN, LOW);  delayMicroseconds(2);
  digitalWrite(TRIG_PIN, HIGH); delayMicroseconds(10);
  digitalWrite(TRIG_PIN, LOW);
  unsigned long us = pulseIn(ECHO_PIN, HIGH, 30000UL);
  if (us == 0) return -1;            // no echo
  return us / 58.0;
}

bool aborted() { return digitalRead(ABORT_PIN) == LOW; }

void goUp() {
  while (liftPos > LIFT_UP) { liftPos--; lift.write(liftPos); delay(10); }
}

void goHome() {
  goUp();
  wrist.write(WRIST_CENTRE);
  Serial.println(F("HOME"));
}

void place(int yaw) {
  if (yaw < -WRIST_LIMIT || yaw > WRIST_LIMIT) {
    Serial.println(F("REFUSED wrist limit - replan with another yaw"));
    return;
  }
  wrist.write(WRIST_CENTRE + yaw);
  delay(400);
  while (true) {
    if (aborted()) { goUp(); Serial.println(F("ABORT")); return; }
    float d = readCm();
    if (d < 0) { goUp(); Serial.println(F("FAIL no echo")); return; }
    float boxGap = d - BOX_BELOW_CM;          // box bottom to shelf
    if (boxGap <= RELEASE_CM) break;          // close enough: release
    if (liftPos >= LIFT_DOWN_MAX) { goUp(); Serial.println(F("FAIL no shelf found")); return; }
    liftPos++;
    lift.write(liftPos);
    delay(boxGap > SLOW_ZONE_CM ? 10 : 40);   // slow near the shelf
  }
  jaw.write(JAW_RELEASE);                     // 1) open a little
  delay(300);
  goUp();                                     // 2) retreat straight UP first
  wrist.write(WRIST_CENTRE);                  // 3) only then turn / move sideways
  Serial.println(F("PLACED"));
}

void setup() {
  Serial.begin(115200);
  pinMode(TRIG_PIN, OUTPUT);
  pinMode(ECHO_PIN, INPUT);
  pinMode(ABORT_PIN, INPUT_PULLUP);
  wrist.attach(WRIST_PIN); lift.attach(LIFT_PIN); jaw.attach(JAW_PIN);
  wrist.write(WRIST_CENTRE); lift.write(LIFT_UP); jaw.write(JAW_HOLD);
  Serial.println(F("READY: P <yaw> | H"));
}

void loop() {
  if (!Serial.available()) return;
  char c = Serial.read();
  if (c == 'P') {
    int yaw = Serial.parseInt();
    place(yaw);
  } else if (c == 'H') {
    goHome();
  }
}
Serial Monitor (115200) — the shape of a run · Text
READY: P <yaw> | H
P 45
PLACED
P 90
REFUSED wrist limit - replan with another yaw
P 0      (with the shelf removed)
FAIL no shelf found

Debugging

SymptomLikely causeFix
Box lands about 1 cm off the markgripper sent to the object poseCompose with the grasp offset (section 1 of the script)
Box lands rotatedwrist zero not at yaw 0, or yaw sign flippedRe-measure WRIST_CENTRE; test P 30 and P −30
Box bounces or tipsreleased too highLower RELEASE_CM; check BOX_BELOW_CM with a ruler
“FAIL no shelf found”LIFT_DOWN_MAX too high, or the sensor sees past the shelf edgePlace nearer the shelf centre; re-measure limits
Placed box dragged on retreatsideways or wrist motion before going upOpen → up → then turn, as in the sketch
Finger knocks a neighbourno finger-room checkAdd the neighbour to the place filter; open the jaw less
UNO resets when the wrist turnsservos on UNO 5 VSeparate supply, grounds joined

Real world

Pick-and-place in the real world

Several orange industrial robot arms in a bakery hall, stacking yellow crates onto pallets beside roller conveyors
Industrial robots palletizing bread at a bakery in Germany. Every crate gets its own place pose in the stack pattern.Photo: KUKA Roboter GmbH, Bachmann · Public domain · Source: Wikimedia Commons · resized, converted to WebP
  • Palletizing: robots stack cartons and crates onto pallets layer by layer, each item at a planned place pose.
  • Lab automation: arms move sample plates between incubators, dispensers and readers.
  • Electronics: pick-and-place machines put components at exact positions on circuit boards (Lesson 13).
  • MoveIt: move to place → generate place pose → open hand → forbid collision (hand, object) → detach → retreat → return home.
  • Your lab: plan the place in Python, execute it carefully on the UNO.
A yellow industrial robot arm in a warehouse beside cartons stacked on a pallet on a roller conveyor
An industrial robot arm next to a pallet of stacked cartons in a warehouse. The stacking pattern is a list of place poses the planner must reach one by one.Photo: Killgore1138 · CC0 · Source: Wikimedia Commons · resized, converted to WebP

Think

Think about it

Think

Your planner finds no valid place at all on a crowded shelf. Name three things the robot (or you) could change before giving up.

Experiment

Try it in the lab

About 60 minutes. Python 3 for the planner; an Arduino UNO with wrist, lift and gripper servos on their own supply, an HC-SR04, a push button, a small box and a cup on a shelf (a book on the desk works).

Experiment

Plan it, then place it

You will need

  • `place_planning_lab.py` (Python 3, no libraries)
  • Pick-and-place planner interactive (in your browser)
  • Arduino UNO, three SG90/MG90-class servos, separate 5–6 V supply, HC-SR04, push button, jumper wires
  • Ruler, protractor, small box, cup, masking tape for marks

Steps

  1. Measure your shelf, the cup and your grasp offset. Put them in the script and list the place candidates it accepts.
  2. Mark the chosen place on the shelf with tape: the box centre and its yaw.
  3. On the bench: set WRIST_CENTRE, LIFT_UP, LIFT_DOWN_MAX, JAW_HOLD and JAW_RELEASE; measure BOX_BELOW_CM.
  4. Pick the box by hand into the jaw (or run Lesson 13’s pick), then send `P <yaw>` for the chosen candidate. Measure how far the box lands from the mark.
  5. Repeat 10 times. Then repeat 5 times with RELEASE_CM = 2.0. Compare the errors and watch for bounces.
  6. Send a yaw beyond ±80° and remove the shelf once. Do the refusals and aborts behave as planned?

Interactive · Pick-and-place planner · Educational

Approach grasp liftPick and place
ApproachGraspLiftTransitPlaceRetreat

Ready — step through Approach → Retreat.

Educational pick/place — not MoveIt task constructor / not industrial cell planner.

A good place is planned for the OBJECT, executed with the GRIPPER, released low, and finished with a retreat away from what you just placed.

Knowledge check

Check your understanding

Knowledge check

1. You want the box at (16, −2, yaw 0). The grasp is 1 cm along the box’s y axis. Where does the gripper go?

2. Why did every yaw-90 place fail in the code lab?

3. Which is NOT a usual place-pose check?

4. A box is released 2 cm above the shelf (no air resistance). It lands at about…

5. After opening the jaw, the first move should be…

6. In MoveIt Task Constructor, what happens to the object at “detach object”?

7. Which stage connects the end of the pick to the place pose in the MTC tutorial?

8. No place candidate passes. A sensible next step is…

Mini assignment

Hands-on assignment

Mini assignment

Place it right, ten times

Plan places for your own shelf in Python, then execute them on the bench and measure the error.

Deliverables

  • Your measured scene, grasp offset and the full candidate printout (accepted and rejected with reasons).
  • A 10-place log for the chosen candidate: distance from the mark (mm) and yaw error (degrees).
  • A comparison of RELEASE_CM 0.5 vs 2.0: errors and any bounces or tips.
  • A short note: which check rejected the most candidates on your shelf, and how you could change the scene or the grasp to fix it.

Do this, step by step

  1. Run place_planning_lab.py and read the accepted and rejected place candidates.
  2. Put your shelf (SHELF), the cup (CUP) and your grasp offset into the script.
  3. Bench: upload place_executor.ino and log 10 places: distance from the mark (mm) and yaw error.
  4. Compare RELEASE_CM 0.5 vs 2.0 in the sketch and note any bounce or tip.
  5. Write which check rejected the most candidates and how you could fix it.

Stuck? Hints, one at a time

NoteTry the task first. Read one hint, try again, and only then read the next one.
  1. The gripper pose is the place pose combined with the grasp offset. If the box lands to one side, check the order in compose().
  2. Wrist yaw is limited to ±80° (WRIST). If most candidates fail on yaw, try a different grasp yaw.
  3. If the box tips on release, lower more slowly near the shelf (SLOW_ZONE_CM) and open only a little (JAW_RELEASE).

Challenges (pick by level)

  • 🟢 Beginner: Place a cup on a tray by hand, slowly. Write the phases you used (move, lower, release, retreat). Did you go up before moving away?
  • 🟡 Intermediate: Add a “keep 2 cm from the shelf edge” rule and a second neighbour object to the script. How many candidates survive now?
  • 🟠 Advanced: Rank candidates by a weighted cost: wrist turning + 2 × carry distance. Does the choice change?
  • 🔴 Expert: Combine Lesson 12 and this lesson: for every grasp candidate × place candidate pair, check both and choose the best pair, not the best grasp first.
  • ⚫ Research: Read the place stages in the MoveIt Task Constructor tutorial. Why does generate place pose need to know which stage attached the object (the “monitored stage”)?

Next step

You can now plan and execute a full pick-and-place. In Lesson 15 — The Manipulation Pipeline you will join everything from this stage — perception, world model, grasp planning, motion planning and execution — into one loop that runs again and again.

Look back: Lesson 13: Approach, Grasp & Lift. Next: Lesson 15: Manipulation Pipeline. Related: Stage 10 — ROS 2.

Sources

Self-attested for now — keep artifacts in your lab notebook.

Complete

Today's goal

0 of 1 done today

0-day streak
Daily goal:lessons, quizzes or assignments a day

Mark this lesson complete when you have worked the experiment, knowledge check, and assignment (even roughly).

Stuck somewhere?

Ask a doubt about this lesson

Saved with this lesson's id and your email so we can reply. Privacy · or email contact@aihubstation.in