# *************************************************************************** # * Copyright (c) 2014 sliptonic * # * Copyright (c) 2025 MiKlo # * * # * 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 * # * * # ***************************************************************************/ import FreeCAD from FreeCAD import Units import Path import argparse import datetime import shlex import Path.Post.Utils as PostUtils import PathScripts.PathUtils as PathUtils from builtins import open as pyopen TOOLTIP = """ This is a postprocessor file for the Path workbench. It is used to take a pseudo-G-code fragment outputted by a Path object, and output real G-code suitable for a cncgraf 3 axis mill. 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: import cncgraf_post cncgraf_post.export(object,"/path/to/file.ncc","") """ now = datetime.datetime.now() parser = argparse.ArgumentParser(prog="mach3_4", add_help=False) parser.add_argument("--no-header", action="store_true", help="suppress header output") parser.add_argument("--no-comments", action="store_true", help="suppress comment output") parser.add_argument("--line-numbers", action="store_true", help="prefix with line numbers") parser.add_argument( "--no-show-editor", action="store_true", help="don't pop up editor before writing output", ) parser.add_argument("--precision", default="3", help="number of digits of precision, default=3") parser.add_argument( "--preamble", help='set commands to be issued before the first command, default="G17\nG90"', ) parser.add_argument( "--postamble", help='set commands to be issued after the last command, default="M05\nG17 G90\nM2"', ) parser.add_argument( "--inches", action="store_true", help="Convert output for US imperial mode (G20)" ) parser.add_argument( "--modal", action="store_true", help="Output the Same G-command Name USE NonModal Mode", ) parser.add_argument("--axis-modal", action="store_true", help="Output the Same Axis Value Mode") parser.add_argument( "--no-tlo", action="store_true", help="suppress tool length offset (G43) following tool changes", ) parser.add_argument( "--translate_drill", action="store_true", help="translate drill cycles G81, G82 & G83 in G0/G1 movements", ) TOOLTIP_ARGS = parser.format_help() # These globals set common customization preferences OUTPUT_COMMENTS = True OUTPUT_HEADER = True OUTPUT_LINE_NUMBERS = False SHOW_EDITOR = True MODAL = False # if true commands are suppressed if the same as previous line. USE_TLO = True # if true G43 will be output following tool changes OUTPUT_DOUBLES = True # if false duplicate axis values are suppressed if the same as previous line. COMMAND_SPACE = " " LINENR = 100 # 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 UNIT_SPEED_FORMAT = "mm/min" UNIT_FORMAT = "mm" MACHINE_NAME = "mach3_4" CORNER_MIN = {"x": 0, "y": 0, "z": 0} CORNER_MAX = {"x": 500, "y": 300, "z": 300} PRECISION = 3 # Preamble text will appear at the beginning of the GCODE output file. PREAMBLE = """G17 G54 G40 G49 G80 G90 """ # Postamble text will appear following the last operation. POSTAMBLE = """M05 G17 G54 G90 G80 G40 M2 """ # 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 = """""" # copy code for '--translate_drill' from grbl postprocessor TRANSLATE_DRILL_CYCLES = False # If true, G81, G82 & G83 are translated in G0/G1 moves DRILL_RETRACT_MODE = ( "G98" # Default value of drill retractations (CURRENT_Z) other possible value is G99 ) MOTION_MODE = "G90" # G90 for absolute moves, G91 for relative # *************************************************************************** # * Internal global variables # *************************************************************************** MOTION_COMMANDS = [ "G0", "G00", "G1", "G01", "G2", "G02", "G3", "G03", ] # Motion gCode commands definition RAPID_MOVES = ["G0", "G00"] # Rapid moves gCode commands definition SUPPRESS_COMMANDS = [] # These commands are ignored by commenting them out COMMAND_SPACE = " " # Global variables storing current position CURRENT_X = 0 CURRENT_Y = 0 CURRENT_Z = 0 def processArguments(argstring): global OUTPUT_HEADER global OUTPUT_COMMENTS global OUTPUT_LINE_NUMBERS global SHOW_EDITOR global PRECISION global PREAMBLE global POSTAMBLE global UNITS global UNIT_SPEED_FORMAT global UNIT_FORMAT global MODAL global USE_TLO global OUTPUT_DOUBLES global TRANSLATE_DRILL_CYCLES try: args = parser.parse_args(shlex.split(argstring)) if args.no_header: OUTPUT_HEADER = False if args.no_comments: OUTPUT_COMMENTS = False if args.line_numbers: OUTPUT_LINE_NUMBERS = True if args.no_show_editor: SHOW_EDITOR = False print("Show editor = %d" % SHOW_EDITOR) PRECISION = args.precision if args.preamble is not None: PREAMBLE = args.preamble if args.postamble is not None: POSTAMBLE = args.postamble if args.inches: UNITS = "G20" UNIT_SPEED_FORMAT = "in/min" UNIT_FORMAT = "in" PRECISION = 4 if args.modal: MODAL = True if args.no_tlo: USE_TLO = False if args.axis_modal: print("here") OUTPUT_DOUBLES = False if args.translate_drill: TRANSLATE_DRILL_CYCLES = True except Exception: return False return True def export(objectslist, filename, argstring): if not processArguments(argstring): return None global UNITS global UNIT_FORMAT global UNIT_SPEED_FORMAT global MOTION_MODE global SUPPRESS_COMMANDS 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 None print("postprocessing...") gcode = "" # write header if OUTPUT_HEADER: gcode += linenumber() + "(Exported by FreeCAD)\n" gcode += linenumber() + "(Post Processor: " + __name__ + ")\n" gcode += linenumber() + "(Output Time:" + str(now) + ")\n" # Check canned cycles for drilling if TRANSLATE_DRILL_CYCLES: if len(SUPPRESS_COMMANDS) == 0: SUPPRESS_COMMANDS = ["G99", "G98", "G80"] else: SUPPRESS_COMMANDS += ["G99", "G98", "G80"] # Write the preamble if OUTPUT_COMMENTS: gcode += linenumber() + "(begin preamble)\n" for line in PREAMBLE.splitlines(False): gcode += linenumber() + line + "\n" gcode += linenumber() + UNITS + "\n" # verify if PREAMBLE have changed MOTION_MODE or UNITS if "G90" in PREAMBLE: MOTION_MODE = "G90" elif "G91" in PREAMBLE: MOTION_MODE = "G91" else: gcode += linenumber() + MOTION_MODE + "\n" for obj in objectslist: # Skip inactive operations if hasattr(obj, "Active"): if not obj.Active: continue if hasattr(obj, "Base") and hasattr(obj.Base, "Active"): if not obj.Base.Active: continue # do the pre_op if OUTPUT_COMMENTS: gcode += linenumber() + "(begin operation: %s)\n" % obj.Label gcode += linenumber() + "(machine: %s, %s)\n" % ( MACHINE_NAME, UNIT_SPEED_FORMAT, ) for line in PRE_OPERATION.splitlines(True): gcode += linenumber() + line # get coolant mode coolantMode = "None" if hasattr(obj, "CoolantMode") or hasattr(obj, "Base") and hasattr(obj.Base, "CoolantMode"): if hasattr(obj, "CoolantMode"): coolantMode = obj.CoolantMode else: coolantMode = obj.Base.CoolantMode # turn coolant on if required if OUTPUT_COMMENTS: if not coolantMode == "None": gcode += linenumber() + "(Coolant On:" + coolantMode + ")\n" if coolantMode == "Flood": gcode += linenumber() + "M8" + "\n" if coolantMode == "Mist": gcode += linenumber() + "M7" + "\n" # process the operation gcode gcode += parse(obj) # do the post_op if OUTPUT_COMMENTS: gcode += linenumber() + "(finish operation: %s)\n" % obj.Label for line in POST_OPERATION.splitlines(True): gcode += linenumber() + line # turn coolant off if required if not coolantMode == "None": if OUTPUT_COMMENTS: gcode += linenumber() + "(Coolant Off:" + coolantMode + ")\n" gcode += linenumber() + "M9" + "\n" # do the post_amble if OUTPUT_COMMENTS: gcode += "(begin postamble)\n" for line in POSTAMBLE.splitlines(True): gcode += linenumber() + line if FreeCAD.GuiUp and 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.") if not filename == "-": gfile = pyopen(filename, "w") gfile.write(final) gfile.close() return final def linenumber(): global LINENR if OUTPUT_LINE_NUMBERS is True: LINENR += 10 return "N" + str(LINENR) + " " return "" def format_outstring(strTable): global COMMAND_SPACE # construct the line for the final output s = "" for w in strTable: s += w + COMMAND_SPACE s = s.strip() return s def parse(pathobj): global PRECISION global MODAL global OUTPUT_DOUBLES global UNIT_FORMAT global UNIT_SPEED_FORMAT global DRILL_RETRACT_MODE global MOTION_MODE global CURRENT_X global CURRENT_Y global CURRENT_Z out = "" lastcommand = None precision_string = "." + str(PRECISION) + "f" currLocation = {} # keep track for no doubles # the order of parameters # mach3_4 doesn't want K properties on XY plane Arcs need work. params = [ "X", "Y", "Z", "A", "B", "C", "I", "J", "F", "S", "T", "Q", "R", "L", "H", "D", "P", ] firstmove = Path.Command("G0", {"X": -1, "Y": -1, "Z": -1, "F": 0.0}) currLocation.update(firstmove.Parameters) # set First location Parameters 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 # groups might contain non-path things like stock. if not hasattr(pathobj, "Path"): return out # if OUTPUT_COMMENTS: # out += linenumber() + "(" + pathobj.Label + ")\n" adaptiveOp = False opHorizRapid = 0 opVertRapid = 0 if "Adaptive" in pathobj.Name: adaptiveOp = True if hasattr(pathobj, "ToolController"): if ( hasattr(pathobj.ToolController, "HorizRapid") and pathobj.ToolController.HorizRapid > 0 ): opHorizRapid = Units.Quantity( pathobj.ToolController.HorizRapid, FreeCAD.Units.Velocity ) else: FreeCAD.Console.PrintWarning( "Tool Controller Horizontal Rapid Values are unset" + "\n" ) if ( hasattr(pathobj.ToolController, "VertRapid") and pathobj.ToolController.VertRapid > 0 ): opVertRapid = Units.Quantity( pathobj.ToolController.VertRapid, FreeCAD.Units.Velocity ) else: FreeCAD.Console.PrintWarning( "Tool Controller Vertical Rapid Values are unset" + "\n" ) for c in PathUtils.getPathWithPlacement(pathobj).Commands: outstring = [] command = c.Name if adaptiveOp and c.Name in ["G0", "G00"]: if opHorizRapid and opVertRapid: command = "G1" else: outstring.append("(Tool Controller Rapid Values are unset)" + "\n") outstring.append(command) # if modal: suppress the command if it is the same as the last one if MODAL is True: if command == lastcommand: outstring.pop(0) if c.Name[0] == "(" and not OUTPUT_COMMENTS: # command is a comment continue # Now add the remaining parameters in order for param in params: if param in c.Parameters: if param == "F" and ( currLocation[param] != c.Parameters[param] or OUTPUT_DOUBLES ): if c.Name not in [ "G0", "G00", ]: # mach3_4 doesn't use rapid speeds speed = Units.Quantity(c.Parameters["F"], FreeCAD.Units.Velocity) if speed.getValueAs(UNIT_SPEED_FORMAT) > 0.0: outstring.append( param + format( float(speed.getValueAs(UNIT_SPEED_FORMAT)), precision_string, ) ) else: continue elif param == "T": outstring.append(param + str(int(c.Parameters["T"]))) elif param == "H": outstring.append(param + str(int(c.Parameters["H"]))) elif param == "D": outstring.append(param + str(int(c.Parameters["D"]))) elif param == "S": outstring.append(param + str(int(c.Parameters["S"]))) else: if ( (not OUTPUT_DOUBLES) and (param in currLocation) and (currLocation[param] == c.Parameters[param]) ): continue else: pos = Units.Quantity(c.Parameters[param], FreeCAD.Units.Length) outstring.append( param + format(float(pos.getValueAs(UNIT_FORMAT)), precision_string) ) if adaptiveOp and c.Name in ["G0", "G00"]: if opHorizRapid and opVertRapid: if "Z" not in c.Parameters: outstring.append( "F" + format( float(opHorizRapid.getValueAs(UNIT_SPEED_FORMAT)), precision_string, ) ) else: outstring.append( "F" + format( float(opVertRapid.getValueAs(UNIT_SPEED_FORMAT)), precision_string, ) ) # store the latest command lastcommand = command currLocation.update(c.Parameters) # Memorizes the current position for calculating the related movements and the withdrawal plan if command in MOTION_COMMANDS: if "X" in c.Parameters: CURRENT_X = Units.Quantity(c.Parameters["X"], FreeCAD.Units.Length) if "Y" in c.Parameters: CURRENT_Y = Units.Quantity(c.Parameters["Y"], FreeCAD.Units.Length) if "Z" in c.Parameters: CURRENT_Z = Units.Quantity(c.Parameters["Z"], FreeCAD.Units.Length) if command in ("G98", "G99"): DRILL_RETRACT_MODE = command if command in ("G90", "G91"): MOTION_MODE = command if TRANSLATE_DRILL_CYCLES: if command in ("G81", "G82", "G83"): out += drill_translate(outstring, command, c.Parameters) # Erase the line we just translated outstring = [] # Check for Tool Change: if command == "M6": # stop the spindle out += linenumber() + "M5\n" for line in TOOL_CHANGE.splitlines(True): out += linenumber() + line # add height offset if USE_TLO: tool_height = "\nG43 H" + str(int(c.Parameters["T"])) outstring.append(tool_height) if command == "message": if OUTPUT_COMMENTS is False: out = [] else: outstring.pop(0) # remove the command if command in SUPPRESS_COMMANDS: outstring.insert(0, "(") outstring.append(")") # 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 def drill_translate(outstring, cmd, params): global DRILL_RETRACT_MODE global MOTION_MODE global CURRENT_X global CURRENT_Y global CURRENT_Z global UNITS global UNIT_FORMAT global UNIT_SPEED_FORMAT strFormat = "." + str(PRECISION) + "f" strG0_Initial_Z = "G0 Z" + format(float(CURRENT_Z.getValueAs(UNIT_FORMAT)), strFormat) + "\n" trBuff = "" if OUTPUT_COMMENTS: # Comment the original command outstring[0] = "(" + outstring[0] outstring[-1] = outstring[-1] + ")" trBuff += linenumber() + format_outstring(outstring) + "\n" # cycle conversion # currently only cycles in XY are provided (G17) # other plains ZX (G18) and YZ (G19) are not dealt with : Z drilling only. drill_X = Units.Quantity(params["X"], FreeCAD.Units.Length) drill_Y = Units.Quantity(params["Y"], FreeCAD.Units.Length) drill_Z = Units.Quantity(params["Z"], FreeCAD.Units.Length) RETRACT_Z = Units.Quantity(params["R"], FreeCAD.Units.Length) # R less than Z is error if RETRACT_Z < drill_Z: trBuff += linenumber() + "(drill cycle error: R less than Z )\n" return trBuff if MOTION_MODE == "G91": # G91 relative movements drill_X += CURRENT_X drill_Y += CURRENT_Y drill_Z += CURRENT_Z RETRACT_Z += CURRENT_Z # if DRILL_RETRACT_MODE == "G98" and CURRENT_Z >= RETRACT_Z: # RETRACT_Z = CURRENT_Z # get the other parameters drill_feedrate = Units.Quantity(params["F"], FreeCAD.Units.Velocity) if cmd == "G83": drill_Step = Units.Quantity(params["Q"], FreeCAD.Units.Length) a_bit = ( drill_Step * 0.05 ) # NIST 3.5.16.4 G83 Cycle: "current hole bottom, backed off a bit." elif cmd == "G82": drill_DwellTime = params["P"] # wrap this block to ensure machine MOTION_MODE is restored in case of error try: if MOTION_MODE == "G91": trBuff += linenumber() + "G90\n" # force absolute coordinates during cycles strG0_RETRACT_Z = ( "G0 Z" + format(float(RETRACT_Z.getValueAs(UNIT_FORMAT)), strFormat) + "\n" ) strF_Feedrate = ( " F" + format(float(drill_feedrate.getValueAs(UNIT_SPEED_FORMAT)), ".2f") + "\n" ) print(strF_Feedrate) # preliminary movement(s) if CURRENT_Z < RETRACT_Z: trBuff += linenumber() + strG0_RETRACT_Z trBuff += ( linenumber() + "G0 X" + format(float(drill_X.getValueAs(UNIT_FORMAT)), strFormat) + " Y" + format(float(drill_Y.getValueAs(UNIT_FORMAT)), strFormat) + "\n" ) if CURRENT_Z > RETRACT_Z: # NIST GCODE 3.5.16.1 Preliminary and In-Between Motion says G0 to RETRACT_Z. trBuff += ( linenumber() + "G0 Z" + format(float(RETRACT_Z.getValueAs(UNIT_FORMAT)), strFormat) + strF_Feedrate ) last_Stop_Z = RETRACT_Z # drill moves if cmd in ("G81", "G82"): trBuff += ( linenumber() + "G1 Z" + format(float(drill_Z.getValueAs(UNIT_FORMAT)), strFormat) + strF_Feedrate ) # pause where applicable if cmd == "G82": trBuff += linenumber() + "G4 P" + str(drill_DwellTime) + "\n" trBuff += linenumber() + strG0_RETRACT_Z else: # 'G83' if params["Q"] != 0: while 1: if last_Stop_Z != RETRACT_Z: clearance_depth = ( last_Stop_Z + a_bit ) # rapid move to just short of last drilling depth trBuff += ( linenumber() + "G0 Z" + format( float(clearance_depth.getValueAs(UNIT_FORMAT)), strFormat, ) + "\n" ) next_Stop_Z = last_Stop_Z - drill_Step if next_Stop_Z > drill_Z: trBuff += ( linenumber() + "G1 Z" + format(float(next_Stop_Z.getValueAs(UNIT_FORMAT)), strFormat) + strF_Feedrate ) trBuff += linenumber() + strG0_RETRACT_Z last_Stop_Z = next_Stop_Z else: trBuff += ( linenumber() + "G1 Z" + format(float(drill_Z.getValueAs(UNIT_FORMAT)), strFormat) + strF_Feedrate ) if DRILL_RETRACT_MODE == "G98": trBuff += linenumber() + strG0_Initial_Z else: trBuff += linenumber() + strG0_RETRACT_Z break except Exception as e: pass if MOTION_MODE == "G91": trBuff += linenumber() + "G91" # Restore if changed return trBuff # print(__name__ + " gcode postprocessor loaded.")