By now, you should have a good idea of which mill to choose, where to find the cutters, and how it all fits together... or perhaps you own a 3D printer, and didn't read the previous chapter at all. Either way, the next step is getting comfortable with the software needed to bring your ideas to life. In this section, we'll go over some of the basics, and then proceed with a simple starter project of our own.
The primary function of CAD software is, quite simply, to let you design 3D parts. Your CAD application may be just about any general-purpose modeling program, such as Blender - but in the long haul, it makes sense to settle for a purpose-built tool. "Real" mechanical design software offers better control over part accuracy, and comes with powerful data input and analysis tools that streamline engineering work. On the flip side, they usually have less impressive rendering capabilities - and may come with no support for animation, physics, and other perks taken for granted in general-purpose 3D apps.
For now, though, the distinction between general-purpose modeling tools and CAD isn't that important. You simply need to get comfortable with any 3D design software of your choice - and that takes a bit of work.
A-ha, that's a good question indeed! In the previous edition of this guide, I tried to give an impartial overview of the market - but in the end, there is plenty of choice, and very few genuinely bad CAD tools. You can just look around, find the one you like and can afford.
If you just want a simple recommendation - and are willing to spend some money on software to begin with - Rhino 3D is probably the best CAD package that you can get on a hobbyist budget. Students can purchase a fully-featured edu license for under $140, so if you are still in the academia, it would be foolish not to go for it. For mere mortals, there is a heftier price tag attached - $750 - so it's a more difficult call. Still, it's a mature and user-friendly tool that runs well even on low-end systems, and it's just done well - so you probably won't regret it.
Now, if Rhino is priced outside your league, many people in the community are also fond of Alibre Design PE, which sells for about $100. Or, if you prefer not to spend any money at all, and can live with a somewhat clunky app, then FreeCAD looks fairly OK for simpler work.
What else? Several accomplished DIYers use general-purpose 3D modeling tools such as Sketchup or Blender. The free-of-charge general-purpose tools are pretty diverse and mature; the only problem is that they may be less suited for complex work later on. If you are willing to cross that bridge when you come to it, they are definitely worth a try as a starter option.
Last but not least, cash-strapped DIYers may also want to check out one of the "demo" editions of commercial CAD tools. For example, Creo Elements has a modest limit of 60 parts per document, but otherwise, should do the trick.
We should probably start the lesson with a gentle warning: CAD programs tend to have a fairly steep learning curve. This is in part because you are forced to manipulate 3D objects using a 2D input device and a 2D display - and it takes a while to master that skill. The other problem is that these applications tend to use unfamiliar UI paradigms and obscure terminology - and even something as simple as right-clicking an object may have an unexpected result. It takes some effort to start using the software in a competent way - and if you're just banking on your innate abilities, you will probably learn to do things exactly the wrong way.
If you want to make real progress, here are some rules to live by:
Read the manual and do the tutorials. Trust me, you are not too good for this - even if you never had to do that with any other software. Set aside 2-3 days to go through all the exercises, and read the help pages. You need to understand what the program has to offer and what terminology it uses; even if you have some experience with 3D modeling software, you will learn a lot.
Give your mouse a break. Try to do as much as possible without clicking around the UI. Learn command names and keyboard shortcuts, and make a habit of entering coordinates and dimensions manually. Find hotkeys for enabling, disabling, and changing grid and object snaps, changing drag modes, constraining movement, zooming and rotating viewports, and so on. This will save you plenty of time.
Don't approximate. Never move objects around to make them just sort-of fit together. Learn to leverage object snaps, or use parametric operators to move, copy, rotate, or replicate objects with precision. If you don't, you will quickly start accummulating subtle geometry errors that will cause many 3D operations to unexpectedly fail later on (e.g., due to self-intersecting curves or imperceptible gaps).
Don't believe in magic. CAD programs often come with advanced features to automatically calculate intersections or unions of 3D solids, place and remove holes, etc - but these functions aren't perfect, and tend to misbehave at least opportune times. Instead, learn to break down complex problems into simple steps, and operate on intuitive primitives (e.g., planar curves and surfaces) for as long as possible in the editing process. This also makes it easier to revise your designs later on.
Before you start, there's just one more thing to do - you need to customize the program for precision work. Needless to say, the tolerances needed to design a building aren't the same as when designing a gearwheel - and CAD applications are used for both. For now, simply go through the configuration pages, and try to do the following:
System units: set to millimeters. Or don't, but I find inches pretty unwieldy for precision work.
Precision: set precision (or tolerance, or accuracy) to 0.5 µm (0.0005 mm) or so. Display mesh tolerance can be set to about 0.01 mm, simply to speed up rendering.
Display grid: enable if necessary, and set major spacing to 5 mm, and minor spacing to 1 mm. Set grid size to match the work area of your machine.
Snaps: disable object and angle snaps by default (you will be able to turn them on with a hotkey when necessary). Enable linear snaps and set distance to 0.5 mm. If the program supports it, turn on "planar" mode for snaps, where all the object snap points are projected to the construction plane of the current viewport.
Viewports: switch to four-viewport display mode - showing top, front, and right sides of the model, plus a rotatable "perspective" (axonometric) view. Zoom in all viewports so that there are about 2-4 mm between the grid lines displayed on your screen.
Shading mode: configure all viewports to use 3D shading, preferably with translucent surfaces (opacity around 80-90%; "ghosted" preset in Rhino), and with 1 pixel edge thickness. If possible, set a different edge color (e.g., red) for any "naked" edges that do not form a closed solid.
Done? Then let's roll...
Your first job is to figure out how to draw several simple, two-dimensional shapes on the X-Y construction plane (i.e., using the "top" viewport of your CAD app). Try do to sketch all of the following:
A single, straight line segment,
A multi-segment zig-zag line (with sharp turns),
A closed multi-segment line, where the end is joined with the beginning,
A circle, using three methods: center point and diameter; two boundary points; and three boundary points,
An arc - by selecting center point, diameter, and start / stop angles,
A rectangle, using two methods: two corner points; or a center point and one corner,
A polygon - circumscribed and inscribed, with a specified number of sides.
Practice a bit; perhaps sketch a simplified, boxy outline of a car, complete with wheels.
When you are comfortable with these 2D primitives, it's time for your next exercise: try to draw a smiley face without using your mouse at all. Type in the required commands and specify coordinates by hand; the display grid should be of great help. Oh - for some extra credit, add a hat!
With your drawing in place, it's time to get familiar with several important operators. Figure out how to select one or more objects with your mouse, and then find the commands that perform the following tasks:
Move selected objects by a specified distance in the current viewport,
Duplicate ("clone") an object, likewise,
Rotate object by a specified angle, around a selected point in the viewport,
Flip (or "mirror") selected objects around a specified axis,
Scale object proportionately in all directions, by a specified factor,
Scale object in one direction only,
Form an array of objects by cloning the selection at a given linear interval,
Form a radial (polar) array by cloning the selection at an angular interval.
Play around with these operators until you are comfortable with the way they work; pay special attention to scaling and rotation operators, and the way they are affected by the choice of the origin, reference point, and the viewport.
As soon as you are done moving, flipping, and cloning stuff, locate and play with the analytic tools that let you do the following:
Measure the distance between any two points,
Measure the angle between two straight lines,
Calculate the diameter (or radius) of a circle or an arc,
Find the center point of a circle or an arc,
Show maximum deviation between two similar curves,
Compute the surface area of any closed curve.
This is a good opportunity to experiment with object snaps, too: enable them temporarily, and check the various options they offer. In particular, be sure to give tangent snaps a try: draw three random circles, and then try to connect them with tangent lines, like this:
Piece of cake? Thought so! You should be now ready to master several more complicated modeling skills.
Note: Somewhat surprisingly, 2D drawing techniques are more important than any 3D sketching tools; in fact, you should resist the temptation to play with 3D primitives at this point. The bulk of mechanical modeling work is almost always done with spline curves, which are later converted into 3D objects with the help of operations such as extrusion, revolution, or lofting. We'll get to these operators soon.
Your CAD application probably stores every curve as a non-uniform rational B-spline. The visual representation of this mathematical model is not very easy to grasp, but getting a hang of it is essential to any sort of serious modeling work.
In essence, every NURBS curve is defined by three parameters:
Degree: this parameter defines how many control points will be simultaneously affecting the trajectory of the curve at any given location. Degree 1 curves allow just two points to have a say, with a linear transition between the starting and the destination point (i.e., a straight line). For degree 2 curves, the shape is influenced by three points, allowing it to have smooth bends. With degree 3, the number grows to four, and so on.
Control points: every curve is accompanied by at least
degree + 1
control points, to which it is progressively attracted to along its length. In degree 1
curves, control points simply lie on the curve (at the vertices). For degrees 2 and above,
the points are often positioned outside the curve, forming a sort of an
editable, elastic envelope, as shown below.
Knots: these are the intervals along the length of the curve at which the influence of a previous control point ends, and the influence of a new one begins. Think of it as a way to pace the changes: densely packed knots can result in sharper turns.
Note: it is possible to have multiple subsequent knots at the same location. If the number of knots in a cluster is equal to the degree of the curve, it's called a kink: it effectively forms a barrier that prevents control points on one side to have any influence over the other, and vice versa. This allows the curvature to change aburptly, forming a proper angle. Curves can be losslessly broken into separate segments at such a kink, too.
An example of a degree 2 spline with no kinks is shown below; control points are marked in yellow, and knots are red:
To practice a bit, try to locate the command that lets you draw a curve of a given degree by specifying subsequent control points. Get a hang of its behavior particularly for curve degrees 2 and 3. There should be also a separate command for creating interpolated curves that go through any number of specified "via" points that you click on, which may be useful for tracing around bitmaps and so forth. Oh, one more thing: using both of these tools, try to create a proper kink!
When you are comfortable with drawing, experiment with the following curve-editing tools:
Displaying and moving around control points for an existing curve,
Adding and removing control points, inserting a kink,
Non-uniform refitting, to simplify the curve or remove kinks while maintaining its approximate shape,
Soft-editing a curve by dragging a selected point on its surface,
Displaying curvature and continuity information - can you spot any exising kinks?
Last but not least, be sure to familiarize yourself with the "explode" operator that splits curves at existing kinks (see what it does to a rectangle, circle, etc); and the "join" tool that merges adjacent curve endpoints to form a curve with kinks.
As should be apparent by now, NURBS curves can be separated and joined at kinks in a completely lossless manner: the underlying coefficients do not have to change, and there is no gradual reduction of accuracy if you repeat these operations 100 or 1,000 times.
Unfortunately, in many cases, you will need to truncate curves at locations that do not correspond to any existing kink. In these situations, the CAD application will be usually forced to create a new curve with a different set of control points in the vicinity of the cut. This fitting process usually works very well, and the resulting deviation should be much smaller than your configured tolerance, but you should be aware that the operation does not come completely free.
With that warning in mind, find the command that let you split a curve at a point where it intersects with another one, and experiment with it. For degrees higher than 1, you should be able to see the effect it has on the set of control points for the curve - and if you ask the program to calculate the deviation between the input and the output curve, it will probably give you a tiny but non-zero result. Examine the deviations for a couple of input curves to see what to expect in normal work.
In addition to the curve splitting tool, there may be also a second operator that works roughly the same way, but lets you immediately delete (trim) the unwanted parts. It may sometimes save you a click, so if possible, get familiar with it.
In any case, it's time for a brief exercise. Remember the command for drawing radial arrays? Try to combine that with splitting and trimming to arrive at a result such as this:
Nice, eh? It's not quite a proper gearwheel, but we're pretty close.
Note: as mentioned earlier, it is always preferable to use the simplest editing tools that still do the job. In particular, you should always favor the join, explode, refit, split, and trim operators over any features that, for example, automatically compute unions, differences, or intersections of 3D objects.
Why? Well, these advanced tools quickly go bonkers if you have something as simple as two closely touching, parallel walls - not to mention accidental self-intersections, non-watertight curves or solids, etc. It's one thing if they just fail in an obvious way... but if the resulting error is subtle and goes unnoticed, you may end up having to redo a good chunk of your work later on.
We're almost done with curves - hooray! But before we go, there are three other, immensely useful editing tools that you should probably learn about:
The fillet operator is applied to any angle (kink) on a curve, and replaces it with a specified radius. The trick is often used for engineering purposes: fillets serve as a stress relief in sharp corners and drastically improve their strength. But even more interestingly, filleting lets you capture the real-world result of machining a corner with an end mill of a given size - which is important for certain types of snap fits.
This illustation shows the use of filleting to determine the actual shape of a machined part:
Note: Of course, it's not that you can't make a competent acute angle with a CNC mill. For example, refinishing the one on the left with a 0.4 mm cutter would result in a deviation of barely 0.3 mm. Still, in many cases, it's more convenient to account for such intrinsic fillets in your designs, than it is to refinish the workpiece with a separate tool.
Oh, one more thing: in situations where you don't control the shape of the mating part (lighter blue in the picture below), you can always resort to bone fillets, too:
Chamfering is a similar operation, but it replaces the selected kink with a straight segment that starts at a specified distance from the vertex. Compared to fillets, chamfering may have a more desirable appearance, depending on the effect you are aiming for - and produces a much simpler 3D mesh.
The last operator, offsetting, offers an interesting way to resize any shape: it creates a derived curve that consists of points at a particular, constant distance from the original geometry. It is quite different from traditional scaling, in the same way that gaining weight is different from growing bigger - and it comes quite handy for generating walls, undersizing or oversizing parts, and so forth.
Well, that's really it! You may also want to explore tools that let you extend or close curves, or blend them with more fine-grained controls - but for most intents and purposes, we are ready to talk about something a bit cooler than that.
Let's start building three-dimensional solids. It's simple: draw a closed curve, and then find the command that creates a planar surface from it. Examine the result, then check out what happens if you select two curves, one within another. What about separate or intersecting input curves? Examine failure modes of this operator, too: what if one of the input curves is at a slightly different Z level? What if the curve is open or self-intersects?
Of course, the planar surface that you have just created is still, well, pretty flat. The next important operator to play with is extrusion: select your curve, and using the side view, select the extrusion height. Disable the creation of top and bottom "caps": we just need the side walls. Try to use the join operator to merge the flat base surface with the extruded wall. If it worked, you have pretty much mastered 3D work. Lets try a slightly more complicated exercise:
That's pretty easy, eh? In fact, it's a lot simpler to construct shapes this way than it is to start with 3D primitives, and clumsily piece them together. But don't let it go to your head. Spend a few more minutes playing with extrusion: see what it does to open or self-intersecting curves, to multiple curves that overlap or aren't at the same Z level, and so on.
You should also take this opportunity to experiment with the explode, split, and trim operators that you remember from your curve editing days. Draw two solids and make them overlap, then see if you can use the trim operator to remove all the overlapping internal sections, and join the resulting outer shells into a new, closed shape. Can you do the same to "subtract" one solid from another, or only keep the intersection? Find the analytic tool that lets you calculate the volume of each of the solids, and use it to double-check that your results check out. Oh, one more thing: can you trim surfaces with curves? Why not give it a try!
These tools aside, there are several other advanced surface editing operators that you should be aware of; they are particularly important if you want to create organic shapes without having to think too much:
Curve revolution: this operator lets you draw a surface by taking any curve, and rotating it around a specified axis, and letting it leave a trail in the 3D space. This is the method of choice for creating many simple shapes with axial symmetry - bottles, vases, cans, chess pieces, rings. In fact, try to create each one of these.
Lofting: this mechanism lets you "drape" a surface through a series of curve outlines arranged in the 3D space. Think of it as the opposite of slicing. It comes handy in a variety of situations, including creating draft angles for molds, or adding a handle to a cup. Play with it a bit - it's fun:
Sweeping: this tool lets you select a curve and drag it along a specified rail, generating a surface in the process. It can be seen as a generalized form of curve revolution (in which the rail is always circular). A more advanced version of this operator lets you use multiple rails, which allow variable scaling of the profile curve; or multiple profiles, thus also generalizing the loft operator.
Blending, filleting, chamfering: equivalents of the curve editing tools that let you smoothen the edges of your solids. Blending is particularly useful for creating a smooth, variable-curvature joint:
The list of useful operators goes on - for example, it's sometimes useful to extract edges from surfaces or solids, to place or remove holes, or to orient something on an oddly-shaped surface - but you can discover these on your own. For now, let's just have a quick look at how to manage your work.
It's one thing to sketch a nice 3D box - but any medium-scale project may easily consist of several hundred of such solids, often meshing closely and stacked in creative ways. If you don't manage your virtual workspace well, you will get overwhelmed, make mistakes, or both.
The document management tools at your disposal will vary from one program to another, but you should familiarize yourself with at least the following:
Grouping. This function lets you combine any number of objects into a single logical component that can be moved around and copied as a whole. Unlike trimming and joining, this operator does not require the objects to form a single solid - in fact, you can group completely disjoint things, such as curves, dimensions, and even light sources for the rendered scene. When necessary, the group can be opened, and its contents can be edited separately.
This tool is very useful for conveniently creating serviceable parts from simpler, reusable solids.
Note: some programs go beyond simple grouping, and let you instantiate objects loaded from a separate document. These instances are automatically updated to reflect any changes to the "master" document. I find this to be an overkill in my work, but your mileage may vary.
Assigning to layers. Layers offer a simple way to centrally manage certain properties of objects, such as visibility or color, without merging them into a single blob. All objects or groups that comprise a named layer can be still accessed individually - although you can also select all members of a layer if so desired.
You should use layers to keep track of all instances of any given part, or to denote other important information - for example, that a particular object represents a premade part not meant to be machined, or that it's only a visual aid.
Locking and hiding. Objects or layers that get in the way of editing may be locked. This keeps them at least somewhat visible, but prevents any interaction: you can't accidentally select them or move them around. Hiding is a more radical alternative: it completely removes the affected items from view.
Locking and hiding is typically best applied to layers, as it usually takes just a single click to toggle this parameter in the layer manager. For individual objects, hiding is useful predominantly for items that you are not planning to access again: for example, any construction curves that were already used to create all the solids you needed, but that are worth keeping around just in case you need to redo something later on. To get them back, you will need to activate a special mode that hides all the visible objects, shows all the hidden ones, and lets you select the ones you want to bring back to life.
As soon as you are reasonably comfortable with object management, we can actually make a simple mold!
Okay, it's time for some fun. Let's start by trying to draw a heart:
Here's what's going on in that illustration:
We draw a helper rectangle as a guide for the overall size of the part. This one is 23 mm wide and 20 mm tall. We then use object snaps to draw a vertical line through the middle of the part, which will be our axis of symmetry.
Once the guides are sketched out, we add a 13 mm circle (slightly larger than half the rectangle), and align it with the edges of the box. You can use grid snaps for that.
We draw an arc using object snaps. The beginning of the arc is tangent to the existing circle, the end is at the bottom of the center guide, and the diameter is manually entered as about 110 mm.
We mirror the circle and the arc around the axis of symmetry. At this point, the symmetry guide is no longer necessary, so we delete it.
We use the trim operator to remove the internal parts of the heart, and then delete the outer rectangle.
Voila! Easy, right? Now, let's join all the curve segments, and turn the whole thing into a mold:
See if you can figure out all the steps on your own. The final result should be
a watertight box with dimensions around 33 x 30 x 8 cm. Its bottom left corner
should be at coordinates
(0, 0), and the top surface should be at
0 mm, likewise. The mold cavity should have a 4 mm clearance around the heart,
and should be 7 mm deep. The heart itself should be resting at the bottom of the
cavity, and should be 4 mm high (its top surface should be at -3 mm).
If everything checks out - well, the good news is that you have yourself a master mold (aka a pattern). Now, we cut some corners with the moldmaking process, given the simplicity of this project, but this is how the entire thing usually plays out:
Be sure to save that project - we'll need this file soon.
CAM software reads the geometry created with your favorite modeling application, and turns it into toolpaths that can be sent to a milling machine, a 3D printer, or some other automated tool. All the computer-controlled manufacturing technologies use a common set of underlying concepts and have a comparable degree of complexity, but there are many details that remain specific to a particular tool. Since we have to choose one way or the other, the rest of this chapter will focus on the software designed for CNC mills.
When I first published the original version of this guide, the makers of CAM applications catered almost exclusively to commercial users. The software was ridiculously overpriced, shipped with archaic UIs, and always included a collection of mind-boggling bugs. Thankfully, the emergence of low-cost mills and serious hobbyists is slowly changing that. Still, there is no single package that would be a sure bet for all users, and you need to understand what sets them apart. Here's a quick list of the things that matter the most for everyday CNC work.
If you own a computer-controlled rotary axis, or plan on getting one, you should figure out which 4-axis machining modes are supported by the program - and decide if they are worth the extra price. The three fundamental choices are:
Indexed cutting (XYZ): in this mode, every milling job is handled using traditional, planar three-axis movements. The only new trick is that the program will automatically rotate the workpiece (and the CAD model itself) in between jobs, letting you machine the part from multiple sides with no extra leg work.
This rudimentary approach is probably the most useful one, particularly for engineering work. It works great on geometries that have a small number of distinct, planar faces - for example, a two-sided PCB, a nut, or a rectangular enclosure.
Interestingly, indexed cutting is actually fairly easy to simulate by creating several CAD files with the same part rotated by the desired degree, generating toolpaths for each of these files, and then sending them to the mill and rotating the part in between. It takes a bit more time, and there's a higher risk of human error - but it's up to you to decide if the extra convenience is worth spending several hundred bucks extra on your CAM tool.
Lathe-type machining (AXZ): in this mode, the Y axis is kept in a fixed position, so that the tool hovers directly over the axis of rotation, or stays at a predefined offset. The workpiece is turning continuously as the milling head is moving up, down, and to the sides. If you haven't seen a lathe in action, this video should clarify what's going on.
Such an approach allows efficient reproduction of smooth, cylindrical shapes that would require indexed cuts from 6 or more sides to approximate the shape by traditional means. Examples may include threaded shafts, worm gears, soda bottles, or rings.
Unlike the previous mode, this one can't be trivially approximated in a program that doesn't support it natively; but it's also not nearly as essential, not unless you're planning to work on jewelry or other artistic stuff.
Fully simultaneous four axis machining (AXYZ): in this mode, the machine is free to move in all four axes while cutting, and the application analyzes the geometry to find the right balance between lathe-like and planar movements.
This may result in more efficient machining of complex surfaces with variable curvature or hard-to-reach undercuts - but it's seldom of any use to begin with, and it can be approximated by alternating between the two techniques mentioned earlier; the extra cost is difficult to justify in hobbyist work.
What to buy: your call. If indexed cutting is all you need, you may be able to live with lower-cost three-axis CAM.
Vendors of CAM software tend to be pretty creative about the range of specialized and obscure machining modes that they offer, but there are only three options that really matter; the rest is either redundant, or doesn't work well in complex molds.
Here are the three methods in question; the first two really must be supported by the application you want to go with:
Overhead projection: this method amounts to projecting a simple surface-filling pattern onto the workpiece, from the top. In the most basic case, the pattern may be just a bunch of evenly spaced parallel lines, connected together on alternating ends. The tool then follows these lines in the X-Y plane (X-A for lathe-style machining), and is lowered or raised as necessary to reproduce the shape of the part:
Such a computationally inexpensive approach is particularly efficient when machining flat regions or very gentle slopes with a flat tip cutter; in this case, the spacing between projected lines (stepover) may be comparable to the diameter of the tool, and still produce excellent surface finish.
Alas, the strategy is a bit less suitable as soon as the cutter gets near any
vertical surfaces. If the wall is in a direction perpendicular to the toolpath,
the process will leave scallops of uncut material, as shown above; the height of the
scallop is equal to
cutter_radius - sqrt(4 * cutter_radius² - stepover²) / 2.
Walls that happen to be parallel to the direction of the cut will acquire a better
finish, but the process may leave a layer of uncut material, up to
stepover thick. Walls at other angles will get a combination of both
Note: both of these issues can be remedied to some extent without switching to a more advanced machining strategy. Scallop height can be managed with modest changes to stepover - for example, when using a 3 mm tool, changing stepover from 2 mm to 0.5 mm reduces scallop from 0.38 mm to 0.02 mm - that's a 20-fold improvement at the expense of slowing down by a factor of four.
The other problem - with the accuracy of parallel walls - can be fixed by doing a second pass using lines projected at a different angle, so that the cut is no longer parallel in the previously affected area. Of course, the situation gets a lot trickier if you have walls at many different angles, or worse yet, any arcs.
Good CAM software be able to not only generate linear projections, but also "offset" patterns that are constructed from an arbitrary outline provided by the user. This has some important benefits that we'll talk about soon; the end result looks kind of like this:
Z axis slicing: also known as waterline cutting, this machining strategy starts by creating a stack of horizontal surfaces, evenly spaced in the Z axis. Each of these surfaces intersects the CAD model, and every such intersection results in a number of closed, two-dimensional outlines of the part. These outlines can be then offset for the size of the tool, checked for collisions, connected together, and used as a toolpath:
This mode allows for faithful and highly efficient reproduction of intricate vertical features, such as spur gears. On the flip side, it does not do anything useful for horizontal surfaces; and produces staircase patterns on sloped surfaces, unless the spacing of Z levels is unreasonably tight - as seen above.
On top of the basic mode with a constant Z step, some of the more expensive CAM programs allow you to automatically detect and optimize the spacing of Z levels based on the geometry of the part. That sounds nice in principle, but I could never get this feature to work in a sensible and consistent way in any of the programs I have tried.
3D draping: this method generates a toolpath that always maintains a particular distance between cuts, or keeps a particular scallop size, regardless of the shape of the machined part; this is somewhat akin to printing linear toolpaths on a piece of fabric, and then laying it over the geometry to be reproduced.
This strategy can be a significant time saver when working with organic shapes using ball tip tools, but it is not commonly useful in everyday mechanical work.
What to buy: the two first strategies must be supported unconditionally, and should come with no strings attached: you should have full control over how they are used and when. The third one is a plus. Advanced features of these modes, and other toolpath generation methods, matter a lot less.
Efficient machining of complex models requires the ability to decide which tool and which strategy will be applied to various regions of the model - and in what order. To facilitate this process, your CAM application should let you define a freeform region for every machining operation, either by selecting an existing boundary curve imported alongside with the 3D model - or by drawing something by hand. It should let you exclude regions within an existing selection by picking a second curve inside the first one, too.
These capabilities are pretty much all that matters. You may notice that certain programs have the ability to automatically generate selections based on some property of the model - for example, to only machine flat surfaces, vertical walls, or something in between. These features are sometimes nice, but are usually more limited or less reliable than what you can do in CAD - so don't pay any special attention to this.
What else? Oh - several programs offer "residual machining" of regions left over after the previous operation with a larger tool. This sounds great in theory, but is typically both fairly coarse and extremely slow; I tried two applications that supported this feature, and it misbehaved or ran out of memory more often than it proved to be useful.
What to buy: curve-based selection is a must. Pay little or no attention to the rest.
Some CAM applications do not put any special thought into organizing the toolpath segments that are spewed out by the underlying geometry-analyzing algorithm. Depending on your model, the result of that can be pretty inefficient; for example, a waterline cut that sequentially machines every outline on every layer before moving further down will produce a total of 15 operations when machining these two separate holes (left):
The image on the right shows a more sensible ordering: instead of going back and forth between the machined regions, finish one first, and then move to the other. The result is 9 operations, consisting mostly of short movements. Quite a few programs are capable of such common-sense optimizations - but not all.
What to buy: it is useful to shop for CAM applications that offer cut optimization, especially for waterline machining. It's not an essential feature, but it's a major time saver. If in doubt, consult the manuals or ask the vendor before buying.
G-code - the language supported by most of the CNC machines on the market - has several commands that can be used to execute circular, spiral, or helical movements of the tool. While support for these opcodes is not required, quite a few embedded controllers recognize them, and translate them to motion optimized for the hardware they are hooked up to.
CAM programs, however, usually convert input files to polygon meshes, and generate toolpaths where arcs are broken into thousands of small, linear movements. This practice is not just a waste of electrons, but may result in lower machining speeds, because it hinders the ability for the controller to plan ahead and pick the best acceleration and braking strategy. Perhaps more annoying is that if the pitch of the generated 3D mesh doesn't overlap with the hardware resolution of the motors in your CNC mill, needless vibration may be introduced, too.
What to buy: If your machine supports arc interpolation, it is good for the CAM program to know how to generate G-code that leverages that. It's not a deal-breaker, but something really nice to have.
There are some brief moments in the cutting process where the tool may be pluging head-on into uncut material. Most of the time, though, the tool simply works to widen existing pockets, and engages the material one side at a time. There are two principal configurations possible during that task:
In the conventional (aka upcut) mode, contact with the workpiece is made on the left side of the tool, in relation to the direction of movement. Toolpaths generated this way allow the material to be engaged very gradually, starting with a near-zero chip load, and ramping it up. This strategy is less dependent on the rigidity of the tool and the workpiece, and results in superior dimensional accuracy and surface finish with rigid plastics and many other types of easily machinable materials.
In the climb (downcut) mode, the orientation of the tool in relation to the workpiece is reversed, and every flute plunges into the material to start at the maximum chip load, and then have it taper off. This approach puts greater strain on the tool - and if the tool or the workpiece deflects, it reduces the dimensional accuracy of the final part. That said, it may offer better cutting speeds or improved surface finish in certain annoying materials - such as metal alloys prone to work hardening, or soft, malleable thermoplastics.
In waterline cutting, maintaining a specific direction of cuts comes naturally, and at no extra cost; in fact, it takes special effort to alternate the type of cut between each layer. Overhead projection strategies are more problematic: if the projected pattern is just a bunch of parallel lines, the only way to achieve consistent direction is to cut the first line, raise the tool, move back to the starting side, lower the tool, and make the next cut - in short, there's a lot of non-cutting movements. And that's the major advantage of "offset", spiral-like projections that we have mentioned earlier on: they permit the direction to be maintained without having to raise the tool.
What to buy: you should make sure that the software gives you full control over the direction of cut for every machining strategy of note. Not having this ability will make your life miserable, especially when working with miniature, long-reach tools that flex easily.
Last but not least, the application you end up choosing needs to support the file formats that can be written by your CAD package. The most common interchange formats include IGES and STEP (both of which are vendor-agnostic); DXF and DWF (originating with AutoCAD); 3DM (Rhino3D); and STL (3D Systems); support for at least one of these is good news - and the more, the better. NURBS surfaces are supported natively in all of these except for STL and DXF, where approximate tessellation may be required.
Input formats aside, you also need to confirm that the application actually supports your CNC mill, and can generate suitable output files. If your machine speaks G-code, and the application offers the ability to create custom G-code postprocessors, you may be able to find a third-party converter or write your own one with relatively little effort; otherwise, you need to make sure that the mill is supported out of the box.
Here's a short and incomplete list of things that tend to appear in product specifications and may seem important, but typically don't matter much:
2.5D machining strategies: these features are used to convert bitmaps and other 2D input data into engravings, simple cutouts, etc. They are truly useful only if you don't have a CAD application to begin with, which obviously won't be the case.
Support for drilling, tapping, boring, and so on: when working in plastics, it makes virtually no sense to buy specialized tools and use exotic toolpaths to make holes and perform similar tasks; end mills, operated the usual way, will almost always do.
Manual toolpath editing: this ability may be useful for very simple models, where the toolpaths are trivial, and fixing them by hand may be a convenient alternative to reworking the model. Toolpaths in complex molds are nearly impenetrable, though.
Visualization support: the ability to simulate the machining process is a nice addition, especially when making your baby steps with CAM, or when dealing with buggy software - but ultimately, it's not worth the extra price. Once you work out a sensible machining workflow, the results are almost always easy to predict.
Collision detection: this lets you prevent cuts where the tool taper or collet holder would hit the workpiece, because you miscalculated the reach of the tool. This is useful chiefly if you have a machine with an automatic tool changer; otherwise, adjusting collision detection settings after every tool change is about as problematic as configuring the toolpath correctly to begin with.
Support for workpiece approach methods: center-cutting tools can work as drills, but aren't particularly competent in this role; plunging them directly into tough materials may reduce their life expectancy quite a bit, especially if the cutter has a flat tip. This can be solved by generating toolpaths where the tool enters at an angle - that said, for easily machinable plastics, it's pretty much a non-issue.
Cutting wizards, libraries of materials, etc: while these seem cool, they are generally tailored at simple industrial applications or other beginner work. Configuring the parameters manually is almost always a safer bet.
Drawing, part editing, and analysis tools: having these capabilities available in a CAM package is useful only if you don't have them in your CAD application - but that, again, shouldn't be the case here.
Of course, feel free to ping me if you stumbled upon any other cool-sounding feature, and need help figuring out what it's worth.
Well, it's complicated. For starters, your CNC machine may come with a basic CAM application, and that package may turn out to be good enough for starter jobs. For example, Modela Player 4 - the application that comes with Roland mills - is pretty decent. That said, in the long haul, you will probably want to upgrade to something more featured and flexible.
Somewhat lamentably, there aren't that many free-of-charge applications that would be easy to use yet powerful enough; FreeMill is one potential choice, but it only supports a single, rudimentary machining strategy - and really, isn't worth much.
This leaves you with commercial tools. If you are on a tight budget, you may want to check out MeshCAM ($200), which is actually a very competent package with good technical support. Other alternatives within that price range include Cut 3D, or the hobby license for DeskProto. I have tried both DeskProto and MeshCAM, and both of them are pretty good - so these would be my top picks.
Other than that, there are quite a few other reputable choices with prices hovering around $1,000 and more. The pricing in the "pro" segment, especially for more featured packages with 4-axis machining, is still rooted in the era of strictly-industrial CNC - but deep discounts are available to students, and sometimes, to those who buy the software along with the mill itself. Notable applications in this category include VisualMILL / RhinoCAM, Alibre CAM Mayka, madCAM, and quite a few more. If money is no object, or if you can get a good discount, you may want to dig deeper. If you need advice, I've seen VisualMILL in action, and it looked pretty good.
Tip: many of the commercial packages have demo versions. These demos are either limited to a 30-day trial, or lack the ability to write G-code, but are otherwise fully-featured - so be sure to check them out before you buy.
CAM programs can be counterintuitive; you will probably need to read the manual carefully to even understand how to create a toolpath, or write the resulting NC file. These applications are also often finicky, unforgiving, and buggy - so it's important to take it slow, and check everything twice.
Before loading your 3D models, you need to configure the software for your particular machine, either by selecting the appropriate postprocessor, or - in the worst case - by writing your own based on an existing config file for a similar mill (not as scary as it sounds, as long as your machine came with a code reference manual). You should also go through all the configuration options, and make sure that units are set to millimeters, that the tolerance is 1 µm or better, that arc interpolation is enabled if supported by your hardware, and that the G-code coordinate system is set to G54 (the first, default user-configurable coordinate system, and the only one you will be using in hobby work).
With this out of the way, you should load the geometry to be cut. Let's use the heart-shaped mold created earlier on; if you need to export it from your CAD application to a mesh-based format, such as DXF or STL, be sure to configure meshing tolerance to 1 µm or better for that step, too, as this setting is often separate from the global value.
Once the model is loaded, you need to verify its position. For three-axis work,
the mold cavity should be facing up, and the top surface should be aligned with the
Z=0 plane in the CAM application; when looking from the top, the bottom
left corner of the mold needs to be at
If it wasn't loaded this way, you can move or rotate it as needed,
but also try to figure out what went wrong: is your original CAD model oriented correctly?
If that's not the reason, is there a CAM-level option you should have toggled at import time?
Well, all right. Once the model is in the right spot, it's time to create some toolpaths next.
To maintain sanity, it helps to split the cutting process into several phases. Each of these phases accomplishes a different task, and may use a different tool, feed speed, machining strategy, stepover distance, and so forth. The first phase of almost every project is known roughing; its goal is to remove the bulk of the material as efficiently as possible. Of course, astute readers may ask why this isn't also the final step - and the answer is that, quite simply, heavy chip loads and rapid tool speeds offer limited accuracy; it's better to leave a small margin of uncut material, and refinish the surface in a separate process later on.
The usual roughing strategy is a hybrid approach where the model is cut in Z layers, and on every layer, the application first uses a pattern of horizontal movements to clear the pockets, and then performs a waterline-type cleanup pass. Once the first level is done, the toolpath advances to the next one:
In some applications, roughing may not include that cleanup pass, in which case, you should probably configure a separate waterline step right after roughing. This is to ensure that the margin of remaining material is reasonably uniform, so that chip loads don't fluctuate wildly later on.
Tip: good CAM applications let you use pocket-shaped offset cuts, rather than linear movements; this completely eliminates the need for the waterline cleanup pass. If that mode is offered by your software, take advantage of it - it will speed up the process and also let you maintain a consistent direction of cuts.
In any case, for the materials used in this guide, you should configure the roughing process the following way:
Tool size: use a 3 mm or 1/8" flat tip cutter, but lie to the application and give it a diameter about 15% higher (say, 3.5 mm). This will cause the toolpath to be slightly farther away from the workpiece than actually makes sense for the tool - thus creating a margin for roughing in the X-Y plane.
Tool length offset: tell the program to pretend that the tool is about 5% of tool diameter longer than set on the machine (effectively moving the toolpath up). This introduces a similar margin in the Z axis. (If not supported by the application, you can make this adjustment simply by setting Z origin a bit higher than measured.)
Roughing margin: set to zero. Using tool size and length offset is usually more intuitive, especially for toolpaths where you want to have an offset only in a specific direction.
Stepover: something between 30% and 50% of tool diameter should do. You can ramp it up even higher, but there's no real need to do so in this case.
Z level spacing: set to 1 mm. Especially if the value is high, it should at least vaguely correspond to the spacing of key features of the mold in the Z axis.
Tolerance / sampling resolution: for roughing, can be safely set to around 0.01 mm or so, to reduce processing time.
Machining speed: use maximum spindle RPM; feed per tooth should be about 0.08 mm (i.e., 2,000 mm/min with four flutes at 6,000 RPM).
Cut direction: when using offset cuts, use conventional cutting with the tool first engaging at the center of each pocket. When using linear cuts, set to bidirectional (meander) mode. No special approach strategy required.
Machining region: set so that the cutter stays completely within the envelope of our mold, and does not attempt to trace around it. Note that depending on your CAM application, selection regions may work in one of three ways:
Tool fully inside: the cutter
must stay completely within the bounds of the selection. Nothing that lies outside the
region will be machined. Protrusions that lie within the selected area, but
are closer than
tool_diameter to the boundary, will not be fully
profiled, as the tool won't be able to pass between them and the limiting curve.
Tool center inside: the center point of the end mill
is required to stay inside the selection, but the tool itself can stick out slightly.
Features up to
tool_diameter / 2 away from the selection can be
machined by the tool if necessary. Protrusions within the selection must be at least
that far from the boundary to be fully profiled.
Tool touches selection: the tool is free to roam anywhere
as long as any point of its geometry stays within the selected region. In this mode,
tool_diameter from the boundary may be machined. Everything
within the selection is cut.
It doesn't really matter which selection philosophy the application happens to use, as long as you are aware of its behavior, and can plan accordingly. If you are still not sure what's going on, check out this image; teal denotes the desired geometry, the selection rectangle is cyan, and the remaining unwanted material is red:
Well, that's pretty much it. Once the roughing operation is set up, simply tell the program to calculate the toolpath, and examine the result closely. Make sure that it actually makes sense: is the tool staying within our virtual workpiece? Do the toolpaths look anything like what we discussed before? If the program can give you estimated machining time, is it less than 10 minutes or so?
If everything checks out, congratulations; now, let's finish this thing.
Finishing toolpaths typically refine the geometry in several consecutive steps:
The vertical (Z axis) margin on flat surfaces is removed using a projection toolpath that has a zero tool height offset, but preserves the original tool diameter offset from the roughing process.
The X-Y plane margin around vertical features is removed using properly spaced waterline cuts, configured with the true diameter of the tool.
If there are any sloped surfaces, they are locally refinished using a tightly spaced projection toolpath or 3D draping, possibly with a ball end tool (this is not applicable to our model).
If there are any holes or tight pockets that couldn't be faithfully reproduced with the current cutter, they are selectively refinished with a smaller one.
To take care of the first item on this list, you'd normally want to configure an offset-type, projection finishing toolpath with the following parameters:
Tool size: about 2-5% higher than the value used for roughing (3.6 mm or so).
Tool length offset and margin: both set to zero.
Stepover: not critical; 1 mm is a safe bet.
Tolerance / sampling resolution: 0.5 µm or so.
Machining speed: maximum RPM; feed speed should be about 0.05 mm per tooth (i.e., 1,500 mm/min with four flutes at 6,000 RPM).
Cut direction: conventional if using offset cuts. Otherwise, for parallel toolpaths, use bidirectional cutting mode to save time.
Machining region: restrict to the inside of the mold cavity. Make sure that the generated toolpath doesn't climb the sides of the cavity, as this would be a no-op.
This step cleans up the flats; now, we need to take care of the walls. This is done with a "pure" waterline toolpath that traces around vertical shapes, and does nothing more. The parameters for this step should be:
Tool size: enter the actual, measured diameter of the tool. It's good hygiene to include TIR, if known.
Z distance: set to 0.5 mm. In general, this must coincide with the spacing of vertical features of the mold, and shouldn't be too large (to avoid high chip loads). Any features that are not aligned with this parameter may need to be refinished separately.
Machining region: restrict to the inside of the pocket. This time, make sure that the outer walls of the pocket will be machined.
Starting height: 0 mm. Always double-check this parameter for waterline toolpaths, as rouding errors may sometimes prompt the CAM application to default to something dubious.
Everything else should be the same as for the previous step.
Well, that's almost it. After this toolpath, the heart should be looking pretty much the way we designed it - with just one minor blemish: center kink in the middle of the heart will have a slight fillet on the top, due to our relatively large 3 mm tool not being able to fully squeeze into that tight spot. To fix this problem, we can perform a selective waterline cut with a 1 mm end mill. Most of the parameters don't change from step #2, except:
Tool size: enter the actual, TIR-compensated diameter of the new tool.
Z distance: use 0.25 mm.
Speed: maximum RPM, feed of around 0.035 mm per tooth should be fine (that's around 450 mm/min with two flutes at 6,000 RPM).
Machining region: make a rectangular or circular selection extending a few millimeters around the problematic kink.
And... well, that's it! Generate the toolpaths and pat yourself on the back.
For future reference: here's the list of maximum recommended cutting parameters for the tools you should have bought. These values are applicable only to several classes easily machinable prototyping materials that we're going to talk about soon - when working in more demanding stock, you will need to slow down:
0.4 mm: feed 0.01 mm/tooth, 0.125 mm cut depth, 0.125 mm stepover,
1 mm: feed 0.035 mm/tooth, 0.25 mm cut depth, 0.4 mm stepover,
3 mm: feed 0.1 mm/tooth, 1 mm cut depth, 2 mm stepover,
6 mm: feed 0.2 mm/tooth, 3 mm cut depth, 5 mm stepover.
Speeds reduced by 20-40% are recommended for finishing operations, especially with 3 mm and 6 mm tools.
Measure twice, cut once. Before sending any data to the machine, it's always good to recheck your work; 5 minutes of that may save you several hours of troubleshooting in the physical realm. Here are some questions to ask yourself:
Have you entered all the values correctly? Confirm tool diameters, stepover, Z distance, and feed speeds. A missing zero or a misplaced decimal point can cost you $20 for a broken tool.
Do the toolpaths look OK? Anything that seems weird, suboptimal, or that exits the expected machining envelope? Any places where the toolpath seems to go straight through the geometry? Run a simulation if possible, and inspect the model from all sides.
Have you covered everything that needs machining? Are there any spots where toolpaths do not reach, even though you wanted them to? For selective refinishing, have you selected all the regions you wanted to clean up? It's embarrassing to miss a spot.
Is there any risk of collisions? Are the toolpaths suitable, given the reach of the tools you are going to use? Are all the traverse movements happening well above the workpiece? Several CAM programs make it easy to misconfigure this, and plunge through an essential part of your work.
Try to use that checklist until you are reasonably comfortable with the process; it's not that mistakes are common, but they can strike at inopportune times.
If everything checks out, you need to get the toolpaths ready for cutting. In some programs (e.g., Modela Player), the output is done directly from the application - in which case, just sit tight. In many other apps, the data is written to a text file, and that file is then sent to the machine using a separate CNC utility; if so, export ("post") the toolpaths now. Of course, remember to save the toolpath for the 1 mm tool in a separate file!
Okay, okay - but first, you need a suitable workpiece. We will cover more permanent options shortly, but for your initial tests, I strongly recommend getting something called machinable wax. It is a hard, rigid, wax-like substance, technically a blend of low-density polyethylene (LDPE) and paraffin. It is not the cheapest or most durable stock, but has two important properties: it machines quickly to a very good finish with excellent dimensional accuracy; and more importantly, because it's much softer and more fragile than common plastics, even fairly major mistakes won't immediately result in a broken tool.
In the States, the material is available cheaply from the folks at MachinableWax.com. I would suggest ordering their set #17-424215 (featured on this page). It's a box of 12 pieces, 42 x 42 x 15 mm, selling for $21. Don't overdo it - this really isn't the best or or the most cost-efficient material for real work, so get just a single box or two.
The only other thing you need in advance is a way to secure the wax to the milling table. Your mill may have come with some sort of a clamping system, or at least slots or screw holes that let you rig something together after a quick trip to the hardware store. Alternatively, you may want to consider MWHS01 from High Tech Systems ($100), which is a very versatile and lightweight system of clamps that should work for almost any medium or large CNC mill. That said, when working with easily machinable materials and using small tools, you can also get away with strong, thin double-sided tape, such as 3M 444 or Tesa 4965. Simply place four short strips in the corners of the workpiece, and press it down; then lift one of the corners to detach.
Assuming you have all the necessary supplies, we can mount the workpiece at this point. Wipe clean the table and the stock material, apply the double-sided tape as described earlier, and attach the workpiece to the table, making sure that it's entirely within the working area of the mill. Depending on the design of the machine and the length of the tool, you may need to put something underneath the workpiece to allow the cutter to reach it, too.
Next, confirm that the workpiece is actually attached securely, and install your 3 mm tool in the collet. Tighten the tool holder, quickly confirm the TIR, and make sure that there is some clearance between the tool and the top of the workpiece when the spindle is fully retracted. Assuming everything is fine, you can now turn on the mill and let it initialize.
Caution: I am assuming that, as requested earlier on, you have familiarized yourself with the operating manual of your mill, and with the safety tips information included in section 7 of this guide. As with any power tool, you can get hurt if you are careless.
For G-code mills, the next step is to set the coordinate system to G54, then move the tool to align it with the bottom left corner of the workpiece (looking from the top), plus about 5 mm. With the tool at this X-Y location, tell the machine to set its X and Y origins; this is done in a hardware-specific fashion.
Setting the Z origin is the last hurdle to deal with. Find a convenient location on the workpiece, in a region that won't be removed in the cutting process. If the machine has a tool sensor, simply place it underneath the tool, and follow the manual to perform the measurement. Without a sensor, you can use the trick we talked about earlier on: place a thin strip of paper or foil on top of the workpiece, and wiggle it back and forth while lowering the tool; use increments of 0.05 mm when you are close, and stop the moment the tool pinches the foil. Set the Z origin in that location; oh, and try not to pinch your hand instead!
Done? Well, in that case, it's time to put on safety glasses, then hit "send" and output the 3 mm roughing and finishing toolpaths to the machine. With any luck, several minutes later, the machining process should be wrapped up. Vacuum off a bit and inspect the result; is the shape in line with what we're expecting? If yes, let's fix the kink: install the 1 mm tool, check TIR, redo the tool height measurement (very important), and hit "send" to output the remaining toolpath on your list.
In case you are wondering, there are very few things that can go wrong with the cutting process itself, and all of them should be fairly self-explanatory. For example, if the machine starts cutting at an unexpected location, or too high / too low in relation to the workpiece, you probably messed up setting the origins, selecting the right coordinate system, or had the CAM model positioned incorrectly. Similarly, if the tool breaks while cutting in the expected location, this is probably due to grossly incorrect RPM, feed speed, or cut-in depth; or bad ordering of toolpaths. But chances are, you won't run into any issues just yet, so sit back and relax!
Note: as hinted earlier, for more complex jobs, it's useful to keep the roughing end mill and the finishing cutter separate, even if both processes call for the same diameter of the tool. This way, you don't have to worry about the loss of micron-scale accuracy as the roughing end mill begins to wear - and you will be able to use both tools for a lot longer.
As soon as you're done, detach the mold and vacuum in thoroughly. Machinable wax sometimes requires a gentle but firm cleaning with a brush and a touch of compressed air to get rid of the somewhat sticky chips - so do that, and then have a closer look. Is the surface silk smooth? Do you see any pronounced tool marks or gouges on vertical surfaces? What about horizontal ones? Do the dimensions check out when you use a caliper? (In more complex projects, pin gage sets are useful for measuring the diameter of small holes, too.)
Chances are, you're in good shape - but if anything is even slightly wrong, now would be the right time to track the problem down; don't wait until you're working on more time-consuming projects, or in less forgiving materials. Here are several causes of the problems you are most likely to see:
Tool ploughing through an essential part of the geometry: this may be due to poorly configured toolpaths; failure to adjust Z origin after tool change; axis stepper motor overload in open-loop machines; or sending a cutting job while the tool is positioned below the top of the workpiece (not all CAM applications prefix the generated toolpath with an instruction to retract the cutter). Double-check that the workpiece is still properly attached, too.
Significant dimensional inaccuracy: this is usually caused by incorrectly specified tool diameter, excessive TIR, misaligned spindle axis, incorrectly secured workpiece, or poor mill calibration. The last problem will be directly proportional to the size of the machined feature, and if so, can be measured and compensated for in software.
Substantial tool marks or gouges: these defects are typically due to high TIR, excessive speeds, or high chip loads during finishing (e.g., due to incorrect choice of toolpaths).
Very poor overall appearance of the mold: this may be due to unsuitable stock material (e.g., certain types of soft, malleable thermoplastics); using a bent or chipped tool; using a drill instead of an end mill; or having the workpiece partly detach from the table in the middle of the cutting job.
Still, in all likelihood, the result will be fine. If that's the case, let's wrap up by reviewing some common-sense rules that come handy in mold design, just so that you are well-equipped to work on your next CNC project - and then, let's cast a mold.
There are relatively few real constraints on what you can cut on your milling machine, but there are several simple design strategies you should follow to keep the cutting process simple and quick, and make accurate, durable, and dimensionally accurate molds. Here's the gist of it:
To speed up toolpath calculations, always choose straight lines over arcs when you can. For example, you may want to opt for simple, manually drawn shapes for mold cavities, or use chamfering instead of filleting to provide reliefs in places where aesthetics do not matter. This keeps the resulting 3D mesh a lot simpler, and can dramatically improve the speed of CAM work.
To simplify the cutting process, it's good to maintain a reasonably consistent margin between each of the parts inside the mold, and between parts and the walls of the mold cavity. Use a distance that is slightly higher than the diameter of the tool entered for the roughing process.
To help with waterline cutting, it's useful to align most of the vertical features present in the mold to 0.5 mm or so. This minimizes the need for selective remachining of individual parts.
When dealing with parts of vastly different part heights, it may be desirable to create several separate mold cavities, instead of trying to cram everything into a single one. Using a shallow cavity for all the small parts will often save you time and materials.
It's preferable to avoid holes and slots that have a size exactly matching the diameter of the tool that will be used to cut them; due to rounding errors, such situations can confuse your CAM software, and make it hard to generate a valid toolpath. Allowing at least 1% wiggle room is a good idea.
Any small, deep holes that reach the very bottom of the master pattern should have their depth reduced by about 0.1 mm. This eliminates the risk that the resulting protrusion of the flexible negative mold will rub against the top cover used in the casting process, and deflect. The resulting 0.1 mm film is very easy to remove from the final part.
You need to allow some headroom between the top of the mold cavity, and the top of the tallest part laid out on the inside; this forms the bottom surface of the resulting negative mold. Allowance of around 2-3 mm is usually OK.
Deep molds (over 10-15 mm or so) benefit from draft angles on their outer walls (a slight slant, created using the offset and loft operators). Introducing several 5 mm deep pull tabs on the edges of the mold may be helpful, too.
Large-volume parts should use molds that are scaled up accordingly, and have more generous margins and headroom, to support the weight of the resin and the mold itself.
Well, that's it. It may sound overwhelming, but once you catch a whiff of it, even remarkably complex multi-part molds are fairly easy to crank out. We'll cover this and several other advanced design topics later on - but for now, let's have some fun with polymers!
Click to proceed to chapter 4...