diff --git a/src/Mod/Path/PathScripts/dynapath_post.py b/src/Mod/Path/PathScripts/dynapath_post.py new file mode 100644 index 000000000..58913d27c --- /dev/null +++ b/src/Mod/Path/PathScripts/dynapath_post.py @@ -0,0 +1,266 @@ + #*************************************************************************** +#* (c) sliptonic (shopinthewoods@gmail.com) 2014 * +#* * +#* This file is part of the FreeCAD CAx development system. * +#* * +#* This program is free software; you can redistribute it and/or modify * +#* it under the terms of the GNU Lesser General Public License (LGPL) * +#* as published by the Free Software Foundation; either version 2 of * +#* the License, or (at your option) any later version. * +#* for detail see the LICENCE text file. * +#* * +#* FreeCAD is distributed in the hope that it will be useful, * +#* but WITHOUT ANY WARRANTY; without even the implied warranty of * +#* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * +#* GNU Lesser General Public License for more details. * +#* * +#* You should have received a copy of the GNU Library General Public * +#* License along with FreeCAD; if not, write to the Free Software * +#* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 * +#* USA * +#* * +#* This file has been modified from Sliptonis original Linux CNC post * +#* for use with a Dynapath 20 controller all changes and Modifications * +#* (c) Linden (Linden@aktfast.net) 2016 * +#* * +#***************************************************************************/ + + +TOOLTIP=''' +This is a postprocessor file for the Path workbench. It is used to +take a pseudo-gcode fragment outputted by a Path object, and output +real GCode suitable for a Tree Journyman 325 3 axis mill with Dynapath 20 controller in MM. +This is a work in progress and very few of the functions available on the Dynapath have been +implemented at this time. +This postprocessor, once placed in the appropriate PathScripts folder, can be used directly +from inside FreeCAD, via the GUI importer or via python scripts with: + +Done +Coordinate Decimal limited to 3 places +Feed limited to hole number no decimal +Speed Limited to hole number no decimal +Machine Travel Limits Set to approximate values +Line numbers start at one and incremental by 1 +Set preamble +Set postamble + +To Do +Change G20 and G21 to G70 and G71 for metric or imperial units +Convert arcs to absolute +Strip comments and white spaces +Add file name in brackets limited to 8 alpha numeric no spaces all caps as first line in file +Change Q to K For depth of peck on G83 +Fix tool change +Limit comments length and characters to Uppercase, alpha numeric and spaces add / prior to coments + +import linuxcnc_post +linuxcnc_post.export(object,"/path/to/file.ncc") +''' + +import datetime +now = datetime.datetime.now() +from PathScripts import PostUtils + +#These globals set common customization preferences +OUTPUT_COMMENTS = True +OUTPUT_HEADER = False +OUTPUT_LINE_NUMBERS = False +SHOW_EDITOR = True +MODAL = False #if true commands are suppressed if the same as previous line. +COMMAND_SPACE = " " +LINENR = 1 #line number starting value + +#These globals will be reflected in the Machine configuration of the project +UNITS = "G21" #G21 for metric, G20 for us standard +MACHINE_NAME = "Tree MM" +CORNER_MIN = {'x':-340, 'y':0, 'z':0 } +CORNER_MAX = {'x':340, 'y':-355, 'z':-150 } + +#Preamble text will appear at the beginning of the GCODE output file. +PREAMBLE = '''G17 +G90 +;G90.1 ;needed for simulation only +G80 +G40 +''' + +#Postamble text will appear following the last operation. +POSTAMBLE = '''M09 +M05 +G80 +G40 +G17 +G90 +M30 +''' + + +#Pre operation text will be inserted before every operation +PRE_OPERATION = '''''' + +#Post operation text will be inserted after every operation +POST_OPERATION = '''''' + +#Tool Change commands will be inserted before a tool change +TOOL_CHANGE = '''''' + + +# to distinguish python built-in open function from the one declared below +if open.__module__ == '__builtin__': + pythonopen = open + + +def export(objectslist,filename): + global UNITS + for obj in objectslist: + if not hasattr(obj,"Path"): + print "the object " + obj.Name + " is not a path. Please select only path and Compounds." + return + + print "postprocessing..." + gcode = "" + + #Find the machine. + #The user my have overriden post processor defaults in the GUI. Make sure we're using the current values in the Machine Def. + myMachine = None + for pathobj in objectslist: + if hasattr(pathobj,"Group"): #We have a compound or project. + for p in pathobj.Group: + if p.Name == "Machine": + myMachine = p + if myMachine is None: + print "No machine found in this project" + else: + if myMachine.MachineUnits == "Metric": + UNITS = "G21" + else: + UNITS = "G20" + + + # write header + if OUTPUT_HEADER: + gcode += linenumber() + "(Exported by FreeCAD)\n" + gcode += linenumber() + "(Post Processor: " + __name__ +")\n" + gcode += linenumber() + "(Output Time:"+str(now)+")\n" + + #Write the preamble + if OUTPUT_COMMENTS: gcode += linenumber() + "(begin preamble)\n" + for line in PREAMBLE.splitlines(True): + gcode += linenumber() + line + gcode += linenumber() + UNITS + "\n" + + for obj in objectslist: + + #do the pre_op + if OUTPUT_COMMENTS: gcode += linenumber() + "(begin operation: " + obj.Label + ")\n" + for line in PRE_OPERATION.splitlines(True): + gcode += linenumber() + line + + gcode += parse(obj) + + #do the post_op + if OUTPUT_COMMENTS: gcode += linenumber() + "(finish operation: " + obj.Label + ")\n" + for line in POST_OPERATION.splitlines(True): + gcode += linenumber() + line + + #do the post_amble + + if OUTPUT_COMMENTS: gcode += "(begin postamble)\n" + for line in POSTAMBLE.splitlines(True): + gcode += linenumber() + line + + if SHOW_EDITOR: + dia = PostUtils.GCodeEditorDialog() + dia.editor.setText(gcode) + result = dia.exec_() + if result: + final = dia.editor.toPlainText() + else: + final = gcode + else: + final = gcode + + print "done postprocessing." + + gfile = pythonopen(filename,"wb") + gfile.write(gcode) + gfile.close() + + +def linenumber(): + global LINENR + if OUTPUT_LINE_NUMBERS == True: + LINENR += 1 + return "N" + str(LINENR) + " " + return "" + +def parse(pathobj): + out = "" + lastcommand = None + + #params = ['X','Y','Z','A','B','I','J','K','F','S'] #This list control the order of parameters + params = ['X','Y','Z','A','B','I','J','F','S','T','Q','R','L'] #linuxcnc doesn't want K properties on XY plane Arcs need work. + + if hasattr(pathobj,"Group"): #We have a compound or project. + if OUTPUT_COMMENTS: out += linenumber() + "(compound: " + pathobj.Label + ")\n" + for p in pathobj.Group: + out += parse(p) + return out + else: #parsing simple path + + if not hasattr(pathobj,"Path"): #groups might contain non-path things like stock. + return out + + if OUTPUT_COMMENTS: out += linenumber() + "(Path: " + pathobj.Label + ")\n" + + for c in pathobj.Path.Commands: + outstring = [] + command = c.Name + outstring.append(command) + # if modal: only print the command if it is not the same as the last one + if MODAL == True: + if command == lastcommand: + outstring.pop(0) + + + # Now add the remaining parameters in order + for param in params: + if param in c.Parameters: + if param == 'F': + outstring.append(param + format(c.Parameters['F'], '.0f')) + elif param == 'S': + outstring.append(param + format(c.Parameters[param], '.0f')) + elif param == 'T': + outstring.append(param + format(c.Parameters['T'], '.0f')) + else: + outstring.append(param + format(c.Parameters[param], '.3f')) + + # store the latest command + lastcommand = command + + # Check for Tool Change: + if command == 'M6': + if OUTPUT_COMMENTS: out += linenumber() + "(begin toolchange)\n" + for line in TOOL_CHANGE.splitlines(True): + out += linenumber() + line + + if command == "message": + if OUTPUT_COMMENTS == False: + out = [] + else: + outstring.pop(0) #remove the command + + #prepend a line number and append a newline + if len(outstring) >= 1: + if OUTPUT_LINE_NUMBERS: + outstring.insert(0,(linenumber())) + + #append the line to the final output + for w in outstring: + out += w + COMMAND_SPACE + out = out.strip() + "\n" + + return out + +print __name__ + " gcode postprocessor loaded." + diff --git a/src/Mod/Path/PathScripts/generic_post.py b/src/Mod/Path/PathScripts/generic_post.py new file mode 100644 index 000000000..d9812a366 --- /dev/null +++ b/src/Mod/Path/PathScripts/generic_post.py @@ -0,0 +1,420 @@ +# -*- coding: utf-8 -*- + +#*************************************************************************** +#* * +#* Copyright (c) 2016 Christoph Blaue * +#* * +#* This program is free software; you can redistribute it and/or modify * +#* it under the terms of the GNU Lesser General Public License (LGPL) * +#* as published by the Free Software Foundation; either version 2 of * +#* the License, or (at your option) any later version. * +#* for detail see the LICENCE text file. * +#* * +#* This program is distributed in the hope that it will be useful, * +#* but WITHOUT ANY WARRANTY; without even the implied warranty of * +#* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * +#* GNU Library General Public License for more details. * +#* * +#* You should have received a copy of the GNU Library General Public * +#* License along with this program; if not, write to the Free Software * +#* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 * +#* USA * +#* * +#*************************************************************************** + +TOOLTIP='''Post processor for Maho M 600E mill + +Machines with Philips or Heidenhain control should be very easy to adapt. + +The post processor is configurable by changing the values of constants. +No programming experience required. This can make a generated g-code +program more readable and since older machines have very +limited memory it seems sensible to reduce the number of commands and +parameters, like e.g. suppress the units in the header and at every hop. +''' + +# reload in python console: +# import maho_post +# reload(maho_post) + +import FreeCAD +import time +import Path, PathScripts +from PathScripts import PostUtils +import math + +#*************************************************************************** +# user editable stuff here + +MACHINE_NAME = 'Maho 600E' +CORNER_MIN = {'x':-51.877, 'y':0, 'z':0 } #use metric for internal units +CORNER_MAX = {'x':591.5, 'y':391.498, 'z':391.5 } #use metric for internal units + +UNITS = 'G21' # use metric units + # possible values: + # 'G20' for inches, + # 'G21' for metric units. + # a mapping to different GCodes is handled in the GCODE MAP below + +UNITS_INCLUDED = False # do not include the units in the GCode program + # possible values: + # True if units should be included + # False if units should not be included + # usually the units to be used are defined in the machine constants and almost never change, + # so this can be set to False. + +COMMENT = '' + # possible values: + # ';' centroid or sinumerik comment symbol, + # '' leave blank for bracketed comments style "(comment comment comment)" + # '...' any other symbol to start comments + # currently this can be only one symbol, if it should be a sequence of characters + # in PostUtils.py the line + # if len(commentsym)==1: + # should be changed to + # if len(commentsym)>1: + +SHOW_EDITOR = True + # possible values: + # True before the file is written it is shown to the user for inspection + # False the file is written directly + +LINENUMBERS = True + # possible values: + # True if linenumbers of the form N1 N2 ... should be included + # False linennumbers are suppressed + # if linenumbers are used, header and footer get numbered as well + +STARTLINENR = 1 # first linenumber used + # possible values: + # any integer value >= 0 + # to have the possibility to change some initial values directly at the CNC machine + # without renumbering the rest it is possible to start the numbering of the file with some value > 0 + +LINENUMBER_INCREMENT = 1 + # possible values: + # any integer value > 0 + # similar to STARTLINENR it is possible to leave gaps in the linenumbering of subsequent lines + +MODAL = True + # possible values: + # True repeated GCodes in subsequent lines are suppressed, like in the following snippet + # G1 X10 Y20 + # X10 Y30 + # False repeated GCodes in subsequent lines are repeated in the GCode file + # G1 X10 Y20 + # G1 X10 Y30 + +MODALPARAMS = ['X','Y','Z','S','F'] # suppress these parameters if they haven't changed + # possible values: + # any list of GCode parameters + # if a parameter doesn't change from one line to the next ( or even further) it is suppressed. + # Example: + # G1 X10 Y20 + # G1 Y30 + # If in addition MODAL is set to True, the generated GCode changes to + # G1 X10 Y20 + # Y30 + +SWAP_G2_G3 = True # some machines have the sign of the X-axis swapped, so they behave like milling from the bottom + # possible values: + # True if left and right turns are to be swapped + # False don't swap + # this might be special with some maho machines or even with mine and might be changed in the machine constants as well + +SWAP_Y_Z = True # machines with an angle milling head do not switch axes, so we do it here + # possible values: + # True if Y and Z values have to be swapped + # False do not swap + # For vertical milling machines the Z-axis is horizontal (of course). + # If they have an angle milling head, they mill vertical, alas the Z-axis stays horizontal. + # With this parameter we can swap the output values of Y and Z. + # For commands G2 and G3 this means that J and K are swapped as well + +ABSOLUTE_CIRCLE_CENTER = True + # possible values: + # True use absolute values for the circle center in commands G2, G3 + # False values for I, J, K are given relative to the last point + +USE_RADIUS_IF_POSSIBLE = True + # possible values: + # True if in commands G2 and G3 the usage of radius R is preferred + # False if in commands G2 and G3 we use always I and J + # When milling arcs there are two reasons to use the radius instead of the center: + # 1. the GCode program might be easier to understand + # 2. Some machines seem to have a different scheme for calculating / rounding the values of the center + # Thus it is possible that the machine complains, that the endpoint of the arc does not lie on the arc. + # Using the radius instead avoids this problem. + # The post processor takes care of the fact, that only angles <= 180 degrees can be used with R + # for larger angles the center is used independent of the setting of this constant + +RADIUS_COMMENT = True + # possible values: + # True for better understanding the radius of an arc is included as a comment + # False no additional comment is included + # In case the comments are included they are always included with the bracketing syntax like '(R20.456)' + # and never with the comment symbol, because the radius might appear in the middle of a line. + +GCODE_MAP = {'M1':'M0', 'M6':'M66', 'G20':'G70', 'G21':'G71'} # cb: this could be used to swap G2/G3 + # possible values: + # Comma separated list of values of the form 'sourceGCode':'targetGCode' + # + # Although the basic movement commands G0, G1, G2 seem to be used uniformly in different GCode dialects, + # this is not the case for all commands. + # E.g the Maho dialect uses G70 and G71 for the units inches vs. metric. + # The map {'M1':'M0', 'G20':'G70', 'G21':'G71'} maps the optional stop command M1 to M0, + # because some Maho machines do not have the optional button on its panel + # in addition it maps inches G20 to G70 and metric G21 to G71 + +AXIS_DECIMALS = 3 + # possible values: + # integer >= 0 + +FEED_DECIMALS = 2 + # possible values: + # integer >= 0 + +SPINDLE_DECIMALS = 0 + # possible values: + # integer >= 0 + +# The header is divided into two parts, one is dynamic, the other is a static GCode header. +# If the current selection and the current time should be included in the header, +# it has to be generated at execution time, and thus it cannot be held in constant values. +# The last linefeed should be ommitted, it is inserted automatically +# linenumbers are inserted automatically if LINENUMBERS is True +# if you don't want to use this header you have to provide a minimal function +# def mkHeader(selection): +# return '' + + + +def mkHeader(selection): + # this is within a function, because otherwise filename and time don't change when changing the FreeCAD project +# now = datetime.datetime.now() + now = time.strftime("%Y-%m-%d %H:%M") + originfile = FreeCAD.ActiveDocument.FileName + headerNoNumber = "%PM\n" # this line gets no linenumber + headerNoNumber += "N9XXX (" + selection[0].Description + ", " + now + ")\n" # this line gets no linenumber, it is already a specially numbered + header = "" +# header += "(Output Time:" + str(now) + ")\n" + header += "(" + originfile + ")\n" + header += "(Exported by FreeCAD)\n" + header += "(Post Processor: " + __name__ +")\n" + header += "(Target machine: " + MACHINE_NAME + ")" + return headerNoNumber + linenumberify(header) + +GCODE_HEADER = "" # do not terminate with a newline, it is inserted by linenumberify +#GCODE_HEADER = "G40 G90" # do not terminate with a newline, it is inserted by linenumberify + #possible values: + # any sequence of GCode, multiple lines are welcome + # this constant header follows the text generated by the function mkheader + # linenumbers are inserted automatically if LINENUMBERS is True + +GCODE_FOOTER = "M30" # do not terminate with a newline, it is inserted by linenumberify + #possible values: + # any sequence of GCode, multiple lines are welcome + # the footer is used to clean things up, reset modal commands and stop the machine + # linenumbers are inserted automatically if LINENUMBERS is True + +# don't edit with the stuff below the next line unless you know what you're doing :) +#*************************************************************************** + +linenr = 0 # variable has to be global because it is used by linenumberify and export + +if open.__module__ == '__builtin__': + pythonopen = open + +def angleUnder180(command,lastX,lastY,x,y,i,j): + # radius R can be used iff angle is < 180. + # This is the case + # if the previous point is left of the current and the center is below (or on) the connection line + # or if the previous point is right of the current and the center is above (or on) the connection line + middleOfLineY = (lastY + y)/2 + centerY = lastY + j + if ((command == 'G2' and ( (lastX == x and ((lastY=0) or (lastY > y and i <= 0))) or (lastX < x and centerY <= middleOfLineY) or (lastX > x and centerY >= middleOfLineY))) + or (command == 'G3' and ((lastX == x and ((lastY y and i >= 0))) or (lastX < x and centerY >= middleOfLineY) or (lastX > x and centerY <= middleOfLineY)))): + return True + else: + return False + +def mapGCode(command): + if command in GCODE_MAP: + mappedCommand = GCODE_MAP[command] + else: + mappedCommand = command + if SWAP_G2_G3: + if command == 'G2': + mappedCommand = 'G3' + elif command == 'G3': + mappedCommand = 'G2' + return mappedCommand + +def linenumberify(GCodeString): + # add a linenumber at every beginning of line + global linenr + if not LINENUMBERS: + result = GCodeString + "\n" + else: + result = ''; + strList = GCodeString.split("\n") + for s in strList: + if s: + # only non empty lines get numbered. the special lines "%PM" and prognumber "N9XXX" are skipped + + result += "N" + str(linenr) + " " + s + "\n" + linenr += LINENUMBER_INCREMENT + else: + result += s + "\n" + return result + +def export(selection,filename): + global linenr + linenr = STARTLINENR + lastX = 0 + lastY = 0 + lastZ = 0 + params = ['X','Y','Z','A','B','I','J','F','H','S','T','Q','R','L'] #Using XY plane most of the time so skipping K + modalParamsDict = dict() + for mp in MODALPARAMS: + modalParamsDict[mp] = None + for obj in selection: + if not hasattr(obj,"Path"): + print "the object " + obj.Name + " is not a path. Please select only path and Compounds." + return + myMachine = None + for pathobj in selection: + if hasattr(pathobj,"Group"): #We have a compound or selection. + for p in pathobj.Group: + if p.Name == "Machine": + myMachine = p + if myMachine is None: + print "No machine found in this selection" + else: + if myMachine.MachineUnits == "Metric": + UNITS = "G21" + else: + UNITS = "G20" + + gcode ='' + gcode+= mkHeader(selection) + gcode+= linenumberify(GCODE_HEADER) + if UNITS_INCLUDED: + gcode += linenumberify(mapGCode(UNITS)) + + lastcommand = None + + gobjects = [] + for g in selection[0].Group: + if g.Name <>'Machine': #filtering out gcode home position from Machine object + gobjects.append(g) + + for obj in gobjects: + if hasattr(obj,'GComment'): + gcode += linenumberify('(' + obj.GComment + ')') + for c in obj.Path.Commands: + outstring = [] + command = c.Name + + if (command != UNITS or UNITS_INCLUDED): + if command[0]=='(': + command = PostUtils.fcoms(command, COMMENT) + mappedCommand = mapGCode(command) # the mapping is done for output only! For internal things we still use the old value. + + if not MODAL or command != lastcommand: + outstring.append(mappedCommand) +# if MODAL == True: ) +# #\better: append iff MODAL == False ) +# if command == lastcommand: ) +# outstring.pop(0!#\ ) + if c.Parameters >= 1: + for param in params: + if param in c.Parameters: + if (param in MODALPARAMS) and (modalParamsDict[str(param)] == c.Parameters[str(param)]): + # do nothing or append white space + outstring.append(' ') + elif param == 'F': + outstring.append(param + PostUtils.fmt(c.Parameters['F'], FEED_DECIMALS,UNITS)) + elif param == 'H': + outstring.append(param + str(int(c.Parameters['H']))) + elif param == 'S': + outstring.append(param + PostUtils.fmt(c.Parameters['S'], SPINDLE_DECIMALS,'G21')) #rpm is unitless-therefore I had to 'fake it out' by using metric units which don't get converted from entered value + elif param == 'T': + outstring.append(param + str(int(c.Parameters['T']))) + elif param == 'I' and (command == 'G2' or command == 'G3'): + # this is the special case for circular paths, where relative coordinates have to be changed to absolute + i = c.Parameters['I'] + # calculate the radius r + j = c.Parameters['J'] + r = math.sqrt(i**2 + j**2) + if USE_RADIUS_IF_POSSIBLE and angleUnder180(command,lastX,lastY,c.Parameters['X'],c.Parameters['Y'],i,j): + outstring.append('R' + PostUtils.fmt(r,AXIS_DECIMALS,UNITS)) + else: + if RADIUS_COMMENT: + outstring.append('(R' + PostUtils.fmt(r,AXIS_DECIMALS,UNITS) + ')') + if ABSOLUTE_CIRCLE_CENTER: + i += lastX + outstring.append(param + PostUtils.fmt(i,AXIS_DECIMALS,UNITS)) + elif param == 'J' and (command == 'G2' or command == 'G3'): + # this is the special case for circular paths, where incremental center has to be changed to absolute center + i = c.Parameters['I'] + j = c.Parameters['J'] + if USE_RADIUS_IF_POSSIBLE and angleUnder180(command,lastX,lastY,c.Parameters['X'],c.Parameters['Y'],i,j): + # R is handled with the I parameter, here: do nothing at all, keep the structure as with I command + pass + else: + if ABSOLUTE_CIRCLE_CENTER: + j += lastY + if SWAP_Y_Z: + # we have to swap j and k as well + outstring.append('K' + PostUtils.fmt(j,AXIS_DECIMALS,UNITS)) + else: + outstring.append(param + PostUtils.fmt(j,AXIS_DECIMALS,UNITS)) + elif param == 'K' and (command == 'G2' or command == 'G3'): + # this is the special case for circular paths, where incremental center has to be changed to absolute center + outstring.append('(' + param + PostUtils.fmt(c.Parameters[param],AXIS_DECIMALS,UNITS) + ')') + z = c.Parameters['Z'] + k = c.Parameters['K'] + if USE_RADIUS_IF_POSSIBLE and angleUnder180(command,lastX,lastY,c.Parameters['X'],c.Parameters['Y'],i,j): + # R is handled with the I parameter, here: do nothing at all, keep the structure as with I command + pass + else: + if ABSOLUTE_CIRCLE_CENTER: + k += lastZ + if SWAP_Y_Z: + # we have to swap j and k as well + outstring.append('J' + PostUtils.fmt(j,AXIS_DECIMALS,UNITS)) + else: + outstring.append(param + PostUtils.fmt(j,AXIS_DECIMALS,UNITS)) + elif param == 'Y' and SWAP_Y_Z: + outstring.append('Z' + PostUtils.fmt(c.Parameters[param],AXIS_DECIMALS,UNITS)) + elif param == 'Z' and SWAP_Y_Z: + outstring.append('Y' + PostUtils.fmt(c.Parameters[param],AXIS_DECIMALS,UNITS)) + else: + outstring.append(param + PostUtils.fmt(c.Parameters[param],AXIS_DECIMALS,UNITS)) + + if param in MODALPARAMS: + modalParamsDict[str(param)] = c.Parameters[param] + # save the last X, Y, Z values + if 'X' in c.Parameters: + lastX = c.Parameters['X'] + if 'Y' in c.Parameters: + lastY = c.Parameters['Y'] + if 'Z' in c.Parameters: + lastZ = c.Parameters['Z'] + outstr = str(outstring) + outstr =outstr.replace(']','') + outstr =outstr.replace('[','') + outstr =outstr.replace("'",'') + outstr =outstr.replace(",",'') + if LINENUMBERS: + gcode += "N" + str(linenr) + " " + linenr += LINENUMBER_INCREMENT + gcode+= outstr + '\n' + lastcommand = c.Name + gcode+= linenumberify(GCODE_FOOTER) + if SHOW_EDITOR: + PostUtils.editor(gcode) + gfile = pythonopen(filename,"wb") + gfile.write(gcode) + gfile.close()