In modern manufacturing, the demand for high-strength and low-cost straight bevel gears has grown significantly, especially in automotive differentials and engines. Traditional cutting methods for straight bevel gears require expensive specialized machines and have low productivity. Precision forging has become an attractive alternative. However, the mold electrodes used in electrical discharge machining (EDM) must be manufactured with high accuracy and efficiency. In this thesis, I focus on the research and implementation of a dedicated CAD/CAM system for straight bevel gear mold electrodes, based on the UG platform and using secondary development tools. The work covers parametric modeling of involute straight bevel gears and circular-lapping straight bevel gears, as well as automatic generation of CNC milling tool paths. Throughout the study, I emphasize the practical requirements of straight bevel gear mold electrode manufacturing.
1. Introduction
Straight bevel gears are widely used in intersecting shaft transmissions. Their tooth geometry is complex, and conventional manufacturing processes such as gear planing are labor-intensive and difficult to adjust. Precision forging of straight bevel gears offers better material utilization and higher tooth strength, but the production of the forging die relies on EDM, which requires a conductive electrode shaped like the desired gear. Since the electrode shape is essentially the same as the final straight bevel gear (ignoring thermal shrinkage and EDM gap), the CAD/CAM technology for straight bevel gears can be directly applied to mold electrode fabrication.
In this research, I build mathematical models for two types of straight bevel gears: the classical involute straight bevel gear and the circular-lapping straight bevel gear. The involute tooth profile is derived from spherical involute theory, but for practical engineering, the back-cone involute approximation is adopted after an error analysis. For circular-lapping gears, the tooth profile is composed of circular arcs on the back-cone development, which simplifies the modeling process. Additionally, I investigate crowned tooth modification, which is important for improving contact behavior and reducing sensitivity to assembly errors. Based on these models, I develop parametric modeling programs using UG/Open API and Visual C++ 6.0. The CAM module is developed using GRIP language, enabling automatic generation of roughing and finishing tool paths for straight bevel gear mold electrodes.
The main contributions of this thesis include:
- Detailed analysis of the back-cone involute approximation for straight bevel gears.
- Parametric design tables and formulas that link all relevant geometric parameters.
- Development of an automatic modeling module for involute straight bevel gear mold electrodes.
- Development of an automatic modeling module for circular-lapping straight bevel gear mold electrodes.
- Development of a CAM module that supports tool selection, cutting parameter setting, and tool path generation.
- Integration of these modules into a unified menu-driven system on the UG platform.
In the following sections, I describe the digital modeling foundation, the CAD implementation, the CAM module, and finally the complete system with a practical example.
2. Mathematical Modeling Foundation for Straight Bevel Gears
The accurate three-dimensional modeling of straight bevel gears requires a thorough understanding of their geometry. For involute straight bevel gears, the theoretical tooth surface is a spherical involute surface, which is generated by rolling a plane over a base cone. However, spherical involutes cannot be developed onto a plane, making direct CAD construction difficult. In engineering practice, the back-cone involute is used as an approximation. The back cone is tangent to the sphere at the large-end pitch circle; projecting the spherical involute onto the back cone produces a planar involute that is sufficiently accurate for most applications.
2.1 Spherical Involute and Back-Cone Approximation
Figure 1 illustrates the principle of spherical involute generation. A sector plane is tangent to a base cone and rolls over it without slipping. A point on the generating line traces a spherical involute on the sphere. The tooth surface of a straight bevel gear is obtained by sweeping this spherical involute along a radial direction toward the cone apex. However, since spherical involutes are non-developable, I follow the common practice of using the back-cone tooth profile instead of the large-end spherical profile.
Let the back cone be tangent to the pitch sphere at the large-end diameter. The tooth addendum and dedendum heights are projected from the sphere onto the back cone. The difference between the spherical arc and the projected line segment can be evaluated as follows:
The addendum angle \(a_a\) and dedendum angle \(a_f\) satisfy:
\[
\sin a_a = \frac{h_a}{R}, \quad \sin a_f = \frac{h_f}{R}
\]
where \(h_a = h^* m\), \(h_f = (h^* + c^*) m\), \(m\) is the large-end module, and \(R\) is the outer cone distance. For a 90-degree shaft angle, the outer cone distance is
\[
R = 0.5 m \sqrt{Z_1^2 + Z_2^2}
\]
For typical transmission ratios \(i \le 5\) and pinion tooth counts \(Z_1 \ge 12\), the ratio \(m/R\) is usually less than \(1/17\). The error between \(a_a\) and \(\sin a_a\) is less than 0.23% in the worst case, and much lower for larger tooth counts. Therefore, the back-cone involute is a valid engineering approximation for straight bevel gears.
2.2 Parametric Design of Involute Straight Bevel Gears
To achieve parametric modeling, all geometric quantities must be expressed as functions of a small set of input parameters. The independent parameters are:
- \(Z_1\): number of pinion teeth
- \(Z_2\): number of gear teeth
- \(m_e\): large-end module
- \(\alpha\): pressure angle
- \(h^*\): addendum coefficient
- \(c^*\): radial clearance coefficient
- \(B\): face width
Table 1 summarizes the dependent parameters and their formulas.
| Parameter | Symbol | Formula |
|---|---|---|
| Addendum | \(h_a\) | \(h^* m_e\) |
| Dedendum | \(h_f\) | \((h^* + c^*) m_e\) |
| Pitch cone angle | \(\delta\) | \(\arctan(Z_1/Z_2)\) for pinion; \(\arctan(Z_2/Z_1)\) for gear |
| Pitch diameter | \(d\) | \(m_e Z\) |
| Addendum circle diameter | \(d_a\) | \(d + 2 h_a \cos\delta\) |
| Dedendum circle diameter | \(d_f\) | \(d – 2 h_f \cos\delta\) |
| Base circle diameter | \(d_b\) | \(d \cos\alpha\) |
| Outer cone distance | \(R_e\) | \(0.5 m_e \sqrt{Z_1^2 + Z_2^2}\) |
| Addendum angle | \(\theta_a\) | \(\arctan(h_a / R_e)\) |
| Dedendum angle | \(\theta_f\) | \(\arctan(h_f / R_e)\) |
| Back-cone pitch diameter | \(d_v\) | \(d / \cos\delta\) |
| Back-cone base diameter | \(d_{vb}\) | \(d_v \cos\alpha\) |
| Virtual tooth number | \(Z_v\) | \(Z / \cos\delta\) |
The involute curve on the back cone is generated using the standard parametric equations:
\[
x(t) = r_b (\cos\phi + \phi \sin\phi)
\]
\[
y(t) = r_b (\sin\phi – \phi \cos\phi)
\]
where \(r_b = d_{vb}/2\) is the base circle radius, and \(\phi\) is the roll angle. In the UG expression system, I define a variable \(s\) varying from \(0\) to \(\phi_t\), where \(\phi_t\) is the maximum roll angle that determines the involute extent. The UG expressions are written as:
\[
s = (1-t)\phi_0 + t \phi_t
\]
\[
x_t = r_b (\cos(s) + s \sin(s))
\]
\[
y_t = r_b (\sin(s) – s \cos(s))
\]
The point (\(x_t, y_t\)) lies in the XY plane of the back-cone coordinate system. Using the UF_MODL_create_law function, I create the involute curve in a sketch. Then, the tooth slot profile is completed by adding a root fillet and mirroring about the tooth center plane.
2.3 Transition Curve Construction
Since the base circle of an involute gear is usually larger than the root circle, the tooth profile between the base circle and the root circle must be connected by a transition curve. In conventional gear manufacturing, this transition is formed by the trochoid generated by the cutting tool tip. For simplicity and to avoid stress concentration, I propose a double-arc transition method. The first arc is tangent to the involute at its start point, and the second arc is tangent to the root circle. The two arcs are tangent to each other. The radius of the second arc is chosen based on the root circle radius and the pressure angle. Figure 2 shows the construction of the tooth slot profile.
| Series | Modules (mm) |
|---|---|
| First choice | 0.1, 0.12, 0.15, 0.2, 0.25, 0.3, 0.4, 0.5, 0.6, 0.8, 1, 1.25, 1.5, 2, 2.5, 3, 4, 5, 6, 8, 10, 12, 16, 20, 25, 32, 40, 50 |
| Second choice | 0.35, 0.7, 0.9, 1.75, 2.25, 2.75, 3.25, 3.5, 3.75, 4.5, 5.5, 6.5, 7, 9, 11, 14, 18, 22, 28, 36, 45 |
When the user inputs a module value, the system compares it against the standard series stored in an array. If the value is not found, an error dialog is shown and the user must re-enter a valid value. This ensures consistency with gear standards.
2.4 Mathematical Model of Circular-Lapping Straight Bevel Gears
Circular-lapping is a highly efficient method for cutting straight bevel gears. The resulting tooth profile is not an involute but an arc. This type of gear is commonly used in automotive differentials. The gear tooth flanks are conjugate only at specific points, and the contact is designed to be localized. The tooth profile on the back-cone development is a circular arc with a radius determined by the equivalent pinion and gear radii.
Let \(R_1\) and \(R_2\) be the back-cone equivalent pitch radii of the pinion and gear, respectively. The arc radii for the pinion and gear tooth profiles are:
\[
\rho_1 = \frac{R_1}{3\sin\alpha} \left( 1 + \frac{2 R_1}{R_2} \right)
\]
\[
\rho_2 = \frac{R_2}{3\sin\alpha} \left( 1 + \frac{2 R_2}{R_1} \right)
\]
where \(\alpha\) is the pressure angle (usually 22.5° for circular-lapping gears). The tooth thickness is determined based on strength considerations; in this work, I adopt the method commonly used in Chinese automotive industry, which is a modified Lewis approach. The key parameters for circular-lapping straight bevel gears are listed in Table 3.
| Parameter | Pinion formula | Gear formula |
|---|---|---|
| Number of teeth | \(Z_1\) | \(Z_2\) |
| Large-end module | \(m_e\) | |
| Pitch diameter | \(m_e Z_1\) | \(m_e Z_2\) |
| Pitch cone angle | \(\arctan(Z_1/Z_2)\) | \(\arctan(Z_2/Z_1)\) |
| Face width | \(B \le R_e / 3\) | |
| Outer cone distance | \(R_e = 0.5 m_e \sqrt{Z_1^2 + Z_2^2}\) | |
| Mid cone distance | \(R_m = R_e – 0.5 B\) | |
| Mid module | \(m_m = m_e R_m / R_e\) | |
| Circular pitch (large end) | \(p_e = \pi m_e\) | |
The circular-lapping gear tooth profile has no root undercut, which gives it higher root bending strength. The actual arc profile is created directly in the sketch using the arc center and radius. The transition radius at the root is taken from Table 4, which depends on the module range.
| Large-end module range (mm) | Normal clearance (mm) | Pinion tip radius (mm) | Gear tip radius (mm) |
|---|---|---|---|
| < 2.5 | 0 – 0.05 | deburred | deburred |
| 2.5 – 3.0 | 0.05 – 0.13 | 0.76 | 0.76 |
| 3.0 – 3.5 | 0.10 – 0.15 | 1.0 | 1.3 |
| 3.5 – 4.0 | 0.10 – 0.15 | 1.1 | 1.4 |
| 4.0 – 4.5 | 0.13 – 0.18 | 1.3 | 1.8 |
| 4.5 – 5.0 | 0.13 – 0.18 | 1.4 | 1.6 |
| 5.0 – 5.5 | 0.15 – 0.20 | 1.5 | 1.8 |
| 5.5 – 6.3 | 0.15 – 0.20 | 1.6 | 1.9 |
| 6.3 – 7.3 | 0.18 – 0.23 | 1.8 | 2.0 |
| 7.3 – 8.5 | 0.20 – 0.28 | 1.9 | 2.2 |
| 8.5 – 10 | 0.25 – 0.33 | 2.0 | 2.3 |
| 10 – 12.5 | 0.30 – 0.40 | 2.4 | 2.5 |
2.5 Crowning of Straight Bevel Gears
To improve contact behavior and reduce edge loading, straight bevel gears are often crowned along the face width direction. The crowning amount, denoted \(\Delta S\), is typically chosen empirically as:
\[
\Delta S = 0.004\,m_e \quad \text{to} \quad 0.005\,m_e
\]
where \(m_e\) is the large-end module. The crowning curve can be a circular arc, a parabola, or a three-segment line. I select a circular arc for simplicity. The arc is used as a sweep guide for the tooth profile, so that the tooth surface has a slight bulge at the center of the face width. This design helps localize the contact pattern and reduces sensitivity to misalignment.
In the CAD model, the guide curve is a spline passing through the mid-face point, with the maximum radial deviation \(\Delta S\) at that point. The sweep of the tooth slot profile along this guide produces a crowned straight bevel gear. The crowning amount is included as an input parameter in the dialog, allowing the user to adjust it.
3. CAD Module Development for Mold Electrodes
Parametric design is the key to automating the generation of three-dimensional models for series products. I developed the CAD modules using UG/Open API and Visual C++ 6.0. The programs are compiled as dynamic link libraries (DLLs) that can be invoked from UG’s menu system.
3.1 Development Environment and Menu Integration
I use UG/Open MenuScript to create a custom menu item named “Straight Bevel Gear Mold Electrode CAD/CAM System”. The menu file is a simple text file with a .men extension placed in the startup folder. The menu contains three sub-items:
- Involute straight bevel gear mold electrode design
- Circular-lapping straight bevel gear mold electrode design
- Straight bevel gear mold electrode CAM
Each sub-item triggers a specific DLL or GRIP program. The dialog boxes are created using UG/Open UIStyler, which provides native UG-style controls.
3.2 Involute Straight Bevel Gear Mold Electrode Modeling
The modeling procedure for an involute straight bevel gear mold electrode is as follows:
- Input the design parameters through a dialog (see Figure 3).
- Validate the parameters: tooth counts must be integers, module must be in the standard series, and pressure angle must be an allowed value.
- Calculate all dependent parameters using Table 1.
- Generate the involute curve on the back-cone plane using UF_MODL_create_law.
- Construct the tooth slot profile: involute curves, transition arcs, and root arc.
- Create the sweep guide lines from the profile endpoints to the cone apex.
- Sweep the tooth slot profile along the guides to form a single tooth space.
- Create the gear blank by revolving the cone outline.
- Subtract the tooth space from the blank and circular-pattern the operation.
The C++ program uses the following core functions:
UF_MODL_create_revolution // creates the gear blank
UF_MODL_trim_body // trims the blank to form one tooth slot
UF_MODL_create_sweep // sweeps the tooth profile
UF_MODL_create_circular_instance // patterns the tooth slot
After the operations are completed, a solid model of the straight bevel gear mold electrode is created. The model is fully parametric: if the user modifies an input parameter, the model can be regenerated by re-running the program. In practice, I do not use UG’s associative update; instead, the program rebuilds the model from scratch, which is simple and reliable for series design.
3.3 Circular-Lapping Straight Bevel Gear Mold Electrode Modeling
For circular-lapping gears, the tooth slot profile is constructed from circular arcs. The arc radius is calculated using the formulas in Section 2.4. The modeling procedure differs slightly from the involute case:
- Input parameters using a dialog similar to that for involute gears.
- Validate the parameters.
- Calculate dependent parameters and arc radii.
- Draw the back-cone section: addendum circle, pitch circle, and root circle.
- Create the tooth slot arc with the calculated radius.
- Add the transition arcs according to Table 4.
- Mirror the profile to form the complete tooth slot.
- Sweep along the cone guides and pattern the solid.
Since the circular-lapping tooth profile is not an involute, no complex law curve is needed. This makes the modeling process faster and more robust.
3.4 Crowned Straight Bevel Gear Mold Electrode Modeling
The crowned gear model is built using a curved sweep guide. The guide curve is a circular arc that lies in the axial plane and passes through the mid-face point. The sag of the arc is equal to the crowning amount \(\Delta S\). The sweep of the tooth profile along this arc creates a barrel-shaped tooth. This type of electrode is used to forge gears with localized contact patterns. My implementation allows the user to specify a zero crowning amount, resulting in a straight-sided tooth, or a positive value to create the crown.
4. CAM Module Development
After obtaining the three-dimensional model of the straight bevel gear mold electrode, the next task is to generate CNC machining paths. I developed a dedicated CAM module using UG GRIP language, which is a high-level programming language for UG capabilities. The module automates the generation of roughing and finishing tool paths for the electrode tooth spaces.
4.1 Overall CAM Structure
The CAM module consists of two major parts: process parameter setting and tool path generation. Process parameter setting includes tool definition, machining method selection, and cutting parameter definition. Tool path generation includes roughing and finishing operations. Figure 4 shows the structure of the CAM module.
| Operation | Type | Description |
|---|---|---|
| Roughing | CAVITY_MILL | Layer-by-layer milling to remove bulk material |
| Finishing | FIXED_CONTOUR | Surface contour milling to achieve final shape |
4.2 Tool Definition
I created a dialog for tool parameters: shank length, tool diameter, and corner radius. The tool type can be flat end mill, ball end mill, or bull nose end mill. In GRIP, the tool is defined using the TOOL statement:
PARAM/'Tool Parameters', 'Tool Length=', tLength, 'Tool Diam=', tDiam, 'Corner Radius=', tr, resp
TOOL/'TOOL_D_R_L', MILL, n_diameter, n_r, n_len
If the corner radius equals half the diameter, the tool is a ball end mill. For straight bevel gear mold electrodes, a ball end mill is commonly used for finishing to achieve a smooth surface.
4.3 Machining Method and Cutting Parameters
I provide options for parallel cutting and contour cutting. The parallel cutting method allows the user to specify the cutting angle, while the contour cutting method follows the part boundary. For roughing, I use layer milling with zig-zag or one-way traversal. For finishing, I use fixed-axis surface contour milling with a projected driving surface.
The cutting parameters include depth of cut, stepover, cutting speed, spindle speed, and feed rate. Example formulas:
\[
n = \frac{1000 \, V_c}{\pi D}
\]
\[
V_f = n \cdot z \cdot f_z
\]
where \(D\) is tool diameter, \(z\) is number of flutes, and \(f_z\) is feed per tooth. For ball end mills, the effective diameter is used in the spindle speed calculation:
\[
D_f = 2 \sqrt{D^2 – (D – 2t)^2}/2
\]
where \(t\) is the depth of cut. I incorporated these calculations into the dialog so that the user can input the required cutting speed and feed per tooth, and the system automatically computes the spindle speed and feed rate.
4.4 Roughing Tool Path Generation
The roughing operation uses the CAVITY_MILL template from UG’s mill_contour configuration. In GRIP, I activate the manufacturing module and create the operation as follows:
&MODULE = &MACH
&OPTSET = '/mytemplatedir/templates/mill_contour'
OPER/NEW, OPEN, 'oper_rough', 'mill_contour', 'CAVITY_MILL'
&GENPTH = &YES
This generates a layer-by-layer tool path that rapidly removes the bulk of the electrode material. The user can specify the processing area by selecting the gear blank or the tooth spaces. The roughing tool path is illustrated conceptually as horizontal loops around each tooth.
4.5 Finishing Tool Path Generation
The finishing operation uses the FIXED_CONTOUR template with area driving. The steps are:
- Create the operation:
OPER/NEW, OPEN, 'oper_finish', 'mill_contour', 'FIXED_CONTOUR'
- Define the driving method as ‘area’:
&DRVMET = &AREA
- Let the user select the surfaces to finish using an interactive IDENT dialog:
IDENT/'Select the surface to finish', choose_area, resp
OPGEOM/GLIST, DRIVE
OPGEOM/GITEM, choose_area
- Set tool axis and projection vector:
TAXIS/TILT, 0, LEAD, 0, DS
&TNAME = 'TOOL_D_R_L'
&PROTYP = 8 // normal to drive surface
- Generate the tool path:
&GENPTH = &YES
The finishing tool path follows the selected tooth slot surfaces, providing a smooth contour. In practice, the user may select one tooth slot at a time or multiple slots, and then rotate the part using a fourth axis if a multi-axis machine is used. In this project, I have focused on three-axis machining of the individual tooth spaces.
5. System Implementation and Example
The complete straight bevel gear mold electrode CAD/CAM system was integrated into UG NX4.0. The system menu appears as “Straight Bevel Gear Mold Electrode CAD/CAM System” in the UG main menu. The user can start the modeling or CAM functions through this menu.
5.1 System Architecture
The system architecture is shown in Table 6.
| Module | Sub-module | Function |
|---|---|---|
| CAD | Involute gear model | Generates involute straight bevel gear mold electrode |
| CAD | Circular-lapping model | Generates circular-lapping straight bevel gear mold electrode |
| CAD | Crowned model | Generates crowned straight bevel gear mold electrode |
| CAM | Tool setup | Defines tool geometry |
| CAM | Machining method | Selects parallel/contour and cutting patterns |
| CAM | Cutting parameters | Sets depths, speed, feed |
| CAM | Roughing tool path | Generates layer milling path |
| CAM | Finishing tool path | Generates surface contour path |
5.2 Example: Modeling a Straight Bevel Gear Mold Electrode
I demonstrate the system using a pinion from a real automotive differential. The input parameters are:
- Pinion teeth \(Z_1 = 10\)
- Gear teeth \(Z_2 = 16\)
- Large-end module \(m_e = 3.75\) mm
- Pressure angle \(\alpha = 22.5^\circ\)
- Radial clearance coefficient \(c^* = 0.2\)
- Addendum coefficient \(h^* = 0.8\)
- Face width \(B = 12\) mm
After clicking the “Involute straight bevel gear mold electrode design” menu, the dialog appears. The user enters the values and clicks OK. The system validates the parameters and then constructs the model. The resulting solid model is displayed in the UG graphics window.
If the user inputs a module of 2.9, which is not in the standard series, a warning dialog appears: “Module value is not in the standard series. Please re-enter.” The user must then correct the value.
5.3 Example: CAM Operation
Once the model is created, the user can click “Straight bevel gear mold electrode CAM”. The system activates the manufacturing module. The user first adjusts the coordinate system so that the gear axis is aligned with the machine spindle. Then the tool dialog is shown. In this example, I choose a ball end mill with a diameter of 2 mm and a shank length of 30 mm.
Next, the machining method dialog appears. I select “contour cutting” and set the stepover to 0.05 mm. The cutting parameters are set as follows:
- Depth of cut: 0.2 mm for roughing, 0.05 mm for finishing
- Spindle speed: 2000 rpm
- Feed rate: 2000 mm/min
The system then generates the roughing tool path using the cavity mill strategy. After reviewing the path, the user clicks “Finishing tool path”. The system prompts the user to select the tooth slot surfaces to finish. After selection, the finishing tool path is generated. The resulting tool path covers the selected surface with a regular pattern.
The generated tool paths can be verified in UG’s graphic window and post-processed to obtain G-code for a specific CNC machine. This automatic procedure significantly reduces the manual programming time for straight bevel gear mold electrodes.
6. Conclusions and Future Work
In this thesis, I have presented a systematic approach to the CAD/CAM of straight bevel gear mold electrodes. The main achievements are:
- I established a solid mathematical foundation for the parametric design of straight bevel gears, including the back-cone involute approximation and the circular-arcing profile for circular-lapping gears.
- I developed an automatic modeling system on the UG platform that can generate three-dimensional solid models of involute straight bevel gears, circular-lapping straight bevel gears, and crowned straight bevel gears with high efficiency and accuracy.
- I developed a dedicated CAM module that automatically creates roughing and finishing tool paths for the tooth spaces of straight bevel gear mold electrodes.
- I integrated all the functions into a single user-friendly menu system, which greatly simplifies the traditional design and manufacturing workflow.
There are several areas for future improvement:
- I only considered gears with a 90-degree shaft angle. Future work could extend the model to arbitrary shaft angles.
- The current model does not include thermal shrinkage, EDM gap, or electrode wear compensation. To produce final forged gears with high precision, these factors must be incorporated into the electrode shape.
- The transition curve design is based on a simplified double-arc method. Further validation using finite element analysis and gear testing would be beneficial.
- The CAM module focuses on three-axis machining. For large straight bevel gear mold electrodes, five-axis machining could improve access to deep tooth spaces. A post-processor for a specific five-axis machine is also needed.
- The system currently rebuilds the model from scratch each time. Implementing associative parameter updates within UG’s part file would allow faster modifications.
In conclusion, the developed system provides a practical and efficient solution for the design and manufacturing of straight bevel gear mold electrodes. It combines theoretical rigor with engineering convenience, and it has the potential to be extended to other types of bevel gears. With continuous improvement, the system can be a valuable tool in the precision forging industry for straight bevel gears.