def construct_sm(): sm = StateMachine(outcomes=['succeeded', 'aborted', 'preempted']) with sm: tutorial_it = Iterator(outcomes=['succeeded', 'preempted', 'aborted'], it=lambda: range(0, 10), it_label='index', input_keys=[], output_keys=[], exhausted_outcome='succeeded') with tutorial_it: container_sm = utils.TargetSelectorContainer('explore') #close container_sm Iterator.set_contained_state('CONTAINER_STATE', container_sm, loop_outcomes=['target_sent']) #close the tutorial_it StateMachine.add('TUTORIAL_IT', tutorial_it, { 'succeeded': 'succeeded', 'aborted': 'aborted' }) return sm
def __init__(self): rospy.init_node('speech_recognition') rospy.on_shutdown(self.shutdown) self.find_people = StateMachine( outcomes=['succeeded', 'aborted', 'error']) self.test_bool = False with self.find_people: self.answer = Iterator(outcomes=['succeeded', 'aborted', 'error'], input_keys=['people_condition'], output_keys=[], it=lambda: range(0, 5), exhausted_outcome='succeeded') with self.answer: Iterator.set_contained_state('ANSWER_STATE', Anwser(), loop_outcomes=['succeeded']) StateMachine.add('ANSWER', self.answer, transitions={ 'succeeded': 'succeeded', 'aborted': 'aborted', 'error': 'error' }) out = self.find_people.execute() if out == 'succeeded': self.test_bool = True rospy.logwarn('test finished, all thing is done well!') else: rospy.logerr('test failed ,something goes wrong')
def construct_sm(): sm = StateMachine(outcomes = ['succeeded','aborted','preempted']) sm.userdata.nums = range(25, 88, 3) sm.userdata.even_nums = [] sm.userdata.odd_nums = [] with sm: ## %Tag(ITERATOR)% tutorial_it = Iterator(outcomes = ['succeeded','preempted','aborted'], input_keys = ['nums', 'even_nums', 'odd_nums'], it = lambda: range(0, len(sm.userdata.nums)), output_keys = ['even_nums', 'odd_nums'], it_label = 'index', exhausted_outcome = 'succeeded') ## %EndTag(ITERATOR)% ## %Tag(CONTAINER)% with tutorial_it: container_sm = StateMachine(outcomes = ['succeeded','preempted','aborted','continue'], input_keys = ['nums', 'index', 'even_nums', 'odd_nums'], output_keys = ['even_nums', 'odd_nums']) with container_sm: #test wether even or odd StateMachine.add('EVEN_OR_ODD', ConditionState(cond_cb = lambda ud:ud.nums[ud.index]%2, input_keys=['nums', 'index']), {'true':'ODD', 'false':'EVEN' }) #add even state @smach.cb_interface(input_keys=['nums', 'index', 'even_nums'], output_keys=['odd_nums'], outcomes=['succeeded']) def even_cb(ud): ud.even_nums.append(ud.nums[ud.index]) return 'succeeded' StateMachine.add('EVEN', CBState(even_cb), {'succeeded':'continue'}) #add odd state @smach.cb_interface(input_keys=['nums', 'index', 'odd_nums'], output_keys=['odd_nums'], outcomes=['succeeded']) def odd_cb(ud): ud.odd_nums.append(ud.nums[ud.index]) return 'succeeded' StateMachine.add('ODD', CBState(odd_cb), {'succeeded':'continue'}) ## %EndTag(CONTAINER)% ## %Tag(ADDCONTAINER)% #close container_sm Iterator.set_contained_state('CONTAINER_STATE', container_sm, loop_outcomes=['continue']) ## %EndTag(ADDCONTAINER)% ## %Tag(ADDITERATOR)% #close the tutorial_it StateMachine.add('TUTORIAL_IT',tutorial_it, {'succeeded':'succeeded', 'aborted':'aborted'}) ## %EndTag(ADDITERATOR)% return sm
def execute(self): sm_top = smach.StateMachine( outcomes=['succeeded', 'preemted', 'aborted', 'continue']) with sm_top: self.rooms_go = Iterator( outcomes=['succeeded', 'preemted', 'aborted'], input_keys=[], output_keys=['index'], it=lambda: range(0, 3), it_label='index', exhausted_outcome='succeeded') with self.rooms_go: self.rooms_go_proton = StateMachine( outcomes=['succeeded', 'aborted', 'continue'], input_keys=['index']) with self.rooms_go_proton: #self.current_pos = self.RoomsPoses[index] self.rooms_go_proton.userdata.current_poses = self.RoomsPoses self.rooms_go_proton.userdata.current_pos2 = 0 self.rooms_go_proton.add('INDEXTRANS', IndexTrans(), transitions={'succeeded': 'GO'}, remapping={ 'poses': 'current_poses', 'current_pos': 'current_pos2', 'index': 'index' }) self.rooms_go_proton.add( 'GO', NavStack(), transitions={ 'succeeded': 'continue', 'aborted': 'GO', 'error': 'continue' }, remapping={'pos_xm': 'current_pos2'}) Iterator.set_contained_state('CONTAINER_STATE', self.rooms_go_proton, loop_outcomes=['continue']) sm_top.add('ROOMS_GO', self.rooms_go, transitions={ 'succeeded': 'succeeded', 'aborted': 'aborted' }, remapping={'index': 'index'}) out = sm_top.execute() rospy.logerr(out)
def make_iterator(container, max_iter=1): it = Iterator(outcomes = ['preempted','aborted','time_out'], it = lambda: range(0, max_iter), it_label = 'index', input_keys=[], output_keys=[], exhausted_outcome = 'time_out') with it: Iterator.set_contained_state('TARGET_CONTROLLER', container, loop_outcomes=['target_sent']) return it
def make_iterator(container, max_iter=1): it = Iterator(outcomes=['preempted', 'aborted', 'time_out'], it=lambda: range(0, max_iter), it_label='index', input_keys=[], output_keys=[], exhausted_outcome='time_out') with it: Iterator.set_contained_state('TARGET_CONTROLLER', container, loop_outcomes=['target_sent']) return it
def __init__(self): Iterator.__init__(self, outcomes=['succeeded', 'preempted', 'aborted'], input_keys=['log_mission'], it=[], output_keys=['log_mission'], it_label='waypoint_id', exhausted_outcome='succeeded') self.register_start_cb(self.set_iterator_list) with self: self.sm_nav = StateMachine( outcomes=['succeeded', 'preempted', 'aborted', 'continue'], input_keys=['waypoint_id', 'log_mission'], output_keys=['log_mission']) self.sm_nav.register_start_cb(self.start_cb_nav) self.sm_nav.register_termination_cb(self.termination_cb_nav) with self.sm_nav: StateMachine.add('MOVE_BASE', SimpleActionState( 'move_base', MoveBaseAction, input_keys=['waypoint_id', 'log_mission'], goal_cb=self.move_base_goal_cb), transitions={ 'succeeded': 'SAVE_DATA', 'aborted': 'continue' }) self.save_data_service = ServiceState( 'make_data_acquisition', RequestSaveData, response_cb=self.save_data_response_cb) StateMachine.add('SAVE_DATA', self.save_data_service, transitions={'succeeded': 'continue'}) # Close the sm_nav machine and add it to the iterator Iterator.set_contained_state('FOLLOW_PATH', self.sm_nav, loop_outcomes=['continue'])
def construct_sm(): sm = StateMachine(outcomes = ['succeeded','aborted','preempted']) with sm: tutorial_it = Iterator(outcomes = ['succeeded','preempted','aborted'], it = lambda: range(0, 10), it_label = 'index', input_keys=[], output_keys=[], exhausted_outcome = 'succeeded') with tutorial_it: container_sm = utils.TargetSelectorContainer('explore') #close container_sm Iterator.set_contained_state('CONTAINER_STATE', container_sm, loop_outcomes=['target_sent']) #close the tutorial_it StateMachine.add('TUTORIAL_IT',tutorial_it, {'succeeded':'succeeded', 'aborted':'aborted'}) return sm
def construct_sm(): sm = StateMachine(outcomes=["succeeded", "aborted", "preempted"]) sm.userdata.nums = range(25, 88, 3) sm.userdata.even_nums = [] sm.userdata.odd_nums = [] with sm: ## %Tag(ITERATOR)% tutorial_it = Iterator( outcomes=["succeeded", "preempted", "aborted"], input_keys=["nums", "even_nums", "odd_nums"], it=lambda: range(0, len(sm.userdata.nums)), output_keys=["even_nums", "odd_nums"], it_label="index", exhausted_outcome="succeeded", ) ## %EndTag(ITERATOR)% ## %Tag(CONTAINER)% with tutorial_it: container_sm = StateMachine( outcomes=["succeeded", "preempted", "aborted", "continue"], input_keys=["nums", "index", "even_nums", "odd_nums"], output_keys=["even_nums", "odd_nums"], ) with container_sm: # test wether even or odd StateMachine.add( "EVEN_OR_ODD", ConditionState( cond_cb=lambda ud: ud.nums[ud.index] % 2, input_keys=["nums", "index"], ), { "true": "ODD", "false": "EVEN" }, ) # add even state @smach.cb_interface( input_keys=["nums", "index", "even_nums"], output_keys=["odd_nums"], outcomes=["succeeded"], ) def even_cb(ud): ud.even_nums.append(ud.nums[ud.index]) return "succeeded" StateMachine.add("EVEN", CBState(even_cb), {"succeeded": "continue"}) # add odd state @smach.cb_interface( input_keys=["nums", "index", "odd_nums"], output_keys=["odd_nums"], outcomes=["succeeded"], ) def odd_cb(ud): ud.odd_nums.append(ud.nums[ud.index]) return "succeeded" StateMachine.add("ODD", CBState(odd_cb), {"succeeded": "continue"}) ## %EndTag(CONTAINER)% ## %Tag(ADDCONTAINER)% # close container_sm Iterator.set_contained_state("CONTAINER_STATE", container_sm, loop_outcomes=["continue"]) ## %EndTag(ADDCONTAINER)% ## %Tag(ADDITERATOR)% # close the tutorial_it StateMachine.add("TUTORIAL_IT", tutorial_it, { "succeeded": "succeeded", "aborted": "aborted" }) ## %EndTag(ADDITERATOR)% return sm
def __init__(self): rospy.init_node('patrol_smach', anonymous=False) # Set the shutdown function (stop the robot) rospy.on_shutdown(self.shutdown) # Initialize a number of parameters and variables self.init() # Subscribe to the move_base action server self.move_base = actionlib.SimpleActionClient("move_base", MoveBaseAction) rospy.loginfo("Waiting for move_base action server...") # Wait up to 60 seconds for the action server to become available self.move_base.wait_for_server(rospy.Duration(60)) rospy.loginfo("Connected to move_base action server") # Track success rate of getting to the goal locations self.n_succeeded = 0 self.n_aborted = 0 self.n_preempted = 0 self.n_patrols = 2 # Turn the waypoints into SMACH states nav_states = list() for waypoint in self.waypoints: nav_goal = MoveBaseGoal() nav_goal.target_pose.header.frame_id = 'map' nav_goal.target_pose.pose = waypoint move_base_state = SimpleActionState( 'move_base', MoveBaseAction, goal=nav_goal, result_cb=self.move_base_result_cb, exec_timeout=rospy.Duration(10.0), server_wait_timeout=rospy.Duration(10.0)) nav_states.append(move_base_state) move_base_state = SimpleActionState( 'move_base', MoveBaseAction, goal=nav_goal, result_cb=self.move_base_result_cb, exec_timeout=rospy.Duration(10.0)) # Initialize the top level state machine self.sm = StateMachine(outcomes=['succeeded', 'aborted', 'preempted']) with self.sm: # Initialize the iterator self.sm_patrol_iterator = Iterator( outcomes=['succeeded', 'preempted', 'aborted'], input_keys=[], it=lambda: range(0, self.n_patrols), output_keys=[], it_label='index', exhausted_outcome='succeeded') with self.sm_patrol_iterator: # Initialize the patrol state machine self.sm_patrol = StateMachine( outcomes=['succeeded', 'aborted', 'preempted', 'continue']) # Add the states to the state machine with the appropriate transitions with self.sm_patrol: StateMachine.add('NAV_STATE_0', nav_states[0], transitions={ 'succeeded': 'NAV_STATE_1', 'aborted': 'NAV_STATE_1', 'preempted': 'NAV_STATE_1' }) StateMachine.add('NAV_STATE_1', nav_states[1], transitions={ 'succeeded': 'NAV_STATE_2', 'aborted': 'NAV_STATE_2', 'preempted': 'NAV_STATE_2' }) StateMachine.add('NAV_STATE_2', nav_states[2], transitions={ 'succeeded': 'NAV_STATE_3', 'aborted': 'NAV_STATE_3', 'preempted': 'NAV_STATE_3' }) StateMachine.add('NAV_STATE_3', nav_states[3], transitions={ 'succeeded': 'NAV_STATE_4', 'aborted': 'NAV_STATE_4', 'preempted': 'NAV_STATE_4' }) StateMachine.add('NAV_STATE_4', nav_states[0], transitions={ 'succeeded': 'continue', 'aborted': 'continue', 'preempted': 'continue' }) # Close the sm_patrol machine and add it to the iterator Iterator.set_contained_state('PATROL_STATE', self.sm_patrol, loop_outcomes=['continue']) # Close the top level state machine StateMachine.add('PATROL_ITERATOR', self.sm_patrol_iterator, { 'succeeded': 'succeeded', 'aborted': 'aborted' }) # Create and start the SMACH introspection server intro_server = IntrospectionServer('patrol', self.sm, '/SM_ROOT') intro_server.start() # Execute the state machine sm_outcome = self.sm.execute() rospy.loginfo('State Machine Outcome: ' + str(sm_outcome)) intro_server.stop()
def main(): rospy.init_node('fcsc_smach') # Create a SMACH state machine sm = smach.StateMachine(outcomes=['succeeded', 'preempted', 'aborted']) sm.userdata.products = [] sm.userdata.sandwiches = [] sm.userdata.scrap_sandwiches = [] sm.userdata.normal_sandwiches = [] sm.userdata.damy_output = [] sm.userdata.adjust_count = 0; sm.userdata.faceup_count = 0; # Open the container with sm: def move_initial_pose_response_cb(userdata, response): if response.success == True: return 'succeeded' else: return 'aborted' smach.StateMachine.add('MOVE_INITIAL_POSE', ServiceState('move_initial_pose', Trigger, response_cb=move_initial_pose_response_cb), # transitions={'succeeded':'DETECT_AND_RECOVER_SANDWICH'}) transitions={'succeeded':'NAVIGATE_TO_SHELF_A'}) navigate_to_shelf_a_sm = smach.StateMachine(outcomes=['succeeded', 'preempted', 'aborted']) with navigate_to_shelf_a_sm: navigate_to_shelf_a_sm.add('GO_TO_NEAR_SHELF', ServiceState('goto_near_shelf', GoToNearShelf, request=GoToNearShelfRequest(0)), transitions={'succeeded':'DETECT_SHELF_A'}) navigate_to_shelf_a_sm.add('DETECT_SHELF_A', ServiceState('detect_shelf_action', DetectShelf, request=DetectShelfRequest(0)), transitions={'succeeded':'GO_TO_STOCKING_POSITION', 'aborted':'aborted'}) navigate_to_shelf_a_sm.add('GO_TO_STOCKING_POSITION', ServiceState('goto_stocking_base_position', Trigger), transitions={'succeeded':'succeeded'}) smach.StateMachine.add('NAVIGATE_TO_SHELF_A', navigate_to_shelf_a_sm, # transitions={'succeeded':'NAVIGATE_TO_SHELF_B'}) transitions={'succeeded':'DETECT_PRODUCT'}) smach.StateMachine.add('DETECT_PRODUCT', ServiceState('detect_product', DetectProduct, response_slots=['detected_object_array']), transitions={'succeeded':'STOCK_PRODUCTS'}, remapping={'detected_object_array':'products'}) stock_it = Iterator(outcomes=['succeeded', 'preempted', 'aborted'], input_keys=['products', 'damy_output'], it=lambda: range(0, len(sm.userdata.products.objects)), output_keys=['damy_output'], it_label='index', exhausted_outcome='succeeded') with stock_it: stock_sm = smach.StateMachine(outcomes=['continue', 'succeeded', 'preempted', 'aborted'], input_keys=['index', 'products']) with stock_sm: @smach.cb_interface(input_keys=['products', 'index']) def pickup_request_cb(userdata, request): request.object = userdata.products.objects[userdata.index] return request @smach.cb_interface(outcomes=['succeeded', 'aborted']) def pickup_response_cb(userdata, response): if response.success == True: return 'succeeded' else: return 'aborted' smach.StateMachine.add('PICKUP_PRODUCT', ServiceState('pickup_product', Manipulate, request_cb=pickup_request_cb, response_cb=pickup_response_cb, input_keys=['products', 'index']), transitions={'succeeded':'PLACE_PRODUCT', 'aborted':'continue'}) @smach.cb_interface(input_keys=['products', 'index']) def place_request_cb(userdata, request): request.object = userdata.products.objects[userdata.index] return request @smach.cb_interface(outcomes=['succeeded', 'aborted']) def place_response_cb(userdata, response): if response.success: return 'succeeded' else: return 'aborted' smach.StateMachine.add('PLACE_PRODUCT', ServiceState('place_product', Manipulate, request_cb=place_request_cb, response_cb=place_response_cb, input_keys=['products', 'index']), transitions={'succeeded':'continue', 'aborted':'continue'}) @smach.cb_interface(input_keys=['products', 'index']) def return_request_cb(userdata, request): request.object = userdata.products.objects[userdata.index] return request @smach.cb_interface(outcomes=['succeeded', 'aborted']) def return_response_cb(userdata, response): if response.success: return 'succeeded' else: return 'aborted' smach.StateMachine.add('RETURN_PRODUCT', ServiceState('return_product', Manipulate, request_cb=return_request_cb, response_cb=return_response_cb, input_keys=['products', 'index']), transitions={'succeeded':'continue', 'aborted':'aborted'}) Iterator.set_contained_state('STOCK_PRODUCTS_STATE', stock_sm, loop_outcomes=['continue']) smach.StateMachine.add('STOCK_PRODUCTS', stock_it, transitions={'succeeded':'NAVIGATE_TO_SHELF_B', 'aborted':'aborted'}) navigate_to_shelf_b_sm = smach.StateMachine(outcomes=['succeeded', 'preempted', 'aborted']) with navigate_to_shelf_b_sm: navigate_to_shelf_b_sm.add('GO_TO_NEAR_SHELF_B', ServiceState('goto_near_shelf', GoToNearShelf, request=GoToNearShelfRequest(2)), transitions={'succeeded':'DETECT_SHELF_B'}) navigate_to_shelf_b_sm.add('DETECT_SHELF_B', ServiceState('detect_shelf_action', DetectShelf, request=DetectShelfRequest(1)), transitions={'succeeded':'GO_TO_FACEUP_POSITION', 'aborted':'aborted'}) navigate_to_shelf_a_sm.add('GO_TO_FACEUP_POSITION', ServiceState('goto_faceup_base_position', Trigger), transitions={'succeeded':'succeeded'}) smach.StateMachine.add('NAVIGATE_TO_SHELF_B', navigate_to_shelf_b_sm, transitions={'succeeded':'DETECT_AND_RECOVER_SANDWICH'}) smach.StateMachine.add('DETECT_AND_RECOVER_SANDWICH', ServiceState('detect_and_recover_sandwich', DetectAndRecoverSandwich, response_slots=['normal_sandwiches']), transitions={'succeeded':'FACEUP_SANDWICHES'}) @smach.cb_interface(input_keys=['normal_sandwiches']) def faceup_request_cb(userdata, request): request.sandwiches = userdata.normal_sandwiches return request @smach.cb_interface(outcomes=['succeeded', 'aborted']) def faceup_response_cb(userdata, response): if response.success: return 'succeeded' else: return 'aborted' smach.StateMachine.add('FACEUP_SANDWICHES', ServiceState('faceup_standing_sandwiches', FaceupSandwich, request_cb=faceup_request_cb, response_cb=faceup_response_cb, input_keys=['normal_sandwiches'] ), transitions={'succeeded':'GO_TO_HOME_POSITION'}) smach.StateMachine.add('GO_TO_HOME_POSITION', ServiceState('goto_home_position', Trigger), transitions={'succeeded':'succeeded'}) # Create and start the introspection server sis = smach_ros.IntrospectionServer('server_name', sm, '/SM_ROOT') sis.start() rospy.sleep(3) # Execute SMACH plan outcome = sm.execute() rospy.spin()
def __init__(self): rospy.init_node('patrol_smach', anonymous=False) # Set the shutdown function (stop the robot) rospy.on_shutdown(self.shutdown) # Initialize a number of parameters and variables self.init() # Subscribe to the move_base action server self.move_base = actionlib.SimpleActionClient("move_base", MoveBaseAction) rospy.loginfo("Waiting for move_base action server...") # Wait up to 60 seconds for the action server to become available self.move_base.wait_for_server(rospy.Duration(60)) rospy.loginfo("Connected to move_base action server") # Track success rate of getting to the goal locations self.n_succeeded = 0 self.n_aborted = 0 self.n_preempted = 0 self.n_patrols = 2 # Turn the waypoints into SMACH states nav_states = list() for waypoint in self.waypoints: nav_goal = MoveBaseGoal() nav_goal.target_pose.header.frame_id = 'map' nav_goal.target_pose.pose = waypoint move_base_state = SimpleActionState('move_base', MoveBaseAction, goal=nav_goal, result_cb=self.move_base_result_cb, exec_timeout=rospy.Duration(10.0), server_wait_timeout=rospy.Duration(10.0)) nav_states.append(move_base_state) move_base_state = SimpleActionState('move_base', MoveBaseAction, goal=nav_goal, result_cb=self.move_base_result_cb, exec_timeout=rospy.Duration(10.0)) # Initialize the top level state machine self.sm = StateMachine(outcomes=['succeeded','aborted','preempted']) with self.sm: # Initialize the iterator self.sm_patrol_iterator = Iterator(outcomes = ['succeeded','preempted','aborted'], input_keys = [], it = lambda: range(0, self.n_patrols), output_keys = [], it_label = 'index', exhausted_outcome = 'succeeded') with self.sm_patrol_iterator: # Initialize the patrol state machine self.sm_patrol = StateMachine(outcomes=['succeeded','aborted','preempted','continue']) # Add the states to the state machine with the appropriate transitions with self.sm_patrol: StateMachine.add('NAV_STATE_0', nav_states[0], transitions={'succeeded':'NAV_STATE_1','aborted':'NAV_STATE_1','preempted':'NAV_STATE_1'}) StateMachine.add('NAV_STATE_1', nav_states[1], transitions={'succeeded':'NAV_STATE_2','aborted':'NAV_STATE_2','preempted':'NAV_STATE_2'}) StateMachine.add('NAV_STATE_2', nav_states[2], transitions={'succeeded':'NAV_STATE_3','aborted':'NAV_STATE_3','preempted':'NAV_STATE_3'}) StateMachine.add('NAV_STATE_3', nav_states[3], transitions={'succeeded':'NAV_STATE_4','aborted':'NAV_STATE_4','preempted':'NAV_STATE_4'}) StateMachine.add('NAV_STATE_4', nav_states[0], transitions={'succeeded':'continue','aborted':'continue','preempted':'continue'}) # Close the sm_patrol machine and add it to the iterator Iterator.set_contained_state('PATROL_STATE', self.sm_patrol, loop_outcomes=['continue']) # Close the top level state machine StateMachine.add('PATROL_ITERATOR', self.sm_patrol_iterator, {'succeeded':'succeeded', 'aborted':'aborted'}) # Create and start the SMACH introspection server intro_server = IntrospectionServer('patrol', self.sm, '/SM_ROOT') intro_server.start() # Execute the state machine sm_outcome = self.sm.execute() rospy.loginfo('State Machine Outcome: ' + str(sm_outcome)) intro_server.stop()
def main(): uci_topic = 'chessboard_uci_node' chesspiece_topic = 'chessboard_chesspieces_node' rospy.init_node('chessboard_sm_node') sm = smach.StateMachine( outcomes=['finished', 'succeeded', 'preempted', 'aborted']) sm.userdata.target = [] sis = smach_ros.IntrospectionServer('chessboard_sm_sis', sm, '/SM_ROOT') sis.start() with sm: sq_init = Sequence(outcomes=['succeeded', 'preempted', 'aborted'], connector_outcome='succeeded') #Stockfish init with sq_init: rospy.loginfo('Stockfish init') Sequence.add( 'PIECE_RESET', SimpleActionState('chessboard_chesspieces_reset', ResetAction)) Sequence.add( 'UCI_INIT', SimpleActionState( uci_topic, ucicommandAction, goal=ucicommandGoal(cmd=ucicommandGoal.CMD_INIT))) Sequence.add( 'UCI_NEWGAME', SimpleActionState( uci_topic, ucicommandAction, goal=ucicommandGoal(cmd=ucicommandGoal.CMD_NEWGAME))) smach.StateMachine.add('STOCKFISH_SETUP', sq_init, transitions={'succeeded': 'UCI_ITER'}) #Test code tutorial_it = Iterator(outcomes=['succeeded', 'preempted', 'aborted'], input_keys=[], it=lambda: range(0, 2), output_keys=[], it_label='index', exhausted_outcome='succeeded') with tutorial_it: container_sm = smach.StateMachine(outcomes=[ 'finished', 'succeeded', 'preempted', 'aborted', 'continue' ]) with container_sm: def calc_result_cb(userdata, status, result): if status == GoalStatus.SUCCEEDED: result_coords = list(result.result.data) print(result.result.data) new_target = [] # convert chess notation to indices # e.g. b8c6 -> 6,7,5,5 new_target.append( 7 - int(string.lowercase.index(result_coords[0]))) new_target.append(int(result_coords[1]) - 1) new_target.append( 7 - string.lowercase.index(result_coords[2])) new_target.append(int(result_coords[3]) - 1) #print(new_target) userdata.target = new_target return 'succeeded' smach.StateMachine.add( 'UCI_CALCMOVE', SimpleActionState( uci_topic, ucicommandAction, goal=ucicommandGoal(cmd=ucicommandGoal.CMD_CALC_MOVE), result_cb=calc_result_cb, output_keys=['target']), transitions={'succeeded': 'PIECE_MOVE'}, remapping={'target': 'user_data_target'}) smach.StateMachine.add( 'PIECE_MOVE', SimpleActionState(chesspiece_topic, MoveActionAction, goal_slots=['target']), transitions={'succeeded': 'UCI_MOVE'}, remapping={'target': 'user_data_target'}) smach.StateMachine.add( 'UCI_MOVE', SimpleActionState( uci_topic, ucicommandAction, goal=ucicommandGoal(cmd=ucicommandGoal.CMD_MOVE)), transitions={'succeeded': 'finished'}) Iterator.set_contained_state('CONTAINER_STATE', container_sm, loop_outcomes=['finished']) smach.StateMachine.add('UCI_ITER', tutorial_it, { 'succeeded': 'succeeded', 'aborted': 'aborted' }) # uci_node -> CMD_CALC_MOVE # uci_node -> CMD_MOVE #get new target position #movement #set position in uci outcome = sm.execute() rospy.spin() sis.stop()
def main(): rospy.init_node('tinker_mission_manipulation') trans = tf.TransformListener() rospy.loginfo("Waiting for tf ...") rospy.sleep(3) assert (len(trans.getFrameStrings()) > 0) state = StateMachine(outcomes=['succeeded', 'preempted', 'aborted']) with state: def kinect_callback(userdata, result): userdata.objects = [] objects = [] sum_x = 0 for obj in result.objects.objects: position = obj.pose.pose.pose.position if position.y > 0.5 or position.y < -0.5: continue _levels = [0.10, 0.44, 0.78, 1.12, 1.46, 1.80] for l in _levels: if fabs(l - position.z) < 0.05: position.z = l + 0.05 if position.z > 1.1: position.z += 0.05 obj.header.stamp = rospy.Time(0) kinect_point = PointStamped(header=obj.header, point=position) odom_point = trans.transformPoint('odom', kinect_point) sum_x += odom_point.point.x rospy.loginfo(colored('[Kinect Object(odom)] from:(%f %f %f)', 'yellow'), odom_point.point.x, odom_point.point.y, odom_point.point.z) objects.append(odom_point) avg_x = sum_x / len(objects) for from_point in objects: to_point = copy.deepcopy(from_point) to_point.point.x = avg_x to_point.point.z = find_div(from_point.point.z) userdata.objects.append({'from': from_point, 'to': to_point}) rospy.loginfo(colored('[Kinect Object(odom)] to:(%f %f %f)', 'yellow'), to_point.point.x, to_point.point.y, to_point.point.z) rospy.loginfo(colored('Total Object: %d','green'), len(objects)) return 'succeeded' StateMachine.add('Arm_Mode_Kinect', ArmModeState(ArmModeState.Arm_Mode_Kinect), transitions={'succeeded': 'Start_Button'}) StateMachine.add('Start_Button', MonitorStartButtonState(), transitions={'valid': 'Start_Button', 'invalid': 'S_Kinect_Recognition'}) StateMachine.add('S_Kinect_Recognition', ServiceState(service_name='/kinect_find_objects', service_spec=FindObjects, input_keys=['objects'], output_keys=['objects'], response_cb=kinect_callback), transitions={'succeeded': 'Generate_Report'}) StateMachine.add('Generate_Report', GenerateReportState(image='result.png', text='object_names.txt'), transitions={'succeeded': 'IT_Objects_Iterator'} ) objects_iterator = Iterator(outcomes=['succeeded', 'preempted', 'aborted'], input_keys=['objects'], output_keys=[], it=lambda: state.userdata.objects, it_label='target', exhausted_outcome='succeeded') with objects_iterator: fetch_object_sequence = Sequence(outcomes=['succeeded', 'aborted', 'continue', 'preempted'], input_keys=['target'], connector_outcome='succeeded') with fetch_object_sequence: Sequence.add('Speak', SpeakState('New Object recognized')) Sequence.add('Gripper_Photo', GripperState(GripperState.GRIPPER_OPEN)) Sequence.add('Move_For_Photo', MoveArmState(Point(-0.7, 0, 0), target_key='from'), transitions={'aborted':'continue'}) concurrence = Concurrence(outcomes=['succeeded', 'aborted', 'preempted'], default_outcome='succeeded', child_termination_cb=lambda x: True, input_keys=['target']) with concurrence: Concurrence.add('Move_Fetch', MoveArmState(Point(0.06, 0, 0), target_key='from')) Concurrence.add('Gripper_Laser_sensor', MonitorState('/gripper_laser_sensor', Bool, cond_cb=lambda x,y: False)) Sequence.add('Move_Fetch_Concurrence', concurrence) Sequence.add('Gripper_Fetch', GripperState(GripperState.GRIPPER_CLOSE)) Sequence.add('Move_Fetch_Back', MoveArmState(Point(-0.7, 0, 0), target_key='from')) Sequence.add('Move_Down', MoveArmState(Point(-0.6, 0, 0), target_key='to')) Sequence.add('Move_Put', MoveArmState(Point(0, 0, 0), target_key='to')) Sequence.add('Gripper_Put', GripperState(GripperState.GRIPPER_OPEN)) Sequence.add('Move_Put_Back', MoveArmState(Point(-0.6, 0, 0), target_key='to'), transitions={'succeeded': 'continue'}) Iterator.set_contained_state('Seq_Fetch_Object', fetch_object_sequence, loop_outcomes=['continue']) # end of objects_iterator StateMachine.add('IT_Objects_Iterator', objects_iterator, transitions= {'succeeded': 'A_Move_Reset', 'aborted': 'A_Move_Reset'}) StateMachine.add('A_Move_Reset', ArmModeState(ArmModeState.Arm_Mode_Init), transitions={'succeeded': 'succeeded', 'aborted': 'aborted'}) # Run state machine introspection server for smach viewer intro_server = IntrospectionServer('tinker_mission_manipulation', state, '/tinker_mission_manipulation') intro_server.start() outcome = state.execute() rospy.spin() intro_server.stop()
def main(): rospy.init_node('tinker_mission_manipulation') trans = tf.TransformListener() rospy.loginfo("Waiting for tf ...") rospy.sleep(3) assert (len(trans.getFrameStrings()) > 0) state = StateMachine(outcomes=['succeeded', 'preempted', 'aborted']) with state: def kinect_callback(userdata, result): userdata.objects = [] objects = [] sum_x = 0 for obj in result.objects.objects: position = obj.pose.pose.pose.position if position.y > 0.5 or position.y < -0.5: continue _levels = [0.10, 0.44, 0.78, 1.12, 1.46, 1.80] for l in _levels: if fabs(l - position.z) < 0.05: position.z = l + 0.05 if position.z > 1.1: position.z += 0.05 obj.header.stamp = rospy.Time(0) kinect_point = PointStamped(header=obj.header, point=position) odom_point = trans.transformPoint('odom', kinect_point) sum_x += odom_point.point.x rospy.loginfo( colored('[Kinect Object(odom)] from:(%f %f %f)', 'yellow'), odom_point.point.x, odom_point.point.y, odom_point.point.z) objects.append(odom_point) avg_x = sum_x / len(objects) for from_point in objects: to_point = copy.deepcopy(from_point) to_point.point.x = avg_x to_point.point.z = find_div(from_point.point.z) userdata.objects.append({'from': from_point, 'to': to_point}) rospy.loginfo( colored('[Kinect Object(odom)] to:(%f %f %f)', 'yellow'), to_point.point.x, to_point.point.y, to_point.point.z) rospy.loginfo(colored('Total Object: %d', 'green'), len(objects)) return 'succeeded' StateMachine.add('Arm_Mode_Kinect', ArmModeState(ArmModeState.Arm_Mode_Kinect), transitions={'succeeded': 'Start_Button'}) StateMachine.add('Start_Button', MonitorStartButtonState(), transitions={ 'valid': 'Start_Button', 'invalid': 'S_Kinect_Recognition' }) StateMachine.add('S_Kinect_Recognition', ServiceState(service_name='/kinect_find_objects', service_spec=FindObjects, input_keys=['objects'], output_keys=['objects'], response_cb=kinect_callback), transitions={'succeeded': 'Generate_Report'}) StateMachine.add('Generate_Report', GenerateReportState(image='result.png', text='object_names.txt'), transitions={'succeeded': 'IT_Objects_Iterator'}) objects_iterator = Iterator( outcomes=['succeeded', 'preempted', 'aborted'], input_keys=['objects'], output_keys=[], it=lambda: state.userdata.objects, it_label='target', exhausted_outcome='succeeded') with objects_iterator: fetch_object_sequence = Sequence( outcomes=['succeeded', 'aborted', 'continue', 'preempted'], input_keys=['target'], connector_outcome='succeeded') with fetch_object_sequence: Sequence.add('Speak', SpeakState('New Object recognized')) Sequence.add('Gripper_Photo', GripperState(GripperState.GRIPPER_OPEN)) Sequence.add('Move_For_Photo', MoveArmState(Point(-0.7, 0, 0), target_key='from'), transitions={'aborted': 'continue'}) concurrence = Concurrence( outcomes=['succeeded', 'aborted', 'preempted'], default_outcome='succeeded', child_termination_cb=lambda x: True, input_keys=['target']) with concurrence: Concurrence.add( 'Move_Fetch', MoveArmState(Point(0.06, 0, 0), target_key='from')) Concurrence.add( 'Gripper_Laser_sensor', MonitorState('/gripper_laser_sensor', Bool, cond_cb=lambda x, y: False)) Sequence.add('Move_Fetch_Concurrence', concurrence) Sequence.add('Gripper_Fetch', GripperState(GripperState.GRIPPER_CLOSE)) Sequence.add( 'Move_Fetch_Back', MoveArmState(Point(-0.7, 0, 0), target_key='from')) Sequence.add('Move_Down', MoveArmState(Point(-0.6, 0, 0), target_key='to')) Sequence.add('Move_Put', MoveArmState(Point(0, 0, 0), target_key='to')) Sequence.add('Gripper_Put', GripperState(GripperState.GRIPPER_OPEN)) Sequence.add('Move_Put_Back', MoveArmState(Point(-0.6, 0, 0), target_key='to'), transitions={'succeeded': 'continue'}) Iterator.set_contained_state('Seq_Fetch_Object', fetch_object_sequence, loop_outcomes=['continue']) # end of objects_iterator StateMachine.add('IT_Objects_Iterator', objects_iterator, transitions={ 'succeeded': 'A_Move_Reset', 'aborted': 'A_Move_Reset' }) StateMachine.add('A_Move_Reset', ArmModeState(ArmModeState.Arm_Mode_Init), transitions={ 'succeeded': 'succeeded', 'aborted': 'aborted' }) # Run state machine introspection server for smach viewer intro_server = IntrospectionServer('tinker_mission_manipulation', state, '/tinker_mission_manipulation') intro_server.start() outcome = state.execute() rospy.spin() intro_server.stop()