Three categories, three jobs​

These machines look similar in product photos. They're built for completely different jobs.

CPH = components per hour. A desktop machine placing a 200-component board in 10 minutes runs at 1,200 CPH. A used JUKI RS1 does the same board in 12 seconds.

Cost: it's not what you think​

Purchase price​

Real cost of ownership in year 1​

Purchase price is half the story. Here's what the first year actually costs:

The "used JUKI" looks cheap until you price the spare feeders. A full bank of 40 used 8 mm feeders alone runs $4,000–8,000. New is double.

When the desktop wins​

• Prototyping: 5–50 boards per spin, multiple designs per month. Setup time matters more than placement speed. PikkoBot config swap takes 2 minutes; the JUKI takes 20.
• Low-volume products: 100–500 units per month. Desktop machines at 1,200 CPH finish a 100-component board in 5 minutes. That's 60 boards per hour, 480 per shift — well within "low volume."
• In-house development at hardware startups: When the same person does electrical design, firmware, and assembly. The desktop's friendly UI (OpenPnP) makes sense; the JUKI's proprietary software needs a dedicated SMT operator.
• Lab and educational use: Hackerspaces, university labs, R&D departments.
• Component diversity: Lots of one-off parts, custom feeders, mixed reels. Desktop is more flexible per swap.

When the industrial used wins​

• Steady production: Same board, 1,000+ per month. CPH dominates total cost of ownership.
• You have an SMT technician on staff: Someone who knows industrial nozzle changes, JUKI vision pipelines, and the standard repair workflow.
• Tight pitch in volume: 0.4 mm BGA at scale benefits from industrial-grade vision (10 µm repeatability vs ~25 µm).
• 24/7 expectation: Industrial units run all night. Desktop machines need supervised operation.

When the new industrial wins​

Honestly: only when you're at the throughput where the line pays for itself in months, not years. Most hardware startups never reach this point. If you do, you'll be working with a contract manufacturer first.

The decision in one paragraph​

If you're a hardware startup placing under 500 boards per month and you don't have a dedicated SMT technician, a desktop pick-and-place pays for itself in the first product run. The labor saved on the first 50 boards more than covers the machine. If you're past 500 boards/month and have someone trained, a used industrial machine wins on CPH — but budget 2× the purchase price for year-1 total cost.

The wrong answer is buying a used industrial machine "to grow into." We've watched two startups do this. Both sold the JUKI at a loss within 18 months because nobody on the team had time to learn it.

Want to see the math on your specific case?​

Email your monthly board count and typical BOM to support@pikkobot.com — we'll run an honest CPH model and tell you whether PikkoBot is the right answer for you (or not).

For setup specs and what's included, see PikkoBot Introduction. To compare what components a desktop machine actually handles, see the component size envelope.

The short answer​

A well-calibrated PikkoBot / LumenPnP with JUKI nozzles handles the 0201–QFN64 range reliably. Above that you start needing extra prep. Below it, accept failure rates above 5%.

What pushes you outside the envelope​

Component too small (below 0201)​

01005 components are technically possible with a custom 0.2 mm nozzle, but placement failure climbs above 15%. The bottleneck isn't the nozzle — it's the camera resolution. To detect a 0.4 × 0.2 mm part on the bottom camera you need >12 px across the long edge, which means moving the camera closer than its calibrated focus.

If your design needs 01005 in volume, you're past desktop territory. Consider a sub-CM SMT line for prototypes, then outsource to a contract manufacturer for production.

Component too tall (>10 mm)​

The Z-axis travel is finite. PikkoBot v4 nozzles can pick parts up to about 25 mm tall, but anything above 15 mm starts blocking the bottom camera during vision check, which means the rotation can't be verified. You can disable bottom-camera verification per-part in OpenPnP, but you trade rotation accuracy for it.

Component too heavy (>5 g)​

Vacuum hold becomes the limit. With a JUKI N24 nozzle at ~70 kPa, you can hold a 5 g part during normal placement moves. Push past that and accept drops at sharp accelerations. Mitigations:

• Reduce machine acceleration in Machine Setup → Heads → Head → Max Feed Rate.
• Use a larger nozzle (custom 1.5 mm tip).
• Increase vacuum hold time before release by 50–100 ms.

Pitch too tight (BGA ≤0.4 mm)​

Once you're below 0.4 mm pitch, the alignment requirement falls below the machine's repeatability (~25 µm on a typical desktop unit). Placements become probabilistic. Hand-rework after the fact ends up faster than chasing the last 10% on the machine.

Realistic prototyping vs production​

These rules of thumb hold for prototyping at low volumes — under 50 boards per session. At higher volumes, two things change:

1. Calibration drift matters more. Over a 200-board run, nozzle concentric calibration shifts by ~30 µm. Schedule a recalibration every 100 boards if you're running tight-pitch QFNs.
2. Tape loading errors compound. A misaligned reel costs you a board if the feeder advances wrong once. Use Photon auto-feeders instead of drag feeders for runs over 25 boards.

What we won't claim​

We've seen marketing copy from other desktop pick-and-place vendors claiming "01005 to BGA0.3 mm" capability on hardware essentially identical to ours. Those numbers are theoretical maximums, not field-tested reliability. The components technically fit on the nozzle. They just don't place reliably.

If you're buying a desktop machine for production, work from the table above. The 99%+ rows are where these machines earn their keep.

Want to test your specific BOM?​

Send your PCB and BOM to support@pikkobot.com and we'll tell you (a) whether PikkoBot can handle it and (b) where the marginal parts are. Free, no obligation, takes us about 10 minutes per BOM.

For the technical setup behind these numbers, see Calibration and OpenPnP Config.

1. The board surface is too reflective​

Glossy soldermask reflects the ring light back into the camera, washing out the fiducial circle. The fix is mechanical, not software:

• Wipe the PCB with isopropyl alcohol to remove handling residue.
• If the board is glossy green or red soldermask, angle the ring light source slightly using a thin diffuser ring (printable in PETG, ~30° angle).
• Switch the top camera exposure down by 20-30% in Machine Setup → Cameras → Top Camera → Device Settings. The histogram peak should sit at roughly 60% brightness, not 95%.

A telltale sign of this issue: detection works at the corners of the board but fails near the center where the reflection is strongest.

2. The vision pipeline's blob detector thresholds are wrong​

OpenPnP's default fiducial detection pipeline uses a BlobDetector stage with conservative defaults. For 1.0 mm copper fiducials on standard soldermask, those defaults work. For anything non-standard, they don't.

Open the pipeline editor: Job → PCB Fiducials → right-click a fiducial → Edit Pipeline.

Adjust these stages in order:

After each change, click Process Pipeline with a still board image to see what survives each stage.

3. The camera is out of focus​

The top camera's lens has a fixed focal distance set during manufacturing. If you've adjusted it for component vision (closer focus), fiducial detection at PCB height will look blurry, and BlobDetector will reject the soft edges.

Quick test:

1. Jog the top camera over a fiducial.
2. Watch the live feed — sharp edges or fuzzy?
3. If fuzzy, you have two choices:
   • Adjust the camera focus ring for fiducial height (loses sharpness for component pickup verification — usually not worth it).
   • Better: retune the BlobDetector minCircularity down to 0.7 to accept softer edges, and tighten MaskCircle to compensate for false positives.

4. mm/pixel calibration drifted​

OpenPnP needs to know how many millimeters one camera pixel represents. If this value is wrong by even 5%, the search window in MaskCircle won't be centered on the actual fiducial position.

Recalibrate using a known reference — a fiducial that you measured with calipers:

1. Place the reference board at staging plate height.
2. Machine Setup → Cameras → Top Camera → Calibration → mm/Pixel Calibration.
3. Follow the wizard with the known fiducial diameter.
4. Save. Re-run fiducial detection.

Symptom that points here: detection finds something but it's offset from the actual fiducial by 1–3 mm consistently.

5. The fiducial is not where OpenPnP thinks it is​

If you've imported a PCB but the fiducial coordinates in the PCB file don't match the physical board (e.g., wrong origin, mirrored design, or you flipped the board), OpenPnP looks in empty space.

Verify by:

• Opening the PCB file in OpenPnP and noting the fiducial X/Y.
• Manually jog the head to that coordinate.
• Look at the live camera feed. The fiducial should be roughly centered.

If it's off by exactly the board's width or height, you've got an origin mismatch. Re-export the PCB with the origin set to the bottom-left fiducial.

Quick checklist​

When fiducial detection fails, run through this:

• PCB cleaned with IPA
• Ring light not pointing directly into the camera
• Top camera exposure not maxed out
• Vision pipeline Threshold and BlobDetector reviewed in the pipeline editor
• Camera in focus at PCB height
• mm/pixel calibration done within the last month
• PCB file coordinates verified against physical board

If you've ticked every box and it still fails, the issue is usually the soldermask itself. Try a different test board or a different fiducial shape (1.5 mm circle instead of 1.0 mm).

For machine setup that comes pre-calibrated for fiducial detection out of the box, see the PikkoBot JUKI config — it includes a tuned pipeline for standard green and black soldermasks. For hands-on testing of camera and lighting outside OpenPnP, use the PikkoBot Debug Tool.

What you'll find here​

• Case studies — PCBs we've assembled, what worked, what didn't.
• Calibration deep dives — JUKI nozzle runout, fiducial vision tuning, feeder zero alignment.
• OpenPnP tips — config patterns, G-code recipes, debug techniques.
• Hardware mods — community-tested upgrades to the LumenPnP platform.

For step-by-step setup and reference documentation, see the PikkoBot Wiki. For browser-based hardware testing, use the Debug Tool.

Contributing​

This blog is open. If you've solved a tricky calibration or have a build to share, email support@pikkobot.com.