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: Thing-O-Matic

Using and tweaking a Makerbot Thing-O-Matic 3D printer

  • Canon SX230HS Microscope and Close-up Macro Adapters

    The deal was, if my Shop Assistant repaired my pocket camera, she could have it. She did, which meant I lost the ability to take pix through the microscope. While I was conjuring up a replacement, it occurred to me that I should also build a gadget to hold a close-up lens in front of the camera for tighter macro shots that don’t quite require a microscope’s magnification.

    The solid model of the microscope adapter:

    Microscope mount - solid model
    Microscope mount – solid model

    The close-up macro adapter, with an LED ring light around the snout:

    LED Ring mount - solid model
    LED Ring mount – solid model

    They have a common camera mounting plate, with a hex recess for a 1/4-20 nut that mates with a standard tripod screw and some support material sticking up through the hole for the screw that holds the camera to the plate:

    Mounting plate - solid model - top view
    Mounting plate – solid model – top view

    The main tube glues into the plate’s cutout and is long enough to accommodate the fully extended lens turret, with four shallow holes for filament snippet locating pins to align the snout:

    Main tube - solid model - bottom view
    Main tube – solid model – bottom view

    An exploded view shows how everything fits together, with the stud below the camera representing its tripod mounting screw:

    LED Ring mount - solid model - exploded view
    LED Ring mount – solid model – exploded view

    More details on the parts will appear over the next few days, but here’s the view through the macro adapter:

    Dahlia through macro adapter
    Dahlia through macro adapter

    Yeah, some slight vignetting, but overall it’s pretty good.

    The OpenSCAD source code that builds both adapters:

    // Close-up lens mount & Microscope adapter for Canon SX230HS camera
    // Ed Nisley KE4ZNU - Nov 2011
    
    Mount = "Eyepiece";			// End result: LEDRing Eyepiece
    
    Layout = "Show";			// Assembly: Show
    							// Parts: Plate Tube LEDRing Camera Eyepiece
    							// Build Plates: Build1..4
    
    Gap = 12;					// between "Show" objects
    
    include </home/ed/Thing-O-Matic/lib/MCAD/units.scad>
    include </home/ed/Thing-O-Matic/Useful Sizes.scad>
    include </home/ed/Thing-O-Matic/lib/visibone_colors.scad>
    
    //-------
    //- Extrusion parameters must match reality!
    //  Print with +1 shells, 3 solid layers, 0.2 infill
    
    ThreadThick = 0.33;
    ThreadWidth = 2.0 * ThreadThick;
    
    HoleFinagle = 0.2;
    HoleFudge = 1.02;
    
    function HoleAdjust(Diameter) = HoleFudge*Diameter + HoleFinagle;
    
    Protrusion = 0.1;			// make holes end cleanly
    
    function IntegerMultiple(Size,Unit) = Unit * ceil(Size / Unit);
    
    //-------
    // Dimensions
    
    // doublet lens
    
    LensDia = 25.0;
    LensRad = LensDia/2;
    LensClearance = 0.2;
    
    LensEdge = 6.7;
    LensThick = 8.6;
    LensRimThick = IntegerMultiple((2.0 + LensThick),ThreadThick);
    
    // LED ring light
    
    LEDRingOD = 50.0;
    LEDRingID = 36.0;
    LEDBoardThick = 1.5;
    LEDThick = 4.0;
    LEDRingClearance = 0.5;
    LEDWireHoleDia = 3.0;
    
    // microscope eyepiece
    
    EyepieceOD = 30.0;
    EyepieceID = 24.0;
    EyepieceLength = 25.0;
    
    // camera
    // Origin at base of [0] ring, Z+ along lens axis, X+ toward bottom, Y+ toward left
    
    CameraBodyWidth = 2*10.6;							// 2 x center-to-curve edge
    CameraBaseWidth = 15.5;								// flat part of bottom front to back
    CameraBaseRadius = (CameraBodyWidth - CameraBaseWidth)/2;	// edge rounding
    CameraBaseLength = 60.0;							// centered on lens axis
    CameraBaseHeight = 55.0;							// main body height
    CameraBaseThick = 0.9;								// downward from lens ring
    
    echo(str("Camera base radius: ",CameraBaseRadius));
    
    TripodHoleOffset = -19.0;							// mount screw wrt lens centerline
    TripodHoleDia = Clear025_20;						// clearance hole
    
    TripodScrewHeadDia = 14.5;							// recess for screw mounting camera
    TripodScrewHeadRad = TripodScrewHeadDia/2;
    TripodScrewHeadThick = 3.0;
    
    // main lens tube
    
    TubeDia = 		[53.0,	44.0,	40.0,	37.6];		// lens rings, [0] is fixed to body
    TubeLength = 	[8.1,	20.6,	17.6,	12.7];
    
    TubeEndClearance = 2.0;								// camera lens end to tube end
    TubeEndThickness = IntegerMultiple(1.5,ThreadThick);
    TubeInnerClearance = 0.5;
    
    TubeInnerLength = TubeLength[0] + TubeLength[1] + TubeLength[2] + TubeLength[3] +
    				  TubeEndClearance;
    TubeOuterLength = TubeInnerLength + TubeEndThickness;
    
    TubeID = TubeDia[0] + TubeInnerClearance;
    TubeOD = TubeID + 6*ThreadWidth;
    TubeWall = (TubeOD - TubeID)/2;
    TubeSides = 48;
    
    echo(str("Main tube outer length: ",TubeOuterLength));
    echo(str("          ID: ",TubeID," OD: ",TubeOD," wall: ",TubeWall));
    
    // camera mounting base
    
    BaseWidth = IntegerMultiple((CameraBaseWidth + 2*CameraBaseRadius),ThreadThick);
    BaseLength = 60.0;
    BaseThick = IntegerMultiple((1.0 + Nut025_20Thick + CameraBaseThick),ThreadThick);
    
    // LED ring mount
    
    LEDBaseThick = IntegerMultiple(2.0,ThreadThick);	// base under lens + LED ring
    LEDBaseRimWidth = IntegerMultiple(6.0,ThreadWidth);
    LEDBaseRimThick = IntegerMultiple(LensThick,ThreadThick);
    
    LEDBaseOD = max((LEDRingOD + LEDRingClearance + LEDBaseRimWidth),TubeOD);
    
    echo(str("LED Ring OD: ",LEDBaseOD));
    
    // alignment pins between tube and LED ring / microscope eyepiece
    
    AlignPins = 4;
    AlignPinOD = 2.9;
    AlignPinCircleDia = TubeOD - 2*TubeWall - 2*AlignPinOD;		// 2*PinOD -> more clearance
    
    //-------
    
    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=HoleAdjust(FixDia)/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);
    
    }
    
    //-------
    
    //- Camera body segment
    //	Including lens base and peg for tripod hole access
    //	Z=0 at edge of lens base ring, X=0 along lens axis
    
    module CameraBody() {
    
      translate([0,0,-CameraBaseThick])
    	rotate(90)
    	  union() {
    		translate([0,0,(CameraBaseHeight/2 + CameraBaseRadius)])
    		  minkowski() {
    			cube([CameraBaseWidth,
    				  (CameraBaseLength + 2*Protrusion),
    				  CameraBaseHeight],center=true);
    			rotate([90,0,0])
    			  cylinder(r=CameraBaseRadius,h=Protrusion,$fn=8);
    		  }
    
    		translate([0,0,(TubeDia[0]/2 + CameraBaseThick)])
    		  rotate([0,90,0])
    			rotate(180/TubeSides)
    			  cylinder(r=(TubeDia[0]/2 + CameraBaseThick),
    					  h=(CameraBodyWidth/2 + Protrusion),
    					  $fn=TubeSides);
    
    		translate([CameraBodyWidth/2,0,(TubeDia[0]/2 + CameraBaseThick)])
    		  rotate([0,90,0])
    			cylinder(r=TubeDia[0]/2,h=TubeLength[0]);
    
    		translate([(TubeLength[0] + CameraBodyWidth/2),
    				  0,(TubeDia[0]/2 + CameraBaseThick)])
    		  rotate([0,90,0])
    			cylinder(r=TubeDia[1]/2,h=TubeLength[1]);
    
    		translate([(TubeLength[0] + TubeLength[1] + CameraBodyWidth/2),
    				  0,(TubeDia[0]/2 + CameraBaseThick)])
    		  rotate([0,90,0])
    			cylinder(r=TubeDia[2]/2,h=TubeLength[2]);
    
    		translate([(TubeLength[0] + TubeLength[1] + TubeLength[2] + CameraBodyWidth/2),
    				  0,(TubeDia[0]/2 + CameraBaseThick)])
    		  rotate([0,90,0])
    			cylinder(r=TubeDia[3]/2,h=TubeLength[3]);
    
    		translate([0,TripodHoleOffset,-BaseThick])
    		  PolyCyl(TripodHoleDia,(BaseThick + 2*Protrusion));
    
    	  }
    }
    
    //- Main tube
    
    module Tube() {
    
      difference() {
    	cylinder(r=TubeOD/2,h=TubeOuterLength,$fn=TubeSides);
    
    	translate([0,0,TubeEndThickness])
    	  PolyCyl(TubeID,(TubeInnerLength + Protrusion),TubeSides);
    
    	translate([0,0,-Protrusion]) {
    	  if (Mount == "LEDRing")
    		cylinder(r=LensRad,h=(TubeEndThickness + 2*Protrusion));
    	  if (Mount == "Eyepiece")
    		cylinder(r=EyepieceID/2,h=(TubeEndThickness + 2*Protrusion));
    	}
    
    	for (Index = [0:AlignPins-1])
    	  rotate(Index*90)
    		translate([(AlignPinCircleDia/2),0,-ThreadThick])
    		  rotate(180)			// flat sides outward
    			PolyCyl(AlignPinOD,TubeEndThickness);
      }
    
    }
    
    //- Base plate
    
    module BasePlate() {
    
      union() {
    	difference() {
    		linear_extrude(height=BaseThick)
    		  hull() {
    			translate([-(BaseLength/2 - BaseWidth/2),0,0])
    			  circle(BaseWidth/2);
    			translate([ (BaseLength/2 - BaseWidth/2),0,0])
    			  circle(BaseWidth/2);
    			translate([0,(0.75*BaseLength),0])
    			  circle(BaseWidth/2);
    		  }
    
    		translate([0,0,BaseThick])
    		  CameraBody();
    
    		translate([0,(TubeOuterLength + CameraBodyWidth/2),
    				  (BaseThick + TubeDia[0]/2)])
    		  rotate([90,0,0])
    			PolyCyl(TubeOD,TubeOuterLength,$fn=TubeSides);
    
    		translate([0,0,3*ThreadThick])
    		  PolyCyl((Nut025_20Dia*sqrt(3)/2),2*Nut025_20Thick,6);	// dia across hex flats
    
    		translate([0,0,-Protrusion])
    		  PolyCyl(Clear025_20,(BaseThick + 2*Protrusion));
    
    		translate([TripodHoleOffset,0,3*ThreadThick])
    		  PolyCyl((Nut025_20Dia*sqrt(3)/2),2*Nut025_20Thick,6);	// dia across hex flats
    
    		translate([TripodHoleOffset,0,-Protrusion])
    		  PolyCyl(Clear025_20,(BaseThick + 2*Protrusion));
    
    		translate([-TripodHoleOffset,0,-Protrusion])
    		  PolyCyl(TripodScrewHeadDia,(TripodScrewHeadThick + Protrusion));
    
    	}
    
    	translate([-TripodHoleOffset,0,0]) {				// support for tripod screw hole
    	  for (Index=[0:3])
    		rotate(Index*45)
    		  translate([-ThreadWidth,-TripodScrewHeadRad,0])
    			cube([2*ThreadWidth,TripodScrewHeadDia,TripodScrewHeadThick]);
    
    	  cylinder(r=0.4*TripodScrewHeadRad,h=(BaseThick - CameraBaseThick),$fn=9);
    	}
      }
    }
    
    //- LED mounting ring
    
    module LEDRing() {
    
      difference() {
    	cylinder(r=LEDBaseOD/2,h=LensRimThick,$fn=48);
    
    	translate([0,0,-Protrusion])
    	  PolyCyl((LensDia + LensClearance),
    			  (LensRimThick + 2*Protrusion));
    
    	translate([0,0,LEDBaseRimThick])
    	  difference() {
    		PolyCyl(LEDBaseOD,LensThick);
    		PolyCyl(LEDRingID,LensThick);
    	  }
    
    	translate([0,0,LEDBaseThick])
    	  difference() {
    		PolyCyl((LEDRingOD + LEDRingClearance),LensThick);
    		cylinder(r1=HoleAdjust(LEDRingID - LEDRingClearance)/2,
    				 r2=HoleAdjust(LensDia + LensClearance)/2 + 2*ThreadWidth,
    				 h=LensThick);
    	  }
    
    	for (Index = [0:AlignPins-1])
    	  rotate(Index*90)
    		translate([(AlignPinCircleDia/2),0,-ThreadThick])
    		  rotate(180)			// flat sides outward
    			PolyCyl(AlignPinOD,LEDBaseThick);
    
    	rotate(45)
    	  translate([0,LEDRingID/2,(LEDBaseThick + 1.2*LEDWireHoleDia/2)])
    		rotate([0,-90,0])			// flat side down
    		  rotate([-90,0,0])
    			PolyCyl(LEDWireHoleDia,2*LEDBaseRimWidth);
      }
    
    }
    
    //- Microscope eyepiece adapter
    
    module EyepieceMount() {
    
      difference() {
    	cylinder(r1=TubeOD/2,
    			 r2=(EyepieceOD + 8*ThreadWidth)/2,
    			 h=EyepieceLength,
    			 $fn=TubeSides);
    
    	translate([0,0,-Protrusion])
    	  PolyCyl(EyepieceOD,(EyepieceLength + 2*Protrusion));
    
    	for (Index = [0:AlignPins-1])
    	  rotate(Index*90)
    		translate([(AlignPinCircleDia/2),0,-ThreadThick])
    		  rotate(180)			// flat sides outward
    			PolyCyl(AlignPinOD,6*ThreadThick);
      }
    
    }
    
    //-------
    // Build it!
    
    if (Layout != "Show")
      ShowPegGrid();
    
    if (Layout == "Tube")
      Tube();
    
    if (Layout == "LEDRing")
      LEDRing();
    
    if (Layout == "Plate")
      BasePlate();
    
    if (Layout == "Camera")
      CameraBody();
    
    if (Layout == "Eyepiece")
      EyepieceMount();
    
    if (Layout == "Build1")
      translate([0,-BaseLength/3,0])
    	BasePlate();
    
    if (Layout == "Build2")
      Tube();
    
    if (Layout == "Build3")
      LEDRing();
    
    if (Layout == "Build4")
      EyepieceMount();
    
    if (Layout == "Show") {
      translate([0,TubeOuterLength,TubeDia[0]/2]) {
    	rotate([90,0,0])
    	  color(LTC) Tube();
    	translate([0,Gap,0])
    	  rotate([-90,0,0]) {
    		if (Mount == "LEDRing")
    		  color(OOR) LEDRing();
    		if (Mount == "Eyepiece")
    		  color(OOR) EyepieceMount();
    	  }
      }
    
      translate([0,-CameraBodyWidth/2,0])
    	color(PG) CameraBody();
    
      color(PDA)
    	render()
    	translate([0,-CameraBodyWidth/2,-(BaseThick + Gap)])
    	  BasePlate();
    }
    

    The original doodles & dimensions:

    Close-up Lens Doodles
    Close-up Lens Doodles
  • Canon SX230HS Lens Cap

    The SX230HS camera lives in my pants pocket, where it gets pressed between my leg and anything I lean against. Turns out that the lens turret end cap isn’t quite thick enough to not bend inward against the leaves that cover the lens, which causes them to hang up. The solution boils down to a hideous external lens cap:

    Canon SX230HS with lens cap
    Canon SX230HS with lens cap

    It’s built from forget-me-not yellow filament for an obvious reason…

    The sheet-metal plate bears against the non-moving rim around the turret. I marked the plate’s diameter with a compass, extracted it from the sheet with left-cutting tin snips, filed off the slivers, rounded the edge, and it snapped right into the recess where a touch of acrylic caulk holds it firmly in place.

    A thin plastic cover would be too flexible and a thicker plastic cover would be too thick; this must fit into an already-snug cloth pouch where a few additional millimeters of girth actually matter. My previous camera taught me that pocket fuzz gets into everything, so a pouch isn’t optional.

    The interior isn’t too inspiring, but you can see what two layers of plastic look like across the bottom:

    SX230HS lens cap - interior
    SX230HS lens cap – interior

    The front has the shallow recess that captures the metal plate. Because the front builds against the aluminum build platform, I added a support structure inside the recess:

    SX230HS lens cap - support in place
    SX230HS lens cap – support in place

    The solid model gives a better view:

    Lens cap - solid model - bottom view
    Lens cap – solid model – bottom view

    It’s basically a ring with tabs under the recess. The ring OD matches the lens caps’s ID, with a height equal to the recess depth, so only the tabs contact the cap. I removed them by twisting each tab with a needle-nose pliers until the whole thing popped loose:

    SX230HS lens cap - support structure
    SX230HS lens cap – support structure

    A bit of scraper and scalpel cleanup and it’s all good. The detail pix show the first trial of the lens cap, which lacks the nice bevel around the front rim.

    The camera is smart enough to notice when something blocks the lens: it immediately shuts down and displays a lens failure error message. That’s probably not a Good Thing on a regular basis, but it doesn’t seem to do any harm.

    FWIW, my previous pocket camera, a Casio EX-Z850 , sported a recessed and somewhat thicker turret end cap that didn’t have this problem. Mary says she’ll make a case for this camera, too, but until then I’m using a pouch from a dinky VOIP phone that just barely holds the camera.

    The OpenSCAD source code:

    // Lens cap for Canon SX230HS
    // Ed Nisley KE4ZNU - Nov 2011
    
    //-------
    //- Extrusion parameters must match reality!
    //  Print with +1 shells, 3 solid layers, 0.2 infill
    
    ThreadThick = 0.33;
    ThreadWidth = 2.0 * ThreadThick;
    
    HoleFinagle = 0.20;
    HoleFudge = 1.00;
    
    function HoleAdjust(Diameter) = HoleFudge*Diameter + HoleFinagle;
    
    Protrusion = 0.1;			// make holes end cleanly
    
    function IntegerMultiple(Size,Unit) = Unit * ceil(Size / Unit);
    
    //-------
    // Dimensions
    
    LensDia = 53.0;
    LensRad = LensDia/2;
    LensLength = 8.0;
    
    PlateThick = IntegerMultiple(0.75,ThreadThick);
    PlateDia = 48.0;
    
    Shell = 2*ThreadWidth;
    Spacer = 2*ThreadThick;
    
    CapOD = LensDia + 2*Shell;
    CapLength = LensLength + Spacer + PlateThick;
    CapSides = 48;
    
    CenterHoleDia = 44.0;
    
    BevelWidth = PlateThick;
    
    NumStruts = 16;
    SupportStrutLen = (PlateDia - ThreadWidth)/2;		// small gap to cap
    
    //-------
    
    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=HoleAdjust(FixDia)/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);
    
    }
    
    //-------
    
    ShowPegGrid();
    
    difference() {
      PolyCyl(CapOD,CapLength,CapSides);
    
      translate([0,0,(Spacer + PlateThick)])					// lens shell
    	PolyCyl(LensDia,(LensLength + Protrusion),CapSides);
    
      translate([0,0,-Protrusion])								// center hole
    	PolyCyl(CenterHoleDia,(CapLength + Protrusion));
    
      translate([0,0,-Protrusion])								// bevel
    	difference() {
    	  cylinder(r=(CapOD/2 + 2*(BevelWidth + Protrusion)),
    			   h=(2*BevelWidth + Protrusion),
    			   $fn=CapSides);
    	  cylinder(r1=(CapOD/2 - BevelWidth - Protrusion),
    			   r2=(CapOD/2 + BevelWidth),
    			   h=(2*BevelWidth + Protrusion),
    			   $fn=CapSides);
    	}
    
      difference() {
    	translate([0,0,-Protrusion])							// cover plate recess
    	  PolyCyl(PlateDia,(PlateThick + Protrusion));
    	for (Index=[0:(NumStruts - 1)])							// support struts
    	  rotate(Index*360/NumStruts)
    		translate([-ThreadWidth,-SupportStrutLen,0])
    		  cube([2*ThreadWidth,SupportStrutLen,PlateThick]);
      }
    }
    
    difference() {									// support ring
      PolyCyl(CenterHoleDia,PlateThick);
      translate([0,0,-Protrusion])
    	PolyCyl((CenterHoleDia - 4*ThreadWidth),(PlateThick + 2*Protrusion));
    }
    
  • OpenSCAD: Useful Sizes file

    My Useful Sizes.scad file has been accumulating the dimensions of nuts & bolts & a motor that don’t (seem to) appear elsewhere in the OpenSCAD universe:

    //-- Useful sizes
    
    Tap2_56 = 0.070 * inch;
    Clear2_56 = 0.082 * inch;
    Head2_56 = 0.156 * inch;
    Head2_56Thick = 0.055 * inch;
    Nut2_56Dia = 0.204 * inch;
    Nut2_56Thick = 0.065 * inch;
    
    Tap3_48 = 0.079 * inch;
    Clear3_48 = 0.096 * inch;
    Head3_48 = 0.184 * inch;
    Head3_48Thick = 0.058 * inch;
    Nut3_48Dia = 0.201 * inch;
    Nut3_48Thick = 0.073 * inch;
    
    Tap4_40 = 0.089 * inch;
    Clear4_40 = 0.110 * inch;
    Head4_40 = 0.211 * inch;
    Head4_40Thick = 0.065 * inch;
    Nut4_40Dia = 0.228 * inch;
    Nut4_40Thick = 0.086 * inch;
    
    Tap10_32 = 0.159 * inch;
    Clear10_32 = 0.190 * inch;
    Head10_32 = 0.373 * inch;
    Head10_32Thick = 0.110 * inch;
    Nut10_32Dia = 0.433 * inch;
    Nut10_32Thick = 0.130 * inch;
    
    Tap025_20 = 0.201 * inch;
    Clear025_20 = 0.2660 * inch;
    Head025_20 = 0.492 * inch;
    Head025_20Thick = 0.144 * inch;
    Nut025_20Dia = 0.505 *inch;
    Nut025_20Thick = 0.161 * inch;
    
    NEMA17_ShaftDia = 5.0;
    NEMA17_ShaftLength = 24.0;
    NEMA17_PilotDia = 0.866 * inch;
    NEMA17_PilotLength = 0.080 * inch;
    NEMA17_BCD = 1.725 * inch;
    NEMA17_BoltDia = 3.5;
    NEMA17_BoltOC = 1.220 * inch;
    

    It seems I’m among the few CamelCase holdouts…

  • Logitech Ball Camera Tripod Adapter

    The Logitech notebook webcam that peers into the Thing-O-Matic has terrible dynamic range compensation; turning on the LED ring light washes out the image something awful. An old Logitech ball camera seems better, but it sits atop a rubbery dingus adapted to grip huge old laptops. So I built an adapter with a standard 1/4-20 tripod screw thread in the bottom that ought to make it more useful.

    The old & new mounts compared:

    Logitech ball camera mounts
    Logitech ball camera mounts

    The color change comes from switching to yellow filament for an upcoming larger object.

    The solid model shows those tiny little notches will require a bit of riffler file work:

    Logitech camera tripod adapter - solid model
    Logitech camera tripod adapter – solid model

    The bottom has a blind 1/4-20 tapped hole. Lacking a bottoming tap, not having any broken 1/4-20 taps, and being unwilling to grind the end off a perfectly good taper tap, I filed three notches along a bolt. Ran the taper tap in until it hit bottom, ran the bolt in likewise, and defined the result to be Good Enough:

    Homebrew bottoming tap
    Homebrew bottoming tap

    On the other end, the most probable failure will leave that delicate little post jammed firmly inside the camera’s socket. There’s not enough post to allow printing a small guide hole, but there’s no real need for one; I drilled a #50 hole right down the middle, ran a 2-56 screw into it without tapping the hole, and filed the screw head flat:

    Camera mount with filed screw
    Camera mount with filed screw

    After cleaning up those notches, it snapped solidly into place:

    Logitech ball camera with mount
    Logitech ball camera with mount

    And then the camera sits neatly atop a cheap Gorillapod knockoff:

    Logitech ball camera on tripod
    Logitech ball camera on tripod

    That tiny reddish dot in the middle of the imposing set of rings marks the actual lens, so it’s more of a pinhole camera than anything else. The fixed focus kicks in beyond a meter, but a bit of rummaging in the Box o’ Lenses produced a random meniscus lens that pulled the focus in to maybe 100 mm. Alas, that means the camera must float in mid-air about 15 mm inside the Thing-O-Matic’s box. If I can conjure up a mount that holds the ball inside the box, above-and-forward of the stage, that’d work great. VLC can allegedly rotate the image upside-down, so maybe I can mount it bottom-up.

    Here’s everything I know about those two cameras, with the ball camera on top and the webcam on the bottom:

    Logitech ball and notebook webcam data
    Logitech ball and notebook webcam data

    Apparently it’s easier to put that information on a tag than provide a good old data plate on the camera body.

    The OpenSCAD source code:

    // Tripod mount for Logitech ball camera
    // Ed Nisley KE4ZNU - Oct 2011
    
    include </home/ed/Thing-O-Matic/lib/MCAD/units.scad>
    include </home/ed/Thing-O-Matic/Useful Sizes.scad>
    include </home/ed/Thing-O-Matic/lib/visibone_colors.scad>
    
    //-------
    //- Extrusion parameters must match reality!
    //  Print with +0 shells and 3 solid layers
    
    ThreadThick = 0.33;
    ThreadWidth = 2.0 * ThreadThick;
    
    HoleFinagle = 0.2;
    HoleFudge = 1.02;
    
    function HoleAdjust(Diameter) = HoleFudge*Diameter + HoleFinagle;
    
    function IntegerMultiple(Size,Unit) = Unit * ceil(Size / Unit);
    
    Protrusion = 0.1;			// make holes end cleanly
    
    //-------
    // Dimensions
    
    BallDia = 60.0;				// camera ball
    BallRad = BallDia/2;
    
    BaseDia = 16.0;				// interface at tripod surface
    BaseRad = BaseDia/2;
    
    BaseLength = 10.0;			// to base of ball
    
    BoltDia = Tap025_20;		// standard 1/4-20 thread
    BoltLength = 7.0;
    
    StemLength = 8.5;
    StemDia = 4.7;
    StemRad = StemDia/2;
    
    FlangeWidth = 6.6;
    FlangeThick = 2.6;
    
    NotchSectionDia = 1.4;		// toroid cross-section diameter
    NotchSectionRad = NotchSectionDia/2;
    NotchOffset = 2.3;			// from top of stem
    
    //-------
    
    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=HoleAdjust(FixDia)/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);
    
    }
    
    //-------
    //
    
    ShowPegGrid();
    
    translate([0,0,BaseLength])
      union() {
    	difference() {
    	  translate([0,0,-BaseLength])
    		cylinder(r=BaseRad,h=2*BaseLength);
    	  translate([0,0,BallRad])
    		sphere(r=BallRad);
    	  translate([0,0,-(BaseLength + Protrusion)])
    		PolyCyl(BoltDia,(BoltLength + Protrusion));
    	}
    	rotate(180/16)
    	  cylinder(r=StemRad,h=StemLength,$fn=16);
    	difference() {
    	  translate([0,0,StemLength/2])
    		cube([FlangeWidth,FlangeThick,StemLength],center=true);
    	  translate([0,0,(StemLength - NotchOffset)])
    		rotate_extrude(convexity=3,$fn=64)
    		  translate([FlangeWidth/2,0,0])
    			circle(r=NotchSectionRad,$fn=16);
    	  translate([0,-FlangeWidth/2,StemLength + sqrt(FlangeWidth)])
    		rotate([0,45,0])
    		  cube(FlangeWidth + 2*Protrusion);
    	  translate([0,FlangeWidth/2,StemLength + sqrt(FlangeWidth)])
    		rotate([0,45,180])
    		  cube(FlangeWidth + 2*Protrusion);
    	}
      }
    
  • Companion Cube Array

    Companion Cubes make good tchotchkes for presentations:

    Companion cube array
    Companion cube array

    Scaling the cubes to about 15 mm on a side puts a 6×6 array neatly on the build plate. Takes nigh onto four hours to print all 36 of them at 30 mm/s print and 100 mm/s move… a bit over 6 minutes each.

    The print quality is Good Enough. The bottom surface of the front cubes faces forward and reflects the scale markings:

    Companion Cubes - detail
    Companion Cubes – detail
  • Zombie Apocalypse Preparations

    When in doubt, nuke ’em from orbit. It’s the only way to be sure:

    Finned CO2 Cartridge on build platform
    Finned CO2 Cartridge on build platform

    When confronted with a zombie horde, though, nothing exceeds like excess:

    Finned CO2 Cartridge Array
    Finned CO2 Cartridge Array

    In real life, they’re 12 gram CO2 capsules, of the type used in tire inflators and air pistols. I knew I’d find something to do with the box of empties I’d been accumulating: they became (somewhat threatening) tchotchkes. This was inspired by that thing, although that STL file doesn’t render into anything and, as with many interesting Thingiverse things, there’s no source code.

    These fins were an exercise in thin-wall printing: the outer square is one thread thick, the diagonal struts are two threads, and the ring around the nozzle has just a touch of fill inside, with a one-thread-thick base below the cartridge nozzle:

    Fin Array on build platform
    Fin Array on build platform

    The solid model looks about like you’d expect:

    Fin Assembly- solid model
    Fin Assembly- solid model

    The teeny little quarter-cylinders in the corners encourage Skeinforge to do the right thing: build each quadrant in one pass, leaving the corners unfinished. The diagonals must be exactly two threads wide to make that possible: each strut thread connects to the corresponding single-thread outer edge.

    Now that I’m trying to be a subtractive kind of guy, that’s actually a fin block:

    Fin Block - solid model
    Fin Block – solid model

    Minus the CO2 cartridge that should fit inside:

    CO2 Cartridge - solid model
    CO2 Cartridge – solid model

    It turns out that my box has several different types of CO2 cartridges and the nozzle ends are all different. To get it right, there’s a template for matching the curves:

    Cartridge nozzle template
    Cartridge nozzle template

    That end of the cartridge consists of a cylinder for the body, a sphere mated to a tangential conic section, another conic fillet, and then the cylindrical nozzle. Basically, you twiddle with the parameters until the template comes pretty close to fitting, then fire off a few trial fins until it comes out right.

    CO2 Capsule Nozzle - solid model detail
    CO2 Capsule Nozzle – solid model detail

    They were a big hit at the Long Island Linux Users Group meeting…

    The OpenSCAD source code:

    // CO2 capsule tail fins
    // Ed Nisley KE4ZNU - Oct 2011
    
    Layout = "Show";			// Show Build FinBlock Cartridge Fit
    
    include
    
    //-------
    //- Extrusion parameters must match reality!
    //  Print with +0 shells and 3 solid layers
    
    ThreadThick = 0.33;
    ThreadWidth = 2.0 * ThreadThick;
    
    HoleWindage = 0.2;
    
    Protrusion = 0.1;			// make holes end cleanly
    
    function IntegerMultiple(Size,Unit) = Unit * ceil(Size / Unit);
    
    //-------
    // Capsule dimensions
    
    BodyDia = 18.70;
    BodyRad = BodyDia/2;
    
    BodyLength = 53.0;						// between hemispherical endcap centers
    BodyBaseLength = 21;					// tip to endcap center
    
    TipDia = 7.40;
    TipRad = TipDia/2;
    TipLength = IntegerMultiple(4.0,ThreadThick);
    
    FilletLength = 5.0;						// fillet between tip and cone
    FilletTop = TipLength + FilletLength;
    
    FilletBaseDia = 8.60;
    FilletBaseRad= FilletBaseDia/2;
    FilletTopDia = 9.5;
    FilletTopRad = FilletTopDia/2;
    
    ConeTop = 16.0;							// tip to tangent with endcap
    ConeLength = ConeTop - FilletTop;
    
    echo(str("Cone Length: ",ConeLength));
    
    IntersectZ = ConeTop;					// coordinates of intersect tangent
    IntersectX = sqrt(pow(BodyRad,2) - pow(BodyBaseLength - ConeTop,2));
    
    echo(str("IntersectZ: ",IntersectZ));
    echo(str("IntersectX: ",IntersectX," dia: ",2*IntersectX));
    
    //-------
    // Fin dimensions
    
    FinThick = 1*ThreadWidth;				// outer square
    StrutThick = 2*FinThick;				// diagonal struts
    
    FinSquare = 24.0;
    FinTaperLength = sqrt(2)*FinSquare/2 - sqrt(2)*FinThick - ThreadWidth;
    
    FinBaseLength = 2*TipLength;
    
    //-------
    
    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);
    
    }
    
    //-------
    // CO2 cartridge outline
    
    module Cartridge() {
    
    $fn = 48;
    
      union() {
    	translate([0,0,BodyBaseLength]) {
    	  cylinder(r=BodyDia/2,h=BodyLength);
    	  translate([0,0,BodyLength])
    		sphere(r=BodyRad);
    	}
    
    	intersection() {
    	  translate([0,0,BodyBaseLength])
    		sphere(r=BodyRad);
    	  union() {
    		translate([0,0,(TipLength + FilletLength+ConeLength)])
    		  cylinder(r=BodyRad,h=(BodyBaseLength - ConeLength));
    		translate([0,0,(TipLength + FilletLength)])
    		  cylinder(r1=FilletTopRad,r2=IntersectX,h=(ConeLength + Protrusion));
    		translate([0,0,TipLength])
    		  cylinder(r1=FilletBaseRad,r2=FilletTopRad,h=(FilletLength + Protrusion));
    		}
    	  }
    
    	translate([0,0,FilletTop])
    	  cylinder(r1=FilletTopRad,r2=IntersectX,h=ConeLength);
    
    	translate([0,0,TipLength])
    	  cylinder(r1=FilletBaseRad,r2=FilletTopRad,h=(FilletLength + Protrusion));
    
    	translate([0,0,-Protrusion])
    	  PolyCyl(TipDia,(TipLength + 2*Protrusion));
    
      }
    }
    
    //-------
    // Diagonal fin strut
    
    module FinStrut() {
      rotate([90,0,45])
    	translate([0,0,-StrutThick/2])
    	  linear_extrude(height=StrutThick)
    		polygon(points=[
    		  [0,0],
    		  [FinTaperLength,0],
    		  [FinTaperLength,FinBaseLength],
    		  [0,(FinBaseLength + FinTaperLength)]
    		]);
    }
    
    //-------
    // Fin outline
    
    module FinBlock() {
      union() {
    	translate([0,0,FinBaseLength/2])
    	  difference() {
    		cube([FinSquare,FinSquare,FinBaseLength],center=true);
    		difference() {
    		  cube([(FinSquare - 2*FinThick),
    			  (FinSquare - 2*FinThick),
    			  (FinBaseLength + 2*Protrusion)],center=true);
    		  for (Index = [0:3])
    			rotate(Index*90)
    			  translate([(FinSquare/2 - FinThick),(FinSquare/2 - FinThick),0])
    				cylinder(r=StrutThick,h=(FinBaseLength + 2*Protrusion),center=true,$fn=16);
    		}
    	  }
    	for (Index = [0:3])
    	  rotate(Index*90)
    		FinStrut();
    	cylinder(r=IntegerMultiple((FilletBaseRad + StrutThick),ThreadWidth),h=TipLength);
      }
    }
    
    //-------
    // Fins
    
    module FinAssembly() {
    
      difference() {
    	FinBlock();
    	translate([0,0,ThreadThick])				// add one layer to close base cylinder
    	  Cartridge();
      }
    
    }
    
    module FinFit() {
    
    	translate([0,0.75*BodyBaseLength,2*ThreadThick])
    	rotate([90,0,0])
    	  difference() {
    		translate([-FinSquare/2,-2*ThreadThick,0])
    		  cube([IntegerMultiple(FinSquare,ThreadWidth),
    			   4*ThreadThick,
    			   1.5*BodyBaseLength]);
    		translate([0,0,5*ThreadWidth])
    		  Cartridge();
    	  }
    
    }
    
    //-------
    // Build it!
    
    ShowPegGrid();
    
    if (Layout == "FinBlock")
      FinBlock();
    
    if (Layout == "Cartridge")
      Cartridge();
    
    if (Layout == "Show") {
      FinAssembly();
      color(LG) Cartridge();
    }
    
    if (Layout == "Fit")
      FinFit();
    
    if (Layout == "Build")
      FinAssembly();
    

    The original doodles:

    CO2 Cartridge Fin Doodles
    CO2 Cartridge Fin Doodles
  • 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();
    }