fix:1.blockly fixes errors in counter and mechanical claw controls;2.Add slide rail stop operation when error is reported;3.Blockly's modbus tcp control is changed to hexadecimal output

Author: SchoolMater

xarm/tools/blockly/_blockly_base.py

@@ -202,18 +202,19 @@ def _get_condition_expression(self, value_block, arg_map=None):
             cmd_li = re.sub('\s+', ' ', cmd_li)
             cmd_li = cmd_li.strip().split(' ')
             int_li = [int(da, 16) for da in cmd_li]
-            return 'self._arm.getset_tgpio_modbus_data({}, host_id={})'.format(int_li, host_id)
+            return '[data if isinstance(data, int) else [hex(da).split("0x")[1].upper().zfill(2) for da in data] for ' \
+                   'data in self._arm.getset_tgpio_modbus_data({}, host_id={})]'.format(int_li, host_id)
         elif block.attrib['type'] == 'get_gripper_status':
             fields = self._get_nodes('field', root=block)
             timeout = fields[0].text
-            return '0 == self._arm.arm.check_gripper_status()[1]'
+            return '0 == self._arm.arm.check_gripper_status()'
         elif block.attrib['type'] == 'get_ft_sensor':
             direction_li = ['Fx', 'Fy', 'Fz', 'Tx', 'Ty', 'Tz']
             fields = self._get_nodes('field', root=block)
             direction = fields[0].text
             return 'self._arm.get_joints_torque()[1][{}]'.format(direction_li.index(direction))
         elif block.attrib['type'] == 'get_counter':
-            return 'self._arm.count()'
+            return 'str(self._arm.count)'
 
 
     def __get_logic_compare(self, block, arg_map=None):

xarm/tools/blockly/_blockly_handler.py

@@ -34,6 +34,8 @@ def __init__(self, xml_path):
         self._cgpio_digital_callbacks = []
         self._cgpio_analog_callbacks = []
         self._count_callbacks= []
+
+        self.is_run_linear_track = False
 
     def _append_init_code(self, code):
         self._init_code_list.append(code)
@@ -263,6 +265,33 @@ def _handle_move_cartesian_var(self, block, indent=0, arg_map=None):
         self._append_main_code('if not self._check_code(code, \'set_position\'):', indent + 2)
         self._append_main_code('    return', indent + 2)
 
+    def _handle_move_circle_var(self, block, indent=0, arg_map=None):
+        values = self._get_nodes('value', root=block)
+        percent = self._get_block_val(values[2], arg_map=arg_map)
+        wait = self._get_block_val(values[3], arg_map=arg_map)
+        if wait == 'TRUE' or wait == 'FALSE':
+            wait = wait == 'TRUE'
+        
+        pose1_block= self._get_node('block', root=values[0])
+        pose1_nodes = self._get_nodes('value', root=pose1_block)
+        pose1 = []
+        for val_node in pose1_nodes:
+            val = self._get_condition_expression(val_node, arg_map=arg_map)
+            pose1.append(val)
+
+        pose2_block = self._get_node('block', root=values[1])
+        pose2_nodes = self._get_nodes('value', root=pose2_block)
+        pose2 = []
+        for val_node in pose2_nodes:
+            val = self._get_condition_expression(val_node, arg_map=arg_map)
+            pose2.append(val)
+
+        pose1 = '[{}]'.format(', '.join(pose1))
+        pose2 = '[{}]'.format(', '.join(pose2))
+        self._append_main_code('code = self._arm.move_circle({}, {}, float({}) / 360 * 100, speed=self._tcp_speed, mvacc=self._tcp_acc, wait={})'.format(pose1, pose2, percent, wait), indent + 2)
+        self._append_main_code('if not self._check_code(code, \'move_circle\'):', indent + 2)
+        self._append_main_code('    return', indent + 2)
+
     def _handle_move_axis_angle(self, block, indent=0, arg_map=None):
         fields = self._get_nodes('field', root=block)
         values = []
@@ -772,7 +801,7 @@ def __handle_count_event(self, count_type, block, indent=0, arg_map=None):
         self._count_callbacks.append(name)
         self._append_main_code(
             'self._count_callbacks.append({{\'trigger\': {}, \'op\': \'{}\', \'callback\': self.{}}})'.format(
-                 trigger, op, name), indent=indent + 2)
+                 trigger, '==' if op == '=' else op, name), indent=indent + 2)
 
     def _handle_event_get_counter_condition(self, block, indent=0, arg_map=None):
         self.__handle_count_event('get_counter', block, indent, arg_map=arg_map)
@@ -1018,6 +1047,7 @@ def _handle_controls_if(self, block, indent=0, arg_map=None):
                 break
 
     def _handle_set_line_track(self, block, indent=0, arg_map=None):
+        self.is_run_linear_track = True
         fields = self._get_nodes('field', root=block)
         if fields is None:
             values = self._get_nodes('value', root=block)

xarm/tools/blockly/_blockly_tool.py

@@ -312,17 +312,17 @@ def __define_listen_count_thread_func(self):
         if self._listen_count or len(self._count_callbacks):
             self._append_main_init_code('    def _listen_count_thread(self):')
             if self._listen_count or len(self._count_callbacks):
-                self._append_main_init_code('        values = self._arm.count()')
+                self._append_main_init_code('        values = self._arm.count')
 
             self._append_main_init_code('        while self.alive:')
 
-            self._append_main_init_code('            values = self._arm.count()')
+            self._append_main_init_code('            values = self._arm.count')
             self._append_main_init_code(
                 '            if self._counter_val is not None and self._counter_val != values:')
             if self._listen_count or len(self._count_callbacks):
                 self._append_main_init_code('                for item in self._count_callbacks:')
                 self._append_main_init_code(
-                    '                        if eval(\'{} {} {}\'.format(values, item[\'op\'], item[\'trigger\'])) and not eval(\'{} {} {}\'.format(self._counter_val, item[\'op\'], item[\'trigger\'])):')
+                    '                    if eval(\'{} {} {}\'.format(values, item[\'op\'], item[\'trigger\'])) and not eval(\'{} {} {}\'.format(self._counter_val, item[\'op\'], item[\'trigger\'])):')
                 self._append_main_init_code('                            self._callback_que.put(item[\'callback\'])')
             self._append_main_init_code('            self._counter_val = values')
             self._append_main_init_code('            time.sleep(0.01)\n')
@@ -356,6 +356,8 @@ def __define_error_warn_changed_callback_func(self, error_exit=True):
             self._append_main_init_code('        if data and data[\'error_code\'] != 0:')
             self._append_main_init_code('            self.alive = False')
             self._append_main_init_code('            self.pprint(\'err={}, quit\'.format(data[\'error_code\']))')
+            if self.is_run_linear_track:
+                self._append_main_init_code('            self._arm.set_linear_track_stop()')
             self._append_main_init_code('            self._arm.release_error_warn_changed_callback(self._error_warn_changed_callback)\n')
 
     def __define_state_changed_callback_func(self, stop_exit=True):

xarm/version.py

@@ -1 +1 @@
-__version__ = '1.13.26'
+__version__ = '1.13.27'

xarm/x3/gripper.py

@@ -425,7 +425,7 @@ def __check_gripper_position(self, target_pos, timeout=None):
             time.sleep(0.2)
         return code
 
-    def __check_gripper_status(self, timeout=None):
+    def check_gripper_status(self, timeout=None):
         start_move = False
         not_start_move_cnt = 0
         failed_cnt = 0
@@ -486,7 +486,7 @@ def _set_modbus_gripper_position(self, pos, wait=False, speed=None, auto_enable=
         ret[0] = self._check_modbus_code(ret, only_check_code=True)
         if wait and ret[0] == 0:
             if self.gripper_is_support_status:
-                return self.__check_gripper_status(timeout=timeout)
+                return self.check_gripper_status(timeout=timeout)
             else:
                 return self.__check_gripper_position(pos, timeout=timeout)
         return ret[0]