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: Improvements

Making the world a better place, one piece at a time

  • Handlebar Grip Sleeve

    Handlebar Grip Sleeve

    Mary’s zero-mph crash loosened the starboard handlebar plug enough to let it eventually decamp for parts unknown. Its replacement, a somewhat fancier aluminum plug with an expanding cone retainer using an actual M3 nut, worked fine for the last year, but Mary recently noticed the socket head screw had worked loose.

    In the interim, I’d moved the Bafang thumb control from its original position on the crossbar to just above the rear shifter:

    Tour Easy - right handlebar control stack
    Tour Easy – right handlebar control stack

    Which moved the clamp on the shortened grip off the end of the handlebar tube, so I flipped the grip around, tightened the clamp, and installed the plug.

    Unfortunately, the grip ID is 4 mm larger than the tube ID, which meant the plug’s cone retainer was struggling to hold on in there. Perhaps the plastic cone has relaxed bit, but I figured giving it more traction would be a Good Idea™ before I declared victory:

    Handlebar Grip Sleeve - PrusaSlicer
    Handlebar Grip Sleeve – PrusaSlicer

    It’s a little plastic sleeve with slots to let it expand against the inside of the grip:

    Handlebar grip sleeve - installed
    Handlebar grip sleeve – installed

    Yes, it’s sticking out slightly; you can see the corresponding gap up inside next to the tube.

    A wrap of double-sided sticky tape glues it in place as the retainer presses it against the grip ID and a dot of low-strength Loctite should keep the screw from loosening again.

    The OpenSCAD source code:

    // Handlebar grip sleeve
    // Ed Nisley - KE4ZNU
    // 2025-10-25
    
    include <BOSL2/std.scad>
    
    /* [Hidden] */
    
    ID = 0;
    OD = 1;
    LENGTH = 2;
    
    HoleWindage = 0.2;
    Protrusion = 0.1;
    NumSides = 3*2*4;
    
    $fn=NumSides;
    
    Sleeve = [18.5,22.0,14.0];
    Kerf = 1.0;
    
      difference() {
        tube(Sleeve[LENGTH],id=Sleeve[ID],od=Sleeve[OD],anchor=BOTTOM);
        for (a=[0,90])
          zrot(a)
            up(Sleeve[LENGTH]/4)
              cuboid([2*Sleeve[OD],Kerf,Sleeve[LENGTH]],anchor=BOTTOM);
      }
    
    

    That was easy …

  • Work Sharp Precision Adjust Sharpener: Button Improvement

    Work Sharp Precision Adjust Sharpener: Button Improvement

    A recent professional knife / lopper sharpening convinced me to up my sharpening game, so I figured a Work Sharp Elite sharpener would improve our backup blades:

    Work Sharp Knife Sharpener - overview
    Work Sharp Knife Sharpener – overview

    Protip: Wear gloves, because you’re working in front of an unprotected and eventually very sharp blade.

    The blade-holding clamp snaps magnetically into a rotating chuck so you can flip the knife over, at least if it’s not quite as long as that one. The chuck index has a spring-loaded release button:

    Work Sharp Knife Sharpener - rear view
    Work Sharp Knife Sharpener – rear view

    The spring is powerful and the button arrived with a recess around the screw holding the chuck together:

    Work Sharp Knife Sharpener clamp button - as received
    Work Sharp Knife Sharpener clamp button – as received

    Pressing the button hard enough to release the chuck hurt my index finger, but their Tech Support said it’s like that and that’s the way it is. Turning the screw adjusts the spring compression, but I think this situation calls for “more secure” rather than “easy to push”.

    Fortunately, I have a laser cutter and know how to use it:

    Work Sharp Knife Sharpener clamp button - filled
    Work Sharp Knife Sharpener clamp button – filled

    Despite appearances, it’s a 10 mm disk of 4.3 mm clear acrylic stuck to the screw head with a snippet of white double-sided tape and flush with the surrounding plastic surface.

    A smooth button makes my index finger much happier …

  • 3D Printed Smashed Glass Coasters: Cork Alignment Fixture

    3D Printed Smashed Glass Coasters: Cork Alignment Fixture

    The printed coaster frame sits on a cork base:

    Printed Coaster - inset cork
    Printed Coaster – inset cork

    A sheet of craft adhesive holds them together; stick a generous rectangle of adhesive on the cork, then cut them at the same time. However, given the irregular perimeter, it’s basically impossible (for me, anyway) to align the cork + adhesive with the printed frame.

    A single-use fixture made from corrugated cardboard make that task trivially easy:

    Printed Coaster - cork alignment fixture - detail
    Printed Coaster – cork alignment fixture – detail

    The LightBurn layout shows the cork layer and the two fixture pieces:

    The cork shape is offset 0.5 mm inward from the Perimeter shape, but I found offsetting the cardboard cut by only 0.3 mm inward produced a snug fit around the cork. The other piece of cardboard gets cut with the exact Perimeter shape and no offset, with the laser kerf providing just enough clearance for a very snug fit on the printed shape.

    Align the two pieces of cardboard by eye to match their inner shapes as shown in the picture, tape them together, and the fixture is ready. In principle, the outer edges should exactly coincide: Trust, but verify.

    Peel off the craft adhesive paper and put the cork in the bottom of the fixture. The cork comes off a roll and really wants to roll up again, making the masking tape holding it flat mandatory:

    Printed Coasters - cork alignment template
    Printed Coasters – cork alignment template

    Yes, that’s a different coaster.

    Flip the fixture over, drop the coaster in place, press firmly together, peel the tape, and pull out the finished coaster:

    Printed Coasters - white PETG finished
    Printed Coasters – white PETG finished

    The fixture goes in the recycling bin, as those fragments will never pass this way again.

  • 3D Printed Smashed Glass Coasters: Fragment Path Offsets, Simplified Version

    3D Printed Smashed Glass Coasters: Fragment Path Offsets, Simplified Version

    Rather than use Inkscape or LightBurn to generate all the offsets required to make a solid model, it’s easier to let OpenSCAD handle it:

    Printed Coaster Layout - 100 mm Set G - solid model
    Printed Coaster Layout – 100 mm Set G – solid model

    The overall process:

    • Pick some interesting fragments
    • Scan to get an image
    • Mark the fragments in GIMP
    • Create a suitable circumcircle in LightBurn
    • Use a nesting program like Deepnest to create a nice layout of the fragments within the circle
    • Create the perimeter path as an offset around all the fragments in LightBurn

    Because the fragments have irregular shapes and spacing, creating the perimeter path may also produce small snippets of orphaned geometry which must be manually selected and deleted. I also edit the path to remove very narrow channels between adjacent fragments.

    Which is why you can’t generate that path automatically:

    Printed Coaster Layout - 100 mm Set G - LightBurn perimeter geometry
    Printed Coaster Layout – 100 mm Set G – LightBurn perimeter geometry

    Because LightBurn doesn’t have the ability to name the various paths, the next step requires Inkscape. After importing the LightBurn paths saved as an SVG, group all the fragments and name the group Fragments, then name the perimeter path Perimeter:

    Printed Coaster Layout - 100 mm Set G - Inkscape layer and IDs
    Printed Coaster Layout – 100 mm Set G – Inkscape layer and IDs

    Inkscape still crashes unpredictably while doing what seems to be a simple process, which may be due to the tremendous number of points in the hand-traced fragment outlines. Unfortunately, simplifying the curves in either LightBurn or Inkscape tends to round off the extreme points and increases the likelihood of the fragment not fitting into its recess.

    OpenSCAD generates all the other features in the solid model with paths plucked from that file:

    include <BOSL2/std.scad>
    
    fn = "Printed Fragment Coaster - 100 mm Set G - Inkscape paths.svg";
    
    FragmentThick = 3.8;
    
    BaseThick = 1.0;
    RimHeight = 1.0;
    
    union() {
    
      linear_extrude(h=BaseThick)
        import(fn,id="Perimeter");
    
       color("Green")
      up(BaseThick)
        linear_extrude(h=FragmentThick)
          difference() {
            import(fn,id="Perimeter");
            offset(delta=0.2)
              import(fn,id="Fragments");
          }
    
      color("Red")
      up(BaseThick)
        linear_extrude(h=FragmentThick + RimHeight)
          difference() {
            offset(delta=2.5)
              import(fn,id="Fragments");
            offset(delta=1.2)
              import(fn,id="Fragments");
          }
    
    
    }
    

    The Perimeter path defines the overall shape of the coaster as a 1.0 mm thick slab, visible as the white-ish line around the edge and at the bottom of all the fragment recesses.

    Atop that, the green shape is the same Perimeter shape, with the Fragment shapes removed after the offset() operation enlarges them by 0.2 mm to ensure enough clearance.

    Finally, the red walls containing the epoxy above each fragment are 1.3 mm wide, the difference of the two offset() operations applied to the Fragments.

    Because the outer edge of the wall is 2.5 mm away from the edge of its fragment:

    • The Perimeter path must be offset at least 2.5 mm from the Fragments in LightBurn. I used 4.0 mm to produce a small lip around the outside edge of the coaster.
    • The fragment shapes must be placed at least 5.0 mm apart to prevent the walls from overlapping. I set Deepnest to exactly 5.0 mm spacing, but you can see a few places where the fragments come too close together. I think this happens due to an approximation deepnest uses while rotating the paths, but it may be better to manually adjust the errant fragments than increase the average space.

    While this still requires manually tracing the glass fragments and fiddling a bit with Inkscape, the overall process isn’t nearly as burdensome as getting all the offsets correct every time.

    However, some oddities remain. OpenSCAD produced this result during the first pass through the process for this coaster:

    Printed Coaster Layout - 100 mm Set G - spurious point
    Printed Coaster Layout – 100 mm Set G – spurious point

    As far as I can tell, the spurious point came from a numeric effect, because telling Inkscape to store only five decimal places in the SVG file reduced the spike to the small bump seen in the first picture. I cannot replicate that effect using the same files and have no explanation.

  • 3D Printed Smashed Glass Coasters: Fragment Layout

    3D Printed Smashed Glass Coasters: Fragment Layout

    I selected and laid out the smashed glass fragments for the first few coasters by hand:

    Smashed Glass - 4in - group A - tweaked
    Smashed Glass – 4in – group A – tweaked

    Which worked reasonably well for coasters with a rim around the perimeter to hold in the epoxy covering the entire top surface:

    Printed Coaster Layout - solid model
    Printed Coaster Layout – solid model

    The problem with smooth-top coasters is this:

    Printed Coasters - epoxy fill
    Printed Coasters – epoxy fill

    A slightly sweaty or wet mug can get a firm suction lock on that smooth top, lift the coaster off the table, then drop it into a plate of food.

    So I put a rim around each fragment to separate the epoxy surfaces and break the suction lock:

    Printed Coaster Layout - 5 inch Set B
    Printed Coaster Layout – 5 inch Set B

    Each recess has a narrow inner lip as a border inside the raised perimeter, which may not be strictly necessary, but IMO nicely sets off the fragments:

    Smashed Glass 3D Printed Coaster - Set B
    Smashed Glass 3D Printed Coaster – Set B

    Each fragment must be spaced far enough from its three neighbors to allow for those lips and perimeter walls, which requires more fussing than I’m willing to apply on a regular basis.

    So fetch & install Deepnest to fuss automagically. The program hasn’t been updated in years and the Linux version segfaults on my Manjaro boxen, but the Windows version runs fine on the Mini-PC I use for LightBurn:

    Deepnest Fragment Set E - in progress
    Deepnest Fragment Set E – in progress

    The Mini-PC runs maxi-hot, though, so at some point I must install Deepnest on the Token Windows Laptop for more grunt.

    Deepnest requires a large shape representing the “sheet” in which to arrange the other pieces, so:

    • Import the fragments outlines into LightBurn
    • Create a suitable circle
    • Export circle + fragments as an SVG file
    • Import into Deepnest
    • Set 5 mm spacing & other suitable parameters
    • Let it grind until a nice arrangement pops out
    • Save as Yet Another SVG file

    The output SVG has the fragment outlines arranged to fit within the circle, but does not include the circle. That’s fine, because the next step involves creating a conformal perimeter around the entire group of fragments and preparing it for input to OpenSCAD to create a solid model:

    Printed Coaster Layout - 5 inch Set C - solid model
    Printed Coaster Layout – 5 inch Set C – solid model

    So. Many. Smashed. Glass.

  • 3D Printed Smashed Glass Coasters: Optimization

    3D Printed Smashed Glass Coasters: Optimization

    A pair of 3D printed smashed glass coasters for a friend:

    Printed Coasters - in use
    Printed Coasters – in use

    The black PETG coaster under the French Press:

    Printed Coasters - black PETG finished
    Printed Coasters – black PETG finished

    The white PETG coaster under the mug:

    Printed Coasters - white PETG finished
    Printed Coasters – white PETG finished

    They’re considerably improved from the first attempt:

    Smashed glass printed coaster - front view
    Smashed glass printed coaster – front view

    More details to follow …

  • Dryer Vent Filter Snout

    Dryer Vent Filter Snout

    The first step in adding a filter bag to the dryer vent requires a convenient way to attach it. Because we live in the future, a couple of hours of 3D printing produced something that might work:

    Clothes Dryer Vent Filter Snout - installed
    Clothes Dryer Vent Filter Snout – installed

    It’s made of TPU, which is bendy enough to ease two tabs into the two outermost slots you can see and a corresponding pair of tabs into slots on the wall side.

    The solid model shows the part snapped inside the vent:

    Clothes Dryer Vent Filter Snout - OpenSCAD show
    Clothes Dryer Vent Filter Snout – OpenSCAD show

    The flared bottom takes something like three hours to print (TPU likes slooow extrusion), so I did the top ring first to verify the tab fit:

    Clothes Dryer Vent Filter Snout - OpenSCAD build
    Clothes Dryer Vent Filter Snout – OpenSCAD build

    Both parts come from hull() surfaces wrapped around quartets of thin circles at the proper positions; the difference() of two slightly different hulls produces thin shells.

    A thin layer of JB PlasticBonder urethane adhesive, which bonds TPU like glue, holds the two parts together. I used the tan variant and, while it’s not a perfect match, it definitely looks better than black. Not that it matters in this case.

    Mary will sew up a bag with a drawstring holding it to the snout. If everything survives the performance tests, printing the whole snout in one four-hour job will both make sense and eliminate an uneven joint that’s sure to be a lint-catcher.

    The OpenSCAD source code as a GitHub Gist:

    // Clothes dryer vent filter snout
    // Ed Nisley – KE4ZNU
    // 2025-10-07
    include <BOSL2/std.scad>
    Layout = "Ring"; // [Show,Build,Ring,Taper]
    /* [Hidden] */
    ID = 0;
    OD = 1;
    LENGTH = 2;
    HoleWindage = 0.2;
    Protrusion = 0.1;
    NumSides = 4*3*2*4;
    $fn=NumSides;
    Gap = 5.0;
    // Centers of corner rounding circles
    InnerWidth = 3.0; // wall inside snout
    InnerRadius = 6.0; // inner corner rounding
    RR = [130.0/2 – InnerRadius,91.0/2 – InnerRadius]; // right rear corner
    RF = [112.0/2 – InnerRadius,-(91.0/2 – InnerRadius)]; // right front corner
    CornerCtrs = [[RR.x,RR.y],[RF.x,RF.y],[-RF.x,RF.y],[-RR.x,RR.y]]; // clockwise from RR
    InsertHeight = 7.0; // overall height inside the snout
    TabOC = [73.0,91.0]; // tabs locking into snout
    TabCtrs = [[TabOC.x/2,TabOC.y/2],[TabOC.x/2,-TabOC.y/2],[-TabOC.x/2,-TabOC.y/2],[-TabOC.x/2,TabOC.y/2]];
    TabRadius = 5.0;
    TabHeight = 3.0;
    TaperHeight = 20.0; // Taper holding filter bag
    TaperRadius = 10.0; // outward to capture bag string
    TaperWidth = 2.0; // wall width
    TaperCtrs = CornerCtrs + [[0,-(TaperRadius – InnerWidth)],[0,0],[0,0],[0,-(TaperRadius – InnerWidth)]];
    //—–
    // Clear inside vent opening as 2D shape
    module Opening() {
    hull()
    for (p = CornerCtrs)
    translate(p)
    circle(r=InnerRadius);
    }
    //—–
    // Insert ring locking into vent snout
    module Ring() {
    difference() {
    union() {
    linear_extrude(h=InsertHeight)
    offset(delta=InnerWidth)
    hull()
    for (p = CornerCtrs)
    translate(p)
    circle(r=InnerRadius);
    up(InsertHeight – TabHeight)
    linear_extrude(h=TabHeight)
    for (p = TabCtrs)
    translate(p)
    circle(r=TabRadius);
    }
    down(Protrusion)
    linear_extrude(h=2*InsertHeight)
    Opening();
    }
    }
    //—–
    // Taper glued to ring
    module Taper() {
    difference() {
    hull() {
    up(TaperHeight)
    linear_extrude(h=Protrusion)
    offset(delta=InnerWidth)
    hull()
    for (p = CornerCtrs)
    translate(p)
    circle(r=InnerRadius);
    linear_extrude(h=Protrusion)
    offset(delta=TaperRadius)
    hull()
    for (p = TaperCtrs)
    translate(p)
    circle(r=TaperRadius);
    }
    hull() {
    up(TaperHeight)
    linear_extrude(h=2*Protrusion)
    offset(delta=InnerWidth)
    hull()
    for (p = CornerCtrs)
    translate(p)
    circle(r=InnerRadius – InnerWidth);
    down(Protrusion)
    linear_extrude(h=2*Protrusion)
    offset(delta=TaperRadius – TaperWidth)
    hull()
    for (p = TaperCtrs)
    translate(p)
    circle(r=TaperRadius);
    }
    }
    }
    //—–
    // Build things
    if (Layout == "Ring")
    Ring();
    if (Layout == "Taper")
    Taper();
    if (Layout == "Show") {
    up(TaperHeight)
    Ring();
    Taper();
    }
    if (Layout == "Build") {
    back(55)
    up(InsertHeight)
    yrot(180)
    Ring();
    fwd(55)
    up(TaperHeight)
    yrot(180)
    Taper();
    }