Posts Tagged MPCNC
MPCNC Drag Knife Holder: Lock Screw
Posted by Ed in Machine Shop on 2020-01-21
While calibrating the MPCNC’s probe camera offset for the drag knife holder, this happened:
Well, at least it’s centered on the target:
This happened a few times before, because my fingers don’t fit neatly inside the drag knife holder to tighten the lock ring:
[Update: The lock ring keeps the holder at a fixed position inside the 12 mm shaft and doesn’t affect the blade directly. When the ring works loose, the threaded holder can rotate to expose more blade and, in this case, stab deeper into the target. ]
So I turned & knurled an aluminum ring, then tapped a 3×0.5 mm hole for a lock screw plucked from the Drawer o’ Random M3 Screws:
A view looking along the screw shows a bit more detail around the spring:
The general idea is to set the blade extension, then tighten the lock screw to hold it in place, without relying on the original brass lock ring, shown here while cutting a boss for the spring:
The lock screw’s knurled handle just barely kisses the NPCNC’s black tool holder ring, so my guesstimated measurements were a bit off. Clamping the knife holder one itsy higher in the tool holder solved the problem.
I cranked on 300 g of spring preload and, squashed like that, the spring’s rate is now 75 g/mm. Cutting at Z=-1 mm should suffice for laminated paper slide rule decks.
The original sizing doodle:
The short 18 mm section clears the inside of the LM12UU bearing, although it could be a millimeter shorter. The 19 mm section comes from the 3/4 inch aluminum rod I used, skim-cut to clean it up.
If I ever remake this thing, it needs a major re-think to get all the dimensions flying in formation again.
Raspberry Pi: Adding a PIXEL Desktop Launcher
Posted by Ed in Machine Shop, PC Tweakage, Software on 2019-12-31
The Raspberry Pi’s Raspbian PIXEL Desktop UI (not to be confused with the Google Pixel phone) descends from LXDE, with all the advantages & disadvantages that entails. One nuisance seems to be the inability to create a launcher for a non-standard program.
The stock task bar (or whatever it’s called) has a few useful launchers and you can add a launcher for a program installed through the usual Add/Remove Software function, as shown by the VLC icon:
Adding a bCNC launcher requires a bit of legerdemain, because it’s not found in the RPi repositories. Instead, install bCNC according to its directions:
… install various pre-requisites as needed …
pip2 install --upgrade git+https://github.com/vlachoudis/bCNC Which is also how you upgrade to the latest & greatest version, as needed.
You then launch bCNC from inside a terminal:
python2 -m bCNCThe installation includes all the bits & pieces required to create a launcher; they’re just not in the right places.
So put them there:
sudo cp ./.local/lib/python2.7/site-packages/bCNC/bCNC.png /usr/share/icons/
sudo cp .local/lib/python2.7/site-packages/bCNC/bCNC.desktop /usr/share/applications/bCNC.desktopThe bCNC.desktop file looks like this:
[Desktop Entry]
Version=1.0
Type=Application
Name=bCNC
Comment=bCNC Controller
Exec=bCNC
Icon=bCNC.png
Path=
Terminal=true
StartupNotify=false
Name[en_US]=bCNCSet Terminal=false if you don’t want a separate terminal window and don’t care about any of the messages bCNC writes to the console during its execution. However, those messages may provide the only hint about happened as bCNC falls off the rails.
With all that in place, it turns out LXDE creates a user-specific panel configuration file only when you change the default system panel configuration. Add a VLC launcher to create the local ~/.config/lxpanel/LXDE-pi/panels/panel file.
With that ball rolled, then add the bCNC launcher:
nano .config/lxpanel/LXDE-pi/panels/panel
… add this stanza …
Plugin {
type=launchbar
Config {
Button {
id=bCNC.desktop
}
}
}Log out, log back in again, and the bCNC icon should appear:
Click it and away you go:
At least you (and I) will start closer to the goal when something else changes …
Drag Knife Cuttery: Entry & Exit Moves
Posted by Ed in Machine Shop, Software on 2019-12-30
The first pass at cutting laminated decks for the Homage Tektronix Circuit Computer left little uncut snippets at the starting point of the cut. The point of the drag knife blade trundles along behind the cutting edge and, when the ending point equals the starting point, leaves an un-cut sliver as it’s retracted vertically:
The knife blade isn’t aligned in any particular direction, so it can leave a nick on either side as it enters the deck vertically at the start of the cut.
Gradually entering the deck along the cut line gives the blade enough time to swivel around to the proper alignment before it gets down to serious cutting. Continuing the final cut past the starting point then allows the blade to recut anything remaining from the entry move.
The middle and top decks have windows exposing the scales:
The paths are basically two arcs connected by semicircular cuts, but with ramps on each end recutting the entry and exit paths:
The entry path in the upper left slants downward from the TravelZ level of 1.5 (-ish) mm to Z=0, with the nose of the blade holder flush against the surface and the blade sunk to its full length. The vertical path to Z=-2 (-ish) increases the cutting pressure from roughly the preload value to preload + 2*(spring rate), so the blade won’t ride up under the cutting forces.
The path then goes completely around the window at Z=-2, then ramps up to the TravelZ level again.
All of which produces a neat cutout that sticks to the Cricut mat when I peel the rest of the deck off:
That’s a middle deck before I started laminating them, but you get the general idea.
The GCMC code (extracted from the complete lump) looks like this:
local WindowArc = 54deg;
local ac = -17 * ScaleArc + ScaleRT/2; // 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
p0 = r0 * [cos(ac + aw/2),sin(ac + aw/2),-];
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(p3);
arc_cw(p0 +| [-,-,0],ScaleHeight/2); // blade enters surface
move([-,-,KnifeZ]); // apply pressure
arc_cw(p1,r0); // smallest arc
arc_cw(p2,ScaleHeight/2); // half a circle
arc_ccw(p3,r1);
arc_cw(p0,ScaleHeight/2);
arc_cw(p1 +| [-,-,TravelZ],r0); // exit from cut
goto([0,0,-]);
goto([-,-,SafeZ]);Having measured the angular position of the window and its size on the original Tek CC, I compute the coordinates of the four points where the semicircular “end caps” meet the longer arcs, then connect the dots with arc_xx() functions to generate the G-Code commands. As always, using the proper radius signs requires trial & error.
While I was at it, I added entry & exit moves for the deck’s central pivot hole and outer perimeter.
I’m pretty sure the right CAM package would take care of that, but GCMC operates well below the CAM level.
Homage Tektronix Circuit Computer: Pen Plotter Version
Posted by Ed in Electronics Workbench, Machine Shop, Software on 2019-12-23
A reproduction circular slide rule from the mid-1960s may not be the cutting edge of consumer demand, but the pen version of a Tektronix Circuit Computer came out pretty well:
A Bash script compiles the GCMC code with eight different parameter combinations to produce pairs of G-Code files to draw (“engrave” being aspirational) and cut (“mill”, likewise) the three decks and the cursor.
The CNC 3018XL with a Pilot V5RT pen draws the deck scales on white paper:
Better paper definitely produces better results, so I must rummage through the Big Box o’ Paper to see what lies within. Laminating the decks improves their durability and matches the original Tek surface finish.
The MPCNC with a drag knife blade cuts through a laminated deck like butter:
Setting the XY origin to dead center on each deck requires carefully calibrating the USB video camera, with the end result accurate to maybe ±0.1 mm around the entire perimeter. Both machines move equal linear distances along both axes, which was definitely comforting.
Having made half a dozen cursors from various bits of acrylic, none of which look particularly good, demonstrates my engraving hand is too weak for a complete slide rule:
With logarithmic scales in hand, however, adapting the GCMC source code to produce general-purpose circular slide rules with only two decks and smaller diameters may be the way to improve my engraving-fu, as a full-scale Tektronix Circuit Computer would chew up three square-foot plastic sheets.
A general-purpose slide rule would need multi-color (well, at least bi-color) labels and digits for red “inverse” scales to remind you (well, me) they read backwards. Some slipsticks use left-slanting italics, left-pointing markers (“<2”), or other weirdness, but they’re all different.
An early small-scale version engraved on ABS came out OK, modulo poor ink fill:
Engraving the decks on hard drive platters doesn’t count:
All in all, it’s been an interesting exercise and, as you may have guessed, will become a Digital Machinist column.
The GCMC and Bash source code as a GitHub Gist:
MPCNC Drag Knife Holder: Showing More Blade
Posted by Ed in Machine Shop on 2019-12-12
Attempting to cut laminated cardstock decks for the Homage Tektronix Circuit Computer required a bit more blade extension than my LM12UU holder made available:
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:
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
Posted by Ed in Machine Shop, Software on 2019-12-09
Creating a paper version of the Tektronix Circuit Computer requires nothing more than a drag knife to cut the deck outlines:
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:
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 cornerThe 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:
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.103Cutting 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:
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
Posted by Ed in Amateur Radio, Electronics Workbench, Machine Shop, Oddities on 2019-11-22
Following a linkie I can no longer find led me to retrieve the Tektronix Circuit Computer in my Box o’ Slide Rules:
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:
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:
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:
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:
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:
Musings on the parameters of each scale:
How to draw decades of tick marks:
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 …
Blowback