def send_plan():
cnh.Buffer().clear_reached_poses()
# send plan
if len(pc.PathContainer()) > 0:
sel_robot_id = bpy.context.scene.selected_robot_props.prop_robot_id
r = robot.RobotSet().getRobot(sel_robot_id)
pose_robot = r.pose
poses_list = pc.PathContainer().poses
robot_obj = bpy.data.objects[r.name]
area_robot_obj = bpy.data.objects[r.area_name]
if pose_robot != poses_list[0]:
collide = pathEditor.is_colliding(sel_robot_id, robot_obj,
area_robot_obj,
pose_robot,
poses_list[0])
if collide:
self.report({
"ERROR"
}, "Collision : robot cannot be moved to the indicated start position"
)
return
# Comprobar colision para el resto de poses de la ruta
for pose_index in range(len(poses_list) - 1):
collide = pathEditor.is_colliding(
sel_robot_id, robot_obj, area_robot_obj,
poses_list[pose_index], poses_list[pose_index + 1])
if collide:
self.report(
{"ERROR"},
"Collision: robot cannot execute current path")
return
bpy.context.scene.com_props.prop_last_sent_packet += 1
pid = bpy.context.scene.com_props.prop_last_sent_packet
status = cnh.ConnectionHandler().send_plan(pid, poses_list)
self.report({"INFO"},
"Plan was sent" if status == len(poses_list) else
"Plan fail {0}".format(status))
if status == len(poses_list):
com_props.prop_last_sent_packet += 1
pid = com_props.prop_last_sent_packet
cnh.ConnectionHandler().send_start_plan(pid)
com_props.prop_running_nav = True
com_props.prop_paused_nav = False
else:
self.report({
"ERROR"
}, "There is not plan created : Please, design a plan to execute"
)
# update path status
context.scene.com_props.prop_last_path_update = pc.PathContainer(
).getLastUpdate()
def execute(self, context):
import datetime as dt
date = str(dt.datetime.now())
global update_time
update = update_time < pc.PathContainer().getLastUpdate()
update_time = pc.PathContainer().getLastUpdate()
log = "PathEditor | " + date + " | update = " + str(update) + " : " + str(update_time) + "\n"
log += "\tPathContainer : " + str(len(pc.PathContainer())) + "\n"
for p in pc.PathContainer().poses:
log += "\t\t" + str(p) + "\n"
log += "\tTempPathContainer : " + str(len(pc.TempPathContainer())) + "\n"
self.report({'INFO'}, log)
return {'FINISHED'}
def execute(self, context):
# poses
poses = pc.PathContainer().poses
json_poses = {'num_poses': len(poses), 'poses': []}
for p in poses:
json_poses['poses'].append({
'x': p.x,
'y': p.y,
'z': p.z,
'rx': p.alpha,
'ry': p.beta,
'rz': p.gamma,
})
# filepath
filepath_str = self.filepath
filepath = Path(filepath_str)
path = filepath.parent
name = Path(filepath.name)
if not export_poses(path, name, json_poses):
self.report({'ERROR'}, f"Cannot write in {str(path / name)}")
else:
self.report({'INFO'}, f"Exported path in {str(path / name)}")
return {'FINISHED'}
def notifyStop(self, operator):
pathContainer = pc.PathContainer()
temp = pc.TempPathContainer()
temp.pushActions()
del self.current_action
self.current_action = None
showCeil()
def notifyStart(self, operator):
bpy.context.scene.cursor.location = Vector((0.0, 0.0, 0.0))
bpy.context.scene.cursor.rotation_euler = Euler((0.0, 0.0, 0.0))
if len(robot_tools.RobotSet()) <= 0:
operator.report({'ERROR'}, 'No robot available : add a robot to create a path')
bpy.ops.scene.stop_cursor_listener('INVOKE_DEFAULT')
return
idx = bpy.context.scene.selected_robot_props.prop_robot_id
assert idx >= 0 and idx in robot_tools.RobotSet(), "Error : no robot selected or not in list"
robot = robot_tools.RobotSet().getRobot(idx)
last_action = pc.PathContainer().getLastAction()
if len(pc.PathContainer()) > 0 and last_action is not None:
# Obtenemos ultima pose como inicio para crear nuevas poses
loc = last_action.p1.loc
angle = last_action.p1.rotation
else:
loc = robot.loc + Vector((bpy.context.scene.TOL, bpy.context.scene.TOL, bpy.context.scene.TOL))
angle = robot.rotation
# Movemos el cursor a la posicion de comienzo
new_pose = path.Pose.fromVector(loc, angle)
cl.CursorListener.set_pose(new_pose)
self.current_action = path.Action(new_pose, new_pose)
if len(pc.PathContainer()) == 0:
self.current_action.set_first_action()
cl.CursorListener.select_cursor()
hideCeil()
pc.TempPathContainer().loadActions()
filepath = Path(filepath_str)
path = filepath.parent
name = Path(filepath.name)
if (json_poses := read_poses(path, name)) is None:
self.report({'ERROR'}, f"Cannot read {str(path / name)}")
else:
self.report({'INFO'}, f"Path loaded from {str(path / name)}")
poses = parse_data(json_poses)
print(poses)
if poses is None:
self.report({'ERROR'},
"Error while parsing poses. Check file content.")
else:
pc.PathContainer().loadPoses(poses, context=context)
context.window_manager.load_file = str(path / name)
return {'FINISHED'}
class ExportPosesOperator(bpy.types.Operator, ExportHelper):
bl_idname = "export.export_poses_operator"
bl_label = "Save path"
filename_ext = ".json"
filter_glob: bpy.props.StringProperty(default="*.json", options={'HIDDEN'})
@classmethod
def poll(cls, context):
def execute(self, context):
pc.PathContainer().clear()
return {'FINISHED'}
def poll(cls, context):
running_plan = context.scene.com_props.prop_running_nav
paused_plan = context.scene.com_props.prop_paused_nav
return len(pc.PathContainer()) > 0 and (not running_plan or (running_plan and paused_plan)) and not context.scene.is_cursor_active
def execute(self, context):
com_props = context.scene.com_props
path_changed = com_props.prop_last_path_update < pc.PathContainer(
).getLastUpdate()
def send_plan():
cnh.Buffer().clear_reached_poses()
# send plan
if len(pc.PathContainer()) > 0:
sel_robot_id = bpy.context.scene.selected_robot_props.prop_robot_id
r = robot.RobotSet().getRobot(sel_robot_id)
pose_robot = r.pose
poses_list = pc.PathContainer().poses
robot_obj = bpy.data.objects[r.name]
area_robot_obj = bpy.data.objects[r.area_name]
if pose_robot != poses_list[0]:
collide = pathEditor.is_colliding(sel_robot_id, robot_obj,
area_robot_obj,
pose_robot,
poses_list[0])
if collide:
self.report({
"ERROR"
}, "Collision : robot cannot be moved to the indicated start position"
)
return
# Comprobar colision para el resto de poses de la ruta
for pose_index in range(len(poses_list) - 1):
collide = pathEditor.is_colliding(
sel_robot_id, robot_obj, area_robot_obj,
poses_list[pose_index], poses_list[pose_index + 1])
if collide:
self.report(
{"ERROR"},
"Collision: robot cannot execute current path")
return
bpy.context.scene.com_props.prop_last_sent_packet += 1
pid = bpy.context.scene.com_props.prop_last_sent_packet
status = cnh.ConnectionHandler().send_plan(pid, poses_list)
self.report({"INFO"},
"Plan was sent" if status == len(poses_list) else
"Plan fail {0}".format(status))
if status == len(poses_list):
com_props.prop_last_sent_packet += 1
pid = com_props.prop_last_sent_packet
cnh.ConnectionHandler().send_start_plan(pid)
com_props.prop_running_nav = True
com_props.prop_paused_nav = False
else:
self.report({
"ERROR"
}, "There is not plan created : Please, design a plan to execute"
)
# update path status
context.scene.com_props.prop_last_path_update = pc.PathContainer(
).getLastUpdate()
if com_props.prop_running_nav:
if com_props.prop_paused_nav:
if path_changed:
send_plan()
self.report({
'INFO'
}, "Paused plan: cancel current plan and start a new plan")
hudWriter.HUDWriterOperator._textos[
RUNNING_STATUS] = SocketModalOperator.RUNNING_PLAN
else:
com_props.prop_last_sent_packet += 1
pid = com_props.prop_last_sent_packet
cnh.ConnectionHandler().send_resume_plan(pid)
com_props.prop_running_nav = True
com_props.prop_paused_nav = False
self.report({'INFO'}, "Paused plan: resume current plan")
hudWriter.HUDWriterOperator._textos[
RUNNING_STATUS] = SocketModalOperator.RUNNING_PLAN
else:
com_props.prop_last_sent_packet += 1
pid = com_props.prop_last_sent_packet
cnh.ConnectionHandler().send_pause_plan(pid)
com_props.prop_running_nav = True
com_props.prop_paused_nav = True
self.report({'INFO'}, "Running plan: pause current plan")
hudWriter.HUDWriterOperator._textos[
RUNNING_STATUS] = SocketModalOperator.PAUSED_PLAN
else:
if com_props.prop_paused_nav:
self.report({'ERROR'}, "not running and paused")
com_props.prop_running_nav = False
com_props.prop_paused_nav = False
else:
send_plan()
hudWriter.HUDWriterOperator._textos[
RUNNING_STATUS] = SocketModalOperator.RUNNING_PLAN
return {'FINISHED'}
def modal(self, context, event):
if event.type == "TIMER":
if context.scene.com_props.prop_running_nav and not context.scene.com_props.prop_paused_nav:
last_pose = pc.PathContainer().poses[-1]
reached_poses = cnh.Buffer().get_reached_poses()
num_reached_poses = len(reached_poses)
num_path_poses = len(pc.PathContainer().poses)
end_reached = cnh.Buffer().end_reached()
if num_reached_poses == num_path_poses and end_reached:
context.scene.com_props.prop_running_nav = False
context.scene.com_props.prop_paused_nav = False
if RUNNING_STATUS in hudWriter.HUDWriterOperator._textos:
del hudWriter.HUDWriterOperator._textos[RUNNING_STATUS]
if num_reached_poses != num_path_poses and end_reached:
self.report({'ERROR'}, "End reached not expected")
context.scene.com_props.prop_running_nav = False
context.scene.com_props.prop_paused_nav = False
capture_started = cnh.Buffer().capture_started()
capture_ended = cnh.Buffer().capture_ended()
if capture_started:
prop_capture_running = context.scene.com_props.prop_capture_running
if prop_capture_running:
self.report({'ERROR'}, "Capture is already started")
else:
context.scene.com_props.prop_capture_running = True
self.report({'INFO'}, "Capture started")
hudWriter.HUDWriterOperator._textos[
CAPTURE_STATUS] = SocketModalOperator.CAPTURE_ON
if capture_ended:
prop_capture_running = context.scene.com_props.prop_capture_running
if not prop_capture_running:
self.report({'ERROR'}, "Capture was not started")
else:
context.scene.com_props.prop_capture_running = False
self.report({'INFO'}, "Capture ended")
if CAPTURE_STATUS in hudWriter.HUDWriterOperator._textos:
del hudWriter.HUDWriterOperator._textos[CAPTURE_STATUS]
if not SocketModalOperator.closed and context.scene.com_props.prop_rendering:
# Render robot position
sel_robot_id = bpy.context.scene.selected_robot_props.prop_robot_id
if sel_robot_id < 0:
self.report({'ERROR'}, "No robot selected")
else:
r = robot.RobotSet().getRobot(sel_robot_id)
trace = cnh.Buffer().get_last_trace_packet()
if trace is not None:
pose = trace.pose
r.loc = Vector((pose.x, pose.y, 0))
r.rotation = Euler((0, 0, pose.gamma))
if SocketModalOperator.closed:
SocketModalOperator.switching = True
if SocketModalOperator.error != "":
self.report({'ERROR'}, self.error)
SocketModalOperator.running = False
cnh.ConnectionHandler().remove_socket()
else:
bpy.context.scene.com_props.prop_last_sent_packet += 1
new_pid = bpy.context.scene.com_props.prop_last_sent_packet
new_mode = robot_modes_summary.index("EDITOR_MODE")
initial_speed = context.scene.com_props.prop_speed
bpy.context.scene.com_props.prop_mode = robot_modes_summary.index(
"EDITOR_MODE")
if not cnh.ConnectionHandler().send_change_mode(
new_pid, new_mode, initial_speed):
self.report({
'ERROR'
}, "Changed to editor mode but not in server : ack not received"
)
SocketModalOperator.switching = False
SocketModalOperator.running = False
self.thread.join() # se espera a que acabe el hilo
cnh.ConnectionHandler().remove_socket()
self.clear_hud(context)
return {'FINISHED'}
#update_gui()
toggle_deactivate_options(
robot_modes_summary.index("EDITOR_MODE"))
SocketModalOperator.running = False
self.thread.join() # se espera a que acabe el hilo
cnh.ConnectionHandler().remove_socket()
if context.scene.is_cursor_active:
bpy.ops.scene.stop_cursor_listener()
cnh.Buffer().clear_reached_poses()
SocketModalOperator.switching = False
self.report({'INFO'}, "Socket closed")
context.scene.com_props.prop_running_nav = False
context.scene.com_props.prop_paused_nav = False
self.clear_hud(context)
return {'FINISHED'}
return {'PASS_THROUGH'}