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.

Category: Software

General-purpose computers doing something specific

Knitted Spider: Eyemaxxing
A 3D printed spider with a knitted texture seemed a sufficient oxymoron to justify its existence:

Knitted Spider – black eyes

But all-black looked rather somber, even for an All Hallow’s Eve decoration, so I used PrusaSlicer’s Multi-Material Painting to print the eyes in retina-burn orange:

Knitted Spider – orange eyes – wipe tower

The chunky wipe tower shows the cost of switching filaments for a quartet of little eyes. The new Prusa INDX extruder design reduces that waste, but I’m not going there.

You can see the block of painted-on support under the palps, which worked better than overenthusiastic automatic support generation.

The consensus suggested the spider suffered from insufficient eye, so I upleveled it to maximum spider spec:

Knitted Spider – 8 eyes – on platform

Which looks like evolution in action:

Knitted Spider – iteration

The additional eyes came from a trivial OpenSCAD / BOSL2 sphere:
```
include <BOSL2/std.scad>
spheroid(d=5.0,style="icosa");
```
Which is both small and large enough to have a useful number of facets:

Knitted Spider – 5mm icosa sphere eye model

Those facets will come in handy for Multi-Material Painting.

Adding the sphere to the spider model turned out to be trickier than I imagined, because PrusaSlicer requires object to sit flat on the platform, but merging the sphere and spider models got it done:

Knitted Spider – merged models

Then you can use the Move tool to haul the sphere into place:

Knitted Spider – eye positioning

Use the Scale tool to reduce it to a suitable size.

With the eye in place, copy-n-paste creates a duplicate Merged sphere at the same coordinates, which you chivvy into its proper spot. Repeat as needed for more eyes!

The sphere facets are far below the 0.4 mm nozzle’s resolution, but they simplify painting the eye with “Smart Fill” angle settings:

Knitted Spider – 8 eyes – slicer material painting

I had initially thought to just drop separate spheres in place and assign them to the orange extruder, but the slicer (quite properly) treats them as separate objects and creates balls sitting in sockets.

Instead, the eyes must become part of the spider’s shape, have their exterior surfaces painted, then get sliced. In order to do that, I exported the 8-eyed spider as a new STL file and imported it back for painting & slicing:

Knitted Spider – 8 eyes – slicer model

The original single-color spider prints in an hour and adding any number of eyes doubles the time, so those MMU3 tool changes are expensive. Although the printer is reliable, the auto-retract spools I set up sometimes retract the filament beyond the feed gear inside the MMU3, which the firmware detects and calls for manual intervention. It’s best to be puttering in the basement while the printer buzzes away.
2026-09-23
Dog Paw Coaster
Start with a picture of a dog paw:

Dog Paw Coaster – starting picture

Rescale the paw to about 100 mm vertically to properly fit a normal-size glass / tumbler / mug. This may be considerably larger than life, but dog owners always want more dog, so it’ll work.

Generate an outline mask in GIMP:

Dog Paw Coaster – paw mask

Generate another mask for the pads & toenails:

Dog Paw Coaster – pad mask

Convert those into paths, save them as SVG files, and hand them to OpenSCAD:
```
include <BOSL2/std.scad>

/* [Hidden] */

PadThick = 1.2;
BaseThick = 2.0;

RimHeight = 0.4;
RimWidth = 0.8;
RimOffset = 1.0;

Clearance = 0.1;    // embiggen pad recesses

OutlineFN = "Dog Paw - Outline.svg";
PadFN = "Dog Paw - Pads.svg";

union() {


  linear_extrude(h=BaseThick)
    import(OutlineFN);

  color("Green")
    up(BaseThick)
      linear_extrude(h=PadThick)
        difference() {
          import(OutlineFN);
          offset(r=Clearance)
            import(PadFN);
        }

  
}
```
Which will get you a solid model like this:

Dog Paw Coaster – OpenSCAD model

Should you want decorative raised rims around the perimeter and pads:

Dog Paw Coaster – raised rim – OpenSCAD model

Then turn this on:
```
if (false)
  color("Red")
    up(BaseThick + PadThick)
      linear_extrude(h=RimHeight) {
        difference() {
          offset(r=RimOffset + RimWidth)
            import(PadFN);
          offset(r=RimWidth)
            import(PadFN);
        }
        difference() {
          offset(r=-RimOffset)
            import(OutlineFN);
          offset(r=-(RimOffset + RimWidth))
            import(OutlineFN);
        }
      }
```
Run the solid model through PrusaSlicer, send it to the MK4, and, while the printer is buzzing away, run the pads through an online nesting program to see how well that works:

Dog Paw Coaster – Pads nesting – LightBurn layout

While nesting didn’t save much material, it might come in handy for something more intricate and now I’ll be able to find it again.

Then get busy:
- Stick adhesive sheet to the chipboard
- Mirror the pads to cut adhesive side up
- Cut the pads, rescue a toenail from the chip tray
- Import the paw outline SVG
- Offset 0.75 mm inward
- Stick adhesive sheet on the cork
- Cut paw outline (adhesive up, but not mirrored!)
- Peel & stick
Which turned out pretty good:

Dog Paw Coaster – assembled

I used Concentric infill on the top to resemble the fur pattern, but it came out way too subtle.

The owner liked it, though, which made it all worthwhile.
2026-09-17
CUPS 2.4.19 vs. Printing
After a rather tedious morning devoted to figuring out why printing had suddenly stopped working, it seems there’s something badly wrong with the most recent CUPS update.

The symptoms included:
- Wrong sheet orientation for multi-page output regardless of the Landscape or Portrait setting
- No output at all, generally with a CUPS error message
The error messages were utterly inscrutable:
- “missing required flags”
- “cfFilterChain: pdftopdf (PID 8189) stopped with status 1”
- “temp file (object 3 0, offset 11462): dictionary has duplicated key /x12; last occurrence overrides earlier ones”
Downgrading two packages restored the status quo ante:
- libcupsfilters 2.2.1-2 → 2.1.1-4
- cups 2.4.19-1 → 2.4.16-2
Perhaps cups need not be reverted, but I’m loathe to fiddle around with it now that printing works again.

Those are now frozen in /etc/pacman.conf:
```
IgnorePkg = cups libcupsfilters
```
The least-awful way to downgrade / revert packages seems to be with manjaro-downgrade. You can, of course, do it on hard mode with pacman or pamac, but perusing a list of what’s in the update cache helped figure out what just changed.

And there they will sit until the next update rolls through.
2026-09-14
Huion H610Pro Tablet vs. Digimend vs. DKMS

A month or two ago the Huion H610Pro tablet’s buttons stopped working with the input-remapper macros I set up to do useful things. Considerable searching showed that the Digimend kernel driver project previously handling the buttons went inertial two years ago and, apparently, no longer worked with contemporary kernels. Further searching suggested old Huion tablets, which mine certainly is, should be handled by the native kernel / X drivers, so I uninstalled Digimend.

Which produced a persistent error message from the DKMS machinery telling me something awful was happening with the now-missing Digimend.

An Arch Linux BBS thread suggested manually removing various detritus left behind during successive kernel updates in places like /usr/lib/modules and /var/lib/dkms. Given that my desktop box runs the 6.18 kernel, I felt reasonably confident in removing the 5* kernel directories and anything mentioning digimend from those locations.

After the box started up the next morning, all the tablet buttons once again worked the way they use to.

The nice thing about Free Software is having access to all the pieces when something breaks …

2026-09-01
Smashed Glass Coasters: Chipboard Variation
The summer season brings iced drinks with condensation trickling down the mug and, alas, running off the smashed glass coasters:

Printed Coaster – Set C – oblique

The hard parts of making those coasters involved converting the glass fragment outlines into vectors and arranging them in interesting patterns. However, with those files already in hand, making a similar coaster with chipboard “fragments” was straightforward:

Chipboard Fragment Coaster – detail

Slightly modify the OpenSCAD code to suit thinner chipboard:
```
include <BOSL2/std.scad>

fn = "Printed Fragment Coaster - 5 in Set B - Inkscape paths.svg";

FragmentThick = 0.8;

BaseThick = 2.0;
RimHeight = 0.4;

union() {


  linear_extrude(h=BaseThick)
    import(fn,id="Perimeter");

  color("Green")
    up(BaseThick)
      linear_extrude(h=FragmentThick)
        difference() {
          import(fn,id="Perimeter");
          import(fn,id="Recesses");
        }

  color("Red")
    up(BaseThick + FragmentThick)
    linear_extrude(h=RimHeight)
      difference() {
        import(fn,id="LipOut");
        import(fn,id="LipIn");
        import(fn,id="Island");
      }

}
```
Run the solid model through PrusaSlicer:

Chipboard Fragment Coaster B – slicer preview

And have a baseplate an hour later:

Coaster Printing – in progress

While that’s buzzing away, tell LightBurn to cut chipboard instead of metallized paper, stick some craft adhesive sheet on the chipboard, and Fire The Laser:

Chipboard Fragment Coaster – chipboard cutting

Remember to mirror the fragments, because you’re cutting them bottom-up.

Do the same for the cork sheet going on the bottom, which does not require mirroring.

I tossed the cardboard alignment fixtures I used to stick the cork onto the 3D printed baseplate, so make another one for each coaster.

The top layer holds the baseplate:

Chipboard Fragment Coaster – cork fixture – top

The cork + adhesive sheet is inset 0.5 mm from the edge of the baseplate, so the outline cut in the bottom layer of cardboard is just that much smaller:

Chipboard Fragment Coaster – cork fixture – bottom

Although the time used to make a fixture isn’t deducted from your allotment, I’m not sure about making two identical fixtures, so I’m saving these for the next time.

Then peel-n-stick the chipboard fragments in their recesses:

Chipboard Fragment Coaster – variety

The first baseplate didn’t have raised rims around the fragments (because there’s no need to retain any epoxy), but the result looked kinda … flat:

Chipboard Fragment Coaster – flat top

Fixing that was a matter of not setting the rim height to zero in the OpenSCAD code.

It’s perfectly functional even without a rim:

Printed Coaster – chipboard inserts – sweaty mug

Protip: White chipboard is a Terrible Idea™ in a quick-n-easy laser cuttery project. All the rest have only red or blue fragments for a good reason.

Conversely, white PETG makes a nice contrast to the deep red and blue.

Prosit!
2026-08-28
Layered Paper: Inkjet Printer Skew
The Summer 2026 issue of Living Bird from the Cornell Bird Lab had a downloadable set of paint-by-number images that seemed tailor-made for laser-cut layered paper, so I laid out a test piece with targets in the corners:

Page 5 – Printed page test piece

Print that on fancy paper, drop it into the Letter cutting fixture, align the printed targets with the layout using the same technique as with the punched cards:
- Position the laser head at the center of a target in the LightBurn workspace
- Skootch the fixture to put the corresponding printed target under the red dot pointer
- Position the laser head at another target
- Skootch the other printed target to match
- Iterate until both align properly
I find that’s faster / easier / no less accurate than Print and Cut.

Then Fire The Laser:

Page 5 – Test piece – cutting

That’s cut over honeycomb, rather than empty space, because there’s not much paper left when the cutting is done and the remaining pieces distort the lacework:

Page 5 – Test piece – as cut

That layer (with binary code 0001) goes under the top black mask hiding the remaining colors on the lacework. The wing feathers and details seemed too small for slots cut into paper, so printing them finessed the issue.

I had aligned the fixture at the upper-right target:

Page 5 – Printed page test piece – cut top-right

And the lower-left target:

Page 5 – Printed page test piece – cut bottom-left

The printed lines are about 0.3 mm wide, so the cut alignment is off by that much in both X and Y.

The lower-right target is spot on:

Page 5 – Printed page test piece – cut bottom-right

But the upper-left target is off by nearly a millimeter in Y:

Page 5 – Printed page test piece – cut top-left

As well as I can measure, the printed image is slightly distorted, perhaps by the printer’s feed rollers skewing the paper slightly on its way through the printer. The laser-cut holes are, again as well as I can measure, dead on.

The punched card process required scaling the composited PNG image by 97%×97.9% so the image matched the laser-evaporated holes. This distortion seems different, but different paper and printer settings surely affect the outcome.

On the whole, though, the first test piece came out OK:

Page 5 – Test piece – stack oblique view

Those chonky feet need some attention.

Maybe three out of four ain’t bad …
2026-08-20
Windows Update Troubles: It’s Not Just You

Spotted on a price scanning terminal during our grocery ride:

Price scanner update in progress

The process continued on all the scanner terminals as we collected our weekly supplies, crashed because a file was missing / locked / whatever, then became a steel-cage death match between whoever was running remote updates and Microsoft Windows:

Price scanner remote support

Given the recent history of catastrophically bad Windows Updates, one might be inclined to consider a different OS for embedded applications, but …

2026-08-19