MPCNC Drag Knife Holder: Showing More Blade

Attempting to cut laminated cardstock decks for the Homage Tektronix Circuit Computer required a bit more blade extension than my LM12UU holder made available:

Drag Knife - LM12UU ground shaft - assembled
Drag Knife – LM12UU ground shaft – assembled

Shortening the 12 mm shaft wasn’t going to happen, so I knocked a little bit off the blade holder to give the knurled lock ring slightly more travel:

Drag Knife Holder - shortening stop
Drag Knife Holder – shortening stop

The lathe cutoff blade is a bit to the right of the new cut, but you get the general idea: not a whole lot of clearance in there.

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
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
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),-];

  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),-];

  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
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),-];


  arc_cw(p1,r0);                          // smallest arc
  arc_cw(p2,ScaleHeight/2);               // half a circle

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
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.

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
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
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
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×100 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
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
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
Tektronix Circuit Computer – scale angle tabulation

Musings on the parameters of each scale:

Tektronix Circuit Computer - scale parameters
Tektronix Circuit Computer – scale parameters

How to draw decades of tick marks:

Tektronix Circuit Computer - decade tick doodles
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 …

MPCNC: Z-Axis Probed Height Map to Solid Model

I set up an orthotic shoe insert on the MPCNC and unleashed the Z-Axis height probe on it:

Orthotic - bottom probing
Orthotic – bottom probing

In principle, the grid keeps the object aligned with the machine axes and the blocks put the upper surface more-or-less parallel with the platform. The XY origin, at the G28 location I’ve been using for tool changes, is on the midline of the sole, with Z touched off by probing the platform beside the sole.

The only interesting part of the orthotic is the rigid white plastic plate, which extends about 20 mm into a pocket in the black foam, so the probe area excludes the bendy part.

I’m abusing the bCNC Auto-level probe routine to get the height map, because it produces a tidy file of XYZ coordinates with three header lines describing the overall probe area:

-50 140 39
-50 50 21
-2 35 500

-50 -50 0.11
-45 -50 0.06
-40 -50 0.005

The first two lines give the X and Y coordinate ranges and number of samples. The third line is the Z axis range and probe speed (?). After that, it’s just probed XYZ coordinates, all the way down.

Meshlab can import ASC files consisting of XYZ coordinates, with the ability to skip a specific number of header lines:

Meshlab ASC file import - header lines
Meshlab ASC file import – header lines

If you don’t skip those three lines, then you get three additional points, far off in XYZ space, that will confuse the next step.

Checking the Grid Triangulation box (the default) produces a nicely lofted sheet:

Orthotic - R bottom triangulated
Orthotic – R bottom triangulated

It is, however, a single-sided sheet, not a manifold 3D object. After a few days of screwing around, I’m unable to find any (automatic, reliable, non-manual) way to solidify the thing in Meshlab, so just save it as a PLY file in ASCII format:

Meshlab PLY file export - unchecked Binary Encoding
Meshlab PLY file export – unchecked Binary Encoding

Import it into Meshmixer, Ctrl-A to select the whole thing, click (Select →) Edit → Extrude, pick Y-Axis and Flat EndType, then extrude a convenient base in the negative direction:

Meshmixer - Y-Axis extrusion
Meshmixer – Y-Axis extrusion

For whatever reason, some 3D programs show machine-tool coordinates with Z pointing upward and others aim the Z axis at your face. Both must have made sense at the time, because Meshmixer defaults to swapping the Y and Z coordinates on import / export.

The Density slider controls the number of generated faces in the extruded section, so tune for best results.

I have no idea what Harden does.

Accept the result and you have a solid object suitable for further modeling.

MPCNC: Z-Axis Height Probe

A slight modification to the MPCNC LM12UU collet pen holder turns it into a long-reach Z-Axis Height Probe:

CNC 3018-Pro - Z-Axis height probe - overview
CNC 3018-Pro – Z-Axis height probe – overview

A flange on the top plate holds a Makerbot-style endstop switch:

Collet Holder - LM12UU - switch plate - solid model
Collet Holder – LM12UU – switch plate – solid model

The brass probe rod sports a 3/32 inch ball epoxied on its tip, although for my simple needs I could probably use the bare rod:

CNC 3018-Pro - Z-Axis height probe - ball tip detail
CNC 3018-Pro – Z-Axis height probe – ball tip detail

I clamped the rod to extend a bit beyond the plate, where it can soak up most of the switch release travel, leaving just enough to reset the clickiness after each probe:

CNC 3018-Pro - Z-Axis height probe - detail
CNC 3018-Pro – Z-Axis height probe – detail

The probe responds only to Z motion, not tip deflection in XY, so it’s not particularly good for soft objects with sloped sides, like the insole shown above. It works fine for rigid objects and should suffice to figure the modeling workflow.

The bCNC Auto-Level probe routine scans a grid over a rectangular region:

Insole - bCNC AutoLevel Probe Map - detail
Insole – bCNC AutoLevel Probe Map – detail

Which Meshlab turns into a solid model:

Insole - Meshlab triangulation
Insole – Meshlab triangulation

That’s the bottom of the insole probed on a 5 mm grid, which takes something over an hour to accomplish.

The OpenSCAD code as a GitHub Gist:

// Collet pen cartridge holder using LM12UU linear bearing
// Ed Nisley KE4ZNU - 2019-04-26
// 2019-06 Adapted from LM12UU drag knife holder
// 2019-09 Probe switch mount plate
Layout = "Build"; // [Build, Show, Puck, Mount, Plate, SwitchPlate]
/* [Hidden] */
// Extrusion parameters
ThreadThick = 0.25; // [0.20, 0.25]
ThreadWidth = 0.40; // [0.40]
// Constants
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;
//- 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
// Basic shape of DW660 snout fitting into the holder
// Lip goes upward to lock into MPCNC mount
Snout = [44.6,50.0,9.6]; // LENGTH = ID height
Lip = 4.0; // height of lip at end of snout
// Holder & suchlike
PenShaft = 3.5; // hole to pass pen cartridge
WallThick = 4.0; // minimum thickness / width
Screw = [4.0,8.5,25.0]; // thread ID, washer OD, length
Insert = [4.0,6.0,10.0]; // brass insert
Bearing = [12.0,21.0,30.0]; // linear bearing body
Plate = [PenShaft,Snout[OD] - WallThick,WallThick]; // spring reaction plate
echo(str("Plate: ",Plate));
SpringSeat = [0.56,7.5,2*ThreadThick]; // wire = ID, coil = OD, seat depth = length
PuckOAL = max(Bearing[LENGTH],(Snout[LENGTH] + Lip)); // total height of DW660 fitting
echo(str("PuckOAL: ",PuckOAL));
Key = [Snout[ID],25.7,(Snout[LENGTH] + Lip)]; // rectangular key
NumScrews = 3;
//ScrewBCD = 2.0*(Bearing[OD]/2 + Insert[OD]/2 + WallThick);
ScrewBCD = (Snout[ID] + Bearing[OD])/2;
echo(str("Screw BCD: ",ScrewBCD));
NumSides = 9*4; // cylinder facets (multiple of 3 for lathe trimming)
// MBI Endstop switch PCB
PCB = [40.0,1.6,16.5]; // endstop PCB, switch downward, facing parts
Touchpoint = [-4.8,4.8,4.5]; // contact point from PCB edges, solder side
TapeThick = 1.0; // foam mounting tape
SwitchMount = [PCB.x,WallThick,PCB.z + Touchpoint.z + Plate.z];
module DW660Puck() {
rotate([180,0,0]) {
cylinder(d=Snout[ID],h=(Snout[LENGTH] + Lip),$fn=NumSides);
translate([0,0,(Snout[LENGTH] + Lip) - Protrusion])
cylinder(d1=Snout[ID],d2=2*WallThick + Bearing[OD],h=PuckOAL - (Snout[LENGTH] + Lip),$fn=NumSides);
intersection() {
translate([0,0,0*Lip + Key.z/2])
cylinder(d=Snout[OD],h=Lip + Key.z,$fn=NumSides);
module MountBase() {
difference() {
translate([0,0,-Protrusion]) // bearing
for (i=[0:NumScrews - 1]) // clamp screws
module SpringPlate() {
difference() {
translate([0,0,-Protrusion]) // pen cartridge hole
translate([0,0,Plate.z - SpringSeat[LENGTH]]) // spring retaining recess
PolyCyl(SpringSeat[OD],SpringSeat[LENGTH] + Protrusion,NumSides);
for (i=[0:NumScrews - 1]) // clamp screws
module SwitchPlate() {
translate([Touchpoint.x,Touchpoint.y + TapeThick,0])
// Build it
if (Layout == "Puck")
if (Layout == "Plate")
if (Layout == "SwitchPlate")
if (Layout == "Mount")
if (Layout == "Show") {
if (Layout == "Build") {

bCNC Probe Camera Calibration

I’m sure I’ll do this again some time …

Focus the camera at whatever distance needed to clear the longest tooling you’ll use or, at least, some convenient distance from the platform. You must touch off Z=0 at the surface before using bCNC’s probe camera alignment, because it will move the camera to the preset focus distance.

Align the camera’s optical axis perpendicular to the table by making it stare into a mirror flat on the platform, then tweaking the camera angles until the crosshair centers on the reflected lens image. This isn’t dead centered, but it’s pretty close:

CNC 3018-Pro - bCNC Probe Camera - collimation - detail
CNC 3018-Pro – bCNC Probe Camera – collimation – detail

The camera will be focused on the mirror, not the reflection, as you can tell by the in-focus crud on the mirror. Whenever you focus the lens, you’ll probably move the optical axis, so do the best you can with the fuzzy image.

You can adjust small misalignments with the Haircross (seems backwards to me) Offset values.

A cheap camera’s lens barrel may not be aligned with its optical axis, giving the lens a jaunty tilt when it’s correctly set up:

CNC 3018-Pro - Engraving - taped
CNC 3018-Pro – Engraving – taped

With the camera focus set correctly, calibrate the camera Offset from the tool (a.k.a. Spindle) axis:

  • Put a pointy tool at XY=0
  • Touch off Z=0 on a stack of masking tape
  • Put a dent in the tape with the bit
  • Move to the camera’s focused Z level
  • Make the dent more conspicuous with a Sharpie, as needed
  • Register the spindle location
  • Jog to center the crosshair on the dent
  • Register the camera location

Calibrate the Crosshair ring diameter thusly:

  • Put an object with a known size on the platform
  • Touch off Z=0 at its surface
  • Move to the camera’s focused Z level
  • Set the Crosshair diameter equal to the known object size
  • Adjust the Scale value to make the Crosshair overlay reality

For example, calibrating the diameter to 10 mm against a shop scale:

CNC 3018-Pro Probe Camera - scale factor - detail
CNC 3018-Pro Probe Camera – scale factor – detail

At 10 mm above the CD, setting the camera’s resolution to 11.5 pixel/mm:

CNC 3018-Pro - bCNC probe camera - settings
CNC 3018-Pro – bCNC probe camera – settings

Makes the outer circle exactly 15.0 mm in diameter to match the CD hub ring ID:

CNC 3018-Pro - bCNC probe camera - red-blue CD target
CNC 3018-Pro – bCNC probe camera – red-blue CD target

I doubt anybody can find the pixel/mm value from first principles, so you must work backwards from an object’s actual size.

CNC 3018-Pro: Diamond Drag Engraving Test Disk

The smaller and more rigid CNC 3018-Pro should be able to engrave text faster than the larger and rather springy MPCNC, which could engrave text at about 50 mm/min. This test pattern pushes both cutting depth and engraving speed to absurd values:

Engraving Test Pattern - 2019-09-18
Engraving Test Pattern – 2019-09-18

Compile the GCMC source to generate G-Code, lash a CD / DVD to the platform (masking tape works fine), touch off the XY coordinates in the center, touch off Z=0 on the surface, then see what happens:

CNC 3018-Pro - Engraving test pattern - curved text
CNC 3018-Pro – Engraving test pattern – curved text

The “engraving depth” translates directly into the force applied to the diamond point, because the spring converts displacement into force. Knowing the Z depth, you can calculate or guesstimate the force.

Early results from the 3018 suggest it can engrave good-looking text about 20 times faster than the MPCNC:

CNC 3018-Pro - Engraving - speeds
CNC 3018-Pro – Engraving – speeds

You must trade off speed with accuracy on your very own machine, as your mileage will certainly differ!

The GCMC source code as a GitHub Gist:

// Engraving test piece
// Ed Nisley KE4ZNU - 2019-09
// Command line parameters
// -D OuterDia=number
if (!isdefined("OuterDia")) {
OuterDia = 120mm - 2mm; // CD = 120, 3.5 inch drive = 95
OuterRad = OuterDia / 2.0;
comment("Outer Diameter: ",OuterDia);
comment(" Radius: ",OuterRad);
// Library routines
// Bend text around an arc
function ArcText(TextPath,Center,Radius,BaseAngle,Align) {
PathLength = TextPath[-1].x;
Circumf = 2*pi()*Radius;
TextAngle = to_deg(360 * PathLength / Circumf);
AlignAngle = BaseAngle + (Align == "Left" ? 0 :
Align == "Center" ? -TextAngle / 2 :
Align == "Right" ? -TextAngle :
ArcPath = {};
foreach(TextPath; pt) {
if (!isundef(pt.x) && !isundef(pt.y) && isundef(pt.z)) { // XY motion, no Z
r = Radius - pt.y;
a = 360deg * (pt.x / Circumf) + AlignAngle;
ArcPath += {[r*cos(a) + Center.x, r*sin(a) + Center.y,-]};
elif (isundef(pt.x) && isundef(pt.y) && !isundef(pt.z)) { // no XY, Z up/down
ArcPath += {pt};
else {
error("Point is not pure XY or pure Z: " + to_string(pt));
return ArcPath;
// Set up for drawing
SafeZ = 10.0mm; // above clamps and screws
TravelZ = 1.0mm; // above workpiece
PlotZ = -0.5mm; // tune for best results
TextSpeed = 1000mm; // intricate detail
DrawSpeed = 2000mm; // smooth curves
TextFont = FONT_HSANS_1_RS;
TextSize = [2.0mm,2.0mm];
TextLeading = 2*TextSize.y; // line spacing
DiskCenter = [0mm,0mm]; // middle of the platter
InnerDia = 40mm;
InnerRad = InnerDia / 2.0;
comment("Inner Diameter: ",InnerDia);
comment(" Radius: ",InnerRad);
NumRings = ceil((OuterRad - (InnerRad + TextLeading))/TextLeading); // number of rings to draw
comment("Numer of rings: ",NumRings);
if (1) {
comment("Text Size begins");
ts = "Text size: " + to_string(TextSize);
tp = scale(typeset(ts,TextFont),TextSize);
tpa = ArcText(tp,DiskCenter,OuterRad,90deg,"Left");
if (1) {
comment("Depth variations begin");
TextRadius = OuterRad;
pz = 0.0mm;
repeat(NumRings ; i) {
comment(" depth: " + to_string(pz));
ts = "Depth: " + to_string(pz) + " at " + to_string(TextSpeed) + "/min";
tp = scale(typeset(ts,TextFont),TextSize);
tpa = ArcText(tp,DiskCenter,TextRadius,-5deg,"Right");
tp = scale(typeset("Rad: " + to_string(TextRadius),TextFont),TextSize);
tpa = ArcText(tp,DiskCenter,TextRadius,180deg,"Right");
TextRadius -= TextLeading;
pz -= 0.10mm;
if (1) {
comment("Feedrate variations begin");
TextRadius = OuterRad;
ps = 250mm;
repeat(NumRings ; i) {
comment(" speed: " + to_string(ps) + "/min");
ts = "Speed: " + to_string(ps) + "/min at " + to_string(PlotZ);
tp = scale(typeset(ts,TextFont),TextSize);
tpa = ArcText(tp,DiskCenter,TextRadius,5deg,"Left");
TextRadius -= TextLeading;
ps += 250mm;
if (1) {
comment("Off-center text arcs begin");
tc = [-40mm/sqrt(2),-40mm/sqrt(2)]; // center point
r = 3mm;
s = [0.5mm,0.5mm];
ts = "Radius: " + to_string(r) + " Size: " + to_string(s);
tp = scale(typeset(ts,TextFont),s);
tpa = ArcText(tp,tc,r,0deg,"Center");
r = 5mm;
s = [1.0mm,1.0mm];
ts = "Radius: " + to_string(r) + " Size: " + to_string(s);
tp = scale(typeset(ts,TextFont),s);
tpa = ArcText(tp,tc,r,0deg,"Center");
r = 8mm;
s = [1.5mm,1.5mm];
ts = "Radius: " + to_string(r) + " Size: " + to_string(s);
tp = scale(typeset(ts,TextFont),s);
tpa = ArcText(tp,tc,r,0deg,"Center");
r = 15mm;
s = [3.0mm,3.0mm];
ts = "Radius: " + to_string(r) + " Size: " + to_string(s);
tp = scale(typeset(ts,FONT_HSCRIPT_2),s);
tpa = ArcText(tp,tc,r,0deg,"Center");
if (1) {
comment("Attribution begins");
tp = scale(typeset("Ed Nisley - KE4ZNU -",TextFont),TextSize);
tpa = ArcText(tp,DiskCenter,15mm,0deg,"Center");
tp = scale(typeset("Engraving Test Disc",TextFont),TextSize);
tpa = ArcText(tp,DiskCenter,15mm,180deg,"Center");
view raw Engraving Test.gcmc hosted with ❤ by GitHub
# Engraving test pattern generator
# Ed Nisley KE4ZNU - 2019-08
Flags='-P 3 --pedantic'
# Set these to match your file layout
Prolog='/mnt/bulkdata/Project Files/CNC 3018-Pro Router/Patterns/gcmc/prolog.gcmc'
Epilog='/mnt/bulkdata/Project Files/CNC 3018-Pro Router/Patterns/gcmc/epilog.gcmc'
Script='/mnt/bulkdata/Project Files/CNC 3018-Pro Router/Patterns/Engraving Test.gcmc'
ts=$(date +%Y%m%d-%H%M%S)
echo Output: $fn
rm -f $fn
echo "(File: "$fn")" > $fn
/opt/gcmc/src/gcmc -D $Diameter $Flags \
--include "$LibPath" --prologue "$Prolog" --epilogue "$Epilog" \
"$Script" >> $fn
view raw Engraving hosted with ❤ by GitHub