Vision controlled conveyor feeding: start stop logic that works

Mechanical feeders pre-position every part, and each new variant buys new tooling. Put a camera over a linear conveyor instead and the scene itself can pace the line: the vision result decides when to feed, when to spread parts apart, when a pick may start, and when the wrong product has arrived. This guide is for controls and vision engineers building that loop on an assembly or kitting station. You get the five decisions a scene should return, the count thresholds that keep the feed relay from chattering, the pixel and exposure budget that fixes the camera, the spacing rule that triggers a flip action, and the collision check that has to pass before the robot is allowed to move. A worked 400 mm belt example carries the arithmetic through.

Five decisions per scene

Each evaluation of the pick window ends in exactly one decision, and that decision word is the whole interface to the machine. Keep it that narrow and the PLC logic stays simple regardless of what the image processing inside does.

The vision side writes the word to a discrete output or a fieldbus register; the PLC or drive treats it as feed enable, actuator pulse, pick trigger or fault. Everything else — matching, locating, counting — stays inside the image-processing program, so a product change is a recipe load rather than a rewiring job. If scenes are evaluated while the belt keeps running, results also age between exposure and use; conveyor vision scene timing: troubleshoot stale pick data covers that failure mode.

Window size and pixel budget

The field of view has to cover the full belt width plus a small margin; its length is the pick window. Work backwards from what the robot needs:

Size the budget from two requirements. The smallest feature the loop must notice — a part itself, a notch, a hole — wants at least 3 pixels across it, and the pick pose needs its calibration error, typically 1-2 pixels, to be finer than the gripper's lateral clearance. For a 400 mm belt and a ±0.5 mm placement tolerance, 0.25 mm/px is the target, which needs 400 / 0.25 = 1600 pixels across. Check your own belt width in the camera resolution calculator, then filter the area scan cameras finder to the result:

The lens follows from the sensor format and the FOV; the lens focal length calculator turns a chosen focal length into a working distance. For a PC-side pipeline, a global-shutter GigE camera on a C-mount is the standard pick-window camera:

Lanes that need no PC at all run the whole loop on a smart camera, driving the feed output directly from the device. The MV-SC3050XC-16M-ATN-H is a 5 MP colour vision sensor with a 1/1.45" global-shutter sensor and an M12 mount. At a 400 mm window, a 2448-pixel-wide 5 MP sensor lands near 0.163 mm/px — inside the 0.25 mm/px target with margin to spare.

Exposure and motion: stop the belt or freeze it

Motion blur sets the one exposure number that matters:

At 0.163 mm/px and a 60 mm/s belt the limit is 0.5 × 0.163 / 60 = 1.4 ms. Run 1 ms and the blur is 60 mm/s × 0.001 s = 0.06 mm, about 0.37 pixels. Start-stop feeding makes this easy: the belt is already stationary between feeds, so capture during the stop and the limit disappears. If you capture on the move, use a global-shutter sensor and strobe the light; a rolling shutter reads the sensor out line by line and shears vertical edges on a moving belt.

The feed state machine: counts with hysteresis

Feed control is a two-threshold controller on the part count in the window. Size the window's capacity first:

The factor 2 is deliberate: a part needs roughly twice its projected footprint so a top gripper can come down between neighbours. Stop feeding at about 80% of capacity and resume at about 50%; the gap is the hysteresis that keeps the feed output from toggling when the feeder surges. With a 400 × 300 mm window (120,000 mm²) and a 60 × 30 mm part (1800 mm²): N_max = 120,000 / (2 × 1800) = 33 parts, so stop at 26 and resume at 16.

Count only parts fully inside a counting window inset from the FOV edge — the worked example below gives the inset. Keep the machine's other interlocks in the same state machine: an upstream reject or a missing arrival acknowledgement suspends picks exactly the way feeding is suspended, as in gate vision picking with an upstream reject signal.

Spacing rule that triggers the flip action

The flip or agitation actuator exists to break up clumps, so its trigger should measure clumping directly. Inflate the space around every part by the gripper's reach plus a clearance margin:

A part counts as buried when the edge-to-edge gap to its nearest neighbour is under r. When more than one part in three in the window is buried, the flip action runs for a fixed 2 s burst and the scene is re-evaluated before any pick is released. With 35 mm finger reach, r = 35 + 5 = 40 mm, so any neighbour within 40 mm of the part's rectangle buries it. Two or three buried parts in thirty is normal presentation; ten or more means the feeder is piling parts into the window.

Wrong product, kit counts and lane stop

Each part also gets a class decision from the active recipe — a template score or a classifier label. A part that fails the match is a wrong product: the loop returns ERROR, stops feeding that lane and logs the count instead of letting the robot pick junk. Template-match thresholds typically sit around 0.7-0.8; the value the machine uses lives in the recipe, where an operator can tune it without touching the program.

The same scene tallies per-variant counts. When every variant in the current kit reaches its target, the loop returns BATCH_DONE and the lane stops iterating — no operator arithmetic, no under-filled kits. Changeover stays a scan-and-load operation: a scanned job code loads the recipe, and as long as the camera fixture has not moved, no recalibration is needed. Wiring the decisions out to the robot and reject hardware is its own task; single camera inspection routing to a robot and reject pusher shows one pattern.

The collision check that releases a pick

A located part is not a pickable part. Before PICK leaves the vision system, the gripped pose is checked against the scene model:

1. Inflate every other part's rectangle by the same r used for the flip trigger, and require that the target's grasp rectangle — where the fingers or cup actually come down — intersects none of them.
2. Require the grasp rectangle to sit inside the fence, rail and stand-off polygons measured once during commissioning.
3. Apply the height rule: a top-down 2D camera cannot see a stack, so the process enforces single-layer presentation, or a height check is added.

Rank the surviving candidates by clearance margin and release the roomiest pose, not merely the first. If no candidate survives, return FLIP and re-evaluate; after two flip retries with no clear pick, hold the robot and latch the error. When picks still land off-target after a passing check, the fault is usually in the calibration chain rather than the logic — vision pick error under rotation: diagnose position drift traces that fault. Parts that arrive in layers, or picks that need z-clearance proof, are a 3D decision: see 2D or 3D camera for conveyor pick and place.

Hardware: where the loop runs

Three placements cover every build:

• Vision sensor or smart camera, no PC. Counting, spacing and ID run on the device; discrete outputs drive the feeder and flip directly. Fastest to commission; best for one lane and one part family.
• Area scan camera plus vision software on a controller. Full pipelines, several lanes per box, room for trained models. The vision controllers category is built for this: multiple camera ports, built-in light channels for the strobe and flip solenoid, discrete I/O for the feed output.
• PLC keeps safety, vision keeps pace. The e-stop chain, guarding and drive-safety functions stay in the PLC regardless; the vision loop owns only the feed-enable, flip and pick-trigger decisions.

Three controller builds cover the range from one lane to many:

All 3 share: Certification CE, KC. Values as printed in each product's data sheet; open a part for its drawing and full specifications.

Match ports to the lane plan: one LAN port per camera plus one for the PLC link, one light channel per strobed light plus one for the flip actuator. Narrow the sensor choice in the cameras finder:

Worked example: a 400 mm belt at 60 mm/s

One lane end to end: 60 × 30 mm parts, a gripper with 35 mm finger reach, ±0.5 mm placement tolerance, 30 parts/min.

1. Field of view. 400 mm across the belt × 300 mm along the window.
2. Pixel budget. Allowed 0.25 mm/px → 400 / 0.25 = 1600 pixels minimum. A 2448 × 2048 (illustrative) 5 MP array gives 400 / 2448 = 0.163 mm/px and 300 / 2048 = 0.147 mm/px; the ±0.5 mm tolerance is 0.5 / 0.163 = 3.1 pixels, clear of the 1-2 pixel calibration error.
3. Exposure. On the move: 0.5 × 0.163 / 60 = 1.4 ms limit, so run 1 ms and blur is 0.06 mm = 0.37 pixels. Stopped-belt capture removes the limit entirely.
4. Feed counts. 120,000 / (2 × 1800) = 33 parts capacity; stop at 26, resume at 16.
5. Flip trigger. r = 35 + 5 = 40 mm; run the 2 s burst when more than eight of the 26 parts in the window are buried.
6. Coast distance. Measure the drive's stop ramp with a loaded belt: at 150 ms, coast is 60 mm/s × 0.15 s = 9 mm, so the counting window is inset 10 mm from each FOV edge.
7. Cycle check. Scene time is 20 ms capture + 100 ms evaluation + 10 ms I/O = 130 ms. At one part every 2 s, the loop holds 130 / 2000 = 6.5% duty, leaving the robot 1.87 s to clear the pick.

Checks before you commit

• Measure the coast distance with the real drive and a loaded belt, not from the drive's rated ramp time.
• Fix the capture mode: stopped belt with any shutter, or moving belt with global shutter plus strobe. Rolling shutter only in the stopped case.
• Inset the counting window by the measured coast plus a few pixels.
• Keep at least four parts of hysteresis between the resume and stop counts.
• Measure the fence and stand-off polygons once, and again after any camera or guard bump — moved-camera drift is its own subject: static camera calibration accuracy: why moved parts drift off target.
• Prove the flip actuator moves the actual bed; a 2 s pulse that does not tumble the parts only burns cycle time.

When stop-and-go feeding is the wrong answer

• Continuous lines at hundreds of parts per minute cannot afford a stopped window. Move to encoder-tracked picks on the running belt; conveyor encoder calibration troubleshooting: position resets is the companion subject there.
• Multi-layer or tangled parts need height information before any pick is safe — that is a 3D sensor decision, not a better threshold.
• Parts that cannot be flipped (orientation-sensitive assemblies, open containers) remove the FLIP action entirely. The feed rate itself must then keep the window sparse: plan the stop threshold at 50% of N_max instead of 80%.

Everything above reduces to four numbers you can put on paper before ordering: pixels across the belt, exposure at your belt speed, the two feed counts, and the coast inset. More conveyor-and-vision reading sits on the systems topic page; when you are ready to size a real lane, the contact page is the direct route to us — send the belt width, part footprint and cycle rate, and the pixel and port budgets can be checked with you before you order.