def __init__(self, input_keys=['outcome'], output_keys=['outcome'], callbacks={}, outcomes=['succeeded']): smach.State.__init__(self, input_keys=input_keys, output_keys=output_keys, outcomes=outcomes) self._cbs = [] if callbacks: for cb in sorted(callbacks): if cb in globals(): self._cbs.append(globals()[cb]) elif cb in locals(): self._cbs.append(locals()[cb]) elif cb in dir(self): self._cbs.append(getattr(self, cb)) self._cb_input_keys = [] self._cb_output_keys = [] self._cb_outcomes = [] for cb in self._cbs: if cb and smach.has_smach_interface(cb): self._cb_input_keys.append(cb.get_registered_input_keys()) self._cb_output_keys.append(cb.get_registered_output_keys()) self._cb_outcomes.append(cb.get_registered_outcomes()) self.register_input_keys(self._cb_input_keys[-1]) self.register_output_keys(self._cb_output_keys[-1]) self.register_outcomes(self._cb_outcomes[-1])
def __init__( self, cb, topic_name, msg_type, global_timeout=None, outcomes=["failed", "preempted"], last_msg_timeout=None, input_keys=[], output_keys=[], io_keys=[], provide_self_instance=False, sleep_duration=0.05, ): if "failed" not in outcomes: outcomes.append("failed") smach.State.__init__(self, outcomes=outcomes, input_keys=input_keys, output_keys=output_keys, io_keys=io_keys) # max time since beginning self._global_timeout = global_timeout # max time since last message : will not be needed when checking if the # person grasps the hand of the robot self._last_msg_timeout = last_msg_timeout self._received_msg = None self._beginning = None self._last_msg_stamp = None self._monitor_cb = cb self._provide_self_instance = provide_self_instance self._sleep_duration = sleep_duration rospy.Subscriber(topic_name, msg_type, self.internal_callback) # this is to be able to pass userdata to the internal_callback if cb and smach.has_smach_interface(cb): self.register_input_keys(cb.get_registered_input_keys()) self.register_output_keys(cb.get_registered_output_keys()) self.register_outcomes(cb.get_registered_outcomes())
def __init__(self, name, msg_publisher, action, input_keys = ['msg', 'topic', 'rate'], output_keys = ['msg', 'topic'], callbacks = None): smach.State.__init__(self, input_keys=input_keys, output_keys=output_keys, outcomes=['succeeded', 'aborted']) # Save the state name self._name = name # Save the MsgPublisherObserver object reference self._msg_publisher = msg_publisher # Save the action self._action = action # Set up dict of parsing functions for certain message types/classes. self._msg_parsers = {"<class 'geometry_msgs.msg._Point.Point'>": parse_pointstamped, "<class 'geometry_msgs.msg._PointStamped.PointStamped'>": parse_pointstamped, "<class 'geometry_msgs.msg._Pose.Pose'>": parse_posestamped, "<class 'geometry_msgs.msg._PoseStamped.PoseStamped'>": parse_posestamped, "<class 'geometry_msgs.msg._PoseArray.PoseArray'>": parse_posearray, "<class 'sensor_msgs.msg._PointCloud.PointCloud'>": parse_pointcloud, "<class 'sensor_msgs.msg._PointCloud2.PointCloud2'>": parse_pointcloud2} self._cbs = [] if callbacks: for cb in sorted(callbacks): if cb in globals(): self._cbs.append(globals()[cb]) elif cb in locals(): self._cbs.append(locals()[cb]) elif cb in dir(self): self._cbs.append(getattr(self, cb)) self._cb_input_keys = [] self._cb_output_keys = [] self._cb_outcomes = [] for cb in self._cbs: if cb and smach.has_smach_interface(cb): self._cb_input_keys.append(cb.get_registered_input_keys()) self._cb_output_keys.append(cb.get_registered_output_keys()) self._cb_outcomes.append(cb.get_registered_outcomes()) self.register_input_keys(self._cb_input_keys[-1]) self.register_output_keys(self._cb_output_keys[-1]) self.register_outcomes(self._cb_outcomes[-1])
def __init__(self, name, bag_recorder, action, input_keys=['file', 'topics'], output_keys=[], callbacks=None): smach.State.__init__(self, input_keys=input_keys, output_keys=output_keys, outcomes=['succeeded', 'aborted']) # Save the state name self._name = name # Save the ROSBagRecorder object reference self._bag_recorder = bag_recorder # Save the action self._action = action self._cbs = [] if callbacks: for cb in sorted(callbacks): if cb in globals(): self._cbs.append(globals()[cb]) elif cb in locals(): self._cbs.append(locals()[cb]) elif cb in dir(self): self._cbs.append(getattr(self, cb)) self._cb_input_keys = [] self._cb_output_keys = [] self._cb_outcomes = [] for cb in self._cbs: if cb and smach.has_smach_interface(cb): self._cb_input_keys.append(cb.get_registered_input_keys()) self._cb_output_keys.append(cb.get_registered_output_keys()) self._cb_outcomes.append(cb.get_registered_outcomes()) self.register_input_keys(self._cb_input_keys[-1]) self.register_output_keys(self._cb_output_keys[-1]) self.register_outcomes(self._cb_outcomes[-1])
def __init__( self, cb, topic_name, msg_type, outcomes=["done", "failed", "preempted"], input_keys=[], output_keys=[], io_keys=[], ): smach.State.__init__(self, outcomes=outcomes, input_keys=input_keys, output_keys=output_keys, io_keys=io_keys) self._publisher = rospy.Publisher(topic_name, msg_type) self._cb = cb if cb and smach.has_smach_interface(cb): self.register_input_keys(cb.get_registered_input_keys()) self.register_output_keys(cb.get_registered_output_keys()) self.register_outcomes(cb.get_registered_outcomes())
def __init__(self, actionname, actionspec, goal = None, goal_cb = None, feedback_cb = None, timeout= None): smach.State.__init__(self, input_keys=['button_cancel', 'sample'], outcomes=['complete', 'timeout', 'canceled', 'preempted', 'aborted']) self.actionname = actionname self.actionspec = actionspec self.goal = goal self.goal_cb = goal_cb self.feedback_cb = feedback_cb self.timeout = timeout #get keys from goal callback if smach.has_smach_interface(goal_cb): self.register_input_keys(goal_cb.get_registered_input_keys()) self.register_output_keys(goal_cb.get_registered_output_keys())
def __init__( self, # Service info service_name, service_spec, # Request Policy request=None, request_cb=None, request_cb_args=[], request_cb_kwargs={}, request_key=None, request_slots=[], # Response Policy response_cb=None, response_cb_args=[], response_cb_kwargs={}, response_key=None, response_slots=[], # Keys input_keys=[], output_keys=[], outcomes=[], ): smach.State.__init__(self, outcomes=['succeeded', 'aborted', 'preempted']) # Store Service info self._service_name = service_name self._service_spec = service_spec self._proxy = None # Store request policy if request is None: self._request = service_spec._request_class() else: self._request = request if request_cb is not None and not hasattr(request_cb, '__call__'): raise smach.InvalidStateError( "Request callback object given to ServiceState that IS NOT a function object" ) self._request_cb = request_cb self._request_cb_args = request_cb_args self._request_cb_kwargs = request_cb_kwargs if smach.has_smach_interface(request_cb): self._request_cb_input_keys = request_cb.get_registered_input_keys( ) self._request_cb_output_keys = request_cb.get_registered_output_keys( ) self.register_input_keys(self._request_cb_input_keys) self.register_output_keys(self._request_cb_output_keys) else: self._request_cb_input_keys = input_keys self._request_cb_output_keys = output_keys self._request_key = request_key if request_key is not None: self.register_input_keys([request_key]) self._request_slots = request_slots self.register_input_keys(request_slots) # Store response policy if response_cb is not None and not hasattr(response_cb, '__call__'): raise smach.InvalidStateError( "Response callback object given to ServiceState that IS NOT a function object" ) self._response_cb = response_cb self._response_cb_args = response_cb_args self._response_cb_kwargs = response_cb_kwargs if smach.has_smach_interface(response_cb): self._response_cb_input_keys = response_cb.get_registered_input_keys( ) self._response_cb_output_keys = response_cb.get_registered_output_keys( ) self._response_cb_outcomes = response_cb.get_registered_outcomes() self.register_input_keys(self._response_cb_input_keys) self.register_output_keys(self._response_cb_output_keys) self.register_outcomes(self._response_cb_outcomes) else: self._response_cb_input_keys = input_keys self._response_cb_output_keys = output_keys self._response_cb_outcomes = outcomes # Register additional input and output keys self.register_input_keys(input_keys) self.register_output_keys(output_keys) self.register_outcomes(outcomes) self._response_key = response_key if response_key is not None: self.register_output_keys([response_key]) self._response_slots = response_slots self.register_output_keys(response_slots)
def __init__( self, # Action info action_name, action_spec, # Default goal goal=None, goal_key=None, goal_slots=[], goal_cb=None, goal_cb_args=[], goal_cb_kwargs={}, # Result modes result_key=None, result_slots=[], result_cb=None, result_cb_args=[], result_cb_kwargs={}, # Keys input_keys=[], output_keys=[], outcomes=[], # Timeouts exec_timeout=None, cancel_timeout=rospy.Duration(15.0), server_wait_timeout=rospy.Duration(60.0), ): """Constructor for SimpleActionState action client wrapper. @type action_name: string @param action_name: The name of the action as it will be broadcast over ros. @type action_spec: actionlib action msg @param action_spec: The type of action to which this client will connect. @type goal: actionlib goal msg @param goal: If the goal for this action does not need to be generated at runtime, it can be passed to this state on construction. @type goal_key: string @param goal_key: Pull the goal message from a key in the userdata. This will be done before calling the goal_cb if goal_cb is defined. @type goal_slots: list of string @param goal_slots: Pull the goal fields (__slots__) from like-named keys in userdata. This will be done before calling the goal_cb if goal_cb is defined. @type goal_cb: callable @param goal_cb: If the goal for this action needs to be generated at runtime, a callback can be stored which modifies the default goal object. The callback is passed two parameters: - userdata - current stored goal The callback returns a goal message. @type result_key: string @param result_key: Put the result message into the userdata with the given key. This will be done after calling the result_cb if result_cb is defined. @type result_slots: list of strings @param result_slots: Put the result message fields (__slots__) into the userdata with keys like the field names. This will be done after calling the result_cb if result_cb is defined. @type result_cb: callable @param result_cb: If result information from this action needs to be stored or manipulated on reception of a result from this action, a callback can be stored which is passed this information. The callback is passed three parameters: - userdata (L{UserData<smach.user_data.UserData>}) - result status (C{actionlib.GoalStatus}) - result (actionlib result msg) @type exec_timeout: C{rospy.Duration} @param exec_timeout: This is the timeout used for sending a preempt message to the delegate action. This is C{None} by default, which implies no timeout. @type cancel_timeout: C{rospy.Duration} @param cancel_timeout: This is the timeout used for aborting the state after a preempt has been requested or the execution timeout occured and no result from the action has been received. This timeout begins counting after cancel to the action server has been sent. @type server_wait_timeout: C{rospy.Duration} @param server_wait_timeout: This is the timeout used for aborting while waiting for an action server to become active. """ # Initialize base class State.__init__(self, outcomes=['succeeded', 'aborted', 'preempted']) # Set action properties self._action_name = action_name self._action_spec = action_spec # Set timeouts self._goal_status = 0 self._goal_result = None self._exec_timeout = exec_timeout self._cancel_timeout = cancel_timeout self._server_wait_timeout = server_wait_timeout # Set goal generation policy if goal and hasattr(goal, '__call__'): raise smach.InvalidStateError( "Goal object given to SimpleActionState that IS a function object" ) sl = action_spec().action_goal.goal.__slots__ if not all([s in sl for s in goal_slots]): raise smach.InvalidStateError( "Goal slots specified are not valid slots. Available slots: %s; specified slots: %s" % (sl, goal_slots)) if goal_cb and not hasattr(goal_cb, '__call__'): raise smach.InvalidStateError( "Goal callback object given to SimpleActionState that IS NOT a function object" ) # Static goal if goal is None: self._goal = copy.copy(action_spec().action_goal.goal) else: self._goal = goal # Goal from userdata key self._goal_key = goal_key if goal_key is not None: self.register_input_keys([goal_key]) # Goal slots from userdata keys self._goal_slots = goal_slots self.register_input_keys(goal_slots) # Goal generation callback self._goal_cb = goal_cb self._goal_cb_args = goal_cb_args self._goal_cb_kwargs = goal_cb_kwargs if smach.has_smach_interface(goal_cb): self._goal_cb_input_keys = goal_cb.get_registered_input_keys() self._goal_cb_output_keys = goal_cb.get_registered_output_keys() self.register_input_keys(self._goal_cb_input_keys) self.register_output_keys(self._goal_cb_output_keys) else: self._goal_cb_input_keys = input_keys self._goal_cb_output_keys = output_keys # Set result processing policy if result_cb and not hasattr(result_cb, '__call__'): raise smach.InvalidStateError( "Result callback object given to SimpleActionState that IS NOT a function object" ) if not all([ s in action_spec().action_result.result.__slots__ for s in result_slots ]): raise smach.InvalidStateError( "Result slots specified are not valid slots.") # Result callback self._result_cb = result_cb self._result_cb_args = result_cb_args self._result_cb_kwargs = result_cb_kwargs if smach.has_smach_interface(result_cb): self._result_cb_input_keys = result_cb.get_registered_input_keys() self._result_cb_output_keys = result_cb.get_registered_output_keys( ) self._result_cb_outcomes = result_cb.get_registered_outcomes() self.register_input_keys(self._result_cb_input_keys) self.register_output_keys(self._result_cb_output_keys) self.register_outcomes(self._result_cb_outcomes) else: self._result_cb_input_keys = input_keys self._result_cb_output_keys = output_keys self._result_cb_outcomes = outcomes # Result to userdata key self._result_key = result_key if result_key is not None: self.register_output_keys([result_key]) # Result slots to userdata keys self._result_slots = result_slots self.register_output_keys(result_slots) # Register additional input and output keys self.register_input_keys(input_keys) self.register_output_keys(output_keys) self.register_outcomes(outcomes) # Declare some status variables self._activate_time = rospy.Time.now() self._cancel_time = rospy.Time.now() self._duration = rospy.Duration(0.0) self._status = SimpleActionState.WAITING_FOR_SERVER # Construct action client, and wait for it to come active self._action_client = SimpleActionClient(action_name, action_spec) self._action_wait_thread = threading.Thread( name=self._action_name + '/wait_for_server', target=self._wait_for_server) self._action_wait_thread.start() self._execution_timer_thread = None self._cancelation_timer_thread = None # Condition variables for threading synchronization self._done_cond = threading.Condition()
def __init__(self, # Service info service_name, service_spec, # Request Policy request = None, request_cb = None, request_cb_args = [], request_cb_kwargs = {}, request_key = None, request_slots = [], # Response Policy response_cb = None, response_cb_args = [], response_cb_kwargs = {}, response_key = None, response_slots = [], # Keys input_keys = [], output_keys = [], outcomes = [], ): smach.State.__init__(self,outcomes=['succeeded','aborted','preempted']) # Store Service info self._service_name = service_name self._service_spec = service_spec self._proxy = None # Store request policy if request is None: self._request = service_spec._request_class() else: self._request = request if request_cb is not None and not hasattr(request_cb, '__call__'): raise smach.InvalidStateError("Request callback object given to ServiceState that IS NOT a function object") self._request_cb = request_cb self._request_cb_args = request_cb_args self._request_cb_kwargs = request_cb_kwargs if smach.has_smach_interface(request_cb): self._request_cb_input_keys = request_cb.get_registered_input_keys() self._request_cb_output_keys = request_cb.get_registered_output_keys() self.register_input_keys(self._request_cb_input_keys) self.register_output_keys(self._request_cb_output_keys) else: self._request_cb_input_keys = input_keys self._request_cb_output_keys = output_keys self._request_key = request_key if request_key is not None: self.register_input_keys([request_key]) self._request_slots = request_slots self.register_input_keys(request_slots) # Store response policy if response_cb is not None and not hasattr(response_cb, '__call__'): raise smach.InvalidStateError("Response callback object given to ServiceState that IS NOT a function object") self._response_cb = response_cb self._response_cb_args = response_cb_args self._response_cb_kwargs = response_cb_kwargs if smach.has_smach_interface(response_cb): self._response_cb_input_keys = response_cb.get_registered_input_keys() self._response_cb_output_keys = response_cb.get_registered_output_keys() self._response_cb_outcomes = response_cb.get_registered_outcomes() self.register_input_keys(self._response_cb_input_keys) self.register_output_keys(self._response_cb_output_keys) self.register_outcomes(self._response_cb_outcomes) else: self._response_cb_input_keys = input_keys self._response_cb_output_keys = output_keys self._response_cb_outcomes = outcomes # Register additional input and output keys self.register_input_keys(input_keys) self.register_output_keys(output_keys) self.register_outcomes(outcomes) self._response_key = response_key if response_key is not None: self.register_output_keys([response_key]) self._response_slots = response_slots self.register_output_keys(response_slots)
def __init__(self, # Action info action_name, action_spec, # Default goal goal = None, goal_key = None, goal_slots = [], goal_cb = None, goal_cb_args = [], goal_cb_kwargs = {}, # Result modes result_key = None, result_slots = [], result_cb = None, result_cb_args = [], result_cb_kwargs = {}, # Keys input_keys = [], output_keys = [], outcomes = [], # Timeouts exec_timeout = None, preempt_timeout = rospy.Duration(60.0), server_wait_timeout = rospy.Duration(60.0) ): """Constructor for SimpleActionState action client wrapper. @type action_name: string @param action_name: The name of the action as it will be broadcast over ros. @type action_spec: actionlib action msg @param action_spec: The type of action to which this client will connect. @type goal: actionlib goal msg @param goal: If the goal for this action does not need to be generated at runtime, it can be passed to this state on construction. @type goal_key: string @param goal_key: Pull the goal message from a key in the userdata. This will be done before calling the goal_cb if goal_cb is defined. @type goal_slots: list of string @param goal_slots: Pull the goal fields (__slots__) from like-named keys in userdata. This will be done before calling the goal_cb if goal_cb is defined. @type goal_cb: callable @param goal_cb: If the goal for this action needs tobe generated at runtime, a callback can be stored which modifies the default goal object. The callback is passed two parameters: - userdata - current stored goal The callback returns a goal message. @type result_key: string @param result_key: Put the result message into the userdata with the given key. This will be done after calling the result_cb if result_cb is defined. @type result_slots: list of strings @param result_slots: Put the result message fields (__slots__) into the userdata with keys like the field names. This will be done after calling the result_cb if result_cb is defined. @type result_cb: callable @param result_cb: If result information from this action needs to be stored or manipulated on reception of a result from this action, a callback can be stored which is passed this information. The callback is passed three parameters: - userdata (L{UserData<smach.user_data.UserData>}) - result status (C{actionlib.GoalStatus}) - result (actionlib result msg) @type exec_timeout: C{rospy.Duration} @param exec_timeout: This is the timeout used for sending a preempt message to the delegate action. This is C{None} by default, which implies no timeout. @type preempt_timeout: C{rospy.Duration} @param preempt_timeout: This is the timeout used for aborting after a preempt has been sent to the action and no result has been received. This timeout begins counting after a preempt message has been sent. @type server_wait_timeout: C{rospy.Duration} @param server_wait_timeout: This is the timeout used for aborting while waiting for an action server to become active. """ # Initialize base class State.__init__(self, outcomes=['succeeded','aborted','preempted']) # Set action properties self._action_name = action_name self._action_spec = action_spec # Set timeouts self._goal_status = 0 self._exec_timeout = exec_timeout self._preempt_timeout = preempt_timeout self._server_wait_timeout = server_wait_timeout # Set goal generation policy if goal and hasattr(goal, '__call__'): raise smach.InvalidStateError("Goal object given to SimpleActionState that IS a function object") if not all([s in action_spec().action_goal.goal.__slots__ for s in goal_slots]): raise smach.InvalidStateError("Goal slots specified are not valid slots.") if goal_cb and not hasattr(goal_cb, '__call__'): raise smach.InvalidStateError("Goal callback object given to SimpleActionState that IS NOT a function object") # Static goal if goal is None: self._goal = copy.copy(action_spec().action_goal.goal) else: self._goal = goal # Goal from userdata key self._goal_key = goal_key if goal_key is not None: self.register_input_keys([goal_key]) # Goal slots from userdata keys self._goal_slots = goal_slots self.register_input_keys(goal_slots) # Goal generation callback self._goal_cb = goal_cb self._goal_cb_args = goal_cb_args self._goal_cb_kwargs = goal_cb_kwargs if smach.has_smach_interface(goal_cb): self._goal_cb_input_keys = goal_cb.get_registered_input_keys() self._goal_cb_output_keys = goal_cb.get_registered_output_keys() self.register_input_keys(self._goal_cb_input_keys) self.register_output_keys(self._goal_cb_output_keys) else: self._goal_cb_input_keys = input_keys self._goal_cb_output_keys = output_keys # Set result processing policy if result_cb and not hasattr(result_cb, '__call__'): raise smach.InvalidStateError("Result callback object given to SimpleActionState that IS NOT a function object") if not all([s in action_spec().action_result.result.__slots__ for s in result_slots]): raise smach.InvalidStateError("Result slots specified are not valid slots.") # Result callback self._result_cb = result_cb self._result_cb_args = result_cb_args self._result_cb_kwargs = result_cb_kwargs if smach.has_smach_interface(result_cb): self._result_cb_input_keys = result_cb.get_registered_input_keys() self._result_cb_output_keys = result_cb.get_registered_output_keys() self._result_cb_outcomes = result_cb.get_registered_outcomes() self.register_input_keys(self._result_cb_input_keys) self.register_output_keys(self._result_cb_output_keys) self.register_outcomes(self._result_cb_outcomes) else: self._result_cb_input_keys = input_keys self._result_cb_output_keys = output_keys self._result_cb_outcomes = outcomes # Result to userdata key self._result_key = result_key if result_key is not None: self.register_output_keys([result_key]) # Result slots to userdata keys self._result_slots = result_slots self.register_output_keys(result_slots) # Register additional input and output keys self.register_input_keys(input_keys) self.register_output_keys(output_keys) self.register_outcomes(outcomes) # Declare some status variables self._activate_time = rospy.Time.now() self._preempt_time = rospy.Time.now() self._duration = rospy.Duration(0.0) self._status = SimpleActionState.WAITING_FOR_SERVER # Construct action client, and wait for it to come active self._action_client = SimpleActionClient(action_name,action_spec) self._action_wait_thread = threading.Thread(name=self._action_name+'/wait_for_server',target = self._wait_for_server) self._action_wait_thread.start() self._execution_timer_thread = None # Condition variables for threading synchronization self._done_cond = threading.Condition()