publish laser engraver page. add video-thumb script.

input/projects/laser-engraver.md

 title: Laser Engraver
-description: Marlin based CNC laser engraver with 3D printed parts
-x-parent: projects
+description: Marlin based CNC laser engraver / cutter with 3D printed parts
+parent: projects
 git: https://git.xythobuz.de/thomas/marlin/src/branch/laser-engraver
-x-date: 2022-11-11
+date: 2022-11-25
 comments: true
 ---
 
 After dabbling in 3D printing for a couple of years now, I had to level-up my Makers toolkit.
 The next logical step, in my opinion, is laser engraving / laser cutting.
-I have to admit, I was initially a bit scared, and still have some respect for the potential hazards posed by the strong and focussed laser beam.
-So I decided to go slow and start with a low powered diode laser.
+I have to admit I was initially a bit scared and still have some respect for the potential hazards posed by the strong, focussed laser beam.
+So I decided to go slow and start with a low powered 2.5W diode laser.
 
 ⚠️ Be sure to always use proper laser safety goggles when working with such machines! ⚠️
 
 <!--%
 lightgallery([
     [ "img/laser_tower_1.jpg", "Frontal view in Ikea Lack tower" ],
+    [ "img/laser_tree_test.mp4", "video/mp4", "", "", "Cutting a christmas tree decoration" ],
+    [ "img/laser_side_1.jpg", "View from left side" ],
+    [ "img/laser_side_2.jpg", "View from right side" ],
 ])
 %-->
 
+### Table Of Contents
+
+* [Hardware](laser-engraver.html#hardware)
+    * [Mechanics](laser-engraver.html#mechanics)
+    * [Electronics](laser-engraver.html#electronics)
+* [Software](laser-engraver.html#software)
+    * [MCU Firmware](laser-engraver.html#mcu_firmware)
+    * [Host Software](laser-engraver.html#host_software)
+        * [LaserGRBL](laser-engraver.html#lasergrbl)
+        * [Inkscape](laser-engraver.html#inkscape)
+        * [FreeCAD](laser-engraver.html#freecad)
+        * [Working with G-Code](laser-engraver.html#g_code)
+* [Cutting Tests](laser-engraver.html#cutting_tests)
+* [Future Improvements](laser-engraver.html#future_improvements)
+* [Cutting Parameters](laser-engraver.html#cutting_parameters)
+* [More Pictures](laser-engraver.html#more_pictures)
+
 ## Hardware
+<a class="anchor" name="hardware"></a>
 
 I know I say this in a lot of articles here, probably in an attempt to justify my hoarding of electronic parts. 😳
 But this was even better than most of my previous projects, in the sense that I didn't have to buy any parts at all, except for the 2500mW 450nm laser diode, which I got used from my colleague [Philipp](https://www.phschoen.de/) for just 13€.
 Everything else came out of my parts bin.
 
 ### Mechanics
+<a class="anchor" name="mechanics"></a>
 
 The mechanism is based on the ["Cantilever Laser Engraver" by Meatball](https://www.printables.com/model/213526-cantilever-laser-engraver).
 This in turn is based on the ["Cantilever Laser Engraver" by GeoDave](https://www.thingiverse.com/thing:4605853).
 <!--%
 lightgallery([
     [ "img/laser_frame.jpg", "Frame of laser engraver, made of 2020 rails" ],
+    [ "img/laser_y_gantry.jpg", "Close view of Y gantry mechanism" ],
+    [ "img/laser_x_support.jpg", "Close view of X axis support wheel" ],
 ])
 %-->
 
 The OpenSCAD and STL files for these parts [can be found on my Printables profile](https://www.printables.com/model/314945-cantilever-laser-engraver-fixes).
 
 To fit the whole machine comfortably inside my [Ikea Lack tower](ikea-lack.html) I mounted it on a 18mm mutliplex base plate with 540x440mm.
+The 3D printed feet of the Y-axis already have holes for countersunk screws, so I simply used wood screws there.
+To mount the mainboard PCB and laser heatsink I made 3.2mm holes for M3 screws and M3 stand-offs, drilling with a 6mm drill from the bottom to approximately half the depth of the base plate, so even cylindrical screw heads don't stand out from below the plate.
+I also added a power switch with a simple 3D printed mount.
+
+<!--%
+lightgallery([
+    [ "img/laser_power_switch.jpg", "Power switch with mount" ],
+])
+%-->
 
 ### Electronics
+<a class="anchor" name="electronics"></a>
 
 As mentioned above I used the electronics, namely mainboard, LCD and fans, from my old 3D printer.
 
 So even when the MOSFET was turned off the laser still had a ground connection and was powered through the ground pin of the TTL connector, so it could never fully turn off.
 So if you do the same, make sure to only connect one of the two ground pins!
 
+The power supply is simply reused from my [Fabrikator Mini](fabrikator-mini.html), it already was placed in the Ikea Lack tower.
+To save some space I now mounted it to the top of the next Lack table above the laser, with some strips of perforated metal sheet.
+Of course this is kind of problematic, as the rest of the machine is kind of designed to be easily transportable.
+I will have to find some kind of small alternative power supply.
+
+<!--%
+lightgallery([
+    [ "img/laser_psu.jpg", "12V power supply on underside of Ikea Lack" ],
+])
+%-->
+
 ## Software
+<a class="anchor" name="software"></a>
+
+There's a surprisingly large amount of software involved in this project.
+All just to move a lamp around a bit 💡🤔
 
 ### MCU Firmware
+<a class="anchor" name="mcu_firmware"></a>
 
 Most DIY laser engravers or CNC machines seem to use the [GRBL firmware](https://github.com/gnea/grbl).
 Unfortunately this firmware only runs on Atmega328p MCUs, so I can not use it with the Atmega2560 on the GT2560 mainboard.
 These changes can be seen [in this commit](https://git.xythobuz.de/thomas/marlin/commit/58dbdff1d5b6e365bfd5ae4eeb7b42967688c51e).
 I also opened a [pull request](https://github.com/MarlinFirmware/Marlin/pull/25003) to hopefully upstream them.
 
+Later I learned that Marlin does not allow setting home offsets further than 20mm away from endstops.
+So I also [added a custom menu command](https://git.xythobuz.de/thomas/marlin/commit/74cafcd77625003623d3a8a6378a4ff0ac6eda72) that simply executes [`G92`](https://marlinfw.org/docs/gcode/G092.html) `X0 Y0` to set the current position to zero.
+Using this I can generate G-Code where the object to cut starts at coordinates `(0, 0)` while being able to position it arbitrarily on the machine itself.
+
 My current Marlin configuration for the laser engraver can be found [on my Gitea instance](https://git.xythobuz.de/thomas/marlin/src/branch/laser-engraver).
 
 ### Host Software
+<a class="anchor" name="host_software"></a>
 
 Besides the microcontroller firmware, we also need some host software to prepare the G-Code from whatever kind of input file we start out with.
 There are two basic approaches for generating paths for the laser engraver.
 Below I will try to document all different free software packages I tried for laser engraving.
 
 #### LaserGRBL
+<a class="anchor" name="lasergrbl"></a>
 
 The first solution I found out about is [LaserGRBL](https://lasergrbl.com/).
 It is a Windows-only program, but at least it is open-source / free software.
 </pre>
 
 Without further modifications, this only moves the toolhead, while keeping the laser off at all times, because Marlin by default does not process the power-level parts of the G-Code lines.
-To get this to work, the "continuous inline power mode" has to be enabled by putting `M3 I` in the G-Code header setting of LaserGRBL.
+To get this to work, the "continuous inline power mode" has to be enabled by putting `M3 I` in the G-Code header setting of LaserGRBL, as well as at the end of the "Multiple Passes" G-Code section.
 
 <!--%
 lightgallery([
 So the speed does not apply to the G1 moves afterwards.
 This case is not handled yet.
 
+In another vector job, I saw LaserGRBL generate output like the following.
+
+<pre class="sh_gcode">
+G0X3Y2
+S255
+G1Y5F200
+X0.7
+Y8.347
+X8.25
+X8.75Y8.847
+Y12.347
+</pre>
+
+This is the very compact GRBL G-Code dialect, which leaves out spaces and also the modes, as long as they don't change.
+So to handle that, I remember the last G0/G1 mode, prepending it as needed to lines, while also adding the missing spaces for better human readable output.
+
+As you can tell there are many different output formats from LaserGRBL and I'm not able to tell when it will generate what.
+But my script below should work for all variants I have seen up to now.
+
 <pre class="sh_python">
 #!/usr/bin/env python
 
 
 power = ""
 speed = ""
+mode_g0 = True
+
+def add_spaces(s):
+    prev = ' '
+    r = ""
+    for c in s:
+        if str(prev).isdigit() and str(c).isalpha():
+            r = r + " "
+        r = r + c
+        prev = c
+    return r
 
 with open(in_file, 'r') as fi, open(out_file, 'w') as fo:
     for line in fi:
         elif line.startswith("F"):
             speed = " " + line.rstrip()
         else:
-            s = line.rstrip()
+            s = add_spaces(line.rstrip())
             if line.startswith("G1"):
+                mode_g0 = False
                 s += power
                 s += speed
             elif line.startswith("G0"):
+                mode_g0 = True
                 s += power
                 if (power != " S0") and (power != ""):
                     print("Warning: G0 move with power not zero!" + power)
+            elif line.startswith("X") or line.startswith("Y"):
+                if mode_g0:
+                    s = "G0 " + s
+                    s += power
+                    if (power != " S0") and (power != ""):
+                        print("Warning: G0 move with power not zero!" + power)
+                else:
+                    s = "G1 " + s
+                    s += power
+                    s += speed
             s += "\n"
             fo.write(s)
 </pre>
 LaserGRBL also can directly connect to the machine via the serial port.
 This has worked for me for a bit, but even though you can set the G-Code flavor to Marlin in the LaserGRBL settings, it does not really work properly.
 You can jog the toolhead but homing is not possible.
-I also had to reduce the polling frequency in the LaserGRBL settings to 'Quiet' and disable Soft-Reset to get it to work inside the VirtualBox VM I use to run the program.
+I also had to reduce the polling frequency in the LaserGRBL settings to 'Quiet' and disable Soft-Reset to get it to work inside the VirtualBox VM I used at first to run the program.
 
-Apparently it is also possible to [run LaserGRBL in Wine](https://github.com/arkypita/LaserGRBL/issues/5#issuecomment-873564055) / [with PlayOnLinux](https://github.com/arkypita/LaserGRBL/raw/master/POL_LaserGRBL_setup.sh), but on my Arch system I was not able to get either of these running, due to problems with the required Winetricks.
+It is also possible to [run LaserGRBL in Wine](https://github.com/arkypita/LaserGRBL/issues/5#issuecomment-873564055) / [with PlayOnLinux](https://github.com/arkypita/LaserGRBL/raw/master/POL_LaserGRBL_setup.sh).
+At first I was not able to run this PlayOnLinux script due to Winetricks downloads failing with invalid checksums.
+But after trying a couple of days later, with the exact same script, the installation worked fine.
+I had to make the same changes to the settings as described for VirtualBox above.
 
-Also, for all the above tests with LaserGRBL I have imported raster bitmap images and either rastered them, or vectorized them within LaserGRBLs UI.
+Also for all the above tests with LaserGRBL I have imported raster bitmap images and either rastered them, or vectorized them within LaserGRBLs UI.
 With bitmaps it is possible to position the resulting G-Code paths with an offset from the zero position of the machine.
 This is not possible when using LaserGRBL to import SVG vector paths.
 With them, the output will always start at coordinates `(0, 0)`.
-You will then have to set the proper offset on the machine itself.
+You will then have to set the proper offset on the machine itself, as described in the Marlin section above.
 
 #### Inkscape
+<a class="anchor" name="inkscape"></a>
 
 Inkscape includes the [G-Code Tools Plugin from the russian-language CNC-Club forums](https://www.cnc-club.ru/forum/viewtopic.php?t=35).
 Unfortunately I was not able to find much up-to-date english-language documentation for this.
 It is also relatively complicated and unintuitive.
 
-TODO
-
 I was able to get it to generate G-Code from a path, but not with any laser power instructions yet.
+This section will be updated if I have more success in the future.
+Until then I'm just using Inkscape to export svg files for LaserGRBL.
 
 #### FreeCAD
+<a class="anchor" name="freecad"></a>
 
 FreeCAD has the [Path Workbench](https://wiki.freecadweb.org/Path_Workbench), which can be used to create G-Code instructions for all kinds of CNC machines.
 It is not really complete and fool-proof yet, unfortunately.
 And it is also not designed for pure 2D machines, like laser engravers, by default.
 
-TODO
-
 I have not yet tested that.
 
 #### Working with G-Code
+<a class="anchor" name="g_code"></a>
 
 One nice feature I saw in LaserGRBL, but was not able to use with Marlin, is the ability to draw the outline of the object to be cut, for positioning of the stock material.
 So I quickly made up a small Python script that analyzes a G-Code file, taking the coordinates from all G1 cutting moves and generating their bounding box, which is then drawn on the lowest possible power setting multiple times.
     write("G0 X0 Y0 F" + str(speed_g0))
 </pre>
 
+I like the idea but unfortunately it has some problems in practice.
+When changing the focus level of my laser diode, it's very easy to also change the offset in the X and Y axes.
+So the grid is not properly aligned for long.
+But it still looks nice.
+
+<!--%
+lightgallery([
+    [ "img/laser_grid.jpg", "Closer view of grid on base plate" ],
+])
+%-->
+
+If you look closely, you can see the first run I did with a power setting of 50 / 255.
+This was not strong enough, the lines are only faintly visible.
+So I did another run with 100 / 255 over it.
+This was enough power for nice visible lines, but the laser offset unfortunately shifted slightly between the runs.
+
+As I grew tired of removing, flashing and re-inserting of the SD card, I decided to also write a quick little G-Code sender for the serial port.
+
+<pre class="sh_python">
+#!/usr/bin/env python
+
+import sys
+import serial
+
+if len(sys.argv) < 3:
+    print("Usage:")
+    print("    " + sys.argv[0] + " /dev/serial/port input.gcode")
+    sys.exit(1)
+
+port_file = sys.argv[1]
+in_file = sys.argv[2]
+
+port = serial.Serial()
+port.port = port_file
+port.baudrate = 115200
+#port.timeout = 0.0
+
+max_cmd_buffer = 5
+counter = 0
+
+def connect_serial():
+    try:
+        port.open()
+        if port.is_open:
+            print("connected to: " + port_file)
+        else:
+            print("error connecting to " + port_file)
+            sys.exit(1)
+    except serial.serialutil.SerialException:
+        print("error connecting to " + port_file)
+        sys.exit(1)
+
+def wait_for_text(s):
+    while True:
+        response = port.read_until().decode().strip()
+        print("rx w: " + response)
+        if response.startswith(s):
+            break
+        elif response.startswith("Error"):
+            print(response)
+            print("CNC returned error. aborting.")
+            abort_print(False)
+            port.close()
+            sys.exit(1)
+
+def abort_print(wait_for_oks = True):
+    global counter
+
+    print("tx: M5")
+    port.write("M5\n".encode())
+    counter += 1
+
+    print("tx: G0 X0 Y0 F1000")
+    port.write("G0 X0 Y0 F1000\n".encode())
+    counter += 1
+
+    if wait_for_oks:
+        while counter > 0:
+            wait_for_text("ok")
+            counter -= 1
+
+def send_file(f):
+    global counter
+
+    for line in f:
+        if ";" in line:
+            line = line.split(";")[0]
+
+        line = line.strip()
+
+        if len(line) <= 0:
+            print("skipping empty line")
+            continue
+
+        print("tx: " + line)
+        tx = line.encode() + b'\n'
+        port.write(tx)
+
+        counter += 1
+        print("cnt=" + str(counter))
+
+        while counter >= max_cmd_buffer:
+            response = port.read_until().decode().strip()
+            #print("rx: " + response)
+            if response.startswith("ok"):
+                counter -= 1
+                print("cnt=" + str(counter))
+            elif response.startswith("Error"):
+                print(response)
+                print("CNC returned error. aborting.")
+                abort_print(False)
+                port.close()
+                sys.exit(1)
+
+def main():
+    connect_serial()
+
+    print("waiting for CNC to reset")
+    wait_for_text("start")
+
+    print("auto-homing after reset")
+    print("tx: G28")
+    port.write("G28\n".encode())
+    wait_for_text("ok")
+
+    try:
+        with open(in_file, 'r') as f:
+            send_file(f)
+
+        while counter > 0:
+            wait_for_text("ok")
+            counter -= 1
+    except KeyboardInterrupt:
+        print("user interrupt. aborting.")
+        abort_print(True)
+
+    port.close()
+
+if __name__ == '__main__':
+    main()
+</pre>
+
+Of course it's important to use the proper speed, power and number of iterations for each object to cut.
+Not enough power or iterations, or too high of a speed, and the object will still be part of the stock material.
+Too much power or iterations and not only the object will be cut, but also the base plate below.
+
+So I first did some tests manually, which is relatively time consuming.
+I then made another Python script go generate G-Code for a cutting test, varying speed and number of iterations.
+
+<pre class="sh_python">
+#!/usr/bin/env python
+
+# general settings
+filename = "cut_test.gcode"
+pwr = 255
+pwr_num = 150
+speed_g0 = 3000
+speed_g1_num = 500
+
+# settings of single test shape
+width = 10
+height = 10
+dist = 2
+
+# range for tests
+iterations = [ 5, 10, 15, 20 ]
+speeds_g1 = [ 1000, 500, 200 ]
+
+def drawSquare(w, h, x, y, speed_g1):
+    write("G0 X" + str(x) + " Y" + str(y) + " S0 F" + str(speed_g0))
+    square = [
+        ( x + w, y ),
+        ( x + w, y + h ),
+        ( x, y + h ),
+        ( x, y ),
+    ]
+    for xp, yp in square:
+        write("G1 X" + str(xp) + " Y" + str(yp) + " S" + str(pwr) + " F" + str(speed_g1))
+
+def drawHeart(w, h, x, y, speed_g1):
+    heart = [
+        ( 0.0, 5.0 / 8.0 ),
+        ( 0.0, 6.0 / 8.0 ),
+        ( 0.1, 7.0 / 8.0 ),
+        ( 0.2, 8.0 / 8.0 ),
+        ( 0.3, 8.0 / 8.0 ),
+        ( 0.4, 7.0 / 8.0 ),
+        ( 0.5, 6.0 / 8.0 ),
+        ( 0.6, 7.0 / 8.0 ),
+        ( 0.7, 8.0 / 8.0 ),
+        ( 0.8, 8.0 / 8.0 ),
+        ( 0.9, 7.0 / 8.0 ),
+        ( 1.0, 6.0 / 8.0 ),
+        ( 1.0, 5.0 / 8.0 ),
+        ( 0.9, 4.0 / 8.0 ),
+        ( 0.8, 3.0 / 8.0 ),
+        ( 0.7, 2.0 / 8.0 ),
+        ( 0.6, 1.0 / 8.0 ),
+        ( 0.5, 0.0 / 8.0 ),
+        ( 0.4, 1.0 / 8.0 ),
+        ( 0.3, 2.0 / 8.0 ),
+        ( 0.2, 3.0 / 8.0 ),
+        ( 0.1, 4.0 / 8.0 ),
+        ( 0.0, 5.0 / 8.0 )
+    ]
+    write("G0 X" + str(x + heart[0][0] * w) + " Y" + str(y + heart[0][1] * h) + " S0 F" + str(speed_g0))
+    for xp, yp in heart:
+        write("G1 X" + str(x + xp * w) + " Y" + str(y + yp * h) + " S" + str(pwr) + " F" + str(speed_g1))
+
+def drawShape(w, h, x, y, speed_g1):
+    #drawSquare(w, h, x, y, speed_g1)
+    drawHeart(w, h, x, y, speed_g1)
+
+digits = [
+    [
+        # 0
+        (0.0, 0.0),
+        (0.0, 1.0),
+        (1.0, 1.0),
+        (1.0, 0.0),
+        (0.0, 0.0)
+    ], [
+        # 1
+        (0.5, 0.0),
+        (0.5, 1.0)
+    ], [
+        # 2
+        (0.0, 1.0),
+        (1.0, 1.0),
+        (1.0, 0.5),
+        (0.0, 0.5),
+        (0.0, 0.0),
+        (1.0, 0.0),
+    ], [
+        # 3
+        (0.0, 1.0),
+        (1.0, 1.0),
+        (1.0, 0.5),
+        (0.0, 0.5),
+        (1.0, 0.5),
+        (1.0, 0.0),
+        (0.0, 0.0),
+    ], [
+        # 4
+        (0.0, 1.0),
+        (0.0, 0.5),
+        (1.0, 0.5),
+        (1.0, 1.0),
+        (1.0, 0.0),
+    ], [
+        # 5
+        (1.0, 1.0),
+        (0.0, 1.0),
+        (0.0, 0.5),
+        (1.0, 0.5),
+        (1.0, 0.0),
+        (0.0, 0.0),
+    ], [
+        # 6
+        (1.0, 1.0),
+        (0.0, 1.0),
+        (0.0, 0.0),
+        (1.0, 0.0),
+        (1.0, 0.5),
+        (0.0, 0.5),
+    ], [
+        # 7
+        (0.0, 1.0),
+        (1.0, 1.0),
+        (1.0, 0.0),
+    ], [
+        # 8
+        (1.0, 0.5),
+        (1.0, 1.0),
+        (0.0, 1.0),
+        (0.0, 0.5),
+        (1.0, 0.5),
+        (1.0, 0.0),
+        (0.0, 0.0),
+        (0.0, 0.5),
+    ], [
+        # 9
+        (1.0, 0.5),
+        (1.0, 1.0),
+        (0.0, 1.0),
+        (0.0, 0.5),
+        (1.0, 0.5),
+        (1.0, 0.0),
+        (0.0, 0.0),
+    ]
+]
+
+font_w = 1.5
+font_h = 3.0
+font_d = 0.5
+
+def draw_digit(f, i, size_x, size_y, off_x, off_y):
+    dig = digits[i]
+    n = 0
+    for p in dig:
+        x, y = p
+        s = ""
+
+        if n == 0:
+            s += "G0 S0 F" + str(speed_g0)
+        else:
+            s += "G1 S" + str(pwr_num) + " F" + str(speed_g1_num)
+
+        s += " X" + str(off_x + size_x * x)
+        s += " Y" + str(off_y + size_y * y)
+
+        print(s)
+        f.write(s + "\n")
+        n += 1
+
+    return s
+
+def draw_number(f, n, x, y):
+    if n >= 1000:
+        draw_digit(f, int(n / 1000),       font_w, font_h, x,                         y)
+        draw_digit(f, int((n / 100)) % 10, font_w, font_h, x + font_d + font_w,       y)
+        draw_digit(f, int((n / 10) % 10),  font_w, font_h, x + 2 * (font_d + font_w), y)
+        draw_digit(f, int(n % 10),         font_w, font_h, x + 3 * (font_d + font_w), y)
+    elif n >= 100:
+        draw_digit(f, int(n / 100),       font_w, font_h, x,                         y)
+        draw_digit(f, int((n / 10) % 10), font_w, font_h, x + font_d + font_w,       y)
+        draw_digit(f, int(n % 10),        font_w, font_h, x + 2 * (font_d + font_w), y)
+    elif n >= 10:
+        draw_digit(f, int(n / 10), font_w, font_h, x,                   y)
+        draw_digit(f, int(n % 10), font_w, font_h, x + font_d + font_w, y)
+    else:
+        draw_digit(f, n, font_w, font_h, x, y)
+
+with open(filename, 'w') as f:
+    def write(s):
+        print(s)
+        f.write(s + "\n")
+
+    # header
+    #write("G28")
+    write("G90")
+    write("M3 I")
+    write("M3 S0")
+    write("")
+
+    # first line is not having the power applied
+    # TODO
+    write("G0 X0 Y0 S0 F" + str(speed_g0))
+    write("G1 X1 Y0 S1 F" + str(speeds_g1[0]))
+    write("G0 X0 Y0 S0 F" + str(speed_g0))
+    write("G1 X0 Y1 S1 F" + str(speeds_g1[0]))
+    write("G0 X0 Y0 S0 F" + str(speed_g0))
+
+    max_num_str_len = 4
+    str_w = (max_num_str_len * font_w) + ((max_num_str_len - 1) * font_d)
+
+    write("; iterations")
+    for i in range(0, len(iterations)):
+        write("; " + str(iterations[i]))
+        draw_number(f, iterations[i], (width + str_w) / 2.0 + dist + i * (width + dist), 0)
+    write("")
+
+    write("; speeds")
+    for i in range(0, len(speeds_g1)):
+        write("; " + str(speeds_g1[i]))
+        draw_number(f, speeds_g1[i], 0, (height + font_h) / 2.0 + dist + i * (height + dist))
+
+    for i in range(0, len(speeds_g1)):
+        for j in range(0, len(iterations)):
+            write("; speed=" + str(speeds_g1[i]) + " n=" + str(iterations[j]))
+            for k in range(0, iterations[j]):
+                drawShape(width, height, str_w + dist + j * (width + dist), font_h + dist + i * (height + dist), speeds_g1[i])
+            write("")
+
+    # footer
+    write("M5")
+    write("G0 X0 Y0 F" + str(speed_g0))
+</pre>
+
+I'm drawing digits again, like in the Grid G-Code generator above.
+It seems I need to create some kind of library or so if I continue this route of generating G-Code.
+
+<!--%
+lightgallery([
+    [ "img/laser_cut_test_1.jpg", "Test sheet being cut" ],
+    [ "img/laser_cut_test_3.jpg", "Finished test run" ],
+])
+%-->
+
+In the pictures above, the 3x3 grid of hearts on the right was made with the laser slightly out of focus.
+It was not able to cut through in this run, even with 30 iterations.
+I also still had the text not aligned properly.
+
+The 3x1 and 3x3 runs on the left side were made after properly focussing the laser and fixing the text alignment.
+Here 200mm/min with 10 iterations was already enough to cut through the 3mm plywood.
+
+## Cutting Tests
+<a class="anchor" name="cutting_tests"></a>
+
+For the first 'real' test I decided to cut the assembly jig for the [Pagoda antenna](https://www.maartenbaert.be/quadcopters/antennas/pagoda-antenna/#design-files) by Maarten Baert.
+The files are available in dxf and svg format.
+I was able to easily import the svg file in LaserGRBL to create G-Code, afterwards converting it to the proper format using my script described above.
+
+<!--%
+lightgallery([
+    [ "img/laser_pagoda_1.jpg", "Front side of the Pagoda jig sheet" ],
+    [ "img/laser_pagoda_2.jpg", "Back side of the Pagoda jig sheet" ],
+    [ "img/laser_pagoda_3.jpg", "Assembled Pagoda antenna jig" ],
+])
+%-->
+
+As in one of my previous tests I used 200mm/min with 10 iterations.
+But this was not quite enough to get the parts out easily.
+In hindsight I should have used at least 15 iterations.
+But the result was still usable, even with only 10 iterations.
+
+Next my SO requested some christmas decoration, so I decided to attempt to cut this [Christmas Tree Ornament](https://www.thingiverse.com/thing:43041) by TomKeddie on Thingiverse.
+It is made for 4.8mm plywood, so I scaled it down by a factor of `3.0 / 4.8 = 0.625`.
+The design comes as a dxf file, so I imported that in Inkscape and then exported an svg file from that.
+This I then imported in LaserGRBL, generated G-Code and converted that using the script above.
+
+<!--%
+lightgallery([
+    [ "img/laser_tree_test.mp4", "video/mp4", "", "", "Cutting a christmas tree decoration" ],
+    [ "img/laser_tree_segments.mp4", "video/mp4", "", "", "Segmented lines while cutting" ],
+])
+%-->
+
+As you can tell from the second video, what should be single continuous lines has instead sometimes been split up into many small path segments, which LaserGRBL is cutting in non-optimal ordering.
+I have not yet found a way to easily clean these paths up.
+
+<!--%
+lightgallery([
+    [ "img/laser_tree_1.jpg", "Front side of christmas tree sheet" ],
+    [ "img/laser_tree_2.jpg", "Back side of christmas tree sheet" ],
+    [ "img/laser_tree_3.jpg", "Finished christmas tree ornament" ],
+])
+%-->
+
+The end-result does not seem to be really affected by this however, although with 200mm/min and 15 iterations the parts were not removable as easily as I hoped.
+So I think I either have to adjust the focus better or go up to 20 iterations for the 3mm birch plywood.
+
+## Future Improvements
+<a class="anchor" name="future_improvements"></a>
+
+I didn't expect it to be this bad, but cutting wood really produces a noticeable amount of smoke and the smell of burnt wood.
+So in the long run I will have to add some kind of air filtration system to my Ikea Lack tower.
+Also I now better understand the need for Air Assist on laser cutters.
+My small fans don't help much in keeping the light-path free of smoke and soot.
+But I will hopefully get away with running it for a while without these additions.
+
+Another obvious improvement is the addition of a Raspberry Pi and a Webcam, to allow remote monitoring of long-running jobs.
+I also came across the [LaserWeb project](https://laserweb.yurl.ch/) which seems to be similar in spirit to OctoPrint for 3D printers, but also with the ability of processing vector and bitmap files from within the web interface.
+This would be a very useful addition and solve a lot of the software workflow problems illustrated above.
+Also theres more than enough room left on my base plate for a SBC.
+
+## Cutting Parameters
+<a class="anchor" name="cutting_parameters"></a>
+
+Here are the results of all cutting tests I've made up to now.
+I will update this table as soon as I gather new data 🧑‍🔬
+
+<!--%
+tableHelper([ "align-right", "align-right", "align-right", "align-right", "align-right", "align-right", "align-right", "align-left", "align-left" ],
+    [ "Type", "Material", "Thickness<br><span style=\"font-size: small;\">(in mm)</span>", "Power<br><span style=\"font-size: small;\">(in W)</span>", "PWM<br><span style=\"font-size: small;\">(out of 255)</span>", "Speed<br><span style=\"font-size: small;\">(in mm/min)</span>", "Iterations", "Remarks", "Date" ], [
+        [ "<s>Plywood</s>", "<s>Birch</s>", "<s>3</s>", "<s>2.5</s>", "<s>255</s>", "<s>200</s>", "<s>5</s>", "<s>Not possible to remove.</s>", "<s>2022-11-24</s>" ],
+        [ "Plywood", "Birch", "3", "2.5", "255", "200", "10", "Difficult to remove.", "2022-11-24" ],
+        [ "Plywood", "Birch", "3", "2.5", "255", "200", "15", "Easily removable.", "2022-11-24" ],
+        [ "Plywood", "Birch", "3", "2.5", "255", "200", "20", "Freely fell out.", "2022-11-24" ],
+        [ "<s>Plywood</s>", "<s>Birch</s>", "<s>3</s>", "<s>2.5</s>", "<s>255</s>", "<s>500</s>", "<s>15</s>", "<s>Not possible to remove.</s>", "<s>2022-11-24</s>" ],
+        [ "Plywood", "Birch", "3", "2.5", "255", "500", "20", "Difficult to remove.", "2022-11-24" ],
+        [ "Plywood", "Birch", "3", "2.5", "255", "200", "15", "Difficult to remove.", "2022-11-25" ],
+    ]
+)
+%-->
+
 ## More Pictures
+<a class="anchor" name="more_pictures"></a>
 
 <div class="collapse">Some more photographs I didn't use above.</div>
 <div class="collapsecontent">
 <!--%
 lightgallery([
     [ "img/laser_tower_2.jpg", "Frontal view in Ikea Lack tower" ],
+    [ "img/laser_cut_test_2.jpg", "Finished test run" ],
     [ "img/laser_gt2560.jpg", "GT2560 mainboard of laser engraver" ],
 ])
 %-->

macros.py

 #     [ "image-link", "description" ],
 #     [ "image-link", "thumbnail-link", "description" ],
 #     [ "youtube-link", "thumbnail-link", "description" ],
-#     [ "video-link", "mime", "thumbnail-link", "image-link", "description" ]
+#     [ "video-link", "mime", "thumbnail-link", "image-link", "description" ],
+#     [ "video-link", "mime", "", "", "description" ],
 # ])
 
 # it will also auto-generate thumbnails and resize and strip EXIF from images
 # using the included web-image-resize script.
+# and it can generate video thumbnails and posters with the video-thumb script.
 
 def lightgallery_check_thumbnail(link, thumb):
     # only check local image links
     script = os.path.join(os.getcwd(), 'web-image-resize')
     os.system(script + ' ' + path)
 
+def lightgallery_check_thumbnail_video(link, thumb, poster):
+    # only check local image links
+    if not link.startswith('img/'):
+        return
+
+    # generate thumbnail filenames video-thumb will create
+    x = link.rfind('.')
+    thumb_l = link[:x] + '_thumb.png'
+    poster_l = link[:x] + '_poster.png'
+
+    # only run when desired thumb path matches calculated ones
+    if (thumb_l != thumb) or (poster_l != poster):
+        return
+
+    # generate fs path to images
+    path = os.path.join(os.getcwd(), 'static', link)
+    thumb_p = os.path.join(os.getcwd(), 'static', thumb)
+    poster_p = os.path.join(os.getcwd(), 'static', poster)
+
+    # no need to generate thumb again
+    if os.path.exists(thumb_p) or os.path.exists(poster_p):
+        return
+
+    # run video-thumb to generate thumbnail
+    script = os.path.join(os.getcwd(), 'video-thumb')
+    os.system(script + ' ' + path)
+
 def lightgallery(links):
     videos = [l for l in links if len(l) == 5]
     v_i = -1
         elif len(l) == 5:
             v_i += 1
             link, mime, thumb, poster, alt = videos[v_i]
+            if len(thumb) <= 0:
+                x = link.rfind('.')
+                thumb = link[:x] + '_thumb.png'
+            if len(poster) <= 0:
+                x = link.rfind('.')
+                poster = link[:x] + '_poster.png'
+            lightgallery_check_thumbnail_video(link, thumb, poster)
             print '<div class="border" data-poster="' + poster + '" data-sub-html="' + alt + '" data-html="#video' + str(v_i) + '"><a href="' + link + '"><img class="pic" src="' + thumb + '"></a></div>'
         else:
             raise NameError('Invalid number of arguments for lightgallery')

static/css/style.css

     padding-bottom: 0.2em;
 }
 
+s {
+    text-decoration-thickness: 0.2em;
+}
+
+s:hover {
+  text-decoration: none;
+}
+
 #nav {
     border-bottom-style: solid;
     border-bottom-width: 2px;
     border-color: #32CD32;
 }
 
+s {
+    text-decoration-color: #FF0000;
+}
+
 .releasecard, .collapse {
     background-color: #C0C0C0;
 }

video-thumb

+#!/bin/bash
+
+if [ -z "$1" ]; then
+    echo "No argument supplied"
+    exit 1
+fi
+
+sdir=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )
+dir=$(dirname "${1}")
+video=$(basename -- "${1}")
+ext="${video##*.}"
+name="${video%.*}"
+thumb="${name}_thumb.png"
+poster="${name}_poster.png"
+tmp="${name}_tmp.png"
+
+echo $sdir
+
+echo "Directory : $dir"
+echo "Input file: $video"
+echo "Thumbnail : $thumb"
+echo "Poster    : $poster"
+
+cd "$dir"
+
+echo ffmpeg -i $video -vf "select=eq(n\,0)" -n -update 1 -frames:v 1 $poster
+ffmpeg -i $video -vf "select=eq(n\,0)" -n -update 1 -frames:v 1 $poster
+
+echo convert "$poster" -auto-orient -thumbnail 300x300\> -strip "$tmp"
+convert "$poster" -auto-orient -thumbnail 300x300\> -strip "$tmp"
+
+echo convert $tmp \( $sdir/static/lg/video-play.png -background none -gravity center \) -composite $thumb
+convert $tmp \( $sdir/static/lg/video-play.png -background none -gravity center \) -composite $thumb
+
+echo rm -rf $tmp
+rm -rf "$tmp"