srs_decision_making: srs_decision_making: srs_configuration

00001 #!/usr/bin/python
00002 #################################################################
00003 ##\file
00004 #
00005 # \note
00006 # Copyright (c) 2011 \n
00007 # Cardiff University \n\n
00008 #
00009 #################################################################
00010 #
00011 # \note
00012 # Project name: Multi-Role Shadow Robotic System for Independent Living
00013 # \note
00014 # ROS stack name: srs
00015 # \note
00016 # ROS package name: srs_decision_making
00017 #
00018 # \author
00019 # Author: Renxi Qiu, email: renxi.qiu@gmail.com
00020 #
00021 # \date Date of creation: Oct 2011
00022 #
00023 # \brief
00024 # Task coordination and interfacing for SRS decision making
00025 #
00026 #################################################################
00027 #
00028 # Redistribution and use in source and binary forms, with or without
00029 # modification, are permitted provided that the following conditions are met:
00030 #
00031 # - Redistributions of source code must retain the above copyright
00032 # notice, this list of conditions and the following disclaimer. \n
00033 #
00034 # - Redistributions in binary form must reproduce the above copyright
00035 # notice, this list of conditions and the following disclaimer in the
00036 # documentation and/or other materials provided with the distribution. \n
00037 #
00038 # This program is free software: you can redistribute it and/or modify
00039 # it under the terms of the GNU Lesser General Public License LGPL as
00040 # published by the Free Software Foundation, either version 3 of the
00041 # License, or (at your option) any later version.
00042 #
00043 # This program is distributed in the hope that it will be useful,
00044 # but WITHOUT ANY WARRANTY; without even the implied warranty of
00045 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
00046 # GNU Lesser General Public License LGPL for more details.
00047 #
00048 # You should have received a copy of the GNU Lesser General Public
00049 # License LGPL along with this program.
00050 # If not, see <http://www.gnu.org/licenses/>.
00051 #
00052 #################################################################
00053 
00054 from srs_monitoring_statemachines import *
00055 from robot_configuration import *
00056 
00057 """
00058 This file contains state machines for robot configuration checking during the operation 
00059 The pause and resume generic state are also included in the file
00060 
00061 The actual robot configuration pre post condition are imported from robot_configuration.py 
00062 
00063 Please note that:
00064 As minimal control unit of the DM is generic state, therefore the pause and resume of the generic states may not be the same as the pause and resume of the real actions of robot.
00065 and, it will be useful to check the pause within the generic state to avoid unnecessary time out.   
00066 
00067 """
00068 
00069 # Checking during robot is paused
00070 class state_checking_during_paused (smach.State):
00071     def __init__(self):
00072         smach.State.__init__(self , outcomes =['resume', 'stopped', 'preempted'])
00073     
00074     
00075     def execute (self, userdata):
00076 
00077         global current_task_info
00078         
00079         
00080         while not self.preempt_requested():
00081             #if stop command has been received during the pause
00082             if current_task_info.get_stop_required():
00083                 #reset the flag to normal
00084                 current_task_info.set_stop_acknowledged(True)
00085                 try:
00086                     sss.say([current_task_info.speaking_language['Stop']],False)
00087                 except:
00088                     print sys.exc_info()
00089                     
00090                 #complete the state and return stop
00091                 return 'stopped'
00092             
00093             #if another command with higher priority received during the pause
00094             elif current_task_info.get_customised_preempt_required():
00095                 #reset the flag to normal
00096                 current_task_info.set_customised_preempt_acknowledged(True)
00097                 #complete the state and return customised_preempted
00098                 return 'preempted'
00099             
00100             #if task is resumed
00101             elif not current_task_info.get_pause_required():
00102                 #return to last operation
00103                 try:
00104                     sss.say([current_task_info.speaking_language['Resume']],False)
00105                 except:
00106                     print sys.exc_info()                
00107                 return 'resume'
00108                         
00109             #elif rospy.is_shutdown:
00110             #    return 'preempted' 
00111             
00112             #sleep 1 sec and check again
00113             rospy.sleep(1)
00114             
00115         self.service_preempt()
00116         
00117         return 'preempted'
00118 
00119 
00120 def robot_configuration(parent, action_name, action_stage):
00121     
00122     global current_task_info
00123     global component_list
00124     global robot_config
00125     global robot_config_need_no_action
00126     
00127     handles = list()
00128     
00129     if action_name == 'navigation':
00130         if current_task_info.object_on_tray: 
00131             if current_task_info.object_in_hand:
00132                 action_name = 'navigation_object_on_tray'
00133             else:
00134                 action_name = 'navigation_object_on_tray_and_sdh'
00135         else:
00136             if current_task_info.object_in_hand:
00137                 action_name = 'navigation_object_in_sdh'
00138             else:
00139                 action_name = 'navigation_no_object'
00140                 
00141     try:
00142         #bring robot into the pre-configuration state     
00143         if action_stage == 'pre-config':
00144             #initial the sss handles
00145             for index in range(len(component_list)):
00146                 if robot_config_pre[action_name][component_list[index]] in robot_config_need_no_action: 
00147                     handles.append(None)
00148                 else:
00149                     if component_list[index] == "arm":
00150                         #handles.append(sss.move_planned(component_list[index], robot_config_pre[action_name][component_list[index]], False))
00151                         handles.append(sss.move(component_list[index], robot_config_pre[action_name][component_list[index]], False))
00152                     else:
00153                         handles.append(sss.move(component_list[index], robot_config_pre[action_name][component_list[index]], False))
00154                     
00155         #bring robot into the post-configuration state     
00156         if action_stage == 'post-config':
00157             #initial the sss handles
00158             for index in range(len(component_list)):
00159                 if robot_config_post[action_name][component_list[index]] in robot_config_need_no_action: 
00160                     handles.append(None)
00161                 else:
00162                     if component_list[index] == "arm":
00163                         handles.append(sss.move(component_list[index], robot_config_post[action_name][component_list[index]], False))
00164                     else:
00165                         handles.append(sss.move(component_list[index], robot_config_post[action_name][component_list[index]], False))             
00166                     
00167     except KeyError:
00168         print("dictionary key is not found in the set of existing keys")    
00169         return failed
00170     except IndexError:
00171         print("Index is out of range")
00172         return failed
00173     except:
00174         print("unexpected error during %s and %s",action_name,action_stage)
00175         return failed
00176         
00177     #wait for action to finish
00178     for index in range(len(component_list)):
00179         if handles[index] != None:
00180             if parent.preempt_requested():  
00181                 parent.service_preempt()    
00182                 return 'preempted'
00183             else:                
00184                 handles[index].wait()
00185                 ###########################################################################
00186                 #TO DO 
00187                 #need check the state of the handles. return failed after the handles fails.
00188                 #
00189                 ############################################################################
00190 
00191     return 'succeeded'
00192     
00193                     
00194             
00195              
00196 
00197 
00198 class pre_conf(smach.State):
00199     def __init__(self):
00200         smach.State.__init__(self , outcomes=['succeeded', 'failed', 'preempted'], input_keys=['action_name'])
00201     
00202     def execute (self, userdata):    
00203         return robot_configuration(self, userdata.action_name, 'pre-config')
00204     
00205         
00206 class post_conf(smach.State):
00207     def __init__(self):
00208         smach.State.__init__(self , outcomes=['succeeded', 'failed',  'preempted'], input_keys=['action_name'])
00209     
00210     def execute (self, userdata):    
00211         return robot_configuration(self, userdata.action_name, 'post-config')
00212 
00213 
00214 co_sm_pre_conf = smach.Concurrence (outcomes=['succeeded', 'failed', 'stopped', 'preempted', 'paused'],
00215                  default_outcome='failed',
00216                  input_keys=['action_name'],
00217                  child_termination_cb = common_child_term_cb,
00218                  outcome_cb = common_out_cb)
00219 with co_sm_pre_conf: 
00220             smach.Concurrence.add('State_Checking_During_Operation', state_checking_during_operation())
00221             smach.Concurrence.add('MAIN_OPERATION', pre_conf(),
00222                                   remapping={'action_name':'action_name'})
00223             
00224 co_sm_post_conf = smach.Concurrence  (outcomes=['succeeded', 'failed', 'stopped', 'preempted', 'paused'],
00225                  default_outcome='failed',
00226                  input_keys=['action_name'],
00227                  child_termination_cb = common_child_term_cb,
00228                  outcome_cb = common_out_cb)
00229 with co_sm_post_conf: 
00230             smach.Concurrence.add('State_Checking_During_Operation', state_checking_during_operation())
00231             smach.Concurrence.add('MAIN_OPERATION', post_conf(),
00232                                   remapping={'action_name':'action_name'})
00233 
00234 """
00235 #It is impossible to reach paused state as the sss used in pre/post conf checking the pause by itself, and will never return time-out 
00236 class co_sm_pre_conf(smach.Concurrence):
00237     def __init__(self, action_name=''):
00238         smach.Concurrence.__init__(outcomes=['succeeded', 'failed', 'stopped', 'preempted', 'paused'],
00239                  default_outcome='failed',
00240                  child_termination_cb = common_child_term_cb,
00241                  outcome_cb = common_out_cb)
00242         self.action_name=action_name
00243                                   
00244         with self: 
00245             smach.Concurrence.add('State_Checking_During_Operation', state_checking_during_operation())
00246             smach.Concurrence.add('MAIN_OPERATION', preconf(self.action_name))
00247     
00248 #It is impossible to reach paused state as the sss used in pre/post conf checking the pause by itself, and will never return time-out 
00249 class co_sm_post_conf(smach.Concurrence):
00250     def __init__(self, action_name=''):
00251         smach.Concurrence.__init__(outcomes=['succeeded', 'failed', 'stopped', 'preempted', 'paused'],
00252                  default_outcome='failed',
00253                  child_termination_cb = common_child_term_cb,
00254                  outcome_cb = common_out_cb)
00255         self.action_name=action_name
00256                                   
00257         with self: 
00258             smach.Concurrence.add('State_Checking_During_Operation', state_checking_during_operation())
00259             smach.Concurrence.add('MAIN_OPERATION', post_conf(self.action_name))
00260 """            
00261 
00262 
00263 """
00264 def add_common_states(parent):
00265     with parent:
00266             smach.StateMachine.add('PRE_CONFIG', co_sm_pre_conf,
00267                     transitions={'succeeded':'ACTION', 'paused':'PAUSED_DURING_PRE_CONFIG', 'failed':'failed', 'preempted':'preempted', 'stopped':'stopped'},
00268                     remapping={'action_name':'action_name'})
00269         
00270             smach.StateMachine.add('POST_CONFIG', co_sm_post_conf,
00271                     transitions={'succeeded':'succeeded', 'paused':'PAUSED_DURING_POST_CONFIG', 'failed':'failed', 'preempted':'preempted', 'stopped':'stopped'},
00272                     remapping={'action_name':'action_name'})
00273             
00274             smach.StateMachine.add('PAUSED_DURING_PRE_CONFIG', state_checking_during_paused(),
00275                     transitions={'resume':'PRE_CONFIG','preempted':'preempted', 'stopped':'stopped'})
00276             
00277             smach.StateMachine.add('PAUSED_DURING_ACTION', state_checking_during_paused(),
00278                     transitions={'resume':'ACTION','preempted':'preempted', 'stopped':'stopped'})
00279             
00280             smach.StateMachine.add('PAUSED_DURING_POST_CONFIG', state_checking_during_paused(),
00281                     transitions={'resume':'POST_CONFIG','preempted':'preempted', 'stopped':'stopped'})    
00282 """   
00283 
00284 
00285 class srs_navigation_operation(smach.StateMachine):
00286     
00287     def __init__(self):    
00288         smach.StateMachine.__init__(self, outcomes=['succeeded', 'not_completed', 'failed', 'stopped', 'preempted'],
00289                                     input_keys=['target_base_pose','semi_autonomous_mode'])
00290         #self.action_name = 'navigation'
00291         self.userdata.action_name = 'navigation'
00292         #add_common_states(self)
00293         
00294         with self:              
00295 
00296             smach.StateMachine.add('PRE_CONFIG', co_sm_pre_conf,
00297                     transitions={'succeeded':'ACTION', 'paused':'PAUSED_DURING_PRE_CONFIG', 'failed':'failed', 'preempted':'preempted', 'stopped':'stopped'},
00298                     remapping={'action_name':'action_name'})
00299             
00300             smach.StateMachine.add('ACTION', co_sm_navigation,
00301                     transitions={'succeeded':'POST_CONFIG', 'not_completed':'not_completed', 'paused':'PAUSED_DURING_ACTION', 'failed':'failed', 'preempted':'preempted', 'stopped':'stopped'},
00302                     remapping={'semi_autonomous_mode':'semi_autonomous_mode','target_base_pose':'target_base_pose'}) 
00303             
00304             smach.StateMachine.add('POST_CONFIG', co_sm_post_conf,
00305                     transitions={'succeeded':'succeeded', 'paused':'PAUSED_DURING_POST_CONFIG', 'failed':'failed', 'preempted':'preempted', 'stopped':'stopped'},
00306                     remapping={'action_name':'action_name'})
00307             
00308             smach.StateMachine.add('PAUSED_DURING_PRE_CONFIG', state_checking_during_paused(),
00309                     transitions={'resume':'PRE_CONFIG','preempted':'preempted', 'stopped':'stopped'})
00310             
00311             smach.StateMachine.add('PAUSED_DURING_ACTION', state_checking_during_paused(),
00312                     transitions={'resume':'ACTION','preempted':'preempted', 'stopped':'stopped'})
00313             
00314             smach.StateMachine.add('PAUSED_DURING_POST_CONFIG', state_checking_during_paused(),
00315                     transitions={'resume':'POST_CONFIG','preempted':'preempted', 'stopped':'stopped'})    
00316     
00317 class srs_put_on_tray_operation(smach.StateMachine):
00318     
00319     def __init__(self):    
00320         smach.StateMachine.__init__(self, outcomes=['succeeded', 'not_completed', 'failed', 'stopped', 'preempted'],
00321                                     input_keys=['grasp_categorisation'])
00322         self.userdata.action_name = 'put_on_tray'
00323         #add_common_states(self)
00324         
00325         with self:
00326             smach.StateMachine.add('PRE_CONFIG', co_sm_pre_conf,
00327                     transitions={'succeeded':'ACTION', 'paused':'PAUSED_DURING_PRE_CONFIG', 'failed':'failed', 'preempted':'preempted', 'stopped':'stopped'},
00328                     remapping={'action_name':'action_name'})
00329             
00330             smach.StateMachine.add('ACTION', co_sm_transfer_to_tray,
00331                     transitions={'succeeded':'POST_CONFIG', 'not_completed':'not_completed', 'paused':'PAUSED_DURING_ACTION', 'failed':'failed', 'preempted':'preempted', 'stopped':'stopped'},
00332                     remapping={'grasp_categorisation':'grasp_categorisation'})
00333 
00334         
00335             smach.StateMachine.add('POST_CONFIG', co_sm_post_conf,
00336                     transitions={'succeeded':'succeeded', 'paused':'PAUSED_DURING_POST_CONFIG', 'failed':'failed', 'preempted':'preempted', 'stopped':'stopped'},
00337                     remapping={'action_name':'action_name'})
00338             
00339             smach.StateMachine.add('PAUSED_DURING_PRE_CONFIG', state_checking_during_paused(),
00340                     transitions={'resume':'PRE_CONFIG','preempted':'preempted', 'stopped':'stopped'})
00341             
00342             smach.StateMachine.add('PAUSED_DURING_ACTION', state_checking_during_paused(),
00343                     transitions={'resume':'ACTION','preempted':'preempted', 'stopped':'stopped'})
00344             
00345             smach.StateMachine.add('PAUSED_DURING_POST_CONFIG', state_checking_during_paused(),
00346                     transitions={'resume':'POST_CONFIG','preempted':'preempted', 'stopped':'stopped'})    
00347 
00348 class srs_enviroment_update_operation(smach.StateMachine):
00349     
00350     def __init__(self):    
00351         smach.StateMachine.__init__(self, outcomes=['succeeded', 'not_completed', 'failed', 'stopped', 'preempted'],
00352                                     input_keys=['scan_pose_list'])
00353         self.userdata.action_name = 'enviroment_update'
00354         #add_common_states(self)
00355         
00356         with self:
00357             smach.StateMachine.add('PRE_CONFIG', co_sm_pre_conf,
00358                     transitions={'succeeded':'ACTION', 'paused':'PAUSED_DURING_PRE_CONFIG', 'failed':'failed', 'preempted':'preempted', 'stopped':'stopped'},
00359                     remapping={'action_name':'action_name'})
00360 
00361             smach.StateMachine.add('ACTION', co_sm_enviroment_update,
00362                     transitions={'succeeded':'POST_CONFIG', 'not_completed':'not_completed', 'paused':'PAUSED_DURING_ACTION', 'failed':'failed', 'preempted':'preempted', 'stopped':'stopped'},
00363                     remapping={'scan_pose_list':'scan_pose_list'})
00364         
00365             smach.StateMachine.add('POST_CONFIG', co_sm_post_conf,
00366                     transitions={'succeeded':'succeeded', 'paused':'PAUSED_DURING_POST_CONFIG', 'failed':'failed', 'preempted':'preempted', 'stopped':'stopped'},
00367                     remapping={'action_name':'action_name'})
00368             
00369             smach.StateMachine.add('PAUSED_DURING_PRE_CONFIG', state_checking_during_paused(),
00370                     transitions={'resume':'PRE_CONFIG','preempted':'preempted', 'stopped':'stopped'})
00371             
00372             smach.StateMachine.add('PAUSED_DURING_ACTION', state_checking_during_paused(),
00373                     transitions={'resume':'ACTION','preempted':'preempted', 'stopped':'stopped'})
00374             
00375             smach.StateMachine.add('PAUSED_DURING_POST_CONFIG', state_checking_during_paused(),
00376                     transitions={'resume':'POST_CONFIG','preempted':'preempted', 'stopped':'stopped'})    
00377 
00378             
00379 
00380 class srs_detection_operation(smach.StateMachine):
00381     
00382     def __init__(self):    
00383         smach.StateMachine.__init__(self, outcomes=['succeeded', 'not_completed', 'failed', 'stopped', 'preempted'],
00384                                     input_keys=['target_object_name','target_object_id', 'target_workspace_name','semi_autonomous_mode'],
00385                                     output_keys=['target_object_pose','target_object'])
00386         self.userdata.action_name = 'detection'
00387         self.userdata.target_object_pose = Pose()
00388         #add_common_states(self)
00389         
00390         with self:
00391                 
00392             smach.StateMachine.add('PRE_CONFIG', co_sm_pre_conf,
00393                     transitions={'succeeded':'ACTION', 'paused':'PAUSED_DURING_PRE_CONFIG', 'failed':'failed', 'preempted':'preempted', 'stopped':'stopped'},
00394                     remapping={'action_name':'action_name'})        
00395             
00396             smach.StateMachine.add('ACTION', co_sm_detection,
00397                     transitions={'succeeded':'POST_CONFIG', 'not_completed':'not_completed', 'paused':'PAUSED_DURING_ACTION', 'failed':'failed', 'preempted':'preempted', 'stopped':'stopped'},
00398                     remapping={'target_object_name':'target_object_name',
00399                                 'target_object_id':'target_object_id',
00400                                 'target_workspace_name':'target_workspace_name',
00401                                 'semi_autonomous_mode':'semi_autonomous_mode',
00402                                 'target_object_pose':'target_object_pose',
00403                                 'target_object':'target_object'})
00404         
00405             smach.StateMachine.add('POST_CONFIG', co_sm_post_conf,
00406                     transitions={'succeeded':'succeeded', 'paused':'PAUSED_DURING_POST_CONFIG', 'failed':'failed', 'preempted':'preempted', 'stopped':'stopped'},
00407                     remapping={'action_name':'action_name'})
00408             
00409             smach.StateMachine.add('PAUSED_DURING_PRE_CONFIG', state_checking_during_paused(),
00410                     transitions={'resume':'PRE_CONFIG','preempted':'preempted', 'stopped':'stopped'})
00411             
00412             smach.StateMachine.add('PAUSED_DURING_ACTION', state_checking_during_paused(),
00413                     transitions={'resume':'ACTION','preempted':'preempted', 'stopped':'stopped'})
00414             
00415             smach.StateMachine.add('PAUSED_DURING_POST_CONFIG', state_checking_during_paused(),
00416                     transitions={'resume':'POST_CONFIG','preempted':'preempted', 'stopped':'stopped'})    
00417 
00418 class srs_grasp_operation(smach.StateMachine):
00419     
00420     def __init__(self):    
00421         smach.StateMachine.__init__(self, outcomes=['succeeded', 'not_completed', 'failed', 'stopped', 'preempted'],
00422                                     input_keys=['target_object_name','target_object_id','target_object','target_workspace_name','semi_autonomous_mode'],
00423                                     output_keys=['grasp_categorisation'])
00424         self.userdata.action_name = 'grasp'
00425         self.userdata.grasp_categorisation = ""
00426         self.userdata.target_object_old_pose = Pose()
00427         
00428         #add_common_states(self)
00429         
00430         with self:
00431             smach.StateMachine.add('PRE_CONFIG', co_sm_pre_conf,
00432                     transitions={'succeeded':'ACTION', 'paused':'PAUSED_DURING_PRE_CONFIG', 'failed':'failed', 'preempted':'preempted', 'stopped':'stopped'},
00433                     remapping={'action_name':'action_name'})
00434             
00435             smach.StateMachine.add('ACTION', co_sm_new_grasp,
00436                     transitions={'succeeded':'POST_CONFIG', 'not_completed':'not_completed', 'paused':'PAUSED_DURING_ACTION', 'failed':'failed', 'preempted':'preempted', 'stopped':'stopped'},
00437                     remapping={'target_object_name':'target_object_name',
00438                                 'semi_autonomous_mode':'semi_autonomous_mode',
00439                                 'target_object_id':'target_object_id',
00440                                 'target_object':'target_object',
00441                                 'target_workspace_name':'target_workspace_name',
00442                                 'grasp_categorisation':'grasp_categorisation'})       
00443              
00444             smach.StateMachine.add('POST_CONFIG', co_sm_post_conf,
00445                     transitions={'succeeded':'succeeded', 'paused':'PAUSED_DURING_POST_CONFIG', 'failed':'failed', 'preempted':'preempted', 'stopped':'stopped'},
00446                     remapping={'action_name':'action_name'})
00447             
00448             smach.StateMachine.add('PAUSED_DURING_PRE_CONFIG', state_checking_during_paused(),
00449                     transitions={'resume':'PRE_CONFIG','preempted':'preempted', 'stopped':'stopped'})
00450             
00451             smach.StateMachine.add('PAUSED_DURING_ACTION', state_checking_during_paused(),
00452                     transitions={'resume':'ACTION','preempted':'preempted', 'stopped':'stopped'})
00453             
00454             smach.StateMachine.add('PAUSED_DURING_POST_CONFIG', state_checking_during_paused(),
00455                     transitions={'resume':'POST_CONFIG','preempted':'preempted', 'stopped':'stopped'})    
00456 
00457 
00458 class srs_old_grasp_operation(smach.StateMachine):
00459     
00460     def __init__(self):    
00461         smach.StateMachine.__init__(self, outcomes=['succeeded', 'not_completed', 'failed', 'stopped', 'preempted'],
00462                                     input_keys=['target_object_name','target_object_id','target_object','semi_autonomous_mode'],
00463                                     output_keys=['grasp_categorisation'])
00464         self.userdata.action_name = 'grasp'
00465         self.userdata.grasp_categorisation = ""
00466         self.userdata.target_object_old_pose = Pose()
00467         
00468         #add_common_states(self)
00469         
00470         with self:
00471             smach.StateMachine.add('PRE_CONFIG', co_sm_pre_conf,
00472                     transitions={'succeeded':'ACTION', 'paused':'PAUSED_DURING_PRE_CONFIG', 'failed':'failed', 'preempted':'preempted', 'stopped':'stopped'},
00473                     remapping={'action_name':'action_name'})
00474             
00475             smach.StateMachine.add('ACTION', co_sm_old_grasp,
00476                     transitions={'succeeded':'POST_CONFIG', 'not_completed':'not_completed', 'paused':'PAUSED_DURING_ACTION', 'failed':'failed', 'preempted':'preempted', 'stopped':'stopped'},
00477                     remapping={'target_object_name':'target_object_name',
00478                                 'semi_autonomous_mode':'semi_autonomous_mode',
00479                                 'target_object_id':'target_object_id',
00480                                 'target_object':'target_object',
00481                                 'grasp_categorisation':'grasp_categorisation'})       
00482              
00483             smach.StateMachine.add('POST_CONFIG', co_sm_post_conf,
00484                     transitions={'succeeded':'succeeded', 'paused':'PAUSED_DURING_POST_CONFIG', 'failed':'failed', 'preempted':'preempted', 'stopped':'stopped'},
00485                     remapping={'action_name':'action_name'})
00486             
00487             smach.StateMachine.add('PAUSED_DURING_PRE_CONFIG', state_checking_during_paused(),
00488                     transitions={'resume':'PRE_CONFIG','preempted':'preempted', 'stopped':'stopped'})
00489             
00490             smach.StateMachine.add('PAUSED_DURING_ACTION', state_checking_during_paused(),
00491                     transitions={'resume':'ACTION','preempted':'preempted', 'stopped':'stopped'})
00492             
00493             smach.StateMachine.add('PAUSED_DURING_POST_CONFIG', state_checking_during_paused(),
00494                     transitions={'resume':'POST_CONFIG','preempted':'preempted', 'stopped':'stopped'})
srs_configuration_statemachines.py
