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: Laser Cutter

  • Poured Epoxy Coaster: Proof of Concept

    Poured Epoxy Coaster: Proof of Concept

    Although I’m getting better about fitting laser-cut pieces into frames, it occurred to me that mashing colored epoxy together with coaster-shaped scrap acrylic might be interesting:

    Acrylic Coaster - epoxy petals
    Acrylic Coaster – epoxy petals

    I eased a thin bead of clear epoxy along the frame sash, using less than I thought necessary, and aligned it atop the base plate:

    Acrylic Coaster - frame epoxy
    Acrylic Coaster – frame epoxy

    The excess epoxy formed fillets along the petals, a little oozed out the perimeter, and even less smeared on the top surface. The scrap acrylic didn’t have a surface mask, but that’s definitely a Good Idea for the next attempt.

    Two drops of transparent red tinted the remainder of the epoxy well enough:

    Acrylic Coaster - first color pour
    Acrylic Coaster – first color pour

    The clear epoxy was still liquid (which is why the red epoxy was still pourable!), but the red tint stayed atop the fillet around the spot.

    The next day:

    Acrylic Coaster - epoxy coloring
    Acrylic Coaster – epoxy coloring

    Obviously, coloring epoxy for a single coaster makes absolutely no sense whatsoever, but ya gotta start somewhere.

    You (well, I) can suck most of the inevitable bubbles out of the epoxy back into the dispensing pipette, but those last few bubbles will remain forever. Popping bubbles by waving a propane torch flame over the surface seems better-suited to tabletop-scale projects not involving an acrylic frame.

    The epoxy puddles are about 1 mm deep inside the 2.5 mm thick frame, so (if this were a real coaster) the sashes between the petals would support the chilled mug and the petals would collect all the condensation.

    Thicker epoxy would have more saturated colors and a white base plate might be in order.

  • Coaster Generator: Simple Petals

    Coaster Generator: Simple Petals

    Having figured out how to intersect a line with a circle, I figured I could do it twice to put arcs on both the inside and the outside of each petal:

    Chipboard coaster - double arcs
    Chipboard coaster – double arcs

    As before, scribbling markers on plain chipboard makes for a … subdued … coaster, so I tried chipboard with one white surface:

    Chipboard coaster - plain vs white
    Chipboard coaster – plain vs white

    Much better.

    Clamping the coaster produces a flatter result:

    Chipboard coaster - clamping
    Chipboard coaster – clamping

    With the risk of squishing excess glue through the kerf:

    Chipboard coaster - excess glue
    Chipboard coaster – excess glue

    That’s the same coaster as in the first picture, carefully arranged with light reflecting off the flat glue surface. In real life, the nearly transparent glue doesn’t look nearly so awful, but smoothing much less glue than seems necessary across the bottom disk suffices.

    The geometry doodle with the arcs:

    Chipboard coaster - double arc petal geometry doodle
    Chipboard coaster – double arc petal geometry doodle

    I suppose I should refactor the code with a quadratic solver returning a list of roots, but copypasta suffices for now.

    The GCMC and Bash source code as a GitHub Gist:

    #!/bin/bash
    # Simple petals test piece
    # Ed Nisley KE4ZNU – 2022-07-01
    Flags='-P 4 –pedantic' # quote to avoid leading hyphen gotcha
    SVGFlags='-P 4 –pedantic –svg –svg-no-movelayer –svg-opacity=1.0 –svg-toolwidth=0.2'
    # Set these to match your file layout
    ProjPath='/mnt/bulkdata/Project Files/Laser Cutter/Coasters/Source Code'
    LibPath='/opt/gcmc/library'
    ScriptPath=$ProjPath
    Script='Simple Petals.gcmc'
    [ -z "$1" ] && petals="6" || petals="$1"
    fn=Petals-$petals.svg
    echo Output: $fn
    gcmc $SVGFlags \
    -D "NumPetals=$petals" \
    –include "$LibPath" \
    "$ScriptPath"/"$Script" > "$fn"
    view raw petals.sh hosted with ❤ by GitHub
    // Simple Petals Test Piece
    // Ed Nisley KE4ZNU
    // 2022-07-12 Simplest possible petals
    layerstack("Frame","Petals","Rim","Base","Center","Tool1"); // SVG layers map to LightBurn colors
    //—–
    // Library routines
    include("tracepath.inc.gcmc");
    include("tracepath_comp.inc.gcmc");
    include("varcs.inc.gcmc");
    include("engrave.inc.gcmc");
    FALSE = 0;
    TRUE = !FALSE;
    //—–
    // Command line parameters
    // -D various useful tidbits
    // add unit to speeds and depths: 2000mm / -3.00mm / etc
    if (!isdefined("OuterDia")) {
    OuterDia = 100.0mm;
    }
    if (!isdefined("CenterDia")) {
    CenterDia = 25.0mm;
    }
    if (!isdefined("NumPetals")) {
    NumPetals = 6;
    }
    if (!isdefined("Sash")) {
    Sash = 5.0mm;
    }
    // Petal values
    PetalAngle = 360.0deg/NumPetals; // subtended by inner sides
    PetalHA = PetalAngle/2;
    PetalOD = OuterDia – 2*Sash;
    PetalID = CenterDia + 2*Sash;
    PetalOAL = OuterDia/2 – Sash – (Sash/2)/sin(PetalHA);
    //message("petalOAL: ",PetalOAL);
    // Find petal vertices
    P0 = [(Sash/2) / sin(PetalHA),0.0mm];
    t1 = tan(PetalHA);
    sc = (Sash/2) / cos(PetalHA);
    if (P0.x < PetalID/2) {
    a = 1 + pow(t1,2);
    b = -2 * t1 * sc;
    c = pow(sc,2) – pow(PetalID/2,2);
    xp = (-b + sqrt(pow(b,2) – 4*a*c))/(2*a);
    xn = (-b – sqrt(pow(b,2) – 4*a*c))/(2*a);
    y = xp*t1 – sc;
    if (FALSE) {
    message("a: ",a);
    message("b: ",b);
    message("c: ",c);
    message("p: ",xp," n: ",xn," y: ",y);
    }
    P1 = [xp,y];
    }
    else {
    P1 = P0;
    }
    a = 1 + pow(t1,2);
    b = -2 * t1 * sc;
    c = pow(sc,2) – pow(PetalOD/2,2);
    if (FALSE) {
    message("a: ",a);
    message("b: ",b);
    message("c: ",c);
    }
    xp = (-b + sqrt(pow(b,2) – 4*a*c))/(2*a);
    xn = (-b – sqrt(pow(b,2) – 4*a*c))/(2*a);
    y = to_mm(sqrt(pow(PetalOD/2,2) – pow(xp,2)));
    //message("p: ",xp," n: ",xn," y: ",y);
    P2 = [xp,y];
    PetalWidth = 2*P2.y;
    P3 = [PetalOD/2,0.0mm];
    if (FALSE) {
    message("P0: ",P0);
    message("P1: ",P1);
    message("P2: ",P2);
    message("P3: ",P3);
    }
    // Construct paths
    PetalPoints = {P1,P2};
    OutArc = varc_cw([P2.x,-P2.y] – P2,PetalOD/2);
    OutArc += P2;
    PetalPoints += OutArc;
    if (P0 != P1) {
    PetalPoints += {[P1.x,-P1.y]};
    InArc = varc_ccw(P1 – [P1.x,-P1.y],PetalID/2);
    InArc += [P1.x,-P1.y];
    PetalPoints += InArc;
    }
    else {
    PetalPoints += {P0};
    }
    //— Lay out the frame
    linecolor(0xff0000);
    layer("Frame");
    if (CenterDia) {
    goto([CenterDia/2,0mm]);
    circle_cw([0mm,0mm]);
    }
    repeat(NumPetals;i) {
    a = (i-1)*PetalAngle;
    tracepath(rotate_xy(PetalPoints,a));
    }
    goto([OuterDia/2,0]);
    circle_cw([0mm,0mm]);
    //— Lay out internal pieces for oriented cutting
    // baseplate
    layer("Base");
    relocate([OuterDia + 2*Sash,0]);
    goto([OuterDia/2,0]);
    circle_cw([0mm,0mm]);
    // central circle
    if (CenterDia) {
    layer("Center");
    relocate([OuterDia/2 + Sash,-(OuterDia – CenterDia)/2]);
    goto([CenterDia/2,0mm]);
    circle_cw([0mm,0mm]);
    }
    // petals
    layer("Petals");
    repeat(NumPetals;i) {
    org = [PetalWidth/2 – OuterDia/2,-(OuterDia + Sash)];
    relocate([(i-1)*(PetalWidth + Sash) + org.x,org.y]);
    tracepath(rotate_xy(PetalPoints,90deg));
    }
    // Debugging by printf()
    if (FALSE) {
    layer("Tool1");
    linecolor(0xff1f00);
    goto([Sash/2,0mm]);
    circle_cw([0mm,0mm]);
    goto(P0);
    circle_cw([0mm,0mm]);
    goto([0,0]);
    move([OuterDia/2,0]);
    goto([0,0]);
    move(OuterDia/2 * [cos(PetalHA),sin(PetalHA)]);
    goto(P2);
    move_r([0,-PetalWidth/2]);
    }
  • Laser Kerf Width Test Pattern / Coaster Generator

    Laser Kerf Width Test Pattern / Coaster Generator

    Before trying to make decorative coasters from colorful acrylic, I figured a few practice sessions in chipboard would be in order:

    Chipboard coasters
    Chipboard coasters

    They’re colored with wide tip Sharpies of various ages and, as the yellow and uncolored sections show, chipboard never gets very bright. On the other paw, chipboard is also known as “beer mat”, so at least I have the right general idea.

    The patterns come from a GCMC program producing SVG figures for LightBurn to apply kerf compensation:

    Chipboard coasters - cut and color
    Chipboard coasters – cut and color

    It’s obviously too late to have me color within the lines.

    The overall frame in the upper left and the base plate in the upper right get the kerf compensation, which (for chipboard) turns out to be +0.15 mm outward (thus making the holes smaller and the diameter larger). If I were doing marquetry, I’d want to arrange each piece on a separate wood veneer sheet with proper grain orientation and similar fussiness, but that’s not the point right now.

    Without compensation, the pieces have a drop-in fit with an obvious gap:

    Coaster - chipboard - no kerf comp
    Coaster – chipboard – no kerf comp

    Adding a mere 0.15 mm on each side produces a very snug fit:

    Coaster - chipboard - frame 0.15 out
    Coaster – chipboard – frame 0.15 out

    In fact, the pieces go in from the back and require hammering gentle tapping to persuade all the corners into place.

    Protip: putting a dark color on the frame and around the edges conceals many flaws.

    Increasing the compensation to +0.20 mm means the pieces no longer fit and, when eventually battered into the frame, the surface becomes a concave-upward dish.

    With the (colored) pieces in the frame, I covered the base plate with a thin layer of good old Elmer’s Yellow Wood Glue, dropped the top over it with some attention to good alignment on all sides, and clamped the assembly between two planks for a while. Obviously, you’d want to make more than one at a time, but they’re rather labor intensive.

    The GCMC program produces the patterns from the coaster’s dimensions:

    • Outer diameter
    • Number of leaves around the center
    • Center spot diameter
    • Sash width (it’s really a muntin, but quilters say sash)
    • Leaf aspect ratio (max width / overall length)

    Due to the relentless symmetry, finding the points describing half a leaf and half the sector between two leaves suffices to generate the entire coaster by various rotations around the center. The code performs no error checking whatsoever, so some dimensions emit a hard crash rather than a coaster.

    A geometry doodle with some incorrect values:

    Coaster Geometry doodle
    Coaster Geometry doodle

    Poinr P1 (where the leaf snugs against the circular sash around the center spot) sits at the intersection of a line and a circle, so the code solves a quadratic equation with grisly coefficients:

      a = 1 + pow(tan(LeafStemHA),2);
      b = -2 * tan(LeafStemHA) * (Sash/2) / cos(LeafStemHA);
      c = pow((Sash/2) / cos(LeafStemHA),2) - pow(LeafID/2,2);
      xp = (-b + sqrt(pow(b,2) - 4*a*c))/(2*a);
      xn = (-b - sqrt(pow(b,2) - 4*a*c))/(2*a);
      y = xp*tan(LeafStemHA) - (Sash/2) / cos(LeafStemHA);
      P1 = [xp,y];
    

    Given the geometry, the “plus” root is always the one to use.

    A doodle working out that intersection, as well as for P5 out at the widest part of the leaf, carrying some errors from the geometry doodle:

    Coaster Geometry equations
    Coaster Geometry equations

    Both of those doodles have errors; the GCMC source code remains the final arbiter of coaster correctness.

    The Bash and GCMC source code as a GitHub Gist:

    #!/bin/bash
    # Marquetry test piece
    # Ed Nisley KE4ZNU – 2022-07-01
    Flags='-P 4 –pedantic' # quote to avoid leading hyphen gotcha
    SVGFlags='-P 4 –pedantic –svg –svg-no-movelayer –svg-opacity=1.0 –svg-toolwidth=0.2'
    # Set these to match your file layout
    ProjPath='/mnt/bulkdata/Project Files/Laser Cutter/Marquetry/Source Code'
    LibPath='/opt/gcmc/library'
    ScriptPath=$ProjPath
    Script='Marquetry Test Piece.gcmc'
    leaves="NumLeaves=$1"
    aspect="LeafAspect=$2"
    fn=Marq-$1-$2.svg
    echo Output: $fn
    gcmc $SVGFlags -D "$leaves" -D "$aspect" \
    –include "$LibPath" \
    "$ScriptPath"/"$Script" > "$fn"
    view raw marq.sh hosted with ❤ by GitHub
    // Marquetry Laser Cuttery Test Piece
    // Ed Nisley KE4ZNU
    // 2022-07-01 Simplest possible mandala
    layerstack("Frame","Leaves","Rim","Base","Center","Tool1"); // SVG layers map to LightBurn colors
    //—–
    // Library routines
    include("tracepath.inc.gcmc");
    include("tracepath_comp.inc.gcmc");
    include("varcs.inc.gcmc");
    include("engrave.inc.gcmc");
    FALSE = 0;
    TRUE = !FALSE;
    //—–
    // Command line parameters
    // -D various useful tidbits
    // add unit to speeds and depths: 2000mm / -3.00mm / etc
    if (!isdefined("OuterDia")) {
    OuterDia = 120.0mm;
    }
    if (!isdefined("CenterDia")) {
    CenterDia = 20.0mm;
    }
    if (!isdefined("NumLeaves")) {
    NumLeaves = 5;
    }
    if (!isdefined("Sash")) {
    Sash = 4.0mm;
    }
    if (!isdefined("LeafAspect")) {
    LeafAspect = 0.40;
    }
    // Leaf values
    LeafStemAngle = 360.0deg/NumLeaves; // subtended by inner sides
    LeafStemHA = LeafStemAngle/2;
    LeafLength = OuterDia/2 – Sash – (Sash/2)/sin(LeafStemHA);
    LeafWidth = LeafAspect*LeafLength;
    L1 = (LeafWidth/2)/tan(LeafStemHA);
    L2 = LeafLength – L1;
    // message("Len: ",LeafLength," L1: ",L1," L2: ",L2);
    LeafTipHA = to_deg(atan(LeafWidth/2,L2)); // subtended by outer sides
    LeafTipAngle = 2*LeafTipHA;
    // message("Width: ",LeafWidth);
    // message("Tip HA: ",LeafTipHA);
    LeafID = CenterDia + 2*Sash;
    LeafOD = LeafID + LeafLength;
    // message("ID: ",LeafID," OD: ",LeafOD);
    // Find leaf and rim vertices
    P0 = [(Sash/2) / sin(LeafStemHA),0.0mm];
    if (P0.x < LeafID/2) {
    a = 1 + pow(tan(LeafStemHA),2);
    b = -2 * tan(LeafStemHA) * (Sash/2) / cos(LeafStemHA);
    c = pow((Sash/2) / cos(LeafStemHA),2) – pow(LeafID/2,2);
    // message("a: ",a);
    // message("b: ",b);
    // message("c: ",c);
    xp = (-b + sqrt(pow(b,2) – 4*a*c))/(2*a);
    xn = (-b – sqrt(pow(b,2) – 4*a*c))/(2*a);
    y = xp*tan(LeafStemHA) – (Sash/2) / cos(LeafStemHA);
    // message("p: ",xp," n: ",xn," y: ",y);
    P1 = [xp,y];
    }
    else {
    P1 = P0;
    }
    P2 = P0 + [L1,LeafWidth/2];
    P3 = P0 + [LeafLength,0mm];
    P4 = P3 + [Sash/sin(LeafTipHA),0.0mm];
    P5r = P4.x * sin(LeafTipHA) / sin(180deg – LeafStemHA – LeafTipHA);
    P5 = rotate_xy([P5r,0.0mm],LeafStemHA);
    P6 = rotate_xy(P4,LeafStemAngle);
    t2 = pow(tan(-LeafTipHA),2);
    a = 1 + t2;
    b = -2 * t2 * P4.x;
    c = t2 * pow(P4.x,2) – pow(P3.x,2);
    xp = (-b + sqrt(pow(b,2) – 4*a*c))/(2*a);
    xn = (-b – sqrt(pow(b,2) – 4*a*c))/(2*a);
    y = (xp – P4.x)*tan(-LeafTipHA);
    // message("p: ",xp," n: ",xn," y: ",y);
    P4a = [xp,y];
    P6a = rotate_xy(P4a,LeafStemAngle – 2*atan(P4a.y,P4a.x));
    // message("P4a: ",P4a);
    // message("P6a: ",P6a);
    // message("P0: ",P0);
    // message("P1: ",P1);
    // message("P2: ",P2);
    // message("P3: ",P3);
    // message("P4: ",P4);
    // message("P5: ",P5);
    // message("P6: ",P6);
    // Construct paths
    LeafPoints = {P1,P2,P3,[P2.x,-P2.y],[P1.x,-P1.y]};
    if (P0 != P1) {
    StemArc = varc_ccw(P1 – [P1.x,-P1.y],LeafID/2);
    StemArc += [P1.x,-P1.y];
    LeafPoints += StemArc;
    }
    RimChord = length(P4a – P6a);
    RimThick = OuterDia/2 – Sash – length(P5);
    RimPoints = {P4a,P5,P6a};
    RimArc = varc_cw(P4a – P6a,P4a.x);
    RimArc += P6a;
    RimPoints += RimArc;
    //— Lay out the frame
    linecolor(0xff0000);
    layer("Frame");
    goto([CenterDia/2,0mm]);
    circle_cw([0mm,0mm]);
    repeat(NumLeaves;i) {
    a = (i-1)*LeafStemAngle;
    tracepath(rotate_xy(LeafPoints,a));
    }
    repeat(NumLeaves;i) {
    a = (i-1)*LeafStemAngle;
    tracepath(rotate_xy(RimPoints,a));
    }
    linecolor(0xff0000);
    goto([OuterDia/2,0]);
    circle_cw([0mm,0mm]);
    //— Lay out internal pieces for oriented cutting
    // baseplate
    layer("Base");
    relocate([OuterDia + 2*Sash,0]);
    goto([OuterDia/2,0]);
    circle_cw([0mm,0mm]);
    // central circle
    layer("Center");
    relocate([OuterDia/2 + Sash,-(OuterDia – CenterDia)/2]);
    goto([CenterDia/2,0mm]);
    circle_cw([0mm,0mm]);
    // leaves
    layer("Leaves");
    repeat(NumLeaves;i) {
    org = [LeafWidth/2 – OuterDia/2,-(OuterDia + Sash)];
    relocate([(i-1)*(LeafWidth + Sash) + org.x,org.y]);
    tracepath(rotate_xy(LeafPoints,90deg));
    }
    // rim
    layer("Rim");
    repeat(NumLeaves;i) {
    org = [-Sash,-(OuterDia + 2*Sash + RimChord/2)];
    relocate([(i-1)*(RimThick + Sash) + org.x,org.y]);
    tracepath(rotate_xy(RimPoints,180 – LeafStemHA));
    }
    // Debugging by printf()
    if (FALSE) {
    layer("Tool1");
    linecolor(0xff1f00);
    goto([Sash/2,0mm]);
    circle_cw([0mm,0mm]);
    goto(P0);
    circle_cw([0mm,0mm]);
    goto([0,0]);
    move([OuterDia/2,0]);
    goto([0,0]);
    move(OuterDia/2 * [cos(LeafStemHA),sin(LeafStemHA)]);
    goto(P2);
    move_r([0,-LeafWidth/2]);
    }
  • Gentec ED-200 Absorber Surface Damage

    Gentec ED-200 Absorber Surface Damage

    Having grossly exceeded the Gentec ED-200 maximum power spec, I wasn’t surprised to see this when I finally tucked it back in the drawer:

    Gentec ED-200 surface damage
    Gentec ED-200 surface damage

    The 0.5 mm scale suggests the damage came from a defocused 2 mm beam or the hot central part of a larger beam, but I obviously wasn’t paying enough attention at the time.

    The rest of the surface seems undamaged, so this may have been one of those inadvertent long-duration pulses or several shorter shots in one spot.

  • High Impact Art: Practical Smashed Glass Coaster

    High Impact Art: Practical Smashed Glass Coaster

    The proof of concept coaster might suffice for a shot glass, but my morning tea comes in a 20 ounce mug with a much larger footprint.

    So, back to the Basement Shop, where a laser-cut and -engraved layout guide helps arrange and carry some suitable fragments:

    Glass Coaster - Layout tray
    Glass Coaster – Layout tray

    As before, scan the bottom of the fragments and wrap selections around them:

    Coaster Layout - selected fragments
    Coaster Layout – selected fragments

    Apply the usual operations to get a suitable mask:

    Coaster Layout - fragment masks
    Coaster Layout – fragment masks

    Fire the laser to cut the chipboard test template holding the fragments, then a white octagonal acrylic base plate and a transparent acrylic layer surrounding the fragments, and:

    Glass Coaster - base epoxy setup
    Glass Coaster – base epoxy setup

    Mix up some pourable epoxy, smooth it over the base plate, squish the transparent layer atop it, use the tape (sticky side up) to hold the two layers in alignment, and gently insert the fragments:

    Glass Coaster - fragment epoxy
    Glass Coaster – fragment epoxy

    I eased some epoxy around the perimeter of each fragment with a pipette in an attempt to reduce the glass-sliver hazard:

    Glass Coaster - fragment epoxy detail
    Glass Coaster – fragment epoxy detail

    Yes, that’s on top of the protective paper, because then I can whisk the paper off to reveal the pristine surface around each fragment:

    Glass Coaster - fracture filling
    Glass Coaster – fracture filling

    As with the smaller coaster, the epoxy penetrates the fractures and reduces the shattered appearance. Mary suggests tinted epoxy would produce an interesting effect and I’ll try that the next time around.

    Because the smashed glass came from our neighbor’s lawn, it carried a bit of dirt and debris onto the playing field:

    Glass Coaster - fragment edge detail
    Glass Coaster – fragment edge detail

    Seen through the edge of the coaster, the uneven surface of the epoxy fill around the fragments shows up clearly:

    Glass Coaster - fragment edge profile
    Glass Coaster – fragment edge profile

    The top of the glass stands half a millimeter above the transparent acrylic. I knew that would happen and wanted to see how the bottom of the mug interacted with the epoxy-coated sides:

    Glass Coaster - first test
    Glass Coaster – first test

    As it turned out, the epoxy coating wasn’t quite good enough to prevent tiny slivers from chipping off and, in the cold light of day, the pale-green-ish tinted glass didn’t stand out well against the white background.

    So I taped up the perimeter, leveled the base, mixed up another batch of epoxy, added two drops of opaque black dye, and poured just enough to level the surface with the glass:

    Glass Coaster - black epoxy pour
    Glass Coaster – black epoxy pour

    Introducing the meniscus to Mr Belt Sander put a bevel around the edge and finished it off well enough:

    Glass Coaster - second test
    Glass Coaster – second test

    The Squidwrench logo looks a bit battered after three and a half years of trips through the dishwasher, although I didn’t expect it to last nearly this long.

    There’s still a slight upward tilt around the perimeter, but it meets my simple requirements and the fragments definitely look better in black. The white base sets off the fragments, but a clear plate takes advantage of their transparency; a mirror sheet might be even more interesting.

  • High-Impact Art: Smashed Glass Earrings, Proof of Concept

    High-Impact Art: Smashed Glass Earrings, Proof of Concept

    If you’re a particularly sharp person, these may accentuate your wardrobe:

    Earrings - 12mm - finished
    Earrings – 12mm – finished

    They’re fragments of smashed tempered glass, epoxied into laser-cut disks, with a ring providing some structural support. Although it’s hard to tell from the photos, the fragments sit flush with one side of the disk, which is likely the side you want closest to your carotid artery:

    Earrings - 12mm - finished
    Earrings – 12mm – finished

    Each chunk consists of a few smaller cuboids, so you get internal reflections from the minute air gaps between them. They’re not diamonds, but they’re surprisingly glittery in the proper light. Bonus: you can see right through!

    The “gold” band around the disk is a beading ring held in a notch engraved around both disks:

    Earrings - rings
    Earrings – rings

    The smaller ring is 12 mm OD, the larger is 25 mm, with 16 mm (the descriptions says 15, but ya get what ya get) and 20 mm available for other glass fragment sizes.

    The engraved recess (green) is slightly larger than the OD to allow the perimeter cut to proceed through a thinner section:

    Earring templates - 25 20 16 12 mm
    Earring templates – 25 20 16 12 mm

    Cross-hatch engraving puts a steep edge all around the recess, so the ring fits with just a little slack and turns freely around the disks.

    You will, of course, have different glass fragments requiring different shapes, but the outlines came from the same process I used to make the palette organizing the fragments:

    Smashed glass palette - fresh cut
    Smashed glass palette – fresh cut

    You (well, I) can just import that layout, copy the outline of the chunk to be used, then delete the rest. Mirror the outline so the engraved sides of the disks fit together around the chunk, position symmetrically in the template halves, and fire the laser.

    Affixing the fresh-cut disk and its glass chunk to a strip of Kapton tape (sticky side up) holds them in proper alignment and prevents the epoxy from leaking out the bottom:

    Earrings - 12mm - taped
    Earrings – 12mm – taped

    With everything lined up, run a small bead of epoxy around the chunk, squish the top disk in place, and line up the notches. When the epoxy cures, peel the earring off the tape and slide a jump ring into the notch.

    As a finishing touch, you’d add a suitable ear hook or stud, but I think it’s fair to assume anything from Amazon would consist of the finest arsenic-plated plutonium and be completely unsuitable for skin contact. Neither of us have any piercings, so I cannot provide enticing action photos.

    The 25 mm versions failed because I made the outlines such a snug fit around the chunks they didn’t quite fit:

    Earrings - 25mm - failed
    Earrings – 25mm – failed

    Protip: do not attempt to coerce two rigid bodies into alignment by applying firm pressure, particularly when one of them is already-broken glass.

    The small earrings weigh 0.7 g each and a 25 mm one (well, the parts for a large one) comes in a bit over 3 g, plus whatever hardware goes in / on / around your ear.

    This was (obviously) an exercise in small-scale laser machining, rather than a venture into haute couture. In the highly unlikely event you can’t live without a pair of custom-designed high-impact earrings, I’ll shut up and take your money … let me know if you want little or big. Black is the new black; I do have other colors, but who are you kidding?

    The SVG images as a GitHub Gist:

    Loading
    Sorry, something went wrong. Reload?
    Sorry, we cannot display this file.
    Sorry, this file is invalid so it cannot be displayed.
  • Smashed Glass Work Palette

    Smashed Glass Work Palette

    Having a myriad small glass fragments and an idea for their use created the problems of organizing the pieces while not losing them under the bench.

    As with the shattered shot-glass coaster, start by lining up the suspects on the scanner:

    Small fragments
    Small fragments

    Blow out the contrast, flip right-to-left, then mask them en masse:

    Small fragments - masked
    Small fragments – masked

    Delete the images (inside their selection masks) to create a binary mask:

    Small fragments - masks
    Small fragments – masks

    Have LightBurn trace the binary images, wrap a rounded rectangle around the lot of them, duplicate the rectangle as a base plate, then fire the laser:

    Smashed glass palette - fresh cut
    Smashed glass palette – fresh cut

    They’re not secured in their sockets, but they won’t fall out unless I fat-finger the whole affair:

    Smashed glass palette - loaded
    Smashed glass palette – loaded

    The thing that takes getting used to: the whole process was about two hours of wall clock time from start to finish, with a leisurely breakfast and KP in the middle.