Automating Pick-and-Place with the Autorun Feature

This eighth video in the controller series covers the autorun feature on the Adeeb Robot Controller. Autorun is a zero-programming workflow: point it at a conveyor and a container, and the controller automatically picks parts off the belt and places them into the container with vision-guided, conveyor-tracked motion.

What the autorun feature does

Autorun handles the full pick-and-place cycle without any custom motion code. The firmware recognizes parts from the camera, tracks them on the moving conveyor, picks them, and deposits them into the container — computing each drop-off position itself. It supports two cycle directions:

• Conveyor to container — picking parts off the belt and filling an empty container.
• Container to conveyor — emptying a full container back onto the belt.

Prerequisites

Download the controller release and the motion control manual from the downloads page. Extract the archive; this walkthrough uses the same artifacts as the prior videos in the series:

• The sample configuration file shipped with the release.
• The arc script — the Python wrappers that connect to the controller server and perform motion. (ARC stands for Adeeb Robot Controller.)
• The autorun script, which drives the automatic pick-and-place cycle.

Every example imports the helper module the same way:

from arc import *

The configuration file

Two entries in the config govern the autorun setup: the position of the conveyor and the position of the camera.

The robot position is typically left at all zeros, so the robot frame and the world frame coincide — this keeps the geometry simple. The camera position rarely needs updating, because the camera is mounted on the robot and does not move relative to it.

Parameter	Purpose
Conveyor position	Location of the conveyor relative to the world frame.
Camera position	Location of the camera relative to the world frame; fixed because the camera is robot-mounted.
Camera image path	Path to a still image, used to run in simulation mode without a physical camera.
Robot world frame	Left at zero so the robot and world frames are identical.
Cycling: start signal	Indicates a new empty box to fill (or a new full box to empty).
Cycling: done signal	Pulsed once a container is filled or emptied.

Cycling, start, and done signals

Near the end of the config file is the cycling section. The start signal indicates that a new empty box has arrived to fill, or a new full box has arrived to empty; on a real system you generate a rising-edge pulse on it each time a box arrives. The controller emits a done signal — a rising-edge pulse — once it finishes filling or emptying a box.

Running in simulation mode

There is no physical camera connected in this demo. Instead, the camera entry points at an example image supplied with the release, which puts the controller into simulation mode. The controller feeds this still to the recognition pipeline so it always has parts to detect and track, even with no live camera attached.

Because the demo also has no physical box-arrival sensor, the autorun Python script sets the start signal to true directly rather than waiting on a hardware pulse. This keeps the cycle from waiting endlessly. On production hardware you leave this driven by the real rising-edge pulse generated each time a box arrives.

How the drop-off logic works

The firmware tracks the next drop-off position on its own. It knows the size of the box and the size of the part, and it knows how much spacing to leave between parts, so it computes where each successive part should land inside the container. No drop-off coordinates need to be specified by hand — the layout is derived from the box and part dimensions plus the configured spacing.

Running autorun

The controller runs as a server that the Python scripts talk to. It takes two terminals.

In the first terminal, from the root folder, launch the controller and pass it a config:

sudo ./robot-controller --config delta-robot.config

In the second terminal, change into the Python scripts folder and run the autorun script:

python3 autorun.py

The motor begins cycling immediately. It moves as though a robot is picking parts off the conveyor — with conveyor tracking active — and dropping them into the container. The cycle time stays consistent as it repeats, behaving as a full pick-and-place line even with only the single motor present on the bench.

Going beyond autorun

Autorun is the turnkey path, but you are not limited to it. If you need finer control over where each part is placed or how the robot moves between picks, the full arc API is available for custom motion — so you can start with autorun and drop down to explicit moves wherever the application demands it.

Next steps

• Work through individual moves in the axis motion commands article.
• Review the full Adeeb Robot Controller and Adeeb Delta Robot product pages.
• Grab the trial build from the downloads page or request a demo.