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.
Making the world a better place, one piece at a time
A bit of rummaging produced a desk lamp arm, minus whatever lamp it originally held, ready to hold the second photo lamp, after a bit of epoxy on one locking knob:
The flanged nut will seat on the wrecked part of the knob, with the epoxy holding it in place and somewhat reinforcing the perimeter. I’m not sure this will last forever, but it’ll be a start.
Printing a second cold shoe, though, worked perfectly, and everything fit:
I love it when a plan comes together!
Another attempt at replacing the Wyze camera firmware went much more smoothly, producing a pair of small cameras with better network manners:
That’s a VLC screen capture from the RTSP stream; obviously, I must up my clutter control game.
I formatted a 32 GB MicroSD card with a 512 MB partition, which may not be strictly necessary, copied the MicroSD CFW bootloader (as demo.bin, sheesh), and it installed without drama.
I resized the partition to 32 GB, installed the firmware (per the FAQ) into the root directory, tweaked the configuration files to match my situation, popped it in the camera, plugged the power cable, and It Just Worked™.
Herewith, a checklist of config directory files requiring tweakage:
wpa_supplicant – WiFi SSID and passwordtimezone.conf – America/New_York for usosd.conf – can be tweaked through the Web interfacestaticip.conf – 192.168.1.11x, as you likeresolve.conf – pihole or router IP, as neededdefaultgw.conf – router IPrtspserver.conf – different ports for additional camerasIt would be possible to have the pihole’s DHCP server assign a fixed IP address to each camera, based on its MAC address, but this way the camera knows who it is right from the start and what it’s supposed to be doing.
The router isn’t bright enough to route different port numbers on its Internet side to different LAN IP addresses with the same port address, so each camera must stream from a different port number. I don’t plan many world-available video streams, but a friend does enjoy watching the birds during feeder season.
With the RTSP stream up & running, I flashed the U-Boot bootloader (again, minus drama) and tweaked its uEnv.txt configuration file:
The cameras now produce no objectionable network activity, dramatically down from the Wyze firmware’s desperate attempts to contact various servers, every five minutes, around the clock. I have no way of tracking connections made with direct dotted-quad IP addresses, rather than through the pihole, but … this is a distinct improvement.
The cover for Mary’s favorite seam ripper cracked long ago, has been repaired several times, and now needs a replacement:
The first pass (at the top) matched the interior and exterior shapes, but was entirely too rigid. Unlike the Clover seam ripper, the handle has too much taper for a thick-walled piece of plastic.
The flexy thinwall cover on the ripper comes from a model of the interior shape:
It’s not conspicuously tapered, but OpenSCAD’s perspective view makes the taper hard to see. The wedge on top helps the slicer bridge the opening; it’s not perfect, just close enough to work.
A similar model of the outer surface is one thread width wider on all sides, so subtracting the handle model from the interior produces a single-thread shell with a wedge-shaped interior invisible in this Slic3r preview:
The brim around the bottom improves platform griptivity. The rounded top (because pretty) precludes building it upside-down, but if you could tolerate a square-ish top, that’s the way to go.
Both models consist of hulls around eight strategically placed spheres, with the wedge on the top of the handle due to the intersection of the hull and a suitable cube. This view shows the situation without the hull:
The spheres overlap, with the top set barely distinguishable, to produce the proper taper. I measured the handle and cover’s wall thicknesses, then guesstimated the cover’s interior dimensions from its outer size.
The handle’s spheres have a radius matching its curvature. The cover’s spheres have a radius exactly one thread width larger, so the difference produces the one-thread-wide shell.
Came out pretty nicely, if I do say so myself: the cover seats fully with an easy push-on fit and stays firmly in place. Best of all, should it get lost (despite the retina-burn orange PETG plastic), I can make another with nearly zero effort.
The Basement Laboratory remains winter-cool, so I taped a paper shield over the platform as insulation from the fan cooling the PETG:
The shield goes on after the nozzle finishes the first layer. The masking tape adhesive turned into loathesome goo and required acetone to get it off the platform; fortunately, the borosilicate glass didn’t mind.
The OpenSCAD source code as a GitHub Gist:
| // Cover for old seam ripper | |
| // Ed Nisley – KE4ZNU | |
| // 2019-03 | |
| /* [Layout Options] */ | |
| Layout = "Build"; // [Show,Build] | |
| Part = "Handle"; // [Handle,CoverSolid,Cover] | |
| /* [Extrusion Parameters] */ | |
| ThreadWidth = 0.40; | |
| ThreadThick = 0.25; | |
| HoleWindage = 0.2; | |
| Protrusion = 0.1; | |
| //—– | |
| // Dimensions | |
| /* [Dimensions] */ | |
| WallThick = 1*ThreadWidth; | |
| CapInsideLength = 48.0; | |
| CornerRadius = 2.0; // handle at base | |
| Base = [11.0,5.5,0.0]; // handle at base | |
| Tip = [8.2,3.7,CapInsideLength]; // inferred at tip | |
| HandleOC = [Base – 2*[CornerRadius,CornerRadius,0.0], | |
| Tip – 2*[CornerRadius,CornerRadius,CornerRadius/2] | |
| ]; | |
| NumSides = 2*3*4; | |
| //—– | |
| // Useful pieces | |
| // Handle is basically the interior of the cover | |
| module Handle() { | |
| intersection() { | |
| hull() | |
| for (i=[-1,1], j=[-1,1], k=[0,1]) | |
| translate([i*HandleOC[k].x/2,j*HandleOC[k].y/2,k*HandleOC[k].z]) | |
| sphere(r=CornerRadius,$fn=NumSides); | |
| translate([0,0,-CornerRadius/2]) // chop tip for better bridging | |
| rotate([45,0,0]) | |
| cube([2*Base.x,CapInsideLength*sqrt(2),CapInsideLength*sqrt(2)],center=true); | |
| } | |
| } | |
| module CoverSolid() { | |
| hull() | |
| for (i=[-1,1], j=[-1,1], k=[0,1]) | |
| translate([i*HandleOC[k].x/2,j*HandleOC[k].y/2,k*HandleOC[k].z]) | |
| sphere(r=CornerRadius + WallThick,$fn=NumSides); | |
| } | |
| module Cover() { | |
| difference() { | |
| CoverSolid(); | |
| Handle(); | |
| translate([0,0,-CornerRadius]) | |
| cube(2*Base + [0,0,2*CornerRadius],center=true); | |
| } | |
| } | |
| //—– | |
| // Build things | |
| if (Layout == "Build") { | |
| Cover(); | |
| } | |
| if (Layout == "Show") | |
| if (Part == "Handle") | |
| Handle(); | |
| else if (Part == "CoverSolid") | |
| CoverSolid(); | |
| else if (Part == "Cover") | |
| Cover(); | |
Somewhat to my surprise, Aneng AN8008/AN8009 multimeter PCBS sport what looks like a reasonably accurate current sense resistor on the 10 A input:
The legend says 0.01R and the conductor doesn’t look quite like pure copper:
The indentations look like clamp marks from the bending jig, rather than “calibration” notches made while squeezing the wire with diagonal cutters and watching the resistance on another meter.
One might quibble about the overall soldering quality, but one would also be splitting hairs. I doubt the meter leads could withstand 10 A for more than a few seconds, anyhow.
If you buy enough of something, you can buy pretty nearly anything you want, even cheap precision resistors!
Having recently acquired a pair of photo lights and desirous of eliminating some desktop clutter, I decided this ancient incandescent (!) magnifying desk lamp had outlived its usefulness:
The styrene plastic shell isn’t quite so yellowed in real life, but it’s close.
Stripping off the frippery reveals the tilt stem on the arm:
The photo lights have a tilt-pan mount intended for a camera’s cold (or hot) shoe, so I conjured an adapter from the vasty digital deep:
Printing with a brim improved platform griptivity:
Fortunately, the photo lights aren’t very heavy and shouldn’t apply too much stress to the layers across the joint between the stem and the cold shoe. Enlarging the stem perpendicular to the shoe probably didn’t make much difference, but it was easy enough.
Of course, you (well, I) always forget a detail in the first solid model, so I had to mill recesses around the screw hole to clear the centering bosses in the metal arm plates:
Which let it fit perfectly into the arm:
The grody threads on the upper surface around the end of the slot came from poor bridging across a hexagon, so the new version has a simple and tity flat end. The slot is mostly invisible with the tilt-pan adapter in place, anyway.
There being no need for a quick-disconnect fitting, a 1/4-20 button head screw locks the adapter in place:
I stripped the line cord from inside the arm struts and zip-tied the photo lamp’s wall wart cable to the outside:
And then It Just Works™:
The lens and its retaining clips now live in the Big Box o’ Optical parts, where it may come in handy some day.
The OpenSCAD source code as a GitHub Gist:
| // Photo light mount for desk lamp arm | |
| // Ed Nisley – KE4ZNU | |
| // 2019-03 | |
| /* [Layout Options] */ | |
| Layout = "Build"; // [Show,Build] | |
| Part = "Mount"; // [LampArm,ShoeSocket,Mount] | |
| /* [Extrusion Parameters] */ | |
| ThreadWidth = 0.40; | |
| ThreadThick = 0.25; | |
| HoleWindage = 0.2; | |
| Protrusion = 0.1; | |
| //—– | |
| // Dimensions | |
| /* [Hidden] */ | |
| ID = 0; | |
| OD = 1; | |
| LENGTH = 2; | |
| /* [Dimensions] */ | |
| FrictionDisk = [4.0,16.5,11.0]; // squashed inside desk lamp arm frame | |
| Divots = [4.0,9.5,0.75]; // recesses for frame alignment bumps | |
| ArmLength = 30.0; // attached to disk | |
| ShoeWheelOD = 32.0; // lock wheel on photo lamp | |
| ShoeBase = [18.5,18.5,2.0] + [HoleWindage,HoleWindage,2*ThreadWidth]; // square base on photo lamp gimbal | |
| ShoeStem = [6.3,12.0,1.5]; // top slide clearance, ID = 1/4 inch screw | |
| ShoeBlock = [ShoeWheelOD,ShoeWheelOD,2*(ShoeBase.z + ShoeStem.z)]; // overall shoe block | |
| NumSides = 3*4; | |
| //—– | |
| // Useful routines | |
| function IntegerMultiple(Size,Unit) = Unit * ceil(Size / Unit); | |
| module PolyCyl(Dia,Height,ForceSides=0,Center=false) { // 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,center=Center); | |
| } | |
| //—– | |
| // Various Parts | |
| // Arm captured in disk lamp | |
| module LampArm() { | |
| difference() { | |
| union() { | |
| cylinder(d=FrictionDisk[OD],h=FrictionDisk[LENGTH],$fn=NumSides,center=true); | |
| hull() | |
| for (j=[-1,1]) | |
| translate([0,j*(FrictionDisk[OD]/2 – FrictionDisk[LENGTH]/2),0]) { | |
| rotate([0,90,0]) rotate(180/NumSides) | |
| cylinder(d=FrictionDisk[LENGTH]/cos(180/NumSides),h=ArmLength/2,$fn=NumSides); | |
| translate([ArmLength – FrictionDisk[LENGTH]/2,0,0]) | |
| sphere(d=FrictionDisk[LENGTH],$fn=NumSides); | |
| } | |
| } | |
| rotate(180/6) { | |
| PolyCyl(FrictionDisk[ID],FrictionDisk[LENGTH] + 2*Protrusion,6,Center=true); | |
| for (k=[-1,1]) | |
| translate([0,0,k*(FrictionDisk[LENGTH]/2 – Divots[LENGTH]/2)]) | |
| PolyCyl(Divots[OD],Divots[LENGTH] + Protrusion,6,Center=true); | |
| } | |
| } | |
| } | |
| // Basic hot shoe socket | |
| module ShoeSocket() { | |
| difference() { | |
| union() { | |
| cube(ShoeBlock,center=true); // overall blocky retainer | |
| translate([-ShoeBlock.x/2,0,0]) | |
| cylinder(d=ShoeBlock.x,h=ShoeBlock.z,$fn=NumSides,center=true); | |
| } | |
| translate([0,0,-2*ShoeBlock.z]) // screw hole throughout | |
| rotate(180/6) | |
| PolyCyl(ShoeStem[ID],4*ShoeBlock.z,6); | |
| translate([0,0,ShoeBase.z/2]) // base slot under pillar | |
| cube([ShoeBase.x,ShoeBase.y,ShoeBase.z],center=true); | |
| translate([ShoeBase.x/2,0,ShoeBase.z/2]) // base slot opening | |
| cube([ShoeBase.x,ShoeBase.y,ShoeBase.z],center=true); | |
| translate([ShoeStem[OD]/2,0,ShoeBase.z/2 + ShoeStem[LENGTH]]) // stem slot | |
| cube([2*ShoeStem[OD],ShoeStem[OD],2*ShoeStem[LENGTH]],center=true); | |
| } | |
| } | |
| // Stick parts together | |
| module Mount() { | |
| rotate([90,0,0]) | |
| LampArm(); | |
| translate([ArmLength + ShoeBlock.x/2 – Protrusion,0,0]) | |
| ShoeSocket(); | |
| } | |
| //—– | |
| // Build things | |
| if (Layout == "Build") { | |
| rotate([0,90,0]) | |
| translate([-(ArmLength + ShoeBlock.x),0,0]) | |
| Mount(); | |
| } | |
| if (Layout == "Show") | |
| if (Part == "LampArm") | |
| LampArm(); | |
| else if (Part == "ShoeSocket") | |
| ShoeSocket(); | |
| else if (Part == "Mount") | |
| Mount(); |
The original dimension doodles, made before I removed the stem and discovered the recesses around the screw hole:
This table must sit across the threshold of a walk-in / sit-down shower, with the shower curtain draped across the table to keep the water inside.
Starting with another patio side table, as before, I installed a quartet of 5 mm stainless screws to lock the top panels in place and convert the table into a rigid assembly:
Because the shower floor is slightly higher than the bathroom floor, I conjured a set of foot pads to raise the outside legs:
The sloping top surface on the pads compensates for the angle on the end of the table legs:
I think the leg mold produces legs for several different tables, with the end angle being Close Enough™ for most purposes. Most likely, it’d wear flat in a matter of days on an actual patio.
Using good 3M outdoor-rated foam tape should eliminate the need for fiddly screw holes and more hardware:
The feet fit reasonably well:
They may need nonskid tape on those flat bottoms, but that’s in the nature of fine tuning.
And, as with the narrow table, it may need foam blocks to raise the top surface to arm level. Perhaps a pair of Yoga Blocks will come in handy for large adjustments.
The OpenSCAD source code as a GitHub Gist:
| // Patio Side Table Feet | |
| // Ed Nisley – KE4ZNU | |
| // 2019-03 | |
| /* [Layout Options] */ | |
| Layout = "Build"; // [Show,Build] | |
| /* [Extrusion Parameters] */ | |
| ThreadWidth = 0.40; | |
| ThreadThick = 0.25; | |
| HoleWindage = 0.2; | |
| Protrusion = 0.1; | |
| //—– | |
| // Dimensions | |
| TapeThick = 1.0; // 3M double-stick outdoor tape | |
| LegWall = [2.5,3.5]; // leg walls are not the same in X and Y! | |
| LegBase = [36.0,19.0]; // flat on floor | |
| LegOuter = [31.0,19.0]; // perpendicular to leg axis | |
| LegInner = [28.5,11.5]; // … ditto | |
| LegAngle = 90 – 53; // vertical to leg | |
| LegRecess = [LegInner.x,LegInner.y,LegInner.x*tan(LegAngle)]; | |
| PadWedge = 2; // to fit end of leg | |
| PadRadius = 4.0; // rounding radius for nice corners | |
| PadBase = [LegBase.x + 2*PadRadius,LegBase.y + 2*PadRadius,5.0]; | |
| PadSides = 6*4; | |
| BathStep = 20; // offset between shower bottom and floor | |
| /* [Hidden] */ | |
| EmbossDepth = 1*ThreadThick; // recess depth | |
| DebossHeight = 1*ThreadThick + Protrusion; // text height + Protrusion into part | |
| //—– | |
| // Useful routines | |
| 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); | |
| } | |
| //—– | |
| // Foot pad | |
| module FootPad(Riser = 0.0) { | |
| difference() { | |
| union() { | |
| hull() | |
| for (i=[-1,1], j=[-1,1]) { | |
| translate([i*(PadBase.x/2 – PadRadius),j*(PadBase.y/2 – PadRadius),0]) | |
| cylinder(r=PadRadius,h=1,$fn=PadSides); | |
| translate([i*(PadBase.x/2 – PadRadius), | |
| j*(PadBase.y/2 – PadRadius), | |
| Riser + PadBase.z – PadRadius – (i-1)*PadWedge/2]) | |
| sphere(r=PadRadius/cos(180/PadSides),$fn=PadSides); | |
| } | |
| translate([PadRadius – PadBase.x/2,0,Riser + PadBase.z]) | |
| rotate([0,LegAngle,0]) | |
| translate([LegRecess.x/2,0,(LegRecess.z – Protrusion)/2 ]) | |
| cube(LegRecess – [2*TapeThick,0,2*TapeThick],center=true); | |
| } | |
| translate([0,0,-2*PadBase.z]) // remove anything under Z=0 | |
| cube(4*PadBase,center=true); | |
| cube([17,12,2*DebossHeight],center=true); | |
| } | |
| mirror([1,0,0]) | |
| linear_extrude(height=EmbossDepth) | |
| translate([0,0,0]) | |
| text(text=str(Riser),size=10,spacing=1.05, | |
| font="Arial:style=Bold", | |
| valign="center",halign="center"); | |
| } | |
| //—– | |
| // Build things | |
| if (Layout == "Build") { | |
| if (true) { | |
| translate([-0.7*PadBase.x,-0.7*PadBase.y,0]) | |
| FootPad(0); | |
| translate([-0.7*PadBase.x,+0.7*PadBase.y,0]) | |
| FootPad(0); | |
| } | |
| translate([+0.7*PadBase.x,-0.7*PadBase.y,0]) | |
| FootPad(BathStep); | |
| translate([+0.7*PadBase.x,+0.7*PadBase.y,0]) | |
| FootPad(BathStep); | |
| } | |
| if (Layout == "Show") | |
| FootPad(); |
For reasons not relevant here, I recently conjured a pair of tables to support an injured arm (ours are OK!) in the bathroom: one table fitting in the narrow space adjacent to a toilet and the other across the threshold of a walk-in / sit-down shower.
The raw material came from a plastic side table intended for outdoor use:
That’s the Patriotic Blue version, which seemed the least offensive of the colors on offer at the local store.
The plastic pieces unsnap easily enough:
The legs also come apart by pulling outward at the crossover points. You may need to clean the flashing from all the joints, as they’re only as finished as absolutely necessary.
A table about half the width seemed about right, so I sawed the two top plates off their struts, then angled the strut ends to match the new leg angle:
Because it’s now completely floppy, I drilled holes for 5 mm screws through the struts:
In the process, I discovered stainless steel nyloc nuts tend to gall on stainless steel screws:
I lost a pair of screws + nuts before I got a clue and began adding a drop of machine oil to each screw before tightening the nuts. Haven’t had that problem with the 3 mm SS screws, so there’s always something new to learn.
With all the screws in place, the half-table becomes a rigid contraption:
The top looks like it’s suffering from severe barrel distortion, but it really started out looking that way:
The slat sides are all curved, except the far edge that was once in the middle of the table and now fits against the wall.
It may be slightly too short, but we can stack foam slabs on the top, probably held in place with cable ties.
Memo to Self: lube all the stainless steel screws!
The Smell of Molten Projects in the Morning 