qtvcp -improve touchoff subprogram error handling

now we get messages with context and return data to qtdragon/hd

Author: c-morley

lib/python/qtvcp/lib/touchoff_subprogram.py

@@ -18,16 +18,25 @@
 
 import sys
 import json
+import time
+import linuxcnc
 
 from PyQt5.QtCore import QObject
-from qtvcp.core import Status, Action
+from qtvcp.core import Status, Action, Info
+from qtvcp import logger
+LOG = logger.getLogger(__name__)
+
+# Force the log level for this module
+#LOG.setLevel(logger.ERROR) # One of DEBUG, INFO, WARNING, ERROR, CRITICAL
 
 STATUS = Status()
 ACTION = Action()
+INFO = Info()
 
 class TouchOffSubprog(QObject):
     def __init__(self):
         QObject.__init__(self)
+        self.timeout = 30
         # input parameters
         self.search_vel = 10.0
         self.probe_vel = 10.0
@@ -61,20 +70,33 @@ def __init__(self):
 
         self.process()
 
+    # mdi timeout setting
+    def set_timeout(self, time):
+        self.timeout = time
+
     def process(self):
         while 1:
             try:
                 cmd = sys.stdin.readline()
                 if cmd:
                     error = self.process_command(cmd)
+
+                    # block polling here. main program should start polling in their end
+                    STATUS.block_error_polling()
+
                     # error = 1 means success, error = None means ignore, anything else is an error
                     if error is not None:
                         if error != 1:
-                            sys.stdout.write("ERROR Touchoff returned with error with:{}\n".format(cmd))
+                            if type(error) == str:
+                                sys.stdout.write("ERROR Touchoff routine: {}\n".format(error))
+                            else:
+                                sys.stdout.write("ERROR Touchoff returned with error from cmd:{}\n".format(cmd))
                         else:
                             self.collect_status()
-                            sys.stdout.write("COMPLETE$" + self.string_to_send +  "\n")
-                        sys.stdout.flush()
+                            sys.stdout.write("{} COMPLETE {}\n".format(cmd.rstrip().split('$')[0], self.string_to_send))
+                    else:
+                        sys.stdout.write("COMPLETE returned FROM COMMAND:{}\n".format(cmd))
+                    sys.stdout.flush()
             except KeyboardInterrupt:
                     break
             except Exception as e:
@@ -85,7 +107,14 @@ def process(self):
     def process_command(self, cmd):
         cmd = cmd.rstrip().split('$')
         if not STATUS.is_on_and_idle(): return None
+        pre = self.prechecks()
+        if pre is not None: return pre
+
+        # start polling errors here - parent program should have blocked their polling
+        STATUS.unblock_error_polling()
+
         ACTION.CALL_MDI("G49")
+        LOG.debug('COMMAND= {}'.format(cmd))
         if cmd[0] == "touchoff":
             self.search_vel = float(cmd[1])
             self.probe_vel = float(cmd[2])
@@ -94,60 +123,141 @@ def process_command(self, cmd):
             self.z_safe_travel = float(cmd[5])
             self.z_offset = float(cmd[6])
             error = self.touchoff()
-            return error
         elif cmd[0] == "probe_z":
             parms = json.loads(cmd[1])
             self.update_data(parms)
             error = self.probe_z()
-            return error
         else:
-            return 0
+            return 'No such touchoff routine'
+        self.postreset()
+        return error
+
+    def CALL_MDI_WAIT(self, code, timeout = 5):
+        LOG.debug('MDI_WAIT_COMMAND= {}, maxt = {}'.format(code, timeout))
+        for l in code:
+            try:
+                ACTION.CALL_MDI( l )
+                result = ACTION.cmd.wait_complete(timeout)
+                # give a chance for the error message to get to stdin
+                time.sleep(.1)
+                error = STATUS.ERROR.poll()
+                if not error is None:
+                    ACTION.ABORT()
+                    LOG.debug('MDI error= {}'.format( error[1]))
+                    return error[1]
+            except Exception as e:
+                ACTION.ABORT()
+                return e
+
+            if result == -1:
+                ACTION.ABORT()
+                return 'Command timed out: ({} second)'.format(timeout)
+            elif result == linuxcnc.RCS_ERROR:
+                ACTION.ABORT()
+                return 'MDI_COMMAND_WAIT RCS error'
+
+        return 1
+
+    # need to be in the right mode - entries are in machine units
+    def prechecks(self):
+        ACTION.CALL_MDI('M70')
+        if INFO.MACHINE_IS_METRIC and STATUS.is_metric_mode():
+            return None
+        if not INFO.MACHINE_IS_METRIC and not STATUS.is_metric_mode():
+            return None
+        # record motion modes
+        if INFO.MACHINE_IS_METRIC:
+            ACTION.CALL_MDI('g21')
+        else:
+            ACTION.CALL_MDI('g20')
+        return None
+
+    # return to previous motion modes
+    def postreset(self):
+        ACTION.CALL_MDI('M72')
 
     def touchoff(self):
+        name = 'Touchoff'
         ACTION.CALL_MDI("G10 L20 P0 Z0")
-        error = self.probe_down()
-        if error == 0:
-            ACTION.CALL_MDI("G90")
-            return 0
-        ACTION.CALL_MDI("G10 L20 P0 Z{}".format(self.z_offset))
-        if ACTION.CALL_MDI_WAIT("G1 Z{} F{}".format(self.retract_distance, self.search_vel)) == -1:
+        rtn = self.probe_down()
+        if rtn != 1:
             ACTION.CALL_MDI("G90")
-            return 0
-        ACTION.CALL_MDI("G90")
+            return '{} failed: {}'.format(name, rtn)
+        cmdList = []
+        cmdList.append("G10 L20 P0 Z{}".format(self.z_offset))
+        cmdList.append("G1 Z{} F{}".format(self.retract_distance, self.search_vel))
+        cmdList.append("G90")
+        rtn = self.CALL_MDI_WAIT(cmdList, self.timeout) 
+        if rtn != 1:
+            return '{} failed: {}'.format(name, rtn)
+
         return 1
 
     def probe_z(self):
+        name = 'Probe Z 1st positioning'
         # rapid jog to first probe position
-        if ACTION.CALL_MDI_WAIT("G0 Z{}".format(self.z_safe_travel), 30) == -1: return 0
-        if ACTION.CALL_MDI_WAIT("G0 X{} Y{}".format(self.pos_x1, self.pos_y1), 30) == -1: return 0
-        if ACTION.CALL_MDI_WAIT("G0 Z{}".format(self.pos_z1), 30) == -1: return 0
+        cmdList = []
+        cmdList.append( "G0 Z{}".format(self.z_safe_travel))
+        cmdList.append( "G0 X{} Y{}".format(self.pos_x1, self.pos_y1))
+        cmdList.append( "G0 Z{}".format(self.pos_z1))
+        rtn = self.CALL_MDI_WAIT(cmdList, self.timeout) 
+        if rtn != 1:
+            return '{} failed: {}'.format(name, rtn)
+
         error = self.probe_down()
-        print('probeDown:{}\n'.format(error))
         ACTION.CALL_MDI("G90")
-        if error == 0: return 0
+        if error != 0: return error
+
         pos = STATUS.get_probed_position_with_offsets()
         self.status_z1 = float(pos[2])
+
+        name = 'Probe Z 2nd positioning'
         # rapid jog to second probe position
-        if ACTION.CALL_MDI_WAIT("G0 Z{}".format(self.z_safe_travel), 30) == -1: return 0
-        if ACTION.CALL_MDI_WAIT("G0 X{} Y{}".format(self.pos_x2, self.pos_y2), 30) == -1: return 0
-        if ACTION.CALL_MDI_WAIT("G0 Z{}".format(self.pos_z2), 30) == -1: return 0
+        cmdList=[]
+        cmdList.append("G0 Z{}".format(self.z_safe_travel))
+        cmdList.append("G0 X{} Y{}".format(self.pos_x2, self.pos_y2))
+        cmdList.append("G0 Z{}".format(self.pos_z2))
+        rtn = self.CALL_MDI_WAIT(cmdList, self.timeout) 
+        if rtn != 1:
+            return '{} failed: {}'.format(name, rtn)
+
         error = self.probe_down()
         ACTION.CALL_MDI("G90")
-        if error == 0: return 0
+        if error != 1: return error
+
         pos = STATUS.get_probed_position_with_offsets()
         self.status_z2 = float(pos[2])
-        if ACTION.CALL_MDI_WAIT("G0 Z{}".format(self.z_safe_travel), 10) == -1: return 0
+
+        s = "G0 Z{}".format(self.z_safe_travel)
+        rtn = self.CALL_MDI_WAIT([s], self.timeout) 
+        if rtn != 1:
+            return 'Probe {} failed: {}'.format(name, rtn)
+
         return 1
 
     def probe_down(self):
+        name = '1st Probe down'
         ACTION.CALL_MDI("G91")
         cmd = "G38.2 Z-{} F{}".format(self.max_probe, self.search_vel)
-        if ACTION.CALL_MDI_WAIT(cmd, 30) == -1: return 0
+        rtn = self.CALL_MDI_WAIT([cmd], self.timeout) 
+        if rtn != 1:
+            return '{} failed: {}'.format(name, rtn)
+
+        name = 'Probe retract'
         cmd = "G1 Z{} F{}".format(self.retract_distance, self.search_vel)
-        if ACTION.CALL_MDI_WAIT(cmd, 30) == -1: return 0
+        rtn = self.CALL_MDI_WAIT([cmd], self.timeout) 
+        if rtn != 1:
+            return '{} failed: {}'.format(name, rtn)
+
+        name = '2nd Probe down'
         ACTION.CALL_MDI("G4 P0.5")
         cmd = "G38.2 Z-{} F{}".format(1.1 * self.retract_distance, self.probe_vel)
-        if ACTION.CALL_MDI_WAIT(cmd, 30) == -1: return 0
+        rtn = self.CALL_MDI_WAIT([cmd], self.timeout) 
+        if rtn != 1:
+            return '{} failed: {}'.format(name, rtn)
+
+        # success
+        return 1
 
     def update_data(self, parms):
         for key in parms:

lib/python/qtvcp/qt_action.py

@@ -754,7 +754,10 @@ def SET_TEMPARARY_MESSAGE(self, msg):
         STATUS.emit('error', STATUS.TEMPARARY_MESSAGE, msg)
 
     def TOUCHPLATE_TOUCHOFF(self, search_vel, probe_vel, max_probe,
-            z_offset, retract_distance, z_safe_travel):
+            z_offset, retract_distance, z_safe_travel, rtn_method=None):
+        # if not none will be called with returned data
+        self._touchoff_return = rtn_method
+
         if self.proc is not None:
             return 0
         self.proc = QProcess()
@@ -772,6 +775,7 @@ def TOUCHPLATE_TOUCHOFF(self, search_vel, probe_vel, max_probe,
                                         str(z_safe_travel),
                                         str(z_offset))
         #print(string_to_send)
+        # block polling here, the sub program will poll now
         STATUS.block_error_polling()
         self.proc.writeData(bytes(string_to_send, 'utf-8'))
         return 1
@@ -973,28 +977,32 @@ def read_stderror(self):
     def parse_line(self, line):
         line = line.decode("utf-8")
         if "COMPLETE" in line:
-            STATUS.unblock_error_polling()
-            self.SET_DISPLAY_MESSAGE("Touchplate touchoff routine returned successfully")
-        elif "DEBUG" in line: # must set DEBUG level on LOG in top of this file
-            LOG.debug(line[line.find('DEBUG')+6:])
+            # did we get a return method to send return data to?
+            if self._touchoff_return is None:
+                self.SET_DISPLAY_MESSAGE("Touchplate touchoff routine returned successfully")
+            else:
+                # strip ugly text
+                s = line[line.find('COMPLETE ')+9:]
+                self._touchoff_return(s)
+
         # This also gets error text sent from logging of ACTION library in the subprogram
         elif "ERROR" in line:
-            STATUS.unblock_error_polling()
-            # remove preceding text
+            # remove preceding text 'ERROR'
             s = line[line.find('ERROR')+6:]
             s = s[s.find(']')+1:]
-            # remove (possible)trailing debug info
-            d = s.find('(')
-            if not d == -1:
-                s = s[:d]
             self.SET_ERROR_MESSAGE(s)
+        elif "DEBUG" in line: # must set DEBUG level on LOG in top of this file
+            LOG.debug(line[line.find('DEBUG')+6:])
 
     def touchoff_started(self):
         LOG.debug("Touchplate touchOff subprogram started with PID {}\n".format(self.proc.processId()))
 
     def touchoff_finished(self, exitCode, exitStatus):
         LOG.debug("Touchplate touchoff Process finished - exitCode {} exitStatus {}".format(exitCode, exitStatus))
         self.proc = None
+        STATUS.unblock_error_polling()
+        # clean up return method variable
+        self._touchoff_return = None
 
     #------- boiler code
 

share/qtvcp/screens/qtdragon/qtdragon_handler.py

@@ -1043,17 +1043,24 @@ def touchoff(self, selector):
         else:
             self.add_status("Unknown touchoff routine specified", CRITICAL)
             return
-        self.add_status("Touchoff to {} started".format(selector))
+
         max_probe = self.w.lineEdit_max_probe.text()
         search_vel = self.w.lineEdit_search_vel.text()
         probe_vel = self.w.lineEdit_probe_vel.text()
         retract = self.w.lineEdit_retract_distance.text()
         safe_z = self.w.lineEdit_z_safe_travel.text()
+        self.add_status("Touchoff to {} started with {} {} {} {} {} {}".format(selector,
+                search_vel, probe_vel, max_probe, 
+                z_offset, retract, safe_z))
         rtn = ACTION.TOUCHPLATE_TOUCHOFF(search_vel, probe_vel, max_probe, 
-                z_offset, retract, safe_z)
+                z_offset, retract, safe_z, self.touchoff_return)
         if rtn == 0:
             self.add_status("Touchoff routine is already running", CRITICAL)
 
+    def touchoff_return(self, data):
+        self.add_status("Touchplate touchoff routine returned successfully")
+        self.add_status("Touchplate returned: "+data, CRITICAL)
+
     def kb_jog(self, state, joint, direction, fast = False, linear = True):
         ACTION.SET_MANUAL_MODE()
         if not STATUS.is_man_mode() or not STATUS.machine_is_on():

share/qtvcp/screens/qtdragon_hd/qtdragon_hd_handler.py

@@ -1118,10 +1118,14 @@ def touchoff(self, selector):
         retract = self.w.lineEdit_retract_distance.text()
         safe_z = self.w.lineEdit_z_safe_travel.text()
         rtn = ACTION.TOUCHPLATE_TOUCHOFF(search_vel, probe_vel, max_probe, 
-                z_offset, retract, safe_z)
+                z_offset, retract, safe_z, self.touchoff_return)
         if rtn == 0:
             self.add_status("Touchoff routine is already running", WARNING)
 
+    def touchoff_return(self, data):
+        self.add_status("Touchplate touchoff routine returned successfully")
+        self.add_status("Touchplate returned:"+data, CRITICAL)
+
     def kb_jog(self, state, joint, direction, fast = False, linear = True):
         ACTION.SET_MANUAL_MODE()
         if not STATUS.is_man_mode() or not STATUS.machine_is_on():