Tag: CNC

Having recently converted to EMC 2.4 and switched the tool table to the new format, I took the opportunity to add a few useful drills.

Low numbers are random end mills & suchlike. Number drills run from 100 to 180, and I’ll add more as I need ’em. Fraction drills run from 201 through 264, although it’s highly unlikely I’ll ever fit a 64/64-inch drill in a chuck that also fits in the Sherline spindle.

All the Z lengths are exactly 1, because I now have a tool length probe that is absolutely wonderful.

In practice, I use the tool table mostly to tell Axis how to draw the tool cylinder in the backplot, because I feed in most diameters directly in the G-Code. The Axis “manual toolchanger” routine prompt will now serve as a mnemonic for the actual size, but I write the G-Code to emit a (debug, #Drill_Size) message for clarity.

The  Sherline.ini file references the tool table with the line:

 TOOL_TABLE = Sherline.tbl

Herewith, Sherline.tbl:

; Common end mills
T1 P1 Z1 D0.1225    ; 1/8
T2 P2 Z1 D0.1535    ; 5/32
T3 P3 Z1 D0.187        ; 3/16
T4 P4 Z1 D0.25        ; 1/4
T5 P5 Z1 D0.3122    ; 5/16
T6 P6 Z1 D0.374        ; 3/8
T7 P7 Z1 D0.4374    ; 7/16
T8 P8 Z1 D0.4720    ; 1/2
T20 P20 Z1 D0.09787 ;  2 mm
; Number drills
T107 P107 Z1 D0.201 ;  7     5.11    10-32 clear
T109 P109 Z1 D0.196 ;  9     4.98    10-32 clear
T118 P118 Z1 D0.170 ; 18     4.32     8-32 clear
T121 P121 Z1 D0.159 ; 21     4.04    10-32 tap
T127 P127 Z1 D0.144 ; 27     3.66     6-32 clear
T129 P129 Z1 D0.136 ; 29     3.45     8-32 tap
T136 P136 Z1 D0.107 ; 36     2.72     6-32 tap
T132 P132 Z1 D0.116 ; 32     2.95     4-40 clear
T143 P143 Z1 D0.089 ; 43     2.26     4-40 tap
T141 P141 Z1 D0.096    ; 41     2.44     2-56 clear
T148 P148 Z1 D0.076 ; 48     1.93     1-72 clear
T150 P150 Z1 D0.070    ; 50     1.78     2-56 tap 0-80 clear
T152 P152 Z1 D0.064 ; 52     1.63     0-80 clear
T153 P153 Z1 D0.060 ; 53     1.52     1-72 tap
; Letter drills
T203 P203 Z1 D0.047 ;  3/64     1.2     0-80 tap

It turns out that the tool table has an undocumented limit of 50-some-odd entries, at least in EMC2 2.4.1. That puts the kibosh on my plans to add a bunch of entries to cover all the drill sizes Eagle might require for a PCB. More on that in a while …

My buddy Eks once observed that knurling is something you want to do on somebody else’s lathe, because it puts so much stress on the bearings. As it happens, both Home Shop Machinist and Machinist’s Workshop have run several articles / series on improved knurling, ranging from better clamp knurling tools to a wonderful widget that turns your lathe into something like a shaper with a rotary axis.

I wondered if a touch of G-Code could do the same thing on my Sherline CNC milling machine, using an ordinary end mill…

Pretty much, yes, it can.

The knurled diamonds aren’t raised above the surface, as they are in classical crush-rolled knurling, but my fingers can’t really tell the difference. That’s a chunk of 1-inch PVC pipe, turned smooth in the lathe and knurled with a 2-mm end mill; the fluff is left over from wiping off the swarf with a rag.

The setup mounts the workpiece in the rotary table on the right with the tailstock on the right end. In this case, a little boring (on the lathe) produced a slip fit on the tailstock ram, but you probably should have a plug that supports the tubing with a center-drilled hole for the tailstock’s dead center.

The general idea is to do the cutting at a 45-degree angle in front of the workpiece, where the end mill will carve a neat 90-degree recess almost like a real 90-degree conical engraving point. This sketch shows the layout, albeit for a very large cutter and a very small workpiece. The YZ origin is at the center of the workpiece, with the X origin at the left edge of the knurled region.

The Z axis remains constant at the level where the bottom of the cutter intersects the 45-degree angle at the proper depth-of-cut. Then you drive Y into the workpiece and drag the end mill along  X while twirling A to make a single cut. Move Y out to clear, return X to the start, index A by the angle between the knurls, repeat.

This isn’t perfect, because the bottom of the cutter isn’t parallel to the cut between the knurl diamonds. The leading edge cuts too high / low and the trailing edge cuts too low / high (depending on which way you’re moving X and twirling A), but for small cutters and large workpieces the approximation is probably Close Enough.

The key number is the diametral pitch DP: the number of knurl diamonds around the workpiece divided by the workpiece OD in inches. Machinery’s Handbook suggests that a DP of 48 is coarse and 96 is fine. Measuring some knurled tools lying around the shop shows those values aren’t hard numbers, but they’re a start.

Given an initial DP and the workpiece diameter, figure an actual DP that will produce an integral number of knurl diamonds around the circumference (call it NA):

NA = round (DP * OD) to the nearest integer

Actual DP = NA / OD

Knowing the number of diamonds NA, figure the width of a diamond in degrees (call it the Width-in-Angle):

WA = 360/NA

and also as a fraction of the circumference in inches:

W = π * diameter / NA

Typical knurl diamonds seem to be about twice as long their width, so the nominal aspect ratio is 2. Given the desired length-of-the-knurled-region, figure an actual aspect that will produce an integral number of diamonds along the length (call it NX):

NX = round (length-of-knurl / nominal-aspect) to the nearest integer

Knowing NX, figure the angle to turn (call it TA) while making the cut along X:

TA = WA * NX

This sketch shows the depth-of-cut geometry, with the cutter producing skeletal points where the cut just touches the next knurl over. With a 45 degree angle between the diagonal, all the trig boils down to factors of √2.

The perimeter of an NA-sided polygon inscribed in a circle of radius R (which is just the OD/2 is:

Perimeter = 2 NA R sin (180 / NA)

which simplifies to

Perimeter = NA OD sin (180 / NA)

The length of the chord L from tip to tip for such a polygon:

L = Perimeter / NA

The side of the triangle from the corner of the cut perpendicular to the chord is half the chord length, because it’s an isosceles triangle with angles of 45 and 90 degrees.

The height of the segment above the chord:

(L / 4) tan (WA / 4)

The total depth-of-cut along the diagonal is the sum of those two numbers. Given that, figure the coordinates (Y is negative because it’s out in front):

Z = (radius – depth) / √2

Y = -Z

Now, because the end mill has a nontrivial length along the X axis, it’s doing too much cutting. Reductio ad absurdum, imagine putting a 1-inch knurl along a pencil using a 6-inch end mill: the thing would cut a horizontal swath the entire length of the knurled region, leaving no material behind.

So it makes sense to heave in a Fudge Factor limiting the actual depth-of-cut to some percentage of that value. The knurl above was with that factor set to 0.50, but (as with rolled knurls) be sure to test in an inconspicuous spot before actual use. Subtract the shrunken depth-of-cut from the radius as above to get the YZ coordinates.

Notice the difference between the ends of the cut in that first picture: you can clearly see the shape of the end mill’s cylindrical cut.  I ran the cutter at 2500 rpm to avoid overheating the PVC, so you can see the cuts on the top edges of the diamonds: the trailing edge makes neat little swipes. In actual practice, you’d run it much faster to get a smooth cut.

Then it’s just a matter of writing some G-Code…

Herewith, the G-Code that did the pencil, with depth-of-cut set to 0.30. It cuts to the right and cuts to the left, then indexes to the next cut by unwinding the A axis. The nominal DP = 48 makes for a coarse, yet oddly attractive, knurl. The variable names don’t track what you see above, but should be pretty obvious. Also see the notes on optimizations down near the bottom.

(Engraved knurling)
(Ed Nisley - KE4ZNU - May 2010)
(G55 Coordinate Origin: 	X to left of checkering)
(							YZ on centerline of workpiece)
(							A = 0 wherever you like)
(Touch off tool center at Y = workpiece radius)
(				   tip at Z = workpiece radius)

(-- Input dimensions)

#<_Outer_Dia>			= 0.324					(outside dia of workpiece - INCHES)

#<_Knurl_Start_X>		= 0.0					(X offset to start of kurling)
#<_Knurl_Length>		= 1.0					(length of knurled section)

#<_Diamet_Pitch>		= 48					(96 = fine 48 = coarse)
#<_Depth_Fraction>		= 0.3					(fraction of max cut depth)
#<_Aspect_Nominal>		= 2.0					(desired knurl diamond length-to-width ratio)

#<_Tool_Dia>			= 0.078					(end mill diameter)
#<_Feed>				= 20					(cutting speed, inch/min)

#<_Traverse_Clear>		= 0.050					(clearance for traverse moves)

(-- Calculated dimensions)

#<_PI>					= 3.14159265358979323

#<_Outer_Radius>		= [#<_Outer_Dia> / 2]
#<_Tool_Radius>			= [#<_Tool_Dia> / 2]

#<_Num_Points_A>		= ROUND [#<_Diamet_Pitch> * #<_Outer_Dia>]	(points around circumference)
#<_Point_Width_Deg>		= [360 / #<_Num_Points_A>]					(degrees per point)
#<_Point_Width>			= [#<_PI> * #<_Outer_Dia> / #<_Num_Points_A>]

#<_Num_Points_X>		= ROUND [#<_Knurl_Length> / [#<_Aspect_Nominal> * #<_Point_Width>]]
#<_Rotation_Per_Cut>	= [#<_Point_Width_Deg> * #<_Num_Points_X>]
#<_Point_Length>		= [#<_Knurl_Length> / #<_Num_Points_X>]		(actual point length)
#<_Aspect>				= [#<_Point_Length> / #<_Point_Width>]		(actual aspect ratio)

#<_Perimeter>			= [2 * #<_Num_Points_A> * #<_Outer_Radius> * SIN [180 / #<_Num_Points_A>]]
#<_Chord>				= [#<_Perimeter> / #<_Num_Points_A>]		(across one point)
#<_Segment_Height>		= [[#<_Chord> / 2] * TAN [#<_Point_Width_Deg> / 4]]

#<_Cut_Depth_Max>		= [#<_Segment_Height> + #<_Chord> / 2]
#<_Cut_Depth>			= [#<_Depth_Fraction> * #<_Cut_Depth_Max>]

#<_Cut_Z>				= [[#<_Outer_Radius> - #<_Cut_Depth>] / SQRT [2]]	(corner of cut)
#<_Cut_Y>				= [0 - #<_Cut_Z>]

#<_Tool_Z>				= #<_Cut_Z>									(tool bottom)
#<_Tool_Y>				= [#<_Cut_Y> - #<_Tool_Radius>]				(tool centerline)

#<_Safe_Z>				= [#<_Outer_Radius> + #<_Traverse_Clear>]	(clear workpiece top)
#<_Safe_Y>				= [0 - #<_Safe_Z> - #<_Tool_Radius>]		(clear workpiece side)

#<_Retract_Y>			= [0 - [#<_Safe_Z> / SQRT [2]] - #<_Tool_Radius>]	(clear cut)

(-- Start cutting!)

G40 G49 G80 G90 G94 G97 G98		(reset many things)

G55					(working coord system)
G20					(inch!)

F#<_Feed>			(set cutting speed)

(debug,Num points AX: #<_Num_Points_A> #<_Num_Points_X>)
(debug,Pt Width Deg Len: #<_Point_Width> #<_Point_Width_Deg> #<_Point_Length>)
(debug,Aspect: #<_Aspect>)
(debug,Cut Depth: #<_Cut_Depth>)
(debug,Cut YZ: #<_Cut_Y> #<_Cut_Z>)
(debug,Tool YZ Retract: #<_Tool_Y> #<_Tool_Y> #<_Retract_Y>)

(msg,Press [Resume])
M0

G0 Z#<_Safe_Z>					(get air)
G0 Y#<_Safe_Y>					(move to cutting side)

G0 X#<_Knurl_Start_X> A0		(get to knurl XA start)

G0 Y#<_Retract_Y> Z#<_Tool_Z>	(get to clearance point)

#<This_Point> = 0				(loop setup)
#<This_Angle> = 0

O1000 DO

;(debug,Angle: #<This_Angle>)

#<Far_A> = [#<This_Angle> + #<_Rotation_Per_Cut>]
#<Near_A> = [#<This_Angle> + 2 * #<_Rotation_Per_Cut>]

G1 Y#<_Tool_Y>					(cut into workpiece)
G1 X[#<_Knurl_Start_X> + #<_Knurl_Length>] A#<Far_A>	(cut right)

G1 X[#<_Knurl_Start_X>] A#<Near_A>						(cut left)

G0 Y#<_Retract_Y>				(get air)

#<This_Point> = [#<This_Point> + 1]
#<This_Angle> = [#<This_Point> * #<_Point_Width_Deg>]

G0 A#<This_Angle>				(index to next cut)

O1000 WHILE [#<This_Point> LT #<_Num_Points_A>]

G0 Y#<_Safe_Y> Z#<_Safe_Z> A0	(get big air)

M2

Some obvious improvements:

• Use G92.whatever to whack A appropriately or
• Fiddle the angle variable to track the actual A windup and
• Figure the shortest direction to unwind A & tweak the variable
• Cut in only one direction to reduce backlash or
• Make all the cuts with common endpoints in one pass
• Knurl along a known taper by interpolating Y & Z along X
• Offset the workpiece axis to match the knurl angle (ugh!)

Although I find it hard to believe I’m the first person to figure this out, a search on CNC knurling using an end mill doesn’t provide any meaningful hits. If you get rich using this idea, send me a generous donation…