# ##########################################################
# FlatCAM: 2D Post-processing for Manufacturing #
# http://flatcam.org #
# Author: Juan Pablo Caram (c) #
# Date: 2/5/2014 #
# MIT Licence #
# ##########################################################
# ##########################################################
# File modified by: Marius Stanciu #
# ##########################################################
from copy import deepcopy
from io import StringIO
from datetime import datetime
from appEditors.AppTextEditor import AppTextEditor
from appObjects.FlatCAMObj import *
from matplotlib.backend_bases import KeyEvent as mpl_key_event
from camlib import CNCjob
from shapely.ops import unary_union
from shapely.geometry import Point, MultiPoint, Polygon, LineString, box
import shapely.affinity as affinity
try:
from shapely.ops import voronoi_diagram
VORONOI_ENABLED = True
# from appCommon.Common import voronoi_diagram
except Exception:
VORONOI_ENABLED = False
import os
import sys
import time
import serial
import glob
import math
import numpy as np
import random
import gettext
import appTranslation as fcTranslate
import builtins
fcTranslate.apply_language('strings')
if '_' not in builtins.__dict__:
_ = gettext.gettext
class CNCJobObject(FlatCAMObj, CNCjob):
"""
Represents G-Code.
"""
optionChanged = QtCore.pyqtSignal(str)
build_al_table_sig = QtCore.pyqtSignal()
ui_type = CNCObjectUI
def __init__(self, name, units="in", kind="generic", z_move=0.1,
feedrate=3.0, feedrate_rapid=3.0, z_cut=-0.002, tooldia=0.0,
spindlespeed=None):
log.debug("Creating CNCJob object...")
self.decimals = self.app.decimals
CNCjob.__init__(self, units=units, kind=kind, z_move=z_move,
feedrate=feedrate, feedrate_rapid=feedrate_rapid, z_cut=z_cut, tooldia=tooldia,
spindlespeed=spindlespeed, steps_per_circle=int(self.app.defaults["cncjob_steps_per_circle"]))
FlatCAMObj.__init__(self, name)
self.kind = "cncjob"
self.options.update({
"plot": True,
"tooldia": 0.03937, # 0.4mm in inches
"append": "",
"prepend": "",
"dwell": False,
"dwelltime": 1,
"type": 'Geometry',
# "toolchange_macro": '',
# "toolchange_macro_enable": False
})
'''
This is a dict of dictionaries. Each dict is associated with a tool present in the file. The key is the
diameter of the tools and the value is another dict that will hold the data under the following form:
{tooldia: {
'tooluid': 1,
'offset': 'Path',
'type_item': 'Rough',
'tool_type': 'C1',
'data': {} # a dict to hold the parameters
'gcode': "" # a string with the actual GCODE
'gcode_parsed': {} # dictionary holding the CNCJob geometry and type of geometry
(cut or move)
'solid_geometry': []
},
...
}
It is populated in the GeometryObject.mtool_gen_cncjob()
BEWARE: I rely on the ordered nature of the Python 3.7 dictionary. Things might change ...
'''
self.cnc_tools = {}
'''
This is a dict of dictionaries. Each dict is associated with a tool present in the file. The key is the
diameter of the tools and the value is another dict that will hold the data under the following form:
{tooldia: {
'tool': int,
'nr_drills': int,
'nr_slots': int,
'offset': float,
'data': {}, a dict to hold the parameters
'gcode': "", a string with the actual GCODE
'gcode_parsed': [], list of dicts holding the CNCJob geometry and
type of geometry (cut or move)
'solid_geometry': [],
},
...
}
It is populated in the ExcellonObject.on_create_cncjob_click() but actually
it's done in camlib.CNCJob.generate_from_excellon_by_tool()
BEWARE: I rely on the ordered nature of the Python 3.7 dictionary. Things might change ...
'''
self.exc_cnc_tools = {}
# flag to store if the CNCJob is part of a special group of CNCJob objects that can't be processed by the
# default engine of FlatCAM. They generated by some of tools and are special cases of CNCJob objects.
self.special_group = None
# for now it show if the plot will be done for multi-tool CNCJob (True) or for single tool
# (like the one in the TCL Command), False
self.multitool = False
# determine if the GCode was generated out of a Excellon object or a Geometry object
self.origin_kind = None
self.coords_decimals = 4
self.fr_decimals = 2
self.annotations_dict = {}
# used for parsing the GCode lines to adjust the GCode when the GCode is offseted or scaled
gcodex_re_string = r'(?=.*(X[-\+]?\d*\.\d*))'
self.g_x_re = re.compile(gcodex_re_string)
gcodey_re_string = r'(?=.*(Y[-\+]?\d*\.\d*))'
self.g_y_re = re.compile(gcodey_re_string)
gcodez_re_string = r'(?=.*(Z[-\+]?\d*\.\d*))'
self.g_z_re = re.compile(gcodez_re_string)
gcodef_re_string = r'(?=.*(F[-\+]?\d*\.\d*))'
self.g_f_re = re.compile(gcodef_re_string)
gcodet_re_string = r'(?=.*(\=\s*[-\+]?\d*\.\d*))'
self.g_t_re = re.compile(gcodet_re_string)
gcodenr_re_string = r'([+-]?\d*\.\d+)'
self.g_nr_re = re.compile(gcodenr_re_string)
if self.app.is_legacy is False:
self.text_col = self.app.plotcanvas.new_text_collection()
self.text_col.enabled = True
self.annotation = self.app.plotcanvas.new_text_group(collection=self.text_col)
self.gcode_editor_tab = None
self.gcode_viewer_tab = None
self.source_file = ''
self.units_found = self.app.defaults['units']
self.probing_gcode_text = ''
self.grbl_probe_result = ''
# store the current selection shape status to be restored after manual adding test points
self.old_selection_state = self.app.defaults['global_selection_shape']
# if mouse is dragging set the object True
self.mouse_is_dragging = False
# if mouse events are bound to local methods
self.mouse_events_connected = False
# event handlers references
self.kp = None
self.mm = None
self.mr = None
self.prepend_snippet = ''
self.append_snippet = ''
self.gc_header = self.gcode_header()
self.gc_start = ''
self.gc_end = ''
'''
dictionary of dictionaries to store the information's for the autolevelling
format when using Voronoi diagram:
{
id: {
'point': Shapely Point
'geo': Shapely Polygon from Voronoi diagram,
'height': float
}
}
'''
self.al_voronoi_geo_storage = {}
'''
list of (x, y, x) tuples to store the information's for the autolevelling
format when using bilinear interpolation:
[(x0, y0, z0), (x1, y1, z1), ...]
'''
self.al_bilinear_geo_storage = []
self.solid_geo = None
self.grbl_ser_port = None
self.pressed_button = None
if self.app.is_legacy is False:
self.probing_shapes = ShapeCollection(parent=self.app.plotcanvas.view.scene, layers=1)
else:
self.probing_shapes = ShapeCollectionLegacy(obj=self, app=self.app, name=name + "_probing_shapes")
# Attributes to be included in serialization
# Always append to it because it carries contents
# from predecessors.
self.ser_attrs += [
'options', 'kind', 'origin_kind', 'cnc_tools', 'exc_cnc_tools', 'multitool', 'append_snippet',
'prepend_snippet', 'gc_header'
]
def build_ui(self):
self.ui_disconnect()
# FIXME: until Shapely 1.8 comes this is disabled
self.ui.sal_btn.setChecked(False)
self.ui.sal_btn.setDisabled(True)
self.ui.sal_btn.setToolTip("DISABLED. Work in progress!")
FlatCAMObj.build_ui(self)
self.units = self.app.defaults['units'].upper()
# if the FlatCAM object is Excellon don't build the CNC Tools Table but hide it
self.ui.cnc_tools_table.hide()
if self.cnc_tools:
self.ui.cnc_tools_table.show()
self.build_cnc_tools_table()
self.ui.exc_cnc_tools_table.hide()
if self.exc_cnc_tools:
self.ui.exc_cnc_tools_table.show()
self.build_excellon_cnc_tools()
if self.ui.sal_btn.isChecked():
self.build_al_table()
self.ui_connect()
def build_cnc_tools_table(self):
tool_idx = 0
n = len(self.cnc_tools)
self.ui.cnc_tools_table.setRowCount(n)
for dia_key, dia_value in self.cnc_tools.items():
tool_idx += 1
row_no = tool_idx - 1
t_id = QtWidgets.QTableWidgetItem('%d' % int(tool_idx))
# id.setFlags(QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled)
self.ui.cnc_tools_table.setItem(row_no, 0, t_id) # Tool name/id
# Make sure that the tool diameter when in MM is with no more than 2 decimals.
# There are no tool bits in MM with more than 2 decimals diameter.
# For INCH the decimals should be no more than 4. There are no tools under 10mils.
dia_item = QtWidgets.QTableWidgetItem('%.*f' % (self.decimals, float(dia_value['tooldia'])))
offset_txt = list(str(dia_value['offset']))
offset_txt[0] = offset_txt[0].upper()
offset_item = QtWidgets.QTableWidgetItem(''.join(offset_txt))
type_item = QtWidgets.QTableWidgetItem(str(dia_value['type']))
tool_type_item = QtWidgets.QTableWidgetItem(str(dia_value['tool_type']))
t_id.setFlags(QtCore.Qt.ItemIsEnabled)
dia_item.setFlags(QtCore.Qt.ItemIsEnabled)
offset_item.setFlags(QtCore.Qt.ItemIsEnabled)
type_item.setFlags(QtCore.Qt.ItemIsEnabled)
tool_type_item.setFlags(QtCore.Qt.ItemIsEnabled)
# hack so the checkbox stay centered in the table cell
# used this:
# https://stackoverflow.com/questions/32458111/pyqt-allign-checkbox-and-put-it-in-every-row
# plot_item = QtWidgets.QWidget()
# checkbox = FCCheckBox()
# checkbox.setCheckState(QtCore.Qt.Checked)
# qhboxlayout = QtWidgets.QHBoxLayout(plot_item)
# qhboxlayout.addWidget(checkbox)
# qhboxlayout.setAlignment(QtCore.Qt.AlignCenter)
# qhboxlayout.setContentsMargins(0, 0, 0, 0)
plot_item = FCCheckBox()
plot_item.setLayoutDirection(QtCore.Qt.RightToLeft)
tool_uid_item = QtWidgets.QTableWidgetItem(str(dia_key))
if self.ui.plot_cb.isChecked():
plot_item.setChecked(True)
self.ui.cnc_tools_table.setItem(row_no, 1, dia_item) # Diameter
self.ui.cnc_tools_table.setItem(row_no, 2, offset_item) # Offset
self.ui.cnc_tools_table.setItem(row_no, 3, type_item) # Toolpath Type
self.ui.cnc_tools_table.setItem(row_no, 4, tool_type_item) # Tool Type
# ## REMEMBER: THIS COLUMN IS HIDDEN IN OBJECTUI.PY # ##
self.ui.cnc_tools_table.setItem(row_no, 5, tool_uid_item) # Tool unique ID)
self.ui.cnc_tools_table.setCellWidget(row_no, 6, plot_item)
# make the diameter column editable
# for row in range(tool_idx):
# self.ui.cnc_tools_table.item(row, 1).setFlags(QtCore.Qt.ItemIsSelectable |
# QtCore.Qt.ItemIsEnabled)
for row in range(tool_idx):
self.ui.cnc_tools_table.item(row, 0).setFlags(
self.ui.cnc_tools_table.item(row, 0).flags() ^ QtCore.Qt.ItemIsSelectable)
self.ui.cnc_tools_table.resizeColumnsToContents()
self.ui.cnc_tools_table.resizeRowsToContents()
vertical_header = self.ui.cnc_tools_table.verticalHeader()
# vertical_header.setSectionResizeMode(QtWidgets.QHeaderView.ResizeToContents)
vertical_header.hide()
self.ui.cnc_tools_table.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
horizontal_header = self.ui.cnc_tools_table.horizontalHeader()
horizontal_header.setMinimumSectionSize(10)
horizontal_header.setDefaultSectionSize(70)
horizontal_header.setSectionResizeMode(0, QtWidgets.QHeaderView.Fixed)
horizontal_header.resizeSection(0, 20)
horizontal_header.setSectionResizeMode(1, QtWidgets.QHeaderView.Stretch)
horizontal_header.setSectionResizeMode(3, QtWidgets.QHeaderView.ResizeToContents)
horizontal_header.setSectionResizeMode(4, QtWidgets.QHeaderView.Fixed)
horizontal_header.resizeSection(4, 40)
horizontal_header.setSectionResizeMode(6, QtWidgets.QHeaderView.Fixed)
horizontal_header.resizeSection(4, 17)
# horizontal_header.setStretchLastSection(True)
self.ui.cnc_tools_table.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
self.ui.cnc_tools_table.setColumnWidth(0, 20)
self.ui.cnc_tools_table.setColumnWidth(4, 40)
self.ui.cnc_tools_table.setColumnWidth(6, 17)
# self.ui.geo_tools_table.setSortingEnabled(True)
self.ui.cnc_tools_table.setMinimumHeight(self.ui.cnc_tools_table.getHeight())
self.ui.cnc_tools_table.setMaximumHeight(self.ui.cnc_tools_table.getHeight())
def build_excellon_cnc_tools(self):
tool_idx = 0
n = len(self.exc_cnc_tools)
self.ui.exc_cnc_tools_table.setRowCount(n)
for tooldia_key, dia_value in self.exc_cnc_tools.items():
tool_idx += 1
row_no = tool_idx - 1
t_id = QtWidgets.QTableWidgetItem('%d' % int(tool_idx))
dia_item = QtWidgets.QTableWidgetItem('%.*f' % (self.decimals, float(tooldia_key)))
nr_drills_item = QtWidgets.QTableWidgetItem('%d' % int(dia_value['nr_drills']))
nr_slots_item = QtWidgets.QTableWidgetItem('%d' % int(dia_value['nr_slots']))
try:
offset_val = self.app.dec_format(float(dia_value['offset']), self.decimals) + self.z_cut
except KeyError:
offset_val = self.app.dec_format(float(dia_value['offset_z']), self.decimals) + self.z_cut
cutz_item = QtWidgets.QTableWidgetItem('%f' % offset_val)
t_id.setFlags(QtCore.Qt.ItemIsEnabled)
dia_item.setFlags(QtCore.Qt.ItemIsEnabled)
nr_drills_item.setFlags(QtCore.Qt.ItemIsEnabled)
nr_slots_item.setFlags(QtCore.Qt.ItemIsEnabled)
cutz_item.setFlags(QtCore.Qt.ItemIsEnabled)
# hack so the checkbox stay centered in the table cell
# used this:
# https://stackoverflow.com/questions/32458111/pyqt-allign-checkbox-and-put-it-in-every-row
# plot_item = QtWidgets.QWidget()
# checkbox = FCCheckBox()
# checkbox.setCheckState(QtCore.Qt.Checked)
# qhboxlayout = QtWidgets.QHBoxLayout(plot_item)
# qhboxlayout.addWidget(checkbox)
# qhboxlayout.setAlignment(QtCore.Qt.AlignCenter)
# qhboxlayout.setContentsMargins(0, 0, 0, 0)
plot_item = FCCheckBox()
plot_item.setLayoutDirection(QtCore.Qt.RightToLeft)
tool_uid_item = QtWidgets.QTableWidgetItem(str(dia_value['tool']))
if self.ui.plot_cb.isChecked():
plot_item.setChecked(True)
self.ui.exc_cnc_tools_table.setItem(row_no, 0, t_id) # Tool name/id
self.ui.exc_cnc_tools_table.setItem(row_no, 1, dia_item) # Diameter
self.ui.exc_cnc_tools_table.setItem(row_no, 2, nr_drills_item) # Nr of drills
self.ui.exc_cnc_tools_table.setItem(row_no, 3, nr_slots_item) # Nr of slots
# ## REMEMBER: THIS COLUMN IS HIDDEN IN OBJECTUI.PY # ##
self.ui.exc_cnc_tools_table.setItem(row_no, 4, tool_uid_item) # Tool unique ID)
self.ui.exc_cnc_tools_table.setItem(row_no, 5, cutz_item)
self.ui.exc_cnc_tools_table.setCellWidget(row_no, 6, plot_item)
for row in range(tool_idx):
self.ui.exc_cnc_tools_table.item(row, 0).setFlags(
self.ui.exc_cnc_tools_table.item(row, 0).flags() ^ QtCore.Qt.ItemIsSelectable)
self.ui.exc_cnc_tools_table.resizeColumnsToContents()
self.ui.exc_cnc_tools_table.resizeRowsToContents()
vertical_header = self.ui.exc_cnc_tools_table.verticalHeader()
vertical_header.hide()
self.ui.exc_cnc_tools_table.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
horizontal_header = self.ui.exc_cnc_tools_table.horizontalHeader()
horizontal_header.setMinimumSectionSize(10)
horizontal_header.setDefaultSectionSize(70)
horizontal_header.setSectionResizeMode(0, QtWidgets.QHeaderView.Fixed)
horizontal_header.resizeSection(0, 20)
horizontal_header.setSectionResizeMode(1, QtWidgets.QHeaderView.Stretch)
horizontal_header.setSectionResizeMode(2, QtWidgets.QHeaderView.ResizeToContents)
horizontal_header.setSectionResizeMode(3, QtWidgets.QHeaderView.ResizeToContents)
horizontal_header.setSectionResizeMode(5, QtWidgets.QHeaderView.ResizeToContents)
horizontal_header.setSectionResizeMode(6, QtWidgets.QHeaderView.Fixed)
# horizontal_header.setStretchLastSection(True)
self.ui.exc_cnc_tools_table.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
self.ui.exc_cnc_tools_table.setColumnWidth(0, 20)
self.ui.exc_cnc_tools_table.setColumnWidth(6, 17)
self.ui.exc_cnc_tools_table.setMinimumHeight(self.ui.exc_cnc_tools_table.getHeight())
self.ui.exc_cnc_tools_table.setMaximumHeight(self.ui.exc_cnc_tools_table.getHeight())
def build_al_table(self):
tool_idx = 0
n = len(self.al_voronoi_geo_storage)
self.ui.al_probe_points_table.setRowCount(n)
for id_key, value in self.al_voronoi_geo_storage.items():
tool_idx += 1
row_no = tool_idx - 1
t_id = QtWidgets.QTableWidgetItem('%d' % int(tool_idx))
x = value['point'].x
y = value['point'].y
xy_coords = self.app.dec_format(x, dec=self.app.decimals), self.app.dec_format(y, dec=self.app.decimals)
coords_item = QtWidgets.QTableWidgetItem(str(xy_coords))
height = self.app.dec_format(value['height'], dec=self.app.decimals)
height_item = QtWidgets.QTableWidgetItem(str(height))
t_id.setFlags(QtCore.Qt.ItemIsEnabled)
coords_item.setFlags(QtCore.Qt.ItemIsEnabled)
height_item.setFlags(QtCore.Qt.ItemIsEnabled)
self.ui.al_probe_points_table.setItem(row_no, 0, t_id) # Tool name/id
self.ui.al_probe_points_table.setItem(row_no, 1, coords_item) # X-Y coords
self.ui.al_probe_points_table.setItem(row_no, 2, height_item) # Determined Height
self.ui.al_probe_points_table.resizeColumnsToContents()
self.ui.al_probe_points_table.resizeRowsToContents()
h_header = self.ui.al_probe_points_table.horizontalHeader()
h_header.setMinimumSectionSize(10)
h_header.setDefaultSectionSize(70)
h_header.setSectionResizeMode(0, QtWidgets.QHeaderView.Fixed)
h_header.resizeSection(0, 20)
h_header.setSectionResizeMode(1, QtWidgets.QHeaderView.Stretch)
h_header.setSectionResizeMode(2, QtWidgets.QHeaderView.ResizeToContents)
self.ui.al_probe_points_table.setMinimumHeight(self.ui.al_probe_points_table.getHeight())
self.ui.al_probe_points_table.setMaximumHeight(self.ui.al_probe_points_table.getHeight())
if self.ui.al_probe_points_table.model().rowCount():
self.ui.grbl_get_heightmap_button.setDisabled(False)
self.ui.grbl_save_height_map_button.setDisabled(False)
self.ui.h_gcode_button.setDisabled(False)
self.ui.view_h_gcode_button.setDisabled(False)
else:
self.ui.grbl_get_heightmap_button.setDisabled(True)
self.ui.grbl_save_height_map_button.setDisabled(True)
self.ui.h_gcode_button.setDisabled(True)
self.ui.view_h_gcode_button.setDisabled(True)
def set_ui(self, ui):
FlatCAMObj.set_ui(self, ui)
log.debug("FlatCAMCNCJob.set_ui()")
assert isinstance(self.ui, CNCObjectUI), \
"Expected a CNCObjectUI, got %s" % type(self.ui)
self.units = self.app.defaults['units'].upper()
self.units_found = self.app.defaults['units']
# this signal has to be connected to it's slot before the defaults are populated
# the decision done in the slot has to override the default value set below
# self.ui.toolchange_cb.toggled.connect(self.on_toolchange_custom_clicked)
self.form_fields.update({
"plot": self.ui.plot_cb,
"tooldia": self.ui.tooldia_entry,
# "append": self.ui.append_text,
# "prepend": self.ui.prepend_text,
# "toolchange_macro": self.ui.toolchange_text,
# "toolchange_macro_enable": self.ui.toolchange_cb,
"al_travelz": self.ui.ptravelz_entry,
"al_probe_depth": self.ui.pdepth_entry,
"al_probe_fr": self.ui.feedrate_probe_entry,
"al_controller": self.ui.al_controller_combo,
"al_method": self.ui.al_method_radio,
"al_mode": self.ui.al_mode_radio,
"al_rows": self.ui.al_rows_entry,
"al_columns": self.ui.al_columns_entry,
"al_grbl_jog_step": self.ui.jog_step_entry,
"al_grbl_jog_fr": self.ui.jog_fr_entry,
})
self.append_snippet = self.app.defaults['cncjob_append']
self.prepend_snippet = self.app.defaults['cncjob_prepend']
if self.append_snippet != '' or self.prepend_snippet != '':
self.ui.snippets_cb.set_value(True)
# Fill form fields only on object create
self.to_form()
# this means that the object that created this CNCJob was an Excellon or Geometry
try:
if self.travel_distance:
self.ui.t_distance_label.show()
self.ui.t_distance_entry.setVisible(True)
self.ui.t_distance_entry.setDisabled(True)
self.ui.t_distance_entry.set_value('%.*f' % (self.decimals, float(self.travel_distance)))
self.ui.units_label.setText(str(self.units).lower())
self.ui.units_label.setDisabled(True)
self.ui.t_time_label.show()
self.ui.t_time_entry.setVisible(True)
self.ui.t_time_entry.setDisabled(True)
# if time is more than 1 then we have minutes, else we have seconds
if self.routing_time > 1:
self.ui.t_time_entry.set_value('%.*f' % (self.decimals, math.ceil(float(self.routing_time))))
self.ui.units_time_label.setText('min')
else:
time_r = self.routing_time * 60
self.ui.t_time_entry.set_value('%.*f' % (self.decimals, math.ceil(float(time_r))))
self.ui.units_time_label.setText('sec')
self.ui.units_time_label.setDisabled(True)
except AttributeError:
pass
if self.multitool is False:
self.ui.tooldia_entry.show()
self.ui.updateplot_button.show()
else:
self.ui.tooldia_entry.hide()
self.ui.updateplot_button.hide()
# set the kind of geometries are plotted by default with plot2() from camlib.CNCJob
self.ui.cncplot_method_combo.set_value(self.app.defaults["cncjob_plot_kind"])
try:
self.ui.annotation_cb.stateChanged.disconnect(self.on_annotation_change)
except (TypeError, AttributeError):
pass
self.ui.annotation_cb.stateChanged.connect(self.on_annotation_change)
# set if to display text annotations
self.ui.annotation_cb.set_value(self.app.defaults["cncjob_annotation"])
self.ui.updateplot_button.clicked.connect(self.on_updateplot_button_click)
self.ui.export_gcode_button.clicked.connect(self.on_exportgcode_button_click)
self.ui.review_gcode_button.clicked.connect(self.on_review_code_click)
# Editor Signal
self.ui.editor_button.clicked.connect(lambda: self.app.object2editor())
# Properties
self.ui.properties_button.toggled.connect(self.on_properties)
self.calculations_finished.connect(self.update_area_chull)
# autolevelling signals
self.ui.sal_btn.toggled.connect(self.on_toggle_autolevelling)
self.ui.al_mode_radio.activated_custom.connect(self.on_mode_radio)
self.ui.al_method_radio.activated_custom.connect(self.on_method_radio)
self.ui.al_controller_combo.currentIndexChanged.connect(self.on_controller_change)
self.ui.plot_probing_pts_cb.stateChanged.connect(self.show_probing_geo)
# GRBL
self.ui.com_search_button.clicked.connect(self.on_grbl_search_ports)
self.ui.add_bd_button.clicked.connect(self.on_grbl_add_baudrate)
self.ui.del_bd_button.clicked.connect(self.on_grbl_delete_baudrate_grbl)
self.ui.controller_reset_button.clicked.connect(self.on_grbl_reset)
self.ui.com_connect_button.clicked.connect(self.on_grbl_connect)
self.ui.grbl_send_button.clicked.connect(self.on_grbl_send_command)
self.ui.grbl_command_entry.returnPressed.connect(self.on_grbl_send_command)
# Jog
self.ui.jog_wdg.jog_up_button.clicked.connect(lambda: self.on_grbl_jog(direction='yplus'))
self.ui.jog_wdg.jog_down_button.clicked.connect(lambda: self.on_grbl_jog(direction='yminus'))
self.ui.jog_wdg.jog_right_button.clicked.connect(lambda: self.on_grbl_jog(direction='xplus'))
self.ui.jog_wdg.jog_left_button.clicked.connect(lambda: self.on_grbl_jog(direction='xminus'))
self.ui.jog_wdg.jog_z_up_button.clicked.connect(lambda: self.on_grbl_jog(direction='zplus'))
self.ui.jog_wdg.jog_z_down_button.clicked.connect(lambda: self.on_grbl_jog(direction='zminus'))
self.ui.jog_wdg.jog_origin_button.clicked.connect(lambda: self.on_grbl_jog(direction='origin'))
# Zero
self.ui.zero_axs_wdg.grbl_zerox_button.clicked.connect(lambda: self.on_grbl_zero(axis='x'))
self.ui.zero_axs_wdg.grbl_zeroy_button.clicked.connect(lambda: self.on_grbl_zero(axis='y'))
self.ui.zero_axs_wdg.grbl_zeroz_button.clicked.connect(lambda: self.on_grbl_zero(axis='z'))
self.ui.zero_axs_wdg.grbl_zero_all_button.clicked.connect(lambda: self.on_grbl_zero(axis='all'))
self.ui.zero_axs_wdg.grbl_homing_button.clicked.connect(self.on_grbl_homing)
# Sender
self.ui.grbl_report_button.clicked.connect(lambda: self.send_grbl_command(command='?'))
self.ui.grbl_get_param_button.clicked.connect(
lambda: self.on_grbl_get_parameter(param=self.ui.grbl_parameter_entry.get_value()))
self.ui.view_h_gcode_button.clicked.connect(self.on_edit_probing_gcode)
self.ui.h_gcode_button.clicked.connect(self.on_save_probing_gcode)
self.ui.import_heights_button.clicked.connect(self.on_import_height_map)
self.ui.pause_resume_button.clicked.connect(self.on_grbl_pause_resume)
self.ui.grbl_get_heightmap_button.clicked.connect(self.on_grbl_autolevel)
self.ui.grbl_save_height_map_button.clicked.connect(self.on_grbl_heightmap_save)
self.build_al_table_sig.connect(self.build_al_table)
# self.ui.tc_variable_combo.currentIndexChanged[str].connect(self.on_cnc_custom_parameters)
self.ui.cncplot_method_combo.activated_custom.connect(self.on_plot_kind_change)
# Show/Hide Advanced Options
if self.app.defaults["global_app_level"] == 'b':
self.ui.level.setText('%s' % _("Basic"))
self.ui.sal_btn.hide()
self.ui.sal_btn.setChecked(False)
else:
self.ui.level.setText('%s' % _("Advanced"))
if 'Roland' in self.pp_excellon_name or 'Roland' in self.pp_geometry_name or 'hpgl' in \
self.pp_geometry_name:
self.ui.sal_btn.hide()
self.ui.sal_btn.setChecked(False)
else:
self.ui.sal_btn.show()
self.ui.sal_btn.setChecked(self.app.defaults["cncjob_al_status"])
preamble = self.prepend_snippet
postamble = self.append_snippet
gc = self.export_gcode(preamble=preamble, postamble=postamble, to_file=True)
self.source_file = gc.getvalue()
self.ui.al_mode_radio.set_value(self.options['al_mode'])
self.on_controller_change()
self.on_mode_radio(val=self.options['al_mode'])
self.on_method_radio(val=self.options['al_method'])
# def on_cnc_custom_parameters(self, signal_text):
# if signal_text == 'Parameters':
# return
# else:
# self.ui.toolchange_text.insertPlainText('%%%s%%' % signal_text)
def ui_connect(self):
for row in range(self.ui.cnc_tools_table.rowCount()):
self.ui.cnc_tools_table.cellWidget(row, 6).clicked.connect(self.on_plot_cb_click_table)
for row in range(self.ui.exc_cnc_tools_table.rowCount()):
self.ui.exc_cnc_tools_table.cellWidget(row, 6).clicked.connect(self.on_plot_cb_click_table)
self.ui.plot_cb.stateChanged.connect(self.on_plot_cb_click)
self.ui.al_add_button.clicked.connect(self.on_add_al_probepoints)
self.ui.show_al_table.stateChanged.connect(self.on_show_al_table)
def ui_disconnect(self):
for row in range(self.ui.cnc_tools_table.rowCount()):
try:
self.ui.cnc_tools_table.cellWidget(row, 6).clicked.disconnect(self.on_plot_cb_click_table)
except (TypeError, AttributeError):
pass
for row in range(self.ui.exc_cnc_tools_table.rowCount()):
try:
self.ui.exc_cnc_tools_table.cellWidget(row, 6).clicked.disconnect(self.on_plot_cb_click_table)
except (TypeError, AttributeError):
pass
try:
self.ui.plot_cb.stateChanged.disconnect(self.on_plot_cb_click)
except (TypeError, AttributeError):
pass
try:
self.ui.al_add_button.clicked.disconnect()
except (TypeError, AttributeError):
pass
try:
self.ui.show_al_table.stateChanged.disconnect()
except (TypeError, AttributeError):
pass
def on_properties(self, state):
if state:
self.ui.properties_frame.show()
else:
self.ui.properties_frame.hide()
return
self.ui.treeWidget.clear()
self.add_properties_items(obj=self, treeWidget=self.ui.treeWidget)
self.ui.treeWidget.setSizePolicy(QtWidgets.QSizePolicy.Ignored, QtWidgets.QSizePolicy.MinimumExpanding)
# make sure that the FCTree widget columns are resized to content
self.ui.treeWidget.resize_sig.emit()
def on_add_al_probepoints(self):
# create the solid_geo
self.solid_geo = unary_union([geo['geom'] for geo in self.gcode_parsed if geo['kind'][0] == 'C'])
# reset al table
self.ui.al_probe_points_table.setRowCount(0)
# reset the al dict
self.al_voronoi_geo_storage.clear()
xmin, ymin, xmax, ymax = self.solid_geo.bounds
if self.ui.al_mode_radio.get_value() == 'grid':
width = abs(xmax - xmin)
height = abs(ymax - ymin)
cols = self.ui.al_columns_entry.get_value()
rows = self.ui.al_rows_entry.get_value()
dx = 0 if cols == 1 else width / (cols - 1)
dy = 0 if rows == 1 else height / (rows - 1)
points = []
new_y = ymin
for x in range(rows):
new_x = xmin
for y in range(cols):
formatted_point = (
self.app.dec_format(new_x, self.app.decimals),
self.app.dec_format(new_y, self.app.decimals)
)
points.append(formatted_point)
new_x += dx
new_y += dy
pt_id = 0
vor_pts_list = []
bl_pts_list = []
for point in points:
pt_id += 1
pt = Point(point)
vor_pts_list.append(pt)
bl_pts_list.append((point[0], point[1], 0.0))
new_dict = {
'point': pt,
'geo': None,
'height': 0.0
}
self.al_voronoi_geo_storage[pt_id] = deepcopy(new_dict)
al_method = self.ui.al_method_radio.get_value()
if al_method == 'v':
if VORONOI_ENABLED is True:
self.generate_voronoi_geometry(pts=vor_pts_list)
# generate Probing GCode
self.probing_gcode_text = self.probing_gcode(storage=self.al_voronoi_geo_storage)
else:
self.app.inform.emit('[ERROR_NOTCL] %s' % _("Voronoi function can not be loaded.\n"
"Shapely >= 1.8 is required"))
else:
self.generate_bilinear_geometry(pts=bl_pts_list)
# generate Probing GCode
self.probing_gcode_text = self.probing_gcode(storage=self.al_bilinear_geo_storage)
self.build_al_table_sig.emit()
if self.ui.plot_probing_pts_cb.get_value():
self.show_probing_geo(state=True, reset=True)
else:
# clear probe shapes
self.plot_probing_geo(None, False)
else:
f_probe_pt = Point([xmin, xmin])
int_keys = [int(k) for k in self.al_voronoi_geo_storage.keys()]
new_id = max(int_keys) + 1 if int_keys else 1
new_dict = {
'point': f_probe_pt,
'geo': None,
'height': 0.0
}
self.al_voronoi_geo_storage[new_id] = deepcopy(new_dict)
radius = 0.3 if self.units == 'MM' else 0.012
fprobe_pt_buff = f_probe_pt.buffer(radius)
self.app.inform.emit(_("Click on canvas to add a Probe Point..."))
self.app.defaults['global_selection_shape'] = False
if self.app.is_legacy is False:
self.app.plotcanvas.graph_event_disconnect('key_press', self.app.ui.keyPressEvent)
self.app.plotcanvas.graph_event_disconnect('mouse_press', self.app.on_mouse_click_over_plot)
self.app.plotcanvas.graph_event_disconnect('mouse_release', self.app.on_mouse_click_release_over_plot)
else:
self.app.plotcanvas.graph_event_disconnect(self.app.kp)
self.app.plotcanvas.graph_event_disconnect(self.app.mp)
self.app.plotcanvas.graph_event_disconnect(self.app.mr)
self.kp = self.app.plotcanvas.graph_event_connect('key_press', self.on_key_press)
self.mr = self.app.plotcanvas.graph_event_connect('mouse_release', self.on_mouse_click_release)
self.mouse_events_connected = True
self.build_al_table_sig.emit()
if self.ui.plot_probing_pts_cb.get_value():
self.show_probing_geo(state=True, reset=True)
else:
# clear probe shapes
self.plot_probing_geo(None, False)
self.plot_probing_geo(geometry=fprobe_pt_buff, visibility=True, custom_color="#0000FFFA")
def show_probing_geo(self, state, reset=False):
if reset:
self.probing_shapes.clear(update=True)
points_geo = []
poly_geo = []
al_method = self.ui.al_method_radio.get_value()
# voronoi diagram
if al_method == 'v':
# create the geometry
radius = 0.1 if self.units == 'MM' else 0.004
for pt in self.al_voronoi_geo_storage:
if not self.al_voronoi_geo_storage[pt]['geo']:
continue
p_geo = self.al_voronoi_geo_storage[pt]['point'].buffer(radius)
s_geo = self.al_voronoi_geo_storage[pt]['geo'].buffer(0.0000001)
points_geo.append(p_geo)
poly_geo.append(s_geo)
if not points_geo and not poly_geo:
return
self.plot_probing_geo(geometry=points_geo, visibility=state, custom_color='#000000FF')
self.plot_probing_geo(geometry=poly_geo, visibility=state)
# bilinear interpolation
elif al_method == 'b':
radius = 0.1 if self.units == 'MM' else 0.004
for pt in self.al_bilinear_geo_storage:
x_pt = pt[0]
y_pt = pt[1]
p_geo = Point([x_pt, y_pt]).buffer(radius)
if p_geo.is_valid:
points_geo.append(p_geo)
if not points_geo:
return
self.plot_probing_geo(geometry=points_geo, visibility=state, custom_color='#000000FF')
def plot_probing_geo(self, geometry, visibility, custom_color=None):
if visibility:
if self.app.is_legacy is False:
def random_color():
r_color = np.random.rand(4)
r_color[3] = 0.5
return r_color
else:
def random_color():
while True:
r_color = np.random.rand(4)
r_color[3] = 0.5
new_color = '#'
for idx in range(len(r_color)):
new_color += '%x' % int(r_color[idx] * 255)
# do it until a valid color is generated
# a valid color has the # symbol, another 6 chars for the color and the last 2 chars for alpha
# for a total of 9 chars
if len(new_color) == 9:
break
return new_color
try:
# if self.app.is_legacy is False:
# color = "#0000FFFE"
# else:
# color = "#0000FFFE"
# for sh in points_geo:
# self.add_probing_shape(shape=sh, color=color, face_color=color, visible=True)
edge_color = "#000000FF"
try:
for sh in geometry:
if custom_color is None:
self.add_probing_shape(shape=sh, color=edge_color, face_color=random_color(), visible=True)
else:
self.add_probing_shape(shape=sh, color=custom_color, face_color=custom_color, visible=True)
except TypeError:
if custom_color is None:
self.add_probing_shape(
shape=geometry, color=edge_color, face_color=random_color(), visible=True)
else:
self.add_probing_shape(
shape=geometry, color=custom_color, face_color=custom_color, visible=True)
self.probing_shapes.redraw()
except (ObjectDeleted, AttributeError):
self.probing_shapes.clear(update=True)
except Exception as e:
log.debug("CNCJobObject.plot_probing_geo() --> %s" % str(e))
else:
self.probing_shapes.clear(update=True)
def add_probing_shape(self, **kwargs):
if self.deleted:
raise ObjectDeleted()
else:
key = self.probing_shapes.add(tolerance=self.drawing_tolerance, layer=0, **kwargs)
return key
def generate_voronoi_geometry(self, pts):
env = self.solid_geo.envelope
fact = 1 if self.units == 'MM' else 0.039
env = env.buffer(fact)
new_pts = deepcopy(pts)
try:
pts_union = MultiPoint(pts)
voronoi_union = voronoi_diagram(geom=pts_union, envelope=env)
except Exception as e:
log.debug("CNCJobObject.generate_voronoi_geometry() --> %s" % str(e))
for pt_index in range(len(pts)):
new_pts[pt_index] = affinity.translate(
new_pts[pt_index], random.random() * 1e-09, random.random() * 1e-09)
pts_union = MultiPoint(new_pts)
try:
voronoi_union = voronoi_diagram(geom=pts_union, envelope=env)
except Exception:
return
new_voronoi = []
for p in voronoi_union:
new_voronoi.append(p.intersection(env))
for pt_key in list(self.al_voronoi_geo_storage.keys()):
for poly in new_voronoi:
if self.al_voronoi_geo_storage[pt_key]['point'].within(poly):
self.al_voronoi_geo_storage[pt_key]['geo'] = poly
def generate_bilinear_geometry(self, pts):
self.al_bilinear_geo_storage = pts
# To be called after clicking on the plot.
def on_mouse_click_release(self, event):
if self.app.is_legacy is False:
event_pos = event.pos
# event_is_dragging = event.is_dragging
right_button = 2
else:
event_pos = (event.xdata, event.ydata)
# event_is_dragging = self.app.plotcanvas.is_dragging
right_button = 3
try:
x = float(event_pos[0])
y = float(event_pos[1])
except TypeError:
return
event_pos = (x, y)
# do paint single only for left mouse clicks
if event.button == 1:
pos = self.app.plotcanvas.translate_coords(event_pos)
# use the snapped position as reference
snapped_pos = self.app.geo_editor.snap(pos[0], pos[1])
probe_pt = Point(snapped_pos)
xxmin, yymin, xxmax, yymax = self.solid_geo.bounds
box_geo = box(xxmin, yymin, xxmax, yymax)
if not probe_pt.within(box_geo):
self.app.inform.emit(_("Point is not within the object area. Choose another point."))
return
int_keys = [int(k) for k in self.al_voronoi_geo_storage.keys()]
new_id = max(int_keys) + 1 if int_keys else 1
new_dict = {
'point': probe_pt,
'geo': None,
'height': 0.0
}
self.al_voronoi_geo_storage[new_id] = deepcopy(new_dict)
# rebuild the al table
self.build_al_table_sig.emit()
radius = 0.3 if self.units == 'MM' else 0.012
probe_pt_buff = probe_pt.buffer(radius)
self.plot_probing_geo(geometry=probe_pt_buff, visibility=True, custom_color="#0000FFFA")
self.app.inform.emit(_("Added a Probe Point... Click again to add another or right click to finish ..."))
# if RMB then we exit
elif event.button == right_button and self.mouse_is_dragging is False:
if self.app.is_legacy is False:
self.app.plotcanvas.graph_event_disconnect('key_press', self.on_key_press)
self.app.plotcanvas.graph_event_disconnect('mouse_release', self.on_mouse_click_release)
else:
self.app.plotcanvas.graph_event_disconnect(self.kp)
self.app.plotcanvas.graph_event_disconnect(self.mr)
self.app.kp = self.app.plotcanvas.graph_event_connect('key_press', self.app.ui.keyPressEvent)
self.app.mp = self.app.plotcanvas.graph_event_connect('mouse_press', self.app.on_mouse_click_over_plot)
self.app.mr = self.app.plotcanvas.graph_event_connect('mouse_release',
self.app.on_mouse_click_release_over_plot)
# signal that the mouse events are disconnected from local methods
self.mouse_events_connected = False
# restore selection
self.app.defaults['global_selection_shape'] = self.old_selection_state
self.app.inform.emit(_("Finished adding Probe Points..."))
al_method = self.ui.al_method_radio.get_value()
if al_method == 'v':
if VORONOI_ENABLED is True:
pts_list = []
for k in self.al_voronoi_geo_storage:
pts_list.append(self.al_voronoi_geo_storage[k]['point'])
self.generate_voronoi_geometry(pts=pts_list)
self.probing_gcode_text = self.probing_gcode(self.al_voronoi_geo_storage)
else:
self.app.inform.emit('[ERROR_NOTCL] %s' % _("Voronoi function can not be loaded.\n"
"Shapely >= 1.8 is required"))
# rebuild the al table
self.build_al_table_sig.emit()
if self.ui.plot_probing_pts_cb.get_value():
self.show_probing_geo(state=True, reset=True)
else:
# clear probe shapes
self.plot_probing_geo(None, False)
def on_key_press(self, event):
# events out of the self.app.collection view (it's about Project Tab) are of type int
if type(event) is int:
key = event
# events from the GUI are of type QKeyEvent
elif type(event) == QtGui.QKeyEvent:
key = event.key()
elif isinstance(event, mpl_key_event): # MatPlotLib key events are trickier to interpret than the rest
key = event.key
key = QtGui.QKeySequence(key)
# check for modifiers
key_string = key.toString().lower()
if '+' in key_string:
mod, __, key_text = key_string.rpartition('+')
if mod.lower() == 'ctrl':
# modifiers = QtCore.Qt.ControlModifier
pass
elif mod.lower() == 'alt':
# modifiers = QtCore.Qt.AltModifier
pass
elif mod.lower() == 'shift':
# modifiers = QtCore.Qt.ShiftModifier
pass
else:
# modifiers = QtCore.Qt.NoModifier
pass
key = QtGui.QKeySequence(key_text)
# events from Vispy are of type KeyEvent
else:
key = event.key
# Escape = Deselect All
if key == QtCore.Qt.Key_Escape or key == 'Escape':
if self.mouse_events_connected is True:
self.mouse_events_connected = False
if self.app.is_legacy is False:
self.app.plotcanvas.graph_event_disconnect('key_press', self.on_key_press)
self.app.plotcanvas.graph_event_disconnect('mouse_release', self.on_mouse_click_release)
else:
self.app.plotcanvas.graph_event_disconnect(self.kp)
self.app.plotcanvas.graph_event_disconnect(self.mr)
self.app.kp = self.app.plotcanvas.graph_event_connect('key_press', self.app.ui.keyPressEvent)
self.app.mp = self.app.plotcanvas.graph_event_connect('mouse_press', self.app.on_mouse_click_over_plot)
self.app.mr = self.app.plotcanvas.graph_event_connect('mouse_release',
self.app.on_mouse_click_release_over_plot)
if self.ui.big_cursor_cb.get_value():
# restore cursor
self.app.on_cursor_type(val=self.old_cursor_type)
# restore selection
self.app.defaults['global_selection_shape'] = self.old_selection_state
# Grid toggle
if key == QtCore.Qt.Key_G or key == 'G':
self.app.ui.grid_snap_btn.trigger()
# Jump to coords
if key == QtCore.Qt.Key_J or key == 'J':
self.app.on_jump_to()
def on_toggle_autolevelling(self, state):
self.ui.al_frame.show() if state else self.ui.al_frame.hide()
self.app.defaults["cncjob_al_status"] = True if state else False
def autolevell_gcode(self):
pass
def autolevell_gcode_line(self, gcode_line):
al_method = self.ui.al_method_radio.get_value()
coords = ()
if al_method == 'v':
self.autolevell_voronoi(gcode_line, coords)
elif al_method == 'b':
self.autolevell_bilinear(gcode_line, coords)
def autolevell_bilinear(self, gcode_line, coords):
pass
def autolevell_voronoi(self, gcode_line, coords):
pass
def on_show_al_table(self, state):
self.ui.al_probe_points_table.show() if state else self.ui.al_probe_points_table.hide()
def on_mode_radio(self, val):
# reset al table
self.ui.al_probe_points_table.setRowCount(0)
# reset the al dict
self.al_voronoi_geo_storage.clear()
# reset Voronoi Shapes
self.probing_shapes.clear(update=True)
# build AL table
self.build_al_table()
if val == "manual":
self.ui.al_rows_entry.setDisabled(True)
self.ui.al_rows_label.setDisabled(True)
self.ui.al_columns_entry.setDisabled(True)
self.ui.al_columns_label.setDisabled(True)
self.ui.al_method_lbl.setDisabled(True)
self.ui.al_method_radio.setDisabled(True)
self.ui.al_method_radio.set_value('v')
else:
self.ui.al_rows_entry.setDisabled(False)
self.ui.al_rows_label.setDisabled(False)
self.ui.al_columns_entry.setDisabled(False)
self.ui.al_columns_label.setDisabled(False)
self.ui.al_method_lbl.setDisabled(False)
self.ui.al_method_radio.setDisabled(False)
self.ui.al_method_radio.set_value(self.app.defaults['cncjob_al_method'])
def on_method_radio(self, val):
if val == 'b':
self.ui.al_columns_entry.setMinimum(2)
self.ui.al_rows_entry.setMinimum(2)
else:
self.ui.al_columns_entry.setMinimum(1)
self.ui.al_rows_entry.setMinimum(1)
def on_controller_change(self):
if self.ui.al_controller_combo.get_value() == 'GRBL':
self.ui.h_gcode_button.hide()
self.ui.view_h_gcode_button.hide()
self.ui.import_heights_button.hide()
self.ui.grbl_frame.show()
self.on_grbl_search_ports(muted=True)
else:
self.ui.h_gcode_button.show()
self.ui.view_h_gcode_button.show()
self.ui.import_heights_button.show()
self.ui.grbl_frame.hide()
# if the is empty then there is a chance that we've added probe points but the GRBL controller was selected
# therefore no Probing GCode was genrated (it is different for GRBL on how it gets it's Probing GCode
if not self.probing_gcode_text or self.probing_gcode_text == '':
# generate Probing GCode
al_method = self.ui.al_method_radio.get_value()
storage = self.al_voronoi_geo_storage if al_method == 'v' else self.al_bilinear_geo_storage
self.probing_gcode_text = self.probing_gcode(storage=storage)
@staticmethod
def on_grbl_list_serial_ports():
"""
Lists serial port names.
From here: https://stackoverflow.com/questions/12090503/listing-available-com-ports-with-python
:raises EnvironmentError: On unsupported or unknown platforms
:returns: A list of the serial ports available on the system
"""
if sys.platform.startswith('win'):
ports = ['COM%s' % (i + 1) for i in range(256)]
elif sys.platform.startswith('linux') or sys.platform.startswith('cygwin'):
# this excludes your current terminal "/dev/tty"
ports = glob.glob('/dev/tty[A-Za-z]*')
elif sys.platform.startswith('darwin'):
ports = glob.glob('/dev/tty.*')
else:
raise EnvironmentError('Unsupported platform')
result = []
s = serial.Serial()
for port in ports:
s.port = port
try:
s.open()
s.close()
result.append(port)
except (OSError, serial.SerialException):
# result.append(port + " (in use)")
pass
return result
def on_grbl_search_ports(self, muted=None):
port_list = self.on_grbl_list_serial_ports()
self.ui.com_list_combo.clear()
self.ui.com_list_combo.addItems(port_list)
if muted is not True:
self.app.inform.emit('[WARNING_NOTCL] %s' % _("COM list updated ..."))
def on_grbl_connect(self):
port_name = self.ui.com_list_combo.currentText()
if " (" in port_name:
port_name = port_name.rpartition(" (")[0]
baudrate = int(self.ui.baudrates_list_combo.currentText())
try:
self.grbl_ser_port = serial.serial_for_url(port_name, baudrate,
bytesize=serial.EIGHTBITS,
parity=serial.PARITY_NONE,
stopbits=serial.STOPBITS_ONE,
timeout=0.1,
xonxoff=False,
rtscts=False)
# Toggle DTR to reset the controller loaded with GRBL (Arduino, ESP32, etc)
try:
self.grbl_ser_port.dtr = False
except IOError:
pass
self.grbl_ser_port.reset_input_buffer()
try:
self.grbl_ser_port.dtr = True
except IOError:
pass
answer = self.on_grbl_wake()
answer = ['ok'] # FIXME: hack for development without a GRBL controller connected
for line in answer:
if 'ok' in line.lower():
self.ui.com_connect_button.setStyleSheet("QPushButton {background-color: seagreen;}")
self.ui.com_connect_button.setText(_("Connected"))
self.ui.controller_reset_button.setDisabled(False)
for idx in range(self.ui.al_toolbar.count()):
if self.ui.al_toolbar.tabText(idx) == _("Connect"):
self.ui.al_toolbar.tabBar.setTabTextColor(idx, QtGui.QColor('seagreen'))
if self.ui.al_toolbar.tabText(idx) == _("Control"):
self.ui.al_toolbar.tabBar.setTabEnabled(idx, True)
if self.ui.al_toolbar.tabText(idx) == _("Sender"):
self.ui.al_toolbar.tabBar.setTabEnabled(idx, True)
self.app.inform.emit("%s: %s" % (_("Port connected"), port_name))
return
self.grbl_ser_port.close()
self.app.inform.emit("[ERROR_NOTCL] %s: %s" % (_("Could not connect to GRBL on port"), port_name))
except serial.SerialException:
self.grbl_ser_port = serial.Serial()
self.grbl_ser_port.port = port_name
self.grbl_ser_port.close()
self.ui.com_connect_button.setStyleSheet("QPushButton {background-color: red;}")
self.ui.com_connect_button.setText(_("Disconnected"))
self.ui.controller_reset_button.setDisabled(True)
for idx in range(self.ui.al_toolbar.count()):
if self.ui.al_toolbar.tabText(idx) == _("Connect"):
self.ui.al_toolbar.tabBar.setTabTextColor(idx, QtGui.QColor('red'))
if self.ui.al_toolbar.tabText(idx) == _("Control"):
self.ui.al_toolbar.tabBar.setTabEnabled(idx, False)
if self.ui.al_toolbar.tabText(idx) == _("Sender"):
self.ui.al_toolbar.tabBar.setTabEnabled(idx, False)
self.app.inform.emit("%s: %s" % (_("Port is connected. Disconnecting"), port_name))
except Exception:
self.app.inform.emit("[ERROR_NOTCL] %s: %s" % (_("Could not connect to port"), port_name))
def on_grbl_add_baudrate(self):
new_bd = str(self.ui.new_baudrate_entry.get_value())
if int(new_bd) >= 40 and new_bd not in self.ui.baudrates_list_combo.model().stringList():
self.ui.baudrates_list_combo.addItem(new_bd)
self.ui.baudrates_list_combo.setCurrentText(new_bd)
def on_grbl_delete_baudrate_grbl(self):
current_idx = self.ui.baudrates_list_combo.currentIndex()
self.ui.baudrates_list_combo.removeItem(current_idx)
def on_grbl_wake(self):
# Wake up grbl
self.grbl_ser_port.write("\r\n\r\n".encode('utf-8'))
# Wait for GRBL controller to initialize
time.sleep(1)
grbl_out = deepcopy(self.grbl_ser_port.readlines())
self.grbl_ser_port.reset_input_buffer()
return grbl_out
def on_grbl_send_command(self):
cmd = self.ui.grbl_command_entry.get_value()
# show the Shell Dock
self.app.ui.shell_dock.show()
def worker_task():
with self.app.proc_container.new(_("Sending GCode...")):
self.send_grbl_command(command=cmd)
self.app.worker_task.emit({'fcn': worker_task, 'params': []})
def send_grbl_command(self, command, echo=True):
"""
:param command: GCode command
:type command: str
:param echo: if to send a '\n' char after
:type echo: bool
:return: the text returned by the GRBL controller after each command
:rtype: str
"""
cmd = command.strip()
if echo:
self.app.inform_shell[str, bool].emit(cmd, False)
# Send Gcode command to GRBL
snd = cmd + '\n'
self.grbl_ser_port.write(snd.encode('utf-8'))
grbl_out = self.grbl_ser_port.readlines()
if not grbl_out:
self.app.inform_shell[str, bool].emit('\t\t\t: No answer\n', False)
result = ''
for line in grbl_out:
if echo:
try:
self.app.inform_shell.emit('\t\t\t: ' + line.decode('utf-8').strip().upper())
except Exception as e:
log.debug("CNCJobObject.send_grbl_command() --> %s" % str(e))
if 'ok' in line:
result = grbl_out
return result
def send_grbl_block(self, command, echo=True):
stripped_cmd = command.strip()
for grbl_line in stripped_cmd.split('\n'):
if echo:
self.app.inform_shell[str, bool].emit(grbl_line, False)
# Send Gcode block to GRBL
snd = grbl_line + '\n'
self.grbl_ser_port.write(snd.encode('utf-8'))
grbl_out = self.grbl_ser_port.readlines()
for line in grbl_out:
if echo:
try:
self.app.inform_shell.emit(' : ' + line.decode('utf-8').strip().upper())
except Exception as e:
log.debug("CNCJobObject.send_grbl_block() --> %s" % str(e))
def on_grbl_get_parameter(self, param):
if '$' in param:
param = param.replace('$', '')
snd = '$$\n'
self.grbl_ser_port.write(snd.encode('utf-8'))
grbl_out = self.grbl_ser_port.readlines()
for line in grbl_out:
decoded_line = line.decode('utf-8')
par = '$%s' % str(param)
if par in decoded_line:
result = float(decoded_line.rpartition('=')[2])
self.app.shell_message("GRBL Parameter: %s = %s" % (str(param), str(result)), show=True)
return result
def on_grbl_jog(self, direction=None):
if direction is None:
return
cmd = ''
step = self.ui.jog_step_entry.get_value(),
feedrate = self.ui.jog_fr_entry.get_value()
travelz = float(self.app.defaults["cncjob_al_grbl_travelz"])
if direction == 'xplus':
cmd = "$J=G91 %s X%s F%s" % ({'IN': 'G20', 'MM': 'G21'}[self.units], str(step), str(feedrate))
if direction == 'xminus':
cmd = "$J=G91 %s X-%s F%s" % ({'IN': 'G20', 'MM': 'G21'}[self.units], str(step), str(feedrate))
if direction == 'yplus':
cmd = "$J=G91 %s Y%s F%s" % ({'IN': 'G20', 'MM': 'G21'}[self.units], str(step), str(feedrate))
if direction == 'yminus':
cmd = "$J=G91 %s Y-%s F%s" % ({'IN': 'G20', 'MM': 'G21'}[self.units], str(step), str(feedrate))
if direction == 'zplus':
cmd = "$J=G91 %s Z%s F%s" % ({'IN': 'G20', 'MM': 'G21'}[self.units], str(step), str(feedrate))
if direction == 'zminus':
cmd = "$J=G91 %s Z-%s F%s" % ({'IN': 'G20', 'MM': 'G21'}[self.units], str(step), str(feedrate))
if direction == 'origin':
cmd = "$J=G90 %s Z%s F%s" % ({'IN': 'G20', 'MM': 'G21'}[self.units], str(travelz), str(feedrate))
self.send_grbl_command(command=cmd, echo=False)
cmd = "$J=G90 %s X0.0 Y0.0 F%s" % ({'IN': 'G20', 'MM': 'G21'}[self.units], str(feedrate))
self.send_grbl_command(command=cmd, echo=False)
return
self.send_grbl_command(command=cmd, echo=False)
def on_grbl_zero(self, axis):
current_mode = self.on_grbl_get_parameter('10')
if current_mode is None:
return
cmd = '$10=0'
self.send_grbl_command(command=cmd, echo=False)
if axis == 'x':
cmd = 'G10 L2 P1 X0'
elif axis == 'y':
cmd = 'G10 L2 P1 Y0'
elif axis == 'z':
cmd = 'G10 L2 P1 Z0'
else:
# all
cmd = 'G10 L2 P1 X0 Y0 Z0'
self.send_grbl_command(command=cmd, echo=False)
# restore previous mode
cmd = '$10=%d' % int(current_mode)
self.send_grbl_command(command=cmd, echo=False)
def on_grbl_homing(self):
cmd = '$H'
self.app.inform.emit("%s" % _("GRBL is doing a home cycle."))
self.on_grbl_wake()
self.send_grbl_command(command=cmd)
def on_grbl_reset(self):
cmd = '\x18'
self.app.inform.emit("%s" % _("GRBL software reset was sent."))
self.on_grbl_wake()
self.send_grbl_command(command=cmd)
def on_grbl_pause_resume(self, checked):
if checked is False:
cmd = '~'
self.send_grbl_command(command=cmd)
self.app.inform.emit("%s" % _("GRBL resumed."))
else:
cmd = '!'
self.send_grbl_command(command=cmd)
self.app.inform.emit("%s" % _("GRBL paused."))
def probing_gcode(self, storage):
"""
:param storage: either a dict of dicts (voronoi) or a list of tuples (bilinear)
:return: Probing GCode
:rtype: str
"""
p_gcode = ''
header = ''
time_str = "{:%A, %d %B %Y at %H:%M}".format(datetime.now())
coords = []
al_method = self.ui.al_method_radio.get_value()
if al_method == 'v':
for id_key, value in storage.items():
x = value['point'].x
y = value['point'].y
coords.append(
(
self.app.dec_format(x, dec=self.app.decimals),
self.app.dec_format(y, dec=self.app.decimals)
)
)
else:
for pt in storage:
x = pt[0]
y = pt[1]
coords.append(
(
self.app.dec_format(x, dec=self.app.decimals),
self.app.dec_format(y, dec=self.app.decimals)
)
)
pr_travel = self.ui.ptravelz_entry.get_value()
probe_fr = self.ui.feedrate_probe_entry.get_value()
pr_depth = self.ui.pdepth_entry.get_value()
controller = self.ui.al_controller_combo.get_value()
header += '(G-CODE GENERATED BY FLATCAM v%s - www.flatcam.org - Version Date: %s)\n' % \
(str(self.app.version), str(self.app.version_date)) + '\n'
header += '(This is a autolevelling probing GCode.)\n' \
'(Make sure that before you start the job you first do a zero for all axis.)\n\n'
header += '(Name: ' + str(self.options['name']) + ')\n'
header += '(Type: ' + "Autolevelling Probing GCode " + ')\n'
header += '(Units: ' + self.units.upper() + ')\n'
header += '(Created on ' + time_str + ')\n'
# commands
if controller == 'MACH3':
probing_command = 'G31'
# probing_var = '#2002'
openfile_command = 'M40'
closefile_command = 'M41'
elif controller == 'MACH4':
probing_command = 'G31'
# probing_var = '#5063'
openfile_command = 'M40'
closefile_command = 'M41'
elif controller == 'LinuxCNC':
probing_command = 'G38.2'
# probing_var = '#5422'
openfile_command = '(PROBEOPEN a_probing_points_file.txt)'
closefile_command = '(PROBECLOSE)'
elif controller == 'GRBL':
# do nothing here because the Probing GCode for GRBL is obtained differently
return
else:
log.debug("CNCJobObject.probing_gcode() -> controller not supported")
return
# #############################################################################################################
# ########################### GCODE construction ##############################################################
# #############################################################################################################
# header
p_gcode += header + '\n'
# supplementary message for LinuxCNC
if controller == 'LinuxCNC':
p_gcode += "The file with the stored probing points can be found\n" \
"in the configuration folder for LinuxCNC.\n" \
"The name of the file is: a_probing_points_file.txt.\n"
# units
p_gcode += 'G21\n' if self.units == 'MM' else 'G20\n'
# reference mode = absolute
p_gcode += 'G90\n'
# open a new file
p_gcode += openfile_command + '\n'
# move to safe height (probe travel Z)
p_gcode += 'G0 Z%s\n' % str(self.app.dec_format(pr_travel, self.coords_decimals))
# probing points
for idx, xy_tuple in enumerate(coords, 1): # index starts from 1
x = xy_tuple[0]
y = xy_tuple[1]
# move to probing point
p_gcode += "G0 X%sY%s\n" % (
str(self.app.dec_format(x, self.coords_decimals)),
str(self.app.dec_format(y, self.coords_decimals))
)
# do the probing
p_gcode += "%s Z%s F%s\n" % (
probing_command,
str(self.app.dec_format(pr_depth, self.coords_decimals)),
str(self.app.dec_format(probe_fr, self.fr_decimals)),
)
# store in a global numeric variable the value of the detected probe Z
# I offset the global numeric variable by 500 so it does not conflict with something else
# temp_var = int(idx + 500)
# p_gcode += "#%d = %s\n" % (temp_var, probing_var)
# move to safe height (probe travel Z)
p_gcode += 'G0 Z%s\n' % str(self.app.dec_format(pr_travel, self.coords_decimals))
# close the file
p_gcode += closefile_command + '\n'
# finish the GCode
p_gcode += 'M2'
return p_gcode
def on_save_probing_gcode(self):
lines = StringIO(self.probing_gcode_text)
_filter_ = self.app.defaults['cncjob_save_filters']
name = "probing_gcode"
try:
dir_file_to_save = self.app.get_last_save_folder() + '/' + str(name)
filename, _f = FCFileSaveDialog.get_saved_filename(
caption=_("Export Code ..."),
directory=dir_file_to_save,
ext_filter=_filter_
)
except TypeError:
filename, _f = FCFileSaveDialog.get_saved_filename(
caption=_("Export Code ..."),
ext_filter=_filter_)
if filename == '':
self.app.inform.emit('[WARNING_NOTCL] %s' % _("Export cancelled ..."))
return
else:
try:
force_windows_line_endings = self.app.defaults['cncjob_line_ending']
if force_windows_line_endings and sys.platform != 'win32':
with open(filename, 'w', newline='\r\n') as f:
for line in lines:
f.write(line)
else:
with open(filename, 'w') as f:
for line in lines:
f.write(line)
except FileNotFoundError:
self.app.inform.emit('[WARNING_NOTCL] %s' % _("No such file or directory"))
return
except PermissionError:
self.app.inform.emit(
'[WARNING] %s' % _("Permission denied, saving not possible.\n"
"Most likely another app is holding the file open and not accessible.")
)
return 'fail'
def on_edit_probing_gcode(self):
self.app.proc_container.view.set_busy(_("Loading..."))
gco = self.probing_gcode_text
if gco is None or gco == '':
self.app.inform.emit('[WARNING_NOTCL] %s...' % _('There is nothing to view'))
return
self.gcode_viewer_tab = AppTextEditor(app=self.app, plain_text=True)
# add the tab if it was closed
self.app.ui.plot_tab_area.addTab(self.gcode_viewer_tab, '%s' % _("Code Viewer"))
self.gcode_viewer_tab.setObjectName('code_viewer_tab')
# delete the absolute and relative position and messages in the infobar
self.app.ui.position_label.setText("")
self.app.ui.rel_position_label.setText("")
self.gcode_viewer_tab.code_editor.completer_enable = False
self.gcode_viewer_tab.buttonRun.hide()
# Switch plot_area to CNCJob tab
self.app.ui.plot_tab_area.setCurrentWidget(self.gcode_viewer_tab)
self.gcode_viewer_tab.t_frame.hide()
# then append the text from GCode to the text editor
try:
self.gcode_viewer_tab.load_text(gco, move_to_start=True, clear_text=True)
except Exception as e:
log.debug('FlatCAMCNCJob.on_edit_probing_gcode() -->%s' % str(e))
return
self.gcode_viewer_tab.t_frame.show()
self.app.proc_container.view.set_idle()
self.gcode_viewer_tab.buttonSave.hide()
self.gcode_viewer_tab.buttonOpen.hide()
self.gcode_viewer_tab.buttonPrint.hide()
self.gcode_viewer_tab.buttonPreview.hide()
self.gcode_viewer_tab.buttonReplace.hide()
self.gcode_viewer_tab.sel_all_cb.hide()
self.gcode_viewer_tab.entryReplace.hide()
self.gcode_viewer_tab.button_update_code.show()
# self.gcode_viewer_tab.code_editor.setReadOnly(True)
self.gcode_viewer_tab.button_update_code.clicked.connect(self.on_update_probing_gcode)
self.app.inform.emit('[success] %s...' % _('Loaded Machine Code into Code Viewer'))
def on_update_probing_gcode(self):
self.probing_gcode_text = self.gcode_viewer_tab.code_editor.toPlainText()
def on_import_height_map(self):
"""
Import the height map file into the app
:return:
:rtype:
"""
_filter_ = "Text File .txt (*.txt);;All Files (*.*)"
try:
filename, _f = QtWidgets.QFileDialog.getOpenFileName(caption=_("Import Height Map"),
directory=self.app.get_last_folder(),
filter=_filter_)
except TypeError:
filename, _f = QtWidgets.QFileDialog.getOpenFileName(caption=_("Import Height Map"),
filter=_filter_)
filename = str(filename)
if filename == '':
self.app.inform.emit('[WARNING_NOTCL] %s' % _("Cancelled."))
else:
self.app.worker_task.emit({'fcn': self.import_height_map, 'params': [filename]})
def import_height_map(self, filename):
"""
:param filename:
:type filename:
:return:
:rtype:
"""
try:
if filename:
with open(filename, 'r') as f:
stream = f.readlines()
else:
return
except IOError:
log.error("Failed to open height map file: %s" % filename)
self.inform.emit('[ERROR_NOTCL] %s: %s' % (_("Failed to open height map file"), filename))
return
idx = 0
if stream is not None and stream != '':
for line in stream:
if line != '':
idx += 1
line = line.replace(' ', ',').replace('\n', '').split(',')
if idx not in self.al_voronoi_geo_storage:
self.al_voronoi_geo_storage[idx] = {}
self.al_voronoi_geo_storage[idx]['height'] = float(line[2])
if 'point' not in self.al_voronoi_geo_storage[idx]:
x = float(line[0])
y = float(line[1])
self.al_voronoi_geo_storage[idx]['point'] = Point((x, y))
self.build_al_table_sig.emit()
def on_grbl_autolevel(self):
# show the Shell Dock
self.app.ui.shell_dock.show()
def worker_task():
with self.app.proc_container.new(_("Sending GCode...")):
self.grbl_probe_result = ''
pr_travelz = str(self.ui.ptravelz_entry.get_value())
probe_fr = str(self.ui.feedrate_probe_entry.get_value())
pr_depth = str(self.ui.pdepth_entry.get_value())
cmd = 'G21\n'
self.send_grbl_command(command=cmd)
cmd = 'G90\n'
self.send_grbl_command(command=cmd)
for pt_key in self.al_voronoi_geo_storage:
x = str(self.al_voronoi_geo_storage[pt_key]['point'].x)
y = str(self.al_voronoi_geo_storage[pt_key]['point'].y)
cmd = 'G0 Z%s\n' % pr_travelz
self.send_grbl_command(command=cmd)
cmd = 'G0 X%s Y%s\n' % (x, y)
self.send_grbl_command(command=cmd)
cmd = 'G38.2 Z%s F%s' % (pr_depth, probe_fr)
output = self.send_grbl_command(command=cmd)
self.grbl_probe_result += output + '\n'
cmd = 'M2\n'
self.send_grbl_command(command=cmd)
self.app.inform.emit('%s' % _("Finished probing. Doing the autolevelling."))
# apply autolevel here
self.on_grbl_apply_autolevel()
self.app.inform.emit('%s' % _("Sending probing GCode to the GRBL controller."))
self.app.worker_task.emit({'fcn': worker_task, 'params': []})
def on_grbl_heightmap_save(self):
if self.grbl_probe_result != '':
_filter_ = "Text File .txt (*.txt);;All Files (*.*)"
name = "probing_gcode"
try:
dir_file_to_save = self.app.get_last_save_folder() + '/' + str(name)
filename, _f = FCFileSaveDialog.get_saved_filename(
caption=_("Export Code ..."),
directory=dir_file_to_save,
ext_filter=_filter_
)
except TypeError:
filename, _f = FCFileSaveDialog.get_saved_filename(
caption=_("Export Code ..."),
ext_filter=_filter_)
if filename == '':
self.app.inform.emit('[WARNING_NOTCL] %s' % _("Export cancelled ..."))
return
else:
try:
force_windows_line_endings = self.app.defaults['cncjob_line_ending']
if force_windows_line_endings and sys.platform != 'win32':
with open(filename, 'w', newline='\r\n') as f:
for line in self.grbl_probe_result:
f.write(line)
else:
with open(filename, 'w') as f:
for line in self.grbl_probe_result:
f.write(line)
except FileNotFoundError:
self.app.inform.emit('[WARNING_NOTCL] %s' % _("No such file or directory"))
return
except PermissionError:
self.app.inform.emit(
'[WARNING] %s' % _("Permission denied, saving not possible.\n"
"Most likely another app is holding the file open and not accessible.")
)
return 'fail'
else:
self.app.inform.emit('[ERROR_NOTCL] %s' % _("Empty GRBL heightmap."))
def on_grbl_apply_autolevel(self):
# TODO here we call the autolevell method
self.app.inform.emit('%s' % _("Finished autolevelling."))
def on_updateplot_button_click(self, *args):
"""
Callback for the "Updata Plot" button. Reads the form for updates
and plots the object.
"""
self.read_form()
self.on_plot_kind_change()
def on_plot_kind_change(self):
kind = self.ui.cncplot_method_combo.get_value()
def worker_task():
with self.app.proc_container.new('%s ...' % _("Plotting")):
self.plot(kind=kind)
self.app.worker_task.emit({'fcn': worker_task, 'params': []})
def on_exportgcode_button_click(self):
"""
Handler activated by a button clicked when exporting GCode.
:param args:
:return:
"""
self.app.defaults.report_usage("cncjob_on_exportgcode_button")
self.read_form()
name = self.app.collection.get_active().options['name']
save_gcode = False
if 'Roland' in self.pp_excellon_name or 'Roland' in self.pp_geometry_name:
_filter_ = "RML1 Files .rol (*.rol);;All Files (*.*)"
elif 'hpgl' in self.pp_geometry_name:
_filter_ = "HPGL Files .plt (*.plt);;All Files (*.*)"
else:
save_gcode = True
_filter_ = self.app.defaults['cncjob_save_filters']
try:
dir_file_to_save = self.app.get_last_save_folder() + '/' + str(name)
filename, _f = FCFileSaveDialog.get_saved_filename(
caption=_("Export Code ..."),
directory=dir_file_to_save,
ext_filter=_filter_
)
except TypeError:
filename, _f = FCFileSaveDialog.get_saved_filename(
caption=_("Export Code ..."),
ext_filter=_filter_)
self.export_gcode_handler(filename, is_gcode=save_gcode)
def export_gcode_handler(self, filename, is_gcode=True):
preamble = ''
postamble = ''
filename = str(filename)
if filename == '':
self.app.inform.emit('[WARNING_NOTCL] %s' % _("Export cancelled ..."))
return
else:
if is_gcode is True:
used_extension = filename.rpartition('.')[2]
self.update_filters(last_ext=used_extension, filter_string='cncjob_save_filters')
new_name = os.path.split(str(filename))[1].rpartition('.')[0]
self.ui.name_entry.set_value(new_name)
self.on_name_activate(silent=True)
try:
if self.ui.snippets_cb.get_value():
preamble = self.prepend_snippet
postamble = self.append_snippet
gc = self.export_gcode(filename, preamble=preamble, postamble=postamble)
except Exception as err:
log.debug("CNCJobObject.export_gcode_handler() --> %s" % str(err))
gc = self.export_gcode(filename)
if gc == 'fail':
return
if self.app.defaults["global_open_style"] is False:
self.app.file_opened.emit("gcode", filename)
self.app.file_saved.emit("gcode", filename)
self.app.inform.emit('[success] %s: %s' % (_("File saved to"), filename))
def on_review_code_click(self):
"""
Handler activated by a button clicked when reviewing GCode.
:return:
"""
self.app.proc_container.view.set_busy(_("Loading..."))
preamble = self.prepend_snippet
postamble = self.append_snippet
gco = self.export_gcode(preamble=preamble, postamble=postamble, to_file=True)
if gco == 'fail':
return
else:
self.app.gcode_edited = gco
self.gcode_editor_tab = AppTextEditor(app=self.app, plain_text=True)
# add the tab if it was closed
self.app.ui.plot_tab_area.addTab(self.gcode_editor_tab, '%s' % _("Code Review"))
self.gcode_editor_tab.setObjectName('code_editor_tab')
# delete the absolute and relative position and messages in the infobar
self.app.ui.position_label.setText("")
self.app.ui.rel_position_label.setText("")
self.gcode_editor_tab.code_editor.completer_enable = False
self.gcode_editor_tab.buttonRun.hide()
# Switch plot_area to CNCJob tab
self.app.ui.plot_tab_area.setCurrentWidget(self.gcode_editor_tab)
self.gcode_editor_tab.t_frame.hide()
# then append the text from GCode to the text editor
try:
self.gcode_editor_tab.load_text(self.app.gcode_edited.getvalue(), move_to_start=True, clear_text=True)
except Exception as e:
log.debug('FlatCAMCNCJob.on_review_code_click() -->%s' % str(e))
return
self.gcode_editor_tab.t_frame.show()
self.app.proc_container.view.set_idle()
self.gcode_editor_tab.buttonSave.hide()
self.gcode_editor_tab.buttonOpen.hide()
# self.gcode_editor_tab.buttonPrint.hide()
# self.gcode_editor_tab.buttonPreview.hide()
self.gcode_editor_tab.buttonReplace.hide()
self.gcode_editor_tab.sel_all_cb.hide()
self.gcode_editor_tab.entryReplace.hide()
self.gcode_editor_tab.code_editor.setReadOnly(True)
self.app.inform.emit('[success] %s...' % _('Loaded Machine Code into Code Editor'))
def on_update_source_file(self):
self.source_file = self.gcode_editor_tab.code_editor.toPlainText()
def gcode_header(self, comment_start_symbol=None, comment_stop_symbol=None):
"""
Will create a header to be added to all GCode files generated by FlatCAM
:param comment_start_symbol: A symbol to be used as the first symbol in a comment
:param comment_stop_symbol: A symbol to be used as the last symbol in a comment
:return: A string with a GCode header
"""
log.debug("FlatCAMCNCJob.gcode_header()")
time_str = "{:%A, %d %B %Y at %H:%M}".format(datetime.now())
marlin = False
hpgl = False
probe_pp = False
gcode = ''
start_comment = comment_start_symbol if comment_start_symbol is not None else '('
stop_comment = comment_stop_symbol if comment_stop_symbol is not None else ')'
try:
for key in self.cnc_tools:
ppg = self.cnc_tools[key]['data']['ppname_g']
if 'marlin' in ppg.lower() or 'repetier' in ppg.lower():
marlin = True
break
if ppg == 'hpgl':
hpgl = True
break
if "toolchange_probe" in ppg.lower():
probe_pp = True
break
except KeyError:
# log.debug("FlatCAMCNCJob.gcode_header() error: --> %s" % str(e))
pass
try:
if 'marlin' in self.options['ppname_e'].lower() or 'repetier' in self.options['ppname_e'].lower():
marlin = True
except KeyError:
# log.debug("FlatCAMCNCJob.gcode_header(): --> There is no such self.option: %s" % str(e))
pass
try:
if "toolchange_probe" in self.options['ppname_e'].lower():
probe_pp = True
except KeyError:
# log.debug("FlatCAMCNCJob.gcode_header(): --> There is no such self.option: %s" % str(e))
pass
if marlin is True:
gcode += ';Marlin(Repetier) G-CODE GENERATED BY FLATCAM v%s - www.flatcam.org - Version Date: %s\n' % \
(str(self.app.version), str(self.app.version_date)) + '\n'
gcode += ';Name: ' + str(self.options['name']) + '\n'
gcode += ';Type: ' + "G-code from " + str(self.options['type']) + '\n'
# if str(p['options']['type']) == 'Excellon' or str(p['options']['type']) == 'Excellon Geometry':
# gcode += '(Tools in use: ' + str(p['options']['Tools_in_use']) + ')\n'
gcode += ';Units: ' + self.units.upper() + '\n' + "\n"
gcode += ';Created on ' + time_str + '\n' + '\n'
elif hpgl is True:
gcode += 'CO "HPGL CODE GENERATED BY FLATCAM v%s - www.flatcam.org - Version Date: %s' % \
(str(self.app.version), str(self.app.version_date)) + '";\n'
gcode += 'CO "Name: ' + str(self.options['name']) + '";\n'
gcode += 'CO "Type: ' + "HPGL code from " + str(self.options['type']) + '";\n'
# if str(p['options']['type']) == 'Excellon' or str(p['options']['type']) == 'Excellon Geometry':
# gcode += '(Tools in use: ' + str(p['options']['Tools_in_use']) + ')\n'
gcode += 'CO "Units: ' + self.units.upper() + '";\n'
gcode += 'CO "Created on ' + time_str + '";\n'
elif probe_pp is True:
gcode += '(G-CODE GENERATED BY FLATCAM v%s - www.flatcam.org - Version Date: %s)\n' % \
(str(self.app.version), str(self.app.version_date)) + '\n'
gcode += '(This GCode tool change is done by using a Probe.)\n' \
'(Make sure that before you start the job you first do a rough zero for Z axis.)\n' \
'(This means that you need to zero the CNC axis and then jog to the toolchange X, Y location,)\n' \
'(mount the probe and adjust the Z so more or less the probe tip touch the plate. ' \
'Then zero the Z axis.)\n' + '\n'
gcode += '(Name: ' + str(self.options['name']) + ')\n'
gcode += '(Type: ' + "G-code from " + str(self.options['type']) + ')\n'
# if str(p['options']['type']) == 'Excellon' or str(p['options']['type']) == 'Excellon Geometry':
# gcode += '(Tools in use: ' + str(p['options']['Tools_in_use']) + ')\n'
gcode += '(Units: ' + self.units.upper() + ')\n' + "\n"
gcode += '(Created on ' + time_str + ')\n' + '\n'
else:
gcode += '%sG-CODE GENERATED BY FLATCAM v%s - www.flatcam.org - Version Date: %s%s\n' % \
(start_comment, str(self.app.version), str(self.app.version_date), stop_comment) + '\n'
gcode += '%sName: ' % start_comment + str(self.options['name']) + '%s\n' % stop_comment
gcode += '%sType: ' % start_comment + "G-code from " + str(self.options['type']) + '%s\n' % stop_comment
# if str(p['options']['type']) == 'Excellon' or str(p['options']['type']) == 'Excellon Geometry':
# gcode += '(Tools in use: ' + str(p['options']['Tools_in_use']) + ')\n'
gcode += '%sUnits: ' % start_comment + self.units.upper() + '%s\n' % stop_comment + "\n"
gcode += '%sCreated on ' % start_comment + time_str + '%s\n' % stop_comment + '\n'
return gcode
@staticmethod
def gcode_footer(end_command=None):
"""
Will add the M02 to the end of GCode, if requested.
:param end_command: 'M02' or 'M30' - String
:return:
"""
if end_command:
return end_command
else:
return 'M02'
def export_gcode(self, filename=None, preamble='', postamble='', to_file=False, from_tcl=False):
"""
This will save the GCode from the Gcode object to a file on the OS filesystem
:param filename: filename for the GCode file
:param preamble: a custom Gcode block to be added at the beginning of the Gcode file
:param postamble: a custom Gcode block to be added at the end of the Gcode file
:param to_file: if False then no actual file is saved but the app will know that a file was created
:param from_tcl: True if run from Tcl Shell
:return: None
"""
# gcode = ''
# roland = False
# hpgl = False
# isel_icp = False
include_header = True
if preamble == '':
preamble = self.app.defaults["cncjob_prepend"]
if postamble == '':
postamble = self.app.defaults["cncjob_append"]
try:
if self.special_group:
self.app.inform.emit('[WARNING_NOTCL] %s %s %s.' %
(_("This CNCJob object can't be processed because it is a"),
str(self.special_group),
_("CNCJob object")))
return 'fail'
except AttributeError:
pass
# if this dict is not empty then the object is a Geometry object
if self.cnc_tools:
first_key = next(iter(self.cnc_tools))
include_header = self.app.preprocessors[self.cnc_tools[first_key]['data']['ppname_g']].include_header
# if this dict is not empty then the object is an Excellon object
if self.exc_cnc_tools:
first_key = next(iter(self.exc_cnc_tools))
include_header = self.app.preprocessors[
self.exc_cnc_tools[first_key]['data']['tools_drill_ppname_e']
].include_header
gcode = ''
if include_header is False:
# detect if using multi-tool and make the Gcode summation correctly for each case
if self.multitool is True:
for tooluid_key in self.cnc_tools:
for key, value in self.cnc_tools[tooluid_key].items():
if key == 'gcode':
gcode += value
break
else:
gcode += self.gcode
g = preamble + '\n' + gcode + '\n' + postamble
else:
# search for the GCode beginning which is usually a G20 or G21
# fix so the preamble gets inserted in between the comments header and the actual start of GCODE
# g_idx = gcode.rfind('G20')
#
# # if it did not find 'G20' then search for 'G21'
# if g_idx == -1:
# g_idx = gcode.rfind('G21')
#
# # if it did not find 'G20' and it did not find 'G21' then there is an error and return
# if g_idx == -1:
# self.app.inform.emit('[ERROR_NOTCL] %s' % _("G-code does not have a units code: either G20 or G21"))
# return
# detect if using multi-tool and make the Gcode summation correctly for each case
if self.multitool is True:
if self.origin_kind == 'excellon':
for tooluid_key in self.exc_cnc_tools:
for key, value in self.exc_cnc_tools[tooluid_key].items():
if key == 'gcode' and value:
gcode += value
break
else:
for tooluid_key in self.cnc_tools:
for key, value in self.cnc_tools[tooluid_key].items():
if key == 'gcode' and value:
gcode += value
break
else:
gcode += self.gcode
end_gcode = self.gcode_footer() if self.app.defaults['cncjob_footer'] is True else ''
# detect if using a HPGL preprocessor
hpgl = False
if self.cnc_tools:
for key in self.cnc_tools:
if 'ppname_g' in self.cnc_tools[key]['data']:
if 'hpgl' in self.cnc_tools[key]['data']['ppname_g']:
hpgl = True
break
elif self.exc_cnc_tools:
for key in self.cnc_tools:
if 'ppname_e' in self.cnc_tools[key]['data']:
if 'hpgl' in self.cnc_tools[key]['data']['ppname_e']:
hpgl = True
break
if hpgl:
processed_body_gcode = ''
pa_re = re.compile(r"^PA\s*(-?\d+\.\d*),?\s*(-?\d+\.\d*)*;?$")
# process body gcode
for gline in gcode.splitlines():
match = pa_re.search(gline)
if match:
x_int = int(float(match.group(1)))
y_int = int(float(match.group(2)))
new_line = 'PA%d,%d;\n' % (x_int, y_int)
processed_body_gcode += new_line
else:
processed_body_gcode += gline + '\n'
gcode = processed_body_gcode
g = self.gc_header + '\n' + self.gc_start + '\n' + preamble + '\n' + \
gcode + '\n' + postamble + end_gcode
else:
# try:
# g_idx = gcode.index('G94')
# if preamble != '' and postamble != '':
# g = self.gc_header + gcode[:g_idx + 3] + '\n' + preamble + '\n' + \
# gcode[(g_idx + 3):] + postamble + end_gcode
# elif preamble == '':
# g = self.gc_header + gcode[:g_idx + 3] + '\n' + \
# gcode[(g_idx + 3):] + postamble + end_gcode
# elif postamble == '':
# g = self.gc_header + gcode[:g_idx + 3] + '\n' + preamble + '\n' + \
# gcode[(g_idx + 3):] + end_gcode
# else:
# g = self.gc_header + gcode[:g_idx + 3] + gcode[(g_idx + 3):] + end_gcode
# except ValueError:
# self.app.inform.emit('[ERROR_NOTCL] %s' %
# _("G-code does not have a G94 code.\n"
# "Append Code snippet will not be used.."))
# g = self.gc_header + '\n' + gcode + postamble + end_gcode
g = ''
if preamble != '' and postamble != '':
g = self.gc_header + self.gc_start + '\n' + preamble + '\n' + gcode + '\n' + \
postamble + '\n' + end_gcode
if preamble == '':
g = self.gc_header + self.gc_start + '\n' + gcode + '\n' + postamble + '\n' + end_gcode
if postamble == '':
g = self.gc_header + self.gc_start + '\n' + preamble + '\n' + gcode + '\n' + end_gcode
if preamble == '' and postamble == '':
g = self.gc_header + self.gc_start + '\n' + gcode + '\n' + end_gcode
# if toolchange custom is used, replace M6 code with the code from the Toolchange Custom Text box
# if self.ui.toolchange_cb.get_value() is True:
# # match = self.re_toolchange.search(g)
# if 'M6' in g:
# m6_code = self.parse_custom_toolchange_code(self.ui.toolchange_text.get_value())
# if m6_code is None or m6_code == '':
# self.app.inform.emit(
# '[ERROR_NOTCL] %s' % _("Cancelled. The Toolchange Custom code is enabled but it's empty.")
# )
# return 'fail'
#
# g = g.replace('M6', m6_code)
# self.app.inform.emit('[success] %s' % _("Toolchange G-code was replaced by a custom code."))
lines = StringIO(g)
# Write
if filename is not None:
try:
force_windows_line_endings = self.app.defaults['cncjob_line_ending']
if force_windows_line_endings and sys.platform != 'win32':
with open(filename, 'w', newline='\r\n') as f:
for line in lines:
f.write(line)
else:
with open(filename, 'w') as f:
for line in lines:
f.write(line)
except FileNotFoundError:
self.app.inform.emit('[WARNING_NOTCL] %s' % _("No such file or directory"))
return
except PermissionError:
self.app.inform.emit(
'[WARNING] %s' % _("Permission denied, saving not possible.\n"
"Most likely another app is holding the file open and not accessible.")
)
return 'fail'
elif to_file is False:
# Just for adding it to the recent files list.
if self.app.defaults["global_open_style"] is False:
self.app.file_opened.emit("cncjob", filename)
self.app.file_saved.emit("cncjob", filename)
self.app.inform.emit('[success] %s: %s' % (_("Saved to"), filename))
else:
return lines
# def on_toolchange_custom_clicked(self, signal):
# """
# Handler for clicking toolchange custom.
#
# :param signal:
# :return:
# """
#
# try:
# if 'toolchange_custom' not in str(self.options['ppname_e']).lower():
# if self.ui.toolchange_cb.get_value():
# self.ui.toolchange_cb.set_value(False)
# self.app.inform.emit('[WARNING_NOTCL] %s' %
# _("The used preprocessor file has to have in it's name: 'toolchange_custom'")
# )
# except KeyError:
# try:
# for key in self.cnc_tools:
# ppg = self.cnc_tools[key]['data']['ppname_g']
# if 'toolchange_custom' not in str(ppg).lower():
# if self.ui.toolchange_cb.get_value():
# self.ui.toolchange_cb.set_value(False)
# self.app.inform.emit('[WARNING_NOTCL] %s' %
# _("The used preprocessor file has to have in it's name: "
# "'toolchange_custom'"))
# except KeyError:
# self.app.inform.emit('[ERROR] %s' % _("There is no preprocessor file."))
def get_gcode(self, preamble='', postamble=''):
"""
We need this to be able to get_gcode separately for shell command export_gcode
:param preamble: Extra GCode added to the beginning of the GCode
:param postamble: Extra GCode added at the end of the GCode
:return: The modified GCode
"""
return preamble + '\n' + self.gcode + "\n" + postamble
def get_svg(self):
# we need this to be able get_svg separately for shell command export_svg
pass
def on_plot_cb_click(self, *args):
"""
Handler for clicking on the Plot checkbox.
:param args:
:return:
"""
if self.muted_ui:
return
kind = self.ui.cncplot_method_combo.get_value()
self.plot(kind=kind)
self.read_form_item('plot')
self.ui_disconnect()
cb_flag = self.ui.plot_cb.isChecked()
for row in range(self.ui.cnc_tools_table.rowCount()):
table_cb = self.ui.cnc_tools_table.cellWidget(row, 6)
if cb_flag:
table_cb.setChecked(True)
else:
table_cb.setChecked(False)
self.ui_connect()
def on_plot_cb_click_table(self):
"""
Handler for clicking the plot checkboxes added into a Table on each row. Purpose: toggle visibility for the
tool/aperture found on that row.
:return:
"""
# self.ui.cnc_tools_table.cellWidget(row, 2).widget().setCheckState(QtCore.Qt.Unchecked)
self.ui_disconnect()
# cw = self.sender()
# cw_index = self.ui.cnc_tools_table.indexAt(cw.pos())
# cw_row = cw_index.row()
kind = self.ui.cncplot_method_combo.get_value()
self.shapes.clear(update=True)
if self.origin_kind == "excellon":
for r in range(self.ui.exc_cnc_tools_table.rowCount()):
row_dia = float('%.*f' % (self.decimals, float(self.ui.exc_cnc_tools_table.item(r, 1).text())))
for tooluid_key in self.exc_cnc_tools:
tooldia = float('%.*f' % (self.decimals, float(tooluid_key)))
if row_dia == tooldia:
gcode_parsed = self.exc_cnc_tools[tooluid_key]['gcode_parsed']
if self.ui.exc_cnc_tools_table.cellWidget(r, 6).isChecked():
self.plot2(tooldia=tooldia, obj=self, visible=True, gcode_parsed=gcode_parsed, kind=kind)
else:
for tooluid_key in self.cnc_tools:
tooldia = float('%.*f' % (self.decimals, float(self.cnc_tools[tooluid_key]['tooldia'])))
gcode_parsed = self.cnc_tools[tooluid_key]['gcode_parsed']
# tool_uid = int(self.ui.cnc_tools_table.item(cw_row, 3).text())
for r in range(self.ui.cnc_tools_table.rowCount()):
if int(self.ui.cnc_tools_table.item(r, 5).text()) == int(tooluid_key):
if self.ui.cnc_tools_table.cellWidget(r, 6).isChecked():
self.plot2(tooldia=tooldia, obj=self, visible=True, gcode_parsed=gcode_parsed, kind=kind)
self.shapes.redraw()
# make sure that the general plot is disabled if one of the row plot's are disabled and
# if all the row plot's are enabled also enable the general plot checkbox
cb_cnt = 0
total_row = self.ui.cnc_tools_table.rowCount()
for row in range(total_row):
if self.ui.cnc_tools_table.cellWidget(row, 6).isChecked():
cb_cnt += 1
else:
cb_cnt -= 1
if cb_cnt < total_row:
self.ui.plot_cb.setChecked(False)
else:
self.ui.plot_cb.setChecked(True)
self.ui_connect()
def plot(self, visible=None, kind='all'):
"""
# Does all the required setup and returns False
# if the 'ptint' option is set to False.
:param visible: Boolean to decide if the object will be plotted as visible or disabled on canvas
:param kind: String. Can be "all" or "travel" or "cut". For CNCJob plotting
:return: None
"""
if not FlatCAMObj.plot(self):
return
visible = visible if visible else self.options['plot']
# Geometry shapes plotting
try:
if self.multitool is False: # single tool usage
try:
dia_plot = float(self.options["tooldia"])
except ValueError:
# we may have a tuple with only one element and a comma
dia_plot = [float(el) for el in self.options["tooldia"].split(',') if el != ''][0]
self.plot2(tooldia=dia_plot, obj=self, visible=visible, kind=kind)
else:
# I do this so the travel lines thickness will reflect the tool diameter
# may work only for objects created within the app and not Gcode imported from elsewhere for which we
# don't know the origin
if self.origin_kind == "excellon":
if self.exc_cnc_tools:
for tooldia_key in self.exc_cnc_tools:
tooldia = float('%.*f' % (self.decimals, float(tooldia_key)))
gcode_parsed = self.exc_cnc_tools[tooldia_key]['gcode_parsed']
if not gcode_parsed:
continue
# gcode_parsed = self.gcode_parsed
self.plot2(tooldia=tooldia, obj=self, visible=visible, gcode_parsed=gcode_parsed, kind=kind)
else:
# multiple tools usage
if self.cnc_tools:
for tooluid_key in self.cnc_tools:
tooldia = float('%.*f' % (self.decimals, float(self.cnc_tools[tooluid_key]['tooldia'])))
gcode_parsed = self.cnc_tools[tooluid_key]['gcode_parsed']
self.plot2(tooldia=tooldia, obj=self, visible=visible, gcode_parsed=gcode_parsed, kind=kind)
self.shapes.redraw()
except (ObjectDeleted, AttributeError):
self.shapes.clear(update=True)
if self.app.is_legacy is False:
self.annotation.clear(update=True)
# Annotaions shapes plotting
try:
if self.app.is_legacy is False:
if self.ui.annotation_cb.get_value() and self.ui.plot_cb.get_value():
self.plot_annotations(obj=self, visible=True)
else:
self.plot_annotations(obj=self, visible=False)
except (ObjectDeleted, AttributeError):
if self.app.is_legacy is False:
self.annotation.clear(update=True)
def on_annotation_change(self):
"""
Handler for toggling the annotation display by clicking a checkbox.
:return:
"""
if self.app.is_legacy is False:
if self.ui.annotation_cb.get_value():
self.text_col.enabled = True
else:
self.text_col.enabled = False
# kind = self.ui.cncplot_method_combo.get_value()
# self.plot(kind=kind)
self.annotation.redraw()
else:
kind = self.ui.cncplot_method_combo.get_value()
self.plot(kind=kind)
def convert_units(self, units):
"""
Units conversion used by the CNCJob objects.
:param units: Can be "MM" or "IN"
:return:
"""
log.debug("FlatCAMObj.FlatCAMECNCjob.convert_units()")
factor = CNCjob.convert_units(self, units)
self.options["tooldia"] = float(self.options["tooldia"]) * factor
param_list = ['cutz', 'depthperpass', 'travelz', 'feedrate', 'feedrate_z', 'feedrate_rapid',
'endz', 'toolchangez']
temp_tools_dict = {}
tool_dia_copy = {}
data_copy = {}
for tooluid_key, tooluid_value in self.cnc_tools.items():
for dia_key, dia_value in tooluid_value.items():
if dia_key == 'tooldia':
dia_value *= factor
dia_value = float('%.*f' % (self.decimals, dia_value))
tool_dia_copy[dia_key] = dia_value
if dia_key == 'offset':
tool_dia_copy[dia_key] = dia_value
if dia_key == 'offset_value':
dia_value *= factor
tool_dia_copy[dia_key] = dia_value
if dia_key == 'type':
tool_dia_copy[dia_key] = dia_value
if dia_key == 'tool_type':
tool_dia_copy[dia_key] = dia_value
if dia_key == 'data':
for data_key, data_value in dia_value.items():
# convert the form fields that are convertible
for param in param_list:
if data_key == param and data_value is not None:
data_copy[data_key] = data_value * factor
# copy the other dict entries that are not convertible
if data_key not in param_list:
data_copy[data_key] = data_value
tool_dia_copy[dia_key] = deepcopy(data_copy)
data_copy.clear()
if dia_key == 'gcode':
tool_dia_copy[dia_key] = dia_value
if dia_key == 'gcode_parsed':
tool_dia_copy[dia_key] = dia_value
if dia_key == 'solid_geometry':
tool_dia_copy[dia_key] = dia_value
# if dia_key == 'solid_geometry':
# tool_dia_copy[dia_key] = affinity.scale(dia_value, xfact=factor, origin=(0, 0))
# if dia_key == 'gcode_parsed':
# for g in dia_value:
# g['geom'] = affinity.scale(g['geom'], factor, factor, origin=(0, 0))
#
# tool_dia_copy['gcode_parsed'] = deepcopy(dia_value)
# tool_dia_copy['solid_geometry'] = unary_union([geo['geom'] for geo in dia_value])
temp_tools_dict.update({
tooluid_key: deepcopy(tool_dia_copy)
})
tool_dia_copy.clear()
self.cnc_tools.clear()
self.cnc_tools = deepcopy(temp_tools_dict)