Parametric Design of Worm Gear Reducer Based on Visual Studio.NET Platform

In the 21st century, computer technology has permeated every industry and is playing an increasingly significant role. Mechanical design, as one of the most advanced foundational industries, has become inseparable from computer technology. To facilitate the automation of worm gear transmission design, I developed a comprehensive design software based on the Visual Studio.NET platform, achieving full parameterization of the entire design process. This article details the development philosophy, implementation methods, key programming techniques, and practical application examples encountered during the development of this software.

Development Philosophy

The software covers all calculation processes of the important transmission system in mechanical design—the worm gear drive—realizing full automation of the design and automatic generation of calculation documents. The design of the software is divided into several core modules, each responsible for a specific part of the overall design workflow. The following subsections describe these modules in detail.

Preliminary Selection of Electric Motor and Shaft Parameters

Based on the magnitude and nature of the workload, the characteristics of the working machine, and the operating environment, I first select the type, structure, power, and rotational speed of the electric motor, and then determine the motor model. The total transmission ratio is then reasonably distributed among each transmission stage. Using the full-load speed of the motor and the transmission ratios, I calculate the transmitted power, torque, and rotational speed of each shaft in the transmission device. This part is fully automated: once the motor model and the transmission ratios are determined, the software directly computes all shaft parameters, providing the basis for the subsequent design of transmission components and shafts.

For the motor selection, the required power $P_{\text{req}}$ is determined by considering the working condition coefficient $K_A$ and the actual power requirement of the driven machine:

$$
P_{\text{req}} = K_A \cdot P_{\text{load}}
$$

The motor speed $n_{\text{motor}}$ is chosen based on common synchronous speeds (e.g., 3000, 1500, 1000, 750 rpm). The total transmission ratio $i_{\text{total}}$ is then:

$$
i_{\text{total}} = \frac{n_{\text{motor}}}{n_{\text{output}}}
$$

where $n_{\text{output}}$ is the required output speed of the reducer. The distribution of $i_{\text{total}}$ among the chain drive and the worm gear stage follows empirical rules. For example, the worm gear ratio $i_{\text{worm}}$ is typically taken between 10 and 40, while the chain drive ratio $i_{\text{chain}}$ is usually between 2 and 6.

The power $P$, torque $T$, and speed $n$ for each shaft are computed using the following relationships, where $\eta$ represents the efficiency of each transmission stage:

$$
\begin{aligned}
P_{\text{shaft}} &= P_{\text{motor}} \cdot \prod \eta \\
T_{\text{shaft}} &= 9550 \cdot \frac{P_{\text{shaft}}}{n_{\text{shaft}}} \\
n_{\text{shaft}} &= \frac{n_{\text{previous}}}{i_{\text{stage}}}
\end{aligned}
$$

Table 1 summarizes the typical parameters handled by this module.

Table 1: Example of Motor and Shaft Parameter Calculation
Parameter	Symbol	Value	Unit
Motor power	$P_{\text{motor}}$	5.5	kW
Motor speed	$n_{\text{motor}}$	1440	rpm
Total transmission ratio	$i_{\text{total}}$	30	–
Worm gear ratio	$i_{\text{worm}}$	20	–
Chain drive ratio	$i_{\text{chain}}$	1.5	–
Output shaft speed	$n_{\text{out}}$	48	rpm
Worm shaft torque	$T_{\text{worm}}$	36.5	Nm
Worm wheel shaft torque	$T_{\text{wheel}}$	729.2	Nm

Chain Drive Design

The design of the chain drive is based on the transmitted power $P$, load characteristics, and working conditions. I first select the number of teeth on the sprockets $z_1$ and $z_2$, then determine the chain pitch $p$, the number of chain strands, the center distance $a$, and the lubrication method. The chain drive module automates the iterative selection process to ensure the chain’s power rating $P_{\text{rating}}$ exceeds the actual power $P$ with a suitable safety factor.

The design power for chain selection is calculated as:

$$
P_{\text{design}} = K_A \cdot P
$$

where $K_A$ is the application factor. The chain pitch is selected from standard tables based on $P_{\text{design}}$ and the small sprocket speed $n_1$. The center distance $a$ can be computed using:

$$
a = \frac{p}{4} \left[ (L_p – \frac{z_1+z_2}{2}) + \sqrt{ (L_p – \frac{z_1+z_2}{2})^2 – 8 \left( \frac{z_2 – z_1}{2\pi} \right)^2 } \right]
$$

where $L_p$ is the chain length in pitches, typically chosen as an even number. The lubrication method is determined from the chain speed $v$ and the pitch $p$, following standard guidelines.

Worm Gear Design

This is the core module of the software and involves the most intensive calculations. The automatic calculation process proceeds as follows:

First, determine the number of worm threads $z_1$ and the number of worm wheel teeth $z_2$, with automatic rounding of the tooth numbers to integer values.
Then, perform design calculations based on tooth surface contact fatigue strength.
Finally, compute all dimensions of the worm and worm wheel, perform thermal balance calculations, and select the accuracy grade and lubricant.

The worm gear geometry relationships are fundamental. For a worm with axial module $m_x$, the worm pitch circle diameter $d_1$ is often chosen to satisfy the strength requirements. A typical empirical relation is:

$$
d_1 = 2.8 \cdot m_x \cdot \sqrt[3]{z_2} \quad \text{(for steel worm and bronze worm wheel)}
$$

The center distance $a$ is given by:

$$
a = \frac{d_1 + d_2}{2} = \frac{d_1 + m_x z_2}{2}
$$

The tooth surface contact strength condition is:

$$
\sigma_H = Z_E \cdot Z_H \cdot Z_{\varepsilon} \cdot \sqrt{ \frac{2 T_2 K_A K_V K_{H\beta}}{d_1 d_2^2} } \le [\sigma_H]
$$

where:

$Z_E$: elastic coefficient (depends on materials)
$Z_H$: zone factor (for worm gears, usually taken as 2.5)
$Z_{\varepsilon}$: contact ratio factor
$T_2$: torque on the worm wheel ($Nm$)
$K_A$: application factor
$K_V$: dynamic factor
$K_{H\beta}$: load distribution factor
$[\sigma_H]$: allowable contact stress (depends on worm wheel material and sliding velocity)

The thermal balance calculation is essential for worm gear reducers because of high sliding speeds. The heat dissipation condition must satisfy:

$$
P_{\text{thermal}} = \frac{1000 P_{\text{input}} (1 – \eta)}{A \cdot k_t} \le \Delta T_{\text{allow}}
$$

where $P_{\text{input}}$ is the input power (kW), $\eta$ is the efficiency, $A$ is the housing surface area ($m^2$), $k_t$ is the heat transfer coefficient (W/(m²·°C)), and $\Delta T_{\text{allow}}$ is the allowable temperature rise (usually 60-70 °C). If the condition is not met, additional cooling measures such as fans or cooling coils are needed.

Table 2 lists the typical dimension calculations for a worm gear pair.

Table 2: Worm Gear Dimensions (Example with $m_x=4$ mm, $z_1=2$, $z_2=40$ )
Parameter	Symbol	Formula	Value	Unit
Worm pitch diameter	$d_1$	$2.8 m_x \sqrt[3]{z_2}$	38.6	mm
Worm wheel pitch diameter	$d_2$	$m_x z_2$	160	mm
Center distance	$a$	$(d_1+d_2)/2$	99.3	mm
Worm lead angle	$\gamma$	$\arctan(z_1 m_x / d_1)$	11.8°	deg
Face width of worm wheel	$b_2$	$\leq 0.75 d_1$	28.95	mm
Worm length	$L$	$ (11+0.06 z_2) m_x$	53.6	mm

Shaft Design and Calculation

Since shafts support rotating parts, I divided the shaft design into two parts: the worm wheel shaft and the worm shaft. Their design methodologies are similar. The worm shaft is subjected to combined bending and torsion, while the worm wheel shaft experiences similar loads. The calculation process first determines the forces acting on the worm and worm wheel:

Tangential force on worm (equal to axial force on worm wheel):

$$
F_{t1} = \frac{2 T_1}{d_1}
$$

Axial force on worm (equal to tangential force on worm wheel):

$$
F_{a1} = \frac{2 T_2}{d_2}
$$

Radial force on worm:

$$
F_{r1} = F_{a1} \cdot \tan(\alpha_n)
$$

where $\alpha_n$ is the normal pressure angle (typically 20°). Then the bending moments and torques are computed, and the equivalent bending moment $M_{\text{eq}}$ is determined using the third strength theory:

$$
M_{\text{eq}} = \sqrt{M^2 + (\alpha T)^2}
$$

where $\alpha$ is the stress correction factor (typically 0.3 for rotating shafts). The shaft diameter at critical sections is then checked against the allowable stress.

For example, the vertical and horizontal reaction forces at bearings A and B (as in the original code) are computed as:

$$
\begin{aligned}
R_{Ay} &= \frac{F_{t1} L_8}{L_7 + L_8} \\
R_{By} &= F_{t1} – R_{Ay} \\
R_{Az} &= \frac{F_{r1} L_8 – F_{a1} d_2/2}{L_7 + L_8} \\
R_{Bz} &= F_{r1} – R_{Az}
\end{aligned}
$$

The bending moments in vertical and horizontal planes are then combined to obtain the total bending moment $M$.

Bearing Life Calculation

To meet diverse design requirements, I implemented life calculations for two common bearing types: deep groove ball bearings and tapered roller bearings. The bearing life is calculated according to ISO standards using the basic rating life formula:

$$
L_{10h} = \frac{10^6}{60 n} \left( \frac{C}{P} \right)^p
$$

where $C$ is the basic dynamic load rating (N), $P$ is the equivalent dynamic load (N), $n$ is the rotational speed (rpm), and $p$ is the exponent (3 for ball bearings, 10/3 for roller bearings). The equivalent load $P$ depends on the radial and axial loads as well as the bearing type and contact angle.

For deep groove ball bearings:

$$
P = X F_r + Y F_a
$$

where $X$ and $Y$ are factors from bearing catalogues depending on the ratio $F_a/F_r$. For tapered roller bearings, the calculation is similar but includes the axial load induced by the radial load.

Output Generation

To facilitate the writing of design reports, I built an output module that generates a calculation document containing most of the calculation results and intermediate steps. The module can display the document and also save it in commonly used formats such as DOC, RTF, and TXT. The output uses a RichTextBox control for displaying formatted text, a CommonDialog control for file operations, and a menu bar for user interaction.

The core mechanism to load a pre-generated temporary file into the RichTextBox is:

CommonDialog1.FileName = "temp_output.rtf"
RichTextBox1.LoadFile(CommonDialog1.FileName)
CommonDialog1.FileName = "" ' reset for further operations

This approach avoids cumbersome line-by-line file reading and string parsing.

Practical Application Examples

During the actual programming process, several challenging issues arose. I provide detailed explanations of these problems and their solutions, which are closely tied to the aforementioned modules.

Real-time Curve Interpolation

In the design of worm gear drives, many parameters are derived from empirical curve charts whose coordinates are not standard and for which no original formula exists. It is therefore difficult to use built-in mathematical functions to reproduce the curves. My solution involved discretizing the function, using CAD tools to interpolate and plot the curve, then programming the software to segment the curve and extract values. Additionally, I endowed the curve with interactive features that help the user complete the design task more efficiently.

Take the curve for selecting worm gear lubricant as an example. The curve relates the required kinematic viscosity of the lubricant to the sliding velocity and the relative curvature radius. I first drew the curve as a vector graphic and then converted it to a bitmap format. On the Windows form, I placed a PictureBox control that loads the bitmap. The mouse movement event captures the X-coordinate of the cursor, which corresponds to one input parameter (e.g., sliding velocity). The program then evaluates the Y-coordinate (viscosity) using piecewise interpolation as implemented in the original code snippet:

If X <= 1635 Then
    If X <= 495 Then
        sng_cX = 10 + 10 * X / 495
    ElseIf X <= 750 Then
        sng_cX = 20 + 10 * (X - 495) / 255
    ...
    End If
    sng_cY = 210 + (X / 1635) * 70
End If

In this snippet, the integer pixel coordinate $X$ is mapped to a scaled value (e.g., sliding velocity in m/s), and the corresponding Y pixel is converted to the kinematic viscosity in cSt. The actual viscosity ranges and segmentation were calibrated using the original chart.

Furthermore, the “Confirm” button on the form not only closes the window but also calculates the appropriate oil type by setting the ListIndex property of a ComboBox control in another form (frmwormjdxz). The program compares the computed viscosity with standard values for worm gear oils (e.g., VG320, VG460, VG680).

This example demonstrates a typical scenario of real-time curve query. The form achieves functions such as real-time value extraction, range limiting, mouse control, cross-form communication, and image following, all of which meet the design requirements.

Detailed Calculation Section: Worm Shaft Checking

The software’s computational power is one of its greatest strengths. Many calculation routines were implemented. I present the worm shaft checking routine as an illustration. The forces on the worm gear pair are first computed using the following code (translated to mathematical notation):

$$
\begin{aligned}
F_{t1} &= \frac{2 T_1}{d_1} \times 1000 \quad (\text{with unit conversion}) \\
F_{a1} &= \frac{2 T_2}{d_2} \times 1000 \\
F_{r1} &= F_{a1} \tan(20^\circ)
\end{aligned}
$$

Then the bearing reactions:

$$
\begin{aligned}
R_{Ay} &= F_{t1} \cdot \frac{L_8}{L_7 + L_8} \\
R_{By} &= F_{t1} – R_{Ay} \\
R_{Az} &= \frac{F_{r1} L_8 – F_{a1} d_2/2}{L_7 + L_8} \\
R_{Bz} &= F_{r1} – R_{Az}
\end{aligned}
$$

where $L_7$ and $L_8$ are distances from bearings to the load point along the shaft (in mm). The bending moments at critical sections (e.g., at the load application point C) are:

$$
\begin{aligned}
M_{yC} &= R_{Ay} \cdot L_7 \\
M_{zC} &= R_{Az} \cdot L_7
\end{aligned}
$$

The total bending moment:

$$
M_C = \sqrt{M_{yC}^2 + M_{zC}^2}
$$

The torque transmitted by the worm shaft:

$$
T_1 = 9550 \cdot \frac{P_1}{n_1}
$$

Finally, the equivalent bending moment (using the third strength theory):

$$
M_{eq,C} = \sqrt{M_C^2 + (\alpha T_1)^2}
$$

The shaft diameter at section C is then checked against the allowable stress $[\sigma_{-1}]$:

$$
d_C \ge \sqrt[3]{\frac{32 M_{eq,C}}{\pi [\sigma_{-1}]}}
$$

Table 3 presents a summary of the worm shaft checking parameters for a typical design case.

Table 3: Example Worm Shaft Checking Results
Parameter	Symbol	Value	Unit
Worm torque	$T_1$	36.5	Nm
Tangential force on worm	$F_{t1}$	1897	N
Radial force on worm	$F_{r1}$	690	N
Axial force on worm	$F_{a1}$	9115	N
Bearing span L7+L8	$L$	200	mm
Bending moment at C	$M_C$	92.5	Nm
Equivalent bending moment	$M_{eq,C}$	105.3	Nm
Required shaft diameter	$d_{req}$	28.4	mm
Actual shaft diameter (chosen)	$d_{act}$	32	mm

Output Controls and File Handling

To produce the calculation report, I used a RichTextBox control to display the formatted results. A CommonDialog control is employed in the background to manage file operations. A menu bar provides the user interface. The approach is to first assign the output file name to the CommonDialog’s FileName property, then load the file into the RichTextBox using its LoadFile method. After loading, the FileName property is cleared to avoid interfering with subsequent operations. This method is much more convenient than reading the file line by line using InputLine statements and does not require additional string control.

The output document contains all intermediate calculation steps, including the values of loads, moments, stresses, and the final verification results. The ability to save in DOC, RTF, and TXT formats provides flexibility for documentation.

Integration and Testing

All the modules described above were integrated into a single application developed using Visual Basic.NET. The software underwent extensive testing with multiple design scenarios. The user interface is designed to guide the designer step by step from motor selection to final output. Data flows automatically between modules, ensuring consistency and reducing human errors. Each module is equipped with input validation and error handling to maintain robustness.

The software also includes a help system that explains each input parameter and calculation method, making it accessible even to engineers who are not deeply familiar with worm gear design.

One of the key challenges was the handling of non-standard empirical curves. The method of discretization combined with bitmap plotting and coordinate mapping proved effective. For curves that could be approximated by polynomial or spline functions, I also included an option for analytical fitting to improve accuracy. However, the bitmap method was retained as a fallback for curves without a known functional form.

Conclusion

Due to the large scale of the software, it is impossible to describe every step in detail. I have selected several representative aspects—motor and shaft parameter calculation, worm gear design, shaft checking, curve interpolation, and output generation—to illustrate both the programming methodology and the mechanical design workflow. The programs described were successfully debugged on the Visual Basic.NET platform. The resulting software significantly reduces the design cycle time for worm gear reducers and improves calculation accuracy. Future work could extend the software to include more advanced features such as finite element analysis integration and optimization algorithms.