Added contributed post-processor scripts.
This commit is contained in:
parent
98e93d329f
commit
3d3a63deaf
266
src/Mod/Path/PathScripts/dynapath_post.py
Normal file
266
src/Mod/Path/PathScripts/dynapath_post.py
Normal file
|
@ -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."
|
||||
|
420
src/Mod/Path/PathScripts/generic_post.py
Normal file
420
src/Mod/Path/PathScripts/generic_post.py
Normal file
|
@ -0,0 +1,420 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
|
||||
#***************************************************************************
|
||||
#* *
|
||||
#* Copyright (c) 2016 Christoph Blaue <blaue@fh-westkueste.de> *
|
||||
#* *
|
||||
#* 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<y and i>=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 (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()
|
Loading…
Reference in New Issue
Block a user