from pyri.device_manager_client import DeviceManagerClient from RobotRaconteur.Client import * import time d = DeviceManagerClient('rr+tcp://localhost:59902?service=device_manager', autoconnect=False) d.refresh_devices(1) d.connect_device('jog_joint') jog_service = d.get_device_client("jog_joint", 1) print(jog_service.device_info.device.name) tool = jog_service.get_tool("tool") while (True): tool.open() time.sleep(0.5) tool.close() time.sleep(0.5)
imgs = [] for i in range(img_count): p = source_dir.joinpath(f"{img_name_prefix}{i}{img_name_ext}") imgs.append(cv2.imread(str(p))) # for img in imgs: # cv2.imshow("",img) # cv2.waitKey(250) d = DeviceManagerClient('rr+tcp://localhost:59902?service=device_manager', autoconnect=False) d.refresh_devices(1) d.connect_device("variable_storage") var_storage = d.get_device_client("variable_storage", 1) image_util = ImageUtil(client_obj=var_storage) var_consts = var_storage.RRGetNode().GetConstants('tech.pyri.variable_storage', var_storage) variable_persistence = var_consts["VariablePersistence"] variable_protection_level = var_consts["VariableProtectionLevel"] def save_image(img, i): global_name = f"{seq_name}_{i}" if len(var_storage.filter_variables("globals", global_name, [])) > 0:
from pyri.device_manager_client import DeviceManagerClient from RobotRaconteur.Client import * from RobotRaconteurCompanion.Util.ImageUtil import ImageUtil import time import cv2 d = DeviceManagerClient('rr+tcp://localhost:59902?service=device_manager', autoconnect=False) d.refresh_devices(1) d.connect_device("vision_camera_calibration") calibration_service = d.get_device_client("vision_camera_calibration", 1) ret = calibration_service.calibrate_camera_intrinsic( "camera", "intrinsic_calib_dataset0", "chessboard", "camera_intrinsic_calibration") #"camera_intrinsic_calibration") image_util = ImageUtil(client_obj=calibration_service) i = 0 for c_img in ret.display_images: img = image_util.compressed_image_to_array(c_img) cv2.imshow(f"img {i}", img) cv2.waitKey() i += 1 cv2.destroyAllWindows()
def new_frame(pipe_ep): global current_compressed_frame while (pipe_ep.Available > 0): compressed_image=pipe_ep.ReceivePacket() current_compressed_frame=compressed_image d = DeviceManagerClient('rr+tcp://localhost:59902?service=device_manager', autoconnect=False) d.refresh_devices(1) d.connect_device("vision_camera_viewer") viewer_service = d.get_device_client("vision_camera_viewer",1) print(viewer_service.device_info.device.name) camera_viewer = viewer_service.get_camera_viewer("camera") p=camera_viewer.preview_stream.Connect(-1) p.PacketReceivedEvent+=new_frame while True: if (not current_compressed_frame is None): img = cv2.imdecode(current_compressed_frame.data,1)
from pyri.device_manager_client import DeviceManagerClient from RobotRaconteur.Client import * import time from RobotRaconteurCompanion.Util.ImageUtil import ImageUtil from RobotRaconteurCompanion.Util.GeometryUtil import GeometryUtil import cv2 roi_name = "pick_roi4" template_name = "perfume_template3" d = DeviceManagerClient('rr+tcp://localhost:59902?service=device_manager', autoconnect=False) d.refresh_devices(1) d.connect_device("vision_template_matching") d.connect_device("variable_storage") c = d.get_device_client("vision_template_matching", 1) bounding_box2d_type = RRN.GetStructureType( 'com.robotraconteur.geometry.BoundingBox2D', c) named_pose2d_type = RRN.GetStructureType( 'com.robotraconteur.geometry.NamedPose2D', c) pose2d_dtype = RRN.GetNamedArrayDType('com.robotraconteur.geometry.Pose2D', c) var_storage = d.get_device_client("variable_storage", 1) roi = var_storage.getf_variable_value("globals", roi_name).data #res = c.match_template_stored_image("extrinsic_image0", "test10", None)
from pyri.device_manager_client import DeviceManagerClient from RobotRaconteur.Client import * import time from RobotRaconteurCompanion.Util.ImageUtil import ImageUtil from RobotRaconteurCompanion.Util.GeometryUtil import GeometryUtil import cv2 import numpy as np d = DeviceManagerClient('rr+tcp://localhost:59902?service=device_manager', autoconnect=False) d.refresh_devices(1) d.connect_device("robotics_motion") c = d.get_device_client("robotics_motion", 1) geom_util = GeometryUtil(client_obj=c) def _run_grab(gen): while True: try: res = gen.Next() print(res) except RR.StopIterationException: break for i in range(5): pose2d_dtype = RRN.GetNamedArrayDType("com.robotraconteur.geometry.Pose2D",
from pyri.device_manager_client import DeviceManagerClient from RobotRaconteur.Client import * d = DeviceManagerClient('rr+tcp://localhost:59902?service=device_manager', autoconnect=False) d.refresh_devices(1) d.connect_device("sandbox") c = d.get_device_client("sandbox",1) gen = c.getf_output() while True: try: ret = gen.Next() print([l.output for l in ret.output_list]) except RR.StopIterationException: break # gen = c.execute_procedure("test_print_many", []) # while True: # try: # print(gen.Next().printed) # except RR.StopIterationException: # break
class PyriWebUIBrowser: def __init__(self, loop: "RobotRaconteur.WebLoop", config: Dict[str, Any]): self._loop = loop self._config = config self._layout = PyriGoldenLayout(self) self._seqno = 0 self._device_manager = DeviceManagerClient(fill_rr_url_template( config["device_manager_url"]), autoconnect=False, tcp_ipv4_only=True) self._devices_states_obj_sub = None self._devices_states_wire_sub = None self._devices_states_value = None self._device_infos = dict() self._device_infos_update_running = False def set_devices_states(state, devices_states): state.devices_states = devices_states def set_active_device_names(state, device_names): current_devices = [] current_devices_js = state.active_device_names for i in range(current_devices_js.length): current_devices.append(current_devices_js[i]) if set(current_devices) != set(device_names): state.active_device_names = device_names def set_device_infos(state, device_infos): state.device_infos = device_infos @property def loop(self): return self._loop def create_task(self, task): async def create_task_w(): await task self._loop.create_task(create_task_w()) @property def layout(self): return self._layout @property def seqno(self): return self._seqno @property def device_manager(self): return self._device_manager async def load_plugin_panels(self): all_panels_u = get_all_webui_browser_panels_infos() all_panels = dict() for u in all_panels_u.values(): all_panels.update(u) all_panels_sorted = sorted(all_panels.values(), key=lambda x: x.priority) for p in all_panels_sorted: await add_webui_browser_panel(p.panel_type, self, self._layout.layout_container) async def run(self): try: print("Running PyRI WebUI Browser") self._layout.init_golden_layout() js.jQuery.find("#menuContainer")[0].removeAttribute('hidden') await self.load_plugin_panels() for i in range(100): if i > 50: js.window.alert( "Could not connect to devices states service") return if "devices_states" in self._device_manager.get_device_names(): break await RRN.AsyncSleep(0.1, None) await self.update_devices() self._device_manager.connect_device("variable_storage") self._device_manager.connect_device("devices_states") self._device_manager.connect_device("sandbox") self._device_manager.connect_device("program_master") self._devices_states_obj_sub = self._device_manager.get_device_subscription( "devices_states") # Run infinite update loop self._layout.select_panel("welcome") while True: await RRN.AsyncSleep(0.1, None) await self.update() except: traceback.print_exc() async def update(self): try: self._seqno += 1 if self._seqno % 150 == 0: self.create_task(self.update_devices()) res, devices_states_obj = self._devices_states_obj_sub.TryGetDefaultClient( ) #print(f"devices states TryGetDefaultClient res: {res} {devices_states_obj}") if res: try: devices_states, _ = await devices_states_obj.devices_states.AsyncPeekInValue( None) except: traceback.print_exc() res = False if res: self._devices_states_value = devices_states self._update_device_infos(devices_states) else: self._devices_states_value = None except: traceback.print_exc() async def update_devices(self): try: await RRN.AsyncSleep(0.02, None) await self._device_manager.async_refresh_devices(1) except: traceback.print_exc() @property def devices_states(self): return self._devices_states_value @property def active_device_names(self): try: return list(self._devices_states_value.devices_states.keys()) except AttributeError: return [] @property def device_infos(self): return self._device_infos def _update_device_infos(self, devices_states): try: if self._device_infos_update_running: return update_devices = [] for d in devices_states.devices_states.keys(): if d not in self._device_infos: self._device_infos[d] = dict() if len(self._device_infos[d]) != 3: update_devices.append(d) if len(update_devices) > 0: self.create_task(self._do_update_device_infos(update_devices)) except: traceback.print_exc() async def _do_update_device_infos(self, local_device_names): try: self._device_infos_update_running = True states_connected, states = self._devices_states_obj_sub.TryGetDefaultClient( ) for d in local_device_names: if not "device_info" in self._device_infos[d]: self._device_infos[d][ "device_info"] = self._device_manager.get_device_info( d) if self._devices_states_value.devices_states[ d].connected and states_connected: if not "standard_info" in self._device_infos[d]: try: self._device_infos[d][ "standard_info"] = await states.async_getf_standard_device_info( d, None) except: traceback.print_exc() if not "extended_info" in self._device_infos[d]: try: self._device_infos[d][ "extended_info"] = await states.async_getf_extended_device_info( d, None) except: traceback.print_exc() finally: self._device_infos_update_running = False
from pyri.device_manager_client import DeviceManagerClient from RobotRaconteur.Client import * import time from RobotRaconteurCompanion.Util.ImageUtil import ImageUtil from RobotRaconteurCompanion.Util.GeometryUtil import GeometryUtil import numpy as np import cv2 d = DeviceManagerClient('rr+tcp://localhost:59902?service=device_manager', autoconnect=False) d.refresh_devices(1) d.connect_device("vision_robot_calibration") calibration_service = d.get_device_client("vision_robot_calibration", 1) geom_util = GeometryUtil(client_obj=calibration_service) marker_pose = geom_util.xyz_rpy_to_pose( np.array([0.0393, -0.0091, 0.055]), np.array(np.deg2rad([90.0, 0.0, 180.0]))) ret = calibration_service.calibrate_robot_origin( "robot", "camera_intrinsic_calibration", "camera_extrinsic_calibration", "robot_calib0", "DICT_6X6_250", 150, 0.0316, marker_pose, "") # "robot_origin_calibration0" image_util = ImageUtil(client_obj=calibration_service) geom_util = GeometryUtil(client_obj=calibration_service) T = geom_util.named_pose_to_rox_transform(ret.robot_pose.pose)
from pyri.device_manager_client import DeviceManagerClient from RobotRaconteur.Client import * import time from RobotRaconteurCompanion.Util.ImageUtil import ImageUtil from RobotRaconteurCompanion.Util.GeometryUtil import GeometryUtil import cv2 import numpy as np d = DeviceManagerClient('rr+tcp://localhost:59902?service=device_manager', autoconnect=False) d.refresh_devices(1) d.connect_device("vision_aruco_detection") c = d.get_device_client("vision_aruco_detection",1) geom_util = GeometryUtil(client_obj = c) b = RRN.NewStructure("com.robotraconteur.geometry.BoundingBox2D", c) center = RRN.NewStructure("com.robotraconteur.geometry.NamedPose2D", c) pose2d_dtype = RRN.GetNamedArrayDType("com.robotraconteur.geometry.Pose2D", c) size2d_dtype = RRN.GetNamedArrayDType("com.robotraconteur.geometry.Size2D", c) center.pose = np.zeros((1,),dtype=pose2d_dtype) center.pose[0]["position"]["x"] = 990 center.pose[0]["position"]["y"] = 64 center.pose[0]["orientation"] = np.deg2rad(10) b.center = center size = np.zeros((1,),dtype=size2d_dtype) size[0]["width"] = 100 size[0]["height"] = 100 b.size = size
from pyri.device_manager_client import DeviceManagerClient from RobotRaconteur.Client import * import time import traceback import os print(os.getpid()) input() d = DeviceManagerClient('rr+tcp://localhost:59902?service=device_manager', autoconnect=False) d.refresh_devices(1) d.connect_device('devices_states') dev_states_sub = d.get_device_subscription("devices_states") dev_states_wire_sub = dev_states_sub.SubscribeWire('devices_states') while True: try: print(dev_states_wire_sub.InValue.seqno) except: traceback.print_exc() time.sleep(0.1)
from RobotRaconteur.Client import * from RobotRaconteurCompanion.Util.UuidUtil import UuidUtil import uuid from pyri.device_manager_client import DeviceManagerClient from RobotRaconteur.Client import * import numpy as np import time d = DeviceManagerClient('rr+tcp://localhost:59902?service=device_manager', autoconnect=False) d.refresh_devices(1) d.connect_device("program_master") c = d.get_device_client("program_master",1) c.run() time.sleep(4.1) c.pause() time.sleep(1) c.clear_step_pointer()
from pyri.device_manager_client import DeviceManagerClient from RobotRaconteur.Client import * import time import traceback import os print(os.getpid()) input() d = DeviceManagerClient('rr+tcp://localhost:59902?service=device_manager', autoconnect=False) d.refresh_devices(1) d.connect_device('joint_jog') jog_sub = d.get_device_subscription("jog_joint") i = 0 dir = 0 while True: i += 1 if i > 20: i = 0 elif i > 10: dir = -1 else: dir = 1
from pyri.device_manager_client import DeviceManagerClient from RobotRaconteur.Client import * d = DeviceManagerClient('rr+tcp://localhost:59902?service=device_manager', autoconnect=False) d.refresh_devices(1) d.connect_device('robotics_jog') jog_service = d.get_device_client("robotics_jog",1) print(jog_service.device_info.device.name) jog = jog_service.get_jog("robot") jog.setf_jog_mode() #for x in range(100): #jog.jog_joints3(1,1) #jog.setf_halt_mode() jog.jog_joints_to_angles([0.1,0.1,-0.1,0.1,-0.1,0.2],50)