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: Laser Cutter

Tour Easy: Bike Rack Tray Holder

Mary starts her garden plants at home, then hauls the trays to the garden in a plastic drawer strapped to the rack on her Tour Easy to avoid crushing the plants in the packs. I finally learned enough to make an adapter mating the drawer to the rack:

Bike Rack Tray Holder – in use

It’s made from four layers of laser-cut cardboard glued together with crossed corrugations for stiffness. I intended make a final version from glued-up plywood sheets, but it works surprisingly well as-is and I may just make another when this one wears out.

The rear view:

Bike Rack Tray Holder – rear view

The front has a cutout for the battery powering the rear camera, with the base height allowing enough meat above the battery:

Bike Rack Tray Holder – overview

The upright posts cradling the drawer may be too skinny for durability, which is why this is a prototype. The inner edges of the posts angle outward by a few millimeters to match the drawer’s mold draft.

Four feet locate the holder on the rack rails just ahead of the Ortlieb pack clips:

Bike Rack Tray Holder – rail detail

The rails are 8 mm ⌀ and the cutouts are 9 mm, because a little tolerance goes a long way. Similarly the tab widths just fit the available spaces beside the rail.

The two flat plates support the drawer and space the uprights to match the Ortlieb clips. I intended to mortise the plates into the uprights, but hot melt glue is wonderful stuff and the joint may outlast the cardboard. In retrospect, the outer edges of the plates should align with the inner sides of the uprights for maximum tidiness.

You don’t have that drawer and likely not the racks, so a picture of the LightBurn layout will give you the general idea for your hardware:

Bike Rack Tray Holder – LightBurn layout

Cut four copies of the uprights in two different orientations, glue them together, then do the obvious thing with the plates.

2026-05-11
Branson 200 Ultrasonic Cleaner: Wiring Fix

Our ancient Branson 200 Ultrasonic Cleaner began behaving erratically due to water seeping under the rather casual seal from last year’s fix. Although drying the switches let it start up again, it would run for only a few seconds before shutting down again, which suggested a deeper problem than just the switches.

Take a picture of the PCB’s component side:

Branson 200 Ultrasonic Cleaner – PCB component side

And of the solder side:

Branson 200 Ultrasonic Cleaner – PCB solder side

Transform those pictures to be the nice real rectangles shown above, resize to a common pixel format, mirror the solder side, turn it into a layer atop the component side, then tweak its opacity to make both sides visible at once:

Branson 200 Ultrasonic Cleaner – PCB overlay

Some pondering produces a partial schematic of the left half of the board:

Branson 200 Ultrasonic Cleaner – partial schematic

The 1:1 transformer is constantly powered, so the ON button connects the 120 V (!) half-wave rectified output to the +12V supply bus, with the 750 Ω resistor dropping most of the voltage while the switch is pressed.

The hotwired +12V supply forces the relay closed, which (in some as-yet unidentified way) fires up a +12V power source to hold the relay closed, with the 555 timer driving an MC14060 14-bit divider to count down the time until it turns itself off.

Reminder: this design dates back to the days when a pair of chips and a handful of through-hole components cost less than one of those fancy microcontroller thingies.

Plug the cleaner into an isolation transformer and trace the half-wave rectified signal through ON button to find it got all the way to the contact on the end of the orange wire in the connector, but did not reach the pin header on the PCB.

A closer look at the connector revealed a broken contact on the white wire, which I (rather crudely) soldered together while considering my choices:

Branson 200 Ultrasonic Cleaner – soldered contact

While plugging that wire back in place, this happened:

Branson 200 Ultrasonic Cleaner – another broken contact

Neither of those are the (presumably) similarly failed orange wire, but even I can get a clue from three similar failures.

So I replaced the OEM connector with a JST-XHP 2.54 mm connector from an assortment I got for another project, replaced the chunky 22 AWG wires with flexy 26 AWG silicone wires in the same cheerful rainbow colors, and it began working perfectly again.

The buttons needed another water seal, so I tweaked the previous layout to kiss-cut GITD tape and through-cut colorful vinyl sheets:

Branson 200 Ultrasonic Cleaner – power button cutting

Capped with a transparent cover sheet cut from a pack of PDA screen protectors (remember PDAs?):

Branson 200 Ultrasonic Cleaner – power button cover

In truth, the GITD tape is too thick, so I’ll probably repeat this dance later this year.

FWIW, I was totally ready to buy a new ultrasonic cleaner, but all of them have scathing one-star Amazon reviews, to the extent I decided fixing this cleaner would be much easier than fixing a new one that’s been cheapnified to the point of no return. A common complaint seems to be water leaking into their capacitive switches and killing the circuitry stone cold dead: not an improvement over this one.

2026-05-06

Window Mount for Bamboo Bee Tunnel Nests

Mary suggested converting wild bamboo up the hill into tunnel nests (per a xerces.org paper) for native bees buzzing around flowers in the yard, so:

Bee Tunnel Nest - downspout installation — Bee Tunnel Nest – downspout installation

I hung bundles of larger tubes in trees out back, in hopes of attracting huge carpenter bees.

3D printed mounts hold smaller bundles on the windows to let us keep an eye on the proceedings:

Bee Tunnel Nest Mount - installed-] — Bee Tunnel Nest Mount – installed

Which look better when not seen though two layers of glass in desperate need of Spring Cleaning:

The tabs provide a bit of pressure to hold the mounts in place, although I don’t know if they have enough springiness or will survive contact with the elements:

Bee Tunnel Nest Mount - tab section - solid model — Bee Tunnel Nest Mount – tab section – solid model

The key advantage of not building bigger bee motels: these little bundles don’t need annual cleaning / maintenance and will eventually fall apart.

If the bees find them suitable, more power to ’em!

And I realized the cut-off ends fit in the rotary. Witticisms engraved on bamboo could become the New Hotness:

Stipulated: I’m barely half-right about being a wit …

The OpenSCAD source code as a GitHub Gist:

	// Bee Tunnel Nest Mount
	// Ed Nisley – KE4ZNU
	// 2026-04-26

	include <BOSL2/std.scad>

	Layout = "Show"; // [Build,Show,Window,Bundle,Tabs]

	BundleOD = 35.0;
	BundleOffset = 0.0;

	SlotDepth = 18.0;
	SlotGap = 1.2;


	/* [Hidden] */

	HoleWindage = 0.2;
	Protrusion = 0.01;
	NumSides = 324;

	Clearance = 0.3;

	//$fn=NumSides;

	WallThick = 2.0;

	MountHeight = 1.5*BundleOD;
	MountWidth = 1.5*BundleOD + BundleOffset;

	ClipOA = [SlotDepth + WallThick,SlotGap + 2*WallThick,MountHeight];

	BundleCtr = [-WallThick/2,ClipOA.y + MountWidth/2 + BundleOffset/2,MountHeight/2];

	TabOA = [0.7SlotDepth,5.0,0.7WallThick];
	TabOffset = 0.2*SlotDepth;
	TabOC = MountHeight/2;

	TabClearance = [4*Clearance,0,Clearance];

	//—–
	// Define things

	module BundleMount() {

	difference() {
	cuboid([WallThick,MountWidth + ClipOA.y,MountHeight],
	rounding=3.0,edges=[TOP+BACK,BOTTOM+BACK],anchor=FRONT+RIGHT);
	back(BundleCtr.y)
	xcyl(3*WallThick,d=BundleOD);
	for (j=[-1,1],k=[-1,1])
	translate([BundleCtr.x,jBundleOD/2 + BundleCtr.y,kBundleOD/2])
	xcyl(3*WallThick,d=3.0,$fn=6);
	}

	}

	module WindowMount() {

	difference() {
	cuboid(ClipOA,rounding=3.0,edges=[TOP+LEFT,BOTTOM+LEFT],
	anchor=FRONT+RIGHT);
	left(WallThick) back(WallThick)
	cuboid([2SlotDepth,SlotGap,2MountHeight],anchor=FRONT+RIGHT);
	for (k=[-1,1])
	translate([-(ClipOA.x – TabOffset),-Protrusion,k*TabOC/2])
	cuboid([TabOA.x + TabClearance.x,WallThick + 2Protrusion,TabOA.y + 2TabClearance.z],anchor=FRONT+LEFT);
	}

	}

	module Tabs() {

	for (j=[-1,1])
	fwd(j*TabOC/2)
	cuboid(TabOA,anchor=BOTTOM+LEFT) position(LEFT+TOP)
	prismoid(size1=[3*SlotGap,TabOA.y],size2=[0,TabOA.y/2],
	h=(WallThick – TabOA.z) + SlotGap/3,anchor=BOTTOM+LEFT);

	}

	module Assembly() {

	union() {
	BundleMount();
	WindowMount();
	left(ClipOA.x – TabOffset – TabClearance.x)
	xrot(-90)
	Tabs();
	}
	}


	//—–
	// Build things

	if (Layout == "Bundle") {
	BundleMount();
	}

	if (Layout == "Window") {
	WindowMount();
	}

	if (Layout == "Tabs") {
	Tabs();
	}


	if (Layout == "Show") {
	Assembly();
	}

	if (Layout == "Build") {
	yrot(90)
	Assembly();
	}

view raw Bee Tunnel Nest Mount.scad hosted with ❤ by GitHub

2026-04-30

Battery Organizer
A small box has been holding an assortment of batteries during their out-of-service phase and I finally made a lid to keep the contents from flopping around:

Battery organizer

The cardboard prototypes record the journey toward the black acrylic lid. The final LightBurn layout:

Battery Collector – LightBurn layout

For whatever it’s worth, the box holds:
- Three USB readers: bike camera Micro-SD cards
- Four AA cells: Forester dash camera
- Four NP-BX1 cells: helmet camera
- Four AAA bucked lithium cells: kitchen scale
The first four suitable & identical screws from the Tray o’ Tiny Screws hold the lid down. The ToTS contains screws and suchlike harvested from all the gadgetry headed for the recycling pile, making it a reliable source for any occasion.
2026-04-29
Image Trace and Cut

Having admired the paper craft at RavensBlight and with some experience in simple paper cuttery, I had to try my hand at the Ghost Truck. Rather than using an X-Acto knife and straight edge around the perimeter, I set it up for laser cutting.

The instructions & layouts are images in PDF files, so it’s straightforward to import them into LightBurn and trace the outlines:

Ghost Truck – LightBurn vectors

Tracing produces short vectors and irregular curves:

Ghost Truck – LightBurn pre-optimize

The Optimize Shapes tool and a little manual intervention clean things up:

Ghost Truck – LightBurn post-optimize

You must manually add any cuts buried in the pattern, as in the Trailer Wheels parts shown above, so pay attention to the instructions.

Use the Move Laser tool to put the laser head at an obvious point on the layout, then skootch the printed page (in a Letter size fixture) to put that point under the beam. Repeat for another point, iterate until satisfied, then Fire The Laser:

Ghost Truck – cutout overview

Some irregularities peek around the edges:

Ghost Truck – cutout detail

On the whole, it’s much better than I could do with a knife.

Repeat for the other seven pages of parts:

Ghost Truck – Assembly

With some diligence I may have it ready for All Hallows Eve …

2026-04-17
Punched Cards: Summary

At last, I can make plausible-looking punched cards:

Test Card 3 – punched

Then chop most of them up to make a layered eagle:

Apollo Eagle – V3 – overview

Back in the beginning, the grand overview explained the card production process, but now I can pull all the blog posts into a more coherent story.

Start by making trays to hold the 1/3 Letter sized printed cards and the final cut cards. A coat of paint improves the result:

Card Storage Tray – front

Then make a fixture to position the 1/3 Letter printed cards in the laser and a simple cover for the honeycomb to direct the air flow:

Punched cards – laser fixture overview

The current versions of the Python program to convert a line of text into the SVG images required to print and punch the cards, plus the Bash scripts handling all the command line parameters, are now in a single GitHub Gist . I used the source code from the Apollo 11 CSM AGC for historic reasons.

The Bash scripts invoke the Python program twice to produce both the printed layout:

Punched Cards – test card – printed

And “punched” holes surrounded by the perimeter cut for the laser:

Test Card 3 – LightBurn layout

The Python program handles translation from the ASCII (really Unicode) character set into the EBCDIC punched hole layout. Because LightBurn and Inkscape handle SVG scaling differently, the script sorts that out.

Because my printer produces slightly off-size printed images, the script uses Inkscape to convert the SVG into a PNG, then downscales the image by a few percent (a different percent on each axis). It composites the card logo onto the PNG and slams the result onto a Letter page in the proper place to hit the 1/3 Letter sheets.

Aligning the targets printed on the cards with the corresponding target positions in the laser SVG requires careful fixture skootching:

Red dot vs printed target vs laser spot alignment

A batch file feeds the laser SVGs into LightBurn, so the process boils down to a few mouse clicks per card.

With a tray full of finished cards in hand, I converted the eagle from the Apollo 11 mission patch into a set of outlines:

Apollo 11 Patch – eagle layers

Each of those outlines defines the shape of a layer cut from those printed cards:

Apollo Eagle – V3 – head

Not gonna lie: it took serious effort to cut up those cards.

Each layer has a specific set of cards chosen to put the holes in the proper place while hiding the card joints:

Apollo Eagle – V4 Layer 1 cards

Mirroring the layout helped me arrange the cards correctly while taping the back side of the joints with book repair tape:

Apollo Eagle – V4 Layer 1 cards – mirrored

Slap a sheet of cards on the laser platform, align it to the layer’s outline, Fire The Laser, and stack up the results:

Apollo Eagle – V3 – tail

I used Elmer’s All Purpose Glue Stick to hold the layers together, figuring if it’s good enough for kindergartners it’s good enough for me.

And that’s all there is to it …

2026-04-15
Gridfininty Tape Dispenser
A Gridfinity Tape Dispenser holds a roll of book repair tape:

Gridfinity Tape Dispenser – overview

The perspective makes the dispenser look chonkier than it really is.

A wrap of black silicone tape around the spool embiggens it for a snug fit inside the tape core. A casual inspection of other tapes suggest enlarging the spool by a few percent would help, but it’s Good Enough™ as-is.

The two end thumbscrews fasten the 4×1 Gridfinity baseplate to the dispenser; both from Gridfinity Refined:

Gridfinity Tape Dispenser – baseplate

If I had my wits about me, I’d have used a nicely contrasting color for the baseplate, but it is what it is.

Although they’re called “thumbscrews”, the slot is sized for a US quarter (or cart coin).

An OpenSCAD one-liner produces an SVG model of the baseplate:
```
projection(cut=true) import("Grid 4x1.stl");
```
Import SVG into LightBurn, delete the magnet pockets, and Fire The Laser on some EVA foam:

Gridfinity Tape Dispenser – foam base

A layer of 3M 300LSE tape holds the foam in place, because neither side sticks well to the goo on a craft adhesive sheet due to their low surface energy. I stuck an oversize rectangle to the foam with the thin adhesive side before cutting, which required a second pass at higher speed.

The thumbscrews also close off the holes in the dispenser bottom through which I poured 275 g = 10 oz of sand for better traction. Steel shot is reputed to be Even Better, although most of the BBs are in the long-arm weight.

The dispenser model includes a printed serrated blade which works as poorly as the author suggested. A length snapped from an ancient Strombecker 4-I (“four eye”) blade in the Box o’ Big X-Acto Blades fits perfectly, works wonderfully well, and is sufficiently inconspicuous to warrant the warning label. An X-Acto #26 Whittling Blade would probably snap down equally well.
2026-04-13