laser engraver scripts now included from gitea at compile time

input/projects/laser-engraver.md

 parent: projects
 git: https://git.xythobuz.de/thomas/marlin/src/branch/laser-engraver
 date: 2022-11-25
+update: 2023-01-02
 comments: true
 ---
 
 But my script below should work for all variants I have seen up to now.
 
 <pre class="sh_python">
-#!/usr/bin/env python
-
-import sys
-
-if len(sys.argv) < 3:
-    print("Usage:")
-    print("    " + sys.argv[0] + " input.nc output.gcode")
-    sys.exit(1)
-
-in_file = sys.argv[1]
-out_file = sys.argv[2]
-
-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:
-        if line.startswith("S"):
-            power = " " + line.rstrip()
-        elif line.startswith("F"):
-            speed = " " + line.rstrip()
-        else:
-            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)
+<!--%
+include_url("https://git.xythobuz.de/thomas/gcode-tools/raw/branch/master/tools/convert_lasergrbl.py")
+%-->
 </pre>
 
+You can also find this script [on my Gitea server](https://git.xythobuz.de/thomas/gcode-tools/src/branch/master/tools/convert_lasergrbl.py).
+
 Here is my first attempt of cutting a vector outline of an image out of a piece of paper.
 I used Marlins default speed and a PWM setting of 150 out of 255.
 
 I copy this file to the SD card, start it, and just abort it when I'm done with the preparations.
 
 <pre class="sh_python">
-#!/usr/bin/env python
-
-import sys
-
-if len(sys.argv) < 3:
-    print("Usage:")
-    print("    " + sys.argv[0] + " input.nc output.gcode")
-    sys.exit(1)
-
-in_file = sys.argv[1]
-out_file = sys.argv[2]
-
-x_min = None
-x_max = None
-y_min = None
-y_max = None
-mode_g1 = False
-
-pwr = 1
-iterations = 100
-speed = 3000
-
-with open(in_file, 'r') as fi, open(out_file, 'w') as fo:
-    for line in fi:
-        if line.startswith("G1"):
-            mode_g1 = True
-        elif line.startswith("G0"):
-            mode_g1 = False
-
-        if mode_g1:
-            x_pos = line.find("X")
-            if x_pos > -1:
-                x_str = line[x_pos + 1:]
-                x_num = float(x_str.split()[0])
-                #print("found x: " + str(x_num))
-                if (x_min == None) or (x_num < x_min):
-                    x_min = x_num
-                if (x_max == None) or (x_num > x_max):
-                    x_max = x_num
-
-            y_pos = line.find("Y")
-            if y_pos > -1:
-                y_str = line[y_pos + 1:]
-                y_num = float(y_str.split()[0])
-                #print("found y: " + str(y_num))
-                if (y_min == None) or (y_num < y_min):
-                    y_min = y_num
-                if (y_max == None) or (y_num > y_max):
-                    y_max = y_num
-
-    print("x_min: " + str(x_min))
-    print("x_max: " + str(x_max))
-    print("y_min: " + str(y_min))
-    print("y_max: " + str(y_max))
-
-    pos = [
-        ( x_min, y_min ),
-        ( x_max, y_min ),
-        ( x_max, y_max ),
-        ( x_min, y_max ),
-    ]
-
-    def write(s):
-        #print(s)
-        fo.write(s + "\n")
-
-    # header
-    write("G90")
-    write("M3 I")
-    write("M3 S0")
-
-    write("G0 X" + str(x_min) + " Y" + str(y_min) + " S0 F" + str(speed))
-
-    for i in range(0, iterations):
-        for x, y in pos:
-            write("G1 X" + str(x) + " Y" + str(y) + " S" + str(pwr) + " F" + str(speed))
-
-    write("M5")
-    write("G0 X" + str(x_min) + " Y" + str(y_min) + " S0 F" + str(speed))
+<!--%
+include_url("https://git.xythobuz.de/thomas/gcode-tools/raw/branch/master/tools/outline_gcode.py")
+%-->
 </pre>
 
+You can also find this script [on my Gitea server](https://git.xythobuz.de/thomas/gcode-tools/src/branch/master/tools/outline_gcode.py).
+
 I also did some experimentation with programatically generating G-Code myself, using a simple Python script as well.
 It's drawing a grid for reference on the base plate of the machine, including numerical position indicators.
 
 <pre class="sh_python">
-#!/usr/bin/env python
-
-filename = "grid.gcode"
-w = 200
-h = 280
-d = 10
-pwr = 100
-speed_g0 = 3000
-speed_g1 = 1000
-
-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, sx, sy, ox, oy):
-    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) + " F" + str(speed_g1)
-
-        s += " X" + str(ox + sx * x)
-        s += " Y" + str(oy + sy * y)
-
-        print(s)
-        f.write(s + "\n")
-        n += 1
-
-    return s
-
-with open(filename, 'w') as f:
-    def write(s):
-        print(s)
-        f.write(s + "\n")
-
-    # header
-    write("G90")
-    write("M3 I")
-    write("M3 S0")
-
-    # first line is not having the power applied
-    # so just draw it twice
-    # TODO why?
-    write("G0 X0 Y0 S0 F" + str(speed_g0))
-    write("G1 X0 Y" + str(h) + " S" + str(pwr) + " F" + str(speed_g1))
-
-    # vertical lines
-    for x in range(0, w + d, d):
-        write("G0 X" + str(x) + " Y0 S0 F" + str(speed_g0))
-        write("G1 X" + str(x) + " Y" + str(h) + " S" + str(pwr) + " F" + str(speed_g1))
-
-    # horizontal lines
-    for y in range(0, h + d, d):
-        write("G0 X0 Y" + str(y) + " S0 F" + str(speed_g0))
-        write("G1 X" + str(w) + " Y" + str(y) + " S" + str(pwr) + " F" + str(speed_g1))
-
-    for x in range(0, w, d):
-        n = int(x / 10)
-        if n >= 10:
-            draw_digit(f, int(n / 10), font_w, font_h, font_d + x, font_d)
-            draw_digit(f, int(n % 10), font_w, font_h, 2 * font_d + font_w + x, font_d)
-        else:
-            draw_digit(f, n, font_w, font_h, font_d + x, font_d)
-
-    for y in range(d, h, d):
-        n = int(y / 10)
-        if n >= 10:
-            draw_digit(f, int(n / 10), font_w, font_h, font_d, font_d + y)
-            draw_digit(f, int(n % 10), font_w, font_h, 2 * font_d + font_w, font_d + y)
-        else:
-            draw_digit(f, n, font_w, font_h, font_d, font_d + y)
-
-    # footer
-    write("M5")
-    write("G0 X0 Y0 F" + str(speed_g0))
+<!--%
+include_url("https://git.xythobuz.de/thomas/gcode-tools/raw/branch/master/generators/grid_gcode.py")
+%-->
 </pre>
 
+You can also find this script [on my Gitea server](https://git.xythobuz.de/thomas/gcode-tools/src/branch/master/generators/grid_gcode.py).
+
 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.
 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()
+<!--%
+include_url("https://git.xythobuz.de/thomas/gcode-tools/raw/branch/master/tools/send_gcode.py")
+%-->
 </pre>
 
+You can also find this script [on my Gitea server](https://git.xythobuz.de/thomas/gcode-tools/src/branch/master/tools/send_gcode.py).
+
 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.
 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))
+<!--%
+include_url("https://git.xythobuz.de/thomas/gcode-tools/raw/branch/master/generators/cut_test_gcode.py")
+%-->
 </pre>
 
+You can also find this script [on my Gitea server](https://git.xythobuz.de/thomas/gcode-tools/src/branch/master/generators/cut_test_gcode.py).
+
 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.
 

macros.py

 
 def restRequest(url):
     response = urllib.urlopen(url)
+    if response.getcode() != 200:
+        raise Exception("invalid response code", response.getcode())
     data = json.loads(response.read())
     return data
 
         print("<li><a href=\"" + a["browser_download_url"] + "\">" + a["name"] + "</a>" + ss)
     print("</ul></div>")
 
+def include_url(url):
+    response = urllib.urlopen(url)
+    if response.getcode() != 200:
+        raise Exception("invalid response code", response.getcode())
+    data = response.read()
+    print data,
+
 # -----------------------------------------------------------------------------
 # preconvert hooks
 # -----------------------------------------------------------------------------