Skip to main content

2.2 Program Creation & Tuning

CAD import, vision teaching, rotation sanity checks, and feeder optimization—so the mounter runs fast and right.


Pick-and-place programming starts long before the first board runs—it begins with clean, consistent CAD data and a rock-solid part library. Getting units, origins, rotations, and heights right at import prevents the “+90°” firefights that waste setup time. Vision teaching should be simple and repeatable, with clear pin-1s, good pick points, and golden images so every operator sees the same “good.” Feeder layouts can make or break throughput—permanent banks for high-runner passives, shortest travel paths for busy nozzles, and splice-friendly positions for long runs. Sequencing parts from dense chip fields to tall odd-forms keeps the head moving efficiently, and a quick, disciplined First Article catches orientation or pickup issues before they hit volume. When each step is locked and documented, programs become plug-and-play assets—fast to load, predictable to run, and ready to reuse without surprises.

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



Bottom line: clean CAD in, teach vision once, sanity-check rotations, and map feeders so the head barely travels. Then prove it with a short First Article and freeze the recipe. Do that, and programs stop being adventures—they become reusable, fast, and quiet.  


Back to top