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