Ed Nisley's Blog: Shop notes, electronics, firmware, machinery, 3D printing, laser cuttery, and curiosities. Contents: 100% human thinking, 0% AI slop.
The ends have nice chamfered entrances made from octagons:
Garden Knife Sheath – entrances – solid model
The thing went away so fast I didn’t get a chance to photograph it, but magenta PETG filament should make it much harder to mislay, out there among the greenery…
The OpenSCAD source code:
// Garden Knife Scabbard
// Ed Nisley KE4ZNU - August 2015
//- Extrusion parameters - must match reality!
ThreadThick = 0.25;
ThreadWidth = 0.40;
function IntegerMultiple(Size,Unit) = Unit * ceil(Size / Unit);
Protrusion = 0.1;
HoleWindage = 0.2;
//------
// Dimensions
WallThick = IntegerMultiple(3.0,ThreadWidth);
Blade = [115,1.8,16.0];
Clearance = [10.0,2.0,2.0];
Slot = Blade + Clearance;
Sheath = Slot + [0,2*WallThick,2*WallThick];
//- Build it
translate([0,0,Sheath[2]/2])
difference() {
union() {
for (i=[-1,1])
translate([i*Sheath[0]/2,0,-Sheath[2]/2])
rotate(180/32)
cylinder(d=Sheath[1],h=Sheath[2],$fn=32);
cube(Sheath,center=true);
}
cube(Slot + [Slot[0],0,0],center=true);
for (i=[-1,1])
translate([i*(Sheath[0]/2 + Sheath[1]/2),0,-Slot[2]/2])
rotate(180/8)
cylinder(d=Sheath[1] - 4*ThreadWidth,h=Slot[2],$fn=8);
}
Being that type of guy, I measure the single-layer skirt threads to keep track of the platform alignment. Most of the time, nothing happens, because the M2 has a remarkably stable platform, but some of the objects I’d done in early August showed more than the usual variation and, worryingly, no discernible trend.
Adjusting the platform alignment between each of those sets produced no consistent effect, which is most unusual. The X in the bottom set shows where that thinwall box came unstuck from the platform, indicating that the clearance was considerably more than the nominal 0.25 mm layer height.
Peering under platform revealed something else that was quite unusual:
M3 washer – bad seating
That washer should be flat against the spider mounting plate. My first thought was a burr on the plate, but that didn’t make any sense, as the plate was clean & smooth when I installed the platform; I’d enlarged those holes with a fine file and would have checked for burrs as part of that operation.
Removing the screw nut and extracting the washer revealed the true problem:
M3 washer with burrs
It’s a bad washer!
Tossing that one in the trash and installing a good washer put everything in order:
M3 washer – proper seating
Well, that’s after re-doing the alignment to un-do the previous flailing around, of course.
As nearly as I can tell, that washer sat there without causing any trouble since I installed the hotrod platform. or, more likely, when I repaired a failed screw. In late July I poked the platform to measure how much it moved under pressure, which apparently dislodged the washer and put the burr in play.
That’s how sensitive a 3D printer is to mechanical problems…
Victoreen 710-104 Ionization Chamber Fittings – Show V2
There’s not much difference from the first iteration, apart from a few code cleanups. The engraved text is kinda-sorta gratuitous, but I figured having the circuit board dimensions on all the key parts would avoid heartache & confusion; the code now autosizes the board to the holder OD. Skeletonizing the board template didn’t save nearly as much printing time as I expected, though.
Now I can build a second electrometer amp without dismantling the two-transistor version.
The OpenSCAD source code:
// Victoreen 710-104 Ionization Chamber Fittings
// Ed Nisley KE4ZNU August 2015
Layout = "Show";
// Show - assembled parts
// Build - print can parts + shield
// BuildShield - print just the shield
// BuildHolder - print just the can cap & PCB base
// CanCap - PCB insulator for 6-32 mounting studs
// CanBase - surrounding foot for ionization chamber
// CanRim - generic surround for either end of chamber
// PCB - template for cutting PCB sheet
// PCBBase - holder for PCB atop CanCap
// Shield - electrostatic shield shell
//- Extrusion parameters must match reality!
// Print with 2 shells and 3 solid layers
ThreadThick = 0.25;
ThreadWidth = 0.40;
HoleWindage = 0.2;
Protrusion = 0.1; // make holes end cleanly
AlignPinOD = 1.75; // assembly alignment pins = filament dia
inch = 25.4;
function IntegerMultiple(Size,Unit) = Unit * ceil(Size / Unit);
//- Screw sizes
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;
Washer4_40OD = 0.270 * inch;
Washer4_40ID = 0.123 * inch;
//----------------------
// Dimensions
OD = 0; // name the subscripts
LENGTH = 1;
Chamber = [91.0,38]; // Victoreen ionization chamber dimensions
Stud = [ // stud welded to ionization chamber lid
[6.5,IntegerMultiple(0.8,ThreadThick)], // flat head -- generous clearance
[4.0,9.5], // 6-32 screw -- ditto
];
NumStuds = 3; // this really isn't much of a variable...
StudAngle = 360/NumStuds;
StudSides = 6; // for hole around stud
BCD = 2.75 * inch; // mounting stud bolt circle diameter
PlateThick = 2.0; // minimum layer atop and below chamber ends
RimHeight = 4.0; // extending along chamber perimeter
WallHeight = RimHeight + PlateThick;
WallThick = 3.0; // thick enough to be sturdy & printable
CapSides = 8*6; // must be multiple of 4 & 3 to make symmetries work out right
RimOD = Chamber[OD] + 2*WallThick;
echo(str("Rim OD: ",RimOD));
//PCBFlatsOD = 82.0; // desired hex dia flat-to-flat
PCBFlatsOD = floor(RimOD*cos(30)) - 2.0; // .. maximum possible
//PCBFlatsOD = floor(Chamber[OD]*cos(30)) - 2.0; // .. chamber fitting
PCBClearance = ThreadWidth; // clearance beyond each flat for mounting
PCBThick = 1.1;
PCBActual = [PCBFlatsOD/cos(30),PCBThick]; // OD = tip-to-tip
PCBCutter = [(PCBFlatsOD + 2*PCBClearance)/cos(30),PCBThick - ThreadThick]; // OD = tip-to-tip dia + clearance
PCBSize = str(PCBFlatsOD, " mm");
echo(str("Actual PCB across flats: ",PCBFlatsOD));
echo(str(" ... tip-to-tip dia: ",PCBActual[OD]));
echo(str(" ... thickness: ",PCBActual[LENGTH]));
HolderHeight = 13.0 + PCBCutter[LENGTH]; // thick enough for PCB to clear studs + batteries
HolderShelf = 2.0; // shelf under PCB edge
HolderTrim = 5.0; // remove end of holder to clear PCB edge solder blobs
echo(str("Holder trim distance: ",HolderTrim));
HolderTrimAngle = StudAngle/2 - 2*atan(HolderTrim*cos(StudAngle/2)/(PCBActual[OD]/2)); // atan is close for small angles
echo(str(" ... angle: ",HolderTrimAngle));
PinAngle = 15; // alignment pin angle on either side of holder screw
echo(str("PCB holder across flats: ",PCBCutter[OD]*cos(30)));
echo(str(" ... height: ",HolderHeight));
ShieldInset = 0.5; // shield inset from actual PCB flat
ShieldWall = 2.0; // wall thickness
ShieldLid = 6*ThreadThick; // top thickness (avoid one infill layer)
Shield = [(PCBFlatsOD - 2*ShieldInset)/ cos(30),40.0]; // electrostatic shield shell dimensions
TextSize = 4;
TextCharSpace = 1.05;
TextLineSpace = TextSize + 2;
TextDepth = 1*ThreadThick;
//----------------------
// 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(r=(FixDia + HoleWindage)/2,
h=Height,
$fn=Sides);
}
//- Locating pin hole with glue recess
// Default length is two pin diameters on each side of the split
module LocatingPin(Dia=AlignPinOD,Len=0.0) {
PinLen = (Len != 0.0) ? Len : (4*Dia);
translate([0,0,-ThreadThick])
PolyCyl((Dia + 2*ThreadWidth),2*ThreadThick,4);
translate([0,0,-2*ThreadThick])
PolyCyl((Dia + 1*ThreadWidth),4*ThreadThick,4);
translate([0,0,-Len/2])
PolyCyl(Dia,Len,4);
}
module ShowPegGrid(Space = 10.0,Size = 1.0) {
RangeX = floor(100 / Space);
RangeY = floor(125 / Space);
for (x=[-RangeX:RangeX])
for (y=[-RangeY:RangeY])
translate([x*Space,y*Space,Size/2])
%cube(Size,center=true);
}
//-----
module CanRim(BaseThick) {
difference() {
cylinder(d=Chamber[OD] + 2*WallThick,h=(WallHeight + BaseThick),$fn=CapSides);
translate([0,0,BaseThick])
PolyCyl(Chamber[OD],Chamber[LENGTH],CapSides);
}
}
module CanCap() {
difference() {
CanRim(PlateThick + Stud[0][LENGTH]);
translate([0,0,-Protrusion]) // central cutout
rotate(180/6)
cylinder(d=BCD,h=Chamber[LENGTH],$fn=6); // ... reasonable size
for (i=[0:(NumStuds - 1)]) // stud clearance holes
rotate(i*StudAngle)
translate([BCD/2,0,0])
rotate(180/StudSides) {
translate([0,0,PlateThick])
PolyCyl(Stud[0][OD],Chamber[LENGTH],StudSides);
translate([0,0,-Protrusion])
PolyCyl(Stud[1][OD],Chamber[LENGTH],StudSides);
}
for (i=[0:(NumStuds - 1)], j=[-1,1]) // PCB holder alignment pins
rotate(i*StudAngle + j*PinAngle + 60)
translate([Chamber[OD]/2,0,0])
rotate(180/4 - j*PinAngle)
LocatingPin(Len=2*(PlateThick + Stud[0][LENGTH]) - 4*ThreadThick);
translate([-(BCD/2),0,-Protrusion])
rotate(90) mirror()
linear_extrude(height=(ThreadThick + Protrusion))
text(PCBSize,size=6,font="Liberation Mono:style=bold",halign="center",valign="center");
}
}
module CanBase() {
difference() {
CanRim(PlateThick);
translate([0,0,-Protrusion])
PolyCyl(Chamber[OD] - 2*RimHeight,Chamber[LENGTH],CapSides);
}
}
module PCBTemplate() {
CutLen = 10*PCBActual[LENGTH];
difference() {
cylinder(d=PCBActual[OD],h=PCBActual[LENGTH],$fn=6); // actual PCB size
translate([0,0,-Protrusion])
cylinder(d=8,h=CutLen,$fn=12);
if (true)
for (i=[0:5]) // empirical cutouts
rotate(i*60 + 30)
translate([PCBFlatsOD/3,0,-Protrusion])
rotate(60)
cylinder(d=0.43*PCBActual[OD],h=CutLen,$fn=3);
translate([PCBActual[OD]/4,0,(PCBActual[LENGTH] - ThreadThick)])
linear_extrude(height=(ThreadThick + Protrusion),convexity=1)
text(PCBSize,size=4,font="Liberation Mono:style=bold",halign="center",valign="center");
}
}
module PCBBase() {
intersection() {
difference() {
cylinder(d=Chamber[OD] + 2*WallThick,h=HolderHeight,$fn=CapSides); // outer rim
rotate(30) {
translate([0,0,-Protrusion]) // central hex
cylinder(d=(PCBActual[OD] - HolderShelf/cos(30) - HolderShelf/cos(30)),h=2*HolderHeight,$fn=6);
translate([0,0,HolderHeight - PCBCutter[LENGTH]]) // hex PCB recess
cylinder(d=PCBCutter[OD],h=HolderHeight,$fn=6);
for (i=[0:NumStuds - 1]) // PCB retaining screws
rotate(i*StudAngle + 180/(2*NumStuds))
translate([(PCBCutter[OD]*cos(30)/2 + Clear4_40/2 + ThreadWidth),0,-Protrusion])
rotate(180/6)
PolyCyl(Tap4_40,2*HolderHeight,6);
for (i=[0:(NumStuds - 1)], j=[-1,1]) // PCB holder alignment pins
rotate(i*StudAngle + j*PinAngle + 180/(2*NumStuds))
translate([Chamber[OD]/2,0,0])
rotate(180/4 - j*PinAngle)
LocatingPin(Len=2*(HolderHeight - 4*ThreadThick));
}
if (false)
for (i=[0:NumStuds - 1])
rotate(i*StudAngle - StudAngle/2) // segment isolation - hex sides
translate([0,0,-Protrusion]) {
linear_extrude(height=2*HolderHeight)
polygon([[0,0],[Chamber[OD],0],[Chamber[OD]*cos(180/NumStuds),Chamber[OD]*sin(180/NumStuds)]]);
}
translate([-(PCBFlatsOD/2 + PCBClearance - HolderShelf),0,HolderHeight/2])
rotate([0,90,0]) rotate(90)
linear_extrude(height=(ThreadWidth + Protrusion))
text(PCBSize,size=6,font="Liberation Mono:style=bold",halign="center",valign="center");
}
for (i=[0:NumStuds - 1])
rotate(i*StudAngle + StudAngle/2 - HolderTrimAngle/2) // trim holder ends
translate([0,0,-Protrusion]) {
linear_extrude(height=2*HolderHeight)
polygon([[0,0],[Chamber[OD],0],[Chamber[OD]*cos(HolderTrimAngle),Chamber[OD]*sin(HolderTrimAngle)]]);
}
}
}
//-- Electrostatic shield
// the cutouts are completely ad-hoc
module ShieldShell() {
CutHeight = 7.0;
difference() {
cylinder(d=Shield[OD],h=Shield[LENGTH],$fn=6); // exterior shape
translate([0,0,-ShieldLid]) // interior
cylinder(d=(Shield[OD] - 2*ShieldWall/cos(30)),h=Shield[LENGTH],$fn=6);
translate([0,0,Shield[LENGTH] - TextDepth])
rotate(180) {
translate([0,0.3*Shield[OD] - 0*TextLineSpace,0])
linear_extrude(height=(TextDepth + Protrusion))
text("Gamma",size=TextSize,spacing=TextCharSpace,font="Liberation:style=bold",halign="center",valign="center");
translate([0,0.3*Shield[OD] - 1*TextLineSpace,0])
linear_extrude(height=(TextDepth + Protrusion))
text("Ionization",size=TextSize,spacing=TextCharSpace,font="Liberation:style=bold",halign="center",valign="center");
translate([0,0.3*Shield[OD] - 2*TextLineSpace,0])
linear_extrude(height=(TextDepth + Protrusion))
text("Amplifier",size=TextSize,spacing=TextCharSpace,font="Liberation:style=bold",halign="center",valign="center");
translate([0,-0.3*Shield[OD] + 1*TextLineSpace,0])
linear_extrude(height=(TextDepth + Protrusion))
text("KE4ZNU",size=TextSize,spacing=TextCharSpace,font="Liberation:style=bold",halign="center",valign="center");
translate([0,-0.3*Shield[OD] + 0*TextLineSpace,0])
linear_extrude(height=(TextDepth + Protrusion))
text("2015-08",size=TextSize,spacing=TextCharSpace,font="Liberation:style=bold",halign="center",valign="center");
}
translate([Shield[OD]/4 - 20/2,Shield[OD]/2,(CutHeight - Protrusion)/2]) // switch
rotate(90)
cube([Shield[OD],20,CutHeight + Protrusion],center=true);
if (false)
translate([-Shield[OD]/4 + 5/2,Shield[OD]/2,(CutHeight - Protrusion)/2]) // front
rotate(90)
cube([Shield[OD],5,CutHeight + Protrusion],center=true);
translate([-Shield[OD]/2,0,(CutHeight - Protrusion)/2]) // right side
cube([Shield[OD],7,CutHeight + Protrusion],center=true);
translate([0,(Shield[OD]*cos(30)/2 - ThreadWidth),0.75*Shield[LENGTH]])
rotate([90,0,180]) rotate(00)
linear_extrude(height=(ThreadWidth + Protrusion))
text(PCBSize,size=5,font="Liberation Mono:style=bold",halign="center",valign="center");
}
}
//----------------------
// Build it
ShowPegGrid();
if (Layout == "CanRim") {
CanRim();
}
if (Layout == "CanCap") {
CanCap();
}
if (Layout == "CanBase") {
CanBase();
}
if (Layout == "PCBBase") {
PCBBase();
}
if (Layout == "PCB") {
PCBTemplate();
}
if (Layout == "Shield") {
ShieldShell();
}
if (Layout == "Show") {
CanBase();
color("Orange",0.5)
translate([0,0,PlateThick + Protrusion])
cylinder(d=Chamber[OD],h=Chamber[LENGTH],$fn=CapSides);
translate([0,0,(2*PlateThick + Chamber[LENGTH] + 2*Protrusion)])
rotate([180,0,0])
CanCap();
translate([0,0,(2*PlateThick + Chamber[LENGTH] + 5.0)])
PCBBase();
color("Green",0.5)
translate([0,0,(2*PlateThick + Chamber[LENGTH] + 7.0 + HolderHeight)])
rotate(30)
PCBTemplate();
translate([0,0,(2*PlateThick + Chamber[LENGTH] + 15.0 + HolderHeight)])
rotate(-30)
ShieldShell();}
if (Layout == "Build") {
translate([-0.50*Chamber[OD],-0.60*Chamber[OD],0])
CanCap();
if (false)
translate([0.55*Chamber[OD],-0.60*Chamber[OD],0])
rotate(30)
translate([0,0,Shield[LENGTH]])
rotate([0,180,0])
ShieldShell();
if (true)
translate([0.55*Chamber[OD],-0.60*Chamber[OD],0])
rotate(30)
PCBTemplate();
if (true)
translate([-0.25*Chamber[OD],0.60*Chamber[OD],0])
CanBase();
translate([0.25*Chamber[OD],0.60*Chamber[OD],0])
PCBBase();
}
if (Layout == "BuildHolder") {
translate([-0.25*Chamber[OD],0,0])
CanCap();
translate([0.25*Chamber[OD],0,0])
PCBBase();
}
if (Layout == "BuildShield") {
translate([0,0,Shield[LENGTH]])
rotate([0,180,0])
ShieldShell();
}
Sticking an extruded plastic thread to the platform of a 3D printer requires absolutely accurate alignment and spacing, maybe ±0.05 mm across the entire platform. I’ll leave the topic of automatic alignment measurement & compensation for another day; here’s how to measure the actual platform alignment.
If the wall thickness (in the XY plane) doesn’t come out exactly right, fix that first by verifying the filament diameter setting, then adjusting the Extrusion Multiplier. If the extruder doesn’t produce the same wall thickness that the slicer calls for, you won’t get good results from anything else. In this case, they all have 0.40 mm thick walls, with 0.25 mm layers.
The first layer of all five boxes should be identical:
M2 V4 nozzle – thinwall box first layer
If the platform isn’t absolutely flat and properly aligned, those five first layers won’t be the same thickness. It’s surprisingly easy to spot differences under 0.05 mm, so pay attention to what’s happening.
When they’re done, pop them off and measure their actual height. I measure across adjacent sides, leaving the corners / stray hairs / snot out of the measurement, and figure the eyeballometric average of the values, which usually differ by less than ±0.03 mm. Write the height on the side to eliminate future angst:
Thinwall Box – platform height
The boxes should be 5.00 mm tall, so the leftmost box is short by -0.02 mm and the rightmost by -0.15 mm. The five boxes were 4.98, 4.95, 4.93, 4.92, and 4.85, with a mean of 4.93 mm. The variation across the 200×250 mm platform is 0.13 mm, which is pretty good.
Comparing the bottom layers of those boxes, the first layer of the 4.85 mm box is definitely squashed:
Thinwall Hollow Boxes – first layer bottom view – 4.98 4.85 mm
Once you know what to look for, it’s also obvious from the side (4.98 on the left, 4.85 on the right, bottom layers facing each other):
Thinwall boxes – 4.98 4.85 – bottom layers
Keep in mind that’s a difference of 0.13 mm = 130 µm, just over the ±0.05 mm I usually bandy about. The nominal layers are 0.25 mm = 250 µm.
A bit more magnification shows the nicely rounded first layer of the 4.98 mm box (rightmost thread of leftmost set):
Thinwall Box – 4.98 mm
And the squashed first layer of the 4.85 mm box (likewise):
Thinwall Box – 4.85 mm
Because the Z axis moves upward (on the M2, the platform moves downward) by exactly the layer thickness at the end of each layer, the first layer must absorb the entire difference between the desired thickness and the actual nozzle-to-platform distance. That squashed first layer is 0.10 mm thick, a bit less than half of the nominal 0.25 mm. The second layer of each box looks just like all the higher layers.
You can set the Z-axis offset for a very slight squish, with the maximum nozzle-to-platform distance at 0.25 mm and the minimum set by the other end of the total misalignment, because the plastic won’t adhere to the platform when the nozzle-to-platform distance exceeds the nozzle diameter.
Think of it this way: the plastic emerges from a 0.35 mm nozzle as a (slightly larger than) 0.35 mm cylinder that must squash to become a 0.25 mm high x 0.40 mm wide thread. Given the measurements above, setting the Z-axis home position to make the average box height equal to 5.00 mm would make the tallest box come out at 5.07 mm, which requires a 0.32 mm actual first layer that probably wouldn’t stick well at all.
When your printer can consistently produce five thinwall boxes with the proper wall thickness and height, then you can move on to more complex objects.
Although Mary’s name in the base of the Clover Mini Iron holder was readable in person, I wondered what filling the characters with epoxy would do. A bit of tinkering produced a name plate:
Text Block – solid model
Which is more readable in person, but magenta PETG renders it basically unreadable here:
Text Block – unfilled
The intent of this was not to produce a lovely name block, but to see what various epoxy fills and techniques produced. Think of this as the one you must build to throw away…
I tediously filled the first line with straight JB Weld epoxy, deliberately ruining the least functional of my 1 ml syringes to ease a strand of epoxy into each letter, then poking the goo into place with a pointed rod:
Text Block – plain epoxy fill
That was way tedious.
Having recently replaced the cartridge in our trusty HP Laserjet 1200, I had no qualms about step-drilling the “empty” cartridge to get the toner. For future reference, here’s where you drill into a 7115X cartridge:
HP 7115X Toner Cartridge – holes in waste and supply compartments
I probably used too much toner, but one heaping pile on that wooden stick didn’t seem like a lot at the time:
Text Block – toner black epoxy
This turned the epoxy rather thick and pasty; it didn’t ease into the letters very well at all. After the usual day, it cured into a slightly rubbery solid, quite unlike the usual rock-solid epoxy blob.
Some rummaging in the Basement Laboratory Warehouse Wing turned up two containers of aluminum powder from an Etch-a-Sketch; I mixed some into another batch of epoxy, to very little effect. With both blends, I just squished the epoxy into the letters and didn’t worry too much about slobbering any over the surface of the block.
To even off the top surface, I affixed the block to the Sherline’s tooling plate with tapeless sticky (basically double-sided tape without the tape):
Text Block – milling setup
Manually traversing the surface (3 k rpm, 24 inch/min) and stepping downward about 0.1 mm per pass gradually crisped up the letters. I expected the excess epoxy to vanish after going 0.1 mm or so into the top layer, but it actually required removing the entire 0.25 mm Hilbert-curve-filled surface layer to get rid of the epoxy that soaked into / through the tiny gaps. This is 0.4 mm down from the first pass, maybe 0.1 mm into the plastic:
Text Block – milled 0.4 mm
With the top layer gone, it looked rather gnarly, so I applied a sanding block that didn’t do much at all: smoother, still gnarly. Spreading maybe 0.3 ml of IPS 4 solvent adhesive over the sanded surface smoothed it a bit:
Text Block – sanded and leveled with IPS 4
Perhaps a topcoat of clear epoxy, along the lines of XTC-3D, would produce better results.
The small black dots in the top line are holes from bubbles in the epoxy. The missing section of the M started out as a bubble (just visible at 0.4 mm) and gradually enlarged as pieces tore out of the recess. There’s another bubble breaking the right stroke of the “y”.
The small dots in the “ley” are plastic spheres that carried the aluminum powder in the Etch-a-Sketch; they’re cross-sectioned and perfectly flat. The epoxy color is marginally lighter than the top line, but not enough to notice.
Backlit on a window, nearly all of the ugly fades away:
Text Block – backlit
It’s definitely not presentation quality, that’s for sure, and I won’t attempt to fill the Mini Iron holder…
The OpenSCAD source code, which can also produce the soldering iron holder:
// Clover MCI-900 Mini Iron holder
// Ed Nisley KE4ZNU - August 2015
Layout = "Text"; // Iron Holder Show Text
//- Extrusion parameters - must match reality!
ThreadThick = 0.25;
ThreadWidth = 0.40;
function IntegerMultiple(Size,Unit) = Unit * ceil(Size / Unit);
Protrusion = 0.1;
HoleWindage = 0.2;
inch = 25.4;
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;
Washer10_32OD = 0.381 * inch;
Washer10_32ID = 0.204 * inch;
//------
// Dimensions
CornerRadius = 4.0;
CenterHeight = 25; // center at cord inlet on body
BodyLength = 110; // cord inlet to body curve at front flange
Incline = 10; // central angle slope
FrontOD = 29;
FrontBlock = [20,1.5*FrontOD + 2*CornerRadius,FrontOD/2 + CenterHeight + BodyLength*sin(Incline)];
CordOD = 10;
CordLen = 10;
RearOD = 22;
RearBlock = [15 + CordLen,1.5*RearOD + 2*CornerRadius,RearOD/2 + CenterHeight];
PlateWidth = 2*FrontBlock[1];
TextDepth = 4*ThreadThick;
ScrewOC = BodyLength - FrontBlock[0]/2;
ScrewDepth = CenterHeight - FrontOD/2 - 5;
echo(str("Screw OC: ",ScrewOC));
BuildSize = [200,250,200]; // largest possible thing
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);
}
// Trim bottom from child object
module TrimBottom(BlockSize=BuildSize,Slice=CornerRadius) {
intersection() {
translate([0,0,BlockSize[2]/2])
cube(BlockSize,center=true);
translate([0,0,-Slice])
children();
}
}
// Build a rounded block-like thing
module RoundBlock(Size=[20,25,30],Radius=CornerRadius,Center=false) {
HS = Size/2 - [Radius,Radius,Radius];
translate([0,0,Center ? 0 : (HS[2] + Radius)])
hull() {
for (i=[-1,1], j=[-1,1], k=[-1,1]) {
translate([i*HS[0],j*HS[1],k*HS[2]])
sphere(r=Radius,$fn=4*4);
}
}
}
// Create a channel to hold something
// This will eventually be subtracted from a block
// The offsets are specialized for this application...
module Channel(Dia,Length) {
rotate([0,90,0])
linear_extrude(height=Length)
rotate(90)
hull() {
for (i=[-1,1])
translate([i*Dia,2*Dia])
circle(d=Dia/8);
circle(d=Dia,$fn=8*4);
}
}
// Iron-shaped series of channels to be removed from blocks
module IronCutout() {
union() {
translate([-2*CordLen,0,0])
Channel(CordOD,2*CordLen + Protrusion);
Channel(RearOD,RearBlock[0] + Protrusion);
translate([BodyLength - FrontBlock[0]/2 - FrontBlock[0],0,0])
Channel(FrontOD,2*FrontBlock[0]);
}
}
module TextBlock() {
translate([2,10,0])
linear_extrude(height=TextDepth + Protrusion,convexity=2) // rendering glitches for convexity > 1
// text("Mary",font="Ubuntu:style=Bold Italic",halign="center",valign="center");
text("Mary",font="Junicode:style=Bold Italic",halign="center",valign="center",size=20,spacing=1.05);
translate([2,-15,0])
linear_extrude(height=TextDepth + Protrusion,convexity=2)
text("Nisley",font="Junicode:style=Bold Italic",halign="center",valign="center",size=20,spacing=1.05);
}
//- Build it
if (Layout == "Iron")
IronCutout();
if (Layout == "Holder" || Layout == "Show")
difference() {
union() {
translate([(BodyLength + CordLen)/2 - CordLen,0,0])
TrimBottom()
RoundBlock(Size=[(CordLen + BodyLength),PlateWidth,CornerRadius]);
translate([(RearBlock[0]/2 - CordLen),0,0])
TrimBottom()
RoundBlock(Size=RearBlock);
translate([BodyLength - FrontBlock[0]/2,0,0]) {
TrimBottom()
RoundBlock(Size=FrontBlock);
}
}
translate([0,0,CenterHeight])
rotate([0,-Incline,0])
if (Layout == "Show")
# IronCutout();
else
IronCutout();
translate([0,0,-Protrusion])
PolyCyl(Tap10_32,ScrewDepth + Protrusion,6);
translate([ScrewOC,0,-Protrusion])
PolyCyl(Tap10_32,ScrewDepth + Protrusion,6);
translate([(RearBlock[0] - CordLen) + BodyLength/2 - FrontBlock[0],0,CornerRadius - TextDepth])
TextBlock();
}
if (Layout == "Text")
difference() {
translate([0,0,0])
TrimBottom(Slice=8*ThreadThick)
RoundBlock(Size=[80,65,8*ThreadThick],Radius=8*ThreadThick);
# translate([-2,2,8*ThreadThick - TextDepth])
TextBlock();
}
Thinwall open boxes – side detail – 4.98 4.85 measured
Alas, the shutter failed after that image, leaving me with pictures untaken and naught to take them with.
The least-awful alternative seems to be gimmicking up an adapter for a small USB camera from the usual eBay source:
Fashion USB video – case vs camera
The camera’s 640×480 VGA resolution is marginally Good Enough for the purpose, as I can zoom the microscope to completely fill all those pixels. The optics aren’t up to the standard set by the microscope, but we can cope with that for a while.
A bit of doodling & OpenSCAD tinkering produced a suitable adapter:
USB Camera Microscope Mount – solid model
To which Slic3r applied the usual finishing touches:
USB Camera Microscope Mount – Slic3r preview
A bit of silicone tape holds the sloppy focusing thread in place:
USB Camera Microscope Mount – cap with camera
Those are 2-56 screws that will hold the cap onto the tube. I drilled out the clearance holes in the cap and tapped the holes in the eyepiece adapter by hand, grabbing the bits with a pin vise.
Focus the lens at infinity, which in this case meant an old DDJ cover poster on the far wall of the Basement Laboratory, and then it’ll be just as happy with the image coming out of the eyepiece as a human eyeball would be.
I put a few snippets of black electrical tape atop the PCB locating tabs before screwing the tube in place. The tube ID is 1 mm smaller than the PCB OD, in order to hold the PCB perpendicular to the optical axis and clamp it firmly in place. Come to find out that the optical axis of the lens isn’t perfectly perpendicular to the PCB, but it’s close enough for my simple needs.
And then it fits just like you’d expect:
USB Camera Microscope Mount – on eyepiece
Actually, that’s the second version. The distance from the camera lens (equivalently: the PCB below the optical block, which I used as the datum plane) to the eyepiece is a critical dimension that determines whether the image fills the entrance pupil. I guesstimated the first version by hand-holding the camera and measuring with a caliper, tried it out, then iteratively whacked 2 mm off the tube until the image lit up properly:
USB Camera Microscope Mount – adjusting tube length
Minus 4 mm made it slightly too short, but then I could measure the correct position, tweak that dimension in the code, and get another adapter, just like the first one (plus a few other minor changes), except that it worked:
USB Camera Microscope Mount – first light
That’s a screen capture from VLC, which plays from /dev/video0 perfectly. Some manual exposure & color balance adjustment may be in order, but it’s pretty good for First Light.
It turns out that removing the eyepiece and holding the bare sensor over the opening also works fine. The real image from the objective fills much more area than the camera’s tiny sensor: the video image covers about one digit in that picture, but gimmicking up a bare-sensor adapter might be useful.
A place to store your vials of blended inkjet juice, plus a workstation for the plotter pen you’re refilling and that ink vial up front:
HP7475A Plotter Pen Refilling Station
The two pen holders accommodate ordinary fiber-tip pens and ceramic-tip pens. The slot along the front lets you keep track of the ink level, not that there’s much danger of running dry at 0.05 ml per refill from a vial holding 1 ml of blended ink. The big flange makes it harder for me to knock the damn thing over; avoiding an ink spill, even when you have a towel underneath, is a Good Thing.
The Slic3r tool path preview shows off the Hilbert Curve top & bottom infill:
Plotter Pen Refill Vial Holder – Slic3r preview
The OpenSCAD source code:
// HP7475A Plotter Pen Refill Station
// Ed Nisley KE4ZNU - August 2015
//- Extrusion parameters - must match reality!
ThreadThick = 0.25;
ThreadWidth = 0.40;
function IntegerMultiple(Size,Unit) = Unit * ceil(Size / Unit);
Protrusion = 0.1;
HoleWindage = 0.2;
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
WallThick = 6*ThreadWidth;
BaseThick = IntegerMultiple(1.0,ThreadThick);
VialOD = 8.0;
VialOC = VialOD + WallThick;
VialArray = [4,4]; // number of vials in each direction
PenOD = [14.7,11.7]; // regular fiber pen body, ceramic *cap* dia
NumPens = len(PenOD); // really works for just two pens...
PenLength = 38;
FlangeOD = 18;
echo(str("Max pen OD: ",max(PenOD)));
echo(str("Number of pens: ",len(PenOD)));
Holder = [(VialOC*VialArray[0] + WallThick),(VialOC*VialArray[1] + 2*FlangeOD + WallThick),(3*VialOD + BaseThick)];
HolderRound = 5.0;
//- Build it
difference() {
union() {
hull() {
for (i=[-1,1], j=[-1,1]) {
translate([i*(Holder[0]/2 - HolderRound),j*(Holder[1]/2 - HolderRound),0])
cylinder(r=HolderRound,h=Holder[2],$fn=8*4);
}
}
hull() {
for (i=[-1,1], j=[-1,1]) {
translate([i*Holder[1]/2,j*(Holder[1]/2 - HolderRound),0])
cylinder(r=HolderRound,h=BaseThick,$fn=8*4);
}
}
for (i=[0:len(PenOD) - 1])
translate([(i*Holder[0]/2 - Holder[0]/4),-Holder[1]/4,BaseThick]) { // spacing is a total hack
rotate(180/12)
cylinder(d=FlangeOD,h=PenLength,$fn=3*4);
}
}
for (i=[0:VialArray[0] - 1] , j=[0:VialArray[1] - 1]) {
vx = i*VialOC - (VialOC*(VialArray[0] - 1)/2);
vy = j*VialOC - (VialOC*(VialArray[1] - 1)/2) + FlangeOD;
translate([vx,vy,BaseThick])
rotate(180/8)
PolyCyl(VialOD,Holder[2],8);
}
translate([0,(VialOD/2 - Holder[1]/2),BaseThick])
rotate(180/8)
PolyCyl(VialOD,Holder[2],8); // edges along open side => snug fit
for (i=[0:len(PenOD) - 1])
translate([(i*Holder[0]/2 - Holder[0]/4),-Holder[1]/4,BaseThick]) { // spacing is a total hack
rotate(180/12)
PolyCyl(PenOD[i],(PenLength + Protrusion),3*4);
}
}
The Smell of Molten Projects in the Morning 