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)
