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: Machine Shop

Mechanical widgetry

  • Thing-O-Matic: Triple Cylinder Thing

    My buddy Mark One asked me to make a golf-ball sized Thing that’s the intersection of three mutually orthogonal cylinders. He claims I (subtractively) machined one from solid plastic, many many years ago, but I cannot imagine I ever had that level of machine shop fu; right now, I’m not sure how I’d fixture the thing.

    Cylinder Thing - solid model
    Cylinder Thing – solid model

    It’s much easier with a 3D printer…

    Of course, spheroids aren’t printable without support, but you can chop one in half to reveal the nice, flat interior surfaces, then add holes for alignment pegs. Using 0.50 infill makes for a compact mesh inside the ball:

    Cylinder Thing - building
    Cylinder Thing – building

    Smooth a few imperfections from the mating surfaces and add four pegs (the other two are busy propping the right-hand half off the countertop). Somewhat to my surprise, the alignment holes came out a perfect push fit for the 2.9 mm actual-OD filament with my more-or-less standard 0.2 mm HoleWindage Finagle Constant. This also uses the 1.005 XY scale factor to adjust for ABS shrinkage, not that that matters in this case:

    Cylinder Thing - alignment pegs
    Cylinder Thing – alignment pegs

    Then solvent-bond everything together forever more:

    Cylinder Thing - clamped
    Cylinder Thing – clamped

    The seam is almost imperceptible around the equator, perhaps because I didn’t slobber solvent right up to the edge. I did print one without the alignment pegs and demonstrated that you (well, I) can’t glue a spheroid without fixturing the halves; that one goes in my Show-n-Tell heap.

    The 0.33 mm Z resolution produces sucky North and South poles; the East, West, Left, and Right poles are just fine, as are the eight Tropical Vertices. After mulling for a bit, I rotated a cylindrical profile upward:

    Cylinder Thing Rotated - solid model
    Cylinder Thing Rotated – solid model

    The obvious contour lines fit the cylinder much better, although you can see where better Z resolution would pay off:

    Cylinder Thing - rotated
    Cylinder Thing – rotated

    This was at 0.33 mm x 0.66 mm, 200 °C, 30 & 100 mm/s, 2 rpm. No delamination problems; I applied a wood chisel to persuade those big flat surfaces to part company with the Kapton tape.

    The OpenSCAD source code:

    // Three intersecting cylinders
    // Ed Nisley KE4ZNU - Oct 2011
    
    Layout = "Build";			// Show Build
    
    //- Extrusion parameters must match reality!
    //  Print with +1 shells and 3 solid layers
    //  Use infill solidity = 0.5 or more...
    
    ThreadThick = 0.33;
    ThreadWidth = 2.0 * ThreadThick;
    
    HoleWindage = 0.2;
    
    Protrusion = 0.1;			// make holes end cleanly
    
    //------ Model dimensions
    
    CylDia = 2*IntegerMultiple(40.0/2,ThreadThick);
    CylRad = CylDia/2;
    
    echo(str("Actual diameter: ",CylDia));
    
    Angle = [45,0,0];			// rotate to choose build orientation
    
    $fn=128;
    
    AlignPegDia = 2.90;
    
    //-------
    
    function IntegerMultiple(Size,Unit) = Unit * ceil(Size / Unit);
    
    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);
    }
    
    module ShowPegGrid(Space = 10.0,Size = 1.0) {
    
      Range = floor(50 / Space);
    
    	for (x=[-Range:Range])
    	  for (y=[-Range:Range])
    		translate([x*Space,y*Space,Size/2])
    		  %cube(Size,center=true);
    
    }
    
    //------- Model bits & pieces
    
    module OneCyl() {
      cylinder(r=CylRad,h=CylDia,center=true);
    }
    
    module ThreeCyl() {
      intersection() {
    	OneCyl();
    	rotate([90,0,0]) OneCyl();
    	rotate([0,90,0]) OneCyl();
      }
    }
    
    module HemiThing() {
      difference() {
    	rotate(Angle)
    	  ThreeCyl();
    	translate([0,0,-CylRad])
    		cube(CylDia,center=true);
    	for (Index = [0:3])
    	  rotate(Index*90)
    		translate([CylRad/2,0,-Protrusion])
    		  PolyCyl(AlignPegDia,5+Protrusion);
      }
    }
    
    //---------
    
    ShowPegGrid();
    
    if (Layout == "Show")
      ThreeCyl();
    
    if (Layout == "Build") {
      translate([CylRad,CylRad,0])
    	HemiThing();
    
      translate([-CylRad,-CylRad,0])
    	  HemiThing();
    }
    
  • Worn-out Zipper Tab

    I’ve carried all my stuff in a belt pack since long before such things were fashionable and, quite some years ago, a friend made me a custom-sized one that’s been in constant use ever since. Of late, one of the zippers got cranky and finally failed completely.

    An autopsy showed the middle of the cross bar on the tab had worn completely through, the stubs had bent outward, and the remains no longer engage the zipper tooth lock.

    Worn-through zipper tab
    Worn-through zipper tab

    I replaced the tab with a short length of chain and a jump ring, but I fear the pack fabric is also reaching end of life.

  • KG-UV3D GPS+Voice: Radio Base Interface

    The Wouxun KG-UV3D has three holes along the base that capture three tabs in the battery case, with tapered edges to align the case with the contacts. After a few passes to get the dimensions right, the plate matching those features came out like this:

    Base plate with tabs
    Base plate with tabs

    The solid model shows the edge tapering down to a single layer:

    Case Tab Base - Solid Model
    Case Tab Base – Solid Model

    The compound taper on the corners must match both the base and the sides of the radio. The bottom plate and shell have corresponding tapers that extend across the glued joints:

    Radio interface tapers
    Radio interface tapers

    That worked out surprisingly well, given the small dimensions and odd angles. The tabs, in particular, bumped right up against the 0.66 mm extrusion width; they’re 2.0 mm thick, so there’s barely one thread width inside the perimeter for fill. A bit of filing & slicing removed the usual enlargement at the end / start of each perimeter thread on the tabs, which is entirely acceptable for something this finicky.

    The OpenSCAD source code with dimensions is all part of that post, but here’s the radio base shape that gets subtracted from the plate to make those tabs:

    Radio Base Polygon - solid model
    Radio Base Polygon – solid model

    This seemed easier than adding a bunch of tiny pegs & triangles, but it’s certainly tedious working around a polygon:

    module RadioBase() {
    
    linear_extrude(height=(BaseOpeningDepth + Protrusion),center=false,convexity=5)
    polygon(points=[
    [-BaseOpeningMax/2,-Protrusion],
    
    [-BaseOpeningMin/2,BaseOpeningY],
    [-(BaseToothOC/2 + BaseToothBase/2),BaseOpeningY],
    
    [-(BaseToothOC/2 + BaseToothTip/2),(BaseOpeningY - BaseToothThick)],
    [-(BaseToothOC/2 - BaseToothTip/2),(BaseOpeningY - BaseToothThick)],
    [-(BaseToothOC/2 - BaseToothBase/2),BaseOpeningY],
    
    [ (BaseToothOC/2 - BaseToothBase/2),BaseOpeningY],
    [ (BaseToothOC/2 - BaseToothTip/2),(BaseOpeningY - BaseToothThick)],
    [ (BaseToothOC/2 + BaseToothTip/2),(BaseOpeningY - BaseToothThick)],
    [ (BaseToothOC/2 + BaseToothBase/2),BaseOpeningY],
    [ BaseOpeningMin/2,BaseOpeningY],
    
    [ BaseOpeningMax/2,-Protrusion],
    
    [ (BaseTabOC + BaseTabWidth/2),-Protrusion],
    [ (BaseTabOC + BaseTabWidth/2),BaseTabThick],
    [ (BaseTabOC - BaseTabWidth/2),BaseTabThick],
    [ (BaseTabOC - BaseTabWidth/2),-Protrusion],
    
    [ BaseTabWidth/2,-Protrusion],
    [ BaseTabWidth/2,BaseTabThick],
    [-BaseTabWidth/2,BaseTabThick],
    [-BaseTabWidth/2,-Protrusion],
    
    [-(BaseTabOC + BaseTabWidth/2),-Protrusion],
    [-(BaseTabOC + BaseTabWidth/2),BaseTabThick],
    [-(BaseTabOC - BaseTabWidth/2),BaseTabThick],
    [-(BaseTabOC - BaseTabWidth/2),-Protrusion],
    ],
    convexity=5
    );
    }
    

    Then subtracting that shape and some inclines…

    Radio Base Interface - solid model - thrown together
    Radio Base Interface – solid model – thrown together

    … lets the base plate pop out of this code:

    module Base() {
    
      difference() {
    
    	translate([0,0,(BaseThick + BaseOpeningDepth)/2])
    	  rotate([-90,0,0])
    		CaseEnvelope(BaseThick + BaseOpeningDepth);
    
    	translate([0,0,BaseThick])
    	  RadioBase();
    
    	translate([(BaseToothOC + BaseTabWidth/2),
    			  -(BaseThick + BaseEndLip)/tan(BaseEndAngle),
    			  0])
    	  rotate([BaseEndAngle,0,0])
    		cube([BaseEndWidth,3*BaseOpeningY,BaseOpeningDepth],center=false);
    
    	translate([-(BaseToothOC + BaseTabWidth/2 + BaseEndWidth),
    			  -(BaseThick + BaseEndLip)/tan(BaseEndAngle),
    			  0])
    	  rotate([BaseEndAngle,0,0])
    		cube([BaseEndWidth,3*BaseOpeningY,BaseOpeningDepth],center=false);
      }
    }
    

    I’m still doodling the electronics, alas…

  • LILUG Meeting Presentation

    Multicolored Chalk People
    Multicolored Chalk People

    In the admittedly unlikely event you happen to be near the left-center part of Long Island this evening, drop in on my DIY 3D Printing & the Makerbot Thing-O-Matic presentation for the Long Island Linux Users Group meeting and pick up a tchotchke!

    Many thanks to LILUG for ruthlessly eliminating all my objections to leaving the Basement Laboratory…

  • KG-UV3D GPS+Voice: Plug Mounting Plate

    Unlike my old ICOM IC-Z1A, the Wouxun KG-UV3D radio has mic and speaker jacks recessed into the case, so that a custom plug plate can absorb all the stress from forces applied to the cables without wiggling the plugs. Even better, there’s a removable cover with a mounting screw that can hold the new plate in place!

    Wouxun plug mounting plate - overview
    Wouxun plug mounting plate – overview

    The first pass at the mount required a bit of filing, as the deepest part of the recess turns out to be not exactly rectangular. That’s (probably) fixed in the source code:

    Wouxun plug plate - detail
    Wouxun plug plate – detail

    The solid model looks about like you’d expect, with terribly thin side walls between the plugs and the not-quite-rectangular section. The whole affair is asymmetrical around the long axis; the not-quite-rectangular block and hole really are offset:

    Plug Mount Plate - Solid Model
    Plug Mount Plate – Solid Model

    When printed, the thin sections come out one 0.66 mm plastic thread wide:

    Wouxun plug mounting plate - build
    Wouxun plug mounting plate – build

    I spent quite some time iterating through OpenSCAD, RepG, and SkeinLayer to make sure that came out right. This is from a later version with larger recesses around the plugs:

    Plug Mount Plate - skeinlayer
    Plug Mount Plate – skeinlayer

    Some epoxy eased down along the plugs will lock them into the plastic, with an epoxy putty turd over the top to stabilize the cables and terminal connections. That’s a T6 Torx bit to mate with the 2 mm screw (with a captive washer!) pulled from the Small Drawer o’ Salvaged Metric Screws:

    Wouxun plug plate - trial fit
    Wouxun plug plate – trial fit

    The OpenSCAD source code is part of the huge block of code at the bottom of that post, but here’s the relevant section:

    module PlugPlate() {
    
      BaseX = PlugBaseWidth/2 - PlugBaseRadius;
      BaseY = PlugBaseLength/2 - PlugBaseRadius;
    
      difference() {
    	union() {
    	  linear_extrude(height=PlugBaseThick,center=false,convexity=3)
    		hull() {
    		  translate([-BaseX,-BaseY,0])
    			circle(r=PlugBaseRadius,$fn=8);
    		  translate([-BaseX, BaseY,0])
    			circle(r=PlugBaseRadius,$fn=8);
    		  translate([ BaseX, BaseY,0])
    			circle(r=PlugBaseRadius,$fn=8);
    		  translate([ BaseX,-BaseY,0])
    			circle(r=PlugBaseRadius,$fn=8);
    		}
    
    	  translate([PlugFillOffsetX,
    				(PlugFillLength/2 - PlugBaseLength/2 + PlugFillOffsetY),
    				PlugBaseThick])
    		linear_extrude(height=PlugFillThick,center=false,convexity=5)
    		  hull() {
    			translate([0,-(PlugFillLength/2 - PlugFillRadius2),0])
    			  circle(r=PlugFillRadius2,$fn=10);
    			translate([-(PlugFillWidth/2 - PlugFillRadius1),-PlugBaseLength/2,0])
    			  circle(r=PlugFillRadius1,$fn=8);
    			translate([-(PlugFillWidth/2 - PlugFillRadius1),
    					  (PlugFillLength/2 - PlugFillRadius1),0])
    			  circle(r=PlugFillRadius1,$fn=8);
    			translate([(PlugFillWidth/2 - PlugFillRadius1),
    					  (PlugFillLength/2 - PlugFillRadius1),0])
    			  circle(r=PlugFillRadius1,$fn=8);
    			translate([(PlugFillWidth/2 - PlugFillRadius1),-PlugBaseLength/2,0])
    			  circle(r=PlugFillRadius1,$fn=8);
    		  }
    	}
    
    	translate([0,-JackOC/2,-Protrusion])
    	  rotate(360/16) {
    		PolyCyl(Plug3BezelDia,(Plug3BezelThick + Protrusion),8);
    		PolyCyl(Plug3ScrewDia,(PlugBaseThick + PlugFillThick + 2*Protrusion),8);
    	  }
    
    	translate([0,+JackOC/2,-Protrusion])
    	  rotate(360/16) {
    		PolyCyl(Plug2BezelDia,(Plug2BezelThick + Protrusion),8);
    		PolyCyl(Plug2ScrewDia,(PlugBaseThick + PlugFillThick + 2*Protrusion),8);
    	  }
    
    	translate([JackScrewOffsetX,-(PlugBaseLength/2 + JackScrewOffsetY),0])
    	  PolyCyl(JackScrewDia,(PlugBaseThick + PlugFillThick + Protrusion));
      }
    
    }
    
  • HP-48GX Calculator Disassembly: Case Rivets

    The keyboard on my trusty HP 48GX calculator finally deteriorated to the point of unusability, so I tore the thing apart following the useful instructions there. The warning about applying force to the rivets that hold the case halves together gives you not the faintest concept of how much force is actually required to pry the mumble thing apart at the battery compartment; I finally invoked force majeure with a chisel scraper

    HP-48GX case rivets
    HP-48GX case rivets

    I expected the calculator would not survive this operation and I wasn’t disappointed.

    An HP 50g is now in hand. Here in late 2011 I’d expect HP’s top-of-the-line RPN calculator to sport a crisp high-resolution display, but noooo the low-contrast 131×80 LCD seems teleported directly from the latter part of the last millennium. The manuals are PDFs, which is OK, but their content is far inferior to the HP 48GX manuals. In particular, the editing / proofreading is terrible. I infer that the HP calculator division can barely fog a mirror and is on advanced life support; HP’s diverting all their money to, uh, executive buyouts or some other non-productive purpose.

    The fact that HP sells new-manufacture HP 15C calculators doesn’t crank my tractor, even though I lived and died by one for many years. A one-line 7-segment display doesn’t cut it any more, even if the new machinery inside allegedly runs like a bat out of hell.

    My HP 16C, now, that one you’ll pry out of my cold, dead hands. At one point in the dim past, I’d programmed the Mandelbrot iteration into it to provide bit-for-bit verification of the 8051 firmware for the Mandelbrot Engine array processor I did for Circuit Cellar: slow, but perfect. That calculator has a low duty cycle these days, but when I need it, I need it bad.

  • Thing-O-Matic: Delamination

    ABS plastic shrinks as it cools and large objects with thin sections tend to delaminate, as seen in the Barbie Pistol and a few other objects. The box for the GPS+voice interface is four threads thick and 35 mm tall, which provided enough energy to rip the side apart:

    Box wall delamination
    Box wall delamination

    Solvent glue and a clamp shoved it back together again:

    Clamping delamination
    Clamping delamination

    This one was extruded at 190 °C, which works fine for small objects and isn’t quite enough to fuse something like this. I’ll crank it up to 210 °C for the next iteration to see if that improves the result.