When it comes to optimizing your production line, selecting the right press can significantly impact efficiency, quality, and operational costs. Two of the most popular options available are hydraulic press and servo presses.
For more information, please visit S-T Intelligence.
While both serve critical roles in industrial manufacturing, they differ in terms of functionality, performance, and suitability for specific applications.
This article explores the key features, advantages, and considerations of each type of press to help you decide which is best for your production line.
A hydraulic press operates on Pascal’s principle, which states that pressure applied to a confined fluid is transmitted equally in all directions.
Hydraulic presses use hydraulic cylinders to generate a compressive force, making them highly versatile and capable of handling a wide range of tasks.
From metal forming to forging, cutting, and stamping, hydraulic presses are integral to many industries, including automotive, aerospace, and construction.
Applications: Hydraulic presses are widely used in forging, stamping, deep drawing, and metal shaping processes. They are also employed in creating automotive components, plastic molds, and industrial equipment.
Servo presses, often referred to as servo stamping presses, utilize a servo motor to control the ram’s movement. Unlike hydraulic presses, which rely on hydraulic fluid for power, servo presses are driven by electric motors. This allows for precise and programmable motion control, making servo presses ideal for high-precision applications.
Applications: Servo presses excel in applications requiring high precision and consistency, such as stamping, forming, and assembly of electronic components, automotive parts, and medical devices.
To determine which type of press is best for your production line, it’s essential to consider several factors, including force requirements, precision, operational costs, and specific application needs.
Winner: For heavy-duty applications, hydraulic presses take the lead. For precision tasks, servo presses are the better choice.
Winner: Servo presses dominate this category.
Winner: Servo presses outperform hydraulic presses in terms of speed and efficiency.
Winner: Servo presses are more energy-efficient.
Winner: Hydraulic presses are easier and cheaper to maintain, but servo presses are more reliable in the long term.
Winner: Hydraulic presses are more budget-friendly for startups and small-scale operations.
The decision between a hydraulic press and a servo press ultimately depends on your production requirements, budget, and long-term goals. Here are some considerations to guide your choice:
If your production line involves heavy-duty tasks like forging and deep drawing, a hydraulic press is the better choice.
For high-precision tasks like electronic assembly or fine blanking, a servo press is more suitable.
Hydraulic presses are more affordable upfront and are ideal for businesses with limited budgets.
While servo presses have a higher initial cost, their energy efficiency and low maintenance make them cost-effective in the long term.
For high-speed, high-volume production lines, servo stamping presses offer superior efficiency.
Hydraulic presses are better for low to medium-volume operations that require significant force.
If reducing energy consumption is a priority, servo presses are the clear winner.
Choose hydraulic presses if you prefer straightforward maintenance with lower costs.
Opt for servo presses if you value reliability and are willing to invest in specialized repairs when needed.
Investing in the right equipment is critical for the success of your production line. Whether you choose a hydraulic press or a servo press, working with a reputable manufacturer ensures quality, reliability, and support. A trusted servo press manufacturer can provide customized solutions, technical guidance, and after-sales service to help you maximize the efficiency and lifespan of your equipment.
Both hydraulic and servo presses offer unique advantages, making them indispensable for various industrial applications. Hydraulic presses are ideal for heavy-duty tasks requiring immense force, while servo presses shine in precision, speed, and energy efficiency. By evaluating your specific production needs and consulting with experienced manufacturers, you can make an informed decision that boosts your operational efficiency and profitability.
Whether you’re looking for a hydraulic press to handle tough metal forming jobs or a high-precision servo stamping press for intricate tasks, choosing the right equipment is a crucial step toward achieving your production goals. Take the time to assess your requirements, budget, and long-term plans to make the best choice for your production line.
What do you do when you need a big servo motor but don’t want to spend a big amount of money? Make your own, of course!
Servo motors are essential components when working with robotics, model aviation, and other animated projects. They are used in all kinds of industrial applications as well.
Servo motors, for those not familiar with them, are motors whose shaft position can be precisely controlled by an external signal. Unlike stepper motors, which also have controllable shaft positions, servo motors don’t need a reference point to start with. You just specify the angle of shaft rotation, and the servo motor will oblige by moving into that position.
Large industrial servo motors use sophisticated controllers and cost quite a bit of money. Smaller, hobby-grade servo motors (sometimes called “RC Servo Motors”) are much more affordable, but they have their limitations.
The biggest limitation with hobby-grade servo motors is the amount of power, or torque, they can provide. The larger the motor, the greater the torque, but this gain comes with a corresponding price increase.
Another limitation is the range, or degrees of rotation, that these motors are made for. The most common hobby-grade servos rotate 180 degrees, some models are available that have 270 degrees of rotation.
But what do you do if you want a smaller, or larger, amount of rotation? It’s entirely possible that you might want to rotate more than 360 degrees. And what if you need a large amount of torque, greater than that provided by inexpensive hobby servo motors?
The answer, of course, is to make your own servo motor. A custom design, based upon your specific needs.
In fact, I know someone who requires a custom servo motor.
I’m sure most of you are already familiar with Jeremy Fielding through his YouTube Channel. For the few of you who are not familiar with Jeremy’s work, he is a mechanical wizard who builds amazing projects in his workshop, many of them using 3D-printed or reclaimed materials. If you want to know anything about mechanical engineering or working with motors, then Jeremy is the fellow you need to know.
Jeremy and I were chatting, and he mentioned that he required a very large servo motor for one of his projects. Not only does it need to have a lot of torque, it also has to be able to turn two full revolutions (720 degrees) instead of 180 degrees. All driven by a signal intended for a standard hobby-grade servo.
So we decided that the easiest way to meet his requirements was to build a custom servo motor, using a high-torque DC motor.
Now, of course, your requirements may differ from Jeremy’s, and that’s fine – this custom design can be tailored to just about any application.
Before we get into the design and the hardware, let’s just review how a servo motor actually works.
As I’ve already mentioned, a servo motor is a motor whose shaft position can be set using an external control signal.
With a standard hobby servo motor, that control signal is a logic-level PWM waveform. The pulse width of the PWM waveform is how the servo position is controller.
The width of the pulses ranges between and microseconds. At microseconds the servo is in its Top Dead Center (TDC) position, on a standard 180-degree servo motor this is the 90-degree position.
Internally, a servo motor consists of a DC motor driven by a controller. The controller takes in the PWM signal. Measures its pulse width and turns the motor accordingly.
The key to making all of this work is that the motor shaft is coupled to a sensor, which reads the motor position. This position information is fed back to the controller, which then makes the appropriate adjustments to the motor speed and direction.
This diagram illustrates how it all fits together.
Note that the controller can be either a digital or analog design, as both types of circuits are used in modern hobby servo motors.
So by building our own controller and position sensor, we should be able to turn just about any brushed DC motor into a servo motor.
Here is a summary of what we would need to build our own custom servo motor:
For our demonstration, we will be using the following components:
Here is how these fit into the servo motor design.
We have used the Seeeduino XIAO before, it’s a low-cost Arduino-compatible microcontroller that is based upon the SAMD21 processor.
I selected the XIAO as it is inexpensive, tiny, and easy to work with. I also chose it as it has a 12-bit analog to digital converter (ADC), as opposed to the 10-bit ADC that the Arduino Uno and other Arduino AVR boards have.
We will be programming our XIAO using the Arduino IDE. If you haven’t used the IDE with the XIAO before, you’ll need to set it up first. This involves (a) adding a new board JSON file to your Arduino IDE Properties window and (b) installing the board using the Boards Manager.
It’s a pretty simple installation, and you’ll find all the details and instructions in the article I did about using the Seeeduino XIAO.
We will also be using a logic-level converter in our design, as the XIAO is a 3.3-volt device and most PWM sources provide either 5 or 6 volts. Of course, we could also have just used a transistor for this, but the logic-level converter is inexpensive and very easy to use.
I used a 2-channel bidirectional logic level convertor, simply because I have a drawer full of them! The bidirectional feature is not being used, so a convertor that has unidirectional channels can also work fine. If you do use a unidirectional converter, remember that the servo connector is the 5-volt input and the 3.3-volt output goes to the XIAO.
I chose this driver simply because it’s the same one that Jeremy will be using in his project. You certainly don’t have to use it, as any motor driver will work as long as it has (a) a PWM input to control motor speed and (b) a direction control.
The MD25HV has the following specifications:
One very nice feature about this motor driver is that it has a regulated 5-volt output, which we can use to power the Seeeduino XIAO.
We will be using a 10-turn 10K linear-taper potentiometer as a position sensor for this design.
If you are building a servo motor that is only traveling 180 degrees, then a standard potentiometer will work just fine. In fact, most commercial servo motors use a standard pot. Just be sure it is a linear-tapered potentiometer, which means when the shaft is in the middle position, the resistance between the wiper and both legs is exactly half of the pot’s total resistance.
It can also be another value other than 10k, anything above 5K will work just fine.
You’ll also have to figure out how to couple the potentiometer to your motor shaft. In my case, I got off easy, as Jeremy was kind enough to provide a 3D-printed demo that had the motor coupled to the potentiometer via a number of gears.
We are using a potentiometer in our design today as it is (a) inexpensive and (b) really available. It is also the type of sensor used in just about every hobby servo motor, which is one of the reasons that small hobby servos are so inexpensive.
But a potentiometer certainly isn’t the only type of position sensor, nor is it the best. There are several alternate sensors that would probably improve the performance of our design.
We have looked at rotary encoders before, these are devices that send a series of pulses out when rotated, as opposed to changing resistance. Internally they employ techniques like optical sensors, so they have the advantage of not wearing out as potentiometers do.
The problem with standard rotary encoders is that they are incremental, not absolute, indicators of motion. To determine absolute position, most encoders add a third track and photosensor as an indicator zero reference track; the shaft must rotate enough to pass the zero reference position for this to signal. This adds to both their complexity and cost.
The accuracy of a rotary encoder is determined by the internal disk that rotates and contains evenly-spaced openings, which interrupt the photosensors. The finer this gap is, the more accurate the encoder can be. A standard rotary encoder, such as the ones we examined in the previous article, would not be suitable for this application.
As with potentiometers rotary encoders can be affected by dirt and other contaminants if they are not completely sealed.
These devices, as their name implies, use variations of capacitance to sense rotation and position. Unlike optical encoders, these devices use a repeating, etched pattern of conductors on the moving and non-moving parts of the encoder. As the encoder rotates, the relative capacitance between the two parts increases and decreases, and this change in capacitance is sensed. Multiple tracks can be added to determine absolute position.
CUI Devices make the AMT10 Series of capacitive sensors, which would be quite suitable;le for this application.
These devices are not as susceptible to contamination as potentiometers and rotary encoders are. They would be an excellent choice for our design!
Another fine choice for a position sensor is based upon the Hall Effect principle, which is another subject that we have discussed in previous articles and videos. Hall Effect devices can be used to sense current flow through a conductor that is part of the sensor, or the presence or absence of a nearby magnetic field.
In this type of sensor, a magnet is fixed to the motor shaft. A sensor like the Melexis MLX, which is specifically designed for this application, senses the change in magnetic flux and can report the angular position of the motor shaft through a full 360 degrees.
Are you interested in learning more about Customized Servo Production Line? Contact us today to secure an expert consultation!
This type of sensor is used in automotive applications, and would probably be a great sensor for Jeremy’s “self-driving go-kart”!
There are a few other types of sensors we can employ as well, such as resolvers. and inductive encoders. A great article that sums up the strengths and weaknesses of many rotary position sensors can be found on the Celera Motion website.
Now what we have all of our components together, it’s time to hook them up. Here is the wiring diagram for our servo controller:
If you are using the same logic-level converter as I did, then you can follow the chart on the schematic to wire it up. If you are using a different one, then you’ll need to adjust the wiring accordingly. See the description of the convertor for more details.
The “Power” jumper is optional, it is used to allow the controller to provide 5-volts through the servo connector to power the device that controls the servo. If you are using a device (like an Arduino) that has its own power, then you can eliminate this, or remove the jumper.
Before we get to our actual servo motor sketch, there are a couple of smaller sketches that we need to run. Actually, the first one is optional, but it’s a good idea to try it out, as it will confirm that you have the wiring correct. The second one is mandatory, as we will be using it to get some values to plug into the final sketch.
Once again, you’ll need to have the Boards Manager for the Seeeduino XIAO installed before you start.
This one is optional, although the information it gives you can be used to “fine-tune” the final sketch to make it even more accurate.
The primary purpose of this sketch is to test the input section of our design, to be sure that we are capable of reading the pulse width of the incoming PWM. As you’ll recall, the pulse width is what determines the desired motor position, so reading it accurately is very important.
Now, when it comes time to measure the width of a pulse, the first inclination is to use the Arduino pulseIn function. After all, measuring pulse width is exactly what this function is intended for.
But although it seems convenient, pulseIn is not the best choice, at least not in this situation. There are actually a couple of issues with using pulseIn:
So instead of using the pulseIn function, we will create our own function. One that uses interrupts.
If you are not familiar with using interrupts, there is a detailed explanation of this important concept in the article I wrote about using speed sensors with robot cars. As a quick refresher, an interrupt is a signal or event that stops the processor and sends it to an “interrupt handler function”. Once the interrupt has been “handled” the processor resumes where it left off.
Here is the code we are using to measure incoming pulse width using interrupts:
Our sketch starts by declaring a number of variables that will be used to calculate the pulse width. Note the use of the volatile statement preceding some of the variable definitions. This is used to load the variable into system RAM, instead of a register, and it is a common practice when the variable is being modified within an interrupt handler.
We also define variables to hold timestamps, which will be used to calculate pulse width. And we define the pin we are using to receive the PWM pulses from our servo controller, pin 10 in this case.
In the setup, we set the incoming PWM pin as an input and also initialize the serial monitor.
The setup also has a statement to attach the interrupt to our interrupt handler function measurePulse, which we will go over in a moment. Note the “CHANGE” parameter, which indicates that we are calling the interrupt handler every time the state of the pin changes. This is so we can call the interrupt handler at both the beginning and the end of the pulse.
Now take a look at the measurePulse function itself, which is the heart of getting this to work. This is the function called every time the pulse changes state.
We need to determine what state the pulse is in, HIGH or LOW, in order to determine if we are at the beginning or the end of the pulse. If the pulse is HIGH, then we are at the beginning, and we assign the value of micros() to the start variable. This is the number of microseconds that have elapsed since the microcontroller was reset, and we are using it to mark the time at the beginning of the pulse.
If, on the other hand, the value is LOW, then we are at the end of the pulse. We then grab the current value of micros() and subtract the value we saved in the start variable. The result is the exact amount of time, in microseconds, that the pulse was HIGH. This result updates the pwm_period variable.
The Loop is pretty simple, we check to see that the interval between pulses has elapsed and if it has we print the value of the pwm_period variable.
To test this sketch, you can use one of those cheap servo testers. If you leave the Power jumper in the circuit, then you can power the servo tester directly.
Load the sketch, op[en the serial monitor and observe the results. If you are using a servo tester, you should get a range of at least to microseconds.
If you are using the source that you intend to drive your custom servo with, you can record those numbers, in order to improve the response of the final product.
While the previous sketch was optional, this one is not. You’ll need the results from this sketch to get the values that you will plug into the final sketch.
The purpose of this sketch is to establish the “endpoints” for your custom servo motor. By ‘endpoints” I mean the value produced by the analog to digital convertor when the potentiometer is at its leftmost and rightmost position.
Here is the sketch, as you can see it’s pretty simple:
We start by defining the analog input pin on the XIAO. We also define an integer that will hold the value of the ADC output.
In the setup, you will note that we have used an analogReadResolution(12) command to set our ADC for 12-bit operation. If you omit this, then the ADC will default to 10-bits, to maintain compatibility with sketches made for the Arduino AVR boards.
We also set up the serial monitor.
The Loop is about a simple as it gets. We just read the ADC and print its output to the serial monitor. After a short delay, we do it all over again. It’s as simple as that!
Load the sketch up to the XIAO and open the serial monitor. Now turn your servo mechanism to one extreme and make note of the reading on the serial monitor. Then turn to the other end and note that value as well.
You will need these values when we put together our final sketch.
Our final design will rely upon something called a “PID Controller”.
A Proportional Integral Derivative, or PID, controller is a control loop mechanism that employs feedback to apply a correction to its output value. Also called a “Three Term Controller”, PID controllers have been used for nearly a century to control everything from HVAC systems to automotive cruise controls and maritime guidance systems.
A PID controller is a Closed Loop system, meaning that the final output is fed back to the input. If the output does not match the desired input, then a correction signal is applied to eliminate the error.
The input to a PID controller is called its “Setpoint”. In the case of our servo motor controller, the Setpoint is the desired position of the motor shaft.
The measured output of the PID control system is referred to as a “Process Variable”. In our servo controller design, this would be the threading from the potentiometer.
The difference between the Setpoint and Process Variable is called an “Error Value”.
A diagram of a PID Controller is shown here.
Note the four values highlighted in yellow:
In order to rectify any differences in the Error Value, we apply proportional, integral, and derivative calculations to the data.
The Proportional process is directly proportional to the Error Value. The amount of this process that is used in the final equation is calculated using a gain factor, represented as Kp.
The Integral process relies upon previous error values. It integrates this value over a period of time. The amount of Integral processing used in the final result is controlled by a gain factor Ki.
And finally, the Derivative process is an estimate of the future trend of the control mechanism. This can serve to provide a damping effect, and its gain is represented by Kd.
Setting the three gain factors, Kp, Ki, and Kd, is a procedure known as “PID Tuning”.
For our servo design, I found that we really only needed to use the Proportional process and that a gain of 1 (in other words, no gain) was sufficient. But your mileage may vary, depending upon the application for your custom servo motor.
If you need to tune your servo controller, the following points will be useful to know:
I would suggest that you use your sketch with the values I have entered and give it a test. If necessary, you can adjust the three gain values to get everything operating to your exact requirements.
Writing our own PID controller code would be a mammoth undertaking. Fortunately, there are a number of great PID libraries that we can use to simplify the task.
Our sketch will make use of the Arduino PID library, which you can install using the Library Manager in the Arduino IDE.
Open your Library Manager and filter by “PID”. Several libraries will be displayed, the one you want is simply called “PID” and is by Brett Beauregard.
Once you have the PID library installed, you can enter the code, which is shown here:
We begin by including the PID library that we just installed. After that, we set up a few PID variables, which should make some sense now that you are familiar with the operation of PID controls.
You’ll notice that the variables Kp, Ki, and Kd are the gain settings for Proportional, Integral, and Derivative modes. In the current sketch, I am only using Proportional, with a gain of 1, however, you can coke back later and “fine-tune” these settings if you wish.
After defining the PID variables, we create a PID object, named myPID. We pass all of our PID variables to this object and use the DIRECT mode, which indicates that we want to move forwards – this is the most common mode of operation.
The variables after that should look familiar, as they are the same ones we used in our interrupt-based pulse width demo earlier.
You will notice two variables, pot_min and pot_max. These are the values you obtained when you did the endpoint test earlier. You will need to replace the values in my sketch with the ones you noted during that endpoint test.
We also define the connections to the servo PWM input, the potentiometer we are using as a feedback sensor and the Cytron motor controller. If you wanted to use a different motor controller, it would be a simple matter of defining more variables to suit its parameters.
Most of the Setup is pretty self-explanatory, we set our connection input and outputs up and set the ADC to 12-bit resolution. We also attach the interrupt handler we are using to measure incoming pulse width.
One new thing we are doing in Setup is to initialize the PID controller. It is set to AUTOMATIC so that it runs constantly.
We also define the Output limits as being a range of -255 to 255. This is the value that we will be using for the PWM signal driving the motor, the negative numbers indicate that the motor should be turning in reverse. We also set the sample time for the PID controller.
We have already seen the measurePulse function, which is called during every interrupt condition to measure the incoming pulse width.
In the Loop, we perform the same checks as we did during our input test. Then we get the value of our potentiometer.
We then use a couple of map functions to map both the incoming pulses and the potentiometer value to a range of -255 to 255. This way we can compare the two directly.
Now the PID magic happens, all with one simple line of code. We have the PID controller compute the output, which will be the value we need to send to the motor to correct the shaft position.
If the result of the output is zero, then there is nothing to do, as the motor is already in the correct position. But if it isn’t zero, then we see if it is negative or positive.
If it’s positive, then the output is the motor PWM speed value, which we write to the motor controller with an analogWrite command. We also set the direction input of the motor HIGH, so it will spin forward.
If it’s negative, we will be getting a negative output value, which we can’t use for PWM. So we use an abs() function to make it positive (we could also have just multiplied it by negative one to achieve the same result). In this case, we set the motors’ direction control LOW to make it move in reverse.
Then we finish the Loop and repeat the process.
Hook your motor controller up to your circuit and load the sketch to the XIAO. I would suggest having everything (servo controller and motor) close to the center position before you power it up.
Now try out the servo controller, the motor should move into the proper position as you move the controller knob. If it goes the wrong way, then you probably have your motor wired in reverse!
Otherwise, you should see your custom servo motor in action! Remember, you can tune the PID gain variables to make it behave exactly as you want.
Congratulations, you have just created a custom servo motor using a DC motor!
As you have seen, any DC motor can be used as a servo motor when coupled with a position sensor and a PID controller. A potentiometer and Seeeduino XIAO make this a very inexpensive setup.
And if you want to see a practical application for this technique, then be sure to check out Jeremy’s video series on building the “self-driving go-kart” to see his servo in action.
Hope you enjoyed the article!
If you are looking for more details, kindly visit Custom Servo Single Point C-frame Press.
Build a Custom Servo Motor with a DC Motor