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
This being repotting season, Mary trimmed a pair of leaves from a bay tree and wanted to dry them for cooking, so I offered to lend a hand:
Two hands, in fact.
The whole affair now sits on a kitchen windowsill, shriveling by the day, and the leaves should be ready in a month or two. Yum!
Just for completeness, here’s what the various soaker hose clamps look like in the garden, as solid models only let you visualize the ideal situation:
This one prevents a puddle in the path to the right:
Bending the hoses around the end of a bed puts them on edge, with this clamp suppressing a shin-soaking spray to the left:
The clamp at the connector closes a leak around the crimped brass fitting, with the other two preventing gouges from direct sprays into the path along the bottom of the picture:
All in all, a definite UI improvement!
As far as I can tell, we have the only soaker hose repairs & spritz stoppers in existence. Hooray for 3D printing!
The robin nestlings fledged fourteen days after we spotted the first eggshell on the driveway below the nest. The first one may have flown away the previous evening, leaving three increasingly restless siblings behind:
They’re recognizably robins now, covered in young-bird speckle camouflage.
Feeding continued apace:
After feeding, robin nestlings produce fecal sacs, which the parents either eat or carry away:
Robins aren’t big on facial expressions, but, speaking from personal experience, anything to do with diapers isn’t the high point of a parent’s day.
And then there were none:
The gazillion black dots on the soffit are pinpoint-sized insects / mites / ticks infesting the nest and, presumably, the birds. The earlier pictures don’t show them, so perhaps these missed the last bird off the nest and are now regretting their life choices.
Go, birds, … gone!
All four nestlings emerged on schedule:
The oldest nestling was ready for feeding almost immediately, even with unopened eyes:
As any infant will tell you, holding your head up is hard work:
But doing only half the job won’t get you fed:
They’re just starting to make little chirps, so this isn’t nearly as raucous as you might think:
The adults seem to have no trouble bringing an endless stream of worms, insects, and unidentifiable organisms from the yard and garden.
Go, birds, go!
Having figured out the geometry for two- and three-channel soaker hoses, I cranked out more clamps:
Actually, those are the remainder of two production runs devoted to reducing the amount of water sprinkling the garden paths. A 50 foot hose runs along both sides of one 14 foot bed, crosses the path, then continues along the adjacent bed. The hoses have (deliberate!) sprinkler holes along their porous rubber body and sometimes the layout puts a hole where it waters the path.
The blue silicone rubber strips provide a bit of sealing to prevent the absurdly high pressure water from streaming through the orange PETG clamps. It’s OK if the clamp leaks, but less flow is better!
I’m getting really good at making those aluminum backing plates and, in fact, I think it’s faster to run the blanks past the disk sander, then drill the holes, than to CNC-machine them. Could be wrong, but Quality Shop Time is not to be sniffed at.
After five gardening seasons, my simple 3D printed wrench broke:
Although Jason’s comment suggesting carbon-fiber reinforcing rods didn’t prompt me to lay in a stock, ordinary music wire should serve the same purpose:
The pins are 1.6 mm diameter and 20 mm long, chopped off with hardened diagonal cutters. Next time, I must (remember to) grind the ends flat.
The solid model needs holes in appropriate spots:
Yes, I’m going to put round pins in square holes, without drilling the holes to the proper diameter: no epoxy, no adhesive, just 20 mm of pure friction.
The drill press aligns the pins:
And rams them about halfway down:
Close the chuck jaws and shove them flush with the surface:
You can see the pins and their solid plastic shells through the wrench stem:
Early testing shows the reinforced wrench works just as well as the previous version, even on some new valves sporting different handles, with an equally sloppy fit for all. No surprise: I just poked holes in the existing model and left all the other dimensions alone.
The OpenSCAD source code as a GitHub Gist:
| // Hose connector knob | |
| // Ed Nisley KE4ZNU – June 2015 | |
| // 2020-05 add reinforcing rods | |
| Layout = "Build"; // [Knob, Stem, Show, Build] | |
| RodHoles = true; | |
| //- Extrusion parameters – must match reality! | |
| /* [Hidden] */ | |
| ThreadThick = 0.25; | |
| ThreadWidth = 0.40; | |
| function IntegerMultiple(Size,Unit) = Unit * ceil(Size / Unit); | |
| Protrusion = 0.1; | |
| HoleWindage = 0.2; | |
| //—— | |
| // Dimensions | |
| /* [Dimensions] */ | |
| RodOD = 1.6; | |
| RodAngle = 35; | |
| /* [Hidden] */ | |
| StemOD = 30.0; // max OD for valve-to-valve clearance | |
| BossOD = 16.0; // single-ended handle boss | |
| SlotWidth = 13.0; | |
| SlotHeight = 10.0; | |
| StemInset = 10.0; | |
| StemLength = StemInset + SlotHeight + 25.0; | |
| StemSides = 2*4; | |
| Align = 0*180/StemSides; // 1* produces thinner jaw ends | |
| KnobOD1 = 70; // maximum dia without chamfer | |
| KnobOD2 = 60; // top dia | |
| KnobSides = 4*4; | |
| DomeHeight = 12; // dome shape above lobes | |
| KnobHeight = DomeHeight + 2*SlotHeight; | |
| DomeOD = KnobOD2 + (KnobOD1 – KnobOD2)*(DomeHeight/KnobHeight); | |
| DomeArcRad = (pow(KnobHeight,2) + pow(DomeOD,2)/4) / (2*DomeHeight); | |
| RodBCD = (StemOD + BossOD)/2; | |
| //- Adjust hole diameter to make the size come out right | |
| module PolyCyl(Dia,Height,ForceSides=0) { // based on nophead's polyholes | |
| Sides = (ForceSides != 0) ? ForceSides : (ceil(Dia) + 2); | |
| FixDia = Dia / cos(180/Sides); | |
| cylinder(r=(FixDia + HoleWindage)/2,h=Height,$fn=Sides); | |
| } | |
| //– Stem for valve handles | |
| module Stem() { | |
| difference() { | |
| rotate(Align) | |
| cylinder(d=StemOD,h=StemLength,$fn=StemSides); | |
| translate([0,0,SlotHeight/2 – Protrusion/2]) | |
| cube([2*StemOD,SlotWidth,(SlotHeight + Protrusion)],center=true); | |
| translate([0,0,-Protrusion]) | |
| cylinder(d=BossOD,h=SlotHeight,$fn=2*StemSides); | |
| if (RodHoles) | |
| for (i=[-1:1]) | |
| rotate(i*RodAngle + 90) | |
| for (j=[-1,1]) | |
| translate([j*RodBCD/2,0,-Protrusion]) | |
| rotate(180/4) | |
| PolyCyl(RodOD,2*SlotHeight,4); | |
| } | |
| } | |
| //– Hand-friendly knob | |
| module KnobCap() { | |
| difference() { | |
| scale([1.0,0.75,1.0]) | |
| rotate(180/KnobSides) | |
| intersection() { | |
| translate([0,0,(KnobHeight-DomeArcRad)]) | |
| sphere(r=DomeArcRad,$fa=180/KnobSides); | |
| cylinder(r1=KnobOD1/2,r2=KnobOD2/2,h=KnobHeight,$fn=KnobSides); | |
| cylinder(r1=KnobOD2/2,r2=KnobOD1/2,h=KnobHeight,$fn=KnobSides); | |
| } | |
| translate([0,0,-Protrusion]) | |
| rotate(Align) | |
| cylinder(d=(StemOD + 2*ThreadWidth),h=(StemInset + Protrusion),$fn=StemSides); | |
| } | |
| } | |
| //- Build it | |
| if (Layout == "Knob") | |
| KnobCap(); | |
| if (Layout == "Stem") | |
| Stem(); | |
| if (Layout == "Build") { | |
| translate([-KnobOD1/2,0,0]) | |
| KnobCap(); | |
| translate([StemOD/2,0,StemLength]) | |
| rotate([180,0,0]) | |
| Stem(); | |
| } | |
| if (Layout == "Show") { | |
| translate([0,0,0]) | |
| Stem(); | |
| translate([0,0,StemLength – StemInset]) | |
| KnobCap(); | |
| } |
One of the soaker hoses in Mary’s Vassar Farms garden split lengthwise near one end:
Although the hose is fully depreciated, I thought it’d be worthwhile to cut off the damaged end and conjure an end cap to see if a simple plug can withstand 100 psi water pressure.
A pair of Delrin (because I have it) plugs with serrations fill the hose channels, with the outer clamp squishing the hose against them:
In real life, they’ll be pushed completely into the hose, with a generous layer of silicone snot caulk improving their griptivity.
I started with 8 mm plugs, but they didn’t quite fill the channels:
Going to 8.5 mm worked better, although there’s really no way to force the granulated rubber shape into a snug fit around a cylinder:
Fortunately, they need not be leakproof, because leaking is what the hose does for a living. Well, did for a living, back before it died.
The clamps have a solid endstop, although it’s more to tidy the end than to hold the plugs in place:
The clamps need aluminum backing plates to distribute the stress evenly across their flat sides:
Those are 8-32 stainless steel screws. The standard 1 inch length worked out exactly right through no fault of my own.
The OpenSCAD source code as a GitHub Gist:
| // Rubber Soaker Hose End Plug | |
| // Ed Nisley KE4ZNU June 2019 | |
| // 2020-05 Two-channel hose end plug | |
| Layout = "Hose"; // [Hose,Block,Show,Build] | |
| //- Extrusion parameters must match reality! | |
| /* [Hidden] */ | |
| ThreadThick = 0.25; | |
| ThreadWidth = 0.40; | |
| HoleWindage = 0.2; | |
| Protrusion = 0.1; // make holes end cleanly | |
| inch = 25.4; | |
| function IntegerMultiple(Size,Unit) = Unit * ceil(Size / Unit); | |
| //———- | |
| // Dimensions | |
| // Hose lies along X axis | |
| HoseTubeOD = 12.0; // water tube diameter | |
| HoseTubeOC = 12.5; // .. spacing | |
| HoseWebThick = 7.8; // center joining tubes | |
| Hose = [100,25.0,HoseTubeOD]; // X=very long, Y=overall width, Z=thickness | |
| HoseSides = 12*4; | |
| PlugLength = 25.0; // plugs in hose channels | |
| PlateThick = 5.0; // end block thickness | |
| WallThick = 2.0; // overall minimum thickness | |
| Kerf = 0.75; // cut through middle to apply compression | |
| ID = 0; | |
| OD = 1; | |
| LENGTH = 2; | |
| // 8-32 stainless screws | |
| Screw = [4.1,8.0,3.0]; // OD = head LENGTH = head thickness | |
| Washer = [4.4,9.5,1.0]; | |
| Nut = [4.1,9.7,6.0]; | |
| CornerRadius = Washer[OD]/2; | |
| ScrewOC = Hose.y + Washer[OD]; | |
| echo(str("Screw OC: ",ScrewOC)); | |
| BlockOAL = [PlugLength + PlateThick,ScrewOC + Washer[OD],2*WallThick + Hose.z]; // overall splice block size | |
| echo(str("Block: ",BlockOAL)); | |
| //———————- | |
| // 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 | |
| module HoseProfile() { | |
| rotate([0,-90,0]) | |
| translate([0,0,-Hose.x/2]) | |
| linear_extrude(height=Hose.x,convexity=4) | |
| union() { | |
| for (j=[-1,1]) // outer channels | |
| translate([0,j*HoseTubeOC/2]) | |
| circle(d=HoseTubeOD,$fn=HoseSides); | |
| translate([0,0]) | |
| square([HoseWebThick,HoseTubeOC],center=true); | |
| } | |
| } | |
| // 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*(BlockOAL.x/2 – CornerRadius),j*(BlockOAL.y/2 – CornerRadius),-BlockOAL.z/2]) | |
| cylinder(r=CornerRadius,h=BlockOAL.z,$fn=4*8); | |
| for (j=[-1,1]) // screw holes | |
| translate([0, | |
| j*ScrewOC/2, | |
| -(BlockOAL.z/2 + Protrusion)]) | |
| PolyCyl(Screw[ID],BlockOAL.z + 2*Protrusion,6); | |
| cube([2*BlockOAL.x,2*BlockOAL.y,Kerf],center=true); // slice through center | |
| } | |
| } | |
| // Splice block less hose | |
| module ShapedBlock() { | |
| difference() { | |
| SpliceBlock(); | |
| translate([(-Hose.x/2) + (BlockOAL.x/2) – PlateThick,0,0]) | |
| HoseProfile(); | |
| } | |
| } | |
| //———- | |
| // Build them | |
| if (Layout == "Hose") | |
| HoseProfile(); | |
| if (Layout == "Block") | |
| SpliceBlock(); | |
| if (Layout == "Show") { | |
| ShapedBlock(); | |
| translate([(-Hose.x/2) + (BlockOAL.x/2) – PlateThick,0,0]) | |
| color("Green",0.25) | |
| HoseProfile(); | |
| } | |
| if (Layout == "Build") { | |
| SliceOffset = 0; | |
| intersection() { | |
| translate([SliceOffset,0,BlockOAL.z/4]) | |
| cube([4*BlockOAL.x,4*BlockOAL.y,BlockOAL.z/2],center=true); | |
| union() { | |
| translate([0,0.6*BlockOAL.y,BlockOAL.z/2]) | |
| ShapedBlock(); | |
| translate([0,-0.6*BlockOAL.y,BlockOAL.z/2]) | |
| rotate([0,180,0]) | |
| ShapedBlock(); | |
| } | |
| } | |
| } |
The original doodle, with dimensions vaguely related to the final model:
There is, as far as I can tell, no standardization of dimensions or shapes across manufacturers, apart from the threaded hose fittings.
The Smell of Molten Projects in the Morning 