def init_direction_service_client(self, service_name = "/crash_direction_service"):
rospy.loginfo('Waiting for Service Server')
rospy.wait_for_service(service_name)
rospy.loginfo('Service Server Found...')
# create the connection to the service
self._direction_service = rospy.ServiceProxy(service_name, Trigger)
self._request_object = TriggerRequest()
def __init__(self):
# Initialize the client for the obstacle_detect_srv server
rospy.logdebug("obstacle_detect_client.py : Client initialized.")
rospy.wait_for_service("detect_obs_server")
self.obsClient = rospy.ServiceProxy('detect_obs_server', Trigger)
self.obsRequest = TriggerRequest()
def run(self): req = TriggerRequest() if self.sensor_states[self.BUTTON_G1] == True: self.trigger_button_g1(req) if self.sensor_states[self.BUTTON_R1] == True: self.trigger_button_r1(req) if self.sensor_states[self.BUTTON_G2] == True: self.trigger_button_g2(req) if self.sensor_states[self.BUTTON_R2] == True: self.trigger_button_r2(req) req_state = SetBoolRequest() req_state.data = self.sensor_states[self.CELL_1] self.state_cell_1(req_state) req_state.data = self.sensor_states[self.CELL_2] self.state_cell_2(req_state) req_state.data = self.sensor_states[self.CELL_3] self.state_cell_3(req_state)
def delete_map(self):
_str = StringRequest()
_str.str = self.map_list_widget.currentItem().text().split(
".")[0].strip()
try:
trig_resp = self.list_maps_srv.call(TriggerRequest())
except Exception as e:
rospy.logwarn_throttle(10, "failed to fetch maps: {}".format(e))
return
current_item = self.map_list_widget.currentItem()
self.localization_button.setEnabled(current_item is not None)
if trig_resp.success:
remote_maps = str(trig_resp.message).split(",")
if (_str.str == 'default_map'):
rospy.logwarn_throttle(10, "The default map cannot be deleted")
self.msg_to_show = "The default_map cannot be deleted."
self.message_popup()
elif (_str.str == self.loaded_map_name):
rospy.logwarn_throttle(10, "Map cannot be deleted")
self.msg_to_show = "'" + self.loaded_map_name + "' cannot be deleted while loaded."
self.message_popup()
else:
trig_resp = self.delete_map_srv.call(_str)
rospy.loginfo(trig_resp.message)
if not trig_resp.success:
rospy.logerr("Failed calling slam delete map service")
def _shooter_reset_helper(self, event):
'''
Used to actually call the shooter's reset service.
'''
rospy.loginfo("Reseting the shooter service")
self.shooter_reset_client(TriggerRequest())
rospy.loginfo("In New York you can be a new man! In New York you can be a new man!")
def undock(self):
self.power_on()
res = self._srv_client_undock(TriggerRequest())
if not self.is_powered_on():
self.power_on()
if not self.is_standing():
self.stand()
return res.success, res.message
def test_0_call_service(self):
resp = self.client.move_random()
self.assert_last_srv_call_failed(resp,
RLLErrorCode.SERVICE_CALL_NOT_ALLOWED)
# robot ready should be allowed even outside project run
resp = self.robot_ready_service.call(TriggerRequest())
self.assertTrue(resp)
def __init__(self):
service_name = Services.CRASH_DETECTION_SERVER.value
rospy.loginfo('Robot waiting for ' + service_name)
rospy.wait_for_service(service_name)
rospy.loginfo('Found!')
self.request = TriggerRequest()
self.connection = rospy.ServiceProxy(service_name, Trigger)
def user_presence_cb(self, data):
if data.data: # user is presented
self.time_user_disappeared = None
if self.time_user_appeared is None: # user just arrived
self.time_user_appeared = rospy.Time.now()
if not self.program_is_paused:
resp = self.pause_program_client.call(TriggerRequest())
if not resp.success:
rospy.logerr(
"Failed to pause program!") # TODO: what to do?
self.program_is_paused = True
elif self.program_is_running and (
rospy.Time.now() -
self.time_user_appeared) > rospy.Duration(2):
# user is at least 2 seconds in front of the table -> stop program
resp = self.stop_program_client.call(TriggerRequest())
if not resp.success:
rospy.logerr(
"Failed to stop program!") # TODO: what to do?
self.program_is_running = False
self.program_is_paused = False
else:
self.time_user_appeared = None
if self.time_user_disappeared is None:
self.time_user_disappeared = rospy.Time.now()
if self.program_is_paused and self.program_is_running:
resp = self.resume_program_client.call(TriggerRequest())
if not resp.success:
rospy.logerr(
"Failed to resume program!") # TODO: what to do?
self.program_is_paused = False
elif not self.program_is_running:
resp = self.start_program_client.call(
ProgramIdTriggerRequest(program_id=self.demo_program))
if not resp.success:
rospy.logerr("Demo program could not be launched!")
self.program_is_running = True
self.program_is_paused = False
elif (rospy.Time.now() - self.time_user_disappeared
) > rospy.Duration(2) and not self.program_is_running:
resp = self.start_program_client.call(
ProgramIdTriggerRequest(program_id=self.demo_program))
if not resp.success:
rospy.logerr("Demo program could not be launched!")
self.program_is_running = True
self.program_is_paused = False
def init_direction_service_client(self):
self.service_name = "/get_direction_message_service"
rospy.loginfo(
"Waiting for service '/get_direction_message_service'...")
rospy.wait_for_service(self.service_name)
rospy.loginfo("Found service '/get_direction_message_service'...")
self.service_client = rospy.ServiceProxy(self.service_name, Trigger)
self.service_request = TriggerRequest()
def setup(self, timeout=10.0):
self.object_state_sub = rospy.Subscriber(self.object_state_topic,
ObjectStateArray,
self.cb,
queue_size=1)
self.get_update_srv = rospy.ServiceProxy(
u'/object_state_publisher/update_object_positions', Trigger)
self.get_update_srv.call(TriggerRequest())
super(KnowrobPlugin, self).setup(timeout)
def interaction_off(self):
if self.interaction_off_client is None:
return ArtBrainErrorSeverities.ERROR, ArtBrainErrors.ERROR_NOT_IMPLEMENTED
resp = self.interaction_off_client.call(
TriggerRequest()) # type: TriggerResponse
if resp.success:
return None, None
else:
return ArtBrainErrorSeverities.WARNING, ArtBrainErrors.ERROR_LEARNING_GRIPPER_INTERACTION_MODE_SWITCH_FAILED
def init_direction_service_client(self, service_name="/move_sphero"):
rospy.loginfo('Waiting for Service Server')
rospy.wait_for_service(
service_name
) # wait for the service client /gazebo/delete_model to be running
rospy.loginfo('Service Server Found...')
self._direction_service = rospy.ServiceProxy(
service_name, Trigger) # create the connection to the service
self._request_object = TriggerRequest()
def trigger_client():
rospy.wait_for_service('trigger_save')
try:
trig = rospy.ServiceProxy('trigger_save', Trigger)
req = TriggerRequest()
res = trig(req)
return res
except rospy.ServiceException as e:
print("Service call failed: %s" % e)
def request_holding_mode(self):
"""Switch into HOLDING mode by sending the respective request.
:return: True if service request was handled successful, False otherwise
"""
req = TriggerRequest()
resp = self._hold_srv(req)
return resp.success
def request_default_mode(self):
"""Switch into DEFAULT mode by sending the respective request.
:return: True if service request was handled successful, False otherwise.
"""
req = TriggerRequest()
resp = self._unhold_srv(req)
return resp.success
def shooter_cancel(self, *args, **kwargs):
'''
Cancels the process that the shooter action client is currently
running.
'''
rospy.loginfo("Canceling shooter requests")
self.shooter_cancel_client(TriggerRequest())
rospy.loginfo("I imaging death so much it feels more like a memory.")
rospy.loginfo("When's it gonna get me? While I'm blocked? Seven clocks ahead of me?")
def move_to_user(self):
if self.move_to_user_client is None:
return ArtBrainErrorSeverities.ERROR, ArtBrainErrors.ERROR_NOT_IMPLEMENTED
resp = self.move_to_user_client.call(
TriggerRequest()) # type: TriggerResponse
if resp.success:
return None, None
else:
return ArtBrainErrorSeverities.WARNING, ArtBrainErrors.ERROR_GRIPPER_MOVE_FAILED
def init_direction_service_client(self):
rospy.loginfo('Waiting for Service Server')
# Wait for the service client /crash_direction_service to be running
rospy.wait_for_service('/crash_direction_service')
rospy.loginfo('Service Server Found...')
# Create the connection to the service
self._dir_srv_cleint = rospy.ServiceProxy('/crash_direction_service', Trigger)
# Create an msg request object
self._dir_srv_cleint_msg_rqst = TriggerRequest()
def init_crash_dir_service_client(self,
service_name="/crash_service_server"):
rospy.loginfo("Waiting for service: " + service_name)
rospy.wait_for_service(
service_name
) # wait for the service client /gazebo/delete_model to be running
rospy.loginfo("Service: " + service_name + "is available now...")
self.direction_service = rospy.ServiceProxy(
service_name, Trigger) # create the connection to the service
self.request_object = TriggerRequest()
def next_waypoint(self):
try:
trig_resp = self.next_waypoint_srv.call(TriggerRequest())
rospy.loginfo(trig_resp.message)
if not trig_resp.success:
msg = "Failed to call '" + self.next_waypoint_srv_name + "' service"
rospy.logerr(msg)
except:
msg = "Service '" + self.next_waypoint_srv_name + "' unavailable"
rospy.logwarn(msg)
def run_mapping(self):
trig_resp = self.launch_mapping_srv.call(TriggerRequest())
if trig_resp.success:
rospy.loginfo(trig_resp.message)
self.mode_label.setText("Mapping")
self.loaded_map_label.setText("")
self.loaded_map_name = ""
else:
rospy.logerr("Failed calling slam_launch_mapping_srv")
def stop_recording(self):
try:
trig_resp = self.stop_recording_srv.call(TriggerRequest())
rospy.loginfo(trig_resp.message)
if not trig_resp.success:
msg = "Failed to call '" + self.stop_mission_srv_name + "' service"
rospy.logerr(msg)
except:
msg = "Service '" + self.stop_mission_srv_name + "' unavailable"
rospy.logwarn(msg)
def update_kill_status(self, alarm):
'''
Updates the kill status display when there is an update on the kill
alarm.
'''
if (alarm.clear and self.killed):
self.killed = False
elif (not self.killed) and (not alarm.clear):
self.cancel_callback(TriggerRequest())
self.killed = True
def trigger_shot(self, request):
# Generate Image Filename and Path to the file
img_file = self.save_path + "obstruction_" + time.strftime(
"%Y-%m-%d-%H-%M-%S") + ".jpg"
cv2.imwrite(img_file, self.cv_image)
if (self.report_to_web == True):
sos = TriggerRequest()
self.sos_service(sos)
return TriggerResponse(
success=True,
message="Obstacle Image has screenshot and located at " + img_file)
def execute_unfill_bins(self, userdata):
# try to call the service
try:
req = TriggerRequest()
response = self.service.call(req)
rospy.loginfo('All bins have been unfilled')
return 'succeeded'
except Exception, e:
rospy.logerr('Service call to unfill_bins failed. Reason: \n %s' %
e)
return 'failed'
def epm_client():
#print("Waiting for /toggle_epm Arduino Service")
rospy.wait_for_service('/toggle_epm')
#print("//toggle_epm service detected")
try:
epm_service = rospy.ServiceProxy('/pb_status', Trigger)
epm = TriggerRequest();
res=epm_service(epm);
return res.success
except rospy.ServiceException, e:
print ("Service call failed: {}".format(e))
def switch_to_localization(self):
trig_resp = self.kill_nodes_srv.call(TriggerRequest())
if trig_resp.success:
rospy.loginfo(trig_resp.message)
temp_timer = rospy.Timer(
rospy.Duration(.1),
lambda _: self.waitTillDead_and_execute(self.run_localization),
oneshot=True)
else:
rospy.logerr("Failed calling slam_killnodes_srv")
def pb_client():
#print("Waiting for /pb_status Arduino Service")
rospy.wait_for_service('/pb_status')
#print("/pb_status service detected")
try:
pb_service = rospy.ServiceProxy('/pb_status', Trigger)
pb = TriggerRequest();
res=pb_service(pb);
return res.success
except rospy.ServiceException, e:
print ("Service call failed: {}".format(e))
def on_enter(self, userdata):
# This method is called when the state becomes active, i.e. a transition from another state to this one is taken.
# It is primarily used to start actions which are associated with this state.
# The following code is just for illustrating how the behavior logger works.
# Text logged by the behavior logger is sent to the operator and displayed in the GUI.
try:
self._srv_result = self._srv.call(self._srv_topic,
TriggerRequest())
except Exception as e:
Logger.logwarn('Failed to send service call:\n%s' % str(e))
self._failed = True