Recently with JLCPCB’s assembly price being quite high, i’ve found myself in need of a pick and place machine to automate the assembly of my PCBs in-house. There were a few open source projects around that that piqued my interest, one being the lumen pick and place from opulo.

Mechanically the machine is a regular gantry style one with linear rails for actuation, To get the costs down (~550€ total BOM including everything) mine doesn’t exactly respect their full BOM but it is still mechanically sound and functional:

The machine’s motherboard and feeder controllers are all fully custom-made by me, including their firmware, these don’t use a pre-made one like Marlin or Smoothieware since i wanted full control over the firmware without having a source tree with thousands of files (ease of expandability). This was a great learning experience around mechatronics and the kinematics of a simple gantry machine like this one.

The RP2040 microcontroller seems uniquely well suited for this kind of task as it’s fast clocks (144Mhz dual core) and 8 state machine in 2 PIOs + DMA allow for very precise stepper control, here 6 steppers are managed with barely any CPU time used (CPU pre-calculates move, saves as an array of delays, and sends to DMA for processing, the PIO state machine consumes the DMA flow for Acceleration, stops incrementing and stays on the last one for the actual move at full speed, and then reverses the DMA array incrementation to decelerate, the whole move is symmetric and everyone’s happy). The RP2040’s generally limited amount of GPIOs (30) is addressed by using some padauk PMS154C over software I2C as Io expanders (E1-E3 on the motherboard), this has been very reliable so far. Only the stepper control, endstops/estop and vacuum sensing is managed by the RP2040 directly.

The machine uses stepper-based feeders with semi-automatic tape peeling. The feeder drivers themselves were an exercise in simplicity since i need to make a ton of them, they come out to about 50 cents / controller in BOM by using a super cheap PY32F002A microcontroller (13 cents for arm M0), and a 5 cent ULN2003-like unipolar driver with 8 chanels to drive two steppers / driver:

Here’s the 16mm version of the feeder in action:

And this is how the feeders get programmed the first time they’re in the feeder chain, to know where they are:

Now as well as this currently works, it’s not quite ready for prime time… the machine itself and it’s motherboard are fully ready (homes, moves around properly, actuated by openpnp), but the feeders need more work. Especially I find that mechanically this passive film peeling is too unreliable for long production runs, a single slip will cause the peel location to advance, this is worse on black tape for some reason, see here:

The real solution here is to use two motors per feeder, so we can use different ratios for the tape and film. Doing this mechanically is possible but tedious, as we can’t just make the gear part of the bottom sprocket bigger, because the tape is in the way, at best this sprocket design can only do 1:~0.993. Adding two extra gears on top would solve the problem but the feeder would be way taller and backlash would be sub ideal (also if we over-tension the film, the main tape sprocket underneath could skip…). Using an N20 motor + worm gear instead of actuating with the sprocket is plain better here, and this is how a lot of feeders do it.