How Does Waste Sorting Machine Manufacturing Work?

Waste sorting machines, also known as automatic garbage sorting machines, have become increasingly essential in the efforts to manage waste effectively and promote recycling. These machines play a crucial role in separating different types of waste materials, such as plastics, metals, paper, and organic matter, and diverting them from landfills. In this article, we will explore the inner workings of waste sorting machines and their significance in waste management.

If you are looking for more details, kindly visit qunfeng.

AI sorting robot

Understanding the Basics

Modern waste sorting machines combine advanced technologies with innovative mechanical systems to sort and segregate various waste materials. These machines are vital in recycling facilities, where they handle tasks like solid waste segregation and municipal solid waste (MSW) sorting. Whether it is a plastic waste segregation machine or a municipal solid waste sorting machine, the goal is to streamline the recycling process and maximize resource recovery.

Key Components of Waste Sorting Machines

Sensor Technology

The heart of an automated waste sorting machine lies in its sensor technology. A variety of sensors work together to identify and classify waste materials:

&#;Infrared Sensors: Used in many plastic waste segregation machines, these sensors detect the chemical composition of materials, distinguishing between types of plastics like PET, HDPE, and PVC.

&#;Optical Sensors: These sensors recognize colors and shapes, enabling the machine to separate items like colored glass, clear glass, and paper.

&#;X-ray Sensors: Common in solid waste segregation machines, these sensors identify materials based on density, making them ideal for detecting metals or hazardous items hidden within mixed waste streams.

Conveyor Belts and Robotics

The majority of garbage sorting machines rely on conveyor belts to transport waste materials through various sorting stages. Robotic arms with suction cups or grippers, guided by sensor data, precisely pick and place items into designated bins. This automation significantly reduces manual labor while improving sorting accuracy and efficiency.

Advanced Separation Techniques

Ballistic Separator Machines

A ballistic separator machine is a crucial component in many recycling facilities. It separates materials based on their size, weight, and density by tilting and vibrating the waste stream. Light materials like paper and plastic are moved to one side, while heavier objects like metals and glass are directed to another.

Trommel Screen Waste Separation

A trommel screen waste separation system uses a rotating cylindrical screen to sort materials by size. Smaller items fall through the perforated holes, while larger objects continue through the machine for further processing.

Magnetic and Eddy Current Separators

Magnets extract ferrous metals like iron and steel from the waste stream, while eddy current separators repel non-ferrous metals such as aluminum. These techniques ensure maximum recovery of recyclable metals.

Air and Optical Sorters

Air jets blow lightweight materials such as films and thin plastics into separate compartments. Optical sorters, often used in automatic waste sorting machines, enhance the accuracy of segregation by detecting specific material properties like transparency and reflectivity.

Final Quality Control

After the initial sorting, waste undergoes a final quality control check. In this stage, misclassified items are identified and re-sorted using sensors or manual inspection. This step is crucial for ensuring the purity of recovered materials, which directly impacts their value and usability in recycling markets.

Applications of Waste Sorting Machines

Automated waste sorting machines are used in various industries and applications:

&#;Municipal Solid Waste (MSW) Segregation

MSW sorting systems, such as MSW segregation machines, help cities manage increasing waste volumes while meeting recycling targets.

&#;Industrial Waste Management

Industries utilize solid waste segregation machines to process metal scraps, plastics, and other recyclables, reducing disposal costs.

&#;Plastic Recycling

A dedicated plastic waste segregation machine ensures efficient recovery of different types of plastics, which are then reused in manufacturing.

&#;Composting and Organic Waste Recycling

Organic waste is separated for composting, creating valuable fertilizers and reducing the burden on landfills.

Environmental and Economic Benefits

The deployment of waste segregation machines offers numerous advantages:

&#;Reduced Environmental Impact: By diverting recyclable materials from landfills, these machines help decrease greenhouse gas emissions and pollution.

&#;Resource Conservation: Materials like metals, plastics, and paper can be recycled into new products, reducing the need for virgin resources.

&#;Cost Efficiency: Automated systems lower labor costs and improve sorting speed, making recycling facilities more profitable.

According to recent industry data, the global waste management market is expected to grow at a CAGR of 5.3% from to , reaching $700 billion by the end of the decade. The adoption of advanced technologies like automatic garbage sorting machines and trommel screen waste separation systems will drive this growth.

Challenges and Innovations

Despite their benefits, modern waste sorting machines face challenges such as adapting to diverse waste compositions and processing complex materials. Innovations like AI-powered trash sorting machines and machine learning algorithms are addressing these issues, enabling better accuracy and adaptability.

Additionally, manufacturers are focusing on improving the energy efficiency of garbage segregation machines, ensuring that they align with sustainability goals while maintaining high performance.

Frequently Asked Questions

Q: What materials can waste sorting machines process?

A: These machines can handle plastics, paper, metals, glass, organic waste, and more, depending on the type of machine (e.g., municipal solid waste sorting machine, plastic waste segregation machine).

Q: How do PEAKS waste sorting machines improve efficiency?

A: By automating the sorting process, these machines reduce human error, lower labor costs, and recover more recyclable materials.

Q: Are these machines suitable for small facilities?

A: Yes, modular systems like automatic garbage sorting machines can be tailored to meet the needs of smaller recycling operations.

Conclusion

Waste sorting machines, including automated waste sorting machines and ballistic separator machines, represent the future of sustainable waste management. By combining advanced technologies like sensor systems, robotics, and specialized separators, these machines ensure efficient waste segregation and resource recovery.

Their role in promoting recycling, reducing landfill dependency, and conserving resources makes them indispensable tools for a more eco-friendly and resource-efficient future. As technology continues to evolve, the capabilities of these machines will only improve, further enhancing their contribution to global waste management efforts.

Each component as listed below is described, detailing its specification, connections and method of operation.

- Arduino Uno

- Inductive Sensors

- Capacitive Sensors

- Ultrasonic Sensors

- Motors

- Step Down Converter

Arduino Uno

As a microcontroller board we have used the Arduino UNO which is based on the ATmega328P. The Arduino Uno has 14 digital input/output pins (of which 6 can be used as PWM outputs), 6 analog inputs, a 16 MHz quartz crystal, a USB connection, a power jack, an ICSP header and a reset button [3].

Inductive Sensor

Inductive proximity sensors have been used to detect metal objects. We have used a larger sensor, based on our requirement of having a larger sensing range.

Type of sensor[Link]:

&#; Inductive Proximity Sensor Switch Model: LJ30A3-15-Z/AX

&#; Wire Type: DC 3 Wire Type

&#;Output Type: NPN-NC (Normally Closed)

&#; Detecting Distance: 15mm/ 0.59'

&#;The threads: M30

&#; Supply Voltage: DC 6-36V

&#;Current Output: 300mA

Capacitive Sensor

Capacitive sensors can sense any object within their sensing range. When the target approaches the face of the sensor, the capacitance increases, resulting in an increase in amplitude of the oscillator. Then the solid state output switch detects the increase in amplitude and based on that it is turned on or off.

There are different types of Capacitive Sensors. In our project we have used Capacitive Sensors with a compensation adjustment. The capacitive sensor sensitivity depends on the material dielectric constant. Plastic, in fact, has a lower dielectric constant than glass. We have adjusted our sensor in such a way that it can "see through" the objects of plastic nature (to not detect plastic),and glass is detected by the capacitive sensor alone.

Larger sensors have a larger range of detection.

Capacitive sensor specifications[Link]:

&#; Product Name: Capacitive Proximity Switch LJC30A3-H-Z/BX

&#; Wire Type: DC 3 Wire Type (Black, Brown, Blue)

&#; Output Type: NPN NC (Normal Closed)

&#; Diameter of Column Sensor: 30mm; Detecting distance: 15mm

&#; Supply Voltage: DC 6-36V; Current Output: 300mA

Motors

We have used servo motors for both gate and pipe, specifically,
we have used TowerPro MG996R servo motors.

Specifications of the TowerPro MG996R servo motor[Link]:

&#; Weight: 55g

&#; Dimension: 40.7×19.7×42.9mm

&#; Stall torque: 9.4kg/cm (4.8v); 11kg/cm (6.0v)

&#;Operating Speed : 0.13sec / 60 degrees (6.0V no load)

&#; Operating voltage: 4.8~ 6.6v

&#; Gear Type: Metal Gear

&#; servo wire length: 32cm

Contact us to discuss your requirements of Waste Sorting Machine Manufacturing. Our experienced sales team can help you identify the options that best suit your needs.

&#; Current draw at idle 10MA

&#; No load operating current draw 170mA

&#; Stall current draw mA

&#;Weight: 0.080 kg

Step Down Converter

The DC/DC step-down voltage regulator is capable to convert voltage between 3.2V and 40V into a smaller voltage between 1.25V and 35V. It is capable of driving a 3A load.
We have adjusted this step-down converter for our requirements, respectively the 6V from the power supply has been converted to 5V which feeds the Arduino Uno; this has been done via the potentiometer for voltage adjustment.

Specifications[Link]:

&#; Input voltage: 3.2V - 40VDC
&#; Output voltage: 1.25V - 35VDC

&#; Max. output Current: 3A

&#; Dimensions: 43mm x 21mm x 14mm(l) x (w) x (h)

&#; Weight: 12 g

On the choice of the motor it is very important one to have an idea of the torque required for the specific implementation.

In the figure a) are given the calculations for the gate torque. The torque needed for the motor to rotate the gate is calculated to be 1. kg-cm. The diameter of the shaft is chosen 4 mm.

In the figure c) are given the calculations for the pipe torque. The torque needed for the pipe motor to rotate the pipe is calculated to be 1. kg-cm.

Experimentally: the current needed is 0.11 A, which corresponds to the torque of 0. kg-cm. The experimental results are close to the calculated analytical values.

In the figure b) is given the servo motor with the weight (load) of 11 kg suspended in 1 cm which represents the stall torque of 11 kg-cm as given in the data sheet. The necessary torque for the gate and the pipe has been calculated analytically and we concluded that each of the servo motors; are more than sufficient to provide the required torque. Further to note the the maximum current draw from the system was measured to be 0.28 A (when the Pipe Servo is rotating) which is less than the stall current of the motor 1.4 A.

A simple/fast approximation of the torque needed for the pipe servo can be done as follows:

T=F*d
In terms of kg-cm we have:

T=kg*cm

T=0.8 kg *(12.5/2)

T=0.8*6.25=5 kg-cm

This result gives as an indication that the servo motor used can fulfill the requirements in terms of torque.

Simply the motor can pull a weight of 0.8 kg suspended in a distance of 12.5/2 cm and we get 5 kg-cm. Since the Torque is directly proportionally to the current. And speed of rotation is directly proportional to voltage applied to the servo motor.

Therefore, we can analytically now calculate the torque that corresponds to the case of 0.28 A.

T=Kt*I
Tstall=11kg-cm
Istall=1.4 A
Kt=7.85
For our case I=0.28 A
T=2.198 kg-cm

Figure 8. Flowchart

To do the sorting of three different types of materials we have used three sensors. Based on these sensors values we can distinguish the type of material. We have 3 cases: Metal detected, Plastic Detected, Glass detected. As we can notice in the flowchart those three cases correspond to those specific state combinations of the sensors.

The programming is divided into these sections:

1. Initialization of the system

2. Object and Material Detection

3. Servos Movements

1. Initialization

Comment: In startup Gate and Pipe servo will go to a prescribed position, this procedure will be repeated in each start-up or reset. This part of the code will be executed only once in startup.

- Read the values for the actual position of the two Servo motors.

If Pipe position != to the zero position

-move pipe to the zero position

-move gate and then bring it back to the initial position (This is done intentionally each system start up/reset; no matter if it is in the zero position or not)

If Pipe position == the zero position

-move gate and then bring it back to the initial position (This is done intentionally each system start up/reset; no matter if it is in the zero position or not)

-Initialize sensors

2. Object and Material Detection

if (Inductive Sensor<=250 && Capacitive Sensor == 1 && Ultrasonic Sensor Distance<=14 cm)

-Plastic Detected: To Plastic Bin (step 3)

if(Inductive Sensor<=250 && Capacitive Sensor != 1 && Ultrasonic Sensor Distance<=14 cm)

-Glass Detected: To Glass Bin (step 3)

if(Inductive Sensor>=250){

-Metal Detected: To Metal Bin (step 3)

3. Servos Movements

If Plastic Detected:

-Move Pipe Servo to Plastic Bin

-Delay

-Move Gate Servo from position 0 to 1
-Delay

-Move Gate Servo from position 1 to 0

If Glass Detected:
-Move Pipe Servo to Glass Bin

-Delay

-Move Gate Servo from position 0 to 1

-Delay

-Move Gate Servo from position 1 to 0

If Metal Detected:

-Move Pipe Servo to Metal Bin

-Delay

-Move Gate Servo from position 0 to 1

-Delay

-Move Gate Servo from position 1 to 0

In the following section the code will be provided.

[code]<br>

//********************************************
// GROUP 8: AUTOMATIC WASTE SORTING MACHINE  *
// MECHATRONICS                          *
// @GROUP 8                                  *
//*******************************************

#include <Servo.h>

Servo Pipe_Servo;
Servo Gate_Servo;

// define the variables
int sensorInd = A0; //Pin A0 (analog)
int sensorpin = 2; //Digital Pin nr. 2
int indValue;
const int trigPin = 7;
const int echoPin = 8;
int i=0;
float Pipe_Pos=0.0;
float Gate_Pos=0.0;
int n=0;

long duration;
int distance;

float metalDetected;

void setup() {

pinMode(trigPin, OUTPUT); // trigPin=output
pinMode(echoPin, INPUT); // echoPin = input

Serial.begin(); // Starts the serial communication

// Codes that run only once[

//--System Initialization--

    Pipe_Pos=Pipe_Servo.read();//Read the last value given to Pipe servo
    Gate_Pos=Gate_Servo.read();//Read the last value given to Pipe servo

    Serial.println("Motor_PIPE Position");
    Serial.println(Pipe_Pos);
    Serial.println("Motor_GATE Position");
    Serial.println(Gate_Pos);
    delay();

    
    Pipe_Servo.attach(11);

    if (Pipe_Pos<90){
      

      for(i=Pipe_Pos; i<=90; i=i+1){
      Pipe_Servo.write(i);
      delay(15);
      }
    }
      
      else {
        for(i=Pipe_Pos; i>=90; i=i-1){
        Pipe_Servo.write(i);
        delay(15); 
      
        }
      }

delay(); //Delay (wait) for servo pipe to go to the bin.

    //Next rotate the gate servo.
    //And control the speed of Gate Servo.
    Gate_Servo.attach(10);

     for(n=0; n<=45; n=n+1){  //Choose the right angle for Gate servo
      Gate_Servo.write(n);
      delay(20); //Controll the speeed of Gate servo 

    }   

    delay(); //Delay (wait) and then bring back the Gate_Servo to its
     //initial position.

     //Bring Back Gate_Servo to initial position
     //So from actual position 2-> n=45; we go backwards up to n=0.

     for(n=45; n>=0; n=n-1){ 
      Gate_Servo.write(n);
      delay(25); //Control the speed of Gate servo 
     }

delay();

//--System Initialization--//
// Codes that run only once]
}

void loop() {

//delay(100);
delay();

// Clears the trigPin
digitalWrite(trigPin, LOW);
delayMicroseconds(10);//
// Sets the trigPin on HIGH state for 10 micro seconds
digitalWrite(trigPin, HIGH);
delayMicroseconds(30);//it was 1
digitalWrite(trigPin, LOW);
// Reads the echoPin, returns the sound wave travel time in microseconds
duration = pulseIn(echoPin, HIGH);
// Calculating the distance
distance= duration*0.034/2;
// Prints the distance on the Serial Monitor
Serial.print("Distance: ");
Serial.println(distance);

indValue=analogRead(sensorInd);//Save value that is read from the analog pin A0 to the variable indValue
delay(10);
int sensorstate = digitalRead(sensorpin); // Digital value for Capacitive S.
delay(500);
metalDetected = (float)indValue*100/.0; //from analog value
delay(50);
Pipe_Pos=Pipe_Servo.read();//Read the actual position of Pipe servo
Gate_Pos=Gate_Servo.read();//Read the actual position of Gate servo

//**METAL DETECTED**/

/ if(indValue>=250 && sensorstate == 1 && distance<=14)
  if(indValue>=250){
   Serial.println("Metal Detected");
    Pipe_Pos=Pipe_Servo.read();//Read the last value given to Pipe servo
    Gate_Pos=Gate_Servo.read();//Read the last value given to Pipe servo
    Serial.println("Motor_PIPE Position");
    Serial.println(Pipe_Pos);
    Serial.println("Motor_GATE Position");
    Serial.println(Gate_Pos);

    Serial.println("Motor to metal bin");

    delay(100);
    //Wait for some time after the measurements and move servo to 
    //the corresponding bin

    //For initial position of servo_gate/PIPE in this case the read function will give us the last position of servo
    //in degree
    //Go to the second position of the PIPE servo @90 degree
    //To control the speed of the servo we do this for loop.
    //We have 2 cases 1; when pipe is somewhere in position greater then 90, in this particular case we want to go to 90 so we have to loop back.
    //The other case is to loop forward i=i+1, (meaning to increase the angle in incremental manner).
    
    if (Pipe_Pos<90){

      for(i=Pipe_Pos; i<=90; i=i+1){
      Pipe_Servo.write(i);
      delay(15);
      }
    }
      
      else {
        for(i=Pipe_Pos; i>=90; i=i-1){
        Pipe_Servo.write(i);
        delay(15); 
      
        }
      }

delay(); //Delay (wait) for servo pipe to go to the bin.

    //Next rotate the gate servo.
    //And control the speed of Gate Servo.

     for(n=0; n<=45; n=n+1){  
      Gate_Servo.write(n);
      delay(20); 

    }   

    delay(); //Delay (wait) and then bring back the Gate_Servo to its initial position.

     //Bring Back Gate_Servo to initial position
     //So from actual position 2--> n=45; we go backwards up to n=0.

     for(n=45; n>=0; n=n-1){  
      Gate_Servo.write(n);
      delay(25);  
     }
    
   //**METAL DETECTED**// 

   //**PLASTIC DETECTED**// 
   
   }

   else if(indValue<=250 && sensorstate == 1 && distance<=15){ //NO NO state
   delay(100);
   Serial.println("Plastic Detected");

    Pipe_Pos=Pipe_Servo.read();//Read the last value given to Pipe servo
    Gate_Pos=Gate_Servo.read();//Read the last value given to Pipe servo
    Serial.println("Motor_PIPE Position");
    Serial.println(Pipe_Pos);
    Serial.println("Motor_GATE Position");
    Serial.println(Gate_Pos);
    Serial.println("Motor to Plastic Bin");

    delay(100); 
    //Wait for some time after the measurements and move servo to 
    //the corresponding bin

    
    //For initial position of servo_gate/PIPE in this case the read function will give us the last position of servo
    //in degree
    //Go to the second position of the gate Pipe_Servo in degree (145) for Plastic
    //To control the speed of the servo we do this for loop.

    //We have 2 cases 1; when pipe is somewhere in position greater then 145, in this particular case we want to go to 145 so we have to loop back.
    //The other case is to loop forward i=i+1, (meaning to increase the angle in incremental manner)until we reach the desired angle.
    
    if (Pipe_Pos<145){

      for(i=Pipe_Pos; i<=145; i=i+1){
      Pipe_Servo.write(i);
      delay(15);
      }
    }
      
      else {
        for(i=Pipe_Pos; i>=145; i=i-1){
        Pipe_Servo.write(i);
        delay(15); 
      
        }
      }

delay(); //Delay (wait) for servo pipe to go to the bin.

    //Next rotate the gate servo.//This remains the same for all other cases
    //And control the speed of Gate Servo.

     for(n=0; n<=45; n=n+1){  
      Gate_Servo.write(n);
      delay(20); 

    }   

    delay(); //Delay (wait) and then bring back the Gate_Servo to its
     //initial position.

     //Bring Back Gate_Servo to initial position
     //So from actual position 2--> n=45; we go backwards up to n=0.

     for(n=45; n>=0; n=n-1){  //Choose the right angle for Gate servo
      Gate_Servo.write(n);
      delay(25); //Controll the speeed of Gate servo (it can be a litle faster now) 
     }
//delay(100);
 
   }

//**PLASTIC DETECTED**// 

//**GLASS DETECTED**// 

else if(indValue<=250 && sensorstate != 1 && distance<=14){ 
   Serial.println("Glass Detected");

    Pipe_Pos=Pipe_Servo.read();//Read the last value given to Pipe servo
    Gate_Pos=Gate_Servo.read();//Read the last value given to Pipe servo
    Serial.println("Motor_PIPE Position");
    Serial.println(Pipe_Pos);
    Serial.println("Motor_GATE Position");
    Serial.println(Gate_Pos);
    Serial.println("Motor to Glass Bin");

    delay();
    //Wait for some time after the measurements and move servo to 
    //the corresponding bin

    //For initial position of servo_gate/PIPE in this case the read function will give us the last position of servo in degree
    //Go to the second position of the Pipe_Servo @25 degree for Glass
    //To control the speed of the servo we do this for loop.

    //We have 2 cases; when pipe is somewhere in position greater then 90, in this particular case we want to go to 25 so we have to loop back.
    //The other case is to loop forward i=i+1, (meaning to increase the angle in incremental manner).
    //Actually in this case we can have only one case when angle is greater then 25, but however! :P

    if (Pipe_Pos<25){

      for(i=Pipe_Pos; i<=25; i=i+1){
      Pipe_Servo.write(i);
      delay(15);
      }
    }
      
      else {
        for(i=Pipe_Pos; i>=25; i=i-1){
        Pipe_Servo.write(i);
        delay(15); 
      
        }
      }

delay(); //Delay (wait) for servo pipe to go to the bin.

    //Next rotate the gate servo.//This remains the same for all other cases
    //And control the speed of Gate Servo.

     for(n=0; n<=45; n=n+1){  
      Gate_Servo.write(n);
      delay(20); 

    }   

    delay(); //Delay (wait) and then bring back the Gate_Servo to its
     //initial position.

     //Bring Back Gate_Servo to initial position
     //So from actual position n=45; we go backwards up to n=0.

     for(n=45; n>=0; n=n-1){  
      Gate_Servo.write(n);
      delay(25); 
     }

    Serial.println("Motor_PIPE Position");
    Serial.println(Pipe_Pos);
    Serial.println("Motor_GATE Position");
    Serial.println(Gate_Pos);
}
}

[/code]

*We suggest to use the code attached here.

Every project on its own has its difficulties and challenges, for our project challenges are listed below:

Rotating the Pipe: Designing a mechanism, while bettering of the project done last year was a challenge. We wanted to have something that can be implemented in real life (like having a centralized garbage system in a Building). Countering the problem of the last year project we focused on not moving the Garbage can and so we went for a design which included a Pipe which rotates in 3 direction of fixed garbage can.

Designing a Gate: Designing a gate where the sensor detects the type of waste and directs it to the pipe, while the pipe rotates in the meantime to the respective garbage can was very tricky. We had several ideas from having an Objection plate while the garbage is held on the plate for detection and having a tilting bucket etc. Finally, we went for an idea of V-gate in order to avoid the movement of sensors and have less mechanical moving parts.

Using bearings: The original Idea involved using bearing both for V-gate shaft and Pipe support. As seen we used an 8 mm Radial bearing for Gate shaft on the either side. Also the rotating pipe shaft was to be supported by a thrust bearing, eventually we opted out of this idea as the wooden frame constructed for the Pipe was more than sufficient to support it. This saved a lot of time and prevented further any future mechanical complications in the project.

Using only one power supply: It was a challenge to restrict our selves in using only one power supply and having least electronic components as possible. Therefore, in our design phase, we have considered all the possible ways to use only one power supply efficiently; and we opted for the scheme that is represented in the electronics chapter.

Accuracy of sensors: Sensors are not always accurate, having limitation in their distance of measurement. This affects it's accuracy in detection (particularly when the object is small). We intended to modify the gate design by adding a printed part but it effected the performance of the sensor and so for future implications of the system for better detection, shielded sensors can be used.

Position of Sensors: There are many factors that came in to the picture while deciding the position and location of our sensors. We considered making a fixed structure for the sensors because we did not want the sensors to be attached to the gate. Also, the distance between the two sensors had to be considered so that the sensors do not influence each other. This has been done by considering the recommended distance in the datasheet and also by some trial and error we found the optimal locations to place our sensors.

Initialization of the system: In the start-up of the system, we wanted everything to go to the prescribed zero position. However, servos were moving without a command given to them (fast and not as commanded). We "fixed" this by considering the actual position of the motors on the system start-up. Furthermore, one can consider here other ways of solving this issue, for instance, using different servos, other software solutions like using EEPROM; or hardware solutions.

Tuning and adjusting different parameters of the system: Tuning and adjusting different parameters of the system, and making everything work together was rather challenging. We opted for values that are optimal, however, the system response can be increased by changing these parameters (ex. speed of servos, the delays added into the code, etc.). Also, we observed that it will detect more efficiently metals if we only consider the data from the inductive sensor, this can be seen in the codes given in the programming section.

The company is the world’s best Waste Sorting Machine Exporter supplier. We are your one-stop shop for all needs. Our staff are highly-specialized and will help you find the product you need.