The Smell of Molten Projects in the Morning

Ed Nisley's Blog: Shop notes, electronics, firmware, machinery, 3D printing, laser cuttery, and curiosities. Contents: 100% human thinking, 0% AI slop.

Tag: Sherline

Sherline CNC mill

Mini-Lathe Chuck Stops: Pocketing Fixture
Putting pockets in the legs of the mini-lathe chuck stop blanks requires a fixture to align them in the Sherline mill:

Lathe Chuck Stops – pocketing setup

Because it need not withstand much lateral force and will get used only a dozen-ish times, the base is MDF and the stop alignment happens in three matching chipboard layers:

Lathe Chuck Stops – Pocketing Fixture – LB layout

The three stops (over on the right) are copy-pasta from the originals. A 0.1 mm outset in the chipboard (center) lets the acrylic shapes drop into the chipboard sheets with Good Enough™ alignment accuracy. The MDF layer (left) provides some overshoot comfort below the chipboard.

The chipboard layers each have four alignment targets at (±30,±20):

Lathe Chuck Stops – pocketing fixture touchoff

Touch off the lower-left target at (-30,-20) and G0 X30 Y30 should drop the laser dot in the middle of the upper-right target. With the (0,0) origin at the geometric center of the stop, LinuxCNC’s polar notation picks out the three pockets:
```
G0 @20 ^-60
G0 @20 ^180
G0 @20 ^60
```
The plywood disk under the Sherline’s clamp has a glued ring to put the clamping force out near the ends of the legs. I started with just the aluminum clamp, but the legs needed a bit more stability; a laser cutter makes impromptu widgets like that trivially easy.

Next: write the G-Code to make the pockets.

The LightBurn SVG layout as a GitHub Gist:

Loading
Sorry, something went wrong. Reload?

Sorry, we cannot display this file.

Sorry, this file is invalid so it cannot be displayed.
Viewer requires iframe.

view raw Lathe Chuck Stops – Pocketing Fixture – LB layout.svg hosted with ❤ by GitHub
2023-07-13
Mini-lathe Chuck Stops

Having occasionally been in need of a lathe chuck stop, I finally cleared that project off the heap:

Lathe Chuck Stops – demo setup

These are definitely not up to commercial standards, but also don’t cost fifty bucks each. A trio of 4×2 mm neodymium disk magnets stick the stop to the chuck (and to each other) with enough force to hold it there, but not enough to make removing it a hassle.

I imported the Z axis orthogonal view of the chuck jaws from the ball fixture for the running lights:

Lathe Chuck Jaws – solid model axial

Trace the right-side jaw, clean it up, put the tip a known distance from the origin, make a circular array, and draw a comfort circle the size of the chuck OD.

The stop geometry comes from a hull wrapped around a circle a few millimeters larger than the 4 mm magnet (out 20 mm from the center) and a circle at the center sized so the hull clears the jaws:

Lathe Chuck Stops – LB layout

Then a small circle at the center allows me to drop the stop atop a known coordinate and rotate it around the circle, because the XY coordinate center is not at the geometric center.

I cut out a few chipboard samples to verify the sizes, a few more from scrap acrylic to set up the pocketing operation, then half a dozen of each in cheerful kindergarten colors:

Lathe Chuck Stops – on-lathe storage

The 5 mm stop is obviously too fragile for commercial success, but I figured it’ll survive long enough around here. Worst case, I can make another handful as needed.

Although I have laser-engraved pockets in plywood, a few experiments in acrylic confirmed the surface finish is terrible and the depth control is iffy, at best. Given that I need a 2.2 mm deep pocket in 3 mm acrylic, a CNC mill seems the right way to poke the pockets:

Lathe Chuck Stops – pocketing setup

More on that tomorrow.

The LightBurn SVG layout as a GitHub Gist:

Loading
Sorry, something went wrong. Reload?

Sorry, we cannot display this file.

Sorry, this file is invalid so it cannot be displayed.
Viewer requires iframe.

view raw Lathe Chuck Stops – LB layout.svg hosted with ❤ by GitHub

2023-07-12
Tour Easy Running Light: Heatsink Machining
Having acquired some thick-wall (1 inch OD, ¾ inch ID) aluminum tube, making the LED heatsink and lens holder for a running light generates a lot less scrap. A new doodle gives the dimensions in a rather Picasso-ish layout:

Running Light – dimension doodles

The back end of the tube gets turned down to 23 mm OD and cleaned up to 19 mm ID, then scored to give the epoxy something to grip:

Front Running Light – Heatsink shell scoring

The front end gets bored to 22.5 mm for the lens holder and has its OD cleaned up to 25 mm:

Front Running Light – finished shell

Clean up the end of a ¾ inch rod to 19 mm OD, knurl it a little to increase the OD ever so slightly and improve its griptivity, slice off a bit more than 10 mm, butter it up with JB Weld epoxy, and shove it into the shell with its front end aligned and its back end sticking out:

Front Running Light – epoxied plug in shell – rear

Face off the back end and the front end looks fine as assembled:

Front Running Light – epoxied plug in shell – front

Grab it in the Sherline mill’s three jaw chuck to:
- Drill & tap the M3 central hole for the stud holding the circuit plate to the back end
- Drill 1.6 mm blind holes for the circuit plate pins
- Drill 2 mm through holes for the LED wires, 60° apart
Which looks like this from the front:

Front Running Light – drilled heatsink – front

And like this with the circuit plate screwed & glued to the rear:

Front Running Light – circuit plate mounted

Clean up the OD of some ¾ inch PVC pipe to 25 mm, bore it out to 23 mm.

While the Sherline is set up, drill a pair of 2 mm holes in the lens holder for the wires, aligned so they’ll match the heatsink holes.

Because we live in the future, laser-cut the rear cap from some edge-lit acrylic with a black inner disk:

Front Running Light – PVC tube – end cap

Cutting that cap with the notch included is now trivially easy, compared to the previous machining.

Now for some circuitry …
2023-04-14
World War II Dog Tag Layout

Quite some time ago, I hammered out G-Code to engrave ersatz dog tags for a Cabin Fever demo:

Cabin Fever Dog Tag

A dozen years later, making a World War II dog tag is a whole lot easier:

John Q Public – WWII dog tag

Well, “easier” if you allow laser engraving in white-on-black Trolase using a font intended to mimic a typewriter.

Close enough, methinks.

Which comes from a simple layout:

John Q Public – WWII dog tag – LB layout

The outline traces a scanned image of my father’s tag, fitting a few hand-laid splines around the curves:

John Q Public – WWII dog tag – spline curves

I generated a random serial number based on my father’s draftee status (he was in his early 30s during his South Sea Island tour) and state of residence; my apologies to anyone carrying it for real. His blood type was A and (I think) the religion code marks him as “Brethren”, a common group in my ancestry.

Given the outline, various plastics, and a laser, other effects become possible:

WWII dog tag outline test

It might come in handy for something, someday.

The LightBurn SVG layout as GitHub Gist:

Loading
Sorry, something went wrong. Reload?

Sorry, we cannot display this file.

Sorry, this file is invalid so it cannot be displayed.
Viewer requires iframe.

view raw John Q Public – WWII dog tag – LB layout.svg hosted with ❤ by GitHub

2023-02-20

Tailor’s Clapper: CNC Pocketing

Separating the interior contour of the finger grip from its overall shape let me reduce the woodworking to a simple pocketing operation:

Start by aligning the finished block to put the joint between the pieces parallel to the X axis, then touch off at the center:

Ironing Weight - alignment — Ironing Weight – alignment

A pair of clamps screwed to the tooling plate act as fixtures to align the block when it’s flipped over to mill the other pocket.

Just to see how it worked, I set up a GCMC program to produce a trochoidal milling pattern using the sample program:

Tailors Clapper - Pocket Milling Path — Tailors Clapper – Pocket Milling Path

Now, most folks would say the Sherline lacks enough speed and stiffness for trochoidal milling:

Ironing weight - trochoidal milling — Ironing weight – trochoidal milling

Aaaand I would agree with them: chugging along at 24 in/min = 600 mm/min doesn’t put the 10 k RPM spindle speed to good use. Fortunately, oak doesn’t require much in the way of machine stiffness and the trochoid path does ensure good chip clearance, so there’s that.

If I had to do a lot of trochoid milling, I’d tweak the GCMC sample code to short-cut the return path across the circle diameter, rather than air-cut the last half of every circumference.

The code starts by emptying a circular pocket so the trochoid path begins in clear air, rather than trenching into solid wood.

Eventually it finishes the pocket:

Ironing weight - grip pocket — Ironing weight – grip pocket

After the trochoid finishes, one climb-milling pass around the perimeter clears the little ripple between each trochoid orbit.

Flip it over, clamp it down, touch off the middle, and do it all again.

The next step is filling those pockets with a pair of comfy grips.

The GCMC source code as a GitHub Gist:

	// Ironing weight pocketing
	// Ed Nisley KE4ZNU – 2023-01

	//—–
	// Library routines

	include("/opt/gcmc/example/cc_hole.inc.gcmc");
	include("varcs.inc.gcmc");
	include("tracepath_comp.inc.gcmc");
	include("trochoidal.inc.gcmc");

	/*
	include("tracepath.inc.gcmc");
	include("engrave.inc.gcmc");
	*/

	//—–
	// Useful constants

	SafeZ = 10.0mm; // above all obstructions
	TravelZ = 2.0mm; // within engraving / milling area

	BlockHome = [0.0mm,0.0mm,TravelZ]; // Origin on surface at center of pocket

	FALSE = 0;
	TRUE = !FALSE;

	//—–
	// Overall values

	Socket = [160.0mm,25.0mm,7.0mm]; // raw grip recess into block

	RoundEnds = TRUE; // TRUE for smooth rounded endcaps

	SocketRadius = RoundEnds ? Socket.y/2 : 10.0mm;
	comment("SocketRadius: ",SocketRadius);

	CutterDia = 6.32mm – 0.15; // actual cutter diameter – windage
	MillStep = 0.25 * CutterDia; // stepover in XY plane
	comment("CutterDia: ",CutterDia," MillStep: ",MillStep);
	MillClean = MillStep/2;

	PlungeSpeed = 150.0mm; // cutter Z plunge into work
	MillSpeed = 600.0mm; // XY speed

	if (CutterDia > SocketRadius) {
	error("Cutter too large for corner radius");
	}

	CornerOC = head(Socket,2) – 2*[SocketRadius,SocketRadius];
	comment("CornerOC: ",CornerOC);

	Corners = RoundEnds ? // rear left CCW around slot
	{-CornerOC/2, CornerOC/2} :
	{[-CornerOC.x,CornerOC.y]/2, [-CornerOC.x,-CornerOC.y]/2, [CornerOC.x,-CornerOC.y]/2, CornerOC/2};
	comment("Corners: ", Corners);

	if (RoundEnds) {
	SlotPerimeter = {[0.0mm,Socket.y/2,-Socket.z]}; // entry point at center rear
	SlotPerimeter += {Corners[0] + [0.0mm,SocketRadius]};
	SlotPerimeter += varc_ccw([-SocketRadius,-SocketRadius],SocketRadius) + SlotPerimeter[-1];
	SlotPerimeter += varc_ccw([+SocketRadius,-SocketRadius],SocketRadius) + (Corners[0] + [-SocketRadius,0.0mm]);
	SlotPerimeter += {Corners[1] + [0.0mm,-SocketRadius]}; // across front
	SlotPerimeter += varc_ccw([+SocketRadius,+SocketRadius],SocketRadius) + SlotPerimeter[-1];
	SlotPerimeter += varc_ccw([-SocketRadius,+SocketRadius],SocketRadius) + (Corners[1] + [+SocketRadius,0.0mm]);
	}
	else {
	SlotPerimeter = {[0.0mm,Socket.y/2,-Socket.z]}; // entry point at center rear
	SlotPerimeter += {Corners[0] + [0.0mm,SocketRadius]};
	SlotPerimeter += varc_ccw([-SocketRadius,-SocketRadius],SocketRadius) + SlotPerimeter[-1];
	SlotPerimeter += {Corners[1] + [-SocketRadius,0.0mm]};
	SlotPerimeter += varc_ccw([+SocketRadius,-SocketRadius],SocketRadius) + SlotPerimeter[-1];
	SlotPerimeter += {Corners[2] + [0.0mm,-SocketRadius]}; // across front
	SlotPerimeter += varc_ccw([SocketRadius,SocketRadius],SocketRadius) + SlotPerimeter[-1];
	SlotPerimeter += {Corners[3] + [SocketRadius,0.0mm]};
	SlotPerimeter += varc_ccw([-SocketRadius,SocketRadius],SocketRadius) + SlotPerimeter[-1];
	}


	//— Begin cutting

	goto([-,-,TravelZ]);
	goto(BlockHome);

	if (!RoundEnds) { // clear corners outward of main pocket
	foreach(Corners; xy) {
	comment("Plunge corner at: ",xy);
	feedrate(PlungeSpeed);
	goto(xy);
	move([-,-,-Socket.z]);
	comment(" pocket");
	feedrate(MillSpeed);
	cc_hole(xy,(SocketRadius – MillClean),CutterDia/2,MillStep,-Socket.z);
	goto([-,-,TravelZ]);
	comment(" done!");
	}
	}

	comment("Open slot");

	TrochRadius = (Socket.y – CutterDia)/2 – MillClean;
	TrochPath = {[-(Socket.x/2 – TrochRadius – CutterDia/2 – MillStep),TrochRadius],
	[ (Socket.x/2 – TrochRadius – CutterDia/2 – MillStep),TrochRadius]};

	comment(" clear landing zone");
	xy = [TrochPath[0].x,0.0mm];
	feedrate(PlungeSpeed);
	goto(xy);
	move([-,-,-Socket.z]);
	feedrate(MillSpeed);
	cc_hole(xy,Socket.y/2 – MillClean,CutterDia/2,MillStep,-Socket.z);
	goto([-,-,TravelZ]);

	comment(" trochoid pocket milling");

	feedrate(MillSpeed);
	trochoid_move(TrochPath[0],TrochPath[1],
	-Socket.z, TrochRadius, MillStep);
	goto([-,-,TravelZ]);

	comment("Clean slot perimeter");
	feedrate(MillSpeed);
	goto([-,-,-Socket.z]);
	tracepath_comp(SlotPerimeter,CutterDia/2,TPC_CLOSED + TPC_LEFT + TPC_ARCIN + TPC_ARCOUT);

	goto([-,-,TravelZ]);
	goto(BlockHome);

view raw Ironing weight grip pocket.gcmc hosted with ❤ by GitHub

	#!/bin/bash
	# Ironing weight finger grip pocketing
	# Ed Nisley KE4ZNU – 2023-01

	Flags='-P 4 –pedantic' # quote to avoid leading hyphen gotcha


	# Set these to match your file layout

	LibPath='/opt/gcmc/library'

	Prolog='prolog.gcmc'
	Epilog='epilog.gcmc'

	#—–

	gcmc $Flags \
	–include "$LibPath" –prologue "$Prolog" –epilogue "$Epilog" \
	"Ironing weight grip pocket.gcmc" > "Grip pocket.ngc"

view raw pocket.sh hosted with ❤ by GitHub

2023-02-02

Ironing Weight, a.k.a. Tailor’s Clapper: Overview

Mary wanted some ironing weights, formally known as tailor’s clappers, to produce flatter seams as she pieced fabric together:

Ironing weight – flattened seam

The weights are blocks of dense, hard, unfinished wood:

Ironing weight – seam ironing A

One can buy commercial versions ranging from cheap Amazon blocks to exotic handmade creations, but a comfortable grip on a block sized to Mary’s hands were important. My lack of woodworking equipment constrained the project, but the picture shows what we settled on.

The general idea is a rounded wood block with 3D printed grips:

Ironing Weight Finger Grip

All other clappers seem to have a simple slot routed along the long sides, presumably using a round-end or ball cutter, which means the cutter determines the shape. This being the age of rapid prototyping, I decided to put the complex geometry in an easy-to-make printed part inserted into a simple CNC-milled pocket.

The first pass at the grip models:

Ironing Weight Finger Grip – slicer preview

Both recesses came from spheres sunk to their equators with their XY radii scaled appropriately, then hulled into the final shape. Customer feedback quickly reported uncomfortably abrupt edges along the top and bottom:

Ironing Weight – maple prototype

We also decided the straight-end design didn’t really matter, so all subsequent grips have rounded ends to simplify milling the pocket into the block.

With the goal in mind, the next few posts will describe the various pieces required to make a nice tailor’s clapper customized to fit the user’s hand.

2023-01-31
CO₂ Laser Cutter: Improved PIN-10D Photodiode Filter Holder

Anything would be better than just taping some gel filters to the front of the bare photodiode package:

Laser output – photodiode kludge

Right?

I heaved the slab of ½ inch black acrylic left over from the Totally Featureless (WWVB) Clock into the laser cutter and, two passes at 90% power later, had a somewhat lumpy 32 mm donut with an 11 mm hole in the middle. Because acrylic is opaque to the IR light from a CO₂ laser (which is why it cuts so well) and black acrylic is opaque to visible light (which is what the photodiode is designed for), this is at least as good as an aluminum housing and much easier to make.

Chuck the donut into Tiny Lathe and bore out the hole:

PIN-10D photodiode filter holder – boring ID

When it’s a snug fit to ½ inch brass tube (about the same size as the photodiode’s active area), flip it around, and bore the other size out to fit the photodiode case.

Ram the tube in place, grab the large recess, and center the tube:

PIN-10D photodiode filter holder – centering snout

That’s the chuck-in-chuck trick I used with the coasters, because the neither of the larger four-jaw chucks close far enough to get their inside jaws inside those little holes.

[Edit: Got that backwards: I bored the big recess first.]

Skim most of the OD down, then, because I ~~am a dolt~~ forgot to put a spacer in there, flip it around again, get it running true (the chuck aligns the flat side):

PIN-10D photodiode filter holder – turning OD

Then skim the rest of the OD to clean it up.

Cut some filter gels to fit inside the recess:

PIN-10D photodiode filter holder – filter disc cutting

Even though they’re pretty much transparent to thermal IR, a focused IR laser beam cuts them just fine. The little tab at 6 o’clock (remember round clocks with hands?) keeps the cut circle from falling out.

Drill & tap for an M3 setscrew to hold the photodiode in place:

PIN-10D photodiode filter holder – parts

Put them all together:

PIN-10D photodiode filter holder – assembled

I must conjure a better mount for the thing, because this is way too precarious:

PIN-10D photodiode filter holder – test install

Early results suggest it works better than the previous hack job, without ambient light sneaking around the edges of the filter pack.

2022-10-11