The foundry industry, a traditional sector with a civilization history of over four thousand years in China, is increasingly facing challenges from the new technological revolution. As a vital component of the manufacturing sector, the casting industry plays a significant role in national economic development. However, to remain competitive in the international market, it is imperative to enhance product quality, improve labor productivity, and reduce production costs. In this context, the application of Computer-Aided Design (CAD) technology in foundry engineering, particularly for sand casting parts, has become a crucial area of development. This thesis focuses on the development of a specialized CAD system for the sand casting process of shell-like parts, integrated with rapid prototyping experiments for rapid mold-making.
1. Introduction
CAD technology, which emerged in the 1960s, has revolutionized product design and engineering across various industries including machinery, electronics, aerospace, automotive, and construction. Its application in the foundry industry, specifically in the design of casting processes and tooling, is commonly referred to as “Casting Process and Tooling CAD.” This field can be broadly divided into two categories: process design and solidification process numerical simulation. The former, known as “Casting Process CAD” in a narrow sense, is the primary focus of this thesis.
The development of casting process CAD can be traced back to the 1960s. Early systems were based on two-dimensional (2D) graphics platforms, which essentially digitized the manual drafting process. While these systems improved efficiency, they had significant limitations, including non-intuitive design, difficulties in extracting process parameters, and the inability to perform complex design calculations. The advent of robust three-dimensional (3D) CAD/CAM/CAE software, such as Unigraphics (UG), has enabled a shift towards 3D-based casting process CAD systems. These modern systems allow designers to work directly on 3D part models, making the design process more intuitive and efficient. Furthermore, the rich geometric information from 3D models can be used for finite element analysis, assembly simulation, and CNC machining, thereby laying the foundation for CAD/CAE/CAM integration in casting tooling.
Despite these advances, the adoption rate of 3D casting process CAD in domestic enterprises remains relatively low compared to industrialized nations. A significant challenge has been the lag in secondary development of these powerful CAD platforms to meet specific industry needs. To address this gap, this research develops a specialized CAD system for the sand casting process of shell-like parts, using UG as the development platform. The system aims to streamline the design workflow, from process parameter determination to riser and gating system design, and to integrate with rapid prototyping for accelerated mold-making. The rapid development of Rapid Prototyping (RP) technology has further underscored the necessity of a robust casting process CAD system, as a 3D CAD model is the fundamental prerequisite for any RP process. For sand casting parts, the CAD system must be capable of adding the necessary gating and riser systems to the part model to create a complete casting model suitable for mold-making and subsequent RP fabrication.
The primary objectives of this research, stemming from a collaborative project with a machinery factory, are to develop a comprehensive CAD system for the sand casting of shell-like parts. The system’s architecture, as illustrated in the initial design, includes modules for product model input, system initialization, process parameter design, riser system design, and gating system design. This thesis details the development and application of this system, culminating in a case study involving a fire control bolt covering, which is a typical shell-like casting part.
2. Overall System Design and Key Technologies
2.1 Platform Selection
The development of the CAD system for sand casting parts is based on the principle of secondary development, which involves enhancing an existing software platform to better suit specific user needs. The choice of the platform software is critical, as the functionality and performance of the resulting system largely depend on the platform’s inherent capabilities and openness. Several factors were considered for platform selection:
- Functionality: The platform should be a comprehensive CAD/CAE/CAM system integrating 2D drafting, 3D solid modeling, advanced surface modeling, FEA, and NC machining.
- User Base: A wide user community ensures system upgrades, maintenance, and ease of knowledge sharing.
- Secondary Development Support: The platform must provide an open development environment and robust tools (APIs) for customization.
- Cross-platform Support: Availability on both Windows and workstation platforms is desirable for flexibility.
Based on these criteria, Unigraphics (UG) NX 3.0 was selected as the platform. UG is a world-class, tightly integrated CAD/CAE/CAM system known for its powerful solid modeling, assembly, and manufacturing capabilities. More importantly, UG provides a comprehensive suite of secondary development tools, including UG/Open API, UG/Open UI Styler, UG/Open MenuScript, and UG/Open GRIP. These tools allow for deep, user-defined customization using high-level languages like C, C++, and Visual C++.
| Criteria | UG NX 3.0 |
|---|---|
| 3D Modeling | Excellent, with robust solid, surface, and feature-based modeling |
| CAD/CAE/CAM Integration | Tightly integrated, allowing seamless transitions between design, analysis, and manufacturing |
| Secondary Development | Rich set of APIs (UG/Open) for customization using C/C++ and other languages |
| Industry Adoption | Widely used in aerospace, automotive, and mold-making industries |
2.2 System Requirement Analysis
Following software engineering principles, the system design began with a thorough requirement analysis based on actual factory needs. The traditional sand casting process for parts involves several key steps: 1) analyzing the part structure for castability; 2) determining casting process parameters such as machining allowances, shrinkage, and draft angles; 3) designing the gating and riser systems; and 4) designing the pattern and core box tooling. The developed CAD system for sand casting parts aims to support these steps, with the core functionality including:
- System Initialization: Creating a project file and capturing part information.
- Process Parameter Design: Assisting in determining parameters like minimum wall thickness, machining allowance, casting shrinkage, and draft angle.
- Riser Design: Calculating critical moduli and designing standard or custom risers and riser necks.
- Gating System Design: Calculating the choke area and designing the sprue, runner, and ingate dimensions.
2.3 Key Technologies
The development process leverages several key technologies provided by the UG/Open toolkit. The system’s foundation is a combination of UG/Open API and UG/Open++ for programming, with UG/Open UI Styler for creating custom interactive interfaces. UG/Open MenuScript is used for seamless integration of the custom application into the UG environment.
For 3D modeling tasks, a modular approach is adopted. Depending on the geometric complexity, different strategies are used: 1) Modification of Existing Models: This is used for tasks like adding machining allowances, where the system analyzes the selected face and generates an offset along its normal direction.
2) Parameter-Driven Modeling for Simple Shapes: This is used for creating standard components like personalized risers or ingates, where all geometric constraints are provided by the system based on user inputs.
3) Complex Shapes via Graphic Libraries: For complex shapes like spherical risers, a pre-built graphic library is used to avoid excessive programming and system burden.
4) Standard Parts Modeling: This combines a parts library with parametric dimension adjustments, allowing for standard diameters with custom lengths, for example.
User interface design is a critical aspect. The system uses UG/Open UI Styler, a visual editor that allows for the creation of native UG-style dialogs. These dialogs simplify data input and process interaction. The UI Styler generates three files for each dialog: a .dlg resource file, a .c template file, and a .h header file. Programmers can embed their functional code within the callback functions of the .c template file, greatly simplifying the GUI programming task.
Database technology is also essential. The system uses Microsoft Access 2000 as the database platform to manage casting process parameters. Data access is achieved using Visual C++ 6.0 with Data Access Objects (DAO). DAO is a high-level database access technology that provides a simple and efficient way to manipulate database records. The database stores various process parameters, such as casting shrinkage rates, machining allowances, and standard riser dimensions, providing a centralized and manageable repository. The integration of U F U N C (User Function) with MFC (Microsoft Foundation Classes) enables the creation of a robust application that can simultaneously handle UG graphics and database queries. The key technical specifications are summarized in the following table:
| Development Tool | Role in System |
|---|---|
| UG NX 3.0 | Primary CAD platform for 3D modeling and design |
| UG/Open API & UG/Open++ | Core programming interfaces for customizing UG functionality |
| Visual C++ 6.0 | High-level programming environment for application logic |
| UG/Open UI Styler | Tool for creating custom, native-style UG dialogs and interfaces |
| UG/Open MenuScript | Scripting language for creating and modifying UG menus and toolbars |
| Microsoft Access 2000 | Database management system for storing process-related data |
3. System Development under the UG Environment
3.1 Development Environment Configuration
Before starting the coding process, the development environment is configured to ensure seamless integration. For UG, the default units are set to metric by modifying the ugii_env.dat file. A user-defined folder structure is created to store development files, typically with application and startup subdirectories. The startup folder is designated to hold menu script (.men) and toolbar (.tbr) files, while the application folder stores the compiled .dll and .dlg files. An environment variable, UGII_USER_DIR, is set to point to this user-defined folder so that UG loads the customized menus and applications at startup.
For Visual C++ 6.0, it is necessary to configure the include and library file paths to point to the UG/Open directories. When creating a new project, the project can be set up as a Win32 Dynamic-Link Library (DLL). The linker settings must include the necessary UG libraries, such as libufun.lib and libugopenint.lib, and the include directories should contain the UG/Open header files.
3.2 System Interface Design
The user interface is crucial for usability. The UG/Open MenuScript provides a method to create custom menus seamlessly integrated into the UG main menu system. A menu title, “Sand Casting” in the developed system, is inserted before the standard “Help” menu. The menu contains commands such as “Load Model”, “Shell-like Parts”, “Shaft Parts”, and “Disc Parts”, each with corresponding response actions that trigger custom dialog boxes or functions. The following is an example of a generic menu script structure that defines a cascading menu within the UG environment:
VERSION 120 EDIT UG_GATEWAY_MAIN_MENUBAR BEFORE UG_HELP CASCADE_BUTTON UI_SAND_MENU LABEL Sand Casting END_OF_BEFORE MENU UI_SAND_MENU BUTTON SAND_LOAD LABEL Load Model ACTIONS load_model SEPARATOR BUTTON SAND_SHELL LABEL Shell-like Parts ACTIONS shell_cad SEPARATOR BUTTON SAND_CUSTOM LABEL Other Parts ACTIONS other_cad END_OF_MENU
The primary interactive dialogs are created using UG/Open UI Styler. The UI Styler environment provides a rich palette of controls, including labels, integer/real/string input fields, buttons, toggles, option menus, and lists, enabling the construction of professional and user-friendly dialog boxes. These dialogs are designed to follow the natural workflow of a casting engineer. For instance, a dialog for machining allowance selection may include a list of casting materials, a drop-down for the grade of precision, a field for the part’s basic dimension, and a field for displaying the computed allowance.
3.3 Program Framework and Key Implementations
The main program framework is built on the entry-point function ufsta(). This function is called when the DLL is loaded by UG. The initial steps involve calling UF_initialize() to set up the UG environment. Then, using UF_MB_add_styler_actions(), the program connects the menu commands to their associated dialog boxes. The main program skeleton is as follows:
void ufsta(char *param, int *retcode, int rlen)
{
int error_code = 0;
if ( (UF_initialize()) != 0)
return;
if ( (error_code = UF_MB_add_styler_actions(actions)) != 0 )
{
char fail_message[133];
UF_get_fail_message(error_code, fail_message);
printf("%s\n", fail_message);
}
UF_terminate();
return;
}
Within the callback functions of the UI Styler dialogs, the functional modules of the system are implemented. These modules handle geometry recognition, parameter calculation, database interaction, and 3D model manipulation. For example, one critical function in the machining allowance module is to identify the faces of the 3D solid model that are to be machined. This is achieved by traversing the faces of the solid model and checking their attributes or orientation using UG/Open APIs like UF_MODL_ask_face_edges() and UF_MODL_ask_edge_faces(). After a face is selected, the system calculates its basic dimensions and queries the database to retrieve the corresponding machining allowance value, finally generating the offset solid geometry to represent the allowance.
4. Development of the Casting Process CAD System
4.1 System Initialization
The design process begins with system initialization, which sets up a project to organize all design data and results. This involves creating a new project folder, entering part information such as the part name, part number, material, designer, and date, and importing the part’s 3D model into the project. This ensures that all subsequent operations, including the storage of parameters and the generation of design outputs, are centrally managed and easily accessible.
4.2 Determination of Main Process Parameters
The module for process parameters is fundamental to the system. It assists designers in determining several critical parameters for sand casting parts, as illustrated in the following tables and formulas.
4.2.1 Minimum Wall Thickness and Minimum Cast Hole
The system helps identify holes that are too small to be cast and should be left for machining. The user interface allows the selection of material, and the system automatically traverses the 3D model to identify potential cast holes based on diameter criteria. For non-cast holes, the system can automatically create a solid cylinder to fill the hole, completing the “solid model repair” function.
4.2.2 Parting Surface
The selection of the parting surface is critical for part accuracy and manufacturability. The system does not automatically determine the parting surface but provides a platform for the user to apply their expertise. The design principles are well-known: ensuring the part is entirely within one half of the mold if possible, minimizing the number of parting surfaces, and choosing a flat surface for ease of molding. The system’s role here is to provide a clear 3D visualization of the part and its orientation so that the user can make an informed decision.
4.2.3 Draft Angle
To facilitate pattern removal from the mold, a draft angle is required on vertical faces. The “Draft Angle Design” user interface provides functions to:
- Identify Draft Faces: The program automatically traverses all planar and cylindrical faces on the part and determines whether they are perpendicular to the parting direction, highlighting them as potential draft faces.
- Analyze Draft Faces: For a selected face, the program calculates its height along the draft direction.
- Create Draft Geometry: The system allows the user to add draft by selecting a reference point. The face is then rotated around a fixed line passing through this point to create the specified draft angle.
4.2.4 Casting Shrinkage
The casting shrinkage rate, K, is calculated using the following formula:
$$ K = \frac{L_{mold} – L_{part}}{L_{part}} \times 100\% \qquad (4-1) $$
Here, \(L_{mold}\) is the pattern dimension and \(L_{part}\) is the part dimension. This value is influenced by the alloy type, part structure, and mold type. Instead of integrating this into a separate modeling function, the system provides a reference table of shrinkage values and recommends the user to apply the scale body function in UG, which supports both uniform and non-uniform scaling.
4.2.5 Machining Allowance
The machining allowance is the extra material left on the casting surface to be removed during machining. The developed “Machining Allowance Design” interface guides the user through the process. It first helps identify machining surfaces by analyzing the model’s faces. After a face is selected, the system determines the basic dimension by comparing the face’s size to its distance from the machining datum. Based on the material, molding method, and dimension, the system queries a relational database for the recommended allowance value. The system then creates a new solid model with the allowance added, using either an Extrude or Offset operation, and highlights the added material. The user interface for this module is designed to show the selected face and the corresponding allowance value clearly.
4.3 Riser Design Module
The riser system is crucial for feeding the casting during solidification to prevent shrinkage defects. The design methodology depends on the alloy type. For grey iron, which exhibits graphitic expansion, the “practical risering” approach can be used. The choice of method—direct, controlled pressure, or no-riser—depends on mold rigidity and the critical modulus of the casting. The critical modulus is calculated after dividing the casting into simpler geometric sections. The modulus of a section is the ratio of its volume to its cooling surface area.
The main output of the riser design module is the identification of the critical modulus, defined mathematically as:
$$ M = \frac{V}{S – S_0} \qquad (4-2) $$
where \(V\) is the volume of the divided part, \(S\) is its total surface area, and \(S_0\) is the area of the non-cooling surfaces (e.g., the section connected to a riser). The system leverages the 3D model to accurately calculate these physical properties. The user segments the part using UG’s split body function, selects the critical section, and the system computes its volume and area to find the modulus. Based on this modulus, the system assists in either selecting a standard riser from a database (such as an open top riser or a side blind riser) or designing a custom riser. Finally, the riser and its neck are created as 3D models, either through parametric programming for simple geometries or by retrieving a pre-built model from a graphic library for complex shapes.
4.4 Gating System Design Module
The gating system is the channel through which molten metal enters the mold cavity. Its design involves determining the system type, calculating the cross-sectional areas of its components (sprue, runner, ingate), and arranging its layout. The module primarily assists with the size calculations and 3D modeling of the system’s components.
4.4.1 Design Flow
The design flow in the CAD system begins with the calculation of casting weight and pouring time, followed by the calculation of the choke cross-section area. The areas of other gating system components are then calculated based on experience ratios. The system then assists in generating the 3D model of the system components and placing them at the desired locations on the casting.
4.4.2 Choke Area Calculation
The choke area is calculated using a hydraulic formula based on Bernoulli’s equation:
$$ F = \frac{G}{\mu \cdot T \cdot \sqrt{2 \cdot g \cdot H_p}} \qquad (4-3) $$
Where \(F\) is the choke cross-section area (cm²), \(G\) is the total weight of the poured metal including gating and risers (kg), \(\mu\) is the flow coefficient, \(T\) is the pouring time (s), \(H_p\) is the effective static head (cm), and \(g\) is the acceleration due to gravity. The system assists the user in determining each of these values.
Pouring Weight: The system calculates the total weight of the casting and risers from their 3D models. An estimated weight for the gating system is then added based on experience.
Pouring Time: For grey iron, the system provides an experience-based table for pouring time.
| Casting Weight G/kg | Pouring Time T/s |
|---|---|
| < 12 | 6 – 8 |
| 15 | 8 |
| 20 | 8 |
| 25 | 8 |
| 30 | 8 |
| 35 | 8 |
| 40 | 10 |
| 50 | 12 |
Flow Coefficient (μ): The flow coefficient depends on the gating system structure and alloy. The system provides typical values, such as 0.76 for a system with only a sprue and cup, 0.58 with the addition of a runner, and 0.48 for a complete system with ingates.
Effective Static Head (Hp): This is calculated based on the pouring position and the height of the casting relative to the ingate, using the following standard formula:
$$ H_p = H_0 – \frac{P^2}{2C} \qquad (4-6) $$
Here \(H_0\) is the static head above the ingate, \(P\) is the height of the casting above the ingate, and \(C\) is the total height of the casting.
4.4.3 Area Ratios for System Components
After the choke area is determined, the areas of the other components are calculated using selected experience-based ratios. The system allows the user to choose between a semi-closed or an open gating system. For instance, the ratios for these systems are as follows:
Semi-closed system (choke at ingate):
$$ \Sigma F_{in} : \Sigma F_{r} : \Sigma F_{s} = 3 : 8 : 4 \qquad (4-7) $$
Open system (choke at sprue-runner connection):
$$ \Sigma F_{in} : \Sigma F_{r} : \Sigma F_{zu} : \Sigma F_{s} = 1 : 0.7 : 0.4 : 0.7 \qquad (4-8) $$
4.4.4 Ingate Design
The ingate is the final section of the gating system that connects the runner to the mold cavity. The system provides a database of standard ingate shapes, such as flat trapezoid and high trapezoid profiles. Based on the calculated total ingate area and the number of ingates, the system finds a matching standard profile from the database. The user can then confirm the selection and proceed to 3D modeling. The system offers two modeling methods: creating a straight ingate of a specified length or creating a curved ingate by sweeping the chosen profile along a pre-drawn trajectory.
4.4.5 Runner and Sprue Design
The runner and sprue design modules follow a similar pattern. The user inputs the required parameters, and the system calculates the cross-section dimensions based on the pre-calculated areas and the desired geometry, such as a trapezoid for the runner or a circular shape for the sprue. After these dimensional calculations are confirmed, the system automatically creates the 3D model of the runner or sprue at a user-defined insertion point, completing the 3D design of the gating system.
5. Application Example: Fire Control Bolt Covering
5.1 Production Conditions and Technical Requirements
The developed system was applied to design the casting process for a fire control bolt covering, a shell-like part from a local machinery factory. The part is shown in a typical 3D model. It has a general shape with outer dimensions of 238 × 238 × 140 mm and a total weight of approximately 8 kg. The material is grey cast iron HT100. The casting must be free of shrinkage, porosity, and surface defects, and the pour temperature should be 1400-1450°C. The production is characterized by single-part manufacturing.
5.2 Casting Process CAD for Fire Control Bolt Covering
5.2.1 3D Model and Process Parameters
The design process begins within the UG environment. The user invokes the “Sand Casting” menu and selects “Shell-like Parts,” which opens the corresponding part file. The system then guides the user through the process parameter design phase, where holes that are not cast are filled, the parting direction is determined, and machining allowances are added to the model.
5.2.2 Riser Design
For the riser design, the casting is divided into two main sections based on its geometry using UG’s split body functionality. The system calculates the volume and surface area for each section. Using the modulus formula (\(M = V/S\)), the system computed the following:
Section 1: Volume (V) = 209732 mm³, Surface Area (S) = 16665 mm², Modulus (M) = 12.58 cm.
Section 2: Volume (V) = 517825 mm³, Surface Area (S) = 106162 mm², Modulus (M) = 4.87 cm.
Since both calculated moduli are greater than 0.48 cm, the controlled pressure riser design method was chosen. The analysis indicates that Section 2, with the smaller modulus, is the critical section. Thus, the critical modulus is 4.87 cm. The system then calculates the riser size and assists in generating its 3D model. After invoking the riser calculation and modeling functions, the system produces a 3D riser model. The riser system is then assembled with the casting model using UG’s assembly functionality, as shown in a dedicated figure.
5.2.3 Gating System Design
For the gating system design, a single part per mold with a horizontal parting line is selected. The sprue is chosen as the choke area. The calculation interface received the necessary inputs, and the system calculated the choke cross-section area to be 3.21 cm², which is the total cross-sectional area of the sprue. The corresponding 3D gating system is then designed and assembled with the casting.
5.3 Verification through Production
To validate the design, a sample casting was produced in the factory based on the design results. The successful production of the casting, as evidenced by the part photograph, confirmed that the casting process design is sound and practical. The application of the system not only simplified the design workflow but also proved the feasibility and efficiency of the developed CAD tools for sand casting parts.
6. Rapid Prototyping Experiment for the Casting Model
6.1 Principles of RPM Technology
Rapid Prototyping & Manufacturing (RPM) is a technology developed in the late 1980s. It builds physical parts layer by layer directly from 3D CAD data. The basic principle involves slicing the 3D CAD model into thin cross-sectional layers. These layers are then physically fabricated and stacked to create the final solid object. Common RPM techniques include SLA, LOM, SLS, and FDM. A comparison of these methods is shown in the table below. For the fire control bolt covering, which requires good accuracy but is not overly complex, the Laminated Object Manufacturing (LOM) method was selected due to its moderate cost, high speed, and adequate precision for the application.
| RPM Method | Speed | Accuracy | Cost | Complexity | Size | Common Materials |
|---|---|---|---|---|---|---|
| SLA | Fast | High | High | Medium | Small-Medium | Photosensitive Resins |
| LOM | Fast | High | Low | Simple | Medium-Large | Paper, Metal Foil, Plastic Film |
| SLS | Slow | Medium | Low | Complex | Small-Medium | Wax, Plastic, Metal, Ceramic Powder |
| FDM | Slow | Medium | Low | Medium | Small-Medium | Wax, Plastic, Low-melting Metals |
6.2 Fabrication Process for Fire Control Bolt Covering Model
The H RP-III rapid prototyping machine was used for this experiment. The machine operates by using a CO₂ laser to cut the outline of each layer into a sheet of paper coated with a heat-sensitive adhesive. These sheets are then laminated together to form the part. The manufacturing process is outlined below.
6.2.1 Process Workflow
The workflow for the LOM process is shown in the following table:
| Stage | Description |
|---|---|
| 1. 3D Model | Create a 3D CAD model of the casting in UG. |
| 2. Data Processing | Export the model into a suitable format, and slice it into layers. |
| 3. Model Building | Laminate and cut the paper layers using the LOM machine. |
| 4. Post-processing | Remove excess material, seal the part, and improve surface finish. |
6.2.2 Experimental Results
In the pre-processing stage, the 3D CAD model from UG is exported into the STL file format. Because UG lacks a direct STL export command, the File > Export > Rapid Prototyping command is used. The resulting STL file is then processed by the H RP-III machine’s software. The machine automatically cuts and layers the paper according to the sliced contours. The successful fabrication of the casting pattern demonstrates the integration of the casting process CAD system with RPM. The physical pattern (after post-processing) accurately reflects the 3D model. A dimensional comparison between the model and the fabricated pattern shows excellent agreement, with errors all below 0.2%.
| Dimension | Model Size (mm) | Sample Size (mm) | Error (%) |
|---|---|---|---|
| Length (W1) | 238 | 238.3 | 0.13 |
| Width (W2) | 76 | 76.1 | 0.13 |
| Height (h) | 140 | 140.2 | 0.14 |
The final sample product, after coating and surface treatment, is shown in the corresponding figure. This experiment validated the complete digital manufacturing chain: from the 3D CAD model of sand casting parts, through casting process design, to the rapid fabrication of a physical pattern. This approach successfully combines CAD/CAE/CAM/RPM, reducing the product development cycle and manufacturing costs.
7. Conclusion and Future Work
7.1 Conclusion
This thesis successfully developed a dedicated CAD system for the sand casting process of shell-like parts. The primary achievements and conclusions are summarized as follows:
- Platform and Architecture: An integrated secondary development platform was established using UG NX 3.0, combining the capabilities of the UG/Open API, UG/Open++, and Visual C++ 6.0.
- Targeted System Design: A modular system architecture was designed to mirror the traditional casting process workflow, including modules for product input, system initialization, process parameters, riser design, and gating system design. This structure is specific to shell-like sand casting parts.
- Complete Function Implementation: The system successfully realized the design of process parameters (machining allowances, draft angles, etc.), a riser design module that calculates critical moduli and selects/designs risers, and a gating system design module that calculates choke areas and designs sprue, runner, and ingate dimensions.
- User-Friendly Interface: The system uses UG/Open UI Styler to create native, user-friendly Chinese-language interfaces that are consistent with the UG style, making the system intuitive and highly usable for casting engineers.
- Database Integration: A data management system was efficiently created and integrated into the CAD application using Visual C++ and DAO (Database Access Objects) technology, enabling the management of casting process data directly within the UG environment.
- Practical Application: The system’s validity was demonstrated through the successful design of the casting process for a fire control bolt covering, a real-world sand casting part. The subsequent production of a defect-free casting validated the process design.
- RPM Integration: The experiment successfully combined the CAD system with Rapid Prototyping (RPM) technology to fabricate a physical casting pattern, proving the feasibility of integrating CAD/CAE/CAM/RPM for sand casting parts.
7.2 Future Work
Several areas of future research and development have been identified to further enhance the system:
- Integration with CAPP/CAM: The sand casting process CAD system should be integrated with Computer-Aided Process Planning (CAPP) and Computer-Aided Manufacturing (CAM) for a more comprehensive digital manufacturing solution.
- Simulation Integration: The system should be coupled with casting solidification simulation software. The simulation of mold filling and solidification can be performed using the gating/riser system designed by this CAD tool, providing valuable feedback for process optimization.
- Expansion of Functions: The current system should be extended to include additional design modules, such as chill design, core design, and the generation of detailed 2D casting drawings. The current database can also be enhanced with more extensive process data and material information.
- Advanced Database: The existing database technology could be upgraded to a more robust, network-compatible system to support collaborative design and data sharing across the enterprise.
This thesis has laid a solid foundation for the development of a practical and efficient CAD system for sand casting parts. The continuous advancement of these technologies will further promote innovation and efficiency in the foundry industry.