kopia lustrzana https://github.com/vilemduha/blendercam
1341 wiersze
44 KiB
Python
1341 wiersze
44 KiB
Python
################################################################################
|
|
# iso.py
|
|
#
|
|
# Simple ISO NC code creator
|
|
#
|
|
# Hirutso Enni, 2009-01-13
|
|
|
|
from . import nc
|
|
import math
|
|
from .format import Format
|
|
from .format import *
|
|
|
|
################################################################################
|
|
class Creator(nc.Creator):
|
|
|
|
def __init__(self):
|
|
nc.Creator.__init__(self)
|
|
|
|
# internal variables
|
|
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.r = 0
|
|
self.s = AddressPlusMinus('S', fmt = Format(number_of_decimal_places = 2), modal = False)
|
|
self.t = None
|
|
self.x = None
|
|
self.y = None
|
|
self.z = None
|
|
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.in_quadrant_splitting = False
|
|
self.in_canned_cycle = False
|
|
self.first_drill_pos = True
|
|
self.shift_x = 0.0
|
|
self.shift_y = 0.0
|
|
self.shift_z = 0.0
|
|
self.start_of_line = False
|
|
self.internal_coolant_on = None
|
|
self.g98_not_g99 = None # True for G98 ouput, False for G99 output
|
|
self.current_fixture = None
|
|
self.fixture_wanted = '54'
|
|
self.move_done_since_tool_change = False
|
|
self.tool_defn_params = {}
|
|
self.program_id = None
|
|
self.current_sub_id = None
|
|
self.subroutine_files = []
|
|
self.program_name = None
|
|
self.temp_file_to_append_on_close = None
|
|
self.fixture_order = ['54', '55', '56', '57', '58', '59']
|
|
for i in range(1, 50):
|
|
self.fixture_order.append('54.' + str(i))
|
|
self.output_disabled = False
|
|
self.z_for_g43 = None
|
|
|
|
# optional settings
|
|
self.arc_centre_absolute = False
|
|
self.arc_centre_positive = False
|
|
self.drillExpanded = False
|
|
self.dwell_allowed_in_G83 = False
|
|
self.can_do_helical_arcs = True
|
|
self.z_for_g53 = None # set this to a value to output G53 Zvalue in tool change and at program end
|
|
self.output_h_and_d_at_tool_change = False
|
|
self.output_block_numbers = True
|
|
self.start_block_number = 10
|
|
self.block_number_increment = 10
|
|
self.block_number_restart_after = None
|
|
self.output_tool_definitions = True
|
|
self.output_tool_change = True
|
|
self.output_g43_on_tool_change_line = False
|
|
self.output_internal_coolant_commands = False
|
|
self.output_g98_and_g99 = True
|
|
self.output_g43_z_before_drilling_if_g98 = False
|
|
self.output_cutviewer_comments = False
|
|
self.output_fixtures = False
|
|
self.use_this_program_id = None
|
|
self.subroutines_in_own_files = False
|
|
self.pattern_done_with_subroutine = False
|
|
self.output_comment_before_tool_change = True
|
|
self.output_arcs_as_lines = False
|
|
self.m_codes_on_their_own_line = False
|
|
|
|
############################################################################
|
|
## Codes
|
|
|
|
def SPACE_STR(self): return ''
|
|
def SPACE(self):
|
|
if self.start_of_line == True:
|
|
self.start_of_line = False
|
|
return ''
|
|
else:
|
|
return self.SPACE_STR()
|
|
|
|
def FORMAT_FEEDRATE(self): return('%.2f')
|
|
def FORMAT_ANG(self): return('%.1f')
|
|
def FORMAT_TIME(self): return self.fmt
|
|
|
|
def BLOCK(self): return('N%i')
|
|
def COMMENT(self,comment): return( ('(%s)' % comment ) )
|
|
def VARIABLE(self): return( '#%i')
|
|
def VARIABLE_SET(self): return( '=%.3f')
|
|
|
|
def PROGRAM(self): return( 'O%i')
|
|
def PROGRAM_END(self): return( 'M02')
|
|
|
|
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, dwell): return('G04' + self.SPACE() + self.TIME() + (self.FORMAT_TIME().string(dwell)))
|
|
def DRILL(self): return('G81')
|
|
def DRILL_WITH_DWELL(self, dwell): return('G82' + self.SPACE() + self.TIME() + (self.FORMAT_TIME().string(dwell)))
|
|
def PECK_DRILL(self): return('G83')
|
|
def PECK_DEPTH(self, depth): return('Q' + (self.fmt.string(depth)))
|
|
def RETRACT(self, height): return('R' + (self.fmt.string(height)))
|
|
def END_CANNED_CYCLE(self): return('G80')
|
|
def TAP(self): return('G84')
|
|
def TAP_DEPTH(self, depth): return('K' + (self.fmt.string(depth)))
|
|
def INTERNAL_COOLANT_ON(self): return('M18')
|
|
def INTERNAL_COOLANT_OFF(self): return('M9')
|
|
|
|
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')
|
|
|
|
def RETRACT_TO_CLEARANCE(self): return('G98')
|
|
def RETRACT_TO_STANDOFF(self): return('G99')
|
|
|
|
############################################################################
|
|
## Internals
|
|
def write(self, s):
|
|
if self.output_disabled == False:
|
|
nc.Creator.write(self, s)
|
|
if '\n' in s:
|
|
self.start_of_line = s[-1] == '\n'
|
|
|
|
def write_feedrate(self):
|
|
self.f.write(self)
|
|
|
|
def write_preps(self):
|
|
i = 0
|
|
if self.g_plane.str:
|
|
i += 1
|
|
self.g_plane.write(self)
|
|
for g in self.g_list:
|
|
if i > 0:
|
|
self.write('\n' if self.m_codes_on_their_own_line else self.SPACE())
|
|
self.write(g)
|
|
i += 1
|
|
self.g_list = []
|
|
|
|
def write_misc(self):
|
|
if (len(self.m)):
|
|
self.write('\n' if self.m_codes_on_their_own_line else self.SPACE())
|
|
self.write(self.m.pop())
|
|
|
|
def write_spindle(self):
|
|
if self.s.str:
|
|
self.write('\n' if self.m_codes_on_their_own_line else '')
|
|
self.s.write(self)
|
|
|
|
def output_fixture(self):
|
|
if self.current_fixture != self.fixture_wanted:
|
|
self.current_fixture = self.fixture_wanted
|
|
self.g_list.append('G' + str(self.current_fixture))
|
|
|
|
def increment_fixture(self):
|
|
for i in range(0, len(self.fixture_order) - 1):
|
|
if self.fixture_order[i] == self.fixture_wanted:
|
|
self.fixture_wanted = self.fixture_order[i+1]
|
|
return
|
|
raise 'too many fixtures wanted!'
|
|
|
|
def get_fixture(self):
|
|
return self.fixture_wanted
|
|
|
|
def set_fixture(self, fixture):
|
|
self.fixture_wanted = fixture
|
|
|
|
############################################################################
|
|
## Programs
|
|
|
|
def program_begin(self, id, name=''):
|
|
if self.use_this_program_id:
|
|
id = self.use_this_program_id
|
|
if self.PROGRAM() != None:
|
|
self.writem([(self.PROGRAM() % id), self.SPACE(), (self.COMMENT(name))])
|
|
self.write('\n')
|
|
self.program_id = id
|
|
self.program_name = name
|
|
|
|
def add_stock(self, type_name, params):
|
|
if self.output_cutviewer_comments:
|
|
self.write("(STOCK/" + type_name)
|
|
for param in params:
|
|
self.write(",")
|
|
self.write(str(param))
|
|
self.write(")\n")
|
|
|
|
def program_stop(self, optional=False):
|
|
if (optional) :
|
|
self.write(self.SPACE() + self.STOP_OPTIONAL() + '\n')
|
|
self.prev_g0123 = ''
|
|
else :
|
|
self.write(self.STOP() + '\n')
|
|
self.prev_g0123 = ''
|
|
|
|
def number_file(self, filename):
|
|
import tempfile
|
|
temp_filename = tempfile.gettempdir()+'/renumbering.txt'
|
|
|
|
# make a copy of file
|
|
f_in = open(filename, 'r')
|
|
f_out = open(temp_filename, 'w')
|
|
while (True):
|
|
line = f_in.readline()
|
|
if (len(line) == 0) : break
|
|
f_out.write(line)
|
|
f_in.close()
|
|
f_out.close()
|
|
|
|
# read copy
|
|
f_in = open(temp_filename, 'r')
|
|
f_out = open(filename, 'w')
|
|
n = self.start_block_number
|
|
while (True):
|
|
line = f_in.readline()
|
|
|
|
if (len(line) == 0) : break
|
|
f_out.write(self.BLOCK() % n + self.SPACE() + line)
|
|
n += self.block_number_increment
|
|
if self.block_number_restart_after != None:
|
|
if n >= self.block_number_restart_after:
|
|
n = self.start_block_number
|
|
f_in.close()
|
|
f_out.close()
|
|
|
|
def program_end(self):
|
|
if self.z_for_g53 != None:
|
|
self.write(self.SPACE() + self.MACHINE_COORDINATES() + self.SPACE() + 'Z' + self.fmt.string(self.z_for_g53) + '\n')
|
|
self.write(self.SPACE() + self.PROGRAM_END() + '\n')
|
|
|
|
if self.temp_file_to_append_on_close != None:
|
|
f_in = open(self.temp_file_to_append_on_close, 'r')
|
|
while (True):
|
|
line = f_in.readline()
|
|
if (len(line) == 0) : break
|
|
self.write(line)
|
|
f_in.close()
|
|
|
|
self.file_close()
|
|
|
|
if self.output_block_numbers:
|
|
# number every line of the file afterwards
|
|
self.number_file(self.filename)
|
|
|
|
for f in self.subroutine_files:
|
|
self.number_file(f)
|
|
|
|
def flush_nc(self):
|
|
if len(self.g_list) == 0 and len(self.m) == 0: return
|
|
self.write_preps()
|
|
self.write_misc()
|
|
self.write('\n')
|
|
|
|
############################################################################
|
|
## Subprograms
|
|
|
|
def make_subroutine_name(self, id):
|
|
s = self.filename
|
|
for i in reversed(range(0, len(s))):
|
|
if s[i] == '.':
|
|
return s[0:i] + 'sub' + str(id) + s[i:]
|
|
|
|
# '.' not found
|
|
return s + 'sub' + str(id)
|
|
|
|
def sub_begin(self, id, name=None):
|
|
if id == None:
|
|
if self.current_sub_id == None:
|
|
self.current_sub_id = self.program_id
|
|
self.current_sub_id += 1
|
|
id = self.current_sub_id
|
|
|
|
if name == None:
|
|
name = self.program_name + ' subroutine ' + str(id)
|
|
|
|
self.save_file = self.file
|
|
if self.subroutines_in_own_files:
|
|
new_name = self.make_subroutine_name(id)
|
|
self.file = open(new_name, 'w')
|
|
self.subroutine_files.append(new_name)
|
|
else:
|
|
## use temporary file
|
|
import tempfile
|
|
temp_filename = tempfile.gettempdir()+'/subroutines.txt'
|
|
if self.temp_file_to_append_on_close == None:
|
|
self.temp_file_to_append_on_close = temp_filename
|
|
self.file = open(temp_filename, 'w')
|
|
else:
|
|
self.file = open(temp_filename, 'a')
|
|
|
|
if self.PROGRAM() != None:
|
|
self.write((self.PROGRAM() % id) + self.SPACE() + (self.COMMENT(name)))
|
|
self.write('\n')
|
|
|
|
def sub_call(self, id):
|
|
if id == None:
|
|
id = self.current_sub_id
|
|
self.write(self.SPACE() + (self.SUBPROG_CALL() % id) + '\n')
|
|
|
|
def sub_end(self):
|
|
self.write(self.SPACE() + self.SUBPROG_END() + '\n')
|
|
|
|
self.file.close()
|
|
self.file = self.save_file
|
|
|
|
def disable_output(self):
|
|
self.output_disabled = True
|
|
|
|
def enable_output(self):
|
|
self.output_disabled = False
|
|
|
|
############################################################################
|
|
## 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(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(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):
|
|
if self.output_comment_before_tool_change:
|
|
if id in self.tool_defn_params:
|
|
self.comment('tool change to ' + self.tool_defn_params[id]['name']);
|
|
|
|
if self.output_cutviewer_comments:
|
|
import cutviewer
|
|
if id in self.tool_defn_params:
|
|
cutviewer.tool_defn(self, id, self.tool_defn_params[id])
|
|
if (self.t != None) and (self.z_for_g53 != None):
|
|
self.write('G53 Z' + str(self.z_for_g53) + '\n')
|
|
self.write(self.SPACE() + (self.TOOL() % id))
|
|
if self.output_g43_on_tool_change_line == True:
|
|
self.write(self.SPACE() + 'G43')
|
|
self.write('\n')
|
|
if self.output_h_and_d_at_tool_change == True:
|
|
if self.output_g43_on_tool_change_line == False:
|
|
self.write(self.SPACE() + 'G43')
|
|
self.write(self.SPACE() + 'D' + str(id) + self.SPACE() + 'H' + str(id) + '\n')
|
|
self.t = id
|
|
self.move_done_since_tool_change = False
|
|
|
|
def tool_defn(self, id, name='',params=None):
|
|
self.tool_defn_params[id] = params
|
|
if self.output_tool_definitions:
|
|
self.write(self.SPACE() + self.TOOL_DEFINITION())
|
|
self.write(self.SPACE() + ('P%i' % id) + ' ')
|
|
|
|
if (params['diameter'] != None):
|
|
self.write(self.SPACE() + ('R%.3f' % (float(params['diameter'])/2)))
|
|
|
|
if (params['cutting edge height'] != 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.SPINDLE_CW(), self.SPINDLE_CCW())
|
|
else:
|
|
self.s.set(s, self.SPINDLE_CCW(), self.SPINDLE_CW())
|
|
|
|
def coolant(self, mode=0):
|
|
if (mode <= 0) : self.m.append(self.COOLANT_OFF())
|
|
elif (mode == 1) : self.m.append(self.COOLANT_MIST())
|
|
elif (mode == 2) : self.m.append(self.COOLANT_FLOOD())
|
|
|
|
def gearrange(self, gear=0):
|
|
if (gear <= 0) : self.m.append(self.GEAR_OFF())
|
|
elif (gear <= 4) : self.m.append(self.GEAR() % (gear + GEAR_BASE()))
|
|
|
|
############################################################################
|
|
## Moves
|
|
|
|
def rapid(self, x=None, y=None, z=None, a=None, b=None, c=None ):
|
|
(x, y, z, a, b, c,axis_count)=self.filter_xyz(x, y, z, a, b, c)
|
|
if axis_count==0: return
|
|
self.on_move()
|
|
|
|
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):
|
|
if (self.absolute_flag ):
|
|
self.write(self.SPACE() + self.X() + (self.fmt.string(x + self.shift_x)))
|
|
else:
|
|
dx = x - self.x
|
|
self.write(self.SPACE() + self.X() + (self.fmt.string(dx)))
|
|
self.x = x
|
|
if (y != None):
|
|
if (self.absolute_flag ):
|
|
self.write(self.SPACE() + self.Y() + (self.fmt.string(y + self.shift_y)))
|
|
else:
|
|
dy = y - self.y
|
|
self.write(self.SPACE() + self.Y() + (self.fmt.string(dy)))
|
|
|
|
self.y = y
|
|
if (z != None):
|
|
if (self.absolute_flag ):
|
|
self.write(self.SPACE() + self.Z() + (self.fmt.string(z + self.shift_z)))
|
|
else:
|
|
dz = z - self.z
|
|
self.write(self.SPACE() + self.Z() + (self.fmt.string(dz)))
|
|
|
|
self.z = z
|
|
|
|
if (a != None):
|
|
if (self.absolute_flag ):
|
|
self.write(self.SPACE() + self.A() + (self.fmt.string(a)))
|
|
else:
|
|
da = a - self.a
|
|
self.write(self.SPACE() + self.A() + (self.fmt.string(da)))
|
|
self.a = a
|
|
|
|
if (b != None):
|
|
if (self.absolute_flag ):
|
|
self.write(self.SPACE() + self.B() + (self.fmt.string(b)))
|
|
else:
|
|
db = b - self.b
|
|
self.write(self.SPACE() + self.B() + (self.fmt.string(db)))
|
|
self.b = b
|
|
|
|
if (c != None):
|
|
if (self.absolute_flag ):
|
|
self.write(self.SPACE() + self.C() + (self.fmt.string(c)))
|
|
else:
|
|
dc = c - self.c
|
|
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):
|
|
(x, y, z, a, b, c,axis_count)=self.filter_xyz(x, y, z, a, b, c)
|
|
if axis_count==0: return
|
|
self.on_move()
|
|
if self.g0123_modal:
|
|
if self.prev_g0123 != self.FEED():
|
|
self.writem([self.SPACE() , self.FEED()])
|
|
self.prev_g0123 = self.FEED()
|
|
else:
|
|
self.write(self.SPACE() + self.FEED())
|
|
self.write_preps()
|
|
dx = dy = dz = 0
|
|
if (x != None):
|
|
dx = x - self.x
|
|
if (self.absolute_flag ):
|
|
self.writem([self.SPACE() , self.X() , (self.fmt.string(x + self.shift_x))])
|
|
else:
|
|
self.writem([self.SPACE() , self.X() , (self.fmt.string(dx))])
|
|
self.x = x
|
|
if (y != None):
|
|
dy = y - self.y
|
|
if (self.absolute_flag ):
|
|
self.writem([self.SPACE() , self.Y() , (self.fmt.string(y + self.shift_y))])
|
|
else:
|
|
self.writem([self.SPACE() , self.Y() , (self.fmt.string(dy))])
|
|
|
|
self.y = y
|
|
if (z != None):
|
|
dz = z - self.z
|
|
if (self.absolute_flag ):
|
|
self.writem([self.SPACE() , self.Z() , (self.fmt.string(z + self.shift_z))])
|
|
else:
|
|
self.writem([self.SPACE() , self.Z() , (self.fmt.string(dz))])
|
|
|
|
self.z = z
|
|
|
|
if (a != None):
|
|
da = a - self.a
|
|
if (self.absolute_flag ):
|
|
self.writem([self.SPACE() , self.A() , (self.fmt.string(a))])
|
|
else:
|
|
self.writem([self.SPACE() , self.A() , (self.fmt.string(da))])
|
|
self.a = a
|
|
|
|
if (b != None):
|
|
db = b - self.b
|
|
if (self.absolute_flag ):
|
|
self.writem([self.SPACE() , self.B() , (self.fmt.string(b))])
|
|
else:
|
|
self.writem([self.SPACE() , self.B() , (self.fmt.string(db))])
|
|
self.b = b
|
|
|
|
if (c != None):
|
|
dc = c - self.c
|
|
if (self.absolute_flag ):
|
|
self.writem([self.SPACE() , self.C() , (self.fmt.string(c))])
|
|
else:
|
|
self.writem([self.SPACE() , self.C() , (self.fmt.string(dc))])
|
|
self.c = c
|
|
|
|
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 filter_xyz(self, x=None, y=None, z=None, a=None, b=None, c=None):
|
|
""" Check if x,y,z,a,b,c are the same and set them to None if they are
|
|
return value = (x,y,z,a,b,c,count) where count is the number of
|
|
axis moves left.
|
|
"""
|
|
rv = [x,y,z,a,b,c,0]
|
|
comparisons = ((x,self.shift_x,self.x),(y,self.shift_y,self.y),(z,self.shift_z,self.z),
|
|
(a,0,self.a),(b,0,self.b),(c,0,self.c))
|
|
|
|
for i,(new_val,shift,current_val) in enumerate(comparisons):
|
|
if new_val is not None:
|
|
if self.fmt.string(new_val+shift) == self.fmt.string(current_val):
|
|
rv[i]=None
|
|
else:
|
|
rv[6]+=1
|
|
return rv
|
|
|
|
|
|
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):
|
|
(x,y,z,_,_,_,axis_count) = self.filter_xyz(x,y,z)
|
|
if axis_count==0: return
|
|
|
|
if self.output_arcs_as_lines or (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
|
|
if z != None:
|
|
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)
|
|
if z == None:
|
|
next_z = None
|
|
else:
|
|
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 (self.fmt.string(x1) != self.fmt.string(self.x)) or (self.fmt.string(y1) != self.fmt.string(self.y)):
|
|
if (math.fabs(x1 - self.x) > 0.01) or (math.fabs(y1 - self.y) > 0.01):
|
|
self.arc(cw, x1, y1, z, i, j, k, r)
|
|
else:
|
|
self.feed(x1, y1, z)
|
|
if q == qe:
|
|
break
|
|
if cw:
|
|
q = q - 1
|
|
else:
|
|
q = q + 1
|
|
|
|
self.in_quadrant_splitting = False
|
|
return
|
|
|
|
self.on_move()
|
|
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(self.SPACE() + arc_g_code)
|
|
self.prev_g0123 = arc_g_code
|
|
else:
|
|
self.write(self.SPACE() + 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_preps()
|
|
self.write(self.SPACE() + self.DWELL(t))
|
|
self.write_misc()
|
|
self.write('\n')
|
|
|
|
def on_move(self):
|
|
if self.output_fixtures:
|
|
self.output_fixture()
|
|
self.move_done_since_tool_change = True
|
|
|
|
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()"
|
|
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(self.SPACE() + 'G40\n')
|
|
|
|
############################################################################
|
|
## Cycles
|
|
|
|
def pattern(self):
|
|
pass
|
|
|
|
def pattern_uses_subroutine(self):
|
|
return self.pattern_done_with_subroutine
|
|
|
|
def pocket(self):
|
|
pass
|
|
|
|
def profile(self):
|
|
pass
|
|
|
|
def write_internal_coolant_commands(self, internal_coolant_on):
|
|
if (internal_coolant_on != None) and (self.output_internal_coolant_commands == True):
|
|
if internal_coolant_on == True:
|
|
if self.internal_coolant_on != True:
|
|
self.write(self.SPACE())
|
|
self.write(self.INTERNAL_COOLANT_ON() + '\n')
|
|
self.internal_coolant_on = True
|
|
else:
|
|
if self.internal_coolant_on != False:
|
|
self.write(self.SPACE())
|
|
self.write(self.INTERNAL_COOLANT_OFF() + '\n')
|
|
self.internal_coolant_on = False
|
|
|
|
# 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 (depthparams.clearance_height == None):
|
|
self.first_drill_pos = False
|
|
return
|
|
|
|
self.write_internal_coolant_commands(internal_coolant_on)
|
|
|
|
drillExpanded = self.drillExpanded
|
|
if (depthparams.step_down != 0) and (dwell != 0):
|
|
# pecking and dwell together
|
|
if self.dwell_allowed_in_G83 != True:
|
|
drillExpanded = True
|
|
|
|
if drillExpanded:
|
|
# for machines which don't understand G81, G82 etc.
|
|
peck_depth = depthparams.step_down
|
|
if peck_depth == None:
|
|
peck_depth = depthparams.final_depth
|
|
current_z = depthparams.start_depth
|
|
self.rapid(x, y)
|
|
|
|
first = True
|
|
last_cut = False
|
|
|
|
while True:
|
|
next_z = current_z - peck_depth
|
|
if next_z < (depthparams.final_depth + 0.001):
|
|
next_z = depthparams.final_depth
|
|
last_cut = True
|
|
if next_z >= current_z:
|
|
break;
|
|
if first:
|
|
self.rapid(z = depthparams.start_depth + depthparams.rapid_safety_space)
|
|
else:
|
|
self.rapid(z = current_z)
|
|
self.feed(z = next_z)
|
|
if dwell != 0 and last_cut:
|
|
self.dwell(dwell)
|
|
if last_cut:self.rapid(z = depthparams.clearance_height)
|
|
else:
|
|
if rapid_to_clearance:
|
|
self.rapid(z = depthparams.clearance_height)
|
|
else:
|
|
self.rapid(z = depthparams.start_depth + depthparams.rapid_safety_space)
|
|
current_z = next_z
|
|
first = False
|
|
|
|
self.first_drill_pos = False
|
|
return
|
|
|
|
if self.output_g98_and_g99 == True:
|
|
if rapid_to_clearance == True:
|
|
if self.output_g43_z_before_drilling_if_g98:
|
|
if self.fmt.string(depthparams.clearance_height) != self.z_for_g43:
|
|
self.z_for_g43 = self.fmt.string(depthparams.clearance_height)
|
|
self.write(self.SPACE() + 'G43' + self.SPACE() + 'Z' + self.z_for_g43 + '\n')
|
|
|
|
if self.first_drill_pos ==True and rapid_to_clearance == True:
|
|
self.rapid(x, y)
|
|
self.rapid(z = depthparams.clearance_height)
|
|
|
|
self.in_canned_cycle = True
|
|
self.write_preps()
|
|
|
|
if (depthparams.step_down != 0):
|
|
# G83 peck drilling
|
|
if self.drill_modal:
|
|
if self.PECK_DRILL() + self.PECK_DEPTH(depthparams.step_down) != self.prev_drill:
|
|
self.write(self.SPACE() + self.PECK_DRILL() + self.SPACE() + self.PECK_DEPTH(depthparams.step_down))
|
|
self.prev_drill = self.PECK_DRILL() + self.PECK_DEPTH(depthparams.step_down)
|
|
else:
|
|
self.write(self.PECK_DRILL() + self.PECK_DEPTH(depthparams.step_down))
|
|
|
|
if (self.dwell != 0) and self.dwell_allowed_in_G83:
|
|
self.write(self.SPACE() + self.TIME() + (self.FORMAT_TIME().string(dwell)))
|
|
|
|
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(dwell) != self.prev_drill:
|
|
self.write(self.SPACE() + self.DRILL_WITH_DWELL(dwell))
|
|
self.prev_drill = self.DRILL_WITH_DWELL(dwell)
|
|
else:
|
|
self.write(self.SPACE() + self.DRILL_WITH_DWELL(dwell))
|
|
|
|
if self.output_g98_and_g99 == True:
|
|
if rapid_to_clearance == True:
|
|
if self.g98_not_g99 != True:
|
|
self.write(self.SPACE() + self.RETRACT_TO_CLEARANCE())
|
|
self.g98_not_g99 = True
|
|
else:
|
|
if self.g98_not_g99 != False:
|
|
self.write(self.SPACE() + self.RETRACT_TO_STANDOFF())
|
|
self.g98_not_g99 = False
|
|
|
|
# Set the retraction point to the 'standoff' distance above the starting z height.
|
|
retract_height = depthparams.start_depth + depthparams.rapid_safety_space
|
|
if (x != None):
|
|
self.write(self.SPACE() + self.X() + (self.fmt.string(x + self.shift_x)))
|
|
self.x = x
|
|
|
|
if (y != None):
|
|
self.write(self.SPACE() + self.Y() + (self.fmt.string(y + self.shift_y)))
|
|
self.y = y
|
|
|
|
if self.drill_modal:
|
|
if depthparams.start_depth != self.prev_z:
|
|
self.write(self.SPACE() + self.Z() + (self.fmt.string(depthparams.final_depth)))
|
|
self.prev_z=depthparams.start_depth
|
|
else:
|
|
self.write(self.SPACE() + self.Z() + (self.fmt.string(depthparams.final_depth))) # This is the 'z' value for the bottom of the hole.
|
|
self.z = (depthparams.start_depth + depthparams.rapid_safety_space) # We want to remember where z is at the end (at the top of the hole)
|
|
|
|
if self.drill_modal:
|
|
if self.prev_retract != self.RETRACT(retract_height) :
|
|
self.write(self.SPACE() + self.RETRACT(retract_height))
|
|
self.prev_retract = self.RETRACT(retract_height)
|
|
else:
|
|
self.write(self.SPACE() + self.RETRACT(retract_height))
|
|
|
|
if (self.fv) :
|
|
self.f.set(self.fv)
|
|
|
|
self.write_feedrate()
|
|
self.write_spindle()
|
|
self.write_misc()
|
|
self.write('\n')
|
|
self.first_drill_pos = False
|
|
|
|
def end_canned_cycle(self):
|
|
if self.in_canned_cycle == False:
|
|
return
|
|
self.write(self.SPACE() + self.END_CANNED_CYCLE() + '\n')
|
|
self.write_internal_coolant_commands(0)
|
|
self.prev_drill = ''
|
|
self.prev_g0123 = ''
|
|
self.prev_z = ''
|
|
self.prev_f = ''
|
|
self.prev_retract = ''
|
|
self.in_canned_cycle = False
|
|
self.first_drill_pos = True
|
|
|
|
############################################################################
|
|
## 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(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(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_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((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(self.SPACE() + ('#' + intersection_variable_x + '= [#5061 - [ 0.5 * ' + probe_offset_x_component + ']]\n'))
|
|
self.write(self.SPACE() + ('#' + intersection_variable_y + '= [#5062 - [ 0.5 * ' + probe_offset_y_component + ']]\n'))
|
|
self.write(self.RAPID())
|
|
self.write(self.SPACE() + ' X #' + intersection_variable_x + ' Y #' + intersection_variable_y + '\n')
|
|
|
|
self.write(self.SPACE() + self.FEEDRATE() + self.ffmt.string(self.fh / 2.0) + '\n')
|
|
|
|
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(('#' + intersection_variable_x + '=' + probe_offset_x_component + ' (Portion of probe radius that contributes to the X coordinate)\n'))
|
|
self.write(('#' + intersection_variable_x + '=[#' + intersection_variable_x + ' + #5061]\n'))
|
|
self.write(('#' + intersection_variable_y + '=' + probe_offset_y_component + ' (Portion of probe radius that contributes to the Y coordinate)\n'))
|
|
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((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((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(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(self.RAPID())
|
|
self.write(' X ' + x + ' Y ' + y + '\n')
|
|
|
|
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(('#' + 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((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(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(ua_numerator + '=[[[' + x4 + ' - ' + x3 + '] * [' + y1 + ' - ' + y3 + ']] - [[' + y4 + ' - ' + y3 + '] * [' + x1 + ' - ' + x3 + ']]]\n')
|
|
self.write(ua_denominator + '=[[[' + y4 + ' - ' + y3 + '] * [' + x2 + ' - ' + x1 + ']] - [[' + x4 + ' - ' + x3 + '] * [' + y2 + ' - ' + y1 + ']]]\n')
|
|
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(' ' + ua + '=[' + ua_numerator + ' / ' + ua_denominator + ']\n')
|
|
self.write(' ' + ub + '=[' + ub_numerator + ' / ' + ua_denominator + ']\n') # NOTE: ub denominator is the same as ua denominator
|
|
self.write(' ' + intersection_x + '=[' + x1 + ' + [[' + ua + ' * [' + x2 + ' - ' + x1 + ']]]]\n')
|
|
self.write(' ' + intersection_y + '=[' + y1 + ' + [[' + ua + ' * [' + y2 + ' - ' + y1 + ']]]]\n')
|
|
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( '#1 = [atan[' + y2 + ' - ' + y1 + ']/[' + x2 +' - ' + x1 + ']] (nominal_angle)\n')
|
|
self.write( '#2 = [atan[' + ref_y + ']/[' + ref_x + ']] (reference angle)\n')
|
|
self.write( '#3 = [#1 - #2] (angle)\n' )
|
|
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( '#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( '#6 = [[' + (self.fmt.string(x_final)) + ' * COS[ #3 ]] - [' + (self.fmt.string(y_final)) + ' * SIN[ #3 ]]]\n' )
|
|
self.write( '#7 = [[' + (self.fmt.string(y_final)) + ' * SIN[ #3 ]] + [' + (self.fmt.string(y_final)) + ' * COS[ #3 ]]]\n' )
|
|
|
|
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 ):
|
|
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()
|