Skip to main content

2.2 Program Creation & Tuning

A pick-and-place machine is only as good as the program that drives it. From the moment CAD data is imported, every decision—how rotations are defined, how vision is taught, how feeders are laid out—shapes whether the line runs smoothly or stumbles into delays. Good programming turns chaos into consistency: machines recognize parts instantly, nozzles travel efficiently, and operators see the same “truth” shift after shift. With disciplined setup and verification, programs transform from fragile one-offs into stable, reusable assets that sustain both speed and quality.

2.2.1 Start with clean inputs (CAD/centroid → program)

Before you place a single part, make the data boring and consistent:

What you import (and freeze):

  • Units & origin: mm, one origin for top and bottom, and θ defined CCW.
  • Side & rotation: explicit “Top/Bottom” per refdes, rotation as seen from top view (bottom side mirrored in software).
  • Package names & heights: match your PnP library names and Z-heights—no one-off aliases.
  • Polarity/pin-1 & fiducials: match the assembly drawing, with global + local fiducials listed.

Put these rules in the Golden Data Pack so every line loads the same truth.

Quick tell: if your first import needs bulk “+90°” fixes, your rotation convention isn’t aligned—fix the library, not the program.



2.2.2 Vision teaching (make recognition effortless)

Build libraries that the camera can’t misread:

  • Clear features: use packages with obvious pin-1/polarity and body edges (your land-patterns and silks did this back in 3.2–3.3). Teach one good part per package, then lock it.
  • Nozzle/pick point: center on flat, repeatable surfaces; avoid embossed logos or domes.
  • Lighting/algorithms: pick the simplest algorithm that passes—fast beats fancy when it’s stable.
  • Golden images: keep a small photo set per package so night shift can compare “good vs weird” quickly.



2.2.3 Rotation sanity (catch 0/90/180/270° traps early)

Do a rotation audit before the first panel:

  • Build a one-page rotation table per package family (what “0°” looks like on top, and how bottom is mirrored).
  • Dry-run placement on screen and print a “rotation heat-map” (count of 0/90/180/270). Spikes at 90/270 on parts that “should be 0°” = library drift.
  • On the bench, check pin-1/A1 for BGAs/QFNs and polarity for diodes/LEDs on your First Article routine (see 8.5).



2.2.4 Feeder optimization (travel less, place more)

Your program is only as fast as its feeder map:

  • Permanent banks: park high-runner passives (e.g., 01005–0603) in fixed slots across products so changeovers don’t touch them.
  • Shortest paths: place the highest-hit parts from feeders closest to the head’s home; cluster by nozzle family to cut swaps.
  • Splice-friendly lanes: assign high-runner reels to feeders you can splice in place; avoid starving the constraint machine. (More in 8.3.)
  • Tray parts last: big BGAs/QFNs from trays cost time—sequence them after chip storms so the head isn’t jogging across the world mid-run.



2.2.5 Path & sequencing (seconds live here)

  • Zones, then details: place dense chip fields first (short head moves), then ICs, then tall/odd-form last.
  • Side strategy: if you run tandem mounters, split by effort (chips vs ICs) so cycle times match within ~10%—otherwise one machine idles. (8.1 covers load-leveling.)



2.2.6 First Article steps (prove the program, then freeze)

Run a quick, scripted FA on the first panel:

  1. Teach three fiducials; confirm X/Y/θ.
  2. Place witness parts for each package family near a board edge; check orientation/polarity, heights, offsets under the scope.
  3. Review pickup logs (miss/retry rates) and tweak vision/nozzle for the worst offender.
  4. Save the recipe and generate the Golden Board photo set for this rev (used again in 8.5).



2.2.7 Metrics to watch (keep tuning small)

  • Placement time per board (ex-travel) and CPH vs spec
  • Pickup misses / vision retries by part family
  • Nozzle swaps per board (aim low—group parts by nozzle size)
  • Starvation events (count of “no part” waits; splice earlier if rising)

Tie these to your OEE dashboard later so planners see the real constraint, not guesses.



2.2.8 Pocket checklists

Before import

  • Units mm, shared origin, θ CCW; top/bottom flagged
  • Library names/heights match; fiducials listed

Vision & rotation

  • One taught part per package; golden images saved
  • Rotation table built; bottom-side mirroring verified

Feeders & sequence

  • High-runners on permanent banks; splice-friendly lanes set
  • Chips first, trays last; tandem programs balanced (±10%)

First Article

  • Fiducials OK; witness parts pass orientation/polarity/height/offset
  • Logs clean (miss/retry); recipe frozen; Golden Board captured



By standardizing inputs, tuning vision and rotations, and optimizing feeders, placement programs become predictable tools instead of firefights. The payoff is faster startups, fewer errors, and lines that run at speed with minimal intervention.


Back to top