I have focused my research and development work on the creation of a practical computer-aided design system for axis-type parts produced by sand mould casting. In my view, sand mould casting remains one of the most widely used manufacturing routes for large and medium-sized steel components, yet its process design is still heavily dependent on empirical knowledge. This dependence leads to long design cycles, repeated modifications, high scrap rates, and limited scientific control. To address these problems, I selected Pro/ENGINEER 2001 as the secondary development platform and C together with Visual C++ 6.0 as the programming language. I then built a CAD framework for sand mould casting process design, including a customized menu, a process database, and an axis-part design module. The resulting system supports material definition, parting plane selection, process parameter setting, gating system design, and riser system design for sand mould casting.
1. Background and Motivation
Sand mould casting is a manufacturing process in which liquid metal is poured into a sand mould, solidifies, and is then removed as a shaped component. The process is characterized by a solid–liquid–solid transformation and by a one-time forming route. Because of this physical complexity, sand mould casting process design involves many coupled decisions: pouring position, parting plane, machining allowance, shrinkage, draft angle, fillet radius, gating system, riser system, chills, and cores. For axis-type parts, especially crankshafts and similar components, the presence of multiple journals, webs, and eccentric masses creates hot spots that are difficult to feed. I therefore concentrated on axis-type parts because they represent a demanding class of sand mould casting components and because their geometry can be parameterized to a useful degree.
Computer-aided engineering for casting has matured considerably. A typical casting CAE system contains a pre-processing module, a central processing module, and a post-processing module. In the pre-processing stage, a three-dimensional solid model is created and meshed. In the central processing stage, filling and solidification are simulated, and shrinkage porosity, shrinkage cavity, stress, and strain are predicted. In the post-processing stage, the results are displayed so that the process can be optimized. Casting process CAD is a key part of the pre-processing stage, and it is also the basis for meaningful CAE analysis. Without a well-designed sand mould casting process, simulation results cannot be translated into a reliable production route.
The development of casting CAD has moved from standalone two-dimensional tools toward secondary development on mature three-dimensional CAD platforms. Sand mould casting CAD systems can be classified as general-purpose or special-purpose. General-purpose systems handle common sand mould casting processes for cast steel, gray iron, ductile iron, and nonferrous alloys. Special-purpose systems focus on a particular part family, such as gears, valves, crankshafts, engine blocks, or blades. I chose to develop a special-purpose axis-part module because the geometry and feeding rules for such parts are sufficiently repetitive to justify automation, while the thermal and feeding behavior remains complex enough to require engineering calculation.
2. Selection of Development Platform and Language
When I selected the platform for sand mould casting CAD development, I considered system function, performance-to-price ratio, hardware compatibility, secondary development capability, openness, reliability, and supplier support. The most common commercial CAD platforms include AutoCAD, UG, CATIA, I-DEAS, SolidWorks, Cimatron, Pro/ENGINEER, and several domestic systems. Each has strengths and limitations. I compared them from the perspective of sand mould casting process design, because the platform must support solid modeling, parameterization, assembly, database access, and user interface customization.
| CAD platform | Main strength | Main limitation for sand mould casting CAD | Secondary development support |
|---|---|---|---|
| AutoCAD | Mature two-dimensional drafting, low cost, wide use | Weak solid modeling and weak full parametric design | AutoLISP, ADS, VBA, ObjectARX |
| UG | Strong CAD/CAE/CAM integration, powerful machining | Complex to learn, high hardware demand | UG/Open, GRIP, API |
| CATIA | Excellent surface and assembly design, strong aerospace use | Expensive, heavy platform, specialized environment | CAA, Automation |
| I-DEAS | Integrated design, simulation, and manufacturing | Less common in small and medium foundries | Open I-DEAS |
| SolidWorks | Easy to use, good parametric design, affordable | Large assembly and advanced simulation less strong | API, VB, C++ |
| Cimatron | Strong mould and die focus | Narrow application range | API, proprietary tools |
| Pro/ENGINEER | Parametric, feature-based, fully related, strong CAE link | Non-Windows-native interface, relatively high learning cost | Pro/Toolkit, J-Link, Pro/PROGRAM, family tables, UDF |
I selected Pro/ENGINEER 2001 because it provides a complete parametric feature-based modeling environment, full associativity, and a well-documented secondary development toolkit. Pro/ENGINEER is widely used in industry, so a sand mould casting CAD system built on it has a realistic deployment path. Its Pro/Toolkit interface allows a C program to access the Pro/ENGINEER database, add menus, create dialogs, and interact with solid models. In addition, the platform supports family tables and user-defined features, which are useful for building standard riser, runner, and gate libraries for sand mould casting. For programming, I selected C and Visual C++ 6.0 because Visual C++ provides an integrated development environment, MFC class libraries, DAO database access, and mature debugging tools. The combination of Pro/Toolkit with Visual C++ 6.0 allowed me to develop a sand mould casting CAD system that is both functional and maintainable.
3. Pro/ENGINEER Secondary Development Technology
Pro/ENGINEER offers several secondary development routes: Pro/PROGRAM, Pro/Toolkit, J-Link, Automation GATEWAY, family tables, and user-defined features. Among these, Pro/Toolkit is the most powerful C-based API. I chose Pro/Toolkit because it provides direct access to the Pro/ENGINEER database and allows a compiled application to run as part of the Pro/ENGINEER session. Pro/Toolkit uses an object-action naming convention. Every function has a prefix, an object name, and an action name. For example, a function that sets a menu button action follows this convention. The API is large, but it is consistent and well suited to the development of a sand mould casting CAD system.
I used synchronous mode rather than asynchronous mode. In synchronous mode, the Pro/Toolkit application is started and stopped by Pro/ENGINEER, and communication efficiency is high. Synchronous mode has two variants: DLL mode and multiprocess mode. DLL mode integrates the Pro/Toolkit application into Pro/ENGINEER and improves execution speed. Multiprocess mode compiles the application into an independent executable that runs as a child process of Pro/ENGINEER. For debugging, I used multiprocess mode because it avoids restarting Pro/ENGINEER after every code change. For release, I used DLL mode because it provides better integration and speed. This dual approach saved a significant amount of development time.
| Development route | Language | Main use | Suitability for sand mould casting CAD |
|---|---|---|---|
| Pro/PROGRAM | Pro/PROGRAM script | Model regeneration and parameter control | Good for simple parametric parts, limited for full process design |
| Pro/Toolkit | C | Full API access, menus, dialogs, database access | Excellent for a complete sand mould casting CAD system |
| J-Link | Java | Java-based customization | Useful but less common in foundry development |
| Automation GATEWAY | Visual Basic | VB access to Pro/ENGINEER | Convenient for simple automation, less mature |
| Family tables | Table-driven | Standard part variants | Excellent for riser, runner, and gate libraries |
| User-defined features | UDF files | Reusable feature groups | Useful for repeated sand mould casting features |
The general procedure I followed for Pro/Toolkit development was: write the Pro/Toolkit application, write the resource files, modify the makefile, compile and link, register the application, and run it inside Pro/ENGINEER. The application must contain two required functions: user_initialize() and user_terminate(). The initialization function sets up menus, dialogs, or other user interfaces. The termination function performs cleanup when the application is unloaded. I placed these functions in the same C++ source file as the project name and kept their signatures unchanged.
To create the application framework, I used three possible methods. The first method uses the MS-DOS command line and the supplied makefile. The second method uses the Visual C++ integrated development environment with a Win32 Console Application project and manually adds include paths, library paths, and system libraries. The third method uses the MFC AppWizard to create a regular DLL using shared MFC DLL. I found that the third method is the most convenient and practical because it allows direct use of MFC classes for dialogs and database access. This is important for sand mould casting CAD because the user interface requires many dialogs for process parameters, gating calculations, and riser selection.
4. Menu Development for the Sand Mould Casting CAD System
I designed the menu structure according to the conventional sand mould casting process design flow. The top-level menu is CastCad, which means casting process CAD. Under this menu, I placed three main submenus: part type, casting type, and casting module. The part type submenu allows the user to select axis, wheel, plate, or other part families. The casting type submenu allows the user to select sand mould casting, metal mould casting, investment casting, and other routes. The casting module submenu contains the detailed process design functions for the selected part family and casting type. For the axis-part sand mould casting module, the submenu includes material definition, parting plane, process parameters, riser system, and gating system.
| Menu level | Menu item | Function |
|---|---|---|
| Top | CastCad | Entry to the sand mould casting CAD environment |
| Part type | Axis | Select axis-type part family |
| Part type | Wheel | Select wheel-type part family |
| Part type | Plate | Select plate-type part family |
| Casting type | Sand mould casting | Select sand mould casting process route |
| Casting type | Metal mould casting | Select permanent mould route |
| Casting module | Material | Define material properties |
| Casting module | Parting plane | Set parting plane and pouring position |
| Casting module | Process parameters | Set shrinkage, machining allowance, draft, fillet |
| Casting module | Riser system | Design feeding system |
| Casting module | Gating system | Design pouring system |
Pro/ENGINEER uses menu resource files with the extensions .mnu and .aux. A .mnu file describes a complete menu, while an .aux file adds buttons to an existing menu. I used both. The menu file contains groups of three lines. The first line gives the menu name or button name. The second line gives the on-line help text. The third line gives the replacement help text, which is also used for localization. If a menu name is followed by a second word, Pro/ENGINEER displays the second word instead of the first. This rule allowed me to add English menu labels and detailed help messages. I registered the menu files with ProMenuFileRegister() and added buttons with ProMenuAuxfileRegister(). I then set the button action with ProMenubuttonActionSet().
The C code for the menu initialization follows this pattern:
int user_initialize() { ProMenuFileRegister("part", "part.mnu", &menu_id); ProMenuAuxfileRegister("part", "part.aux", &menu_id); ProMenubuttonActionSet("part", "CastCad", (ProMenubuttonAction)UserProCastCad, NULL, 0); return 0; }
After compiling the application, I modified the makefile by copying the standard makefile from the Pro/Toolkit installation directory and changing the Pro/Toolkit source path, the Pro/Develop source path, the include paths, the library paths, and the output names. I then compiled the application with Visual C++ or from the command line. To run the application in Pro/ENGINEER, I wrote a registration file. The registration file contains the application name, executable file, text directory, startup option, stop option, delay option, and revision. I used multiprocess mode during development and DLL mode during release.
5. Database Development for Sand Mould Casting
Sand mould casting process design requires many empirical and standard data items: machining allowances, shrinkage rates, draft angles, fillet radii, riser dimensions, riser volumes, feeding capacities, gating ratios, pouring times, and minimum rising velocities. I developed a process database to manage these data. I selected Microsoft Access 2000 as the database platform because the data volume is moderate and Access is easy to deploy. I used the Data Access Object interface, known as DAO, through MFC because Access is a Microsoft database format and DAO provides efficient access to it. The database is used to store, query, modify, add, and delete sand mould casting process parameters.
| Database table | Main fields | Purpose in sand mould casting |
|---|---|---|
| Machining allowance | Part size, surface type, allowance value | Set machining allowance for axis surfaces |
| Shrinkage rate | Material, casting size, shrinkage value | Compensate for solidification contraction |
| Draft angle | Surface height, pattern type, draft value | Facilitate pattern removal from sand mould |
| Fillet radius | Wall thickness, intersection type, radius | Reduce stress concentration and hot spots |
| Riser standard | Riser type, modulus, volume, weight, feeding capacity | Select and size feeders |
| Gating standard | Pouring weight, ladle nozzle, gate area, runner area | Design gating system |
| Rising velocity | Cast steel weight, wall thickness, minimum velocity | Check pouring speed in sand mould casting |
To call the database from Pro/ENGINEER, I used a DLL-based interface between Pro/Toolkit and MFC. The Pro/Toolkit application was built as a console application, and the MFC dialog and database application was built as a regular DLL using shared MFC. The Pro/Toolkit program called the exported DLL function. I added the required Pro/Toolkit libraries and the MFC DLL library to the link settings. The interface allowed Pro/ENGINEER to open MFC dialogs, query the Access database, and return selected values to the sand mould casting process model. The communication path was Pro/ENGINEER to Pro/Toolkit executable to MFC DLL to DAO database. This approach combined the strength of Pro/ENGINEER in geometry handling with the strength of MFC and DAO in user interface and database access.
The MFC DAO classes I used included CDaoDatabase, CDaoRecordset, CDaoTableDefInfo, and CDaoFieldInfo. The database object manages the connection. The recordset object performs queries and updates. The table definition and field information objects manage database structure. This made it possible to build a sand mould casting process database that can be queried for machining allowance, shrinkage, draft, fillet, riser, and gating data. For example, when the user selects a top surface machining allowance, the system opens a dialog and displays the recommended allowance from the database. The user can accept the value or modify it. The selected value is then written into the Pro/ENGINEER model or used in subsequent calculations.
6. Axis Sand Mould Casting CAD Modules
The axis sand mould casting CAD system is organized into five functional modules: material definition, parting plane design, casting process parameter design, riser system design, and gating system design. Each module interacts with the Pro/ENGINEER model and with the process database. I will describe each module in the context of sand mould casting.
6.1 Material and Unit Definition
Before process design, the user should define the material and units. In Pro/ENGINEER, the material definition can be accessed through the setup menu. The user can define a new material or select an existing one. For cast steel, typical properties include density, thermal conductivity, specific heat, elastic modulus, Poisson ratio, yield strength, tensile strength, elongation, and hardness. The unit system should be set consistently. For sand mould casting calculations, I used millimeter, tonne, and second as the base units. The shrinkage rate is applied to the solid model after the material is defined. The shrinkage rate is a key input for sand mould casting because the pattern dimensions must be larger than the final casting dimensions.
The shrinkage rate can be expressed as:
$$ S = \frac{L_m – L_c}{L_c} \times 100\% $$
where \(S\) is the shrinkage rate, \(L_m\) is the mould cavity dimension, and \(L_c\) is the casting dimension at room temperature. For cast steel, the shrinkage rate depends on carbon content, alloy content, casting size, and restraint from the sand mould. The database provides recommended values that the user can query.
6.2 Parting Plane Design
The parting plane is a critical decision in sand mould casting. It determines the pouring position, the number of sand cores, the pattern layout, and the location of the gating system. For axis-type parts, the parting plane is often a flat plane passing through the main axis or through the center of the largest cross-section. For a crankshaft, the parting plane is usually chosen so that the main journals and crankpins can be molded without undercuts. If the parting plane is not selected correctly, the sand mould cannot be withdrawn, or the casting will require complicated cores. I used datum planes in Pro/ENGINEER to define the parting plane. The user can insert a datum plane or create a cross-section to visualize the parting surface. The gating system is then attached to the parting plane so that the liquid metal enters the mould cavity in a controlled manner.
6.3 Casting Process Parameter Design
The casting process parameter module allows the user to set shrinkage, machining allowance, draft angle, and fillet radius. Each parameter is linked to a Pro/ENGINEER command. Shrinkage is applied through the shrinkage command. Draft is applied through the chamfer or draft command. Fillet is applied through the round command. Machining allowance is applied by offsetting the surfaces that will be machined. The process parameter database provides recommended values based on casting standard data. The user can query the database and select a value that is suitable for the specific sand mould casting conditions.
| Process parameter | Symbol | Typical influence | Pro/ENGINEER tool |
|---|---|---|---|
| Shrinkage rate | \(S\) | Pattern oversize, final dimensions | Shrinkage |
| Machining allowance | \(a\) | Machined surface stock | Surface offset |
| Draft angle | \(\alpha\) | Pattern withdrawal from sand | Draft |
| Fillet radius | \(r\) | Hot spot reduction, stress relief | Round |
6.4 Gating System Design
The gating system for sand mould casting must fill the mould cavity smoothly and quickly, avoid sand erosion, avoid gas entrapment, and provide a favorable temperature distribution. For cast steel axis parts, I used the rising velocity method because it is widely applied to large steel castings. The method first determines the required minimum rising velocity of liquid steel in the mould cavity. Then it calculates the pouring time from the ladle nozzle diameter and the total pouring weight. Finally it checks whether the actual rising velocity is acceptable. If not, the ladle nozzle diameter or the number of nozzles is adjusted.
The pouring time is calculated as:
$$ t = \frac{G}{n N V} $$
where \(t\) is the pouring time, \(G\) is the total weight of liquid steel, \(n\) is the number of nozzles in one ladle, \(N\) is the number of ladles used simultaneously, and \(V\) is the average pouring weight velocity through one nozzle. The rising velocity in the mould cavity is:
$$ v_L = \frac{C}{t} $$
where \(v_L\) is the rising velocity of liquid steel in the mould cavity and \(C\) is the height of the casting in the pouring position. The calculated rising velocity is compared with the recommended minimum rising velocity for the given casting weight and wall thickness. If the calculated value is close to or higher than the recommended value, the gating design is acceptable. If it is too low, the pouring time must be reduced by increasing the nozzle diameter or the number of nozzles.
| Ladle nozzle diameter | Average pouring weight velocity | Recommended use |
|---|---|---|
| \(\phi 30\) mm | \(V_1\) | Small and medium sand mould casting |
| \(\phi 40\) mm | \(V_2\) | Medium cast steel parts |
| \(\phi 50\) mm | \(V_3\) | Large cast steel parts |
| \(\phi 60\) mm | \(V_4\) | Heavy sand mould casting |
The gating system is divided into sprue, runner, and ingate. The area ratio is chosen according to the casting type and the pouring position. For cast steel, a common ratio is:
$$ F_{runner} : F_{ingate} = 1.2 : 1 $$
and
$$ F_{sprue} : F_{runner} : F_{ingate} = 1.2 : 1.2 : 1 $$
The exact ratio depends on the alloy, the casting size, and whether the gating system is top-gated, bottom-gated, or middle-gated. For axis-type sand mould casting, bottom gating or stepped gating is often preferred because it reduces turbulence and sand erosion. However, bottom gating may produce a unfavorable temperature gradient, so the design must balance filling quality and feeding requirements. I implemented the calculation of the choking area, the runner area, the sprue area, and the ingate area in the gating module. The user can select the gating type, the number of ingates, the number of runners, and the area ratios. The system then calculates the required dimensions and creates the gating geometry in the Pro/ENGINEER model.
| Gating type | Advantages | Disadvantages | Suitable sand mould casting parts |
|---|---|---|---|
| Top gating | Simple, good temperature gradient, low metal consumption | High turbulence, sand erosion, oxidation | Short, thick parts |
| Bottom gating | Smooth filling, low turbulence, less sand erosion | Unfavorable temperature gradient, more metal consumption | Tall axis parts, steel castings |
| Middle gating | Compromise between top and bottom | Moderate turbulence and moderate gradient | Medium-height parts |
| Stepped gating | Controlled filling, reduced erosion | More complex pattern | Large steel axis parts |
6.5 Riser System Design
The riser system is essential for sand mould casting of steel axis parts because solidification shrinkage must be compensated. I used the modulus method. The modulus of a casting region is defined as the ratio of its volume to its cooling surface area:
$$ M = \frac{V}{A} $$
where \(M\) is the modulus, \(V\) is the volume, and \(A\) is the heat-dissipating surface area. For simple shapes, the modulus can be calculated analytically. For complex axis parts, the casting is divided into simpler elements, and the modulus of each element is calculated. The element with the largest modulus is the hot spot and is the last to solidify. A riser is placed on or near that hot spot. The riser modulus must be larger than the casting modulus at the feeding location:
$$ M_r = f M_c $$
where \(M_r\) is the riser modulus, \(M_c\) is the casting modulus at the feeding location, and \(f\) is a safety factor. For open risers, \(f\) is typically between 1.1 and 1.2. For blind risers, \(f\) is typically between 1.2 and 1.5. The exact value depends on the riser type, the feeding distance, and the alloy. After the required riser modulus is determined, the riser dimensions are selected from the standard riser database. The database contains riser type, modulus, volume, weight, maximum feeding volume, and maximum feeding weight. The user can query the database, select a riser, and insert it into the sand mould casting model.
| Riser type | Modulus factor \(f\) | Typical application in sand mould casting |
|---|---|---|
| Open cylindrical riser | 1.1–1.2 | Large steel castings, easy access |
| Blind cylindrical riser | 1.2–1.5 | Cases where top surface must remain flat |
| Spherical riser | 1.2–1.4 | Compact feeding, high efficiency |
| Neck-down riser | 1.1–1.3 | Easier knockout and cleaning |
For the crankshaft example, I divided the casting into main journals, crankpins, webs, and counterweights. The largest modulus occurred at the junctions between the crankpins and the webs. Those junctions are natural hot spots. I calculated the casting modulus at the hot spot as \(M_c = 10.02\) cm. I applied a safety factor of 1.2, giving a required riser modulus of \(M_r = 12.02\) cm. From the standard riser database, I selected a riser with modulus \(11.96\) cm and maximum feeding weight \(4340\) kg. The weight of the casting region to be fed was \(4338\) kg. Since \(4340 > 4338\), the selected riser is adequate. The riser weight was about \(2100\) kg. The process yield was about 60%, which is reasonable for a large steel sand mould casting.
7. Case Study: Crankshaft Sand Mould Casting
I applied the developed system to a crankshaft produced in small-batch production. The material was ZG270-500 cast steel. The maximum diameter was 1270.0 mm, and the maximum length was 1720.85 mm. The crankshaft had three throws. The junctions between the crankpins and the main journals were thick and produced hot spots. The mechanical property requirements included yield strength not less than 585 MPa, tensile strength not less than 725 MPa, elongation not less than 17%, and reduction of area not less than 35%. The foundry specified normalizing and tempering, with a hardness of 217–248 HB. The casting surface had to be free from sand burn-on, scale, and harmful defects.
The design workflow was as follows. First, I started Pro/ENGINEER 2001 and loaded the Pro/Toolkit application. Second, I selected the axis part type and created or retrieved the crankshaft solid model. Third, I selected sand mould casting as the casting type. Fourth, I entered the axis sand mould casting CAD module. Fifth, I defined the material and units. Sixth, I set the parting plane. Seventh, I added process parameters such as shrinkage, machining allowance, draft, and fillet. Eighth, I designed the gating system using the rising velocity method. Ninth, I designed the riser system using the modulus method. Tenth, I assembled the gating and riser geometry with the casting model. Finally, I exported the model for sand mould casting simulation and checked the process yield.
| Step | Action | Result |
|---|---|---|
| 1 | Start Pro/ENGINEER and load Pro/Toolkit application | CastCad menu appears |
| 2 | Select axis part type | Axis part dialog opens |
| 3 | Create or retrieve crankshaft model | Solid model available |
| 4 | Select sand mould casting | Sand mould casting database linked |
| 5 | Define material and units | ZG270-500 and mm-t-s units set |
| 6 | Set parting plane | Datum plane DTM1 created |
| 7 | Add process parameters | Shrinkage, allowance, draft, fillet applied |
| 8 | Design gating system | Pouring time and rising velocity checked |
| 9 | Design riser system | Riser selected from database |
| 10 | Assemble gating and riser | Complete sand mould casting model |
The gating system calculation for the crankshaft used the rising velocity method. The total weight of liquid steel was estimated from the casting weight, riser weight, and gating system weight. The ladle nozzle diameter was selected from standard data. The pouring time was calculated with the formula \(t = G / (n N V)\). The rising velocity was then calculated with \(v_L = C / t\). The calculated rising velocity was compared with the recommended minimum. The final gating system used a bottom-gated or stepped-gated layout to reduce turbulence. The area ratio was set according to cast steel practice. The sprue, runner, and ingate dimensions were then generated in Pro/ENGINEER.
The riser system was designed with the modulus method. The hot spots were identified at the crankpin–web junctions. The casting modulus was calculated for each region. The largest modulus was used to select the riser. The riser database provided a standard riser with sufficient feeding capacity. The riser was placed above the hot spot. The feeding distance was checked to ensure that the entire hot spot could be fed. If the feeding distance was insufficient, additional risers or chills would be required. In this case, two large throws were fed by risers, while the small throw was assumed to be fed by the adjacent thick sections. The final sand mould casting model included the casting, the gating system, and the risers.
| Parameter | Value | Unit |
|---|---|---|
| Casting material | ZG270-500 | — |
| Maximum diameter | 1270.0 | mm |
| Maximum length | 1720.85 | mm |
| Number of throws | 3 | — |
| Casting modulus at hot spot | 10.02 | cm |
| Safety factor for riser | 1.2 | — |
| Required riser modulus | 12.02 | cm |
| Selected riser modulus | 11.96 | cm |
| Maximum riser feeding weight | 4340 | kg |
| Casting region weight | 4338 | kg |
| Riser weight | 2100 | kg |
| Process yield | about 60 | % |
The resulting sand mould casting process was checked with simulation. The simulation results showed that the gating system filled the mould cavity smoothly and that the risers provided sufficient feeding. The process yield was about 60%, which is acceptable for a large steel casting. The system reduced the time required for process design, shortened the design cycle, and made it easier to apply standard data consistently. It also provided a structured way to store and reuse foundry experience for sand mould casting.
8. Results and Discussion
The main outcome of my work is a working sand mould casting CAD system for axis-type parts. The system is built on Pro/ENGINEER 2001 and uses Pro/Toolkit, MFC, and DAO. The menu structure follows the sand mould casting process design flow. The process database stores machining allowance, shrinkage, draft, fillet, riser, and gating data. The axis module supports material definition, parting plane selection, process parameter setting, gating system design, and riser system design. The crankshaft case study demonstrated that the system can produce a complete sand mould casting process model with gating and risers. The calculations are transparent and can be traced back to standard formulas. The database reduces the need to consult paper handbooks repeatedly. The resulting model is ready for casting simulation and for further optimization.
I found several practical advantages during development. Multiprocess mode saved time because I did not need to restart Pro/ENGINEER after every code change. The DLL mode provided better runtime performance for release. The spawn method and DLL technique made it possible to call MFC dialogs from Pro/ENGINEER. The DAO technique made it possible to query and update the Access database from within the Pro/ENGINEER session. The combination of Pro/Toolkit with MFC and DAO is a practical route for building a sand mould casting CAD system. The system is extensible: new part families, new alloys, and new standard data can be added without changing the overall architecture.
| Development aspect | Method used | Benefit for sand mould casting CAD |
|---|---|---|
| Secondary development API | Pro/Toolkit | Direct access to Pro/ENGINEER database and UI |
| Programming language | C and Visual C++ 6.0 | Powerful IDE, MFC, DAO, debugging |
| Application mode | Multiprocess for debug, DLL for release | Fast development and efficient runtime |
| Menu development | .mnu and .aux resource files | Customized sand mould casting workflow |
| Dialog and database access | MFC DLL and DAO | User-friendly process parameter input |
| Database platform | Microsoft Access 2000 | Simple deployment and maintenance |
| Axis module | Parametric Pro/ENGINEER model plus calculations | Automated gating and riser design |
9. Conclusions
I developed a sand mould casting CAD system for axis-type parts using Pro/ENGINEER 2001, Pro/Toolkit, C, Visual C++ 6.0, MFC, and DAO. The system includes a customized menu, a process database, and an axis-part module. The axis-part module supports material definition, parting plane design, process parameter design, gating system design, and riser system design. The gating system uses the rising velocity method for cast steel. The riser system uses the modulus method and a standard riser database. The database stores machining allowance, shrinkage, draft, fillet, riser, gating, and rising velocity data. The case study of a crankshaft showed that the system can generate a complete sand mould casting process model with gating and risers, and that the calculated process yield is reasonable. The system reduces design time, improves consistency, and provides a foundation for further CAE analysis and optimization of sand mould casting.
10. Future Work
Several directions remain for future development. First, the sand mould casting CAD system should be integrated with CAPP and CAM so that process planning and manufacturing can be linked directly to the process model. Second, the system should be extended to include chill design, core design, and tooling design. Third, the part family approach should be broadened from axis, wheel, and plate parts to a more general decomposition strategy in which complex parts are divided into rods, plates, and cylinders. Each decomposed element can then be designed in its corresponding module. Fourth, the database should be migrated to a network-capable database management system so that multiple users can share sand mould casting data. Fifth, the system should be made more independent of a single CAD platform so that it can serve users of different software environments. These improvements would make the sand mould casting CAD system more general, more powerful, and more useful in industrial practice.