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.

Tag: Improvements

Making the world a better place, one piece at a time

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

  • American Standard Elite Kitchen Faucet: Hot Limit Safety Stop FAIL

    During an evening KP session, the kitchen faucet handle jammed at the clockwise (hottest) end of its travel and refused to turn; it continued to move vertically and I turned off the water. This had happened before, so I knew roughly what to expect:

    Am Std Elite Faucet - misaligned hot limit stop

    The pointer on the red hot limit safety stop ring should be aimed just right of the front screw, at the 0 position producing maximum hotness. The scale reads backwards, perhaps in units of increasing safety.

    In that position, the ring prevents the valve core from turning counterclockwise, which explains the symptoms. With the water turned off (at the ball valves in the basement) and the valve stub tilted vertically, the ring popped loose (it shouldn’t move on its own) and exposed the problem:

    Am Std Elite Faucet - wrecked hot limit splines - as found
    Am Std Elite Faucet – wrecked hot limit splines – as found

    Neither Mary nor I recall applying that much force to the handle, but ya never know.

    The flanges protruding from the stem prevent you from removing the ring, but a pair of small diagonal cutters will chop right through the plastic. If you’re one of the six people depending on the limit stop to keep the water temperature under control, you probably don’t want to cut the ring out; I have no suggestions on how to repair it.

    It’s obvious the splines won’t ever be the same again:

    Am Std Elite Faucet - wrecked hot limit splines - detail 1
    Am Std Elite Faucet – wrecked hot limit splines – detail 1

    The ring has two sets of splines and they’re both wrecked:

    Am Std Elite Faucet - wrecked hot limit splines - detail 2
    Am Std Elite Faucet – wrecked hot limit splines – detail 2

    With the ring out of the way, it’s easy to see the trunnion shaft has moved leftward:

    Am Std Elite Faucet - misaligned pivot shaft
    Am Std Elite Faucet – misaligned pivot shaft

    There’s essentially no clearance between the shaft and the ring, so it was rubbing against the ring, as evidenced by the red debris left behind when I tapped it to the far end of its travel:

    Reassemble in reverse order and it works fine again.

    I expect the shaft will resume moving leftward and eventually jam in the notch, probably after abrading the white plastic, but I don’t see how to lock it in place.

  • Windows-free BIOS Update

    A new-to-me Dell Optiplex 9020 needed a BIOS update, which, as always, arrives in a Windows / DOS EXE file. Because I’d already swapped in an SSD and installed Manjaro, I had to (re-)discover how to put the EXE file on a bootable DOS USB stick.

    The least horrible way seemed to be perverting a known-good FreeDOS installation image:

    sha256sum FD12FULL.zip 
    fd353f20f509722e8b73686918995db2cd03637fa68c32e30caaca70ff94c6d2  FD12FULL.zip

    Unzip it to get the USB image file, then find the partition offset:

    fdisk -l FD12FULL.img
    Disk FD12FULL.img: 512 MiB, 536870912 bytes, 1048576 sectors
    Units: sectors of 1 * 512 = 512 bytes
    Sector size (logical/physical): 512 bytes / 512 bytes
    I/O size (minimum/optimal): 512 bytes / 512 bytes
    Disklabel type: dos
    Disk identifier: 0x00000000
    
    Device        Boot Start     End Sectors   Size Id Type
    FD12FULL.img1 *       63 1048319 1048257 511.9M  6 FAT16

    Mount the partition as a loop device:

    sudo mount -o loop,offset=$((63*512)),uid=ed FD12FULL.img /mnt/loop

    See how much space is left:

    df -h /mnt/loop
    Filesystem      Size  Used Avail Use% Mounted on
    /dev/loop0      512M  425M   87M  84% /mnt/loop

    The image file is 512 MB and has 87 MB available. The BIOS file is 9.5 MB, so copy the file to the “drive”:

    cp O9020A25.exe /mnt/loop

    Which knocks the available space down by about what you’d expect:

    df -h /mnt/loop
    Filesystem      Size  Used Avail Use% Mounted on
    /dev/loop0      512M  435M   78M  85% /mnt/loop

    Unmount the image “drive”:

    sudo umount /mnt/loop

    Copy the image file to a USB stick:

    sudo dcfldd status=progress bs=1M if=FD12FULL.img of=/dev/sdg
    512 blocks (512Mb) written.
    512+0 records in
    512+0 records out

    Pop the USB stick in the Optiplex, set the BIOS to boot from “Legacy” ROMs, whack F12 during the reboot, pick the USB stick from the list, and It Just Works™:

    BIOS Update screen
    BIOS Update screen

    We have a couple of other 9020s around that need the same treatment, so the effort won’t go to waste.

  • GCMC: Circular Slide Rule Scales

    The Tektronix Circuit Computer, being a specialized circular slide rule, requires logarithmic scales bent around arcs:

    Scale Tick Layout - Bottom Deck
    Scale Tick Layout – Bottom Deck

    Each decade spans 18°, except for the FL scale’s 36° span to extract the square root of the LC product:

    FL = 1 / (2π · sqrt(LC))

    The tick marks can point inward or outward from their baseline radius, with corresponding scale labels reading either inward or outward.

    There being no (easy) way to algorithmically set the tick lengths, I used a (pair of) tables (a.k.a. vector lists):

    TickScaleNarrow = {
      [1.0,TickMajor],
      [1.1,TickMinor],[1.2,TickMinor],[1.3,TickMinor],[1.4,TickMinor],
      [1.5,TickMid],
      [1.6,TickMinor],[1.7,TickMinor],[1.8,TickMinor],[1.9,TickMinor],
      [2.0,TickMajor],
      [2.2,TickMinor],[2.4,TickMinor],[2.6,TickMinor],[2.8,TickMinor],
      [3.0,TickMajor],
    … and so on …

    The first number in each vector is the tick value in the decade, the log of which corresponds to its angular position. The second gives its length, with three constants matching up to the actual lengths on the Tek scales.

    The Circuit Computer labels only three ticks within each decade in the familiar (to EE bears, anyhow) 1, 2, 5 sequence. Their logs are 0.0, 0.3, and 0.7, spacing them neatly at the 1/3 decade points.

    Pop quiz: If you wanted to label two evenly spaced ticks per decade, you’d mark 1 and …

    Generating the L (inductance) scale on the bottom deck goes like this:

      Radius = DeckRad - ScaleSpace;
    
      MinLog = -9;
      MaxLog = 6;
      Arc = -ScaleArc;
    
      dec = 1;
      offset = 0deg;
      for (logval = MinLog; logval < MaxLog; logval++) {
        a = offset + logval * Arc;
        DrawTicks(Radius,TickScaleNarrow,OUTWARD,a,Arc,dec,INWARD,FALSE);
        dec = (dec == 100) ? 1 : 10 * dec;
      }
    
      a = offset + MaxLog * Arc;
      DrawTicks(Radius,TickScaleNarrow,OUTWARD,a,Arc,100,INWARD,TRUE);

    The L scale covers 1 nH to 1 MH (!), as set by the MinLog and MaxLog values. Arc sets the angular size of each decade from ScaleArc, with the negative sign indicating the values increase in the clockwise direction.

    The first decade starts with a tick labeled 1, so dec = 1. The next decade has dec = 10 and the third has dec = 100. Maybe I should have used the log values 0, 1, and 2, but that seemed too intricate.

    The angular offset is zero because this is the outermost scale, so 1.0 H will be at 0° (the picture is rotated about half a turns, so you’ll find it off to the left). All other scales on the deck have a nonzero offset to put their unit tick at the proper angle with respect to this one.

    The scales have legends for each group of three decades, positioned in the middle of the group:

      logval = MinLog + 1.5;
      a = offset + logval * Arc;
      ArcLegend("nH - nanohenry  x10^-9",r,a,INWARD);
    
      logval += 3;
      a = offset + logval * Arc;
      ArcLegend("μH - microhenry  x10^-6",r,a,INWARD);

    I wish there were a clean way to draw exponents, as the GCMC Hershey font does not include superscripts, but the characters already live at the small end of what’s do-able with a ballpoint pen cartridge. Engraving will surely work better, but stylin’ exponents are definitely in the nature of fine tuning.

    With all that in hand, the scales look just like they should:

    Tektronix Circuit Computer - Bottom Deck - scale detail
    Tektronix Circuit Computer – Bottom Deck – scale detail

    The GCMC source code as a GitHub Gist:

    //—-
    // Define tick layout for scales
    // Numeric value for scale, corresponding tick length
    TickScaleNarrow = {
    [1.0,TickMajor],
    [1.1,TickMinor],[1.2,TickMinor],[1.3,TickMinor],[1.4,TickMinor],
    [1.5,TickMid],
    [1.6,TickMinor],[1.7,TickMinor],[1.8,TickMinor],[1.9,TickMinor],
    [2.0,TickMajor],
    [2.2,TickMinor],[2.4,TickMinor],[2.6,TickMinor],[2.8,TickMinor],
    [3.0,TickMajor],
    [3.2,TickMinor],[3.4,TickMinor],[3.6,TickMinor],[3.8,TickMinor],
    [4.0,TickMajor],
    [4.5,TickMinor],
    [5.0,TickMajor],
    [5.5,TickMinor],
    [6.0,TickMajor],
    [6.5,TickMinor],
    [7.0,TickMajor],
    [7.5,TickMinor],
    [8.0,TickMajor],
    [8.5,TickMinor],
    [9.0,TickMajor],
    [9.5,TickMinor]
    };
    TickScaleWide = {
    [1.0,TickMajor],
    [1.1,TickMinor],[1.2,TickMinor],[1.3,TickMinor],[1.4,TickMinor],
    [1.5,TickMid],
    [1.6,TickMinor],[1.7,TickMinor],[1.8,TickMinor],[1.9,TickMinor],
    [2.0,TickMajor],
    [2.1,TickMinor],[2.2,TickMinor],[2.3,TickMinor],[2.4,TickMinor],
    [2.5,TickMid],
    [2.6,TickMinor],[2.7,TickMinor],[2.8,TickMinor],[2.9,TickMinor],
    [3.0,TickMajor],
    [3.2,TickMinor],[3.4,TickMinor],[3.6,TickMinor],[3.8,TickMinor],
    [4.0,TickMajor],
    [4.2,TickMinor],[4.4,TickMinor],[4.6,TickMinor],[4.8,TickMinor],
    [5.0,TickMajor],
    [5.5,TickMinor],
    [6.0,TickMajor],
    [6.5,TickMinor],
    [7.0,TickMajor],
    [7.5,TickMinor],
    [8.0,TickMajor],
    [8.5,TickMinor],
    [9.0,TickMajor],
    [9.5,TickMinor]
    };
    TickLabels = [1,2,5]; // labels only these ticks, must be integers
    /—–
    // Draw a decade of ticks & labels
    // ArcLength > 0 = CCW, < 0 = CW
    // UnitOnly forces just the unit tick, so as to allow creating the last tick of the scale
    function DrawTicks(Radius,TickMarks,TickOrient,UnitAngle,ArcLength,Decade,LabelOrient,UnitOnly) {
    feedrate(ScaleSpeed);
    local a,r0,r1,p0,p1;
    if (Decade == 1 || UnitOnly) { // draw unit marker
    a = UnitAngle;
    r0 = Radius + TickOrient * (TickMajor + 2*TickGap + ScaleTextSize.y);
    p0 = r0 * [cos(a),sin(a)];
    r1 = Radius + TickOrient * (ScaleSpace – 2*TickGap);
    p1 = r1 * [cos(a),sin(a)];
    goto(p0);
    move([-,-,EngraveZ]);
    move(p1);
    goto([-,-,TravelZ]);
    }
    local ticklist = UnitOnly ? {TickMarks[0]} : TickMarks;
    local tick;
    foreach(ticklist; tick) {
    a = UnitAngle + ArcLength * log10(tick[0]);
    p0 = Radius * [cos(a), sin(a)];
    p1 = (Radius + TickOrient*tick[1]) * [cos(a), sin(a)];
    goto(p0);
    move([-,-,EngraveZ]);
    move(p1);
    goto([-,-,TravelZ]);
    }
    feedrate(TextSpeed); // draw scale values
    local lrad = Radius + TickOrient * (TickMajor + TickGap);
    if (TickOrient == INWARD) {
    if (LabelOrient == INWARD) {
    lrad -= ScaleTextSize.y; // inward ticks + inward labels = offset inward
    }
    }
    else {
    if (LabelOrient == OUTWARD) {
    lrad += ScaleTextSize.y; // outward ticks + outward labels = offset outward
    }
    }
    ticklist = UnitOnly ? [TickLabels[0]] : TickLabels;
    local ltext,lpath,tpa;
    foreach(ticklist; tick) {
    ltext = to_string(Decade * to_int(tick));
    lpath = scale(typeset(ltext,TextFont),ScaleTextSize);
    a = UnitAngle + ArcLength * log10(tick);
    tpa = ArcText(lpath,[0mm,0mm],lrad,a,TEXT_CENTERED,LabelOrient);
    engrave(tpa,TravelZ,EngraveZ);
    }
    }
  • LED Floor Lamp UI Improvement

    A new floor lamp arrived with the usual dark-gray-on-black annotations on an absolutely non-tactile pair of capacitive controls. For a device intended for use in a dim room, this makes little sense, unless you’re both trendy and concerned about manufacturing costs.

    A strip of 1/4 inch Kapton tape added just enough tactility to find the damn buttons without looking at the lamp head:

    Teckin floor lamp - tactile switch tape
    Teckin floor lamp – tactile switch tape

    The pole’s non-adjustable length put the lamp head well above eye level, so I removed one pole segment. This required cutting the 12 V zipcord and crimping a pair of connectors:

    Teckin floor lamp - spliced wire
    Teckin floor lamp – spliced wire

    I briefly considered conjuring a skinny connector, but came to my senses: there’s plenty of zipcord if I must chop out the connectors, particularly seeing as how shortening the pole added a foot.

    The setscrew at the bottom of the gooseneck crunched the zipcord against the metal shell. A polypropylene snippet made me feel better, even if it makes no difference:

    Teckin floor lamp - wire clamp pad
    Teckin floor lamp – wire clamp pad

    After all that, It Just Worked™:

    Teckin floor lamp - installed
    Teckin floor lamp – installed

    Done!

  • GCMC Radial Text

    The Tektronix Circuit Computer needs text along radial lines:

    Tek CC - original RC arrow layout
    Tek CC – original RC arrow layout

    Fortunately, this doesn’t require nearly as much effort as the text-on-arcs code, because GCMC includes functions to rotate paths around the origin:

    return rotate_xy(TextPath,Angle) + CenterPt;

    The only trick is figuring out how to handle the justification, given the overall path length:

      local pl = TextPath[-1].x;
    
      local ji = (Justify == TEXT_LEFT)     ? 0mm :
                 (Justify == TEXT_CENTERED) ? -pl/2 :
                 (Justify == TEXT_RIGHT)    ? -pl :
                 0mm;

    A testcase showed it worked:

    Radial text testcase
    Radial text testcase

    With that in hand, I took the liberty of slightly simplifying the original Tek layout:

    Tek CC - radial text example
    Tek CC – radial text example

    If lives depended on it, one could duplicate the Tek layout, but they don’t and I didn’t. Fancy typography isn’t a GCMC thing.

    And, yeah, laser printing is way crisper than a pen drawing.

    The GCMC source code as a GitHub Gist:

    comment("RadialText test");
    ctr = [0mm,0mm];
    r = 20mm;
    a = 0deg;
    tp = scale(typeset("Left Inward",TextFont),LegendTextSize);
    tpr = RadialText(tp,ctr,r,a,TEXT_LEFT,INWARD);
    feedrate(TextSpeed);
    engrave(tpr,TravelZ,EngraveZ);
    tp = scale(typeset("Left Outward",TextFont),LegendTextSize);
    tpr = RadialText(tp,ctr,r,a,TEXT_LEFT,OUTWARD);
    feedrate(TextSpeed);
    engrave(tpr,TravelZ,EngraveZ);
    a = 90deg;
    tp = scale(typeset("Right Inward",TextFont),LegendTextSize);
    tpr = RadialText(tp,ctr,r,a,TEXT_RIGHT,INWARD);
    feedrate(TextSpeed);
    engrave(tpr,TravelZ,EngraveZ);
    tp = scale(typeset("Right Outward",TextFont),LegendTextSize);
    tpr = RadialText(tp,ctr,r,a,TEXT_RIGHT,OUTWARD);
    feedrate(TextSpeed);
    engrave(tpr,TravelZ,EngraveZ);
    a = 180deg;
    tp = scale(typeset("Center Inward",TextFont),LegendTextSize);
    tpr = RadialText(tp,ctr,r,a,TEXT_CENTERED,INWARD);
    feedrate(TextSpeed);
    engrave(tpr,TravelZ,EngraveZ);
    tp = scale(typeset("Center Outward",TextFont),LegendTextSize);
    tpr = RadialText(tp,ctr,r,a,TEXT_CENTERED,OUTWARD);
    feedrate(TextSpeed);
    engrave(tpr,TravelZ,EngraveZ);
    a = 270deg;
    RadialLegend("Offset to radius",ctr,r,a,TEXT_CENTERED,INWARD,-0.5);
    goto(ctr);
    move([0,-2*r,EngraveZ]);
    goto([r,0mm,-]);
    circle_cw(ctr);
    //—–
    // Write text on a radial line
    function RadialText(TextPath,CenterPt,Radius,Angle,Justify,Orient) {
    local pl = TextPath[-1].x; // path length
    local ji = (Justify == TEXT_LEFT) ? 0mm : // justification indent
    (Justify == TEXT_CENTERED) ? -pl/2 :
    (Justify == TEXT_RIGHT) ? -pl :
    0mm;
    if (Orient == INWARD) {
    TextPath = rotate_xy(TextPath,180deg);
    ji = -ji;
    }
    TextPath += [Radius + ji,0mm];
    return rotate_xy(TextPath,Angle) + CenterPt;
    }
    //—–
    // Draw a radial legend
    // Offset in units of char height: 0 = baseline on radius, +/- = above/below
    function RadialLegend(Text,Center,Radius,Angle,Justify,Orient,Offset) {
    local tp = scale(typeset(Text,TextFont),LegendTextSize) + [0mm,Offset * LegendTextSize.y];
    local tpr = RadialText(tp,Center,Radius,Angle,Justify,Orient);
    feedrate(TextSpeed);
    engrave(tpr,TravelZ,EngraveZ);
    }
  • GCMC Text on Arcs: Improved Version

    The Tektronix Circuit Computer scale annotations read both inward (from the center) and outward (from the rim):

    Text on Arcs - orientation
    Text on Arcs – orientation

    It’s surprisingly difficult (for me, anyhow) to see the middle FL Scale as reading upside-down, rather than mirror-image backwards.

    This turned into a rewrite of the the read-outward annotation code I used for the vacuum tube reflectors. Eventually the justification and orientation options came out right:

    Text-on-arcs example
    Text-on-arcs example

    The text baseline sits at the specified radius from the center point, regardless of its orientation, so you must offset the text path by half its height in the proper direction before handing it to the ArcText function.

    The testcase shows the invocation ritual:

        ctr = [0mm,0mm];
    
        tp = scale(typeset("Right Inward",TextFont),ScaleTextSize);
        tpa = ArcText(tp,ctr,30mm,45deg,TEXT_RIGHT,INWARD);
        engrave(tpa,TravelZ,EngraveZ);
        tp = scale(typeset("Right Outward",TextFont),ScaleTextSize);
        tpa = ArcText(tp,ctr,30mm,45deg,TEXT_RIGHT,OUTWARD);
        engrave(tpa,TravelZ,EngraveZ);
    
        tp = scale(typeset("Center Inward",TextFont),ScaleTextSize);
        tpa = ArcText(tp,ctr,20mm,45deg,TEXT_CENTERED,INWARD);
        engrave(tpa,TravelZ,EngraveZ);
        tp = scale(typeset("Center Outward",TextFont),ScaleTextSize);
        tpa = ArcText(tp,ctr,20mm,45deg,TEXT_CENTERED,OUTWARD);
        engrave(tpa,TravelZ,EngraveZ);
    
        tp = scale(typeset("Left Inward",TextFont),ScaleTextSize);
        tpa = ArcText(tp,ctr,10mm,45deg,TEXT_LEFT,INWARD);
        engrave(tpa,TravelZ,EngraveZ);
        tp = scale(typeset("Left Outward",TextFont),ScaleTextSize);
        tpa = ArcText(tp,ctr,10mm,45deg,TEXT_LEFT,OUTWARD);
        engrave(tpa,TravelZ,EngraveZ);
    
        goto([0mm,0mm,-]);
        move([40mm,40mm,-]);

    A utility function to draw scale legends stuffs some of that complexity into a bottle:

    function ArcLegend(Text,Radius,Angle,Orient) {
    
      local tp = scale(typeset(Text,TextFont),LegendTextSize);
      local tpa = ArcText(tp,[0mm,0mm],Radius,Angle,TEXT_CENTERED,Orient);
    
      feedrate(TextSpeed);
      engrave(tpa,TravelZ,EngraveZ);
    }

    Which means most of the text uses a simpler invocation:

      r = Radius + TickMajor + 2*TickGap + LegendTextSize.y;
    
      logval = MinLog + 1.5;
      a = offset + logval * Arc;
      ArcLegend("nH - nanohenry  x10^-9",r,a,INWARD);
    
      logval += 3;
      a = offset + logval * Arc;
      ArcLegend("μH - microhenry  x10^-6",r,a,INWARD);
    

    Arc determines the angular span of each decade, with positive values going counterclockwise. MinLog is the logarithm of the scale endpoint, so adding 1.5 puts the text angle one-and-a-half decades from MinLog and multiplying by Arc moves it in the right direction. The offset angle rotates the entire scale with respect to the 0° reference sticking out the X axis over on the right. The top picture has its 0° reference pointing north-northeast.

    The GCMC source code as a GitHub Gist:

    INWARD = -1; // text and tick alignment (used as integers)
    OUTWARD = 1;
    TEXT_LEFT = -1; // text justification
    TEXT_CENTERED = 0;
    TEXT_RIGHT = 1;
    //—–
    // Bend text around an arc
    function ArcText(TextPath,CenterPt,Radius,BaseAngle,Justify,Orient) {
    local pl = TextPath[-1].x; // path length
    local c = 2*pi()*Radius;
    local ta = to_deg(360 * pl / c); // subtended angle
    local ja = (Justify == TEXT_LEFT ? 0deg : // assume OUTWARD
    (Justify == TEXT_CENTERED) ? -ta / 2 :
    (Justify == TEXT_RIGHT) ? -ta :
    0deg);
    ja = BaseAngle + Orient*ja;
    local ArcPath = {};
    local pt,r,a;
    foreach(TextPath; pt) {
    if (!isundef(pt.x) && !isundef(pt.y) && isundef(pt.z)) { // XY motion, no Z
    r = (Orient == OUTWARD) ? Radius – pt.y : Radius + pt.y;
    a = Orient * 360deg * (pt.x / c) + ja;
    ArcPath += {[r*cos(a) + CenterPt.x, r*sin(a) + CenterPt.y,-]};
    }
    elif (isundef(pt.x) && isundef(pt.y) && !isundef(pt.z)) { // no XY, Z up/down
    ArcPath += {pt};
    }
    else {
    error("ArcText – Point is not pure XY or pure Z: " + to_string(pt));
    }
    }
    return ArcPath;
    }

    GCMC treats variables defined inside a function as local, unless they’re already defined in an enclosing scope, whereupon you overwrite the outer variables. This wasn’t a problem in my earlier programs, but I fired the footgun with nested functions using the same local / temporary variables. Now, I ruthlessly declare truly local variables as local, except when I don’t, for what seem good reasons at the time.