Vibration Bowl Feeder System

A vibratory bowl feeder system is generally used to separate various components and bring them precisely into the correct position. These systems are used in a wide range of industrial applications. The following are some examples:

  • Vibratory bowl feeders are commonly used in assembly and manufacturing plants. They are used to automatically feed parts such as screws, nuts, bolts, electronic components and other small parts, which increases the efficiency and precision of the assembly process.
  • In the pharmaceutical industry, vibratory bowl feeders are used to feed capsules, tablets or small vials into the production process.
  • In the food processing industry, these systems enable precise dosing and packaging of food ingredients such as spices, grains and snack items.
  • The automotive industry widely uses vibratory bowl feeders to precisely feed parts such as screws, bolts, washers and gaskets.
  • In the electronics industry, vibratory bowl feeders are essential in the manufacture of electronic products such as cell phones and computers. They ensure precise handling of electronic components such as resistors, capacitors and ICs.
  • In the packaging industry, these systems are used to efficiently provide packaging materials, labels or closures.
  • In the manufacture of medical devices, vibratory bowl feeders help to reliably handle and assemble precision parts.
  • In plastics processing, vibratory bowl feeders are used in injection molding to precisely feed plastic granules, closures, stoppers and other parts.

This wide range of applications illustrates the versatility of vibratory bowl feeder systems in various industries.




Thoughts about the project

The idea of developing a vibrating bowl feeder system has been circling in my head for some time. It came from a comment on YouTube: „A machine for sorting nuts and bolts would be a great idea. I did some quick research on YouTube. I think it would be a good and useful topic. Thanks for the idea. Going on the to-do list ;-)“.

After thorough research, my enthusiasm for these machines was aroused and I thought that building such a machine should be an easy task. The principle is relatively simple when viewed from the outside.

But that’s how you can be deceived. The reality turned out to be completely different than expected. The development of the vibrating bowl feeder system took over 3 months and consumed about 200-300 working hours. This was not what I had expected.

Several times I was on the verge of throwing in the towel and moving on to other projects. As a result, the machine kept lingering unattended in a corner for a while while it waited for my attention. But my determination would not let me rest, and I continued to work on the machine.

I invested numerous hours in extensive testing. In addition, I printed and built countless parts to finally develop a working bowl feeder system. But let’s take things one step at a time.

The first walking tests and feasibility study

Basically, a Vibration Bowl Feeder works as follows: Slanted springs are connected to a base plate and a slider track. A magnet generates the vibration. Due to the slanted arrangement, a throwing motion occurs, also known as a micro-throwing motion. The magnet pretensions the spring and releases it again. As a result, the springs throw the component forward a small distance. The inclination of the springs has an influence on the conveying rate. A steeper angle accelerates the forward movement of the parts.

My first attempts were made with a straight conveyor. The structure, which used 20mm item profiles, was deliberately kept simple. My main goal was to test the feasibility of the system with 3D printed components. I wound the magnet by hand, since I did not have a suitable magnet available. To control the magnet I used an Arduino. The driver chip was an ordinary MOSFET, which is normally used for the heating bed of a 3D printer. To cool the MOSFET, I installed a fan.

I ran tests with two different arrangements of the magnet. The first was a vertical arrangement, and the second was horizontal. The horizontal arrangement (as shown in the picture) offered the advantage that the gap between the magnet and the metal disk could be easily adjusted. Basically, however, the orientation of the magnet does not play a decisive role.

First prototype feeding system
First prototype feeding system

Learnings from this test setup:

  • It needs a real electromagnet: I decided to use a cheap pot magnet. This manget has 80kg pulling force at 12V. I operate the magnet with about 24V. So I guess there is a force of about 120-150kg.
  • To create a smooth clean bouncing motion it needs a special Arduino code. But more about that later.
  • A MOSFET is not the ideal transformer device for this application.
  • The springs must provide a very large resistance.
  • It needs a very heavy foundation to absorb the vibrations.
  • A fan should cool the electronics.
  • The surface of the slideway should be given an adhesive coating to increase friction.

Vibration bowl feeder design and function


Expolsion view of the Vibration Bowl Feeder
Expolsion view of the Vibration Bowl Feeder

The construction of the vibration feeder is comparatively uncomplicated. A stable base plate is required to absorb the vibrations. This base plate should be placed on rubber buffers, because rubber buffers increase the performance of the feeder considerably. To ensure the most massive baseplate possible, I filled it with scrap metal parts. The more iron, the better. In my case, I subsequently filled this space with tile adhesive, however this can also be achieved with concrete.

Threaded rods were cast into the baseplate to attach the magnet. The design of the base plate allowed nuts to be inserted into the holes provided. Particular attention was paid to minimizing the wall thicknesses at the points where significant forces occur, such as the areas where the springs rest and the surfaces around the nuts. This had the advantage that the forces were not transferred into the 3D-printed plastic but could be absorbed by the concrete.




Pouring with concrete and scrap iron parts
Pouring with concrete and scrap iron parts

The springs

One of the main components of the system are the springs, and in relation to this I have conducted numerous experiments. I printed a variety of springs in different thicknesses and sizes. To provide some spacing between the springs, I inserted filler plates. The main function of the springs is to keep the pieces spinning. Precise tuning of the springs is critical. So the springs should always be preloaded a little during operation but not too much so that the bowl does not stick to the magnet. In other words, the system must be kept in „suspension“.

Too low a spring force will cause the electromagnet to attract the bowl and stick to it. If the spring force is too high, the solenoid cannot properly preload the spring. Another problem with too high a spring force is the forces introduced into the system. Depending on the operating voltage set, the magnet pulls with about 120-150 kg. These forces are already at the limit of what is possible for 3D-printed parts. At such strong forces, the 3D-printed parts start to deform internally, which is extremely problematic in a resonant system like this. The stiffer the parts, the better the conveyor system works. So the parts must be printed with as much infill as possible. It is no coincidence that industrial vibratory bowl feeders are made of solid cast iron.

So there are two forces acting in the system. „Fm“ is the magnetic force and „Fs“ is the spring force. „Fm“ pulls the bowl down while „Fs“ acts against it. This results in a massive bending force between the magnet and the springs. So you can imagine how big the forces are that act on the 3D printed parts.

The magnet has such a large pulling force that it is not possible to install so many springs to prevent the plate from tightening. Hard to believe what forces act here!

Forces in the system (Fm=magnetic force, Fs=spring force)
Forces in the system (Fm=magnetic force, Fs=spring force)

The bowl

The bowl is the element in which the parts to be conveyed are located. In industrial applications, the parts are usually fed into the center of the bowl with the help of other feeding systems. A sensor is often placed here to monitor the filling quantity. Inside the bowl there is a spiral path on which the parts move towards the exit of the bowl. Furthermore, various devices are often installed in the bowl to separate the parts and bring them into the correct position.

The bowl was printed with a layer height of 0.3 mm, although a layer height of 0.1 mm would have been a better choice here. To compensate for the layer levels of the 3D print, a spiral-shaped web was printed and glued into the bowl. To increase friction, this web was coated with foil spray. This step is extremely important, otherwise the parts tend to slip and not be conveyed further.

Vibration Bowl with spiral path
Vibration Bowl with spiral path

The bowl bracket

The bowl bracket has the function of holding the metal counterplate of the magnet, the bowl itself and the springs. Like all other components, the console should be printed with the highest possible infill to ensure maximum rigidity. The round iron plate, which is 80 mm in diameter and 8 mm thick, is carefully screwed into place. This metal plate is attracted by the magnet and thus generates the vibration. To fix the bowl, M4 fusion threads have been pressed into the bracket all around.

Bowl Bracket with metal plate
Bowl Bracket with metal plate

The electro magnet

The magnet in this system is a conventional pot magnet. This magnet is mounted on a bracket that is adjustable in height with the help of three M6 threaded rods. The height adjustment allows the exact adjustment of the distance to the opposite metal plate. Depending on the selected spring combination and operating voltage, this distance must be carefully adjusted. Normally, it is within a range of about 1-1.5 mm. However, it is essential to adjust this setting precisely, which must be determined empirically in practice.

Due to the high forces generated, depending on the spring-operating voltage combination, it was found that 3D-printed consoles tend to deflect. I have printed consoles in PLA and PETG, and my experience indicates that PLA is better suited because it is slightly stiffer. Sagging of the magnetic console results in the magnet moving towards the metal counter plate, which is extremely detrimental. While the operation is running, it may happen that the console swings up with time and the metal plate sticks to the magnet. The more stable the entire structure is, the better it is to create a consistent vibration. For this reason, I decided to make a thick iron plate to which the magnet was attached. This ensures that the magnet no longer vibrates up.

Magnet on iron plate
Magnet on iron plate

The electronics and the Arduino code

Another important component of the Vibration Bowl Feeder is the electronics. In order to achieve a smooth and even motion, certain aspects are crucial. My initial testing was done using a MOSFET from the 3D printing field. These MOSFETs are typically used to drive the heating bed of a 3D printer. With a MOSFET it is possible to control large electrical currents using a microcontroller like the Arduino. You can basically think of the principle as a light switch or a relay. The microcontroller sends a signal to the MOSFET, which then controls the circuit.

My idea was to simply turn the solenoid on and off at a frequency between 60 Hz and 120 Hz using Arduino code. However, this resulted in the movement of the parts in the bowl being rough and irregular. Smooth movement was not possible this way.

The problem here is that a coil is inert. A magnetic field takes a certain amount of time to build up and dissipate. If the magnet is simply switched off, a certain amount of time passes before the energy of the magnetic field is completely dissipated. This means that it also takes time to build up the magnetic field. The system therefore shows a certain inertia.

//Simple Arduino code to switch the magnet on and off
const int outputPin = 8; 
int frequency = 60;  
const int potPin = A0;

void setup() {
  pinMode(outputPin, OUTPUT); 

void loop() {
  int potValue = analogRead(potPin);
  int frequency = map(potValue, 0, 1023, 60, 120);
  int periodDuration = 1000 / frequency;  // Calculate the period duration in milliseconds

  digitalWrite(outputPin, HIGH);  // 
  delay(periodDuration / 2);  // Hold the signal HIGH for half of the period duration
  digitalWrite(outputPin, LOW); 
  delay(periodDuration / 2);  // Keep the signal LOW for the other half of the period duration


To overcome this problem, I looked for help in the forum. There I met a friendly expert in the field of microcontrollers, electronics and programming, who gave me the decisive tip. He provided me with an Arduino code with which it is possible to generate a sinusoidal signal using the DDS algorithm. My heartfelt thanks go to this kind gentleman! Without his support it would not have been possible for me to continue working on this point of the project.

Therefore, it is necessary to minimize the inertia of the system. One approach is to connect a diode to the electromagnet. This has the effect of short-circuiting the coil and quickly dissipating the magnetic field. I have tested this, but with only moderate success.

The solution to this problem lies in the bipolar control of the electromagnet, which means that the direction of current in the coil must be reversed during an oscillation period. The coil is therefore energized alternately in both directions. To ensure this, an H-bridge is needed. H-bridges are normally used to control the direction of rotation of electric motors. In my case I used an inexpensive L298 H-bridge.

Another important aspect is the voltage characteristic of the control. The H-bridge is driven with a sinusoidal voltage. This is not easy with a microcontroller, because a microcontroller output only knows zeros and ones. The challenge is how to generate a sine wave with these digital signals. I will discuss this point in more detail in the next section.

In summary, a smooth, clean and continuously adjustable movement is achieved by a bipolar sinusoidal control of the magnet.

The wiring

The power supply of the solenoid is connected to terminals 4 and 5.
The solenoid is connected to 1 and 2.
Connector 7 and 8 go to go to the Arduino Pin 9 and 10.
The 2 potentiometers are connected to 5V, Ground and respectively to A0 and A1 of the Arduino.

Important: GND of the power supply unit must be connected to GND on the Arduino.
Much more wiring is not necessary.

The wiring

The DDS-Algorithm (Direct Digital Synthesis)

At the beginning, I would like to emphasize that I am certainly not the expert on this algorithm. Nevertheless, I will do my best to explain the main points so that you understand how it works.

The DDS algorithm makes it possible to generate a sinusoidal voltage using digital signals (0 and 1). To do this, you must first understand what a PWM signal is. Certain pins of an Arduino are PWM capable. A PWM signal is basically a digital signal that mimics analog behavior. This is achieved by turning the pin on and off very quickly. The duration of the pulses determines the average power at the output. The speed of switching on and off can be controlled in the code. In this way it is possible to create a kind of analog signal.

Long pulses on „on“ result in higher average power at the pin, while shorter pulses result in lower average power. This opens up applications like controlling the speed of motors or adjusting the brightness of LEDs or even generating a sinusoidal signal.

The principle can be illustrated as follows: With a certain sampling rate a table is read out in which a PWM curve is shown. A value from this table is selected and applied to the output pin as a PWM signal. This produces a stepped sinusoidal pattern. Calculating the mean value of this pattern results in a sine curve. So it is possible to create any voltage curve with this table.

DDS Algorythm
DDS Algorythm

Here’s a little more detail:
The core of the DDS algorithm is to create a digital table of values representing a periodic signal, such as a sine wave. These values correspond to the amplitudes or heights of the signal at different points in time. The more values stored in this table, the more accurate the generated signal will be.

To generate a sinusoidal signal, a phase is used that is increased step by step. This phase is used as an index in the table to retrieve the corresponding value. As the phase increases, it goes through the table and reads the values one by one. These values are then used as amplitudes for the generated signal.

The key to the flexibility of the DDS algorithm is in the frequency control. When the rate of phase change is increased, the generated frequency of the signal increases. When the phase is changed more slowly, it results in a lower frequency. This makes it possible to generate signals with different frequencies by controlling the phase accordingly.




/* Sine signal generation by means of DDS

Output of two sinusoidal signals with variable frequency, amplitude and phase via PWM

Variable resolution

R(frequenz) : F_PWM / 2^16 = 15,625kHz / 65536 = 0,238Hz
R(phase)    : 360° / 256 = 1,4° = 0,025 rad
R(amplitude): 1 / 256 = 0,39%



#define F_PWM 15625     // Hz        // Must be an integer divisor of 62500!
#define PRESCALER 1     // Timer prescaler
#define SHIFT 2         // additional shift for PWM values, so that smaller PWM frequencies can be achieved without having to adjust the DDS table
#define TIMER_RELOAD ((F_CPU / ( PRESCALER * F_PWM) -1))    // Fast PWM
#define DELAY 20    // ms, Pause for intermediate steps in demo 
#define LOOPS 1     // Number of loops per modulation demo

// Variables

volatile uint16_t frequenz;
volatile uint8_t amplitude, phase;

const int8_t sinus[256] PROGMEM = {
  0, 3, 6, 9, 12, 16, 19, 22, 25, 28, 31, 34, 37, 40, 43, 46, 49, 
  51, 54, 57, 60, 63, 65, 68, 71, 73, 76, 78, 81, 83, 85, 88, 90, 
  92, 94, 96, 98, 100, 102, 104, 106, 107, 109, 111, 112, 113, 115, 116, 117, 
  118, 120, 121, 122, 122, 123, 124, 125, 125, 126, 126, 126, 127, 127, 127, 127, 
  127, 127, 127, 126, 126, 126, 125, 125, 124, 123, 122, 122, 121, 120, 118, 117, 
  116, 115, 113, 112, 111, 109, 107, 106, 104, 102, 100, 98, 96, 94, 92, 90, 
  88, 85, 83, 81, 78, 76, 73, 71, 68, 65, 63, 60, 57, 54, 51, 49, 
  46, 43, 40, 37, 34, 31, 28, 25, 22, 19, 16, 12, 9, 6, 3, 0, 
  -3, -6, -9, -12, -16, -19, -22, -25, -28, -31, -34, -37, -40, -43, -46, -49, 
  -51, -54, -57, -60, -63, -65, -68, -71, -73, -76, -78, -81, -83, -85, -88, -90, 
  -92, -94, -96, -98, -100, -102, -104, -106, -107, -109, -111, -112, -113, -115, -116, -117, 
  -118, -120, -121, -122, -122, -123, -124, -125, -125, -126, -126, -126, -127, -127, -127, -127, 
  -127, -127, -127, -126, -126, -126, -125, -125, -124, -123, -122, -122, -121, -120, -118, -117, 
  -116, -115, -113, -112, -111, -109, -107, -106, -104, -102, -100, -98, -96, -94, -92, -90, 
  -88, -85, -83, -81, -78, -76, -73, -71, -68, -65, -63, -60, -57, -54, -51, -49, 
  -46, -43, -40, -37, -34, -31, -28, -25, -22, -19, -16, -12, -9, -6, -3, 

// Set frequency in Hz

void set_frequenz(uint16_t frequ_Hz) {
  volatile uint16_t tmp;

  tmp = ((uint32_t)frequ_Hz<<16)/F_PWM;
    frequenz = tmp;

// Set phase in degrees

void set_phase(uint16_t phase_deg) {

    phase = (phase_deg << 8) / 360;

// Set amplitude in percent

void set_amplitude(uint16_t amplitude_prozent) {
  amplitude = (amplitude_prozent <<8)/100;

void demo(void) {
  uint16_t i, j;

  // Demonstration of the parameters

  // Amplitude modulation
  for (i=0; i0; j--) {
      amplitude = j;
  amplitude = 255;

  // Frequency modulation
  for (i=0; i0; j--) {
        frequenz = 256+2*j;
    frequenz = 256;

  // Phasenmodulation von OCR1B
  for (i=0; i0; j--) {
      phase = j;
  phase = 0;

void setup(){

  // Arduino UNO
  pinMode(9,OUTPUT);   // OCR1A
  pinMode(10,OUTPUT);   // OCR1B

  // Timer1 initialize
  // Mode 14, Fast PWM (ICR1), non-inverted PWM, Prescaler 1
  // OCR1A, OCR1B active
  TCCR1A  = (1<= 200 ) {
    last = now;
    tmp = analogRead(A0);
    frequenz_hz = map(tmp, 0, 1023, 60, 120);
    tmp = analogRead(A1);
    amplitude_prozent = map(tmp, 0, 1023, 0, 100);
    Serial.print(F("f: ")); Serial.print(frequenz_hz); Serial.print(F("   "));
    Serial.print(F("a: ")); Serial.println(amplitude_prozent);

// Interrupt for timer 1, frequency F_PWM
// PWM reload

ISR(TIMER1_CAPT_vect) {        
  // Index for sine table, fixed point number, 8 bit pre-decimal point, 8 bit post-decimal point
  static uint16_t i;    

  i += frequenz;
  OCR1A = ( 128+(((int8_t)pgm_read_byte(&sinus[i>>8])*(int16_t)amplitude)>>8)) << SHIFT;
  OCR1B = ( 128+(((int8_t)pgm_read_byte(&sinus[((i>>8)+phase) & 0xFF])*(int16_t)amplitude)>>8)) << SHIFT;  

Here you can download the files.
You get:
– all 3D files needed in .stl format
– a complete 3D model in .step format
– an overview drawing in .dxf and .pdf format




Kommentar verfassen

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert

Nach oben scrollen