kopia lustrzana https://github.com/vilemduha/blendercam
1634 wiersze
49 KiB
Python
1634 wiersze
49 KiB
Python
# heiden.py, just copied from iso.py, to start with, but needs to be modified to make this sort of output
|
|
|
|
# 1 BEGIN PGM 0011 MM
|
|
# 2 BLK FORM 0.1 Z X-262.532 Y-262.55 Z-75.95
|
|
# 3 BLK FORM 0.2 X262.532 Y262.55 Z0.05
|
|
# 4 TOOL CALL 3 Z S3263 DL+0.0 DR+0.0
|
|
# 5 TOOL CALL 3 Z S3263 DL+0.0 DR+0.0
|
|
# 6 L X-80.644 Y-95.2 Z+100.0 R0 F237 M3
|
|
# 7 L Z-23.222 F333
|
|
# 8 L X-80.627 Y-95.208 Z-23.5 F326
|
|
# 49 L X-73.218 Y-88.104 Z-26.747 F229
|
|
# 50 L X-73.529 Y-87.795 Z-26.769 F227
|
|
# 51 L X-74.09 Y-87.326 Z-25.996 F279
|
|
# 52 M30
|
|
# 53 END PGM 0011 MM
|
|
|
|
|
|
from . import iso, nc, emc2
|
|
import math
|
|
from .format import Format
|
|
from .format import *
|
|
|
|
################################################################################
|
|
|
|
|
|
class Creator(nc.Creator):
|
|
def __init__(self):
|
|
nc.Creator.__init__(self)
|
|
|
|
self.a = 0
|
|
self.b = 0
|
|
self.c = 0
|
|
self.f = Address("F", fmt=Format(number_of_decimal_places=2))
|
|
self.fh = None
|
|
self.fv = None
|
|
self.fhv = False
|
|
self.g_plane = Address("G", fmt=Format(number_of_decimal_places=0))
|
|
self.g_list = []
|
|
self.i = 0
|
|
self.j = 0
|
|
self.k = 0
|
|
self.m = []
|
|
self.n = 10
|
|
self.r = 0
|
|
self.s = AddressPlusMinus("S", fmt=Format(number_of_decimal_places=2), modal=False)
|
|
self.t = None
|
|
self.x = 0
|
|
self.y = 0
|
|
self.z = 500
|
|
self.g0123_modal = False
|
|
self.drill_modal = False
|
|
self.prev_f = ""
|
|
self.prev_g0123 = ""
|
|
self.prev_drill = ""
|
|
self.prev_retract = ""
|
|
self.prev_z = ""
|
|
self.useCrc = False
|
|
self.useCrcCenterline = False
|
|
self.gCRC = ""
|
|
self.fmt = Format()
|
|
self.absolute_flag = True
|
|
self.ffmt = Format(number_of_decimal_places=2)
|
|
self.sfmt = Format(number_of_decimal_places=1)
|
|
self.arc_centre_absolute = False
|
|
self.arc_centre_positive = False
|
|
self.in_quadrant_splitting = False
|
|
self.drillExpanded = False
|
|
self.can_do_helical_arcs = True
|
|
self.shift_x = 0.0
|
|
self.shift_y = 0.0
|
|
self.shift_z = 0.0
|
|
|
|
############################################################################
|
|
# Codes
|
|
|
|
def SPACE(self):
|
|
return ""
|
|
|
|
def FORMAT_FEEDRATE(self):
|
|
return "%.2f"
|
|
|
|
def FEEDRATE(self):
|
|
return self.SPACE() + "F"
|
|
|
|
def FORMAT_ANG(self):
|
|
return "%.1f"
|
|
|
|
def FORMAT_TIME(self):
|
|
return "%.2f"
|
|
|
|
def FORMAT_DWELL(self):
|
|
return "P%f"
|
|
|
|
def BLOCK(self):
|
|
return "%i"
|
|
|
|
def COMMENT(self, comment):
|
|
return "(%s)" % comment
|
|
|
|
def VARIABLE(self):
|
|
return "#%i"
|
|
|
|
def VARIABLE_SET(self):
|
|
return "=%.3f"
|
|
|
|
def SUBPROG_CALL(self):
|
|
return "M98" + self.SPACE() + "P%i"
|
|
|
|
def SUBPROG_END(self):
|
|
return "M99"
|
|
|
|
def STOP_OPTIONAL(self):
|
|
return "M01"
|
|
|
|
def STOP(self):
|
|
return "M00"
|
|
|
|
def IMPERIAL(self):
|
|
return "G20"
|
|
|
|
def METRIC(self):
|
|
return "G21"
|
|
|
|
def ABSOLUTE(self):
|
|
return "G90"
|
|
|
|
def INCREMENTAL(self):
|
|
return "G91"
|
|
|
|
def SET_TEMPORARY_COORDINATE_SYSTEM(self):
|
|
return "G92"
|
|
|
|
def REMOVE_TEMPORARY_COORDINATE_SYSTEM(self):
|
|
return "G92.1"
|
|
|
|
def POLAR_ON(self):
|
|
return "G16"
|
|
|
|
def POLAR_OFF(self):
|
|
return "G15"
|
|
|
|
def PLANE_XY(self):
|
|
return "17"
|
|
|
|
def PLANE_XZ(self):
|
|
return "18"
|
|
|
|
def PLANE_YZ(self):
|
|
return "19"
|
|
|
|
def TOOL(self):
|
|
return "T%i" + self.SPACE() + "M06"
|
|
|
|
def TOOL_DEFINITION(self):
|
|
return "G10" + self.SPACE() + "L1"
|
|
|
|
def WORKPLANE(self):
|
|
return "G%i"
|
|
|
|
def WORKPLANE_BASE(self):
|
|
return 53
|
|
|
|
def SPINDLE_CW(self):
|
|
return "M03"
|
|
|
|
def SPINDLE_CCW(self):
|
|
return "M04"
|
|
|
|
def COOLANT_OFF(self):
|
|
return "M09"
|
|
|
|
def COOLANT_MIST(self):
|
|
return "M07"
|
|
|
|
def COOLANT_FLOOD(self):
|
|
return "M08"
|
|
|
|
def GEAR_OFF(self):
|
|
return "?"
|
|
|
|
def GEAR(self):
|
|
return "M%i"
|
|
|
|
def GEAR_BASE(self):
|
|
return 37
|
|
|
|
def RAPID(self):
|
|
return "G00"
|
|
|
|
def FEED(self):
|
|
return "G01"
|
|
|
|
def ARC_CW(self):
|
|
return "G02"
|
|
|
|
def ARC_CCW(self):
|
|
return "G03"
|
|
|
|
def DWELL(self):
|
|
return "G04"
|
|
|
|
def DRILL(self):
|
|
return "G81"
|
|
|
|
def DRILL_WITH_DWELL(self, format, dwell):
|
|
return "G82" + self.SPACE() + (format.string(dwell))
|
|
|
|
def PECK_DRILL(self):
|
|
return "G83"
|
|
|
|
def PECK_DEPTH(self, format, depth):
|
|
return self.SPACE() + "Q" + (format.string(depth))
|
|
|
|
def RETRACT(self, format, height):
|
|
return self.SPACE() + "R" + (format.string(height))
|
|
|
|
def END_CANNED_CYCLE(self):
|
|
return "G80"
|
|
|
|
def TAP(self):
|
|
return "G84"
|
|
|
|
def TAP_DEPTH(self, format, depth):
|
|
return self.SPACE() + "K" + (format.string(depth))
|
|
|
|
def X(self):
|
|
return "X"
|
|
|
|
def Y(self):
|
|
return "Y"
|
|
|
|
def Z(self):
|
|
return "Z"
|
|
|
|
def A(self):
|
|
return "A"
|
|
|
|
def B(self):
|
|
return "B"
|
|
|
|
def C(self):
|
|
return "C"
|
|
|
|
def CENTRE_X(self):
|
|
return "I"
|
|
|
|
def CENTRE_Y(self):
|
|
return "J"
|
|
|
|
def CENTRE_Z(self):
|
|
return "K"
|
|
|
|
def RADIUS(self):
|
|
return "R"
|
|
|
|
def TIME(self):
|
|
return "P"
|
|
|
|
def PROBE_TOWARDS_WITH_SIGNAL(self):
|
|
return "G38.2"
|
|
|
|
def PROBE_TOWARDS_WITHOUT_SIGNAL(self):
|
|
return "G38.3"
|
|
|
|
def PROBE_AWAY_WITH_SIGNAL(self):
|
|
return "G38.4"
|
|
|
|
def PROBE_AWAY_WITHOUT_SIGNAL(self):
|
|
return "G38.5"
|
|
|
|
def MACHINE_COORDINATES(self):
|
|
return "G53"
|
|
|
|
def EXACT_PATH_MODE(self):
|
|
return "G61"
|
|
|
|
def EXACT_STOP_MODE(self):
|
|
return "G61.1"
|
|
|
|
############################################################################
|
|
# Internals
|
|
|
|
def write_feedrate(self):
|
|
self.f.write(self)
|
|
|
|
def write_preps(self):
|
|
self.g_plane.write(self)
|
|
for g in self.g_list:
|
|
self.write(self.SPACE() + g)
|
|
self.g_list = []
|
|
|
|
def write_misc(self):
|
|
if len(self.m):
|
|
self.write(self.m.pop())
|
|
|
|
def write_blocknum(self):
|
|
self.write(self.BLOCK() % self.n)
|
|
self.n += 1
|
|
|
|
def write_spindle(self):
|
|
self.s.write(self)
|
|
|
|
############################################################################
|
|
# Programs
|
|
|
|
def program_begin(self, id, name=""):
|
|
# 1 BEGIN PGM 0011 MM
|
|
self.write_blocknum()
|
|
self.program_id = id
|
|
self.write(self.SPACE() + ("BEGIN PGM %i MM" % id))
|
|
self.write("\n")
|
|
|
|
def program_stop(self, optional=False):
|
|
self.write_blocknum()
|
|
if optional:
|
|
self.write(self.SPACE() + self.STOP_OPTIONAL() + "\n")
|
|
self.prev_g0123 = ""
|
|
else:
|
|
self.write(self.STOP() + "\n")
|
|
self.prev_g0123 = ""
|
|
|
|
def program_end(self):
|
|
self.write_blocknum()
|
|
self.write(self.SPACE() + ("END PGM %i MM" % self.program_id) + "\n")
|
|
|
|
def flush_nc(self):
|
|
if len(self.g_list) == 0 and len(self.m) == 0:
|
|
return
|
|
self.write_blocknum()
|
|
self.write_preps()
|
|
self.write_misc()
|
|
self.write("\n")
|
|
|
|
############################################################################
|
|
# Subprograms
|
|
|
|
def sub_begin(self, id, name=""):
|
|
self.write((self.PROGRAM() % id) + self.SPACE() + (self.COMMENT(name)))
|
|
self.write("\n")
|
|
|
|
def sub_call(self, id):
|
|
self.write_blocknum()
|
|
self.write(self.SPACE() + (self.SUBPROG_CALL() % id) + "\n")
|
|
|
|
def sub_end(self):
|
|
self.write_blocknum()
|
|
self.write(self.SPACE() + self.SUBPROG_END() + "\n")
|
|
|
|
############################################################################
|
|
# Settings
|
|
|
|
def imperial(self):
|
|
self.g_list.append(self.IMPERIAL())
|
|
self.fmt.number_of_decimal_places = 4
|
|
|
|
def metric(self):
|
|
self.g_list.append(self.METRIC())
|
|
self.fmt.number_of_decimal_places = 3
|
|
|
|
def absolute(self):
|
|
self.g_list.append(self.ABSOLUTE())
|
|
self.absolute_flag = True
|
|
|
|
def incremental(self):
|
|
self.g_list.append(self.INCREMENTAL())
|
|
self.absolute_flag = False
|
|
|
|
def polar(self, on=True):
|
|
if on:
|
|
self.g_list.append(self.POLAR_ON())
|
|
else:
|
|
self.g_list.append(self.POLAR_OFF())
|
|
|
|
def set_plane(self, plane):
|
|
if plane == 0:
|
|
self.g_plane.set(self.PLANE_XY())
|
|
elif plane == 1:
|
|
self.g_plane.set(self.PLANE_XZ())
|
|
elif plane == 2:
|
|
self.g_plane.set(self.PLANE_YZ())
|
|
|
|
def set_temporary_origin(self, x=None, y=None, z=None, a=None, b=None, c=None):
|
|
self.write_blocknum()
|
|
self.write(self.SPACE() + (self.SET_TEMPORARY_COORDINATE_SYSTEM()))
|
|
if x != None:
|
|
self.write(self.SPACE() + "X " + (self.fmt.string(x + self.shift_x)))
|
|
if y != None:
|
|
self.write(self.SPACE() + "Y " + (self.fmt.string(y + self.shift_y)))
|
|
if z != None:
|
|
self.write(self.SPACE() + "Z " + (self.fmt.string(z + self.shift_z)))
|
|
if a != None:
|
|
self.write(self.SPACE() + "A " + (self.fmt.string(a)))
|
|
if b != None:
|
|
self.write(self.SPACE() + "B " + (self.fmt.string(b)))
|
|
if c != None:
|
|
self.write(self.SPACE() + "C " + (self.fmt.string(c)))
|
|
self.write("\n")
|
|
|
|
def remove_temporary_origin(self):
|
|
self.write_blocknum()
|
|
self.write(self.SPACE() + (self.REMOVE_TEMPORARY_COORDINATE_SYSTEM()))
|
|
self.write("\n")
|
|
|
|
############################################################################
|
|
# new graphics origin- make a new coordinate system and snap it onto the geometry
|
|
# the toolpath generated should be translated
|
|
|
|
def translate(self, x=None, y=None, z=None):
|
|
self.shift_x = -x
|
|
self.shift_y = -y
|
|
self.shift_z = -z
|
|
|
|
############################################################################
|
|
# Tools
|
|
|
|
def tool_change(self, id):
|
|
self.write_blocknum()
|
|
self.write(self.SPACE() + (self.TOOL() % id) + "\n")
|
|
self.t = id
|
|
|
|
def tool_defn(self, id, name="", params=None):
|
|
self.write_blocknum()
|
|
self.write(self.SPACE() + self.TOOL_DEFINITION())
|
|
self.write(self.SPACE() + ("P%i" % id) + " ")
|
|
|
|
if radius != None:
|
|
self.write(self.SPACE() + ("R%.3f" % (float(params["diameter"]) / 2)))
|
|
|
|
if length != None:
|
|
self.write(self.SPACE() + "Z%.3f" % float(params["cutting edge height"]))
|
|
|
|
self.write("\n")
|
|
|
|
def offset_radius(self, id, radius=None):
|
|
pass
|
|
|
|
def offset_length(self, id, length=None):
|
|
pass
|
|
|
|
def current_tool(self):
|
|
return self.t
|
|
|
|
############################################################################
|
|
# Datums
|
|
|
|
def datum_shift(self, x=None, y=None, z=None, a=None, b=None, c=None):
|
|
pass
|
|
|
|
def datum_set(self, x=None, y=None, z=None, a=None, b=None, c=None):
|
|
pass
|
|
|
|
# This is the coordinate system we're using. G54->G59, G59.1, G59.2, G59.3
|
|
# These are selected by values from 1 to 9 inclusive.
|
|
def workplane(self, id):
|
|
if (id >= 1) and (id <= 6):
|
|
self.g_list.append(self.WORKPLANE() % (id + self.WORKPLANE_BASE()))
|
|
if (id >= 7) and (id <= 9):
|
|
self.g_list.append(
|
|
((self.WORKPLANE() % (6 + self.WORKPLANE_BASE())) + (".%i" % (id - 6)))
|
|
)
|
|
|
|
############################################################################
|
|
## Rates + Modes
|
|
|
|
def feedrate(self, f):
|
|
self.f.set(f)
|
|
self.fhv = False
|
|
|
|
def feedrate_hv(self, fh, fv):
|
|
self.fh = fh
|
|
self.fv = fv
|
|
self.fhv = True
|
|
|
|
def calc_feedrate_hv(self, h, v):
|
|
if math.fabs(v) > math.fabs(h * 2):
|
|
# some horizontal, so it should be fine to use the horizontal feed rate
|
|
self.f.set(self.fv)
|
|
else:
|
|
# not much, if any horizontal component, so use the vertical feed rate
|
|
self.f.set(self.fh)
|
|
|
|
def spindle(self, s, clockwise):
|
|
if clockwise == True:
|
|
self.s.set(s, self.SPACE() + self.SPINDLE_CW(), self.SPACE() + self.SPINDLE_CCW())
|
|
else:
|
|
self.s.set(s, self.SPACE() + self.SPINDLE_CCW(), self.SPACE() + self.SPINDLE_CW())
|
|
|
|
def coolant(self, mode=0):
|
|
if mode <= 0:
|
|
self.m.append(self.SPACE() + self.COOLANT_OFF())
|
|
elif mode == 1:
|
|
self.m.append(self.SPACE() + self.COOLANT_MIST())
|
|
elif mode == 2:
|
|
self.m.append(self.SPACE() + self.COOLANT_FLOOD())
|
|
|
|
def gearrange(self, gear=0):
|
|
if gear <= 0:
|
|
self.m.append(self.SPACE() + self.GEAR_OFF())
|
|
elif gear <= 4:
|
|
self.m.append(self.SPACE() + self.GEAR() % (gear + GEAR_BASE()))
|
|
|
|
############################################################################
|
|
# Moves
|
|
|
|
def rapid(self, x=None, y=None, z=None, a=None, b=None, c=None):
|
|
self.write_blocknum()
|
|
|
|
if self.g0123_modal:
|
|
if self.prev_g0123 != self.RAPID():
|
|
self.write(self.SPACE() + self.RAPID())
|
|
self.prev_g0123 = self.RAPID()
|
|
else:
|
|
self.write(self.SPACE() + self.RAPID())
|
|
self.write_preps()
|
|
if x != None:
|
|
dx = x - self.x
|
|
if self.absolute_flag:
|
|
self.write(self.SPACE() + self.X() + (self.fmt.string(x + self.shift_x)))
|
|
else:
|
|
self.write(self.SPACE() + self.X() + (self.fmt.string(dx)))
|
|
self.x = x
|
|
if y != None:
|
|
dy = y - self.y
|
|
if self.absolute_flag:
|
|
self.write(self.SPACE() + self.Y() + (self.fmt.string(y + self.shift_y)))
|
|
else:
|
|
self.write(self.SPACE() + self.Y() + (self.fmt.string(dy)))
|
|
|
|
self.y = y
|
|
if z != None:
|
|
dz = z - self.z
|
|
if self.absolute_flag:
|
|
self.write(self.SPACE() + self.Z() + (self.fmt.string(z + self.shift_z)))
|
|
else:
|
|
self.write(self.SPACE() + self.Z() + (self.fmt.string(dz)))
|
|
|
|
self.z = z
|
|
|
|
if a != None:
|
|
da = a - self.a
|
|
if self.absolute_flag:
|
|
self.write(self.SPACE() + self.A() + (self.fmt.string(a)))
|
|
else:
|
|
self.write(self.SPACE() + self.A() + (self.fmt.string(da)))
|
|
self.a = a
|
|
|
|
if b != None:
|
|
db = b - self.b
|
|
if self.absolute_flag:
|
|
self.write(self.SPACE() + self.B() + (self.fmt.string(b)))
|
|
else:
|
|
self.write(self.SPACE() + self.B() + (self.fmt.string(db)))
|
|
self.b = b
|
|
|
|
if c != None:
|
|
dc = c - self.c
|
|
if self.absolute_flag:
|
|
self.write(self.SPACE() + self.C() + (self.fmt.string(c)))
|
|
else:
|
|
self.write(self.SPACE() + self.C() + (self.fmt.string(dc)))
|
|
self.c = c
|
|
self.write_spindle()
|
|
self.write_misc()
|
|
self.write("\n")
|
|
|
|
def feed(self, x=None, y=None, z=None, a=None, b=None, c=None):
|
|
if self.same_xyz(x, y, z):
|
|
return
|
|
self.write_blocknum()
|
|
if self.g0123_modal:
|
|
if self.prev_g0123 != self.FEED():
|
|
self.write(self.SPACE() + self.FEED())
|
|
self.prev_g0123 = self.FEED()
|
|
else:
|
|
self.write(self.FEED())
|
|
self.write_preps()
|
|
dx = dy = dz = 0
|
|
if x != None:
|
|
dx = x - self.x
|
|
if self.absolute_flag:
|
|
self.write(self.SPACE() + self.X() + (self.fmt.string(x + self.shift_x)))
|
|
else:
|
|
self.write(self.SPACE() + self.X() + (self.fmt.string(dx)))
|
|
self.x = x
|
|
if y != None:
|
|
dy = y - self.y
|
|
if self.absolute_flag:
|
|
self.write(self.SPACE() + self.Y() + (self.fmt.string(y + self.shift_y)))
|
|
else:
|
|
self.write(self.SPACE() + self.Y() + (self.fmt.string(dy)))
|
|
|
|
self.y = y
|
|
if z != None:
|
|
dz = z - self.z
|
|
if self.absolute_flag:
|
|
self.write(self.SPACE() + self.Z() + (self.fmt.string(z + self.shift_z)))
|
|
else:
|
|
self.write(self.SPACE() + self.Z() + (self.fmt.string(dz)))
|
|
|
|
self.z = z
|
|
if self.fhv:
|
|
self.calc_feedrate_hv(math.sqrt(dx * dx + dy * dy), math.fabs(dz))
|
|
self.write_feedrate()
|
|
self.write_spindle()
|
|
self.write_misc()
|
|
self.write("\n")
|
|
|
|
def same_xyz(self, x=None, y=None, z=None):
|
|
if x != None:
|
|
if (self.fmt.string(x + self.shift_x)) != (self.fmt.string(self.x)):
|
|
return False
|
|
if y != None:
|
|
if (self.fmt.string(y + self.shift_y)) != (self.fmt.string(self.y)):
|
|
return False
|
|
if z != None:
|
|
if (self.fmt.string(z + self.shift_z)) != (self.fmt.string(self.z)):
|
|
return False
|
|
|
|
return True
|
|
|
|
def get_quadrant(self, dx, dy):
|
|
if dx < 0:
|
|
if dy < 0:
|
|
return 2
|
|
else:
|
|
return 1
|
|
|
|
else:
|
|
if dy < 0:
|
|
return 3
|
|
else:
|
|
return 0
|
|
|
|
def quadrant_start(self, q, i, j, rad):
|
|
while q > 3:
|
|
q = q - 4
|
|
if q == 0:
|
|
return i + rad, j
|
|
if q == 1:
|
|
return i, j + rad
|
|
if q == 2:
|
|
return i - rad, j
|
|
return i, j - rad
|
|
|
|
def quadrant_end(self, q, i, j, rad):
|
|
return self.quadrant_start(q + 1, i, j, rad)
|
|
|
|
def get_arc_angle(self, sdx, sdy, edx, edy, cw):
|
|
angle_s = math.atan2(sdy, sdx)
|
|
angle_e = math.atan2(edy, edx)
|
|
if cw:
|
|
if angle_s < angle_e:
|
|
angle_s = angle_s + 2 * math.pi
|
|
else:
|
|
if angle_e < angle_s:
|
|
angle_e = angle_e + 2 * math.pi
|
|
return angle_e - angle_s
|
|
|
|
def arc(self, cw, x=None, y=None, z=None, i=None, j=None, k=None, r=None):
|
|
if (
|
|
self.can_do_helical_arcs == False
|
|
and self.in_quadrant_splitting == False
|
|
and (z != None)
|
|
and (math.fabs(z - self.z) > 0.000001)
|
|
and (self.fmt.string(z) != self.fmt.string(self.z))
|
|
):
|
|
# split the helical arc into little line feed moves
|
|
if x == None:
|
|
x = self.x
|
|
if y == None:
|
|
y = self.y
|
|
sdx = self.x - i
|
|
sdy = self.y - j
|
|
edx = x - i
|
|
edy = y - j
|
|
radius = math.sqrt(sdx * sdx + sdy * sdy)
|
|
arc_angle = self.get_arc_angle(sdx, sdy, edx, edy, cw)
|
|
angle_start = math.atan2(sdy, sdx)
|
|
tolerance = 0.02
|
|
angle_step = 2.0 * math.atan(math.sqrt(tolerance / (radius - tolerance)))
|
|
segments = int(math.fabs(arc_angle / angle_step) + 1)
|
|
angle_step = arc_angle / segments
|
|
angle = angle_start
|
|
z_step = float(z - self.z) / segments
|
|
next_z = self.z
|
|
for p in range(0, segments):
|
|
angle = angle + angle_step
|
|
next_x = i + radius * math.cos(angle)
|
|
next_y = j + radius * math.sin(angle)
|
|
next_z = next_z + z_step
|
|
self.feed(next_x, next_y, next_z)
|
|
return
|
|
|
|
if self.arc_centre_positive == True and self.in_quadrant_splitting == False:
|
|
# split in to quadrant arcs
|
|
self.in_quadrant_splitting = True
|
|
|
|
if x == None:
|
|
x = self.x
|
|
if y == None:
|
|
y = self.y
|
|
sdx = self.x - i
|
|
sdy = self.y - j
|
|
edx = x - i
|
|
edy = y - j
|
|
|
|
qs = self.get_quadrant(sdx, sdy)
|
|
qe = self.get_quadrant(edx, edy)
|
|
|
|
if qs == qe:
|
|
arc_angle = math.fabs(self.get_arc_angle(sdx, sdy, edx, edy, cw))
|
|
# arc_angle will be either less than pi/2 or greater than 3pi/2
|
|
if arc_angle > 3.14:
|
|
if cw:
|
|
qs = qs + 4
|
|
else:
|
|
qe = qe + 4
|
|
|
|
if qs == qe:
|
|
self.arc(cw, x, y, z, i, j, k, r)
|
|
else:
|
|
rad = math.sqrt(sdx * sdx + sdy * sdy)
|
|
if cw:
|
|
if qs < qe:
|
|
qs = qs + 4
|
|
else:
|
|
if qe < qs:
|
|
qe = qe + 4
|
|
|
|
q = qs
|
|
while 1:
|
|
x1 = x
|
|
y1 = y
|
|
if q != qe:
|
|
if cw:
|
|
x1, y1 = self.quadrant_start(q, i, j, rad)
|
|
else:
|
|
x1, y1 = self.quadrant_end(q, i, j, rad)
|
|
|
|
if (
|
|
(math.fabs(x1 - self.x) > 0.000001) or (math.fabs(y1 - self.y) > 0.000001)
|
|
) and (
|
|
(self.fmt.string(x1) != self.fmt.string(self.x))
|
|
or (self.fmt.string(y1) != self.fmt.string(self.y))
|
|
):
|
|
self.arc(cw, x1, y1, z, i, j, k, r)
|
|
if q == qe:
|
|
break
|
|
if cw:
|
|
q = q - 1
|
|
else:
|
|
q = q + 1
|
|
|
|
self.in_quadrant_splitting = False
|
|
return
|
|
|
|
# if self.same_xyz(x, y, z): return
|
|
self.write_blocknum()
|
|
arc_g_code = ""
|
|
if cw:
|
|
arc_g_code = self.ARC_CW()
|
|
else:
|
|
arc_g_code = self.ARC_CCW()
|
|
if self.g0123_modal:
|
|
if self.prev_g0123 != arc_g_code:
|
|
self.write(arc_g_code)
|
|
self.prev_g0123 = arc_g_code
|
|
else:
|
|
self.write(arc_g_code)
|
|
self.write_preps()
|
|
if x != None:
|
|
dx = x - self.x
|
|
if self.absolute_flag:
|
|
self.write(self.SPACE() + self.X() + (self.fmt.string(x + self.shift_x)))
|
|
else:
|
|
self.write(self.SPACE() + self.X() + (self.fmt.string(dx)))
|
|
if y != None:
|
|
dy = y - self.y
|
|
if self.absolute_flag:
|
|
self.write(self.SPACE() + self.Y() + (self.fmt.string(y + self.shift_y)))
|
|
else:
|
|
self.write(self.SPACE() + self.Y() + (self.fmt.string(dy)))
|
|
if z != None:
|
|
dz = z - self.z
|
|
if self.absolute_flag:
|
|
self.write(self.SPACE() + self.Z() + (self.fmt.string(z + self.shift_z)))
|
|
else:
|
|
self.write(self.SPACE() + self.Z() + (self.fmt.string(dz)))
|
|
if i != None:
|
|
if self.arc_centre_absolute == False:
|
|
i = i - self.x
|
|
s = self.fmt.string(i)
|
|
if self.arc_centre_positive == True:
|
|
if s[0] == "-":
|
|
s = s[1:]
|
|
self.write(self.SPACE() + self.CENTRE_X() + s)
|
|
if j != None:
|
|
if self.arc_centre_absolute == False:
|
|
j = j - self.y
|
|
s = self.fmt.string(j)
|
|
if self.arc_centre_positive == True:
|
|
if s[0] == "-":
|
|
s = s[1:]
|
|
self.write(self.SPACE() + self.CENTRE_Y() + s)
|
|
if k != None:
|
|
if self.arc_centre_absolute == False:
|
|
k = k - self.z
|
|
s = self.fmt.string(k)
|
|
if self.arc_centre_positive == True:
|
|
if s[0] == "-":
|
|
s = s[1:]
|
|
self.write(self.SPACE() + self.CENTRE_Z() + s)
|
|
if r != None:
|
|
s = self.fmt.string(r)
|
|
if self.arc_centre_positive == True:
|
|
if s[0] == "-":
|
|
s = s[1:]
|
|
self.write(self.SPACE() + self.RADIUS() + s)
|
|
# use horizontal feed rate
|
|
if self.fhv:
|
|
self.calc_feedrate_hv(1, 0)
|
|
self.write_feedrate()
|
|
self.write_spindle()
|
|
self.write_misc()
|
|
self.write("\n")
|
|
if x != None:
|
|
self.x = x
|
|
if y != None:
|
|
self.y = y
|
|
if z != None:
|
|
self.z = z
|
|
|
|
def arc_cw(self, x=None, y=None, z=None, i=None, j=None, k=None, r=None):
|
|
self.arc(True, x, y, z, i, j, k, r)
|
|
|
|
def arc_ccw(self, x=None, y=None, z=None, i=None, j=None, k=None, r=None):
|
|
self.arc(False, x, y, z, i, j, k, r)
|
|
|
|
def dwell(self, t):
|
|
self.write_blocknum()
|
|
self.write_preps()
|
|
self.write(self.FORMAT_DWELL() % t)
|
|
self.write_misc()
|
|
self.write("\n")
|
|
|
|
def rapid_home(self, x=None, y=None, z=None, a=None, b=None, c=None):
|
|
pass
|
|
|
|
def rapid_unhome(self):
|
|
pass
|
|
|
|
def set_machine_coordinates(self):
|
|
self.write(self.SPACE() + self.MACHINE_COORDINATES())
|
|
self.prev_g0123 = ""
|
|
|
|
############################################################################
|
|
# CRC
|
|
|
|
def use_CRC(self):
|
|
return self.useCrc
|
|
|
|
def CRC_nominal_path(self):
|
|
return self.useCrcCenterline
|
|
|
|
def start_CRC(self, left=True, radius=0.0):
|
|
# set up prep code, to be output on next line
|
|
if self.t == None:
|
|
raise "No tool specified for start_CRC()"
|
|
self.write_blocknum()
|
|
if left:
|
|
self.write(self.SPACE() + "G41")
|
|
else:
|
|
self.write(self.SPACE() + "G42")
|
|
self.write((self.SPACE() + "D%i\n") % self.t)
|
|
|
|
def end_CRC(self):
|
|
self.write_blocknum()
|
|
self.write(self.SPACE() + "G40\n")
|
|
|
|
############################################################################
|
|
# Cycles
|
|
|
|
def pattern(self):
|
|
pass
|
|
|
|
def pocket(self):
|
|
pass
|
|
|
|
def profile(self):
|
|
pass
|
|
|
|
# The drill routine supports drilling (G81), drilling with dwell (G82) and peck drilling (G83).
|
|
# The x,y,z values are INITIAL locations (above the hole to be made. This is in contrast to
|
|
# the Z value used in the G8[1-3] cycles where the Z value is that of the BOTTOM of the hole.
|
|
# Instead, this routine combines the Z value and the depth value to determine the bottom of
|
|
# the hole.
|
|
#
|
|
# The standoff value is the distance up from the 'z' value (normally just above the surface) where the bit retracts
|
|
# to in order to clear the swarf. This combines with 'z' to form the 'R' value in the G8[1-3] cycles.
|
|
#
|
|
# The peck_depth value is the incremental depth (Q value) that tells the peck drilling
|
|
# cycle how deep to go on each peck until the full depth is achieved.
|
|
#
|
|
# NOTE: This routine forces the mode to absolute mode so that the values passed into
|
|
# the G8[1-3] cycles make sense. I don't know how to find the mode to revert it so I won't
|
|
# revert it. I must set the mode so that I can be sure the values I'm passing in make
|
|
# sense to the end-machine.
|
|
#
|
|
def drill(
|
|
self,
|
|
x=None,
|
|
y=None,
|
|
dwell=None,
|
|
depthparams=None,
|
|
retract_mode=None,
|
|
spindle_mode=None,
|
|
internal_coolant_on=None,
|
|
rapid_to_clearance=None,
|
|
):
|
|
if standoff == None:
|
|
# This is a bad thing. All the drilling cycles need a retraction (and starting) height.
|
|
return
|
|
|
|
if z == None:
|
|
return # We need a Z value as well. This input parameter represents the top of the hole
|
|
|
|
if self.drillExpanded:
|
|
# for machines which don't understand G81, G82 etc.
|
|
if peck_depth == None:
|
|
peck_depth = depth
|
|
current_z = z
|
|
self.rapid(x, y)
|
|
|
|
first = True
|
|
|
|
while True:
|
|
next_z = current_z - peck_depth
|
|
if next_z < z - depth:
|
|
next_z = z - depth
|
|
if next_z >= current_z:
|
|
break
|
|
if first:
|
|
self.rapid(z=z + standoff)
|
|
else:
|
|
self.rapid(z=current_z)
|
|
self.feed(z=next_z)
|
|
self.rapid(z=z + standoff)
|
|
current_z = next_z
|
|
if dwell:
|
|
self.dwell(dwell)
|
|
first = False
|
|
|
|
# we should pass clearance height into here, but my machine is on and I'm in a hurry... 22nd June 2011 danheeks
|
|
self.rapid(z=z + 5.0)
|
|
|
|
return
|
|
|
|
self.write_preps()
|
|
self.write_blocknum()
|
|
|
|
if peck_depth != 0:
|
|
# We're pecking. Let's find a tree.
|
|
if self.drill_modal:
|
|
if self.PECK_DRILL() + self.PECK_DEPTH(self.fmt, peck_depth) != self.prev_drill:
|
|
self.write(
|
|
self.SPACE()
|
|
+ self.PECK_DRILL()
|
|
+ self.SPACE()
|
|
+ self.PECK_DEPTH(self.fmt, peck_depth)
|
|
)
|
|
self.prev_drill = self.PECK_DRILL() + self.PECK_DEPTH(self.fmt, peck_depth)
|
|
else:
|
|
self.write(self.PECK_DRILL() + self.PECK_DEPTH(self.fmt, peck_depth))
|
|
|
|
else:
|
|
# We're either just drilling or drilling with dwell.
|
|
if dwell == 0:
|
|
# We're just drilling.
|
|
if self.drill_modal:
|
|
if self.DRILL() != self.prev_drill:
|
|
self.write(self.SPACE() + self.DRILL())
|
|
self.prev_drill = self.DRILL()
|
|
else:
|
|
self.write(self.SPACE() + self.DRILL())
|
|
|
|
else:
|
|
# We're drilling with dwell.
|
|
|
|
if self.drill_modal:
|
|
if self.DRILL_WITH_DWELL(self.FORMAT_DWELL(), dwell) != self.prev_drill:
|
|
self.write(self.SPACE() + self.DRILL_WITH_DWELL(self.FORMAT_DWELL(), dwell))
|
|
self.prev_drill = self.DRILL_WITH_DWELL(self.FORMAT_DWELL(), dwell)
|
|
else:
|
|
self.write(self.SPACE() + self.DRILL_WITH_DWELL(self.FORMAT_DWELL(), dwell))
|
|
|
|
# self.write(self.DRILL_WITH_DWELL(self.FORMAT_DWELL(),dwell))
|
|
|
|
# Set the retraction point to the 'standoff' distance above the starting z height.
|
|
retract_height = z + standoff
|
|
if x != None:
|
|
dx = x - self.x
|
|
self.write(self.SPACE() + self.X() + (self.fmt.string(x + self.shift_x)))
|
|
self.x = x
|
|
|
|
if y != None:
|
|
dy = y - self.y
|
|
self.write(self.SPACE() + self.Y() + (self.fmt.string(y + self.shift_y)))
|
|
self.y = y
|
|
|
|
# In the end, we will be standoff distance above the z value passed in.
|
|
dz = (z + standoff) - self.z
|
|
|
|
if self.drill_modal:
|
|
if z != self.prev_z:
|
|
self.write(self.SPACE() + self.Z() + (self.fmt.string(z - depth)))
|
|
self.prev_z = z
|
|
else:
|
|
# This is the 'z' value for the bottom of the hole.
|
|
self.write(self.SPACE() + self.Z() + (self.fmt.string(z - depth)))
|
|
# We want to remember where z is at the end (at the top of the hole)
|
|
self.z = z + standoff
|
|
|
|
if self.drill_modal:
|
|
if self.prev_retract != self.RETRACT(self.fmt, retract_height):
|
|
self.write(self.SPACE() + self.RETRACT(self.fmt, retract_height))
|
|
self.prev_retract = self.RETRACT(self.fmt, retract_height)
|
|
else:
|
|
self.write(self.SPACE() + self.RETRACT(self.fmt, retract_height))
|
|
|
|
if self.fhv:
|
|
self.calc_feedrate_hv(math.sqrt(dx * dx + dy * dy), math.fabs(dz))
|
|
|
|
self.write_feedrate()
|
|
self.write_spindle()
|
|
self.write_misc()
|
|
self.write("\n")
|
|
|
|
# G33.1 tapping with EMC for now
|
|
# unsynchronized (chuck) taps NIY (tap_mode = 1)
|
|
|
|
def tap(
|
|
self,
|
|
x=None,
|
|
y=None,
|
|
z=None,
|
|
zretract=None,
|
|
depth=None,
|
|
standoff=None,
|
|
dwell_bottom=None,
|
|
pitch=None,
|
|
stoppos=None,
|
|
spin_in=None,
|
|
spin_out=None,
|
|
tap_mode=None,
|
|
direction=None,
|
|
):
|
|
# mystery parameters:
|
|
# zretract=None, dwell_bottom=None,pitch=None, stoppos=None, spin_in=None, spin_out=None):
|
|
# I dont see how to map these to EMC Gcode
|
|
|
|
if standoff == None:
|
|
# This is a bad thing. All the drilling cycles need a retraction (and starting) height.
|
|
return
|
|
if z == None:
|
|
return # We need a Z value as well. This input parameter represents the top of the hole
|
|
if pitch == None:
|
|
return # We need a pitch value.
|
|
if direction == None:
|
|
return # We need a direction value.
|
|
|
|
if tap_mode != 0:
|
|
raise "only rigid tapping currently supported"
|
|
|
|
self.write_preps()
|
|
self.write_blocknum()
|
|
self.write_spindle()
|
|
self.write("\n")
|
|
|
|
# rapid to starting point; z first, then x,y iff given
|
|
|
|
# Set the retraction point to the 'standoff' distance above the starting z height.
|
|
retract_height = z + standoff
|
|
|
|
# unsure if this is needed:
|
|
if self.z != retract_height:
|
|
self.rapid(z=retract_height)
|
|
|
|
# then continue to x,y if given
|
|
if (x != None) or (y != None):
|
|
self.write_blocknum()
|
|
self.write(self.RAPID())
|
|
|
|
if x != None:
|
|
self.write(self.X() + self.fmt.string(x + self.shift_x))
|
|
self.x = x
|
|
|
|
if y != None:
|
|
self.write(self.Y() + self.fmt.string(y + self.shift_y))
|
|
self.y = y
|
|
self.write("\n")
|
|
|
|
self.write_blocknum()
|
|
self.write(self.TAP())
|
|
self.write(self.TAP_DEPTH(self.ffmt, pitch) + self.SPACE())
|
|
# This is the 'z' value for the bottom of the tap.
|
|
self.write(self.Z() + self.fmt.string(z - depth))
|
|
self.write_misc()
|
|
self.write("\n")
|
|
|
|
self.z = (
|
|
retract_height # this cycle returns to the start position, so remember that as z value
|
|
)
|
|
|
|
def bore(
|
|
self,
|
|
x=None,
|
|
y=None,
|
|
z=None,
|
|
zretract=None,
|
|
depth=None,
|
|
standoff=None,
|
|
dwell_bottom=None,
|
|
feed_in=None,
|
|
feed_out=None,
|
|
stoppos=None,
|
|
shift_back=None,
|
|
shift_right=None,
|
|
backbore=False,
|
|
stop=False,
|
|
):
|
|
pass
|
|
|
|
def end_canned_cycle(self):
|
|
if self.drillExpanded:
|
|
return
|
|
self.write_blocknum()
|
|
self.write(self.SPACE() + self.END_CANNED_CYCLE() + "\n")
|
|
self.prev_drill = ""
|
|
self.prev_g0123 = ""
|
|
self.prev_z = ""
|
|
self.prev_f = ""
|
|
self.prev_retract = ""
|
|
|
|
############################################################################
|
|
# Misc
|
|
|
|
def comment(self, text):
|
|
self.write((self.COMMENT(text) + "\n"))
|
|
|
|
def insert(self, text):
|
|
pass
|
|
|
|
def block_delete(self, on=False):
|
|
pass
|
|
|
|
def variable(self, id):
|
|
return self.VARIABLE() % id
|
|
|
|
def variable_set(self, id, value):
|
|
self.write_blocknum()
|
|
self.write(
|
|
self.SPACE()
|
|
+ (self.VARIABLE() % id)
|
|
+ self.SPACE()
|
|
+ (self.VARIABLE_SET() % value)
|
|
+ "\n"
|
|
)
|
|
|
|
# This routine uses the G92 coordinate system offsets to establish a temporary coordinate
|
|
# system at the machine's current position. It can then use absolute coordinates relative
|
|
# to this position which makes coding easy. It then moves to the 'point along edge' which
|
|
# should be above the workpiece but still on one edge. It then backs off from the edge
|
|
# to the 'retracted point'. It then plunges down by the depth value specified. It then
|
|
# probes back towards the 'destination point'. The probed X,Y location are stored
|
|
# into the 'intersection variable' variables. Finally the machine moves back to the
|
|
# original location. This is important so that the results of multiple calls to this
|
|
# routine may be compared meaningfully.
|
|
def probe_single_point(
|
|
self,
|
|
point_along_edge_x=None,
|
|
point_along_edge_y=None,
|
|
depth=None,
|
|
retracted_point_x=None,
|
|
retracted_point_y=None,
|
|
destination_point_x=None,
|
|
destination_point_y=None,
|
|
intersection_variable_x=None,
|
|
intersection_variable_y=None,
|
|
probe_offset_x_component=None,
|
|
probe_offset_y_component=None,
|
|
):
|
|
self.write_blocknum()
|
|
self.write(
|
|
self.SPACE()
|
|
+ (
|
|
self.SET_TEMPORARY_COORDINATE_SYSTEM()
|
|
+ (" X 0 Y 0 Z 0")
|
|
+ ("\t(Temporarily make this the origin)\n")
|
|
)
|
|
)
|
|
|
|
if self.fhv:
|
|
self.calc_feedrate_hv(1, 0)
|
|
self.write_blocknum()
|
|
self.write_feedrate()
|
|
self.write("\t(Set the feed rate for probing)\n")
|
|
|
|
self.rapid(point_along_edge_x, point_along_edge_y)
|
|
self.rapid(retracted_point_x, retracted_point_y)
|
|
self.feed(z=depth)
|
|
|
|
self.write_blocknum()
|
|
self.write(
|
|
(
|
|
self.PROBE_TOWARDS_WITH_SIGNAL()
|
|
+ (
|
|
" X "
|
|
+ (self.fmt.string(destination_point_x))
|
|
+ " Y "
|
|
+ (self.fmt.string(destination_point_y))
|
|
)
|
|
+ ("\t(Probe towards our destination point)\n")
|
|
)
|
|
)
|
|
|
|
self.comment("Back off the workpiece and re-probe more slowly")
|
|
self.write_blocknum()
|
|
self.write(
|
|
self.SPACE()
|
|
+ (
|
|
"#"
|
|
+ intersection_variable_x
|
|
+ "= [#5061 - [ 0.5 * "
|
|
+ probe_offset_x_component
|
|
+ "]]\n"
|
|
)
|
|
)
|
|
self.write_blocknum()
|
|
self.write(
|
|
self.SPACE()
|
|
+ (
|
|
"#"
|
|
+ intersection_variable_y
|
|
+ "= [#5062 - [ 0.5 * "
|
|
+ probe_offset_y_component
|
|
+ "]]\n"
|
|
)
|
|
)
|
|
self.write_blocknum()
|
|
self.write(self.RAPID())
|
|
self.write(
|
|
self.SPACE()
|
|
+ " X #"
|
|
+ intersection_variable_x
|
|
+ " Y #"
|
|
+ intersection_variable_y
|
|
+ "\n"
|
|
)
|
|
|
|
self.write_blocknum()
|
|
self.write(self.SPACE() + self.FEEDRATE() + self.ffmt.string(self.fh / 2.0) + "\n")
|
|
|
|
self.write_blocknum()
|
|
self.write(
|
|
(
|
|
self.SPACE()
|
|
+ self.PROBE_TOWARDS_WITH_SIGNAL()
|
|
+ (
|
|
" X "
|
|
+ (self.fmt.string(destination_point_x))
|
|
+ " Y "
|
|
+ (self.fmt.string(destination_point_y))
|
|
)
|
|
+ ("\t(Probe towards our destination point)\n")
|
|
)
|
|
)
|
|
|
|
self.comment("Store the probed location somewhere we can get it again later")
|
|
self.write_blocknum()
|
|
self.write(
|
|
(
|
|
"#"
|
|
+ intersection_variable_x
|
|
+ "="
|
|
+ probe_offset_x_component
|
|
+ " (Portion of probe radius that contributes to the X coordinate)\n"
|
|
)
|
|
)
|
|
self.write_blocknum()
|
|
self.write(
|
|
("#" + intersection_variable_x + "=[#" + intersection_variable_x + " + #5061]\n")
|
|
)
|
|
self.write_blocknum()
|
|
self.write(
|
|
(
|
|
"#"
|
|
+ intersection_variable_y
|
|
+ "="
|
|
+ probe_offset_y_component
|
|
+ " (Portion of probe radius that contributes to the Y coordinate)\n"
|
|
)
|
|
)
|
|
self.write_blocknum()
|
|
self.write(
|
|
("#" + intersection_variable_y + "=[#" + intersection_variable_y + " + #5062]\n")
|
|
)
|
|
|
|
self.comment("Now move back to the original location")
|
|
self.rapid(retracted_point_x, retracted_point_y)
|
|
self.rapid(z=0)
|
|
self.rapid(point_along_edge_x, point_along_edge_y)
|
|
self.rapid(x=0, y=0)
|
|
|
|
self.write_blocknum()
|
|
self.write(
|
|
(
|
|
self.REMOVE_TEMPORARY_COORDINATE_SYSTEM()
|
|
+ ("\t(Restore the previous coordinate system)\n")
|
|
)
|
|
)
|
|
|
|
def probe_downward_point(self, x=None, y=None, depth=None, intersection_variable_z=None):
|
|
self.write_blocknum()
|
|
self.write(
|
|
(
|
|
self.SET_TEMPORARY_COORDINATE_SYSTEM()
|
|
+ (" X 0 Y 0 Z 0")
|
|
+ ("\t(Temporarily make this the origin)\n")
|
|
)
|
|
)
|
|
if self.fhv:
|
|
self.calc_feedrate_hv(1, 0)
|
|
self.write_blocknum()
|
|
self.write(self.FEEDRATE() + " [" + self.ffmt.string(self.fh) + " / 5.0 ]")
|
|
self.write("\t(Set the feed rate for probing)\n")
|
|
|
|
if x != None and y != None:
|
|
self.write_blocknum()
|
|
self.write(self.RAPID())
|
|
self.write(" X " + x + " Y " + y + "\n")
|
|
|
|
self.write_blocknum()
|
|
self.write(
|
|
(
|
|
self.PROBE_TOWARDS_WITH_SIGNAL()
|
|
+ " Z "
|
|
+ (self.fmt.string(depth))
|
|
+ ("\t(Probe towards our destination point)\n")
|
|
)
|
|
)
|
|
|
|
self.comment("Store the probed location somewhere we can get it again later")
|
|
self.write_blocknum()
|
|
self.write(("#" + intersection_variable_z + "= #5063\n"))
|
|
|
|
self.comment("Now move back to the original location")
|
|
self.rapid(z=0)
|
|
self.rapid(x=0, y=0)
|
|
|
|
self.write_blocknum()
|
|
self.write(
|
|
(
|
|
self.REMOVE_TEMPORARY_COORDINATE_SYSTEM()
|
|
+ ("\t(Restore the previous coordinate system)\n")
|
|
)
|
|
)
|
|
|
|
def report_probe_results(
|
|
self,
|
|
x1=None,
|
|
y1=None,
|
|
z1=None,
|
|
x2=None,
|
|
y2=None,
|
|
z2=None,
|
|
x3=None,
|
|
y3=None,
|
|
z3=None,
|
|
x4=None,
|
|
y4=None,
|
|
z4=None,
|
|
x5=None,
|
|
y5=None,
|
|
z5=None,
|
|
x6=None,
|
|
y6=None,
|
|
z6=None,
|
|
xml_file_name=None,
|
|
):
|
|
pass
|
|
|
|
def open_log_file(self, xml_file_name=None):
|
|
pass
|
|
|
|
def log_coordinate(self, x=None, y=None, z=None):
|
|
pass
|
|
|
|
def log_message(self, message=None):
|
|
pass
|
|
|
|
def close_log_file(self):
|
|
pass
|
|
|
|
# Rapid movement to the midpoint between the two points specified.
|
|
# NOTE: The points are specified either as strings representing numbers or as strings
|
|
# representing variable names. This allows the HeeksCNC module to determine which
|
|
# variable names are used in these various routines.
|
|
def rapid_to_midpoint(self, x1=None, y1=None, z1=None, x2=None, y2=None, z2=None):
|
|
self.write_blocknum()
|
|
self.write(self.RAPID())
|
|
if (x1 != None) and (x2 != None):
|
|
self.write((" X " + "[[[" + x1 + " - " + x2 + "] / 2.0] + " + x2 + "]"))
|
|
|
|
if (y1 != None) and (y2 != None):
|
|
self.write((" Y " + "[[[" + y1 + " - " + y2 + "] / 2.0] + " + y2 + "]"))
|
|
|
|
if (z1 != None) and (z2 != None):
|
|
self.write((" Z " + "[[[" + z1 + " - " + z2 + "] / 2.0] + " + z2 + "]"))
|
|
|
|
self.write("\n")
|
|
|
|
# Rapid movement to the intersection of two lines (in the XY plane only). This routine
|
|
# is based on information found in http://local.wasp.uwa.edu.au/~pbourke/geometry/lineline2d/
|
|
# written by Paul Bourke. The ua_numerator, ua_denominator, ua and ub parameters
|
|
# represent variable names (with the preceding '#' included in them) for use as temporary
|
|
# variables. They're specified here simply so that HeeksCNC can manage which variables
|
|
# are used in which GCode calculations.
|
|
#
|
|
# As per the notes on the web page, the ua_denominator and ub_denominator formulae are
|
|
# the same so we don't repeat this. If the two lines are coincident or parallel then
|
|
# no movement occurs.
|
|
#
|
|
# NOTE: The points are specified either as strings representing numbers or as strings
|
|
# representing variable names. This allows the HeeksCNC module to determine which
|
|
# variable names are used in these various routines.
|
|
def rapid_to_intersection(
|
|
self,
|
|
x1,
|
|
y1,
|
|
x2,
|
|
y2,
|
|
x3,
|
|
y3,
|
|
x4,
|
|
y4,
|
|
intersection_x,
|
|
intersection_y,
|
|
ua_numerator,
|
|
ua_denominator,
|
|
ua,
|
|
ub_numerator,
|
|
ub,
|
|
):
|
|
self.comment("Find the intersection of the two lines made up by the four probed points")
|
|
self.write_blocknum()
|
|
self.write(
|
|
ua_numerator
|
|
+ "=[[["
|
|
+ x4
|
|
+ " - "
|
|
+ x3
|
|
+ "] * ["
|
|
+ y1
|
|
+ " - "
|
|
+ y3
|
|
+ "]] - [["
|
|
+ y4
|
|
+ " - "
|
|
+ y3
|
|
+ "] * ["
|
|
+ x1
|
|
+ " - "
|
|
+ x3
|
|
+ "]]]\n"
|
|
)
|
|
self.write_blocknum()
|
|
self.write(
|
|
ua_denominator
|
|
+ "=[[["
|
|
+ y4
|
|
+ " - "
|
|
+ y3
|
|
+ "] * ["
|
|
+ x2
|
|
+ " - "
|
|
+ x1
|
|
+ "]] - [["
|
|
+ x4
|
|
+ " - "
|
|
+ x3
|
|
+ "] * ["
|
|
+ y2
|
|
+ " - "
|
|
+ y1
|
|
+ "]]]\n"
|
|
)
|
|
self.write_blocknum()
|
|
self.write(
|
|
ub_numerator
|
|
+ "=[[["
|
|
+ x2
|
|
+ " - "
|
|
+ x1
|
|
+ "] * ["
|
|
+ y1
|
|
+ " - "
|
|
+ y3
|
|
+ "]] - [["
|
|
+ y2
|
|
+ " - "
|
|
+ y1
|
|
+ "] * ["
|
|
+ x1
|
|
+ " - "
|
|
+ x3
|
|
+ "]]]\n"
|
|
)
|
|
|
|
self.comment("If they are not parallel")
|
|
self.write("O900 IF [" + ua_denominator + " NE 0]\n")
|
|
self.comment("And if they are not coincident")
|
|
self.write("O901 IF [" + ua_numerator + " NE 0 ]\n")
|
|
|
|
self.write_blocknum()
|
|
self.write(" " + ua + "=[" + ua_numerator + " / " + ua_denominator + "]\n")
|
|
self.write_blocknum()
|
|
# NOTE: ub denominator is the same as ua denominator
|
|
self.write(" " + ub + "=[" + ub_numerator + " / " + ua_denominator + "]\n")
|
|
self.write_blocknum()
|
|
self.write(
|
|
" " + intersection_x + "=[" + x1 + " + [[" + ua + " * [" + x2 + " - " + x1 + "]]]]\n"
|
|
)
|
|
self.write_blocknum()
|
|
self.write(
|
|
" " + intersection_y + "=[" + y1 + " + [[" + ua + " * [" + y2 + " - " + y1 + "]]]]\n"
|
|
)
|
|
self.write_blocknum()
|
|
self.write(" " + self.RAPID())
|
|
self.write(" X " + intersection_x + " Y " + intersection_y + "\n")
|
|
|
|
self.write("O901 ENDIF\n")
|
|
self.write("O900 ENDIF\n")
|
|
|
|
# We need to calculate the rotation angle based on the line formed by the
|
|
# x1,y1 and x2,y2 coordinate pair. With that angle, we need to move
|
|
# x_offset and y_offset distance from the current (0,0,0) position.
|
|
#
|
|
# The x1,y1,x2 and y2 parameters are all variable names that contain the actual
|
|
# values.
|
|
# The x_offset and y_offset are both numeric (floating point) values
|
|
def rapid_to_rotated_coordinate(
|
|
self, x1, y1, x2, y2, ref_x, ref_y, x_current, y_current, x_final, y_final
|
|
):
|
|
self.comment("Rapid to rotated coordinate")
|
|
self.write_blocknum()
|
|
self.write(
|
|
"#1 = [atan[" + y2 + " - " + y1 + "]/[" + x2 + " - " + x1 + "]] (nominal_angle)\n"
|
|
)
|
|
self.write_blocknum()
|
|
self.write("#2 = [atan[" + ref_y + "]/[" + ref_x + "]] (reference angle)\n")
|
|
self.write_blocknum()
|
|
self.write("#3 = [#1 - #2] (angle)\n")
|
|
self.write_blocknum()
|
|
self.write(
|
|
"#4 = [[["
|
|
+ (self.fmt.string(0))
|
|
+ " - "
|
|
+ (self.fmt.string(x_current))
|
|
+ "] * COS[ #3 ]] - [["
|
|
+ (self.fmt.string(0))
|
|
+ " - "
|
|
+ (self.fmt.string(y_current))
|
|
+ "] * SIN[ #3 ]]]\n"
|
|
)
|
|
self.write_blocknum()
|
|
self.write(
|
|
"#5 = [[["
|
|
+ (self.fmt.string(0))
|
|
+ " - "
|
|
+ (self.fmt.string(x_current))
|
|
+ "] * SIN[ #3 ]] + [["
|
|
+ (self.fmt.string(0))
|
|
+ " - "
|
|
+ (self.fmt.string(y_current))
|
|
+ "] * COS[ #3 ]]]\n"
|
|
)
|
|
|
|
self.write_blocknum()
|
|
self.write(
|
|
"#6 = [["
|
|
+ (self.fmt.string(x_final))
|
|
+ " * COS[ #3 ]] - ["
|
|
+ (self.fmt.string(y_final))
|
|
+ " * SIN[ #3 ]]]\n"
|
|
)
|
|
self.write_blocknum()
|
|
self.write(
|
|
"#7 = [["
|
|
+ (self.fmt.string(y_final))
|
|
+ " * SIN[ #3 ]] + ["
|
|
+ (self.fmt.string(y_final))
|
|
+ " * COS[ #3 ]]]\n"
|
|
)
|
|
|
|
self.write_blocknum()
|
|
self.write(self.RAPID() + " X [ #4 + #6 ] Y [ #5 + #7 ]\n")
|
|
|
|
def BEST_POSSIBLE_SPEED(self, motion_blending_tolerance, naive_cam_tolerance):
|
|
statement = "G64"
|
|
|
|
if motion_blending_tolerance > 0:
|
|
statement += " P " + str(motion_blending_tolerance)
|
|
|
|
if naive_cam_tolerance > 0:
|
|
statement += " Q " + str(naive_cam_tolerance)
|
|
|
|
return statement
|
|
|
|
def set_path_control_mode(self, mode, motion_blending_tolerance, naive_cam_tolerance):
|
|
self.write_blocknum()
|
|
if mode == 0:
|
|
self.write(self.EXACT_PATH_MODE() + "\n")
|
|
if mode == 1:
|
|
self.write(self.EXACT_STOP_MODE() + "\n")
|
|
if mode == 2:
|
|
self.write(
|
|
self.BEST_POSSIBLE_SPEED(motion_blending_tolerance, naive_cam_tolerance) + "\n"
|
|
)
|
|
|
|
|
|
################################################################################
|
|
|
|
nc.creator = Creator()
|