Quilting Hexagon Template Generator: Knobless Half-Triangle

Although I’d put the same knob on the half-triangle end piece template as on the equilateral triangle template for piecing hexagons into strips, Mary decided a flat chip would be easier to use:

Quilting Hex Template - family - knobless half-triangle
Quilting Hex Template – family – knobless half-triangle

Bonus: you can now flip it over to cut the other half-triangles, if you haven’t already figured out how to cut two layers of fabric folded wrong sides together.

While I was at it, the knob on the triangle became optional, too. Flipping that one doesn’t buy you much, though.

The OpenSCAD source as a GitHub Gist has been ever so slightly tweaked:

// Quilting - Hexagon Templates
// Ed Nisley KE4ZNU - July 2020
// Reverse-engineered to repair a not-quite-standard hexagon quilt
// Useful geometry:
// https://en.wikipedia.org/wiki/Hexagon
/* [Layout Options] */
Layout = "Build"; // [Build, HexBuild, HexPlate, TriBuild, TriPlate, EndBuild, EndPlate]
//-------
//- Extrusion parameters must match reality!
// Print with 2 shells
/* [Hidden] */
ThreadThick = 0.25;
ThreadWidth = 0.40;
HoleFinagle = 0.2;
HoleFudge = 1.00;
function HoleAdjust(Diameter) = HoleFudge*Diameter + HoleFinagle;
Protrusion = 0.1; // make holes end cleanly
function IntegerMultiple(Size,Unit) = Unit * ceil(Size / Unit);
inch = 25.4;
//-------
// Dimensions
/* [Layout Options] */
FinishedWidthInch = 2.75;
FinishedWidth = FinishedWidthInch * inch;
SeamAllowanceInch = 0.25;
SeamAllowance = SeamAllowanceInch * inch;
TemplateThick = 3.0;
TriKnob = true;
EndKnob = false;
/* [Hidden] */
FinishedSideInch = FinishedWidthInch/sqrt(3);
FinishedSide = FinishedSideInch * inch;
echo(str("Finished side: ",FinishedSideInch," inch"));
CutWidth = FinishedWidth + 2*SeamAllowance;
CutSide = CutWidth/sqrt(3);
echo(str("Cut side: ",CutSide / inch," inch"));
// Make polygon-circles circumscribe the target widths
TemplateID = FinishedWidth / cos(180/6);
TemplateOD = CutWidth / cos(180/6);
/* [Hidden] */
TriRadius = FinishedSide/sqrt(3);
TriPoints = [[TriRadius,0],
[TriRadius*cos(120),TriRadius*sin(120)],
[TriRadius*cos(240),TriRadius*sin(240)]
];
echo(str("TriPoints: ",TriPoints));
EndPoints = [[TriRadius,0],
[TriRadius*cos(120),TriRadius*sin(120)],
[TriRadius*cos(120),0]
];
echo(str("EndPoints: ",EndPoints));
TipCutRadius = 2*(TriRadius + SeamAllowance); // circumscribing radius of tip cutter
TipPoints = [[TipCutRadius,0],
[TipCutRadius*cos(120),TipCutRadius*sin(120)],
[TipCutRadius*cos(240),TipCutRadius*sin(240)]
];
HandleHeight = 1 * inch;
HandleLength = (TemplateID + TemplateOD)/2;
HandleThick = IntegerMultiple(3.0,ThreadWidth);
HandleSides = 12*4;
StringDia = 4.0;
StringHeight = 0.6*HandleHeight;
DentDepth = HandleThick/4;
DentDia = 15 * DentDepth;
DentSphereRadius = (pow(DentDepth,2) + pow(DentDia,2)/4)/(2*DentDepth);
KnobOD = 15.0; // Triangle handle
KnobHeight = 20.0;
//-------
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=HoleAdjust(FixDia)/2,h=Height,$fn=Sides);
}
//-------
// Hex template
module HexPlate() {
difference() {
cylinder(r=TemplateOD/2,h=TemplateThick,$fn=6);
translate([0,0,-Protrusion])
cylinder(r=TemplateID/2,h=(TemplateThick + 2*Protrusion),$fn=6);
}
for (i=[1:6/2])
rotate(i*60)
translate([0,0,TemplateThick/2])
cube([HandleLength,HandleThick,TemplateThick],center=true);
}
module HexHandle() {
difference() {
rotate([90,0,0])
scale([1,HandleHeight/(TemplateOD/2),1])
rotate(180/HandleSides)
cylinder(d=HandleLength,h=HandleThick,center=true,$fn=HandleSides);
translate([0,0,-HandleHeight])
cube([2*TemplateOD,2*TemplateOD,2*HandleHeight],center=true);
translate([0,HandleThick,StringHeight])
rotate([90,090,0])
rotate(180/8)
PolyCyl(StringDia,2*HandleThick,8);
for (j=[-1,1]) {
translate([0,j*(DentSphereRadius + HandleThick/2 - DentDepth),StringHeight])
rotate(180/48)
sphere(r=DentSphereRadius,$fn=48);
}
}
}
module HexTemplate() {
HexPlate();
HexHandle();
}
//-------
// Triangle template
module TriPlate() {
linear_extrude(height=TemplateThick)
intersection() {
offset(delta=SeamAllowance) // basic cutting outline
polygon(points=TriPoints);
rotate(180)
polygon(points=TipPoints);
}
}
module TriTemplate() {
union() {
if (TriKnob)
cylinder(d=KnobOD,h=KnobHeight,$fn=HandleSides);
TriPlate();
}
}
//-------
// End piece template
module EndPlate() {
linear_extrude(height=TemplateThick)
intersection() {
offset(delta=SeamAllowance) // basic cutting outline
polygon(points=EndPoints);
rotate(180)
polygon(points=TipPoints);
}
}
module EndTemplate() {
union() {
if (EndKnob)
translate([0,(TriRadius/2)*sin(30),0])
cylinder(d=KnobOD,h=KnobHeight,$fn=HandleSides);
EndPlate();
}
}
//-------
// Build it!
if (Layout == "HexPlate")
HexPlate();
if (Layout == "HexBuild")
HexTemplate();
if (Layout == "TriPlate")
TriPlate();
if (Layout == "TriBuild")
TriTemplate();
if (Layout == "EndPlate")
EndPlate();
if (Layout == "EndBuild")
EndTemplate();
if (Layout == "Build") {
translate([1.5*TriRadius,-TriRadius,0])
rotate(180/6)
TriTemplate();
translate([-1.5*TriRadius,-TriRadius,0])
rotate(180/6)
EndTemplate();
translate([0,TemplateOD/2,0])
HexTemplate();
}

Quilting Hexagon Template Generator

Mary took on the task of finishing a hexagonal quilt from pieced strips, only to discover she’ll need several more strips and the myriad triangles required to turn hexagons into strips. The as-built strips do not match any of the standard pattern sizes, which meant ordinary templates were unavailing. I offered to build a template matching the (average) as-built hexagons, plus a triangle template based on those dimensions.

Wikipedia has useful summaries of hexagon and equilateral triangle geometry and equations.

Quilters measure hexes based on their finished side length, so a “1 inch hex” has sides measuring 1 inch, with the seam allowance extending ¼ inch beyond the sides. It’s difficult to measure finished sides with sufficient accuracy, so we averaged the side-to-side distance across several hexes.

Some thrashing around produced a quick-and-dirty check piece that matched (most of) the stack of un-sewn hexes:

Quilting Hexagon Cutting Template
Quilting Hexagon Cutting Template

That one came from a knockoff of the circle template, after some cleanup & tweakage, but failed user testing for not withstanding the side force from the rotary cutter blade. The inside and outside dimensions were correct, however, so I could proceed with some confidence I understood the geometry.

Both the pattern width (the side-to-side distance across the inside of the hex) and the seam allowance appearing in the Customizer appear in inches, because that’s how things get measured outside the Basement Laboratory & Fabrication Facility:

FinishedWidthInch = 2.75;
FinishedWidth = FinishedWidthInch * inch;

SeamAllowanceInch = 0.25;
SeamAllowance = SeamAllowanceInch * inch;

You feed in one side-to-side measurement and all other hex dimensions get calculated from that number; quilters default to a ¼ inch seam allowance. Remember, standard quilt hexes are measured by their side length, so just buy some standard templates.

This is one of the few times I’ve needed triangle graph paper:

Hex Quilting Template - geometry doodles
Hex Quilting Template – geometry doodles

After I gave up trying to get it right on square-grid paper, of course.

Solidifying those relations:

Quilting Hex Template - build layout
Quilting Hex Template – build layout

Then math got real:

Hex Quilting Templates - on strips
Hex Quilting Templates – on strips

Both templates have non-skid strips to keep the fabric in place while cutting:

Hex Quilting Template - grip strips
Hex Quilting Template – grip strips

I should have embossed the size on each template, but this feels like a one-off project and YAGNI. Of course, that’s how I felt about the circle templates, so maybe next time I’ll get it right.

As it turned out, Mary realized she needed a template for the two half-triangles at the end of each row:

Quilting Hex Template - half-triangle
Quilting Hex Template – half-triangle

It’s half of the finished size of the equilateral triangle on the right, with seam allowance added all around. The test scrap of fabric on the left shows the stitching along the hypotenuse of the half-triangle, where it joins to the end-of-row hexagon. Ideally, you need two half-triangle templates, but Mary says it’s easier to cut the fabric from the back side than to keep track of two templates.

The family portrait now has three members:

Quilting Hex Template - family
Quilting Hex Template – family

The OpenSCAD source code as a GitHub Gist:

// Quilting - Hexagon Templates
// Ed Nisley KE4ZNU - July 2020
// Reverse-engineered to repair a not-quite-standard hexagon quilt
// Useful geometry:
// https://en.wikipedia.org/wiki/Hexagon
/* [Layout Options] */
Layout = "Build"; // [Build, HexBuild, HexPlate, TriBuild, TriPlate, EndBuild, EndPlate]
//-------
//- Extrusion parameters must match reality!
// Print with 2 shells
/* [Hidden] */
ThreadThick = 0.25;
ThreadWidth = 0.40;
HoleFinagle = 0.2;
HoleFudge = 1.00;
function HoleAdjust(Diameter) = HoleFudge*Diameter + HoleFinagle;
Protrusion = 0.1; // make holes end cleanly
function IntegerMultiple(Size,Unit) = Unit * ceil(Size / Unit);
inch = 25.4;
//-------
// Dimensions
/* [Layout Options] */
FinishedWidthInch = 2.75;
FinishedWidth = FinishedWidthInch * inch;
SeamAllowanceInch = 0.25;
SeamAllowance = SeamAllowanceInch * inch;
TemplateThick = 3.0;
TriKnob = true;
EndKnob = false;
/* [Hidden] */
FinishedSideInch = FinishedWidthInch/sqrt(3);
FinishedSide = FinishedSideInch * inch;
echo(str("Finished side: ",FinishedSideInch," inch"));
CutWidth = FinishedWidth + 2*SeamAllowance;
CutSide = CutWidth/sqrt(3);
echo(str("Cut side: ",CutSide / inch," inch"));
// Make polygon-circles circumscribe the target widths
TemplateID = FinishedWidth / cos(180/6);
TemplateOD = CutWidth / cos(180/6);
/* [Hidden] */
TriRadius = FinishedSide/sqrt(3);
TriPoints = [[TriRadius,0],
[TriRadius*cos(120),TriRadius*sin(120)],
[TriRadius*cos(240),TriRadius*sin(240)]
];
echo(str("TriPoints: ",TriPoints));
EndPoints = [[TriRadius,0],
[TriRadius*cos(120),TriRadius*sin(120)],
[TriRadius*cos(120),0]
];
echo(str("EndPoints: ",EndPoints));
TipCutRadius = 2*(TriRadius + SeamAllowance); // circumscribing radius of tip cutter
TipPoints = [[TipCutRadius,0],
[TipCutRadius*cos(120),TipCutRadius*sin(120)],
[TipCutRadius*cos(240),TipCutRadius*sin(240)]
];
HandleHeight = 1 * inch;
HandleLength = (TemplateID + TemplateOD)/2;
HandleThick = IntegerMultiple(3.0,ThreadWidth);
HandleSides = 12*4;
StringDia = 4.0;
StringHeight = 0.6*HandleHeight;
DentDepth = HandleThick/4;
DentDia = 15 * DentDepth;
DentSphereRadius = (pow(DentDepth,2) + pow(DentDia,2)/4)/(2*DentDepth);
KnobOD = 15.0; // Triangle handle
KnobHeight = 20.0;
//-------
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=HoleAdjust(FixDia)/2,h=Height,$fn=Sides);
}
//-------
// Hex template
module HexPlate() {
difference() {
cylinder(r=TemplateOD/2,h=TemplateThick,$fn=6);
translate([0,0,-Protrusion])
cylinder(r=TemplateID/2,h=(TemplateThick + 2*Protrusion),$fn=6);
}
for (i=[1:6/2])
rotate(i*60)
translate([0,0,TemplateThick/2])
cube([HandleLength,HandleThick,TemplateThick],center=true);
}
module HexHandle() {
difference() {
rotate([90,0,0])
scale([1,HandleHeight/(TemplateOD/2),1])
rotate(180/HandleSides)
cylinder(d=HandleLength,h=HandleThick,center=true,$fn=HandleSides);
translate([0,0,-HandleHeight])
cube([2*TemplateOD,2*TemplateOD,2*HandleHeight],center=true);
translate([0,HandleThick,StringHeight])
rotate([90,090,0])
rotate(180/8)
PolyCyl(StringDia,2*HandleThick,8);
for (j=[-1,1]) {
translate([0,j*(DentSphereRadius + HandleThick/2 - DentDepth),StringHeight])
rotate(180/48)
sphere(r=DentSphereRadius,$fn=48);
}
}
}
module HexTemplate() {
HexPlate();
HexHandle();
}
//-------
// Triangle template
module TriPlate() {
linear_extrude(height=TemplateThick)
intersection() {
offset(delta=SeamAllowance) // basic cutting outline
polygon(points=TriPoints);
rotate(180)
polygon(points=TipPoints);
}
}
module TriTemplate() {
union() {
if (TriKnob)
cylinder(d=KnobOD,h=KnobHeight,$fn=HandleSides);
TriPlate();
}
}
//-------
// End piece template
module EndPlate() {
linear_extrude(height=TemplateThick)
intersection() {
offset(delta=SeamAllowance) // basic cutting outline
polygon(points=EndPoints);
rotate(180)
polygon(points=TipPoints);
}
}
module EndTemplate() {
union() {
if (EndKnob)
translate([0,(TriRadius/2)*sin(30),0])
cylinder(d=KnobOD,h=KnobHeight,$fn=HandleSides);
EndPlate();
}
}
//-------
// Build it!
if (Layout == "HexPlate")
HexPlate();
if (Layout == "HexBuild")
HexTemplate();
if (Layout == "TriPlate")
TriPlate();
if (Layout == "TriBuild")
TriTemplate();
if (Layout == "EndPlate")
EndPlate();
if (Layout == "EndBuild")
EndTemplate();
if (Layout == "Build") {
translate([1.5*TriRadius,-TriRadius,0])
rotate(180/6)
TriTemplate();
translate([-1.5*TriRadius,-TriRadius,0])
rotate(180/6)
EndTemplate();
translate([0,TemplateOD/2,0])
HexTemplate();
}

Kenmore 158 Sewing Machine: More Deglaring

My first pass at deglaring the shiny metal parts on Mary’s brightly lit Kenmore 158 used translucent mailing labels on the “hand hole cover” in front of the needle:

Kenmore 158 - non-glare cover plate
Kenmore 158 – non-glare cover plate

That worked surprisingly well for surprisingly long, but the edges eventually came loose and, after far too long, I deployed the Tiny Sandblaster™:

Kenmore 158 - matte cover plate - feet
Kenmore 158 – matte cover plate – feet

The mottled matte effect isn’t quite what I expected, but it’s better-looking in person and we deemed it Good Enough™ for the purpose.

You saw the foot on the left in the previous effort:

Kenmore 158 - matte cover plate - feet - detail
Kenmore 158 – matte cover plate – feet – detail

The rounded plate directly under the needle sits far enough back to not reflect any of the LEDs toward her normal operating position, so we decided it didn’t need sandblasting.

She now has plenty of light where she needs it, with no glare from the metal bits.

HON Lateral File Cabinets: Rekeying

You’d hope the original owner would tape a key inside each file cabinet before donating it to charity; ours arrived unlocked and without keys. Fortunately, eBay sellers have All The Keys and I ordered replacement keys for each cabinet.

One pair of new keys fit into their lock, but the shoulder didn’t seat properly and the key didn’t turn:

HON Lateral File - 125E key insertion
HON Lateral File – 125E key insertion

Compared with a key for the other cabinet (on the bottom), it seems the tip profile wasn’t quite the same:

HON Lateral File - 125E key tip
HON Lateral File – 125E key tip

Perhaps the underside of the tip hadn’t been cut? Stacking the two keys makes it even more obvious:

Key 125E tip shaping - vs Key 101E
Key 125E tip shaping – vs Key 101E

The eBay seller suggested the lock cores have changed over the years, as other (unaltered) keys fit current cabinet locks. Perhaps HON used fussy high-quality lock cores back in 2004 when they built these cabinets.

I gingerly filed the 125E key’s tip to match the 101E key and, after several iterations, the shoulder seated firmly in the lock and the core turned smoothly. Flushed with success, I marked the other key of the pair, filed to the mark, and it worked on the first try.

Mary doesn’t plan to store any secret fabrics in her new cabinets, but now I can declare victory and move on.

HON Lateral File: Shelf Rebuild

After sliding the HON Lateral File Cabinet shelf into place and installing the bumpers, it seemed rather loose and floppy. Comparing the situation with the other file cabinet showed it had a missing glide button in the rear and two missing slides at the front.

A replacement button emerged from the end of a Delrin rod:

HON Lateral File - shelf button - parting off
HON Lateral File – shelf button – parting off

The original buttons had an expanding stem, which is easy to do with an injection-molded part. I opted for simple adhesive, with enough of a blob underneath the shelf to (presumably) lock it in place forevermore:

HON Lateral File - shelf button - installed
HON Lateral File – shelf button – installed

The slides required an iterative design technique (pronounced “fumbling around”), because nothing on either side remained square / plumb / true / unbent. I hacked the first version from scrap acrylic, broke off anything that didn’t fit, and got better measurements from what remained:

HON Lateral File - shelf front guide - size test
HON Lateral File – shelf front guide – size test

With those measurements in hand, the second version used a pair of weird flat-head shoulder screws (probably from a hard drive) to anchor 3D printed angle brackets into the frame:

HON Lateral File - shelf slides - version 2
HON Lateral File – shelf slides – version 2

Those worked reasonably well, but PETG doesn’t produce a nice sliding surface, so the final version has flat-head Delrin studs in slightly tweaked brackets:

HON Lateral File - shelf slides - version 3
HON Lateral File – shelf slides – version 3

As with the buttons in the back, the original slides had expanding studs holding them in place, but glue works fine here, too:

HON Lateral File - shelf slides - version 3 - installed
HON Lateral File – shelf slides – version 3 – installed

The button isn’t quite square to the surface and the slide isn’t quite flush with the bent metal in the frame, but it’s Good Enough™ for a shelf that won’t get lots of mileage.

For reference, the brackets should print vertically to wrap the plastic threads around the upright for better strength:

HON Lateral File Shelf Slide - Slic3r
HON Lateral File Shelf Slide – Slic3r

If you did it the obvious way, the upright side would break right off at the first insult from the hulking shelf, although they’re basically a solid chip of plastic, with a little infill inside the bottom slab.

While I was at it, I pulled the springs to make them a bit longer, so they touch the back of the frame when the shelf is half an inch behind the front face of the drawers. A firm push and those Delrin contact points let the shelf pop out an inch or so, with plenty of room for fingers underneath the front edge.

Some drawer slide stops near the back needed attention, too:

HON Lateral File - slide stop bumper - bent
HON Lateral File – slide stop bumper – bent

I cannot imagine how hard somebody slammed the drawers, because bending the stops back to a right angle required a Vise-Grip and some muttering:

HON Lateral File - slide stop bumper
HON Lateral File – slide stop bumper

Oddly, the cushiony hollow side faces away from the drawer, toward the back of the frame, because putting it forward holds the drawer front proud of the front frame face. Maybe HON cost-reduced the steel slides by making them just slightly shorter and using the same bumpers?

The drawers have begun filling up from boxes scattered around the house:

HON Lateral File - fabric stash
HON Lateral File – fabric stash

That’s the “orange” part of Mary’s collection, now with plenty of room to grow!

The OpenSCAD source code as a GitHub Gist:

// HON Lateral File Cabinet
// Shelf slides
// Ed Nisley KE4ZNU 2020-02-25
//- Extrusion parameters must match reality!
// Print with 3 shells and 3 solid layers
ThreadThick = 0.25;
ThreadWidth = 0.40;
HoleWindage = 0.2;
function IntegerMultiple(Size,Unit) = Unit * ceil(Size / Unit);
Protrusion = 0.1; // make holes end cleanly
inch = 25.4;
ID = 0;
OD = 1;
LENGTH = 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
SlideBlock = [18.0,25.0,12.0]; // across, along, height of left shelf bracket
SlideWalls = [1.0,-SlideBlock.y/2,2.0]; // wall thicknesses, dummy Y
HoleOffset = [8.4,7.0,0]; // hole center from left, front, dummy Z
HoleOD = 4.0;
Screw = [4.0,10,0.8]; // weird flat-head shoulder screw
ScrewRecess = Screw.z + 2*ThreadThick; // depth to keep head below slide surface
echo(str("Head base: ",SlideWalls.z - ScrewRecess));
$fn = 12*4;
//-------------------
// Single slide
module Slide() {
difference() {
cube(SlideBlock,center=false);
translate(SlideWalls)
cube(SlideBlock * 2,center=false);
translate(HoleOffset - [0,0,SlideBlock.z/2])
rotate(180/8)
PolyCyl(HoleOD,2*SlideBlock.z,8);
translate(HoleOffset + [0,0,SlideWalls.z] - [0,0,ScrewRecess])
rotate(180/12)
PolyCyl(Screw[OD],3*Screw[LENGTH],12);
}
}
//-------------------
// Build them
Gap = 5.0/2;
translate([0,-Gap,0])
rotate([90,0,0])
Slide();
translate([0,Gap,0])
rotate([-90,0,0])
mirror([0,1,0])
Slide();

HON Lateral File Cabinet Shelf Bumper Replacement

Somewhat to our surprise, our “new” HON Lateral File Cabinets include a pop-out shelf:

HON Lateral File - shelf - closed
HON Lateral File – shelf – closed

The trick: push the bar inward against fairly stiff spring pressure, release it suddenly, watch it pop out maybe half an inch, get some fingers under the front edge, then pull it outward:

HON Lateral File - shelf - extended
HON Lateral File – shelf – extended

Obviously, opening the drawer above the shelf will sweep whatever you put there onto the floor and opening the drawer below seems futile. I suppose it produced a bullet item on the features list.

Note that the topmost “drawer” is also called a “shelf”, because the front cover slides up-and-inward to reveal the contents. Should you stand eight feet tall, you might be able to look down on that shelf, but we mere mortals barely see its contents at eye level.

Dismantling the cabinets preparatory to deep cleaning revealed a pair of rubber bumpers along the rear edge of the shelf:

HON Lateral File - shelf bumper - installed
HON Lateral File – shelf bumper – installed

The slightly angled front side of the bumper (on the right) collides with a crossbar below the drawer just above it, preventing you from pulling the shelf entirely out of the cabinet.

Remove the bumper by pressing down and rearward (to the left), shoving the protruding lip into the slot with a thumb / screwdriver, then pull it upward through the slot:

HON Lateral File - shelf bumper - removed
HON Lateral File – shelf bumper – removed

The second cabinet had only one bumper, so I traced it twice onto a rubber sheet half as thick as the OEM bumper, bandsawed the shapes, and introduced them to Mr Belt Sander for cleanup:

HON Lateral File - replacement shelf bumper
HON Lateral File – replacement shelf bumper

Jammed side-by-side into the slot, they’ll serve the purpose:

HON Lateral File - replacement shelf bumper - installed
HON Lateral File – replacement shelf bumper – installed

As with the replacement foot on the first cabinet, they’re not the prettiest things you’ve ever seen, but Mary doesn’t expect to use the shelf and they’ll never actually bump into anything.

Even the Pixel phone’s HDR image processing has trouble dealing with dark gray objects on a black background in dim light …

HON Lateral File Cabinet Foot Repair

We bought the best-looking (pronounced “least bashed”) pair of hulking five-drawer industrial-strength HON Brigade Lateral File Cabinets from the local ReStore outlet’s assortment for Mary’s quilting fabric stash. They came with a steep discount, barely fit inside the Forester, caused minor interior trim damage, and should organize her entire stash.

One cabinet lost a foot nut at some point in its 16 year history:

HON Lateral File - foot hole - weld nugget filed
HON Lateral File – foot hole – weld nugget filed

The surviving foot nuts sported two weld nuggets apiece:

HON Lateral File - OEM front foot
HON Lateral File – OEM front foot

The hole had the remains of one nugget at the top left and looks like a manufacturing defect to me. Of course, we’re (at least) the second owners and the usual lifetime warranty no longer applies.

I can fix that.

Bandsaw a 1×¾ inch rectangle from 3/8 inch aluminum plate to match the surviving foot nut (which is steel, but aluminum will suffice for our needs). Break the edges, clamp in the Sherline, and mill a square protrusion to match the square-ish hole:

HON Lateral File - square nut - rough cut
HON Lateral File – square nut – rough cut

Drill a 17/64 inch hole (looser than the nominal F drill, because I’m a sissy) for a flat-head bolt from the Drawer o’ 3/8-16 Bolts, tap, and clean up.

A trial fit showed the nugget had to go before the nut would come even close to fitting flat into the hole:

HON Lateral File - foot hole - grinding
HON Lateral File – foot hole – grinding

The sheet metal around the hole had absorbed at least one mighty blow pushing the entire surface inward behind the front edge. To compensate, recess the nut’s front edge and slope the sides with a Dremel wheel to let the bottom face sit level:

HON Lateral File - square nut - taper grinding
HON Lateral File – square nut – taper grinding

Another trial fit showed the need for more recess:

HON Lateral File - square nut - deeper cut
HON Lateral File – square nut – deeper cut

Another spate of grinding made it sit mostly level on the decidedly non-level surface around the hole:

HON Lateral File - square nut - ready to install
HON Lateral File – square nut – ready to install

The beveled corners fit inside the swaged hole corners.

Grind paint / crud off the sheet metal and roughen the surface for good epoxy griptivity:

HON Lateral File - foot hole - ready for install
HON Lateral File – foot hole – ready for install

Stand the cabinet top-side-down to make the bottom level. I wish the basement had one more course of block, but it’s not to be.

Butter the nut with JB Weld epoxy, plunk it in place, apply excess epoxy to make a fillet around the edges, apply duct tape to guy the top of the bolt level-ish, and let it cure:

HON Lateral File - square nut - epoxy curing
HON Lateral File – square nut – epoxy curing

After the epoxy stiffened enough to hold its position, remove the bolt, file a crude ¼ inch hex, and saw a screwdriver slot to make it match the other feet:

HON Lateral File - new foot hex head
HON Lateral File – new foot hex head

Not the fanciest job I’ve ever done, but it now behaves just like the other ones and it’s all good. The HON Storage Files FAQ points to a Troubleshooting Guide showing how to level the thing with a hex socket from inside the bottom drawer.

The flat heads on those bolts are basically 25 mm OD steel plates calling for fuzzy felt bumpers on the Sewing Room’s wood floors. When properly leveled, the front will be ⅛ inch higher than the rear. Although they suggest a pencil should roll toward the back, the top sheet metal on this one may be sufficiently warped to confuse the issue; I have a long level well suited to the task.

The original dimension doodle includes metric offsets for cutting with a ¼ inch end mill:

HON Foot nut - dimension doodles
HON Foot nut – dimension doodles

All in all, a satisfying day in the Basement Shop …