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.
Mechanical widgetry
Ordered 100 stainless steel M3 washers from a “US Seller”, received this:
Yeah, it looked a bit short to me, too.
The chopped and bent washers in the upper right corner suggest the seller got floor sweepings from his source, which is about what you’d expect for a bottom-dollar vendor.
The seller refunded half, which wasn’t particularly generous, but I wasn’t ready to go to the mat for two bucks.
A pair of colorful laser-cut stacked acrylic Raspberry Pi cases with “Moster” (*) heatsinks arrived, with the intent of dressing up the HP 7475A plotters for their next Show-n-Tell:
Unfortunately, the thermal tape on one of the CPU heatsinks was sufficiently wrinkled to prevent good contact with the CPU:
The seller sent a replacement copper slug with tape on one side. Presumably, they glue it to the heatsink with thermal silicone:
Of which, I have none on hand.
So I did what I should have done originally, which was to drop a few bucks on a lifetime supply of thermally conductive heatsink tape, apply it to the bare side of the slug and stick the slug to the heatsink with their tape:
The blue stuff is the separation film, with the tape being white. It doesn’t match the black tape on the other side, but seems gooey enough to work.
Done!
Despite the heatsink hype, ball grid array chips dissipate most of their heat through their pads (and perhaps a central thermal pad) into the PCB, so sticking a heatsink atop the package is largely decorative, along the lines of hotrod ornamentation.
The epoxy packages used in previous Raspberry Pi iterations had better thermal conductivity to their top surface:
Than the more recent metal-top packages, which surely have inert-gas fill under the lid:
Pix cropped after being pilfered from the Official Raspberry Pi site.
Yes, the heatsink does conduct some heat into the air, even if not nearly as much as you might want.
(*) I’m pretty sure “Moster” was a typo in the original eBay listing which took on a life of its own to become something of an unofficial trademark. All of the search results ship from Duluth, Georgia (USA), regardless of the nominal seller; feel free to draw your own conclusions.
With the 3018-Pro used for drag engraving on CDs and hard drive platters, there’s no need for all the clearance below the Z-axis carriage required for the OEM motor and ER11 collet chuck. A chunk of laminate countertop and a hunk of Celotex foam insulation produce a nicely flat surface 47 mm above the platform:
It’s surprisingly flat:
Those are millimeters of clearance between the gray plastic clamp around the diamond drag tool holder (about which, more later) and my trusty bench block, measured at 50 mm intervals across the platform. The lower figures appeared after tightening the upper-left screw by a little over 1/6 turn = 0.2 mm, making the entire platform flat & aligned within ±0.1 mm.
Yeah, not bad for a scrap countertop!
The four M6 socket head cap screws pass through the stack into T-nuts in the platform:
The countertop was thick enough to allow countersinking the screws slightly below the surface:
I transfer-punched the screw clearance hole locations into the Celotex and drilled it with an ordinary twist drill. It wasn’t pretty, but nobody will ever notice.
Two sheets, maybe 1 mm thick, of closed-cell foam below the Celotext provide enough squish to align the top surface without straining anything. The screws are firmly tight, so they shouldn’t work their way loose under minimal engraving loads.
Taping the CDs to the surface works well for now, although a simpler version of the fixture may be in order.
The anonymous USB camera I used with the stereo zoom microscope not only works with VLC, but also with bCNC, and it has a round PCB with ears:
Which suggested putting it in a ball mount for E-Z aiming:
Black filament snippets serve as alignment pins to hold the ball halves together while they’re getting clamped. They’re epoxied into the upper half of the ball, because who knows when I’ll need to harvest the camera.
The clamp mount descends from the Tour Easy Daytime Running Lights, with more screws and less fancy shaping:
The clamp pieces fit around the ball with four M3 screws providing the clamping force:
The whole affair sticks onto the Z axis carrier with double-sided foam tape:
It barely clears the strut on the -X side of the carriage, although it does stick out over the edge of the chassis.
After the fact, I tucked a closed-cell foam ring between the lens threads and the ball housing to stabilize the lens; the original camera glued the thing in place, but some fiddly alignment & focusing lies ahead:
It’s worth noting that the optical axis of these cheap cameras rarely coincides with the physical central axis of the lens. This one requires a jaunty tilt, although it’s not noticeable in any of the pictures I tried to take.
All in all, this one works just like the probe camera on the MPCNC.
The OpenSCAD source code as a GitHub Gist:
| // CNC 3018-Pro Probe Camera mount for anonymous USB camera | |
| // Ed Nisley KE4ZNU – August 2019 | |
| Layout = "Show"; // [Show, Build, Ball, Clamp, Bracket, Mount] | |
| //——- | |
| //- Extrusion parameters must match reality! | |
| // Print with 2 shells | |
| /* [Hidden] */ | |
| ThreadThick = 0.25; | |
| ThreadWidth = 0.40; | |
| HoleWindage = 0.2; | |
| Protrusion = 0.1; // make holes end cleanly | |
| function IntegerMultiple(Size,Unit) = Unit * ceil(Size / Unit); | |
| inch = 25.4; | |
| ID = 0; | |
| OD = 1; | |
| LENGTH = 2; | |
| //——- | |
| // Dimensions | |
| //– Camera | |
| PCBThick = 1.2; | |
| PCBDia = 25.0; | |
| KeySize = [28.0,8.5,IntegerMultiple(PCBThick,ThreadThick)]; | |
| KeyOffset = [0.0,2.0,0.0]; | |
| KeyRadius = IntegerMultiple(sqrt(pow(KeySize.y – KeyOffset.y,2) + pow(KeySize.x/2,2)),0.01); | |
| echo(str("Key radius: ",KeyRadius)); | |
| Lens = [14.0,18.0,25.0]; | |
| BallID = PCBDia; | |
| BallOD = IntegerMultiple(2*KeyRadius,5.0); | |
| echo(str("Ball OD: ",BallOD)); | |
| WallThick = 3.0; | |
| CableOD = 3.75; | |
| NumPins = 3; | |
| Pin = [1.75,1.8,5.0]; | |
| Screw = [ | |
| 3.0,6.8,25.0 // M3 ID=thread, OD=washer, LENGTH=below head | |
| ]; | |
| RoundRadius = IntegerMultiple(Screw[OD]/2,1.0); // corner rounding | |
| ClampSize = [BallOD + 2*WallThick,BallOD + 2*WallThick,20.0]; | |
| echo(str("Clamp: ",ClampSize)); | |
| MountSize = [5.0,BallOD,25.0]; | |
| MountClearance = 1.0; // distance between clamp and mount | |
| Kerf = 2*ThreadThick; | |
| ScrewOC = [ClampSize.x – 2*RoundRadius,ClampSize.y – 2*RoundRadius]; | |
| echo(str("Screw OC: ",ScrewOC)); | |
| Insert = [ // brass insert: body, knurl,length | |
| 3.9,4.9,8.0 | |
| ]; | |
| UseInsert = false; | |
| NumSides = 12*4; | |
| //——- | |
| 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); | |
| } | |
| //——- | |
| // Components | |
| module CamBall(Section="Both") { | |
| Offset = (Section == "Both") ? 0 : | |
| (Section == "Upper") ? BallOD/2 : | |
| (Section == "Lower") ? -BallOD/2 : | |
| 0; | |
| render(convexity=4) | |
| intersection(convexity = 3) { | |
| difference() { | |
| sphere(d=BallOD,$fn=NumSides); | |
| sphere(d=BallID,$fn=NumSides); // interior | |
| PolyCyl(CableOD,2*BallOD,8); // cable & lens holes | |
| translate([0,0,-Lens[LENGTH]]) | |
| PolyCyl(Lens[OD],Lens[LENGTH],NumSides); | |
| translate([0,0,-PCBThick]) | |
| PolyCyl(PCBDia,PCBThick,NumSides); | |
| translate(KeyOffset + [0,-KeySize.y/2,-PCBThick/2]) // PCB key | |
| cube(KeySize,center=true); | |
| for (i=[0:NumPins – 1]) | |
| rotate(i*360/NumPins) | |
| translate([0,-(BallID + BallOD)/4,-Pin[LENGTH]/2]) | |
| PolyCyl(Pin[OD],Pin[LENGTH],6); | |
| } | |
| translate([0,0,Offset]) | |
| cube([BallOD,BallOD,BallOD] + 2*[Protrusion,Protrusion,0],center=true); | |
| } | |
| } | |
| module Clamp(Section="Both") { | |
| Offset = (Section == "Both") ? 0 : | |
| (Section == "Upper") ? ClampSize.z/2 : | |
| (Section == "Lower") ? -ClampSize.z/2 : | |
| 0; | |
| render(convexity=4) | |
| intersection() { | |
| difference() { | |
| hull() | |
| for (i=[-1,1], j=[-1,1]) | |
| translate([i*ScrewOC.x/2,j*ScrewOC.y/2,0]) | |
| cylinder(r=RoundRadius,h=ClampSize.z,$fn=NumSides,center=true); | |
| sphere(d=BallOD + 2*HoleWindage,$fn=NumSides); // space around camera ball | |
| for (i=[-1,1], j=[-1,1]) // screws | |
| translate([i*ScrewOC.x/2,j*ScrewOC.y/2,-ClampSize.z]) | |
| PolyCyl(Screw[ID],2*ClampSize.z,6); | |
| if (UseInsert) | |
| for (i=[-1,1], j=[-1,1]) // inserts | |
| translate([i*ScrewOC.x/2,j*ScrewOC.y/2,-(ClampSize.z/2 + Protrusion)]) | |
| PolyCyl(Insert[OD],Insert[LENGTH] + Protrusion,8); | |
| cube([2*ClampSize.x,2*ClampSize.y,Kerf],center=true); // clamping gap | |
| } | |
| translate([0,0,Offset]) | |
| cube([ClampSize.x,ClampSize.y,ClampSize.z] + 2*[Protrusion,Protrusion,0],center=true); | |
| } | |
| } | |
| module Bracket() { | |
| translate([ClampSize.x/2 + MountSize.x/2 + MountClearance,0,MountSize.z/2 – ClampSize.z/2]) | |
| cube(MountSize,center=true); | |
| translate([ClampSize.x/2 + MountClearance/2,0,-(ClampSize.z + Kerf)/4]) | |
| cube([MountClearance + 2*Protrusion,MountSize.y,(ClampSize.z – Kerf)/2],center=true); | |
| } | |
| module Mount() { | |
| union() { | |
| Clamp("Lower"); | |
| Bracket(); | |
| } | |
| } | |
| //——- | |
| // Build it! | |
| if (Layout == "Ball") | |
| CamBall(); | |
| if (Layout == "Clamp") | |
| Clamp(); | |
| if (Layout == "Bracket") | |
| Bracket(); | |
| if (Layout == "Mount") | |
| Mount(); | |
| if (Layout == "Show") { | |
| difference() { | |
| union() { | |
| color("Purple") | |
| Clamp("Upper"); | |
| Mount(); | |
| color("LimeGreen") | |
| CamBall(); | |
| } | |
| rotate([0,0,45]) | |
| translate([-ClampSize.x,0,0]) | |
| cube(2*ClampSize,center=true); | |
| } | |
| } | |
| if (Layout == "Build") { | |
| Gap = 0.6; | |
| translate([-Gap*BallOD,Gap*BallOD,0]) | |
| CamBall("Upper"); | |
| translate([-Gap*BallOD,-Gap*BallOD,0]) | |
| rotate([0,180,0]) | |
| CamBall("Lower"); | |
| translate([Gap*ClampSize.x,-Gap*ClampSize.y,ClampSize.z/2]) | |
| rotate([0,180,0]) | |
| Clamp("Upper"); | |
| translate([Gap*ClampSize.x,Gap*ClampSize.y,ClampSize.z/2]) { | |
| rotate(180) | |
| Mount(); | |
| } | |
| } |
The ball-shaped Logitch QuickCam Pro 5000 has a rectangular PCB, so conjuring a case wasn’t too challenging:
That’s more-or-less matte black duct tape to cut down reflections.
The top side has a cover made from scuffed acrylic scrap:
The corners are slightly rounded to fit under the screw heads holding it in place.
The solid model shows off the internal ledge positioning the PCB so the camera lens housing rests on the floor:
The notch lets the cable out, while keeping it in one place and providing some strain relief.
I though if a camera was recognized by V4L2 and worked with VLC, it was good to go:
Regrettably, it turns out the camera has a pixel format incompatible with the Python opencv interface used by bCNC. This may have something to do with running the code on a Raspberry Pi, rather than an x86 box.
The camera will surely come in handy for something else, especially with such a cute case.
The OpenSCAD source code as a GitHub Gist:
| // Probe Camera Mount for CNC 3018-Pro Z Axis | |
| // Ed Nisley – KE4ZNU – 2019-08 | |
| Layout = "Block"; // [Show,Build,Block] | |
| Support = false; | |
| /* [Hidden] */ | |
| ThreadThick = 0.20; | |
| ThreadWidth = 0.40; | |
| HoleWindage = 0.2; | |
| Protrusion = 0.1; // make holes end cleanly | |
| function IntegerMultiple(Size,Unit) = Unit * ceil(Size / Unit); | |
| ID = 0; | |
| OD = 1; | |
| LENGTH = 2; | |
| inch = 25.4; | |
| //———————- | |
| // Dimensions | |
| PCB = [45.0,38.0,1.5]; // Logitech QuickCam Pro 5000 ball camera | |
| PCBLip = 1.0; // max non-component border | |
| PCBChamfer = 3.0; // cut along XY axes for corner bevel | |
| PCBClearTop = 15.0; // cables & connectors | |
| PCBClearSides = [0.5,0.5]; // irregular edges & comfort zone | |
| PCBClearBelow = 5.0; // lens support bracket rests on floor | |
| Lens = [11.5,14.2,3.0]; // LENGTH = beyond PCBClearBelow bracket | |
| LensOffset = [-1.5,0.0,0]; // distance from center of board | |
| CableOD = 4.5; | |
| BaseThick = Lens[LENGTH]; | |
| Screw = [ | |
| 3.0,6.8,18.0 // M3 OD=washer, LENGTH=below head | |
| ]; | |
| RoundRadius = IntegerMultiple(Screw[OD]/2,1.0); // corner rounding | |
| ScrewOC = [PCB.x + 2*sqrt(Screw[OD]),PCB.y + 2*sqrt(Screw[OD])]; | |
| echo(str("Screw OC: ",ScrewOC)); | |
| Lid = [ScrewOC.x,ScrewOC.y,1.0/16.0 * inch]; // top cover plate | |
| echo(str("Lid: ",Lid)); | |
| BlockSize = [ScrewOC.x + 2*RoundRadius,ScrewOC.y + 2*RoundRadius, | |
| BaseThick + PCBClearBelow + PCB.z + PCBClearTop + Lid.z]; | |
| echo(str("Block: ",BlockSize)); | |
| NumSides = 2*3*4; | |
| //———————- | |
| // 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); | |
| } | |
| // Basic shapes | |
| // Overall block | |
| module Block() { | |
| difference() { | |
| hull() | |
| for (i=[-1,1], j=[-1,1]) | |
| translate([i*ScrewOC.x/2,j*ScrewOC.y/2,0]) | |
| cylinder(r=RoundRadius,h=BlockSize.z,$fn=NumSides); | |
| for (i=[-1,1], j=[-1,1]) // corner screws | |
| translate([i*ScrewOC.x/2,j*ScrewOC.y/2,BlockSize.z – Screw[LENGTH]]) | |
| cylinder(d=Screw[ID],h=2*Screw[LENGTH],$fn=8); // cylinder = undersized | |
| translate(LensOffset + [0,0,-Protrusion]) // lens body | |
| PolyCyl(Lens[OD],2*BlockSize.z,NumSides); | |
| translate([0,0,BlockSize.z/2 + BaseThick]) // PCB lip on bottom | |
| cube([PCB.x – 2*PCBLip,PCB.y,BlockSize.z],center=true); | |
| translate([0,0,BlockSize.z/2 + BaseThick + PCBClearBelow]) // PCB clearance | |
| cube([PCB.x + 2*PCBClearSides.x,PCB.y + 2*PCBClearSides.y,BlockSize.z],center=true); | |
| translate([0,0,BlockSize.z – Lid.z/2]) // lid recess | |
| cube(Lid + [0,0,Protrusion],center=true); | |
| translate([0,Lid.y/2 – CableOD/2,BaseThick + PCBClearBelow + PCB.z]) // cable exit | |
| hull() | |
| for (j=[-1,1]) | |
| translate([0,j*CableOD/4,0]) | |
| rotate(180/8) | |
| PolyCyl(CableOD,BlockSize.z,8); | |
| } | |
| } | |
| //- Build it | |
| if (Layout == "Block") | |
| Block(); | |
| if (Layout == "Show") { | |
| Block(); | |
| } | |
| if (Layout == "Build") { | |
| Block(); | |
| } |
Up to this point, the Sherline has been drilling 3.5 inch hard drive platters to serve as as reflecting bases for the vacuum tubes:
The CNC 3018-Pro has a work envelope large enough for CD / DVD platters, so I mashed the Sherline fixture with dimensions from the vacuum tube code, added the 3018’s T-slot spacing, and conjured a pair of fixtures for a pair of machines.
Because I expect to practice on scrap CDs and DVDs for a while:
And a 3.5 inch hard drive platter version:
The holes sit at half the 3018’s T-slot spacing (45 mm / 2), so you can nudge the fixtures to the front or rear, as you prefer.
The alignment dots & slots should help touch off the XY coordinate system on the Sherline, although it can’t reach all of a CD. Using bCNC’s video alignment on the hub hole will be much easier on the 3018.
After fiddling around with the 3018 for a while, however, the CD fixture doesn’t have many advantages over simply taping the disc to a flat platen. Obviously, you’d want a sacrificial layer for drilling, but it’s not clear the OEM motor / ER11 chuck would be up to that task.
The OpenSCAD source code as a GitHub Gist:
| // Machining fixtures for CD and hard drive platters | |
| // Ed Nisley KE4ZNU February … September 2016 | |
| // 2019-08 split from tube base models | |
| PlatterName = "CD"; // [3.5inch,CD] | |
| CNCName = "3018"; // [3018,Sherline] | |
| PlateThick = 5.0; // [5.0,10.0,15.0] | |
| RecessDepth = 4.0; // [0.0,2.0,4.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; | |
| 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(d=(FixDia + HoleWindage),h=Height,$fn=Sides); | |
| } | |
| ID = 0; | |
| OD = 1; | |
| LENGTH = 2; | |
| //———————- | |
| // Dimensions | |
| P_NAME = 0; // platter name | |
| P_ID = 1; // … inner diameter | |
| P_OD = 2; // … outer diameter | |
| P_THICK = 3; // … thickness | |
| PlatterData = [ | |
| ["3.5inch", 25.0, 95.0, 1.75], | |
| ["CD", 15.0, 120.0, 1.20], | |
| ]; | |
| PlatterSides = 3*4*5; // polygon approximation | |
| B_NAME = 0; // machine name | |
| B_OC = 1; // … platform screw OC, use small integer for slot | |
| B_STUD = 2; // … screw OD clearance | |
| BaseData = [ | |
| ["3018", [5.0, 45.0], 6.0], // slots along X axis | |
| ["Sherline", [1.16*inch,1.16*inch], 5.0], // tooling plate | |
| ]; | |
| //———————- | |
| // Drilling fixture for disk platters | |
| module PlatterFixture(Disk,Machine) { | |
| PI = search([Disk],PlatterData,1,0)[P_NAME]; // get platter index | |
| echo(str("Platter: ",Disk)); | |
| Platter = [PlatterData[PI][P_ID], | |
| PlatterData[PI][P_OD], | |
| PlatterData[PI][P_THICK]]; | |
| BI = search([Machine],BaseData,1,0)[B_NAME]; // get base index | |
| echo(str("Machine: ",Machine)); | |
| AlignOC = IntegerMultiple(Platter[OD],10); | |
| echo(str("Align OC: ",AlignOC)); | |
| AlignSlot = [3*ThreadWidth,10.0,3*ThreadThick]; | |
| StudClear = BaseData[BI][B_STUD]; // … clearance | |
| StudOC = [IntegerMultiple(AlignOC + 2*StudClear,BaseData[BI][B_OC].x), // … screw spacing | |
| BaseData[BI][B_OC].y]; | |
| echo(str("Stud spacing: ",StudOC)); | |
| NumStuds = [2,1 + 2*floor(Platter[OD] / StudOC.y)]; // holes only along ±X edges | |
| echo(str("Stud holes: ",NumStuds)); | |
| BasePlate = [(20 + StudOC.x*ceil(Platter[OD] / StudOC.x)), | |
| (10 + AlignOC), | |
| PlateThick]; | |
| echo(str("Plate: ",BasePlate)); | |
| PlateRound = 10.0; // corner radius | |
| difference() { | |
| hull() // basic plate shape | |
| for (i=[-1,1], j=[-1,1]) | |
| translate([i*(BasePlate.x/2 – PlateRound),j*(BasePlate.y/2 – PlateRound),0]) | |
| cylinder(r=PlateRound,h=BasePlate.z,$fn=4*4); | |
| for (i=[-1,0,1], j=[-1,0,1]) // origin pips | |
| translate([i*AlignOC/2,j*AlignOC/2,BasePlate.z – 2*ThreadThick]) | |
| cylinder(d=4*ThreadWidth,h=1,$fn=6); | |
| for (i=[-1,1], j=[-1,1]) { // alignment slots | |
| translate([i*(AlignOC + AlignSlot.x)/2, | |
| j*Platter[OD]/4, | |
| (BasePlate.z – AlignSlot.z/2 + Protrusion/2)]) | |
| cube(AlignSlot + [0,0,Protrusion],center=true); | |
| translate([i*Platter[OD]/4, | |
| j*(AlignOC + AlignSlot.x)/2, | |
| (BasePlate.z – AlignSlot.z/2 + Protrusion/2)]) | |
| rotate(90) | |
| cube(AlignSlot + [0,0,Protrusion],center=true); | |
| } | |
| for (i=[-1,1], j=[-floor(NumStuds.y/2):floor(NumStuds.y/2)]) // mounting stud holes | |
| translate([i*StudOC.x/2,j*StudOC.y/2,-Protrusion]) | |
| rotate(180/6) | |
| PolyCyl(StudClear,BasePlate.z + 2*Protrusion,6); | |
| translate([0,0,-Protrusion]) // center clamp hole | |
| rotate(180/6) | |
| PolyCyl(StudClear,BasePlate.z + 2*Protrusion,6); | |
| translate([0,0,BasePlate.z – Platter[LENGTH]]) // disk locating recess | |
| rotate(180/PlatterSides) | |
| linear_extrude(height=(Platter[LENGTH] + Protrusion),convexity=2) | |
| difference() { | |
| circle(d=(Platter[OD] + HoleWindage),$fn=PlatterSides); | |
| circle(d=Platter[ID] – HoleWindage,$fn=PlatterSides); | |
| } | |
| translate([0,0,BasePlate.z – RecessDepth]) // drilling recess | |
| rotate(180/PlatterSides) | |
| linear_extrude(height=(RecessDepth + Protrusion),convexity=2) | |
| difference() { | |
| circle(d=(Platter[OD] – 10),$fn=PlatterSides); | |
| circle(d=(Platter[ID] + 10),$fn=PlatterSides); | |
| } | |
| } | |
| } | |
| //———————- | |
| // Build it | |
| PlatterFixture(PlatterName,CNCName); | |
I finally decommissioned my old Thing-O-Matic, as it’s been far surpassed by the current generation of dirt-cheap Prusa-style 3D printers, and must now figure out what to do with about 10 kg of 3 mm ABS filament. Yes, 3 mm filament from back in the Bad Old Days.
Also back in the day, our Larval Engineer made millifiori creations in glass (at school) and polymer clay, building up the final piece from murrine canes, which suggested a similar technique using filament strands:
Well, maybe it’s not exactly art …
Just to see how it might work, I packed a random length of conduit with filament snippets and jammed a thermocouple into the middle:
Which went into the shop’s sacrificial Dutch oven over low heat:
For lack of anything smarter, I slowly heated it to 250 °C, well above what the Thing-O-Matic used for extrusion, let it soak for a few minutes, then let the tube cool on the counter.
Some persuasion with a hammer and drift punch extracted the fused filament:
Obviously, the concept needs more work, but the bottom side looks promising:
Wrapping the bundle with silicone tape should keep the filament from sticking to the tube and provide uniform compression:
I forced it into the tube and wrapped the whole affair with aluminum foil to confine the hot ABS stench:
I held this one at 235 °C for a few minutes, cooled, unwrapped, and discovered the silicone wrap worked as expected:
OK, the blob on each end wasn’t expected, but at least the thermocouple came out with gentle persuasion. The compressed filament looked like it should be edible:
The molten filament oozed out of the wrap inside the tube, over there toward the right.
The filament snippets have a distinct curvature, brought on by years spent snuggled around a spool’s core, so I wondered if they could be straightened by application of somewhat less heat. Wikipedia lists the glass transition temperature for various ABS compositions as around 105 °C, so I packed the tube with more snippets and affixed the thermocouple with silicone tape:
Wrap with foil, heat to 100 °C, let cool, and they’re definitely straighter than the unheated white strand at the bottom:
Having learned my lesson with a thermocouple inside the strands, the straightened strands get a looser silicone wrap with the thermocouple secured to the outside of the bundle:
Heat to 160 °C:
Let cool and (easily!) slide the compressed bundle out of the tube:
The silicone wrap definitely mushed the strands together, as shown by the larger diameter on the uncompressed end:
Bandsawing the bundle reveals nicely fused filaments inside, along with melty ends that stuck out of the wrap:
Thinking shorter lengths might pack better without straightening, I faced the ends of a thick aluminum pipe and stuffed as many snippets into it as would fit. This is the point where a real artist would arrange the filaments in a pleasing pattern, if not a picture, but I was content with a random layout:
That’s what the ends looked like after heating to 160 °C: somewhat glazed, reasonably fused, but certainly not compacted. The other end pointed upward and definitely felt the heat:
With a PCV pipe “collet” holding the cable / cane / murrina in the chuck, I faced the end:
After taking this picture, I came to my senses and bandsawed the slice instead:
Parting the slice in the lathe might have worked, but it just seemed like a really really bad idea when I looked at the setup.
A PVC pipe spacer kept the slice lined up in the chuck jaws while facing the bandsawed end:
The slice and the cable:
Although the filament snippets fuse together without a silicone tape compression wrap, the gaps collect plenty of swarf during the cutting & facing:
The snippets along the outside, closest to the pipe, obviously got hotter than the ones in the middle and fused more solidly.
The pipe has a 35 mm ID for an area 136 times larger than a 3 mm filament. I packed about 100 snippets into the pipe, a 0.73 packing fraction, which looks to be in the right ballpark for the high end of the Circle Packing Problem. If they were straighter, maybe a few more would fit, but twisting the lot into a cable seemed to align them pretty well.
Perhaps filling the gaps with pourable epoxy before cutting the slices would help? A completely filled interior might require pulling a good vacuum on the whole thing.
A hexagonal pipe would produce slices one could tile into a larger sheet.
All in all, a useful exercise, but … it ain’t Art yet!
The Smell of Molten Projects in the Morning 