How to make electric feeder BLDC Motor？

Here is a comprehensive guide on how to approach making an electric feeder with a BLDC motor, broken down into stages.

Important Disclaimer:

Building a system like this involves working with high voltages and powerful motors. If you are not experienced and qualified, please exercise extreme caution. This overview is for educational purposes to understand the components and process.

The process can be broken down into three main parts:

1. The Mechanical Feeder System

2. The BLDC Motor and Drive Electronics

3. The Control System & Programming

Phase 1: Mechanical Feeder Design

This is the platform that will actually move the parts. The most common type is a vibratory bowl feeder.

1. Design the Feeder Base: You need a base plate mounted on a set of flexible leaf springs. This allows the entire assembly to vibrate freely. The spring angle is critical for creating the desired directional motion (e.g., a spiral climb for a bowl).

2. The Bowl or Track: This is the part that holds and orients the components. It's typically a bowl with a spiral track running inside it from the bottom to the exit. Designing the tooling (guides, wipers, traps) on the track to correctly orient parts is a specialized skill.

3. The Driving Mechanism: This is where the BLDC motor comes in. You need to attach an eccentric mass (an unbalanced weight) to the motor's shaft. When the motor spins this mass, it creates centrifugal force, which causes the vibration.

Phase 2: BLDC Motor System

You won't be building the BLDC motor itself; you will be selecting and integrating it.

1. Select a BLDC Motor: Choose a motor with sufficient torque and RPM for your feeder size. Larger, heavier feeders require more powerful motors.

   • Source: Purchase a standard BLDC motor from a supplier (e.g., maxon, T-Motor, or many vendors on Amazon/AliExpress for hobbyist-level projects).

2. Select the Electronic Speed Controller (ESC): This is the essential brain for the motor. The ESC takes a low-power control signal and DC power and delivers three-phase AC power to the motor windings to make it spin.

   • Key Feature: Ensure the ESC can operate in speed-controlled mode and accepts a standard control signal like PWM (Pulse Width Modulation) or 0-10V analog. This is how your main controller will tell it how fast to go.

3. Power Supply: You need a DC power supply (e.g., 24V or 48V) capable of delivering the current required by both the motor and the ESC. Overspec this by at least 25% to be safe.

Phase 3: Control System & Integration

This is the intelligence of the system.

1. Microcontroller (The Boss): This is a small computerlike board (e.g., Arduino, Raspberry Pi, STM32, PLC) that will run your control program.

2. User Interface (Input): You need a way to set the speed. This could be a simple potentiometer (variable resistor) connected to the Arduino's analog input, a rotary encoder, or a touchscreen.

3. Feedback Sensor (Optional but Highly Recommended): To make a truly robust system, you need feedback. A photoeye (optical sensor) or proximity sensor at the exit of the feeder can count parts. This allows the controller to maintain a precise feed rate (parts per minute) instead of just a motor speed.

4. Wiring and Integration:

   • Power Supply connects to the ESC.

   • ESC connects to the BLDC Motor's three phases.

   • The microcontroller sends a PWM signal to the ESC's control wire.

   • The user interface (potentiometer) connects to the microcontroller's analog input.

   • The feedback sensor connects to a digital input on the microcontroller.

Phase 4: Programming & Tuning

This is where you bring it all to life.

1. Basic Speed Control Program (Arduino Pseudocode):

   cpp

   复制

   下载

   int potPin = A0;    // Potentiometer connected to analog pin A0
   int escPin = 9;     // ESC control wire connected to digital pin 9 (PWM)
   int potValue = 0;
   int speedValue = 0;
   
   void setup() {
     pinMode(escPin, OUTPUT);
     // Often ESCs require an "armming" sequence on startup
     // e.g., send a low PWM signal for a few seconds
   }
   
   void loop() {
     potValue = analogRead(potPin);                 // Read the pot (0-1023)
     speedValue = map(potValue, 0, 1023, 1000, 2000); // Map to standard ESC PWM range (1000us - 2000us pulse)
     analogWrite(escPin, speedValue);               // Send command to ESC
     delay(20);                                     // Small delay for stability
   }

2. Advanced Program with Feedback (Concept):

   • The program would constantly check the part counter sensor.

   • It would compare the actual part count over time to the desired feed rate.

   • It would then automatically adjust the PWM signal sent to the ESC to increase or decrease the motor speed, creating a closed-loop control system that maintains the exact feed rate you want, regardless of material load or other variables.

A Much Simpler Alternative: Using a Pre-made BLDC Feeder Controller

For most practical applications, you don't build the controller from scratch. Companies like Syntron and RNA manufacture dedicated BLDC controller units for vibratory feeders.

• You simply mount your feeder bowl on their base unit, which has the BLDC motor and eccentric mass already installed.

• You plug it into their pre-programmed control box.

• The control box has a knob for speed adjustment and often built-in features like soft-start, overload protection, and sometimes even basic feed rate control.

This is by far the most reliable and efficient way to "make" a professional-grade system.

Summary of Steps:

1. Design/Buy the mechanical feeder bowl and base with spring suspension.

2. Select and Mount a BLDC motor with an eccentric mass onto the feeder base.

3. Choose a compatible ESC and power supply for the motor.

4. Wire a microcontroller (e.g., Arduino) to read a speed potentiometer and output a PWM signal.

5. Connect the PWM signal to the ESC to control motor speed.

6. Write and upload code to translate the potentiometer value into a speed command.

7. (Advanced) Add a sensor and program a closed-loop control system for precise feed rate management.

Building one from the ground up is a fantastic and rewarding engineering project, but using a pre-designed controller and motor base is the standard professional practice.