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

Using and tweaking a Makergear M2 3D printer

  • Threaded Brass Inserts: Test to Destruction

    With an outmoded LM12UU linear bearing drag knife mount on hand, I threaded an M4 screw into each brass insert, lined it up on a hole in a homebrew (by a long-gone machinist, not me) steel bench block, and applied pressure with the drill press until the insert tore out:

    Brass Insert Retention test - A B
    Brass Insert Retention test – A B

    The retina-burn orange ring is printed in PETG with my usual slicer settings: three perimeter threads, three top and bottom layers, and 15% 3D honeycomb infill. That combination is strong enough and stiff enough for essentially everything I do around here.

    The insert on the left came out of its hole carrying its layer of epoxy: the epoxy-to-hole bond failed first. Despite that, punching it out required enough force to convince me it wasn’t going anywhere on its own.

    The column of plastic around the insert standing up from the top fits into the central hole (hidden in the picture) in the bench block. Basically, the edge of the hole applied enough shear force to the plastic to break the infill before the epoxy tore free, with me applying enough grunt to the drill press quill handle to suggest I should get a real arbor press if I’m going to keep doing this.

    The third insert maintained a similar grip, as seen from the left:

    Brass Insert Retention test - C left
    Brass Insert Retention test – C left

    And the right:

    Brass Insert Retention test - C right
    Brass Insert Retention test – C right

    The perimeter threads around the hole tore away from the infill, with the surface shearing as the plastic column punched through.

    Bottom line: a dab of epoxy anchors an insert far better than the 3D printed structure around it can support!

  • MPCNC Collet Pen Holder: LM12UU Edition

    Encouraged by the smooth running of the LM12UU drag knife mount, I chopped off another length of 12 mm shaft:

    LM12UU Collet Pen Holder - sawing shaft
    LM12UU Collet Pen Holder – sawing shaft

    The MicroMark Cut-off saw was barely up to the task; I must do something about its craptastic “vise”. In any event, the wet rags kept the shaft plenty cool and the ShopVac hose directly behind the motor sucked away all of the flying grit.

    The reason I used an abrasive wheel: the shaft is case-hardened and the outer millimeter or two is hard enough to repel a carbide cutter:

    LM12UU Collet Pen Holder - drilling shaft
    LM12UU Collet Pen Holder – drilling shaft

    Fortunately, the middle remains soft enough to drill a hole for the collet pen holder, which I turned down to a uniform 8 mm (-ish) diameter:

    LM12UU Collet Pen Holder - turning collet body
    LM12UU Collet Pen Holder – turning collet body

    Slather JB Kwik epoxy along the threads, insert into the shaft, wipe off the excess, and it almost looks like a Real Product:

    LM12UU Collet Pen Holder - finished body
    LM12UU Collet Pen Holder – finished body

    The far end of the shaft recesses the collet a few millimeters to retain the spring around the pen body, which will also require a knurled ring around the outside so you (well, I) can tighten the collet around the pen tip.

    Start the ring by center-drilling an absurdly long aluminum rod in the steady rest:

    M12UU Collet Pen Holder - center drilling
    M12UU Collet Pen Holder – center drilling

    Although it’s not obvious, I cleaned up the OD before applying the knurling tool:

    LM12UU Collet Pen Holder - knurling
    LM12UU Collet Pen Holder – knurling

    For some unknown reason, it seemed like a Good Idea to knurl without the steady rest, perhaps to avoid deepening the ring where the jaws slide, but Tiny Lathe™ definitely wasn’t up to the challenge. The knurling wheels aren’t quite concentric on their bores and their shafts have plenty of play, so I got to watch the big live center and tailstock wobbulate as the rod turned.

    With the steady rest back in place, drill out the rod to match the shaft’s 12 mm OD:

    LM12UU Collet Pen Holder - drilling shaft
    LM12UU Collet Pen Holder – drilling shaft

    All my “metric” drilling uses hard-inch drills approximating the metric dimensions, of course, because USA.

    Clean up the ring face, file a chamfer on the edge, and part it off:

    LM12UU Collet Pen Holder - parting ring
    LM12UU Collet Pen Holder – parting ring

    Turn some PVC pipe to a suitable length, slit one side so it can collapse to match the ring OD, wrap shimstock to protect those lovely knurls, and face off all the ugly:

    LM12UU Collet Pen Holder - knurled ring facing
    LM12UU Collet Pen Holder – knurled ring facing

    Tweak the drag knife’s solid model for a different spring from the collection and up the hole OD in the plate to clear the largest pen cartridge in the current collection:

    Collet Holder - LM12UU - solid model
    Collet Holder – LM12UU – solid model

    Convince all the parts to fly in formation, then measure the spring rate:

    LM12UU Collet Pen Holder - spring rate test
    LM12UU Collet Pen Holder – spring rate test

    Which works out to be 128 g + 54 g/mm:

    LM12UU Collet Pen Holder - test plot - overview
    LM12UU Collet Pen Holder – test plot – overview

    I forgot the knurled ring must clear the screws and, ideally, the nyloc nuts. Which it does, after I carefully aligned each nut with a flat exactly tangent to the ring. Whew!

    A closer look at the business end:

    LM12UU Collet Pen Holder - test plot - detail
    LM12UU Collet Pen Holder – test plot – detail

    The shaft has 5 mm of travel, far more than enough for the MPCNC’s platform. Plotting at -1 mm applies 180 g of downforce; the test pattern shown above varies the depth from 0.0 mm in steps of -0.1 mm; anything beyond -0.2 mm gets plenty of ink.

    Now I have a pen holder, a diamond scribe, and a drag knife with (almost) exactly the same “tool offset” from the alignment camera, thereby eliminating an opportunity to screw up.

    The OpenSCAD source code as a GitHub Gist:

    // Collet pen cartridge holder using LM12UU linear bearing
    // Ed Nisley KE4ZNU – 2019-04-26
    // 2019-06 Adapted from LM12UU drag knife holder
    Layout = "Build"; // [Build, Show, Puck, Mount, Plate]
    /* [Extrusion] */
    ThreadThick = 0.25; // [0.20, 0.25]
    ThreadWidth = 0.40; // [0.40]
    /* [Hidden] */
    Protrusion = 0.1; // [0.01, 0.1]
    HoleWindage = 0.2;
    inch = 25.4;
    function IntegerMultiple(Size,Unit) = Unit * ceil(Size / Unit);
    ID = 0;
    OD = 1;
    LENGTH = 2;
    //- Adjust hole diameter to make the size come out right
    module PolyCyl(Dia,Height,ForceSides=0) { // based on nophead's polyholes
    Sides = (ForceSides != 0) ? ForceSides : (ceil(Dia) + 2);
    FixDia = Dia / cos(180/Sides);
    cylinder(r=(FixDia + HoleWindage)/2,h=Height,$fn=Sides);
    }
    //- Dimensions
    // Basic shape of DW660 snout fitting into the holder
    // Lip goes upward to lock into MPCNC mount
    Snout = [44.6,50.0,9.6]; // LENGTH = ID height
    Lip = 4.0; // height of lip at end of snout
    // Holder & suchlike
    Spring = [8.8,10.0,3*ThreadThick]; // compression spring loading knife blade
    PenShaft = 4.5; // hole to pass pen cartridge
    WallThick = 4.0; // minimum thickness / width
    Screw = [4.0,8.5,25.0]; // thread ID, washer OD, length
    Insert = [4.0,6.0,10.0]; // brass insert
    Bearing = [12.0,21.0,30.0]; // linear bearing body
    Plate = [PenShaft,Snout[OD] – WallThick,WallThick]; // spring reaction plate
    echo(str("Plate: ",Plate));
    SpringSeat = [0.56,7.2,2*ThreadThick]; // wire = ID, coil = OD, seat depth = length
    PuckOAL = max(Bearing[LENGTH],(Snout[LENGTH] + Lip)); // total height of DW660 fitting
    echo(str("PuckOAL: ",PuckOAL));
    Key = [Snout[ID],25.7,(Snout[LENGTH] + Lip)]; // rectangular key
    NumScrews = 3;
    //ScrewBCD = 2.0*(Bearing[OD]/2 + Insert[OD]/2 + WallThick);
    ScrewBCD = (Snout[ID] + Bearing[OD])/2;
    echo(str("Screw BCD: ",ScrewBCD));
    NumSides = 9*4; // cylinder facets (multiple of 3 for lathe trimming)
    module DW660Puck() {
    translate([0,0,PuckOAL])
    rotate([180,0,0]) {
    cylinder(d=Snout[OD],h=Lip/2,$fn=NumSides);
    translate([0,0,Lip/2])
    cylinder(d1=Snout[OD],d2=Snout[ID],h=Lip/2,$fn=NumSides);
    cylinder(d=Snout[ID],h=(Snout[LENGTH] + Lip),$fn=NumSides);
    translate([0,0,(Snout[LENGTH] + Lip) – Protrusion])
    cylinder(d1=Snout[ID],d2=2*WallThick + Bearing[OD],h=PuckOAL – (Snout[LENGTH] + Lip),$fn=NumSides);
    intersection() {
    translate([0,0,0*Lip + Key.z/2])
    cube(Key,center=true);
    cylinder(d=Snout[OD],h=Lip + Key.z,$fn=NumSides);
    }
    }
    }
    module MountBase() {
    difference() {
    DW660Puck();
    translate([0,0,-Protrusion]) // bearing
    PolyCyl(Bearing[OD],2*PuckOAL,NumSides);
    for (i=[0:NumScrews – 1]) // clamp screws
    rotate(i*360/NumScrews)
    translate([ScrewBCD/2,0,-Protrusion])
    rotate(180/8)
    PolyCyl(Insert[OD],2*PuckOAL,8);
    }
    }
    module SpringPlate() {
    difference() {
    cylinder(d=Plate[OD],h=Plate[LENGTH],$fn=NumSides);
    translate([0,0,-Protrusion]) // pen cartridge hole
    PolyCyl(PenShaft,2*Plate[LENGTH],NumSides);
    translate([0,0,Plate[LENGTH] – Spring[LENGTH]]) // spring retaining recess
    PolyCyl(Spring[OD],Spring[LENGTH] + Protrusion,NumSides);
    for (i=[0:NumScrews – 1]) // clamp screws
    rotate(i*360/NumScrews)
    translate([ScrewBCD/2,0,-Protrusion])
    rotate(180/8)
    PolyCyl(Screw[ID],2*PuckOAL,8);
    if (false)
    for (i=[0:NumScrews – 1]) // coil positioning recess
    rotate(i*360/NumScrews)
    translate([ScrewBCD/2,0,-Protrusion])
    rotate(180/8)
    PolyCyl(SpringSeat[OD],SpringSeat[LENGTH] + Protrusion,8);
    }
    }
    //—–
    // Build it
    if (Layout == "Puck")
    DW660Puck();
    if (Layout == "Plate")
    SpringPlate();
    if (Layout == "Mount")
    MountBase();
    if (Layout == "Show") {
    MountBase();
    translate([0,0,1.6*PuckOAL])
    rotate([180,0,0])
    SpringPlate();
    }
    if (Layout == "Build") {
    translate([0,Snout[OD]/2,PuckOAL])
    rotate([180,0,0])
    MountBase();
    translate([0,-Snout[OD]/2,0])
    SpringPlate();
    }

  • MPCNC Diamond Engraver: LM3UU Bearings, Second Pass

    Having a single spring and a fixed upper plate works much better than the first version:

    Diamond Scribe - LM3UU Rev 2 - overview
    Diamond Scribe – LM3UU Rev 2 – overview

    The (lubricated!) nyloc nuts under the plate provide a little friction and stabilize the whole affair.

    The solid model has the same stylin’ tapered snout as the LM12UU drag knife mount:

    Diamond Scribe - LM3UU bearings
    Diamond Scribe – LM3UU bearings

    The spring seats in the plate recess, with the 3 mm shank passing through the hole as the tool holder presses the tip against the workpiece.

    I diamond-filed a broken carbide end mill to make a slotting tool:

    Diamond Scribe - LM3UU - Rev 2 - carbide notch tool
    Diamond Scribe – LM3UU – Rev 2 – carbide notch tool

    Lacking any better method (“a tiny clip spreader tool”), I rammed the Jesus clip the length of the shank with a (loose-fitting) chuck in the tailstock:

    Diamond Scribe - LM3UU - Rev 2 - clip installation
    Diamond Scribe – LM3UU – Rev 2 – clip installation

    Even without nyloc nuts, the first test worked fine:

    Diamond Scribe - LM3UU - Rev 2 - first light
    Diamond Scribe – LM3UU – Rev 2 – first light

    The 53 g/mm spring rate may be too low for serious engraving, but it suffices for subtle Guilloché patterns on scrap platters.

    The OpenSCAD source code as a GitHub Gist:

    // Drag Knife Holder using LM12UU linear bearing
    // Ed Nisley KE4ZNU – 2019-04-26
    // 2019-05-09 LM3UU for diamond scribe
    // 2019-05-28 taper end, single spring around shaft
    Layout = "Build"; // [Build, Show, Puck, Mount, Plate]
    /* [Extrusion] */
    ThreadThick = 0.25; // [0.20, 0.25]
    ThreadWidth = 0.40; // [0.40, 0.40]
    /* [Hidden] */
    Protrusion = 0.1; // [0.01, 0.1]
    HoleWindage = 0.2;
    inch = 25.4;
    function IntegerMultiple(Size,Unit) = Unit * ceil(Size / Unit);
    ID = 0;
    OD = 1;
    LENGTH = 2;
    //- Adjust hole diameter to make the size come out right
    module PolyCyl(Dia,Height,ForceSides=0) { // based on nophead's polyholes
    Sides = (ForceSides != 0) ? ForceSides : (ceil(Dia) + 2);
    FixDia = Dia / cos(180/Sides);
    cylinder(r=(FixDia + HoleWindage)/2,h=Height,$fn=Sides);
    }
    //- Dimensions
    // Knife holder & suchlike
    KnifeBody = [3.0,9.0,2.0]; // washer epoxied to diamond shaft, with epoxy fillet
    Spring = [9.5,10.0,3*ThreadThick]; // compression spring around shaft, LENGTH = socket depth
    WallThick = 4.0; // minimum thickness / width
    Screw = [4.0,8.5,8.0]; // holding it all together, OD = washer
    Insert = [4.0,6.0,10.0]; // brass insert
    Bearing = [3.0,7.0,2*10.0 + WallThick]; // linear bearing body (pair + small gap)
    // Basic shape of DW660 snout fitting into the holder
    // Lip goes upward to lock into MPCNC mount
    Snout = [44.6,50.0,9.6]; // LENGTH = ID height
    Lip = 4.0; // height of lip at end of snout
    Plate = [KnifeBody[ID],Snout[OD] – WallThick,WallThick]; // spring reaction plate
    PuckOAL = max(Bearing[LENGTH],(Snout[LENGTH] + Lip)); // total height of DW660 fitting
    echo(str("PuckOAL: ",PuckOAL));
    Key = [Snout[ID],25.7,(Snout[LENGTH] + Lip)]; // rectangular key
    NumScrews = 3;
    ScrewBCD = 2.5*(Bearing[OD]/2 + Insert[OD]/2 + WallThick);
    NumSides = 9*4; // cylinder facets (multiple of 3 for lathe trimming)
    module DW660Puck() {
    translate([0,0,PuckOAL])
    rotate([180,0,0]) {
    cylinder(d=Snout[OD],h=Lip/2,$fn=NumSides);
    translate([0,0,Lip/2])
    cylinder(d1=Snout[OD],d2=Snout[ID],h=Lip/2,$fn=NumSides);
    cylinder(d=Snout[ID],h=(Snout[LENGTH] + Lip),$fn=NumSides);
    translate([0,0,(Snout[LENGTH] + Lip) – Protrusion])
    cylinder(d1=Snout[ID],d2=2*WallThick + Bearing[OD],h=PuckOAL – (Snout[LENGTH] + Lip),$fn=NumSides);
    intersection() {
    translate([0,0,0*Lip + Key.z/2])
    cube(Key,center=true);
    cylinder(d=Snout[OD],h=Lip + Key.z,$fn=NumSides);
    }
    }
    }
    module MountBase() {
    difference() {
    DW660Puck();
    translate([0,0,-Protrusion]) // bearing
    PolyCyl(Bearing[OD],2*PuckOAL,NumSides);
    for (i=[0:NumScrews – 1]) // clamp screws
    rotate(i*360/NumScrews)
    translate([ScrewBCD/2,0,-Protrusion])
    rotate(180/8)
    PolyCyl(Insert[OD],2*PuckOAL,8);
    }
    }
    module SpringPlate() {
    difference() {
    cylinder(d=Plate[OD],h=Plate[LENGTH],$fn=NumSides);
    translate([0,0,-Protrusion]) // ample shaft clearance
    PolyCyl(1.5*KnifeBody[ID],2*PuckOAL,NumSides);
    // translate([0,0,Plate[LENGTH] – KnifeBody[LENGTH]]) // flange, snug fit
    // PolyCyl(KnifeBody[OD],KnifeBody[LENGTH] + Protrusion,NumSides);
    translate([0,0,Plate[LENGTH] – Spring[LENGTH]]) // spring retainer
    PolyCyl(Spring[OD],Spring[LENGTH] + Protrusion,NumSides);
    for (i=[0:NumScrews – 1]) // clamp screws
    rotate(i*360/NumScrews)
    translate([ScrewBCD/2,0,-Protrusion])
    rotate(180/8)
    PolyCyl(Screw[ID],2*PuckOAL,8);
    }
    }
    //—–
    // Build it
    if (Layout == "Puck")
    DW660Puck();
    if (Layout == "Plate")
    SpringPlate();
    if (Layout == "Mount")
    MountBase();
    if (Layout == "Show") {
    MountBase();
    translate([0,0,1.5*PuckOAL])
    rotate([180,0,0])
    SpringPlate();
    }
    if (Layout == "Build") {
    translate([0,Snout[OD]/2,PuckOAL])
    rotate([180,0,0])
    MountBase();
    translate([0,-Snout[OD]/2,0])
    SpringPlate();
    }

  • Garden Soaker Hose Connector Repair

    Two of Mary’s garden soaker hoses failed their pre-installation checks with leaks from around their connectors. The problem seemed to be a break in the hose inside the connector, with water spewing out of the connector around the hose. Having previously fixed a gash in another hose, I figured I might have some success at fixing these leaks.

    The general idea is to squish enough silicone rubber inside the connector to seal around the hose, then clamp the hose and connector snugly enough to hold the rubber in place:

    Soaker Hose Connector Clamp - Show view
    Soaker Hose Connector Clamp – Show view

    The enlarged recess fits around the brass connector shell, which is squashed loosely around the hose and from which the leaking water emerges. Of course, because this is a different hose, the previous model didn’t quite fit and I had to doodle up new geometry:

    Soaker Hose Connector repair - Dimension doodle
    Soaker Hose Connector repair – Dimension doodle

    As before, I bandsawed aluminum backing plates to ensure the plastic didn’t get all bendy in the middle:

    Soaker hose connector leak clamps
    Soaker hose connector leak clamps

    The hose clamp (!) around the connector on the far right ensures a split in the brass shell doesn’t get any larger.

    They’ll spend the rest of their lives under the garden mulch, where nobody will ever see those bulky lumps. Life is good!

    The OpenSCAD source code as a GitHub Gist:

    // Rubber Soaker Hose End Connector Clamp
    // Helps hold silicone rubber in connector
    // Ed Nisley KE4ZNU June 2019
    Layout = "Build"; // [Hose,Connector,Block,Show,Build]
    //- Extrusion parameters must match reality!
    /* [Hidden] */
    ThreadThick = 0.25;
    ThreadWidth = 0.40;
    HoleWindage = 0.2;
    Protrusion = 0.1; // make holes end cleanly
    inch = 25.4;
    function IntegerMultiple(Size,Unit) = Unit * ceil(Size / Unit);
    //———-
    // Dimensions
    // Hose lies along X axis
    Hose = [200,26.5,11.6]; // X=very long, Y=width, Z=overall height
    RimThick = 10.3; // outer sections
    RimOD = RimThick;
    RimFlatRecess = 1.0; // recess to front flat surface
    OuterOC = Hose.y – RimOD; // outer tube centers
    RecessM = 0.8; // back recess chord
    RecessC = OuterOC;
    RecessR = (pow(RecessM,2) + pow(RecessC,2)/4) / (2*RecessM);
    RidgeM = 1.6; // front ridge chord
    RidgeC = 7.5;
    RidgeR = (pow(RidgeM,2) + pow(RidgeC,2)/4) / (2*RidgeM);
    HoseSides = 12*4;
    Connector = [5.0,33.0,13.0]; // oval brass: X=snout Y=width Z=dia
    Block = [20.0,50.0,4.0 + Hose.z]; // overall splice block size
    echo(str("Block: ",Block));
    Kerf = 0.5; // cut through middle to apply compression
    ID = 0;
    OD = 1;
    LENGTH = 2;
    // 8-32 stainless screws
    Screw = [4.1,8.0,3.0]; // OD = head LENGTH = head thickness
    Washer = [4.4,9.5,1.0];
    Nut = [4.1,9.7,6.0];
    CornerRadius = Washer[OD]/2;
    ScrewOC = Block.y – 2*CornerRadius;
    echo(str("Screw OC: x=",ScrewOC.x," y=",ScrewOC.y));
    //———————-
    // Useful routines
    module PolyCyl(Dia,Height,ForceSides=0) { // based on nophead's polyholes
    Sides = (ForceSides != 0) ? ForceSides : (ceil(Dia) + 2);
    FixDia = Dia / cos(180/Sides);
    cylinder(d=(FixDia + HoleWindage),h=Height,$fn=Sides);
    }
    // Hose shape
    // This includes magic numbers measured from reality
    module HoseProfile() {
    rotate([0,-90,0])
    translate([0,0,-Hose.x/2])
    linear_extrude(height=Hose.x,convexity=4)
    difference() {
    union() {
    for (j=[-1,1]) // outer channels
    translate([0,j*OuterOC/2])
    circle(d=RimOD,$fn=HoseSides);
    translate([-RimOD/4,0]) // rear flat fill
    square([RimOD/2,OuterOC],center=true);
    translate([(RimOD/4 – RimFlatRecess),0]) // front flat fill
    square([RimOD/2,OuterOC],center=true);
    intersection() {
    translate([Hose.z/2,0])
    square([Hose.z,OuterOC],center=true);
    translate([-RidgeR + RimOD/2 – RimFlatRecess + RidgeM,0])
    circle(r=RidgeR,$fn=HoseSides);
    }
    }
    translate([-(RecessR + RimOD/2 – RecessM),0])
    circle(r=RecessR,$fn=2*HoseSides);
    }
    }
    // Outside shape of splice Block
    // Z centered on hose rim circles, not overall thickness through center ridge
    module SpliceBlock() {
    difference() {
    hull()
    for (i=[-1,1], j=[-1,1]) // rounded block
    translate([i*(Block.x/2 – CornerRadius),j*(Block.y/2 – CornerRadius),-Block.z/2])
    cylinder(r=CornerRadius,h=Block.z,$fn=4*8);
    for (j=[-1,1]) // screw holes
    translate([0,
    j*ScrewOC/2,
    -(Block.z/2 + Protrusion)])
    PolyCyl(Screw[ID],Block.z + 2*Protrusion,6);
    cube([2*Block.x,2*Block.y,Kerf],center=true); // slice through center
    }
    }
    // Splice block less hose
    module ShapedBlock() {
    difference() {
    SpliceBlock();
    HoseProfile();
    Connector();
    }
    }
    // Brass connector end
    module Connector() {
    translate([-(Block.x/2 + Protrusion),0,0])
    rotate([0,90,0])
    linear_extrude(height=Connector.x + Protrusion)
    hull()
    for (i = [-1,1])
    translate([0,i*(Connector.y – Connector.z)/2])
    circle(d=Connector.z);
    }
    //———-
    // Build them
    if (Layout == "Hose")
    HoseProfile();
    if (Layout == "Block")
    SpliceBlock();
    if (Layout == "Connector")
    Connector();
    if (Layout == "Show") {
    ShapedBlock();
    color("Green",0.25)
    HoseProfile();
    }
    if (Layout == "Build") {
    SliceOffset = 0;
    intersection() {
    translate([SliceOffset,0,Block.z/4])
    cube([4*Block.x,4*Block.y,Block.z/2],center=true);
    union() {
    translate([0,0.6*Block.y,Block.z/2])
    ShapedBlock();
    translate([0,-0.6*Block.y,Block.z/2])
    rotate([0,180,0])
    ShapedBlock();
    }
    }
    }

  • Kitchen Blender Base Spacer

    We don’t use the blender much, so the most recent bearing replacement continues to work. I never got around to re-making the overly long shaft spacer from the first bearing replacement, which I compensated for with a spacer kludge cut from a random chunk of bendy plastic sheet.

    Which we put up with For. Eleven. Years.

    The blender recently emerged from hiding and, with my solid modeling-fu cranked up to a dangerous chattering whine, I conjured a real spacer:

    Blender base spacer - Slic3r preview
    Blender base spacer – Slic3r preview

    It pretty much disappears into the blender base, which is the whole point of the operation:

    Blender base spacer - installed
    Blender base spacer – installed

    When the bearings fail again, I promise to make a proper shaft spacer and toss this bodge.

    The OpenSCAD code as a GitHub Gist:

    // Kitchen blender base adapter
    // Ed Nisley KE4ZNU June 2019
    //- Extrusion parameters must match reality!
    /* [Hidden] */
    ThreadThick = 0.25;
    ThreadWidth = 0.40;
    HoleWindage = 0.2;
    Protrusion = 0.1; // make holes end cleanly
    inch = 25.4;
    function IntegerMultiple(Size,Unit) = Unit * ceil(Size / Unit);
    ID = 0;
    OD = 1;
    LENGTH = 2;
    //———-
    // Just build it
    Spacer = [48.0,66.0,1.8]; // LENGTH raises blade holder
    Aligner = [Spacer[ID],52.0,Spacer[LENGTH] + 3.0]; // LENGTH locks into base ring
    NumSides = 4*3*4;
    //———-
    // Just build it
    difference() {
    union() {
    cylinder(d=Spacer[OD],h=IntegerMultiple(Spacer[LENGTH],ThreadThick),$fn=NumSides);
    cylinder(d=Aligner[OD],h=Aligner[LENGTH],$fn=NumSides);
    }
    translate([0,0,-Protrusion])
    cylinder(d=Spacer[ID],h=10*Aligner[LENGTH],$fn=NumSides);
    }

    Not that it really deserves so much attention …

  • MPCNC Drag Knife: Ground Shaft in LM12UU Bearing

    The 12 mm drag knife holder on the left slides nicely in an LM12UU bearing:

    Drag Knife holders - detail
    Drag Knife holders – detail

    However, its aluminum body isn’t really intended as a bearing surface and it extends only halfway through the LM12UU, so I finally got around to modifying the 11.5 mm body on the right to fit into a section of 12 mm ground shaft:

    Drag Knife - turning 11.5 mm body to 10 mm
    Drag Knife – turning 11.5 mm body to 10 mm

    The general idea is to turn the body down to 10 mm OD; the picture shows the first pass over the nose after turning the far end down and removing the flange in the process. Exact concentricity of both ends isn’t important (it gets epoxied into a 10 mm hole through the 12 mm ground shaft), but it came out rather pretty:

    Drag Knife - 11.5 mm body - turned to 10 mm
    Drag Knife – 11.5 mm body – turned to 10 mm

    The ground shaft started as a pen holder:

    DW660 Pen Holder - ground shaft
    DW660 Pen Holder – ground shaft

    I knocked off the ring and bored the interior to fit the 10 mm knife body. The large end of the existing bore came from a 25/64 inch = 9.92 mm drill, so it was just shy of 10.0 mm, and I drilled the small end upward from 0.33 inch = 8.4 mm.

    The smallest trio of a new set of cheap carbide boring bars allegedly went into a 5/16 inch = 7.9 mm bore, but I had to file the bar body down and diamond-file more end relief into the carbide for clearance inside the drilled hole:

    Modified boring bar vs original
    Modified boring bar vs original

    I blued the bit, kissed it against the drilled bore, filed off whatever wasn’t blued, and iterated until the carbide edge started cutting. Sissy cuts all the way, with no pix to show for all the flailing around.

    Epoxying the turned-down drag knife body into the shaft: anticlimactic.

    The solid model features a stylin’ tapered snout:

    Drag Knife LM12UU holder - tapered end
    Drag Knife LM12UU holder – tapered end

    Which gets an LM12UU bearing rammed into place:

    Drag Knife - LM12UU holder - inserting bearing
    Drag Knife – LM12UU holder – inserting bearing

    The steel block leaves the bearing flush with the plastic surface, rather than having it continue onward and indent itself into the wood; I can learn from my mistakes.

    The new idea: a single spring pressing the knife holder downward, reacting against a fixed plastic plate:

    Drag Knife - LM12UU ground shaft - assembled
    Drag Knife – LM12UU ground shaft – assembled

    Unlike the previous design, the upper plate doesn’t move, so there’s no problem caused by sliding along the screw threads. I should run nylock nuts up against the plate to keep it in place, stiffen the structure, and provide some friction to keep the screws from loosening.

    The top of the knife holder now has a boss anchoring the spring:

    Drag Knife - turning spring recess
    Drag Knife – turning spring recess

    As you’d expect, the ground shaft slides wonderfully in the bearing, because that’s what it’s designed to do, and the knife has essentially zero stiction and friction at any point along the bearing, which is exactly what I wanted.

    The spring, from the same assortment as all the others, has a 48 g/mm rate.

    The OpenSCAD source code as a GitHub Gist:

    // Drag Knife Holder using LM12UU linear bearing
    // Ed Nisley KE4ZNU – 2019-04-26
    // 2019-06-01 Taper the nose
    Layout = "Build"; // [Build, Show, Puck, Mount, Plate]
    /* [Extrusion] */
    ThreadThick = 0.25; // [0.20, 0.25]
    ThreadWidth = 0.40; // [0.40]
    /* [Hidden] */
    Protrusion = 0.1; // [0.01, 0.1]
    HoleWindage = 0.2;
    inch = 25.4;
    function IntegerMultiple(Size,Unit) = Unit * ceil(Size / Unit);
    ID = 0;
    OD = 1;
    LENGTH = 2;
    //- Adjust hole diameter to make the size come out right
    module PolyCyl(Dia,Height,ForceSides=0) { // based on nophead's polyholes
    Sides = (ForceSides != 0) ? ForceSides : (ceil(Dia) + 2);
    FixDia = Dia / cos(180/Sides);
    cylinder(r=(FixDia + HoleWindage)/2,h=Height,$fn=Sides);
    }
    //- Dimensions
    // Basic shape of DW660 snout fitting into the holder
    // Lip goes upward to lock into MPCNC mount
    Snout = [44.6,50.0,9.6]; // LENGTH = ID height
    Lip = 4.0; // height of lip at end of snout
    // Knife holder & suchlike
    KnifeBody = [12.0,18.0,2.0]; // body OD, flange OD, flange thickness
    Spring = [9.5,10.0,3*ThreadThick]; // compression spring loading knife blade
    PinAccess = 4.0; // hole to reach knife ejection pin
    WallThick = 4.0; // minimum thickness / width
    Screw = [4.0,8.5,25.0]; // thread ID, washer OD, length
    Insert = [4.0,6.0,10.0]; // brass insert
    Bearing = [12.0,21.0,30.0]; // linear bearing body
    Plate = [PinAccess,Snout[OD] – WallThick,WallThick]; // spring reaction plate
    echo(str("Plate: ",Plate));
    SpringSeat = [0.56,7.2,2*ThreadThick]; // wire = ID, coil = OD, seat depth = length
    PuckOAL = max(Bearing[LENGTH],(Snout[LENGTH] + Lip)); // total height of DW660 fitting
    echo(str("PuckOAL: ",PuckOAL));
    Key = [Snout[ID],25.7,(Snout[LENGTH] + Lip)]; // rectangular key
    NumScrews = 3;
    //ScrewBCD = 2.0*(Bearing[OD]/2 + Insert[OD]/2 + WallThick);
    ScrewBCD = (Snout[ID] + Bearing[OD])/2;
    NumSides = 9*4; // cylinder facets (multiple of 3 for lathe trimming)
    module DW660Puck() {
    translate([0,0,PuckOAL])
    rotate([180,0,0]) {
    cylinder(d=Snout[OD],h=Lip/2,$fn=NumSides);
    translate([0,0,Lip/2])
    cylinder(d1=Snout[OD],d2=Snout[ID],h=Lip/2,$fn=NumSides);
    cylinder(d=Snout[ID],h=(Snout[LENGTH] + Lip),$fn=NumSides);
    translate([0,0,(Snout[LENGTH] + Lip) – Protrusion])
    cylinder(d1=Snout[ID],d2=2*WallThick + Bearing[OD],h=PuckOAL – (Snout[LENGTH] + Lip),$fn=NumSides);
    intersection() {
    translate([0,0,0*Lip + Key.z/2])
    cube(Key,center=true);
    cylinder(d=Snout[OD],h=Lip + Key.z,$fn=NumSides);
    }
    }
    }
    module MountBase() {
    difference() {
    DW660Puck();
    translate([0,0,-Protrusion]) // bearing
    PolyCyl(Bearing[OD],2*PuckOAL,NumSides);
    for (i=[0:NumScrews – 1]) // clamp screws
    rotate(i*360/NumScrews)
    translate([ScrewBCD/2,0,-Protrusion])
    rotate(180/8)
    PolyCyl(Insert[OD],2*PuckOAL,8);
    }
    }
    module SpringPlate() {
    difference() {
    cylinder(d=Plate[OD],h=Plate[LENGTH],$fn=NumSides);
    translate([0,0,-Protrusion]) // ejection pin hole
    PolyCyl(PinAccess,2*Plate[LENGTH],NumSides);
    translate([0,0,Plate[LENGTH] – Spring[LENGTH]]) // spring retaining recess
    PolyCyl(Spring[OD],Spring[LENGTH] + Protrusion,NumSides);
    for (i=[0:NumScrews – 1]) // clamp screws
    rotate(i*360/NumScrews)
    translate([ScrewBCD/2,0,-Protrusion])
    rotate(180/8)
    PolyCyl(Screw[ID],2*PuckOAL,8);
    if (false)
    for (i=[0:NumScrews – 1]) // coil positioning recess
    rotate(i*360/NumScrews)
    translate([ScrewBCD/2,0,-Protrusion])
    rotate(180/8)
    PolyCyl(SpringSeat[OD],SpringSeat[LENGTH] + Protrusion,8);
    }
    }
    //—–
    // Build it
    if (Layout == "Puck")
    DW660Puck();
    if (Layout == "Plate")
    SpringPlate();
    if (Layout == "Mount")
    MountBase();
    if (Layout == "Show") {
    MountBase();
    translate([0,0,1.6*PuckOAL])
    rotate([180,0,0])
    SpringPlate();
    }
    if (Layout == "Build") {
    translate([0,Snout[OD]/2,PuckOAL])
    rotate([180,0,0])
    MountBase();
    translate([0,-Snout[OD]/2,0])
    SpringPlate();
    }

  • MPCNC Diamond Engraver: LM3UU Bearings, First Pass

    Gripping a diamond engraver in a collet chuck worked well enough, but the MPCNC’s pen holder lacks sufficient downforce and lateral stiffness. The bit has a chrome-ish plated 3 mm shank, so I tinkered up a mount for a pair of LM3UU linear bearings from the LM12UU drag knife holder:

    Diamond Scribe - LM3UU - Rev 1 - point view
    Diamond Scribe – LM3UU – Rev 1 – point view

    The shank isn’t exactly a precision part, but a few licks with a diamond file knocked off enough of the high spots so it slides reasonably well through the bearings. The bearing alignment is more critical than a simple 3D printed plastic part can provide, so a real version may need bearings in a metal shaft press-fit into the plastic; brute-forcing the bearings into alignment sufficed for now.

    The butt end of the shank press-fits into a disk held down with three springs, similar to the LM12UU mount:

    Diamond Scribe - LM3UU - Rev 1 - top view
    Diamond Scribe – LM3UU – Rev 1 – top view

    It draws Guilloché patterns just fine:

    Diamond Scribe - LM3UU - Rev 1 - first light
    Diamond Scribe – LM3UU – Rev 1 – first light

    I don’t like how the spring-around-screw motion works, even if it’s OK for small excursions.