Add example of chaining autonomous modes together

robotpy_ext/autonomous/__init__.py

@@ -3,4 +3,4 @@
 from .selector import AutonomousModeSelector
 
 # Autonomous mode state machine
-from .stateful_autonomous import state, timed_state, StatefulAutonomous
+from .stateful_autonomous import state, state_alias, timed_state, StatefulAutonomous

robotpy_ext/autonomous/stateful_autonomous.py

@@ -138,6 +138,39 @@ def state(f=None, first=False):
     return _create_wrapper(f, first)
 
 
+class state_alias:
+    '''
+        Not a decorator, used to alias a state so it can be referred to as
+        a different name::
+        
+            class MyAuto(StatefulAutonomous):
+            
+                @state()
+                def something(self):
+                    pass
+                    
+                something_else = state_alias(something)
+                
+        It can be used to set a state as first too (useful in derived classes)::
+        
+            class MyAuto(StatefulAutonomous):
+            
+                @state()
+                def something(self):
+                    pass
+                
+            class MyDerivedAuto(MyAuto):
+            
+                something_else = state_alias(something, first=True)
+        
+    '''
+
+    def __init__(self, state_fn, first=False):
+        self.first = first
+        self.aliased = state_fn
+
+    def __getattr__(self, name):
+        return getattr(self.aliased, name)
 
 class StatefulAutonomous:
     '''
@@ -306,6 +339,10 @@ def __build_states(self):
             state = getattr(self.__class__, name)
             if name.startswith('__') or not hasattr(state, 'first'):
                 continue
+
+            if isinstance(state, state_alias):
+                setattr(self, name, state.aliased)
+                name = state.aliased.name
 
             # is this the first state to execute?
             if state.first:
@@ -314,6 +351,9 @@ def __build_states(self):
 
                 self.__first = name
                 has_first = True
+
+            if isinstance(state, state_alias):
+                continue
 
             # problem: how do we expire old entries?
             # -> what if we just use json? more flexible, but then we can't tune it
@@ -407,9 +447,12 @@ def done(self):
         self.next_state(None)
 
     def next_state(self, name):
-        '''Call this function to transition to the next state
+        '''Call this function to transition to the next state.
         
         :param name: Name of the state to transition to
+        
+        .. note:: The state function will not be called immediately, it will
+                  be called on the next iteration of the control loop.
         '''
         if name is not None:
             self.__state = getattr(self.__class__, name)
@@ -420,12 +463,23 @@ def next_state(self, name):
             return
 
         self.__state.ran = False
+
+    def next_state_now(self, name):
+        '''Call this function to transition to the next state, and call the next
+        state function immediately. Prefer to use :meth:`next_state` instead.
+        
+        :param name: Name of the state to transition to
+        '''
+        self.next_state(name)
+        self.on_iteration(self.__iter_tm)
 
     def on_iteration(self, tm):
         '''This function is called by the autonomous mode switcher, should
            not be called by enduser code. It is called once per control
            loop iteration.'''
 
+        self.__iter_tm = tm
+
         # if you get an error here, then you probably overrode on_enable, 
         # but didn't call super().on_enable(). Don't do that.
         try:

samples/stateful_autonomous/autonomous/chained.py

@@ -0,0 +1,45 @@
+"""
+    Demonstrates chaining multiple autonomous modes together
+"""
+
+
+from robotpy_ext.autonomous import StatefulAutonomous, state, state_alias, timed_state
+
+class Auto1(StatefulAutonomous):
+    @timed_state(duration=1, next_state='do1_2')
+    def do1_1(self):
+        pass
+
+    @timed_state(duration=1, next_state='transition')
+    def do1_2(self):
+        pass
+
+
+class Auto2(StatefulAutonomous):
+    @timed_state(duration=1, next_state='do2_2')
+    def do2_1(self):
+        pass
+
+    @timed_state(duration=1)
+    def do2_2(self):
+        pass
+
+
+class ChainedMode(Auto1, Auto2):
+    '''Chains two autonomous modes together'''
+
+    MODE_NAME = "ChainedMode"
+
+    start = state_alias(Auto1.do1_1, first=True)
+    transition = state_alias(Auto2.do2_2)
+
+class SingleMode(Auto1):
+    '''Runs one of the chained autonomous modes by itself'''
+
+    MODE_NAME = "Single"
+
+    start = state_alias(Auto1.do1_1, first=True)
+
+    @state()
+    def transition(self):
+        pass

samples/stateful_autonomous/robot.py

@@ -10,6 +10,7 @@ def robotInit(self):
 
         # Simple two wheel drive
         self.drive = wpilib.RobotDrive(0, 1)
+        self.drive.setSafetyEnabled(False)
 
         # Items in this dictionary are available in your autonomous mode
         # as attributes on your autonomous object