Merge branch '2.9'

Author: c-morley

configs/sim/qtdragon/qtdragon_tool_probe/qtdragon_auto_tool_probe.ini

@@ -163,13 +163,17 @@ USE_PROBE = versaprobe
 # Abs (G53) coordinates remap tool change point
 X = 10
 Y = 10
-Z = -2
+Z = 8
 
 # where in absolute machine units to probe the tool
 [VERSA_TOOLSETTER]
 X = 300
 Y = 300
 Z = -50
+# how migh to lift when moving to the tool setter
+Z_MAX_CLEAR = 9.999
+# tool setter diameter for diameter probing
+DIAMETER = 25
 # maximuim machine units to lower while probing
 MAXPROBE =  -40
 

docs/src/gui/images/qtdragon.png

@@ -707,7 +707,7 @@ Probing is very unforgiving to mistakes; be sure to check settings before using.
 QtDragon has 2 methods for setting Z0.
 The first is a touchplate, where a metal plate of known thickness is placed on top of the workpiece,
 then the tool is lowered until it touches the plate, triggering the probe signal.
-Z0 is set to probe height - plate thickness.
+The current user system's (G5x) Z0 is set to probe height - the entered plate thickness.
 
 The second method uses a tool setter in a fixed position and a known height above the table where the probe signal will be triggered.
 In order to set Z0 to the top of the workpiece, it has to know

docs/src/gui/qtdragon.adoc

@@ -138,6 +138,16 @@ image::images/tklinuxcnc_fr.png["TkLinuxCNC graphical interface",align="center"]
 
 Xemc:: an X-Window program
 
+QtDragon:: <<cha:qtdragon-gui,QtDragon>>, a touch screen GUI based on QtVCP using the PyQt5 library. It comes in two versions 
+'QtDragon' and 'QtDragon_hd'. They are very similar in features but QtDragon_hd is made for larger monitors.
+
+[[fig:QtDragon-graphical-interface]]
+.QtDragon, a touch screen GUI based on QtVCP
+image::images/qtdragon.png["QtDragon, a touch screen GUI based on QtVCP",align="center"]
+
+== User Interfaces
+These User interfaces are a way to interact with linuxcnc outside of the graphical user interfaces.
+
 halui:: A HAL based user interface allowing to control LinuxCNC using buttons and switches
 
 linuxcncrsh:: A telnet based user interface allowing to send commands from remote computers.
@@ -165,6 +175,14 @@ GladeVCP:: <<cha:glade-vcp,'GladeVCP'>>, a Glade-based virtual control panel tha
 .GladeVCP Example Embedded Into AXIS GUI
 image::../gui/images/axis-gladevcp.png["GladeVCP embedded into AXIS",align="center"]
 
+QtVCP:: <<cha:qtvcp,'QtVCP'>>, a PyQT5-based virtual control panel that can be added to most GUIs or run as a standalone panel.
+  QtVCP has the advantage over PyVCP in that it is not limited to the display or control of HAL virtual signals,
+  but can include other external interfaces outside LinuxCNC such as window or network events by extending with python code.
+  QtVCP is also more flexible in how it may be configured to appear on the GUI with many special widgets:
+
+.QtVCP Example Embedded Into QtDragon GUI
+image::../gui/images/qtvcp_spindle_belts.png["QtVCP panel embedded into QtDragon",align="center"]
+
 == Languages
 
 LinuxCNC uses translation files to translate LinuxCNC User Interfaces into many languages including

docs/src/user/images/qtdragon.png

@@ -518,7 +518,8 @@ def update(self):
     ###################
     # helper functions
     ###################
-
+    # return a found string or else None by default, anything else by option
+    # since this is used in this file there are some workarounds for plasma machines
     def get_error_safe_setting(self, heading, detail, default=None):
         result = self.INI.find(heading, detail)
         if result:
@@ -531,6 +532,22 @@ def get_error_safe_setting(self, heading, detail, default=None):
                 log.warning('INI Parsing Error, No {} Entry in {}, Using: {}'.format(detail, heading, default))
             return default
 
+    # return a found float or else None by default, anything else by option
+    def get_safe_float(self, heading, detail, default=None):
+        try:
+            result = float(self.INI.find(heading, detail))
+            return result
+        except:
+            return default
+
+    # return a found integer or else None by default, anything else by option
+    def get_safe_int(self, heading, detail, default=None):
+        try:
+            result = int(self.INI.find(heading, detail))
+            return result
+        except:
+            return default
+
     def convert_machine_to_metric(self, data):
         if self.MACHINE_IS_METRIC:
             return data

docs/src/user/user-intro.adoc

@@ -20,7 +20,6 @@
 class ProbeRoutines():
     def __init__(self):
         self.timeout = 30
-
 ##################
 # Helper Functions
 ##################
@@ -126,6 +125,47 @@ def probe(self, name):
             return 'Probe {} failed: {}'.format(name, rtn)
         return 1
 
+    def goto_toolsetter(self):
+      try:
+        # basic sanity checks 
+        for test in('z_max_clear','ts_x','ts_y','ts_z','ts_max'):
+            if self['data_{}'.format(test)] is None:
+                return'Missing toolsetter setting: {}'.format(test)
+        if self.data_tool_diameter is None:
+            return 'No tool diameter found'
+
+        # raise to safe Z height
+        # move to tool setter (XY then Z)
+        # offset X by tool radius (from toolfile)
+        # probe Z
+        # raise z clear
+        # move back X by tool radius
+
+        cmdList = []
+        cmdList.append('F{}'.format(self.data_rapid_vel))
+        cmdList.append('G53 G1 Z{}'.format(self.data_z_max_clear))
+        cmdList.append('G53 G1 X{} Y{}'.format(self.data_ts_x, self.data_ts_y))
+        cmdList.append('G53 G1 Z{}'.format(self.data_ts_z))
+        cmdList.append('G91 ')
+        cmdList.append('G1 X{}'.format(self.data_tool_diameter/2))
+        cmdList.append('G38.2 Z{} F{}'.format(self.data_ts_max,self.data_search_vel))
+        cmdList.append('G1 Z{} F{}'.format(self.data_latch_return_dist, self.data_rapid_vel))
+        cmdList.append('F{} G4 P0.5'.format(self.data_probe_vel))
+        cmdList.append('G38.2 Z-{}'.format(self.data_latch_return_dist*2))
+        cmdList.append('G1 Z{} F{}'.format(self.data_z_clearance, self.data_rapid_vel))
+        cmdList.append('G1 X-{}'.format(self.data_tool_diameter/2))
+        cmdList.append('G90')
+
+        # call each command - if fail report the error and gcode command
+        for s in cmdList:
+            rtn = self.CALL_MDI_WAIT(s, self.timeout) 
+            if rtn != 1:
+                return 'failed: {} cmd: {}'.format(rtn, s)
+        # report success
+        return 1
+      except Exception as e:
+        return e
+
     def CALL_MDI_WAIT(self, code, timeout = 5):
         LOG.debug('MDI_WAIT_COMMAND= {}, maxt = {}'.format(code, timeout))
         for l in code.split("\n"):
@@ -1483,7 +1523,7 @@ def probe_valley_y(self):
     def probe_cal_round_pocket(self):
         if self.data_cal_diameter_hint <= 0 :
             return 'Calibration diameter hint must be larger then 0'
-        if self.data_probe_diameter >= self.data_cal_diameter_hint:
+        if self.data_probe_diam >= self.data_cal_diameter_hint:
             return 'Probe diameter too large for Calibration diameter hint'
 
         self.data_side_edge_length = self.data_cal_diameter / 2
@@ -1631,3 +1671,154 @@ def probe_angle_right(self):
         self.status_a = math.degrees(math.atan2(self.status_delta, self.data_side_edge_length))
         self.rotate_coord_system(self.status_a)
         return error
+
+    # TOOL setter Diameter/height
+    # returns 1 for success or a string error message for failure
+    def probe_tool_z_d(self):
+      try:
+        # move XY to Tool Setter point
+        # Start goto ts (probes Z height too)
+        rtn = self.goto_toolsetter()
+        if rtn != 1:
+            return 'failed: {}'.format(rtn)
+        # move X - edge_length- xy_clearance
+        s="""G91
+        G1 F%s X-%f
+        G90""" % (self.data_rapid_vel, 0.5 * self.data_ts_diam + self.data_xy_clearance)
+        rtn = self.CALL_MDI_WAIT(s, self.timeout) 
+        if rtn != 1:
+            return 'failed: {}'.format(rtn)
+        rtn = self.z_clearance_down()
+        if rtn != 1:
+            return 'failed: {}'.format(rtn)
+
+        # Start xplus
+        rtn = self.probe('xplus')
+        if rtn != 1:
+            return 'failed: {}'.format(rtn)
+
+        # show X result
+        a = STATUS.get_probed_position_with_offsets()
+        xpres=float(a[0])+0.5*self.data_probe_diam
+
+        # move Z to start point up
+        rtn = self.z_clearance_up()
+        if rtn != 1:
+            return 'failed: {}'.format(rtn)
+
+        # move to finded  point X
+        s = "G1 F%s X%f" % (self.data_rapid_vel, xpres)
+        rtn = self.CALL_MDI_WAIT(s, self.timeout) 
+        if rtn != 1:
+            return 'failed: {}'.format(rtn)
+
+        # move X + data_ts_diam +  xy_clearance
+        aa=self.data_ts_diam+self.data_xy_clearance
+        s="""G91
+        G1 X%f
+        G90""" % (aa)
+        rtn = self.CALL_MDI_WAIT(s, self.timeout) 
+        if rtn != 1:
+            return 'failed: {}'.format(rtn)
+
+        rtn = self.z_clearance_down()
+        if rtn != 1:
+            return 'failed: {}'.format(rtn)
+
+        # Start xminus
+        rtn = self.probe('xminus')
+        if rtn != 1:
+            return 'failed: {}'.format(rtn)
+
+        # show X result
+        a = STATUS.get_probed_position_with_offsets()
+        xmres=float(a[0])-0.5*self.data_probe_diam
+        self.length_x()
+        xcres=0.5*(xpres+xmres)
+        self.status_xc = xcres
+
+        # move Z to start point up
+        rtn = self.z_clearance_up()
+        if rtn != 1:
+            return 'failed: {}'.format(rtn)
+
+        # go to the new center of X
+        s = "G1 F%s X%f" % (self.data_rapid_vel, xcres)
+        rtn = self.CALL_MDI_WAIT(s, self.timeout) 
+        if rtn != 1:
+            return 'failed: {}'.format(rtn)
+
+        # move Y - data_ts_diam/2 - xy_clearance
+        a=0.5*self.data_ts_diam+self.data_xy_clearance
+        s="""G91
+        G1 Y-%f
+        G90""" % a
+        rtn = self.CALL_MDI_WAIT(s, self.timeout) 
+        if rtn != 1:
+            return 'failed: {}'.format(rtn)
+
+        rtn = self.z_clearance_down()
+        if rtn != 1:
+            return 'failed: {}'.format(rtn)
+
+        # Start yplus
+        rtn = self.probe('yplus')
+        if rtn != 1:
+            return 'failed: {}'.format(rtn)
+
+        # show Y result
+        a = STATUS.get_probed_position_with_offsets()
+        ypres=float(a[1])+0.5*self.data_probe_diam
+        # move Z to start point up
+        if self.z_clearance_up() == -1:
+            return
+
+        # move to found point Y
+        s = "G1 Y%f" % ypres
+        rtn = self.CALL_MDI_WAIT(s, self.timeout) 
+        if rtn != 1:
+            return 'failed: {}'.format(rtn)
+
+        # move Y + data_ts_diam +  xy_clearance
+        aa=self.data_ts_diam+self.data_xy_clearance
+        s="""G91
+        G1 Y%f
+        G90""" % (aa)
+        rtn = self.CALL_MDI_WAIT(s, self.timeout) 
+        if rtn != 1:
+            return 'failed: {}'.format(rtn)
+        rtn = self.z_clearance_down()
+        if rtn != 1:
+            return 'failed: {}'.format(rtn)
+
+        # Start yminus
+        rtn = self.probe('yminus')
+        if rtn != 1:
+            return 'failed: {}'.format(rtn)
+        # show Y result
+        a = STATUS.get_probed_position_with_offsets()
+        ymres=float(a[1])-0.5*self.data_probe_diam
+        self.length_y()
+
+        # find, show and move to finded  point
+        ycres=0.5*(ypres+ymres)
+        self.status_yc = ycres
+        diam=self.data_probe_diam + (ymres-ypres-self.data_ts_diam)
+        self.status_d = diam
+
+        # move Z to start point up
+        rtn = self.z_clearance_up()
+        if rtn != 1:
+            return 'failed: {}'.format(rtn)
+        tmpz=STATUS.stat.position[2] - self.data_z_clearance
+        self.status_z=tmpz
+        self.add_history('Tool diameter',"XcYcZD",0,xcres,0,0,0,ycres,0,0,tmpz,diam,0)
+        # move to finded  point
+        s = "G1 Y%f" % ycres
+        rtn = self.CALL_MDI_WAIT(s, self.timeout) 
+        if rtn != 1:
+            return 'failed: {}'.format(rtn)
+        # success
+        return 1
+      except Exception as e:
+        return e

lib/python/qtvcp/qt_istat.py

@@ -63,7 +63,15 @@ def __init__(self):
                           'cal_x_width',
                           'cal_y_width',
                           'cal_diameter',
-                          'calibration_offset']
+                          'calibration_offset',
+                          'ts_diam',
+                          'z_max_clear',
+                          'ts_x',
+                          'ts_y',
+                          'ts_z',
+                          'ts_max',
+                          'tool_diameter']
+
         # data structure to hold parameters
         # common
         self.data_probe_diam = 1.0
@@ -84,6 +92,13 @@ def __init__(self):
         self.data_adj_y = 0.0
         self.data_adj_z = 0.0
         self.data_adj_angle = 0.0
+        self.data_ts_diam = 1.0
+        self.data_z_max_clear = None
+        self.data_ts_x= None
+        self.data_ts_y= None
+        self.data_ts_z= None
+        self.data_ts_max = None
+        self.data_tool_diameter = None
         # BasicProbe exclusive
         self.data_x_hint_bp = 0.0
         self.data_y_hint_bp = 0.0

lib/python/qtvcp/widgets/probe_routines.py

@@ -49,6 +49,8 @@ class VersaProbe(QtWidgets.QWidget, _HalWidgetBase):
     def __init__(self, parent=None):
         super(VersaProbe, self).__init__(parent)
         self.proc = None
+        self.tool_diameter = None
+        STATUS.connect('tool-info-changed', lambda w, data: self._tool_info(data))
         if INFO.MACHINE_IS_METRIC:
             self.valid = QtGui.QRegExpValidator(QtCore.QRegExp('^((\d{1,4}(\.\d{1,3})?)|(\.\d{1,3}))$'))
         else:
@@ -113,6 +115,14 @@ def eventFilter(self, obj, event):
                     self.popEntry(obj)
         return super(VersaProbe, self).eventFilter(obj, event)
 
+
+    def _tool_info(self, data):
+        if data.id != -1:
+            self.tool_diameter = data.diameter
+            print(data)
+            return
+        self.tool_diameter = None
+
     def _hal_init(self):
 
         def homed_on_test():
@@ -177,6 +187,13 @@ def homed_on_test():
             self.input_adj_angle.setText(str(self.PREFS_.getpref( "ps_offs_angle", 0.0, float, 'VERSA_PROBE_OPTIONS')) )
             self.input_rapid_vel.setText(str(self.PREFS_.getpref( "ps_probe_rapid_vel", 60.0, float, 'VERSA_PROBE_OPTIONS')) )
 
+        self.z_max_clear = INFO.get_safe_float("VERSA_TOOLSETTER", "Z_MAX_CLEAR")
+        self.ts_x =  INFO.get_safe_float('VERSA_TOOLSETTER','X')
+        self.ts_y = INFO.get_safe_float('VERSA_TOOLSETTER','Y')
+        self.ts_z = INFO.get_safe_float('VERSA_TOOLSETTER','Z')
+        self.ts_max = INFO.get_safe_float('VERSA_TOOLSETTER','MAXPROBE')
+        self.ts_diam = INFO.get_safe_float('VERSA_TOOLSETTER','DIAMETER')
+
         # make pins available for tool measure remaps
         oldname = self.HAL_GCOMP_.comp.getprefix()
         self.HAL_GCOMP_.comp.setprefix('qtversaprobe')
@@ -397,6 +414,11 @@ def get_parms(self):
         for key in ['allow_auto_zero', 'allow_auto_skew']:
             val = '1' if self[key].isChecked() else '0'
             self.send_dict.update( {key: val} )
+        # come from INI
+        for key in ['ts_diam','z_max_clear','ts_x','ts_y','ts_z','ts_max','tool_diameter']:
+            val = str(self[key])
+            if val == 'NONE': val = None
+            self.send_dict.update( {key: val} )
 
     def check_probe(self):
         try: