Ed Nisley's Blog: Shop notes, electronics, firmware, machinery, 3D printing, laser cuttery, and curiosities. Contents: 100% human thinking, 0% AI slop.
Back in 2006, I clamped a Hobo temperature sensor onto the pipe that delivers town water from the main, under 150 feet of front yard, and into our basement:
Town Water Inlet – temperature sensor mounting
Wrapping a chunk of closed-cell foam insulation around it made me feel better, but probably doesn’t affect the results very much at all:
Town Water Inlet – temperature sensor insulation
I assume the temperature of the pipe at that location will match the water temperature pretty closely, at least while some water flows into the house, and the water temperature will match the ground temperature four feet under the front yard.
Under those assumptions, the bottom trace shows the pipe temperature and the top trace shows the air temperature on the shelf a few feet above the pipe:
Town Water Inlet
The gap in early 2011 documents an embarrassing bit of forgetfulness. All in all, you’re looking at about 750,000 logged records; if you observe something long enough, it turns into science.
Cleaning up the date and time columns in the data files required a few hours of heads-down sed experimentation:
Convert quoted headers to comments → s/^\"/#&/
Convert non-data records to comments → s/^.*Logged/#&/
Convert two-digit years to four-digit years and enforce trailing blank → s_/\([01][0-9]\)[ ,]_/20\1 _
Enforce blank after four-digit years → s_/\(20[0-9]\{2\}\),_/\1 _
Remove blank after time-of-day value → s_\(:[0-9]\{2\}\) _\1_
Being reminded that sed will accept (nearly) any delimiter character came in handy!
The temperature spikes happen when I bring the Hobo datalogger upstairs to read it out. The plotting routine discards the junk readings caused by unplugging the remote sensor; anything below 30 °F or above 100 °F counts as spurious. The gnuplot idiom uses the ternary operator with the Not-a-Number value:
plot "filename" using 2:((\$3 > 30) && (\$3 < 100) ? \$3 : NaN) with ...</code>
The backslashes escape gnuplot’s variable markers, which would otherwise get eaten by Bash.
The Bash / gnuplot script that produces the plot:
#!/bin/sh
#-- overhead
export GDFONTPATH="/usr/share/fonts/truetype/"
base="${1%.*}"
echo Base name: ${base}
tfile1=$(tempfile)
ofile=${base}.png
echo Input file: $1
echo Temporary files: ${tfile1}
echo Output file: ${ofile}
#-- prepare csv Hobo logger file
sed 's/^\"/#&/ ; s/^.*Logged/#&/ ; s_/\([01][0-9]\)[ ,]_/20\1 _ ; s_/\(20[0-9]\{2\}\),_/\1 _ ; s_\(:[0-9]\{2\}\) _\1_' "$1" > ${tfile1}
#-- do it
gnuplot << EOF
set term png font "arialbd.ttf" 18 size 950,600
set output "${ofile}"
set title "${base}"
set key noautotitles
unset mouse
set grid xtics ytics
set timefmt "%m/%d/%Y %H:%M:%S"
set xdata time
#set xlabel "Week of Year"
set format x "%Y"
set ylabel "Temperature - F"
set yrange [30:90]
set datafile separator ","
plot \
"${tfile1}" using 2:((\$3 > 30) && (\$3 < 100) ? \$3 : NaN) with lines lt 3 title "Air", \
"${tfile1}" using 2:((\$5 > 30) && (\$5 < 100) ? \$5 : NaN) with lines lt 4 title "Water"
EOF
No snagging on a bulky quilt shoved through the machine
Not completely butt-ugly
Reasonably durable
I picked up reels of cool-white and warm-white waterproof LED strips (12 V, 3528-size chips, 5 m, 600 LED, 25 mm segments) from the usual eBay supplier, who promptly charged for both and shipped only the warm-white reel. Cool-white LEDs will be a better color match to daylight from the window and the little Ottlite she uses for detail work, but I ran some prototypes while we wait for the replacement.
The Chinese New Year really comes in handy as an excuse for screwing things up and not responding for a week or two. ‘Nuff said.
They’re similar to the RGB LEDs from a while ago, with even gummier “waterproof” encapsulation. I got double-density 600 LED strips to put more light emitters across the arm:
Various LED strip lights
The smaller 3528 SMD LEDs (vs. 5050 chips in the others) allow a narrower strip and the double-density layout means each three-LED segment is half as long long. The as-measured dimensions work out to:
25.0 mm segment length
8.2 mm strip width
2.5 mm thickness
The sealant thickness varies considerably, so I’d allow 3.0 mm for that in case it mattered. It slobbers over the edge of the strip here and there; allowing at least 9.0 mm would be wise.
The SMD resistor in each segment is 150 Ω. A 5 segment length drew 85 mA @ 12 V = 17 mA/segment. Boosting the voltage to 12.8 V got the current to the expected 100 mA = 20 mA/segment.
The LEDs are noticeably less bright than the 5050 LEDs, even at 20 mA/segment, but I think they’ll suffice for the task.
This chart, shamelessly ripped from the Interwebs because the links keep rotting out, may prove useful in the future:
Desiccant absorption vs humidity
In round numbers: between 10% and 40%RH, silica gel equilibrates at 1.8%RH for each percent of weight gain. If you toss 100 g of dry silica gel into a container with some filament, when it weighs 120 g (20% weight gain) the air inside the container will be at about 36%RH.
Come to find out that Makerbot changed the spacing between the Y-axis rod and the idler bolt, so it doesn’t fit the TOM286. I could fire up the Token Windows Box, install Sketchup, modify the model, rebuild and clean up the STL, and try again, but it’s easier to just give up. The TOM286 has worked fine so far, so maybe this isn’t really needed.
What with all the snow this winter, I noticed that the muffler on the snowblower was rattling around something awful; eventually, the blue fire jetting directly from the engine block got to be distracting. Come to find out the bracket attached to the top of the block had ripped free from the muffler:
The two long bolts on the right explain why this particular anomaly didn’t get an immediate repair: they were firmly jammed, deep in the block, and resisted my gentle attempts to free them. For obvious reasons, you (well, I) don’t want to break off the end of a bolt in its tapped hole…
Snowblower muffler – failed bracket
So, over the course of a few weeks, I applied a dose of PB B’laster to the bolts, down deep behind the muffler where they entered the block, and gingerly wiggled the bolts back-and-forth to their ever-increasing limits of travel. Doing that every time I went into the garage guaranteed plenty of excess oil to smoke off the engine during the first few minutes, but ya gotta do what ya gotta do. Two days before the next big storm, the block finally released the bolts. Whew!
Evidently, having the bracket tear loose wasn’t a rare failure and, perhaps, the situation attracted the attention of someone in accounting who pointed out the warranty repair costs (no, our blower wasn’t in warranty), because the new muffler has a different bracket:
Snowblower muffler – new bracket design
Look at all those spot welds across that huge contact patch!
Yes, I used new bolts with a generous dollop of Never-Seez on each one…
A reversible belt lets me look perfectly natty, regardless of whether I’m wearing my brown pants or my khaki pants. The post joining the buckle and the base worked loose, so the spring wasn’t holding the two parts together; obviously, something must be done.
Loosen the four screws that hold the leather belt in place to reveal what’s inside:
Reversible belt buckle – spring post
Then push the two parts together and give the post a few shots with a sharp punch:
Cleaning up the wrecked gears on the can opener made it painfully obvious that I had to conjure at least one gear to get the poor thing working again:
Can opener – gears and cutters
Fortunately, those are more in the line of cogs, rather than real gears, so I decided a crude hack would suffice: drill a pattern of holes to define the openings between the teeth, file / grind the teeth reasonably smooth, and then tweak the shape to suit.
Fitting some small number-size drills between the remains of the teeth showed:
A #52 = 52.0 mil = 1.32 mm drill matched the root curvature
A #28 = 140.5 mil = 3.57 mm drill was tangent to the small drill and the tooth walls
Neither of those count as precision measurements, particularly given the ruined teeth, but they’re close enough for a first pass.
The OEM drive gear (on the right) has the teeth bent upward to mate with the cutter gear (on the left), but under normal gripping force, the teeth don’t mesh securely and tend to slide over / under / past each other. However, if I were to cut the drive gear from a metal sheet that’s thick enough to engage both the root and the crest of the cutter gear, that should prevent all the slipping & sliding. Some eyeballometric guesstimation suggested 2.5 mm would be about right and the Basement Laboratory Stockpile produced a small slab of 100 mil = 2.54 mm aluminum sheet.
However, the center part of the gear must have the same thickness as the OEM gear to keep the drive wheel at the same position relative to the cutter blade, which means a bit of pocket milling. I have some small ball burrs that seemed like they might come in handy.
A recent thread on the LinuxCNC mailing list announced Bertho Stultien’s gcmc, the G-Code Meta Compiler, and this looked like a golden opportunity to try it out. Basically, gcmc lets you write G-Code programs in a C-like language that eliminates nearly all the horrendous syntactic noise of raw G-Code. I like it a lot and you’ll be seeing more of it around here…
The gcmc source code, down below, include a function that handles automatic tool height probing, using that simple white-goods switch. The literal() function emits whatever you hand it as text for the G-Code file, which is how you mechanize esoteric commands that gcmc doesn’t include in its repertoire. It’s basically the same as my bare G-Code probe routine, but now maintains a state variable that eliminates the need for separate first-probe and subsequent-probe entry points.
One point that tripped me up, even though I should know better: because gcmc is a compiler, it can’t read G-Code parameters that exist only when LinuxCNC (or whatever) is interpreting the G-Code. You can write parameters with values computed at compile time, but you can’t read and process them in the gcmc program.
Anyhow, the first pass produced an array of holes that, as I fully expected, weren’t quite right:
Can opener gear – first hole pattern
The second pass got the root and middle holes tangent to each other:
Can opener gear – second hole pattern
It also ran a center drill pass for those tiny little holes to prevent their drill from wandering about. The other drills are about the same size as the center drill, so they’re on their own.
The rosette around the central hole comes from sweeping the burr in a dozen overlapping circles tangent to the outer diameter, then making a cleanup pass around the OD:
Can opener gear – 12 leaf rosette
Incidentally, that stray hole between the two patterns came from the aluminum sheet’s previous life, whatever it may have been. There are three other holes, two of which had flat washers taped to them, so your guess is as good as mine. That’s my story and I’m sticking with it.
Introducing the sheet to Mr Bandsaw and cutting through the outer ring produced a bizarre snowflake:
Can opener gear – cut out
Cutting off the outer ring of holes turned the incipient gear body into a ragged shuriken:
Can opener gear – isolated
A few minutes of increasingly deft Dremel cutoff wheel work, poised on the bench vise over the shopvac nozzle to capture the dust, produced a credible gear shape:
Can opener gear – first pass
Iterating through some trial fits, re-grinds, and general fiddling showed that the center pocket was too shallow. The cutter wheel should slightly clear the drive wheel, but it’s an interference fit:
Can opener gear – trial fit
Which, of course, meant that I had to clamp the [mumble] thing back in the Sherline and re-mill the pocket. The trick is to impale it on the wrong end of a suitable drill, clamp it down, and touch off that spot as the origin:
Can opener gear – re-centering
I took the opportunity to switch to a smaller ball and make 16 little circles to clear the pocket:
Can Opener Gear – 16 leaf rosette
Now that’s better:
Can opener gear – deeper pocket
Another trial fit showed that everything ended up in the right place:
Can opener gear – final fit
I gave it a few cranks, touched up any cogs that clashed with the (still misshapen) cutter gear, applied it to a randomly chosen can, and it worked perfectly:
Squeeze the levers to easily punch through the lid
Crankety crank on the handle, while experiencing none of the previous drama
The severed lid falls into the can
Which is exactly how it’s supposed to work. What’s so hard about that?
What you can’t see in that picture is the crest of the lowest cutter gear tooth fitting just above the bottom of the drive gear root. Similarly, the crest of the highest drive gear tooth remains slightly above the cutter root. That means the cutter gear teeth always engage the drive gear, there’s no slipping & sliding, and it’s all good.
Aluminum isn’t the right material for a gear-like object meshed with a steel counterpart, but it’s easy to machine on a Sherline. I’ll run off a few more for show-n-tell and, if when this one fails, I’ll have backup.
The gcmc source code:
// Can opener drive gears
// Ed Nisley KE4ZNU - February 2014
// Sherline CNC mill with tool height probe
// XYZ touchoff origin at center on fixture surface
DO_DRILLCENTER = 1;
DO_MILLCENTER = 1;
DO_DRILLINNER = 1;
DO_DRILLOUTER = 1;
DO_DRILLTIPS = 1;
//----------
// Overall dimensions
GearThick = 2.54; // overall gear thickness
GearCenterThick = 1.75; // thickness of gear center
GearTeeth = 12; // number of teeth!
ToothAngle = 360deg/GearTeeth;
GearOD = 22.0; // tooth tip
GearID = 13.25; // tooth root
SafeZ = 20.0; // guaranteed to clear clamps
TravelZ = GearThick + 1.0; // guaranteed to clear plate
//----------
// Tool height probe
// Sets G43.1 tool offset in G-Code, so our Z=0 coordinate always indicates the touchoff position
ProbeInit = 0; // 0 = not initialized, 1 = initialized
ProbeSpeed = 400.0mm;
ProbeRetract = 1.0mm;
PROBE_STAY = 0; // remain at probe station
PROBE_RESTORE = 1; // return to previous location after probe
function ProbeTool(RestorePos) {
local WhereWasI;
WhereWasI = position();
if (ProbeInit == 0) { // probe with existing tool to set Z=0 as touched off
ProbeInit++;
literal("#<_Probe_Speed> = ",to_none(ProbeSpeed),"\n");
literal("#<_Probe_Retract> = ",to_none(ProbeRetract),"\n");
literal("#<_ToolRefZ> = 0.0 \t; prepare for first probe\n");
ProbeTool(PROBE_STAY);
literal("#<_ToolRefZ> = #5063 \t; save touchoff probe point\n");
literal("G43.1 Z0.0 \t; set zero offset = initial touchoff\n");
}
elif (ProbeInit == 1) { // probe with new tool, adjust offset accordingly
literal("G49 \t; clear tool length comp\n");
literal("G30 \t; move over probe switch\n");
literal("G59.3 \t; use coord system 9\n");
literal("G38.2 Z0 F#<_Probe_Speed> \t; trip switch on the way down\n");
literal("G0 Z[#5063 + #<_Probe_Retract>] \t; back off the switch\n");
literal("G38.2 Z0 F[#<_Probe_Speed> / 10] \t; trip switch slowly\n");
literal("#<_ToolZ> = #5063 \t; save new tool length\n");
literal("G43.1 Z[#<_ToolZ> - #<_ToolRefZ>] \t; set new length\n");
literal("G54 \t; return to coord system 0\n");
literal("G30 \t; return to safe level\n");
}
else {
error("*** ProbeTool sees invalid ProbeInit: ",ProbeInit);
comment("debug,*** ProbeTool sees invalid ProbeInit: ",ProbeInit);
ProbeInit = 0;
}
if (RestorePos == PROBE_RESTORE) {
goto(WhereWasI);
}
}
//----------
// Utility functions
function WaitForContinue(MsgStr) {
comment(MsgStr);
pause();
}
function CueToolChange(MsgStr) {
literal("G0 Z" + SafeZ + "\n");
literal("G30\n");
WaitForContinue(MsgStr);
}
function ToolChange(Info,Name) {
CueToolChange("msg,Insert " + to_mm(Info[TOOL_DIA]) + " = " + to_in(Info[TOOL_DIA]) + " " + Name);
ProbeTool(PROBE_STAY);
WaitForContinue("msg,Set spindle to " + Info[TOOL_SPEED] + " rpm");
feedrate(Info[TOOL_FEED]);
}
function GetAir() {
goto([-,-,SafeZ]);
}
//-- compute drill speeds & feeds based on diameter
// rule of thumb is 100 x diameter at 3000 rpm for real milling machines
// my little Sherline's Z axis can't produce enough thrust for that!
MaxZFeed = 600.0mm; // fastest possible Z feed
TOOL_DIA = 0; // Indexes into DrillParam() result
TOOL_SPEED = 1; // spindle RPM
TOOL_FEED = 2; // linear feed
TOOL_TIP = 3; // length of 118 degreee drill tip
function DrillParam(Dia) {
local RPM,Feed,Tip,Data,Derating;
Derating = 0.25; // derate from (100 x diameter) max feed
RPM = 3000.0; // default 3 k rpm
Feed = Derating * (100.0 * Dia);
if (Feed > MaxZFeed) {
RPM *= (MaxZFeed / Feed); // scale speed downward to fit
Feed = MaxZFeed;
}
Tip = (Dia/2) * tan(90deg - 118deg/2);
Data = [Dia,RPM,Feed,Tip];
message("DrillParam: ",Data);
return Data;
}
//-- peck drilling cycle
function PeckDrill(Endpt,Retract,Peck) {
literal("G83 X",to_none(Endpt[0])," Y",to_none(Endpt[1])," Z",to_none(Endpt[2]),
" R",to_none(Retract)," Q",to_none(Peck),"\n");
}
//----------
// Make it happen
literal("G99\t; retract to R level, not previous Z\n");
WaitForContinue("msg,Verify: G30 position in G54 above tool change switch?");
WaitForContinue("msg,Verify: fixture origin XY touched off at center of gear?");
WaitForContinue("msg,Verify: Z touched off on top surface at " + GearThick + "?");
ProbeTool(PROBE_STAY);
//-- Drill center hole
if (DO_DRILLCENTER) {
DrillData = DrillParam(5.0mm);
ToolChange(DrillData,"drill");
goto([0,0,-]);
goto([-,-,TravelZ]);
drill([0,0,-1.5*DrillData[TOOL_TIP]],TravelZ,DrillData[TOOL_DIA]);
GetAir();
}
//-- Drill inner ring
if (DO_DRILLINNER) {
DrillData = DrillParam(1.32mm);
RingRadius = GearID/2.0 + DrillData[TOOL_DIA]/2.0; // center of inner ring holes
HolePosition = [RingRadius,0mm,-1.5*DrillData[TOOL_TIP]];
// but first, center-drill to prevent drifting
CDData = DrillParam(1.00mm); // pretend it's a little drill
CDData[TOOL_FEED] = 100mm; // ... use faster feed
CDPosition = HolePosition; // use center drill coordinates
CDPosition[2] = GearThick - 0.25mm; // ... just below surface
ToolChange(CDData,"center drill");
goto([0,0,-]);
goto([-,-,TravelZ]);
for (Tooth = 0 ; Tooth < GearTeeth ; Tooth++) {
drill(CDPosition,TravelZ,2*TravelZ); // large increment ensures one stroke
CDPosition = rotate_xy(CDPosition,ToothAngle);
}
// now drill the holes
ToolChange(DrillData,"drill");
goto([0,0,-]);
goto([-,-,TravelZ]);
for (Tooth = 0 ; Tooth < GearTeeth ; Tooth++) {
PeckDrill(HolePosition,TravelZ,DrillData[TOOL_DIA]);
HolePosition = rotate_xy(HolePosition,ToothAngle);
}
GetAir();
}
//-- Mill center recess
if (DO_MILLCENTER) {
MillData = [4.50mm,3000,250.0mm,0.0mm]; // spherical ball burr
Delta = GearThick - GearCenterThick; // depth to be milled away
Inset = sqrt(2.0*Delta*(MillData[TOOL_DIA]/2) - pow(Delta,2)); // toll axis to milled edge
ToolChange(MillData,"ball burr");
goto([0,0,-]); // above central hole
goto([0,0,GearThick]); // vertically down to flush with surface
move([0,0,GearCenterThick]); // into gear blank
for (Angle = 0.0deg; Angle < 360.0deg; Angle+=360.0deg/16) { // clear interior
circle_cw((GearID/2 - Inset)/2,Angle);
}
move_r([(GearID/2 - Inset),0.0,0.0]); // clean rim
circle_ccw([0.0,0.0,GearCenterThick],2);
GetAir();
}
//-- Drill outer ring
if (DO_DRILLOUTER) {
RingRadius += DrillData[TOOL_DIA]/2; // at OD of inner ring holes
DrillData = DrillParam(3.18mm);
RingRadius += DrillData[TOOL_DIA]/2.0; // center of outer ring holes
HolePosition = [RingRadius,0mm,-1.5*DrillData[TOOL_TIP]];
ToolChange(DrillData,"drill");
for (Tooth = 0 ; Tooth < GearTeeth ; Tooth++) {
PeckDrill(HolePosition,TravelZ,DrillData[TOOL_DIA]);
HolePosition = rotate_xy(HolePosition,ToothAngle);
}
GetAir();
}
//-- Drill to locate gear tooth tip end
if (DO_DRILLTIPS) {
DrillData = DrillParam(4.22mm);
RingRadius = GearOD/2.0 + DrillData[TOOL_DIA]/2.0; // tangent to gear tooth tip
HolePosition = [RingRadius,0mm,-1.5*DrillData[TOOL_TIP]];
HolePosition = rotate_xy(HolePosition,ToothAngle/2); // align to tooth
ToolChange(DrillData,"drill");
for (Tooth = 0 ; Tooth < GearTeeth ; Tooth++) {
PeckDrill(HolePosition,TravelZ,DrillData[TOOL_DIA]);
HolePosition = rotate_xy(HolePosition,ToothAngle);
}
GetAir();
}
literal("G30\n");
comment("msg,Done!");
The original doodle that suggested the possibility:
Can Opener Gears – Doodle 1
The chord equation at the bottom shows how to calculate the offset for the ball burr, although it turns out there’s no good way to measure the cutting diameter of the burr and it’s not really spherical anyway.
A more detailed doodle with the key line at a totally bogus angle:
Can Opener Gears – Doodle 2
The diagram in the lower right corner shows how you figure the length of the tip on a 118° drill point, which you add to the thickness of the plate in order to get a clean hole.
The Smell of Molten Projects in the Morning 