initial commit

.gitignore

@@ -0,0 +1 @@
+*.pyc

README.md

@@ -0,0 +1,10 @@
+# G-Code Tools
+
+A collection of Python scripts to convert / generate G-Code.
+For more background see [the page about my laser engraver](https://www.xythobuz.de/laser-engraver.html).
+
+The directory `generators` contains scripts that generate G-Code by themselves.
+
+The directory `tools` contains scripts that convert or otherwise work with G-Code.
+
+See the README.md in each directory for details.

generators/README.md

@@ -0,0 +1,15 @@
+# Generators
+
+Scripts that generate G-Code by themselves.
+
+## square_gcode.py
+
+Very simple, just cuts out square shape.
+
+## grid_gcode.py
+
+Generates a centimeter grid with numerical graduations for engraving on a work surface.
+
+## cut_test_gcode.py
+
+Generates sheets of repeated shapes, cut with different parameters for each, to find optimal cutting speed and number of iterations for a new material.

generators/cut_test_gcode.py

@@ -0,0 +1,228 @@
+#!/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("G90")
+    write("G28")
+    write("G92 X0 Y-20")
+    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))

generators/grid_gcode.py

@@ -0,0 +1,172 @@
+#!/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("G28")
+    write("G92 X0 Y-20")
+    write("M3 I")
+    write("M3 S0")
+    write("")
+
+    # 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
+    write("; 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))
+    write("")
+
+    # horizontal lines
+    write("; 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))
+    write("")
+
+    # horizontal text
+    for x in range(0, w, d):
+        n = int(x / 10)
+        write("; number '" + str(n) + "' at x " + str(x))
+        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)
+    write("")
+
+    # vertical text
+    for y in range(d, h, d):
+        n = int(y / 10)
+        write("; number '" + str(n) + "' at y " + str(y))
+        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)
+    write("")
+
+    # footer
+    write("M5")
+    write("G0 X0 Y0 F" + str(speed_g0))

generators/square_gcode.py

@@ -0,0 +1,48 @@
+#!/usr/bin/env python
+
+filename = "square.gcode"
+w = 10
+h = 10
+n = 20
+pwr = 255
+speed_g0 = 3000
+speed_g1 = 500
+
+with open(filename, 'w') as f:
+    def write(s):
+        print(s)
+        f.write(s + "\n")
+
+    # header
+    write("G90")
+    write("G28")
+    write("G92 X0 Y-20")
+    write("M3 I")
+    write("M3 S0")
+    write("")
+
+    square = [
+        ( 0, 0 ),
+        ( w, 0 ),
+        ( w, h ),
+        ( 0, h ),
+    ]
+
+    # 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 Y0 S" + str(pwr) + " F" + str(speed_g1))
+
+    for i in range(0, n):
+        for x, y in square:
+            write("G1 X" + str(x) + " Y" + str(y) + " S" + str(pwr) + " F" + str(speed_g1))
+        write("")
+
+    # finish last line
+    write("G1 X0 Y0 S" + str(pwr) + " F" + str(speed_g1))
+    write("")
+
+    # footer
+    write("M5")
+    write("G0 X0 Y0 F" + str(speed_g0))

tools/README.md

@@ -0,0 +1,28 @@
+# Tools
+
+Scripts that convert or otherwise work with G-Code.
+
+## convert_lasergrbl.py
+
+Converts output from LaserGRBL to a format that can be understood by the Marlin firmware.
+
+## outline_gcode.py
+
+Takes all G1 move coordinates from a G-Code files to get the bounding box of the object, minimum and maximum coordinates in x and y axis.
+Then produces a whole lot of low-power moves along this bounding box.
+
+Useful to proplery place stock material on a laser cutting machine.
+
+## gcode_center_outline.py
+
+Combines the previous two scripts.
+First cleans up G-Code from LaserGRBL like in `convert_lasergrbl.py`.
+Also creates an outline as a separate file, like in `outline_gcode.py`.
+Both are then shifted as well to the center of my machine.
+
+Machine size is hardcoded in the script.
+
+## send_gcode.py
+
+Simple G-Code sender using pySerial to access serial port.
+For use with Marlin and possibly other RepRap compatible firmwares.

tools/convert_lasergrbl.py

@@ -0,0 +1,69 @@
+#!/usr/bin/env python
+
+import sys
+
+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
+
+def convert_gcode(fi, fo):
+    power = ""
+    speed = ""
+    mode_g0 = True
+
+    for line in fi:
+        if line.startswith("S"):
+            power = " " + line.rstrip()
+        elif line.startswith("F"):
+            speed = " " + line.rstrip()
+        elif line.startswith("M3 S0"):
+            fo.write(line)
+            fo.write("G0 X0 Y0 S0 F1000\n")
+            fo.write("G1 X1 Y0 S1 F1000\n")
+            fo.write("G0 X0 Y0 S0 F1000\n")
+            fo.write("G1 X0 Y1 S1 F1000\n")
+            fo.write("G0 X0 Y0 S0 F1000\n")
+        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)
+
+def main():
+    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]
+
+    with open(in_file, 'r') as fi, open(out_file, 'w') as fo:
+        convert_gcode(fi, fo)
+
+if __name__ == '__main__':
+    main()

tools/gcode_center_outline.py

@@ -0,0 +1,92 @@
+#!/usr/bin/env python
+
+import sys
+import os
+from outline_gcode import file_bounding_box, write_outline
+from convert_lasergrbl import convert_gcode
+
+machine_size = ( 208, 287 )
+
+def patch_offset(fi, fo, zp):
+    found_off = False
+    found_home = False
+    found_abs = False
+    for line in fi:
+        if line.startswith("G92"):
+            found_off = True
+        elif line.startswith("G28"):
+            found_home = True
+        elif line.startswith("G90"):
+            found_abs = True
+
+    fi.seek(0)
+
+    sx = "{:.3f}".format(zp[0])
+    sy = "{:.3f}".format(zp[1])
+
+    if found_off:
+        for line in fi:
+            if line.startswith("G92"):
+                fo.write("G92 X" + sx + " Y" + sy + "\n")
+            else:
+                fo.write(line)
+    elif found_home:
+        for line in fi:
+            fo.write(line)
+            if line.startswith("G28"):
+                fo.write("G92 X" + sx + " Y" + sy + "\n")
+    elif found_abs:
+        for line in fi:
+            fo.write(line)
+            if line.startswith("G90"):
+                fo.write("G92 X" + sx + " Y" + sy + "\n")
+    else:
+        fo.write("G92 X" + sx + " Y" + sy + "\n")
+        for line in fi:
+            fo.write(line)
+
+def main():
+    if len(sys.argv) < 2:
+        print("Usage:")
+        print("    " + sys.argv[0] + " input.nc")
+        sys.exit(1)
+
+    in_file = sys.argv[1]
+
+    out_tmp_file = os.path.splitext(in_file)[0] + '_tmp.gcode'
+    out_file = os.path.splitext(in_file)[0] + '.gcode'
+    outline_tmp_file = os.path.splitext(in_file)[0] + '_bb_tmp.gcode'
+    outline_file = os.path.splitext(in_file)[0] + '_bb.gcode'
+
+    for f in [ out_tmp_file, out_file, outline_tmp_file, outline_file ]:
+        if os.path.exists(f):
+            print("File exists: " + f)
+            sys.exit(1)
+
+    bb = ( None, None, None, None )
+    with open(in_file, 'r') as f:
+        bb = file_bounding_box(f)
+
+    x_min, x_max, y_min, y_max = bb
+
+    size = ( x_max - x_min, y_max - y_min )
+    off = ( -x_min + (machine_size[0] - size[0]) / 2.0, -y_min + (machine_size[1] - size[1]) / 2.0 )
+    zero_point = ( -off[0], -off[1] )
+
+    with open(in_file, 'r') as fi, open(out_tmp_file, 'w') as fo:
+        convert_gcode(fi, fo)
+
+    with open(out_tmp_file, 'r') as fi, open(out_file, 'w') as fo:
+        patch_offset(fi, fo, zero_point)
+
+    with open(outline_tmp_file, 'w') as f:
+        write_outline(f, bb)
+
+    with open(outline_tmp_file, 'r') as fi, open(outline_file, 'w') as fo:
+        patch_offset(fi, fo, zero_point)
+
+    os.remove(out_tmp_file)
+    os.remove(outline_tmp_file)
+
+if __name__ == '__main__':
+    main()

tools/outline_gcode.py

@@ -0,0 +1,102 @@
+#!/usr/bin/env python
+
+import sys
+
+pwr = 1
+iterations = 100
+speed = 3000
+
+def file_bounding_box(f):
+    x_min = None
+    x_max = None
+    y_min = None
+    y_max = None
+    mode_g1 = False
+
+    for line in f:
+        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
+
+    return ( x_min, x_max, y_min, y_max )
+
+def write_outline(f, bb):
+    def write(s):
+        #print(s)
+        f.write(s + "\n")
+
+    x_min, x_max, y_min, y_max = bb
+
+    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 ),
+    ]
+
+    # header
+    write("G90")
+    write("G28")
+    write("G92 X0 Y-20")
+    write("M3 I")
+    write("M3 S0")
+
+    write("G0 X0 Y0 S0 F" + str(speed))
+    write("G1 X1 Y0 S1 F" + str(speed))
+    write("G0 X0 Y0 S0 F" + str(speed))
+    write("G1 X0 Y1 S1 F" + str(speed))
+    write("G0 X0 Y0 S0 F" + str(speed))
+
+    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))
+
+def main():
+    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]
+
+    with open(in_file, 'r') as f:
+        bb = file_bounding_box(f)
+
+    with open(out_file, 'w') as f:
+        write_outline(f, bb)
+
+if __name__ == '__main__':
+    main()

tools/send_gcode.py

@@ -0,0 +1,125 @@
+#!/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
+
+        print("workaround. kill when done.")
+        while True:
+            pass
+    except KeyboardInterrupt:
+        print("user interrupt. aborting.")
+        abort_print(True)
+
+    port.close()
+
+if __name__ == '__main__':
+    main()