Tag: CNC-3018XL

Small gantry router

eBay Drop-Ship Addressing

So I bought some LM12UU linear bearings from a nominally US-based eBay seller and received a suitably marked bag:

eBay – LM8UU bearings in LM12UU bag

They looked a bit on the skinny side:

eBay – LM8UU bearing

It seems somebody in the supply chain wasn’t paying attention, which isn’t surprising given the its ability to deliver ten hunks of reasonably precise machining to my mailbox for a buck-and-a-half apiece.

As it happens, I already have far too many LM8UU bearings and, after some unavailing back-and-forth with the seller, eBay customer service determined neither of us was “at fault” and refunded the whole order.

Being in no particular hurry, I ordered the next lot from halfway around the planet. Apparently, I’m now known throughout the land:

eBay – drop-ship addressing

Another label atop that one sported my actual address, with a matching Orange Connex tracking number barcode. Turns out OC is a “a joint venture between a leader in Chinese private equity investment, CITI CPE, and the a [sic] pioneer of global e-commerce platform, ebay”.

AFAICT, containers of “direct from China” packages arrive in the belly of a cargo airplane, get a sticker with their final destination, and enter the US postal system. It’s not clear buying from a “US seller” changes anything, as many of those packages come from addresses matching a building next to an airport.

2019-12-14
Tek Circuit Computer: Drag Knife Deck Cutting
Creating a paper version of the Tektronix Circuit Computer requires nothing more than a drag knife to cut the deck outlines:

Tek Circuit Computer – cursor hairline

The middle deck is a disk with a notch exposing the FL scale, a cutout window exposing the inductive time constant / risetime scale, and a wee circle for the Chicago screw in the middle:

Tek CC – middle deck outline

Three angles define the notch:
```
  FLNotchArc = 85deg;                   // width exposing FL scale
  FLRampArc = 7deg;                     // … width of entry & exit ramps
  FLNotchOffset = 2deg;                 // … start angle from 0°
```
Given those, along with the deck radius and notch height (equals the underlying scale height), calculate four points defining the start and end of the ramps and connect the dots:
```
  local a0 = FLNotchOffset;
  local p0 = DeckRad * [cos(a0),sin(a0),-];

  local a1 = a0 + FLNotchArc;
  local p1 = DeckRad * [cos(a1),sin(a1),-];

  goto(p0);
  move([-,-,KnifeZ]);
  arc_cw(p1,-DeckRad);          // largest arc

  local r = DeckRad - ScaleHeight;
  local a3 = a1 - FLRampArc;
  local p3 = r * [cos(a3),sin(a3),-];

  local a4 = a0 + FLRampArc;
  local p4 = r * [cos(a4),sin(a4),-];

  move(p3);
  arc_cw(p4,r);                 // smallest arc

  move(p0);                     // end of notch

  arc_cw([DeckRad,0,-],DeckRad);      // round off corner
```
The arc_cw() functions draw arcs, as you’d expect, with a positive radius tracing the shortest arc and a negative radius for the longest arc. Although I know how that works, I must still preview the result to verify the G-Code does what I want, not what I said.

The unhappy result of a wrong sign:

Tek CC – middle deck outline – wrong arc sign

GCMC uses the (signed) radius to generate the XY coordinates and IJ offsets for G2 commands in the preferred center format:
```
G0 X88.846 Y3.103
G1 Z-2.000
G2 X4.653 Y88.778 I-88.846 J-3.103
```
Cutting the window starts from its angular width and offset, which are hardcoded magic numbers from the Tek artifact, and proceeds similarly:
```
  local WindowArc = 39deg;

  local ac = -6 * ScaleArc;                  // center of window arc
  local r0 = DeckRad - ScaleHeight;         // outer
  local r1 = DeckRad - 2 * ScaleHeight;     // inner

  local aw = WindowArc - to_deg(atan(ScaleHeight,(r0 + r1)/2));    // window arc minus endcaps

  local p0 = r0 * [cos(ac + aw/2),sin(ac + aw/2),-];
  local p1 = r0 * [cos(ac - aw/2),sin(ac - aw/2),-];
  local p2 = r1 * [cos(ac - aw/2),sin(ac - aw/2),-];
  local p3 = r1 * [cos(ac + aw/2),sin(ac + aw/2),-];

  goto(p0);
  move([-,-,KnifeZ]);

  arc_cw(p1,r0);                          // smallest arc
  arc_cw(p2,ScaleHeight/2);               // half a circle
  arc_ccw(p3,r1);
  arc_cw(p0,ScaleHeight/2);
```
Trust me on this: incorrect radius signs generate unrecognizable outlines. Which, of course, is why you preview the G-Code before actually cutting anything:

Tek CC – MPCNC drag knife

A similar hunk of code cuts the top deck; the bottom deck is a simple circle.

The workflow, such as it is:
- Tape a sheet of paper (Index stock, Basis 110 = 10 mil = 0.25 mm) at the center of the 3018-ProXL platform
- Plot (“engrave”) the scales with a pen
- Affix paper to a Cricut sticky mat taped to the MPCNC platform
- Touch off the origin at the middle
- Drag-cut (“mill”) the outlines
Less complex than it may appear, but the GCMC file now spits out two G-Code files per deck: one to engrave / draw the scales on the 3018 and another to mill / cut the outlines on the MPCNC.
2019-12-09
Diamond Drag Bit: Moah Downforce!

Engraving the Tektronix Circuit Computer bottom deck on a scrap hard drive platter suggested I’m entirely too much of a sissy about downforce on the diamond drag bit:

Tek CC – bottom deck – HD platter – L scale

That’s at Z=-5 mm for 350 g of downforce, with the spring preloaded with 100 g at a 50 g/mm rate. More or less, anyhow.

The GCMC code automagically scales everything by the ratio of the actual platter OD to the original Tek bottom deck. Using 93 mm for a hard drive platter (actual OD = 95 mm) sets the scaling to 0.197 = 93/197, which makes the scale legends just barely visible:

Tek CC – bottom deck – scaled to HD platter

The thing looks lovely, though, with ticks engraved at 2400 mm/min and the text at 2000 mm/min. The problem turns out to be the time taken to run the Z axis down and up while engraving so many ticks and characters!

I cranked on another 2 mm = 100 g of preload:

CNC 3018-Pro – diamond bit downforce plot

The top graph shows the downforce in 0.1 mm increments, rising from 0.0 to 217 g in 0.3 mm, which illustrates what the Y intercept of the plot means in real life.

Engraving at Z=-3 mm will now produce 350 g of downforce and cut the Z axis travel time down by a bit less than half. I have no idea what the right force might be; more experiments are in order.

2019-12-06
Tek Circuit Computer: Acrylic Cursor Hairline
A slide rule needs a cursor with a hairline to align numbers on its scales:

Tek Circuit Computer – cursor hairline

The GCMC code generating the hairline is basically a move scratching one line into the surface with the diamond bit:
```
  feedrate(ScaleSpeed);

  goto([-,-,TravelZ]);

  repeat(2) {
    goto([DeckTopOD/2 - 3*ScaleHeight,0,-]);
    move([-,-,EngraveZ]);
    move([DeckBottomOD/2 + ScaleHeight,0,-]);
    goto([-,-,TravelZ]);
  }
```
Two passes make the scratch deep enough to hold engraving crayon / lacquer / ink, without making it much wider. Laser engraving would surely work better.

In lieu of actually milling the cursor, this code scratches the perimeter:
```
  local dr = DeckBottomOD/2;
  local hr = CursorHubOD/2;
  local a = atan(hr - CursorTipWidth/2,dr);   // rough & ready approximation

  local p0 = hr * [sin(a),cos(a),-];          // upper tangent point on hub

  local c1 = [dr - CursorTipRadius,CursorTipWidth/2 - CursorTipRadius*cos(a),-];
  local p1 = c1 + [CursorTipRadius*sin(a),CursorTipRadius*cos(a),-];

  local p2 = c1 + [CursorTipRadius,0,-];      // around tip radius

  feedrate(KnifeSpeed);

  goto([-,-,TravelZ]);
  goto([-hr,0,-]);
  move([-,-,EngraveZ]);

  repeat(3) {
    arc_cw(p0,hr);
    move(p1);
    arc_cw(p2,CursorTipRadius);

    move([p2.x,-p2.y,-]);
    arc_cw([p1.x,-p1.y,-],CursorTipRadius);
    move([p0.x,-p0.y,-]);
    arc_cw([-hr,0,-],hr);
  }
```
Three passes makes it deep enough to snap along the line:

Tektronix Circuit Computer – cursor outline

If you look closely, though, you’ll find a little divot over on the left along the bottom edge, so I really must machine the thing.

Were I to go into production, I’d have to figure out a fixture, but I think I can just clamp a rough-cut acrylic rectangle to the Sherline’s table, mill half the perimeter, re-clamp without moving anything, then mill the other half.

Subtractive machining is such a bother!

The pivot holding the cursor and decks together is a “Chicago screw“, a.k.a. a “sex bolt“. I am not making this up.
2019-12-05
CNC 3018-ProXL: Y-axis Extension
The CNC 3018-Pro uses cheap & readily available parts, so extending the Y axis went smoothly:

CNC 3018-34 – overview

The 2040 side rails are now 450 mm long, as is the 8 mm leadscrew. I ordered 500 mm guide rods to forestall small length mismatches, then marked them to match the rails:

CNC 3018-ProXL – marking guide rods

Cut them off slightly beyond the mark, face the raw ends to length, drill-and-tap for M5 screws, then put a pair of just-under-50-mm stubs in the bar stockpile. They ought to come in handy for something, right?

The original side rails & guide rods were 290 (not 300!) mm long, so the table gained another 160 mm of travel for a total of 340 mm; I suppose it’s now a CNC 3034-Pro. Seeing as how it’s the only one and I don’t want to kill my snicker SEO, let’s call it a CNC 3018-ProXL or a maybe 3018-Pro34. Whatever.

The embiggened 300×340 mm platform dates back to the original 1955 kitchen: genuine Formica over plywood. It sits atop the previous 300×180 mm table, now demoted to being a riser, and a sheet of closed-cell foam, with the same 50 mm long M6 screws holding everything to T-nuts in the 3018’s original aluminum platform.

And, yes, the identical Formica underneath the machine originally covered a freestanding kitchen cabinet; I knew I kept it around for some good reason. Kinda disorienting to see a piece of the pattern moving against the same background, though.

The GRBL setup now extends the Y-axis length ($131=338) and puts the G54 coordinate at the new middle, with the Z-axis origin kissing the ball-point pen on the new surface:
```
 G10 L2 P1 X-145 Y-169 Z-24.6
```
While I was at it, I set the G28 position at the far left side of the gantry, with the table sticking out to the front, and the Z axis at the top:
```
 G28.1 X-298 Y-1 Z-1
```
Those are absolute machine coordinates, with Y and Z pulled off home by 1 mm. I set one of bCNC’s buttons to emit G28 and park the tool carrier over there, out of the way.

With all that prepared, a full-size Tek Circuit Computer disk plots the way it should on a sheet of Letter-size paper:

CNC 3018-34 – first light

I suspect the longer rods wouldn’t work quite so well for actual milling / machining any material tougher than, say, rigid foam blocks. For engraving and pen plotting, they’re all good.

Some measurements show this countertop isn’t quite as flat as the previous one, but a pair of tweaks got it within -0.15 / +0.1 mm:

CNC 3018-ProXL – table flatness – 2019-11-09

Which I defined to be Good Enough™ for use with spring-loaded implements of cutting & drawing.

Your mileage will certainly vary.
2019-11-25
Tektronix Circuit Computer: Layout Analysis
Following a linkie I can no longer find led me to retrieve the Tektronix Circuit Computer in my Box o’ Slide Rules:

Tektronix Circuit Computer – front

I’m pretty sure it came from Mad Phil’s collection. One can line up the discolored parts of the decks under their cutout windows to restore it to its previous alignment; most likely it sat at the end of a row of books (remember books?) on his reference shelf.

The reverse side lists the equations it can solve, plus pictorial help for the puzzled:

Tektronix Circuit Computer – rear

Some searching reveals the original version had three aluminum disks, shaped and milled and photo-printed, with a honkin’ hex nut holding the cursor in place. The one I have seems like laser-printed card stock between plastic laminating film; they don’t make ’em like that any more, either.

TEK PN 003-023 (the paper edition) runs about thirty bucks (modulo the occasional outlier) on eBay, so we’re not dealing in priceless antiquity here. The manual is readily available as a PDF, with photos in the back.

Some doodling produced key measurements:

Tektronix Circuit Computer – angle layout

All the dimensions are hard inches, of course.

Each log decade spans 18°, with the Inductive Frequency scale at 36° for the square root required to calculate circuit resonance.

Generating the log scales requires handling all possible combinations of:
- Scales increase clockwise
- Scales increase counterclockwise
- Ticks point outward
- Ticks point inward
- Text reads from center
- Text reads from rim
I used the 1×10⁰ tick on the outer scale of each deck as the 0° reference for the other scales on that deck. The 0° tick appears at the far right of plots & engravings & suchlike.

The L/R Time Constant (tau = τ) pointer on the top deck and the corresponding τL scale on the bottom deck has (what seems like) an arbitrary -150° offset from the 0° reference.

The Inductive Frequency scale has an offset of 2π, the log of which is 0.79818 = 14.37°.

The risetime calculations have a factor of 2.197, offsetting those pointers from their corresponding τ pointer by 0.342 = log(2.197) = 6.15°.

A fair bit of effort produced a GCMC program creating a full-size check plot of the bottom deck on the MPCNC:

Tektronix Circuit Computer – Bottom Deck – scale check plot

By the conservation of perversity, the image is rotated 90° to put the 1 H tick straight up.

The 3018 can’t handle a 7.75 inch = 196 mm disk, but a CD-size (120 mm OD) engraving came out OK on white plastic filled with black crayon:

Tek CC bottom – ABS 160g 2400mm-min

The millimeter scale over on the right shows the letters stand a bit under 1 mm tall. And, yes, the middle scale should read upside-down.

Properly filling the engraved lines remains an ongoing experiment. More downforce on the diamond or more passes through the G-Code should produce deeper trenches, perhaps with correspondingly higher ridges along the sides. Sanding & polishing the plastic without removing the ink seems tedious.

The Great Dragorn of Kismet observes I have a gift for picking projects at the cutting edge of consumer demand.

More doodles while figuring the GCMC code produced a summary of the scale offsets:

Tektronix Circuit Computer – scale angle tabulation

Musings on the parameters of each scale:

Tektronix Circuit Computer – scale parameters

How to draw decades of tick marks:

Tektronix Circuit Computer – decade tick doodles

It turned out easier to build vectors of tick mark values and their corresponding lengths, with another list of ticks to be labeled, than to figure out how to automate those values.

More on all this to come …
2019-11-22

CNC 3018-Pro: Collet Pen Holder

Along the same lines as the MPCNC pen holder, I now have one for the 3018:

CNC3018 - Collet pen holder - assembled — CNC3018 – Collet pen holder – assembled

The body happened to be slightly longer than two LM12UU linear bearings stacked end-to-end, which I didn’t realize must be a constraint until I was pressing them into place:

CNC 3018-Pro Collet Holder - LM12UU - solid model — CNC 3018-Pro Collet Holder – LM12UU – solid model

In the unlikely event I need another one, the code will sprout a max() function in the appropriate spot.

Drilling the aluminum rod for the knurled ring produced a really nice chip:

CNC3018 - Collet pen holder - drilling knurled ring — CNC3018 – Collet pen holder – drilling knurled ring

Yeah, a good drill will produce two chips, but I’ll take what I can get.

There’s not much left of the original holder after turning it down to 8 mm so it fits inside the 12 mm rod:

CNC3018 - Collet pen holder - turning collet OD — CNC3018 – Collet pen holder – turning collet OD

Confronted by so much shiny aluminum, I realized I didn’t need an 8 mm hole through the rod, so I cut off the collet shaft and drilled out the back end to clear the flanges on the ink tubes:

CNC3018 - Collet pen holder - drilling out collet — CNC3018 – Collet pen holder – drilling out collet

I figured things would eventually go badly if I trimmed enough ink-filled crimps:

Collet holder - pen cartridge locating flanges — Collet holder – pen cartridge locating flanges

The OpenSCAD source code as a GitHub Gist:

	// Collet Pen Holder in LM12UU linear bearings for CNC3018
	// Ed Nisley KE4ZNU – 2019-10-30

	Layout = "Build"; // [Build, Show, Base, Mount, Plate]

	/* [Hidden] */

	ThreadThick = 0.25; // [0.20, 0.25]
	ThreadWidth = 0.40; // [0.40, 0.40]

	/* [Hidden] */

	Protrusion = 0.1; // [0.01, 0.1]

	HoleWindage = 0.2;

	inch = 25.4;

	function IntegerMultiple(Size,Unit) = Unit * ceil(Size / Unit);

	ID = 0;
	OD = 1;
	LENGTH = 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);
	}

	//- Dimensions

	PenOD = 3.5; // pen cartridge diameter

	Bearing = [12.0,21.0,30.0]; // linear bearing body

	SpringSeat = [0.56,10.0,3*ThreadThick]; // wire = ID, coil = OD, seat depth = length

	WallThick = 4.0; // minimum thickness / width

	Screw = [3.0,6.75,25.0]; // holding it all together, OD = washer

	Insert = [3.0,5.5,8.2]; // brass insert
	//Insert = [4.0,6.0,10.0];

	Clamp = [43.2,44.5,34.0]; // tool clamp ring, OD = clearance around top

	LipHeight = IntegerMultiple(2.0,ThreadThick); // above clamp for retaining

	BottomExtension = 25.0; // below clamp to reach workpiece

	MountOAL = LipHeight + Clamp[LENGTH] + BottomExtension; // total mount length
	echo(str("Mount OAL: ",MountOAL));

	Plate = [1.5PenOD,Clamp[ID] – 02*WallThick,WallThick]; // spring reaction plate

	NumScrews = 3;
	ScrewBCD = Bearing[OD] + Insert[OD] + 2*WallThick;

	echo(str("Retainer max OD: ",ScrewBCD – Screw[OD]));

	NumSides = 9*4; // cylinder facets (multiple of 3 for lathe trimming)

	// Basic mount shape

	module CNC3018Base() {

	translate([0,0,MountOAL – LipHeight])
	cylinder(d=Clamp[OD],h=LipHeight,$fn=NumSides);
	translate([0,0,MountOAL – LipHeight – Clamp[LENGTH] – Protrusion])
	cylinder(d=Clamp[ID],h=(Clamp[LENGTH] + 2*Protrusion),$fn=NumSides);
	cylinder(d1=Bearing[OD] + 2*WallThick,d2=Clamp[ID],h=BottomExtension + Protrusion,$fn=NumSides);

	}

	// Mount with holes & c

	module Mount() {

	difference() {
	CNC3018Base();

	translate([0,0,-Protrusion]) // bearing
	PolyCyl(Bearing[OD],2*MountOAL,NumSides);

	for (i=[0:NumScrews – 1]) // clamp screws
	rotate(i*360/NumScrews)
	translate([ScrewBCD/2,0,MountOAL – Clamp[LENGTH]])
	rotate(180/8)
	PolyCyl(Insert[OD],Clamp[LENGTH] + Protrusion,8);
	}

	}

	module SpringPlate() {

	difference() {
	cylinder(d=Plate[OD],h=Plate[LENGTH],$fn=NumSides);

	translate([0,0,-Protrusion])
	PolyCyl(Plate[ID],2*MountOAL,NumSides);

	translate([0,0,Plate.z – SpringSeat[LENGTH]]) // spring retaining recess
	PolyCyl(SpringSeat[OD],SpringSeat[LENGTH] + Protrusion,NumSides);

	for (i=[0:NumScrews – 1]) // clamp screws
	rotate(i*360/NumScrews)
	translate([ScrewBCD/2,0,-Protrusion])
	rotate(180/8)
	PolyCyl(Screw[ID],2*MountOAL,8);
	}

	}


	//—–
	// Build it

	if (Layout == "Base")
	CNC3018Base();

	if (Layout == "Mount")
	Mount();

	if (Layout == "Plate")
	SpringPlate();

	if (Layout == "Show") {
	Mount();
	translate([0,0,1.25*MountOAL])
	rotate([180,0,0])
	SpringPlate();
	}

	if (Layout == "Build") {

	translate([0,-0.75*Clamp[OD],MountOAL])
	rotate([180,0,0])
	Mount();
	translate([0,0.75*Plate[OD],0])
	SpringPlate();
	}

view raw CNC 3018-Pro Collet Holder – LM12UU.scad hosted with ❤ by GitHub

2019-11-18

Tag: CNC-3018XL

eBay Drop-Ship Addressing

Tek Circuit Computer: Drag Knife Deck Cutting

Diamond Drag Bit: Moah Downforce!

Tek Circuit Computer: Acrylic Cursor Hairline

CNC 3018-ProXL: Y-axis Extension

Tektronix Circuit Computer: Layout Analysis

CNC 3018-Pro: Collet Pen Holder