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.
Growing and sometimes fixing
Mary bound up a mesh cover for the shelter frame and deployed it to protect some yummy seedlings:
Those will become the next round of lunchtime sandwiches:
It’s a quarter-pounder: 4 oz of turkey, 4 oz of lettuce, and a layer of Swiss and good stinky Provolone cheese. Yum!
This is laid in against a need I hope never occurs:
It’s intended to clamp around one of the Dripworks mainline pipes carrying water from the pressure regulator to the driplines in the raised beds, should an errant shovel or fork find the pipe.
It descends from a long line of soaker hose clamps, with a 25 mm ID allowing for a silicone tape wrap as a water barrier.
The solid model has no surprises:
The OpenSCAD source code as a GitHub Gist:
| // Dripworks 3/4 inch mainline clamp | |
| // Ed Nisley KE4ZNU 2021-06 | |
| Layout = "Build"; // [Hose,Block,Show,Build] | |
| HoseOD = 25.0; | |
| TestFit = false; // true to build test fit slice from center | |
| //- 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; | |
| //———- | |
| // Dimensions | |
| // Hose lies along X axis | |
| Hose = [200,HoseOD,HoseOD]; // X = longer than anything else | |
| NumScrews = 2; // screws along each side of cable | |
| WallThick = 3.0; // Thinnest printed wall | |
| PlateThick = 1.5; // Stiffening plate thickness | |
| // 8-32 stainless screws | |
| Screw = [4.1,8.0,50.0]; // OD = head LENGTH = thread length | |
| Washer = [4.4,9.5,1.0]; | |
| Nut = [4.1,9.7,3.3]; | |
| Block = [30.0,Hose.y + 2*Washer[OD],HoseOD + 2*WallThick]; // overall splice block size | |
| echo(str("Block: ",Block)); | |
| ScrewMinLength = Block.z + 2*PlateThick + 2*Washer.z + Nut.z; // minimum screw length | |
| echo(str("Screw min length: ",ScrewMinLength)); | |
| Kerf = 1.0; // cut through middle to apply compression | |
| CornerRadius = Washer[OD]/2; | |
| ScrewOC = [(Block.x – 2*CornerRadius) / (NumScrews – 1), | |
| Block.y – 2*CornerRadius, | |
| 2*Block.z // ensure complete holes | |
| ]; | |
| 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() { | |
| NumSides = 12*4; | |
| rotate([0,-90,0]) | |
| translate([0,0,-Hose.x/2]) | |
| resize([Hose.z,Hose.y,0]) | |
| cylinder(d=Hose.z,h=Hose.x,$fn=NumSides); | |
| } | |
| // 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 (i = [0:NumScrews – 1], j=[-1,1]) // screw holes | |
| translate([-(Block.x/2 – CornerRadius) + i*ScrewOC.x, | |
| j*ScrewOC.y/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(); | |
| } | |
| } | |
| //———- | |
| // Build them | |
| if (Layout == "Hose") | |
| HoseProfile(); | |
| if (Layout == "Block") | |
| SpliceBlock(); | |
| if (Layout == "Show") { | |
| difference() { | |
| SpliceBlock(); | |
| HoseProfile(); | |
| } | |
| color("Green",0.25) | |
| HoseProfile(); | |
| } | |
| if (Layout == "Build") { | |
| SliceOffset = TestFit && !(NumScrews % 2) ? ScrewOC.x/2 : 0; | |
| intersection() { | |
| translate([SliceOffset,0,Block.z/4]) | |
| if (TestFit) | |
| cube([ScrewOC.x/2,4*Block.y,Block.z/2],center=true); | |
| else | |
| 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(); | |
| } | |
| } | |
| } |
Mary chased a small rabbit out of her garden a few days ago, whereupon we up-armored a few vulnerable parts of the fence. The culprit turns out to be insufferably cute:
You cannot be annoyed with something like this:
Oh, yes, you can. Rabbits are basically eating machines:
They’re welcome to all the greenery in the yard, just nothing in the garden:
It’s known as a 2×2 Bunny, because it can fit through that size opening in a chain link fence while traveling at a dead run.
This one has yet to learn about being wary around the Big People:
The alert reader will have noted the crappy quality of the last three pictures, at least in comparison with the first two. It’s the difference between digital zoom on my Pixel 3a phone applied to a zoomed-all-the-way image and optical zoom on a “real” camera (admittedly, an old Sony DSC-H5). On the other paw, I had the phone in my pocket when Mary spotted the bunny on the driveway, which counts for everything in similar situations.
JPG compression doesn’t handle hair particularly well, so the low-res bunny wears a rather artistic brush-stroke coat; it’s OK if you like that sort of thing.
We recently installed a Dripworks drip irrigation system for Mary’s garden and, of course, pre-assembled the emitter / dripline tubing, fittings, and supply / filter / plumbing for each of the beds in the Basement Shop. A few days after burying the main lines, plumbing the filter + pressure regulator, and plugging in half a dozen bed assemblies, Mary noticed some emitter tubes weren’t delivering any water and other beds seemed too dry.
N.B.: We bought everything directly from Dripworks. This is not counterfeit crap from a sketchy Amazon seller.
I cut the dripline just downstream of the Micro-Flow valve on a completely dry bed, whereupon no water emerged. Cutting the supply tube just upstream of the valve produced a jet squirting halfway along the bed. I tried and failed to blow air through the valve: it was completely blocked despite being in the “open” position. I installed another valve and the emitter tube started working properly.
I sat down at the kitchen table with a bag of unused valves and peered through them (the pix are through the microscope):
That’s one of the better-looking valves, with only a little mold flash in the lumen.
Partially occluded lumens were more typical:
Quite a few were almost completely obstructed:
For lack of better instrumentation, I blew through the valves and sorted them by effort:
Two of the valves in the group on the left are completely blocked, with the others mostly blocked.
The middle group has enough mold flash to produce noticeable resistance to the air flow. I think water would have more trouble getting through, but the emitters would at least look like they’re delivering water.
The group on the right has mostly unblocked valves, with visible mold flash but little restriction.
I have no way to measure the actual water flow, so it’s entirely possible the QC spec allows considerable blockage while still delivering enough water to the emitters. More likely, the spec assumes a clear lumen and the mold flash is a total QC faceplant; it’s obviously not a controlled quantity.
Well, I can fix that:
That’s a 2.3 mm drill going straight through the valve body. I drilled the valves from both ends and blew out the swarf:
That produced twenty valves with clear lumens. Of course, the drill leaves a slightly rough interior surface, but it’s now much easier to blow air through them.
We hadn’t installed the driplines in two beds with three emitter tubes per bed. I cut out those six unused valves and sorted them by resistance:
Both of the valves on the left are blocked, the three on the right are mostly OK, and the one in the middle is partially blocked.
With two dozen repaired valves in hand, we returned to the garden, I cut 22 valves out of the installed driplines and replaced them under field conditions. Returning to the Basement Laboratory, I blew the water out (*), sorted them by resistance, and produced a similar distribution, albeit with no pictorial evidence. Although we have no immediate need for the used valves, they’re drilled out and ready for use.
In very round numbers, you should expect:
Plan to drill out all the Micro-Flow valves before you assemble your driplines.
AFAICT, none of the other ¼ inch fittings we used have any interior flash, so it’s only a problem with the valves.
We are, as the saying goes, not amused.
(*) If you will eat a peck of dirt before you die, I’m well on my way.
The objective being to reduce the number of onion maggots in Mary’s Vassar Farm plot without chemical agents, I conjured sticky trap screen frames from the vasty digital deep:
Each one contains half a sheet of yellow sticky plastic, which is easy enough to cut before peeling off the protective covering sheets. The cage is half-inch galvanized hardware cloth snipped with hardened diagonal cutters. A bead of acrylic adhesive around the base holds the cage in place
Although you can deploy sticky sheets without cages, they tend to attract and affix beneficial critters: butterflies, small birds, furry critters, toads, gardeners, and the like. We don’t know how effective the cages will be, but they seemed better than nothing.
They mount on ski poles cut in half:
And on fence posts around the perimeter:
To my untrained eye, some of those doomed critters are, indeed, onion maggot flies. The rest seem to be gnats and other nuisances, so IMO we’re applying population pressure in the right direction.
Each base-and-cap frame takes about three hours to print, so I did them one at a time over the course of a few days while applying continuous product improvement.
The sheets rest on small V blocks intended to keep them centered within the cage:
The ski pole attachment must build with the cap on top, but it bridges well enough for the purpose:
The overhanging hooks on the blocks (just barely) engage the grid to keep the lid in place, while remaining short enough to not droop too badly. You could probably delete the hooks from the bottom plate, but they align the cage while the adhesive cures.
The sheets tend to bend in the middle, so I’ll stick a thin slat or two vertically to keep them straight.
The OpenSCAD source code as a GitHub Gist:
| // Sticky Sheet Cage | |
| // Ed Nisley KE4ZNU May 2021 | |
| Layout = "Build"; // [Build, Show, Cap, Attachment] | |
| Bracket = "Ski"; // [Angle, Ski, Post] | |
| //- 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; | |
| ID = 0; | |
| OD = 1; | |
| LENGTH = 2; | |
| function IntegerMultiple(Size,Unit) = Unit * ceil(Size / Unit); | |
| //———————- | |
| // Dimensions | |
| Sheet = [1,100,150]; // sticky sheet | |
| Grid = 0.5*inch; | |
| Cage = [2*Grid + 5.0, 8*Grid + 5.0, 12*Grid + 2.0]; // grid wire cage bent around sheet | |
| CageRad = 2.5; // wire bending radius | |
| CageThick = 2.0; // grid thickness | |
| WallThick = 3.0; // min wall and bottom thickness | |
| Recess = 5.0; // inset to capture cage edge | |
| Plate = [Cage.x,Cage.y,Recess] + [2*WallThick,2*WallThick,WallThick]; | |
| PlateRad = 5.0; | |
| SkiPole = [20.0,20.0 + 2*WallThick,50]; | |
| AnglePlate = [30,30,50]; | |
| ScrewClear = 5.0; | |
| BuildGap = 5.0; | |
| //———————- | |
| // 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); | |
| } | |
| //———————- | |
| // Pieces | |
| module Cap() { | |
| union() { | |
| difference() { | |
| hull() | |
| for (i=[-1,1], j=[-1,1]) | |
| translate([i*(Plate.x/2 – PlateRad),j*(Plate.y/2 – PlateRad),0]) | |
| cylinder(r=PlateRad,h=Plate.z,$fn=12); | |
| translate([0,0,Plate.z – Recess]) | |
| hull() | |
| for (i=[-1,1], j=[-1,1]) | |
| translate([i*(Cage.x/2 – CageRad),j*(Cage.y/2 – CageRad),0]) | |
| cylinder(r=CageRad,h=Plate.z,$fn=12); | |
| } | |
| difference() { | |
| Strut = Cage.x – 2*CageThick; | |
| Latch = [Cage.x,WallThick,0.75*Plate.z]; | |
| union() { | |
| for (j=[-1,1]) | |
| translate([0,j*2.5*Grid,Plate.z]) | |
| cube([Strut,WallThick,2*Plate.z],center=true); | |
| for (j=[-1,1]) | |
| translate([0,j*2.5*Grid,2*Plate.z – Latch.z/2]) | |
| cube(Latch,center=true); | |
| } | |
| translate([0,0,2*Plate.z + (Cage.z – Sheet.z)/4]) | |
| rotate([0,45,0]) | |
| cube([Strut/sqrt(2),Plate.y,Strut/sqrt(2)],center=true); | |
| } | |
| } | |
| } | |
| module Attachment() { | |
| if (Bracket == "Angle") { | |
| translate([0,Plate.y/2,0]) | |
| rotate(45) | |
| difference() { | |
| union() { | |
| cube(AnglePlate,center=false); | |
| rotate(-45) | |
| translate([0,WallThick,Plate.z/2]) | |
| cube([Plate.x – 2*PlateRad,4*WallThick,Plate.z],center=true); | |
| } | |
| translate([WallThick,WallThick,-Protrusion]) | |
| cube(AnglePlate + [0,0,2*Protrusion],center=false); | |
| translate([AnglePlate.x/2,-Protrusion,2*AnglePlate.z/3]) | |
| rotate([-90,0,0]) | |
| PolyCyl(ScrewClear,2*AnglePlate.x,6); | |
| translate([-Protrusion,AnglePlate.x/2,1*AnglePlate.z/3]) | |
| rotate([90,0,90]) | |
| PolyCyl(ScrewClear,2*AnglePlate.x,6); | |
| } | |
| } | |
| else if (Bracket == "Ski") { | |
| translate([0,Plate.y/2 + SkiPole[OD]/2,0]) | |
| difference() { | |
| union() { | |
| PolyCyl(SkiPole[OD],SkiPole[LENGTH],24); | |
| translate([0,-3*WallThick,Plate.z/2]) | |
| cube([Plate.x – 2*PlateRad,4*WallThick,Plate.z],center=true); | |
| } | |
| translate([0,0,-2*WallThick]) | |
| PolyCyl(SkiPole[ID],SkiPole[LENGTH],24); | |
| } | |
| } | |
| } | |
| //———————- | |
| // Build it | |
| if (Layout == "Cap") | |
| Cap(); | |
| if (Layout == "Attachment") { | |
| Attachment(); | |
| } | |
| if (Layout == "Show") { | |
| translate([0,0,Sheet.z/2 + Plate.z]) | |
| color("Yellow") | |
| cube(Sheet,center=true); | |
| Cap(); | |
| Attachment(); | |
| translate([0,0,Sheet.z + 2*Plate.z]) | |
| rotate([180,0,0]) | |
| Cap(); | |
| } | |
| if (Layout == "Build") { | |
| translate([-(Plate.x/2 + BuildGap),0,0]) { | |
| Cap(); | |
| Attachment(); | |
| } | |
| translate([(Plate.x/2 + BuildGap),0,0]) | |
| Cap(); | |
| } |
For what should be obvious reasons, we armored Mary’s “kitchen garden” with buried concrete blocks and deer fence. I secured the fence to 7 foot plastic-coated steel-core posts strapped to shorter stakes supporting the lower wire fence, using cable ties we both knew wouldn’t survive exposure to the sun.
As part of the spring garden prep, I summoned proper supports from the vasty digital deep:
The general idea is to plunk one atop each post and tangle wrap the netting through the hooks, thusly:
The garden looks like we killed an entire chess set and impaled their carcasses as a warning to others of their kind, but the fence now hangs neatly from the top of the posts rather than drooping sadly.
Each one of those things takes nigh onto two hours to emerge from the M2, so I printed them one by one over the course of a few days while making continuous product improvements.
The “natural” PETG isn’t UV stabilized, either, but it ought to last longer than those little bitty nylon cable ties. We shall see.
The OpenSCAD source code as a GitHub Gist:
| // Deer Fence Hangers | |
| // Ed Nisley KE4ZNU May 2021 | |
| Layout = "Show"; // [Build, Show, Cap, Hook] | |
| // net grid spacing | |
| NetOC = 55.0; // [40.0:5.0:70.0] | |
| // stake OD | |
| PoleDia = 23.0; // [20.0:30.0] | |
| //- 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; | |
| ID = 0; | |
| OD = 1; | |
| LENGTH = 2; | |
| function IntegerMultiple(Size,Unit) = Unit * ceil(Size / Unit); | |
| //———————- | |
| // Dimensions | |
| Notch = 5.0; // hook engagement | |
| WallThick = 3.0; // min wall and end thickness | |
| Shell = [PoleDia,PoleDia + 2*WallThick,NetOC + 2*Notch]; | |
| HookBlock = [10.0,Shell.y/4,2*Notch]; // hanger inside length | |
| LegendBlock = [0.7*Shell.z,Shell.y/2,2*ThreadThick]; // legend size | |
| //———————- | |
| // 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); | |
| } | |
| //———————- | |
| // Pieces | |
| module Hook() { | |
| //%Cap(); | |
| translate([Shell[OD]/2 – Protrusion,HookBlock.y/2,0]) | |
| rotate([90,0,0]) | |
| linear_extrude(height=HookBlock.y) | |
| difference() { | |
| scale([1,2]) | |
| intersection() { | |
| circle(r=HookBlock.x); | |
| square(HookBlock.x,center=false); | |
| } | |
| square(Notch,center=false); | |
| } | |
| } | |
| module Cap() { | |
| difference() { | |
| rotate(180/6) | |
| PolyCyl(Shell[OD],Shell[LENGTH],6); | |
| translate([0,0,-WallThick]) | |
| rotate(180/24) | |
| PolyCyl(Shell[ID],Shell[LENGTH],24); | |
| translate([-Shell[OD]/2,0,Shell[LENGTH]/2]) | |
| rotate([0,90,0]) | |
| cube(LegendBlock,center=true); | |
| } | |
| translate([-(Shell[OD]/2 – LegendBlock.z/2),0,Shell[LENGTH]/2]) | |
| rotate([0,-90,0]) | |
| resize(0.8*LegendBlock,auto=[true,true,false]) | |
| linear_extrude(height=LegendBlock.z) | |
| text(text=str(NetOC," ",PoleDia), | |
| size=6,spacing=1.00,font="Bitstream Vera Sans:style=Bold", | |
| halign="center",valign="center"); | |
| } | |
| module Hanger() { | |
| Cap(); | |
| for (k=[0,1]) | |
| translate([0,0,k*Shell.z]) | |
| for (a=[-1:1]) | |
| rotate([k*180,0,a*60]) | |
| Hook(); | |
| } | |
| //———————- | |
| // Build it | |
| if (Layout == "Cap") | |
| Cap(); | |
| if (Layout == "Hook") | |
| Hook(); | |
| if (Layout == "Show") | |
| Hanger(); | |
| if (Layout == "Build") | |
| translate([0,0,Shell[LENGTH]]) | |
| rotate([180,0,0]) | |
| Hanger(); |
I used the long-handled bypass lopper to harvest the 3D printed soaker hose splices and clamps, which made the sad state of the lopper’s bumper painfully obvious:
Contrary to what you might think, those rivets never had a head on this side and the bumper seems to be held in place by an interference fit with the plastic handle cover.
A bit of cutoff wheel work removed the crimped end on the 5 mm stud holding the bumper to the pot-metal dingus:
Whacking it with a punch separated all the parts:
The gray thing is a silicone rubber vibration isolator that’s a bit too large in all dimensions, but surely Close Enough™ for present purposes.
A length of 5 mm shaft became the new stud, with M3×0.5 threads tapped into both ends and a pair of random screws held in place with red Loctite:
There are no pix of the drilling and threading, as it was accomplished after a shiny-new 2.7 mm “titanium” metric drill from a not-dirt-cheap set shattered in the shaft:
The blue color on the flutes is Sharpie to remind me it’s defunct. I completed the mission using a #36 drill with no further excitement.
The dingus is now held to the lopper with JB Weld and, should that fail, I’ll drill-n-tap the rivets and be done with it.
The Smell of Molten Projects in the Morning 