Have you ever considered the manufacture of candles? Not necessarily manufacturing them yourself, but how they are manufactured in a small-scale industrial setting? It’s something that has been of great concern to Michael Schuldt as he grappled with the task of automating a simple manual candle production process.
It’s not just an interesting subject, but the topic of manufacturing automation is something we can all learn from. This was the subject of his Adventures in Manufacturing Automation talk at the recent Hackaday Superconference which you’ll find below the break. Let’s dive in and see what this is all about!
How Complex Can a Simple Process Be?
The candle making process was simple enough, a hopper containing molten wax was positioned above a conveyor along which candle jars were sent, with the wax was dispensed into the jars from above. Periodically the hopper would need refilling, and all tasks were performed by an operator.
Michael’s first prototype automated the machinery with pneumatic components and attacked the whole process in software, with a MicroPython loop holding all possible functions. The problem he found with that approach was one that no doubt many engineers have grappled with: it quickly becomes unwieldy. The monolithic solution fell short on his essential criteria: that it be reliable, debuggable, repairable, and easy-to-use. In essence, the lesson is more hardware, less software.
There were some obvious simplifications, replacing excess software associated with simple tasks with hardware built for them. In the candle process for example there was no point in having a wax tank selection step in software when a simple switch would suffice. He came to the realisation that he was replicating common off the shelf control components such as timers or PID controllers, and his solution was to abandon the large software and produce a series of single function PCBs he calls control bricks. These are self contained units with their own displays and interfaces, that handle a particular task and are designed to run sequentially wired in a chain through which each passes control to the next. Think of it as a block diagram of an algorithm enacted as hardware modules.
A Block Diagram in Hardware
In this way he has created a general purpose toolkit that address the problem of simple process automation, so it’s worth looking at in greater detail. Each brick has a set of common interfaces, a chain input and an output to connect with other bricks, a sensor input where necessary, and an active output that can be used to trigger a relay or similar. The processor on each block is an ATmega328, chosen for convenience as he had a supply of them in hand.
There are many possible bricks that could be created to satisfy all possible functions, but so far he has created only the selection he required for the candle automation task. There is a process delay brick with a rotary encoder to set a time, a “while” brick that sets an output while a sensor condition is true, a process counter brick that increments its count every time the process passes through it, and a stop-start brick allowing the process to be halted and resumed. Loops can be enacted simply by connecting the output of the chain to its input, and the stop-start brick is normally the first in the chain. He makes the point that process parameters have to be entered manually every time the system is run rather than set in software, but he opines that for the relatively simple processes involved this should not be a problem.
Such a modular process automation system is not entirely new, indeed similar ideas could be found in the relay-driven ancestors of modern programmable logic controllers. But to have a readily available design so convenient for experimentation is an interesting development for our community, and Michael’s tale of discovery should provide interesting lessons for anyone with an automation task in front of them even if they don’t adopt his solution.