def __init__(self):
transitions = [
['login', InteractionState.start, InteractionState.login],
['register', InteractionState.start, InteractionState.register],
['study', InteractionState.login, InteractionState.study],
['study', InteractionState.register, InteractionState.study],
['learnnew', InteractionState.study, InteractionState.learnnew],
['review', InteractionState.study, InteractionState.review],
['answer', InteractionState.learnnew, InteractionState.answer],
['answer', InteractionState.review, InteractionState.answer],
['skip', InteractionState.learnnew, InteractionState.skip],
['skip', InteractionState.review, InteractionState.skip],
['study', InteractionState.answer, InteractionState.study],
['study', InteractionState.skip, InteractionState.study],
['exit', InteractionState.login, InteractionState.start],
['exit', InteractionState.register, InteractionState.start],
['exit', InteractionState.start, InteractionState.finish],
['exit', InteractionState.study, InteractionState.finish]
# ['error', InteractionState.learnnew, InteractionState.study],
# ['error', InteractionState.review, InteractionState.study]
]
Machine.__init__(self,
states=InteractionState,
initial=InteractionState.start,
transitions=transitions)
def __init__(self):
states = ['pre_trial', 'moving']
pre_trial_t = {
'source': 'pre_trial',
'trigger': 'step',
'conditions': 'wait_for_space',
'after': ['reset_baseline', 'start_trial_countdown'],
'dest': 'moving'
}
moving_t = {
'source': 'moving',
'prepare': [],
'trigger': 'step',
'conditions': 'time_elapsed',
'after': ['start_trial_countdown'],
'dest': 'pre_trial'
}
transitions = [pre_trial_t, moving_t]
Machine.__init__(self,
states=states,
transitions=transitions,
initial='pre_trial')
def __init__(self):
# Define the different states of the state machine
states = ['secure', 'takeoff', 'follow', 'take_picture', \
'land', 'reacquisition', 'emergency']
# Define the transitions between states
# FORMAT: ['trigger_event', 'source_state', 'destination_state']
transitions = [
['takeoff_command', 'secure', 'takeoff'],
['takeoff_alt_reached', 'takeoff', 'follow'],
['picture_command', 'follow', 'take_picture'],
['picture_taken', 'take_picture', 'land'],
['land_alt_reached', 'land', 'secure'],
[
'emergency_condition',
['takeoff', 'follow', 'take_picture', 'land'], 'emergency'
], ['takeoff_tag_lost', 'takeoff', 'reacquisition'],
['follow_tag_lost', 'follow', 'reacquisition'],
['land_tag_lost', 'land', 'reacquisition'],
['take_picture_tag_lost', 'take_picture', 'reacquisition'],
['takeoff_tag_found', 'reacquisition', 'takeoff'],
['follow_tag_found', 'reacquisition', 'follow'],
['land_tag_found', 'reacquisition', 'land'],
['take_picture_tag_found', 'reacquisition', 'take_picture'],
['timed_out', 'reacquisition', 'emergency'],
['reset', 'emergency', 'secure']
]
Machine.__init__(self, states=states, transitions=transitions, \
initial='secure')
def __init__(self):
self.states = [
{'name': 'Begin'}, #
{'name': 'End'}, #
{'name': 'ChoosePage'}, #
{'name': 'FirstPage'}, #
{'name': 'SecondPage'}, #
{'name': 'Error'} #
]
self.transitions = [
{'trigger': 'step', 'source': 'Begin', 'dest': 'ChoosePage'},
{'trigger': 'step', 'source': 'ChoosePage', 'dest': 'FirstPage', 'conditions': ['verify', 'answerIsOne'], 'after': 'to_ChoosePage'},
# {'trigger': 'step', 'source': 'ChoosePage', 'dest': 'Error', 'after': 'err'},
# {'trigger': 'step', 'source': 'ChoosePage', 'dest': 'FirstPage', 'conditions': 'verify', 'after': 'to_ChoosePage'},
{'trigger': 'step', 'source': 'FirstPage', 'dest': 'ChoosePage'},
# {'trigger': 'step', 'source': 'FirstPage', 'dest': 'Error', 'after': 'err'},
{'trigger': 'step', 'source': 'ChoosePage', 'dest': 'SecondPage', 'conditions': ['verify', 'answerIsTwo'], 'after': 'to_ChoosePage'},
# {'trigger': 'step', 'source': 'ChoosePage', 'dest': 'SecondPage', 'conditions': 'verify', 'after': 'to_ChoosePage'},
{'trigger': 'step', 'source': 'SecondPage', 'dest': 'ChoosePage'},
{'trigger': 'step', 'source': 'SecondPage', 'dest': 'Error', 'after': 'err'},
# {'trigger': 'step', 'source': 'ChoosePage', 'dest': 'End', 'conditions': ['verify', 'answerIsThree']},
# {'trigger': 'step', 'source': 'ChoosePage', 'dest': 'End', 'conditions': 'verify'}
# {'trigger': 'step', 'source': 'ChoosePage', 'dest': 'End'},
{'trigger': 'step', 'source': '*', 'dest': 'End'}
]
Machine.__init__(self, states=self.states, transitions=self.transitions,
initial='Begin', send_event=True)
self.pageNumber = None
self.answer = None
def __init__(self, fridge):
states = ['pump_hot_cooling_mainplate',
'pump_warming',
'pump_warming_cooling_mainplate',
'cooling_pump',
'cold',
'heat_switch_cooling',
'system_warm',
'warming_up',
'manual',
'unknown'
]
Machine.__init__(self, states=states,
initial='manual')
self.fridge = fridge
self.config = fridge.config
self.manual_mode = True
self.time_last_transition = time.time()
self.logger = None
self.console = None
# self.logger = logging.getLogger('fridge_machine')
# self.logger.setLevel(logging.INFO)
# self.logger.info('logging from fridge_machine')
self.recycle_hour = self.config['recycle_time']
self.recycle_period = \
datetime.timedelta(days=self.config['recycle_period'])
self.update_next_recycle_time()
def __init__(self, acc):
Machine.__init__(self, states=BicycleController.states, initial='nap')
self.previous = self.state
self.accelFileName = ''
self.gpsFileName = ''
self.accelDataBuffer = ''
self.lat = 1.0
self.lon = 1.0
self.accel = acc
self.turningRight = False
self.turningLeft = False
self.freshData = False
self.add_transition('awaken', 'nap', 'commute')
self.add_transition('slumber', 'commute', 'nap')
self.add_transition('there', 'commute', 'ride', before='emailThere')
self.add_transition('back_again',
'ride',
'commute',
before='emailBack')
def __init__(self, bot):
self.bot = bot
self.language = 'EN' # TODO
states = [
{'name': 'unregistered'},
{'name': 'idle'},
{'name': 'dummy_state'}]
# Transitions
transitions = [
{'trigger': 'reset', 'source': '*', 'dest': 'unregistered'},
{'trigger': 'dummy', 'source': '*', 'dest': 'dummy_state'}
]
# Append to Machine
try:
self.transitions += transitions
except BaseException:
self.transitions = transitions
try:
self.states += states
except BaseException:
self.states = states
Machine.__init__(
self,
states=self.states,
transitions=self.transitions,
send_event=True,
initial='unregistered')
def __init__(self):
states = ['wait',
'in_trial',
'post_trial',
'done']
transitions = [
{'source': 'wait',
'trigger': 'step',
'conditions': 'check_for_space',
'after': 'remove_text',
'dest': 'in_trial'},
{'source': 'in_trial',
'trigger': 'step',
'prepare': ['update_target_pos', 'update_target_color_and_count'],
'conditions': 'samples_exhausted',
'after': ['draw_time_on_target', 'start_countdown'],
'dest': 'post_trial'},
{'source': 'post_trial',
'trigger': 'step',
'conditions': 'time_elapsed',
'dest': 'done'}
]
Machine.__init__(self, states=states,
transitions=transitions, initial='wait')
def __init__(self, **kwargs):
super(Comment, self).__init__(**kwargs)
# 状态定义
states = ['wait', 'pass', 'not pass']
Machine.__init__(self, states=states, initial='wait')
self.add_transition('review', 'wait', 'pass')
self.status = 'wait'
def __init__(self, name):
self.name = name
Machine.__init__(self,
states=ServerState.STATES,
initial=self.DEFAULT_STATE)
self.define_state_paths()
self.path = [self.DNE]
def __init__(self):
# States
states = ["s"+str(i) for i in range(14)]
transitions = splitter(["s0->s1",
"s1->s2",
"s2->s3",
"s3->s2",
"s3->s4",
"s3->s5",
"s4->s5",
"s5->s6",
"s5->s8",
"s6->s6",
"s6->s7",
"s8->s9",
"s0->s10",
"s10->s11",
"s11->s12",
"s7->s2",
"s7->s6",
"s7->s8",
"s7->s13",
"s13->s7"])
Machine.__init__(self, states=states, initial='s0', transitions=transitions)
self.to_s0()
def __init__(self):
self.running = True
self.isEnabled = False
self.isEjectEnabled = False
self.isDispenseEnabled = False
self.isOK = False
# break beam sensor status
self.break_beam_sensor = False
# conveyor counter reset
self.idxcount = 0
#setup break beam sensor
GPIO.setmode(GPIO.BCM)
# GPIO 24 set up as input, pulled up to avoid false detection.
GPIO.setup(24, GPIO.IN, pull_up_down=GPIO.PUD_UP)
states = ['init', 'ready', 'start', 'stop', 'dispense', 'eject']
Machine.__init__(self, states=states, initial='init')
self.add_transition('trigger',
'init',
'ready',
conditions='is_enabled')
self.add_transition('trigger', 'ready', 'start', conditions='is_hw_ok')
self.add_transition('trigger',
'start',
'stop',
conditions='is_beam_broken')
self.add_transition('trigger',
'stop',
'dispense',
conditions='is_dispense_ready')
self.add_transition('trigger', 'dispense', 'eject')
self.add_transition('trigger', 'eject', 'ready')
def __init__(self):
states=['chitchat',
'requestingRide', 'offeringRide',
'sendingLocation','sendingDestination',
'waiting',
'matchFound','nomatchFound',
'completed']
transitions = [
{ 'trigger': 'abort', 'source': '*', 'dest': 'chitchat'},
{ 'trigger': 'wantRide', 'source': 'chitchat', 'dest': 'requestingRide'},
{ 'trigger': 'offerRide', 'source': 'chitchat', 'dest': 'offeringRide'},
{ 'trigger': 'hasToSendLocation', 'source': 'requestingRide', 'dest': 'sendingLocation'},
{ 'trigger': 'hasToSendLocation', 'source': 'offeringRide', 'dest': 'sendingLocation' },
{ 'trigger': 'hasToSendDestination', 'source': 'sendingLocation', 'dest': 'sendingDestination' },
{ 'trigger': 'gotPosition', 'source': 'sendingDestination', 'dest': 'waiting'},
{ 'trigger': 'OK', 'source': 'waiting', 'dest': 'matchFound' },
{ 'trigger': 'sorry', 'source': 'waiting', 'dest': 'nomatchFound' },
{ 'trigger': 'done', 'source': 'matchFound', 'dest': 'completed' },
{ 'trigger': 'done', 'source': 'nomatchFound', 'dest': 'completed' },
{ 'trigger': 'end', 'source': 'completed', 'dest': 'chitchat' },
]
Machine.__init__(self, states=states, transitions=transitions,auto_transitions=False,initial='chitchat')
def __init__(self):
state = ['Up', 'Failed', 'Maintenance', 'Blocked']
Machine.__init__(self, states = state, initial='Up')
self.add_transition('start', 'Up', 'Up', after = "startJob")
self.add_transition('fail', 'Up', 'Failed', after = 'startFail')
self.add_transition('repair', 'Failed', 'Up', after = 'rep')
self.add_transition('maint', 'Up', 'Maintenance', after='startmaint')
self.add_transition('maintcpl', 'Maintenance', 'Up')
self.add_transition('interrep', 'Failed', 'Maintenance', after='startmaint')
self.add_transition('block', 'Up', 'Blocked')
self.add_transition('unblock', 'Blocked', 'Up')
self.queue = SortedSet(key = lambda job: job.arrivalTime)
self.numServers = 1
self.busyServers = 0
self.prevState = None
Server._ids +=1
self.serviceTimeDistribution = None
self.name = "Server {}".format(Server._ids)
self.In = None
self.Out = None
self.scheduler = None
self.activejob = None
self.interuptjob = None
#debugging
self.jobsarrived = 0
self.jobsprocessed = 0
self.numfailures = 0
self.nummaint = 0
self.onzin = 0
def __init__(self, data_dic):
if data_dic:
self.states = data_dic['states']
self.transitions = data_dic['transitions']
self.audio_data = data_dic['audio_data']
self.recognition_data = data_dic['recognition_data']
self.tts_data = data_dic['tts_data']
self.grammar_data = data_dic['grammar_data']
self.trigger_data = data_dic['trigger_data']
self.action_data = data_dic['action_data']
self.local = data_dic['local_proc']
self.player = TestVoice(local=self.local)
# available only when deployed in a raspberry pi
if app.config['RASPI']:
self.traction = CholitaTraction()
# init fsm part
Machine.__init__(self,
states=self.states,
transitions=self.transitions,
initial='init',
ignore_invalid_triggers=True)
else:
pass
def __init__(self, vehicle):
self.cur_mode = None
self.mode_pub = None
self.mode_pub_rate = None
self.prev_publish_time = None
self.set_mode_service = None
self.vehicle = vehicle
modes = [
Inactive(self.vehicle),
RTD(self.vehicle),
Autospray(self.vehicle)
]
self.initial_state = modes[0].name
Machine.__init__(self,
states=modes,
initial=self.initial_state,
after_state_change='set_new_mode')
self.set_new_mode()
self.setup_services()
self.setup_publisher()
# TODO could be included as a transition, however, this might be more
# resource friendly
rospy.Timer(rospy.Duration(0.5), self.check_manual_mode_change)
def __init__(self):
self.running = True
states = ['init', 'ready', 'start', 'stop', 'pickplace', 'eject']
Machine.__init__(self, states=states, initial='init')
self.add_transition('trigger', 'init', 'ready')
self.add_transition('trigger',
'ready',
'start',
conditions='is_enabled')
self.add_transition('trigger',
'start',
'stop',
conditions='is_beam_broken')
self.add_transition('trigger',
'stop',
'pickplace',
conditions='is_pickplace_ready')
self.add_transition('trigger', 'pickplace', 'eject')
self.add_transition('trigger', 'eject', 'ready')
self.state = states[0]
self.iterator = cycle([1, 0, 0, 0, 0, 0, 0, 0, 0])
self.count = 0 #trigger counter
# define hardware objects at start
self.conveyor = Conveyor_cmd()
self.robot = Robot_cmd()
# setup break beam sensor
GPIO.setmode(GPIO.BCM)
# GPIO 16 set up as input, pulled up to avoid false detection.
GPIO.setup(16, GPIO.IN, pull_up_down=GPIO.PUD_UP)
def __init__(self, manifold):
self.manifold = manifold
self.gui = None
# Record controller states
states = [
State(name='disconnected', on_enter=['unbusyUI', 'updateUI']),
State(name='connected', on_enter=['unbusyUI', 'updateUI']),
State(name='confirmed', on_enter=['unbusyUI', 'updateUI']),
State(name='ready', on_enter=['unbusyUI', 'updateUI', 'prepRecording']),
State(name='started', on_enter=['unbusyUI', 'updateUI', 'startRecording']),
State(name='paused', on_enter=['unbusyUI', 'updateUI', 'pauseRecording'])
]
# Record controller state transition definition
transitions = [
{'trigger': 'connect', 'source': 'disconnected', 'dest': 'connected' , 'prepare': ['busyUI', 'connectToServers', 'pingServers'], 'conditions': 'connection_confirmed'},
{'trigger': 'disconnect', 'source': 'connected', 'dest': 'disconnected' , 'prepare': ['busyUI'] },
{'trigger': 'disconnect', 'source': 'paused', 'dest': 'disconnected' , 'prepare': ['busyUI'] },
{'trigger': 'new', 'source': 'connected', 'dest': 'ready' , 'prepare': ['busyUI'] },
{'trigger': 'new', 'source': 'paused', 'dest': 'ready' , 'prepare': ['busyUI'] },
{'trigger': 'start', 'source': 'ready', 'dest': 'started' , 'prepare': ['busyUI'] },
{'trigger': 'pause', 'source': 'started', 'dest': 'paused' , 'prepare': ['busyUI'] },
]
# Record machine
Machine.__init__(self,
states=states,
transitions=transitions,
initial='disconnected')
def __init__(self, vehicle, states, transitions):
"""
This class is used to create a state machine for modes
:param vehicle: The vehicle object
:param states: an array of State classes
:param transitions: a double list of state transitions, [[source, dest, conditions, unless],..]
"""
self.name = self.__class__.__name__
self.cur_state = None
self.transitions = transitions
self.vehicle = vehicle
# initialize the states
activeStates = []
for x in states:
activeStates.append(x(vehicle))
self.initial_state = activeStates[0].name
# set a default trigger name for each transition
if transitions is not None:
for transition in transitions:
transition.insert(0, 'attempt_transition')
Machine.__init__(self,
states=activeStates,
transitions=self.transitions,
initial=self.initial_state,
after_state_change='set_current_state')
self.set_current_state()
super(Mode, self).__init__(self.name) # initialize the State class
def __init__(self):
states = ['wait', 'in_trial', 'post_trial', 'done']
transitions = [{
'source': 'wait',
'trigger': 'step',
'conditions': 'check_for_space',
'after': 'remove_text',
'dest': 'in_trial'
}, {
'source':
'in_trial',
'trigger':
'step',
'prepare': ['update_target_pos', 'update_target_color_and_count'],
'conditions':
'samples_exhausted',
'after': ['draw_time_on_target', 'start_countdown'],
'dest':
'post_trial'
}, {
'source': 'post_trial',
'trigger': 'step',
'conditions': 'time_elapsed',
'dest': 'done'
}]
Machine.__init__(self,
states=states,
transitions=transitions,
initial='wait')
def __init__(self):
# Define the different states of the state machine
states = ['secure', 'takeoff', 'follow', 'take_picture', \
'land', 'reacquisition', 'emergency']
# Define the transitions between states
# FORMAT: ['trigger_event', 'source_state', 'destination_state']
transitions = [
['takeoff_command', 'secure', 'takeoff'],
['takeoff_alt_reached', 'takeoff', 'follow'],
['picture_command', 'follow', 'take_picture'],
['picture_taken', 'take_picture', 'land'],
['land_alt_reached', 'land', 'secure'],
['emergency_condition', ['takeoff', 'follow', 'take_picture', 'land'], 'emergency'],
['takeoff_tag_lost', 'takeoff', 'reacquisition'],
['follow_tag_lost', 'follow', 'reacquisition'],
['land_tag_lost', 'land', 'reacquisition'],
['take_picture_tag_lost', 'take_picture', 'reacquisition'],
['takeoff_tag_found', 'reacquisition', 'takeoff'],
['follow_tag_found', 'reacquisition', 'follow'],
['land_tag_found', 'reacquisition', 'land'],
['take_picture_tag_found', 'reacquisition', 'take_picture'],
['timed_out', 'reacquisition', 'emergency'],
['reset', 'emergency', 'secure']
]
Machine.__init__(self, states=states, transitions=transitions, \
initial='secure')
def __init__(self, current_time=Time('2018-01-01', scale='utc',
location=P48_loc),
current_ha=0. * u.deg, current_dec=33.36 * u.deg,
current_domeaz=180. * u.deg,
current_filter_id=2, filters=FILTER_IDS,
current_zenith_seeing=2.0 * u.arcsec,
target_skycoord=None,
historical_observability_year=2015):
# Define some states.
states = ['ready', 'cant_observe',
'slewing', 'changing_filters', 'exposing']
# define the transitions
transitions = [
{'trigger': 'start_slew', 'source': 'ready', 'dest': 'slewing',
'after': ['process_slew', 'stop_slew'],
'conditions': 'slew_allowed'},
{'trigger': 'stop_slew', 'source': 'slewing', 'dest': 'ready'},
# for now do not require filter changes to include a slew....
{'trigger': 'start_filter_change', 'source': 'ready',
'dest': 'changing_filters',
'after': ['process_filter_change', 'stop_filter_change']},
{'trigger': 'stop_filter_change', 'source': 'changing_filters',
'dest': 'ready'},
{'trigger': 'start_exposing', 'source': 'ready', 'dest': 'exposing',
'after': ['process_exposure', 'stop_exposing']},
{'trigger': 'stop_exposing', 'source': 'exposing', 'dest': 'ready'},
# I would like to automatically set the cant_observe state from
# start_exposing, but that doesn't seem to work.
{'trigger': 'check_if_ready', 'source': ['ready', 'cant_observe'],
'dest': 'ready', 'conditions': 'can_observe'},
{'trigger': 'set_cant_observe', 'source': '*',
'dest': 'cant_observe'}
]
# Initialize the state machine. syntax from
# https://github.com/tyarkoni/transitions
Machine.__init__(self, states=states,
transitions=transitions,
initial='ready')
self.current_time = current_time
self.current_ha = current_ha
self.current_dec = current_dec
self.current_domeaz = current_domeaz
self.current_filter_id = current_filter_id
self.filters = filters
self.current_zenith_seeing = current_zenith_seeing
self.target_skycoord = target_skycoord
# historical observability
self.historical_observability_year = historical_observability_year
self.observability = PTFObservabilityDB()
self.logger = logging.getLogger(__name__)
def __init__(self, device=None, opts=None):
self.__opts = opts
self.__device = device
self.__user_info = None
self.__logout_timer = None
self.__logger = ClientLogger.setup(opts)
self.__tinkerAccessServerApi = TinkerAccessServerApi(opts)
states = []
for key, value in vars(State).items():
if not key.startswith('__'):
states.append(value)
transitions = [
{
'source': [State.INITIALIZED],
'trigger': Trigger.IDLE,
'dest': State.IDLE
},
{
'source': [State.IDLE],
'trigger': Trigger.LOGIN,
'dest': State.IN_USE,
'conditions': ['is_authorized']
},
{
'source': [State.IN_USE],
'trigger': Trigger.LOGIN,
'dest': State.IN_USE,
'conditions': ['should_extend_current_session']
},
{
'source': [State.IN_USE, State.IN_TRAINING],
'trigger': Trigger.LOGOUT,
'dest': State.IDLE
},
{
'source': [State.IDLE],
'trigger': Trigger.LOGOUT,
'dest': State.IN_TRAINING,
'conditions': ['is_waiting_for_training']
},
{
'source': '*',
'trigger': Trigger.TERMINATE,
'dest': State.TERMINATED
}
]
Machine.__init__(self, queued=True, states=states,
transitions=transitions, initial=State.INITIALIZED, after_state_change='update_status')
def __init__(self):
self.annotations = {}
self.for_loops = {}
self.history: List[HistoryState] = []
Machine.__init__(self,
initial='start',
auto_transitions=False,
before_state_change=[self.add_state_to_history])
self.add_state(State(name='end', meta={}, on_enter=['write_to_db']))
self.add_state(State(name='failure', meta={}, on_enter=['failure']))
def __init__(self):
Machine.__init__(
self,
states=self.states,
initial='idle',
transitions=self.transitions,
after_state_change=self.set_state_start_time_and_update_flushing)
self.state_start_time = time.time()
self.pending_actions = deque([])
self.flushing = False # flush caused by timer
self.hard_flushing = False # flush forced by user input via web UI
def __init__(self):
self.states = [
{'name': 'Begin'}, #
{'name': 'End'}, #
{'name': 'Error'} #
]
self.transitions = [
{'trigger': 'step', 'source': 'Begin', 'dest': 'End'}
]
Machine.__init__(self, states=self.states, transitions=self.transitions,
initial='Begin', send_event=True)
self.answer = None
def __init__(self, states, initial_state):
# To store response from model to user.
self.cache_response = []
Machine.__init__(self,
states=states,
initial=initial_state,
ignore_invalid_triggers=False,
send_event=True,
auto_transitions=False)
self.add_ordered_transitions(conditions=[self.static_check_new_state],
prepare=[self.static_handle])
def __init__(self, states, conditions, cycle=None, output=True):
if len(states) != len(conditions):
raise ValueError(
"Number of states must equal number of conditions.")
if cycle is None:
if output:
print "Simulation using default guidance cycle."
cycle = Cycle()
self.__conditions = conditions
self.__states = states
self.__output = output
self.cycle = cycle # The guidance cycle governing the simulation. Data logging and control updates occur every cycle.duration seconds while trigger checking happens 10x per cycle
self.time = 0.0 # Current simulation time
self.times = [
] # Collection of times at which the state history is logged
self.index = 0 # The index of the current phase
self.sample = None # Uncertainty sample to be run
self.x = None # Current state vector
self.history = [] # Collection of state vectors
self.u = None # Previous controls
self.control_history = [] # Collection of controls
self.ie = [0] # Indices of event transitions
self.edlModel = None # The dynamics and other functions associated with EDL
self.fullEDL = None # The type of edl model used - "ideal" with perfect knowledge and no bank angle constraints, or "full" truth/nav/constraints/filters etc
self.triggerInput = None # An input to triggers and controllers
states.append('Complete')
transitions = [{
'trigger': 'advance',
'source': states[i - 1],
'dest': states[i],
'conditions': 'integrate'
} for i in range(1, len(states))]
try:
iSRP = states.index('SRP')
transitions[iSRP - 1]['after'] = 'ignite'
except:
pass
Machine.__init__(self,
model=None,
states=states,
initial=states[0],
transitions=transitions,
auto_transitions=False,
after_state_change='printState')
def __init__(self, config):
Machine.__init__(self,
states=self.states,
initial='awake',
queued=True)
self.add_transition('check',
'*',
'asleep',
conditions='is_sleepy_time')
self.add_transition('check', '*', 'awake', unless='is_sleepy_time')
self.lock_command = config['lock command']
self.sleepy_start = datetime.time(hour=config['time to sleep'])
self.sleepy_end = datetime.time(hour=config['time to sleep'] +
config['sleep length'])
def __init__(self, tracker, blob):
Machine.__init__(self, states=BlobTracker.States, initial='hypothesis')
self.blob = None
self.age = 1
self.tracker = tracker
self.kalman = cv2.KalmanFilter(4, 2, 0)
self.setup_kalman(blob.centroid)
self._ocr = PlateDetector.Instance()
r = lambda: random.randint(0,255)
self.color = (r(),r(),r())
self.id = BlobTracker.id
BlobTracker.id += 1
self.code = None
self.best_image = None
self._addblob(blob)
def __init__(self, *args, **kwargs):
Machine.__init__(self, *args, **kwargs)
if len(self.states) < 2:
raise ValueError('OrderedStateMachine must be defined at constuction time')
def add_transition(_from,_to):
self.add_transition('%s_to_%s' % (_from,_to), _from, _to)
#auto define transitions between states
state_names = self.states.keys()
for states in pairwise(state_names):
add_transition(*states)
#add a transition from the last to the initial state
add_transition(state_names[-1], self._initial)
#add a transition from the last to the first non-initial state
add_transition(state_names[-1],[s for s in state_names if s != self._initial][0])
def __init__(self, table_view):
self._data = {}
self._table = table_view
self._view = self._table.VIEW
self._raw = ''
self._lines = []
self.states = ['row_column', 'title_data', 'regex_data',
'delimiter_data', 'exists_bool_data']
self.transitions = [
{'trigger': 'column_provided', 'source': '*', 'dest': 'row_column',
'conditions': 'match_columns', 'before': 'check_header_bar',
'after': 'parse_raw_columns'},
{'trigger': 'check_next_row', 'source': 'row_column',
'dest': 'row_column', 'conditions': 'prev_next_row_same_type',
'after': 'parse_raw_columns'},
{'trigger': 'title_provided', 'source': 'start',
'dest': 'title_data', 'conditions':
['match_title', 'title_not_followed_by_columns'],
'after': 'parse_title_data'},
{'trigger': 'regex_provided', 'source': 'title_data',
'dest': 'regex_data', 'conditions': ['match_title'],
'before': 'check_header_bar', 'after': 'parse_using_regex'},
{'trigger': 'delimiter_without_title', 'source': 'start', 'dest':
'delimiter_data', 'after': 'parse_using_delimiter'},
{'trigger': 'delimiter_with_title', 'source': ['start',
'delimiter_data'],
'dest': 'delimiter_data',
'conditions': ['match_title'], 'before': 'check_header_bar',
'after': 'parse_using_delimiter'},
{'trigger': 'regex_with_item', 'source': ['start', 'regex_data'],
'dest': 'regex_data', 'after': 'parse_using_item_and_regex'},
{'trigger': 'regex_parser', 'source': 'start',
'dest': 'regex_data', 'after': 'parse_using_regex'},
{'trigger': 'regex_parser', 'source': 'regex_data',
'dest': 'regex_data', 'after': 'parse_using_regex'},
{'trigger': 'regex_parser', 'source': 'row_column',
'dest': 'regex_data', 'after': 'parse_using_regex'},
{'trigger': 'exists_check', 'source': ['start', 'regex_data',
'row_column'],
'dest': 'exists_bool_data', 'after': 'parse_exists'},
{'trigger': 'exists_check', 'source': 'title_data',
'dest': 'exists_bool_data', 'after': 'parse_exists'},
]
Machine.__init__(self, states=self.states, transitions=self.transitions,
initial='start', send_event=True)
def __init__(self, *args, **kwargs):
Machine.__init__(self, *args, **kwargs)
if len(self.states) < 2:
raise ValueError(
'OrderedStateMachine must be defined at constuction time')
def add_transition(_from, _to):
self.add_transition('%s_to_%s' % (_from, _to), _from, _to)
#auto define transitions between states
state_names = self.states.keys()
for states in pairwise(state_names):
add_transition(*states)
#add a transition from the last to the initial state
add_transition(state_names[-1], self._initial)
#add a transition from the last to the first non-initial state
add_transition(state_names[-1],
[s for s in state_names if s != self._initial][0])
def __init__(self, initialState, radio, useUSB=True, first=False):
states = ["s" + str(i) for i in range(14)]
transitions = splitter([
"s0->s1", "s1->s2", "s2->s3", "s3->s2", "s3->s4", "s3->s5",
"s4->s5", "s5->s6", "s5->s8", "s6->s6", "s6->s7", "s8->s9",
"s0->s10", "s10->s11", "s12->s7"
"s11->s12", "s7->s6", "s7->s2", "s7->s13", "s7->s8", "s13->s7"
])
Machine.__init__(self,
states=states,
initial='s0',
transitions=transitions)
self.stateFSM = initialState
self.pipe_master_tx = self.pipe_slave_rx = PIPES[0]
self.pipe_slave_tx = self.pipe_master_rx = PIPES[1]
self.radio = radio
# The FSM begins at state S0
# First and useUSB is only used for testing by reading form the SD not from USB
self.to_s0(useUSB, first)
def __init__(self, service, maxqueue, mtbf, mttr, mInt, mTime, stoch):
super().__init__()
# initialize state machine
state = ['Up', 'Failed', 'Maintenance', 'Blocked']
Machine.__init__(self, states=state, initial='Up')
self.add_transition('start', 'Up', 'Up', after='start_job')
self.add_transition('fail', 'Up', 'Failed', after='start_fail')
self.add_transition('repair', 'Failed', 'Up', after='rep')
self.add_transition('maintain', 'Up', 'Maintenance', after='start_maint')
self.add_transition('maintcpl', 'Maintenance', 'Up', after='stop_maint')
self.add_transition('interrep', 'Failed', 'Maintenance', after='start_maint')
self.add_transition('block', 'Up', 'Blocked')
self.add_transition('unblock', 'Blocked', 'Up')
# initialize all kind of variables
self.queue = Queue(maxqueue)
self.numServers = 1
self.busyServers = 0
self.mtbf = mtbf
self.mttr = mttr
self.maintInt = mInt
self.maintTime = mTime
self.serviceTimeDistribution = service
self.blocked = False
Server.stochastic = stoch
Server._ids += 1
self.name = 'Server {}'.format(Server._ids)
self.In, self.Out, self.scheduler, self.activejob, self.interuptjob = None, None, None, None, None
self.blocked = False
# logging variables
self.jobsarrived = 0
self.jobsprocessed = 0
self.jobsprocessed = 0
self.numfailures = 0
self.numMaint = 0
self.ctime = []
self.logging = []
self.idletime = 0
self.previdle = 0
self.startidle = 0
def __init__(self):
"""
@Type 0
E[第一次到max Lv.] = 8
分佈:左低右高，分散
機器人種類:溫和。偶爾性情不定。
@Type 1
E[第一次到max Lv.] = 8
分佈:左低右高，集中
機器人種類:溫和。很有規則的機器人，生氣的時機都差不多
"""
self.T = self.Trans[1]
self.states = [{'name': '0'}]
Machine.__init__(self, states=self.states, initial='0')
other_states = list(map(str, range(1, self.T.shape[0])))
self.add_states(other_states)
self.max_lv = self.T.shape[0] - 1
def __init__(self, conf):
self.conf = conf
self.mystery_state = Light.UNKN
states = [Light.ON, Light.OFF, Light.BAT]
# XXX this causes a weirdo hole and indeterminite startup if run in the off_hour hour I guess, I don't super care as verify_state will catch things
t = self._add_times_to_schedule(self.conf['schedule'])
#logging.info(f"__init__ t: {t}") # to debug that weirdo hole
now = datetime.now()
if (t['morn_twil']['time'] < now and now < t['post_sunl']['time']) or (t['aft_twil']['time'] < now and now < t['off_time']['time']):
initial_state = Light.ON
else:
initial_state = Light.OFF
Machine.__init__(self, states=states, initial=initial_state)
SwitchScheduler.__init__(self, point=self.conf['home'])
SwitchMate.__init__(self, self.conf)
self.add_transition('on', Light.OFF, Light.ON, before='on_state', after='check_state')
self.add_transition('off', Light.ON, Light.OFF, before='off_state', after='check_state')
def __init__(self, name, high_limit_pin, low_limit_pin, level_limit_pin):
self.name = name
self.running = True
#gui controlled
self.isEnabled = False
#tof distance sensor data
self.distance = 0
self.high_limit = 0
self.ready_limit = 100
self.low_limit = 600
#hardware pin assignments
self.high_level_pin = high_limit_pin #65
self.low_level_pin = low_limit_pin #66
self.level_limit_pin = level_limit_pin #81
self.stepper = stepper.Stepper("Bin-1", 0x60, 1, 65, 66,
81) # generic stepper object
states = ['init', 'start', 'up', 'down']
Machine.__init__(self, states=states, initial='init')
self.add_transition('trigger',
'init',
'start',
conditions='is_enabled')
self.add_transition('trigger', 'start', 'down')
self.add_transition('trigger', 'down', 'down',
unless='is_low_limit') #loop
self.add_transition('trigger', 'down', 'up', conditions='is_low_limit')
self.add_transition('trigger', 'up', 'up',
unless='is_high_level') #loop is high_level
self.add_transition(
'trigger', 'up', 'down',
conditions='is_high_level') #same as loop condittion
self.add_transition('trigger',
'up',
'down',
conditions='is_high_limit')
def __init__(self):
self.running = True
self.isEnabled = False
# define hardware objects at start
#define FSM states with a state timeout, go to next state when timeout is reached
states = ['dummy', 'init', 'ready', 'start', 'stop']
Machine.__init__(self, states=states, initial='dummy')
self.add_transition(
'trigger', 'dummy', 'init'
) #dummy on-enter callback will not fire when a Machine is first initialized.
self.add_transition('trigger', 'init', 'ready', conditions='always_on')
self.add_transition('trigger',
'ready',
'start',
conditions='always_on')
self.add_transition('trigger', 'start', 'stop', conditions='always_on')
self.add_transition('trigger', 'stop', 'ready', conditions='alwyas_on')
def __init__(self):
self.running = True
self.isEnabled = False
self.isEjectEnabled = False
self.isDispenseEnabled = False
states = ['init', 'start', 'stop', 'dispense', 'eject']
Machine.__init__(self, states=states, initial='init')
self.add_transition('trigger',
'init',
'start',
conditions='is_enabled')
self.add_transition('trigger',
'start',
'stop',
conditions='is_beam_broken')
self.add_transition('trigger',
'stop',
'dispense',
conditions='is_ready')
self.add_transition('trigger', 'dispense', 'eject')
self.add_transition('trigger', 'eject', 'start')
def __init__(self, parent, arenaMain):
super(OMRController, self).__init__(parent, arenaMain)
print type(parent)
#calibration
self.arenaCamCorners = None
self.arenaMidLine = []
self.arenaSide1Sign = 1
self.arenaProjCorners = []
self.fishImg = None #image of fish
#tracking
self.arenaCvMask = None
#state
self.mutex = Lock()
states = ['off', 'between_session', 'omr_to_s1', 'no_omr_post_s1', 'omr_to_s2', 'no_omr_post_s2'] # off between L-N-R-N-L-N-R between LNRNLNR between off
Machine.__init__(self, states=states, initial='off', after_state_change='update_state_data')
self.add_transition('begin', 'off', 'between_session', conditions='isReadyToStart')
self.add_transition('start_session', 'between_session', 'omr_to_s1')
self.add_transition('start_omr', 'no_omr_post_s1', 'omr_to_s2')
self.add_transition('start_omr', 'no_omr_post_s2', 'omr_to_s1')
self.add_transition('stop_omr', 'omr_to_s1', 'no_omr_post_s1')
self.add_transition('stop_omr', 'omr_to_s2', 'no_omr_post_s2')
self.add_transition('stop_session', ['omr_to_s1', 'omr_to_s2', 'no_omr_post_s1', 'no_omr_post_s2'], 'between_session')
self.add_transition('quit', '*', 'off')
self.fishPosUpdate = False
self.fishPos = (0,0)
self.fishPosBuffer = []
self.fishPosBufferT = []
self.currCvFrame = None
#Note additional state variable will be created during state transitions (like nextStateTime)
#data results
self.arenaData = None
self.fishSize = None
#init UI
#arena info group box
self.arenaGroup = QtGui.QGroupBox(self)
self.arenaGroup.setTitle('Arena Info')
self.arenaLayout = QtGui.QGridLayout()
self.arenaLayout.setHorizontalSpacing(3)
self.arenaLayout.setVerticalSpacing(3)
self.camCalibButton = QtGui.QPushButton('Set Cam Position')
self.camCalibButton.setMaximumWidth(150)
self.camCalibButton.clicked.connect(self.getArenaCameraPosition)
self.resetCamCorners = None
self.projGroup = QtGui.QGroupBox(self.arenaGroup)
self.projGroup.setTitle('Projector Position')
self.projLayout = QtGui.QGridLayout(self.projGroup)
self.projLayout.setHorizontalSpacing(3)
self.projLayout.setVerticalSpacing(3)
self.projCalibButton = QtGui.QPushButton('Calibrate Projector Position')
self.projCalibButton.setCheckable(True)
self.projCalibButton.clicked.connect(self.projectorPositionChanged)
self.projLayout.addWidget(self.projCalibButton,0,0,1,6)
self.projPosL = QtGui.QLabel('Pos')
self.projX = QtGui.QSpinBox()
self.projX.setRange(0,1000)
self.projX.setValue(250)
self.projX.setMaximumWidth(50)
self.projY = QtGui.QSpinBox()
self.projY.setRange(0,1000)
self.projY.setValue(250)
self.projY.setMaximumWidth(50)
self.projLayout.addWidget(self.projPosL,1,0)
self.projLayout.addWidget(self.projX,1,1)
self.projLayout.addWidget(self.projY,1,2)
self.projX.valueChanged.connect(self.projectorPositionChanged)
self.projY.valueChanged.connect(self.projectorPositionChanged)
self.projSizeL = QtGui.QLabel('Size W,L')
self.projWid = QtGui.QSpinBox()
self.projWid.setRange(0,1000)
self.projWid.setValue(115)
self.projWid.setMaximumWidth(50)
self.projLen = QtGui.QSpinBox()
self.projLen.setRange(0,1000)
self.projLen.setValue(220)
self.projLen.setMaximumWidth(50)
self.projLen.valueChanged.connect(self.projectorPositionChanged)
self.projWid.valueChanged.connect(self.projectorPositionChanged)
self.projLayout.addWidget(self.projSizeL,2,0)
self.projLayout.addWidget(self.projWid,2,1)
self.projLayout.addWidget(self.projLen,2,2)
self.projRotL = QtGui.QLabel('Rotation')
self.projRot = QtGui.QSpinBox()
self.projRot.setRange(0,360)
self.projRot.setValue(270)
self.projRot.setMaximumWidth(50)
self.projLayout.addWidget(self.projRotL,3,0)
self.projLayout.addWidget(self.projRot,3,1)
self.projRot.valueChanged.connect(self.projectorPositionChanged)
self.tankLength = LabeledSpinBox(None, 'Tank Len (mm)', 0,100,46,60)
self.projLayout.addWidget(self.tankLength, 4,0,1,2)
self.tankWidth = LabeledSpinBox(None, 'Tank Wid (mm)', 0,100,21,60)
self.projLayout.addWidget(self.tankWidth, 4,2,1,2)
self.projLayout.setColumnStretch(6,1)
self.projGroup.setLayout(self.projLayout)
self.arenaLayout.addWidget(self.camCalibButton, 0,0)
self.arenaLayout.addWidget(self.projGroup,1,0)
self.arenaLayout.setColumnStretch(1,1)
self.arenaGroup.setLayout(self.arenaLayout)
#tracking group box
self.trackWidget = FishTrackerWidget(self, self.arenaMain.ftDisp)
#start button for individual tank
self.startButton = QtGui.QPushButton('Start')
self.startButton.setMaximumWidth(150)
self.startButton.clicked.connect(self.startstop)
#whether to save movie
self.paramSaveMovie = QtGui.QCheckBox('Save Movie')
#experimental parameters groupbox
self.paramGroup = QtGui.QGroupBox()
self.paramGroup.setTitle('Exprimental Parameters')
self.paramLayout = QtGui.QGridLayout()
self.paramLayout.setHorizontalSpacing(2)
self.paramLayout.setVerticalSpacing(2)
#high level flow - Between - OMR Session ( OMRS1 - pause - OMRS2
self.paramNumSession = LabeledSpinBox(None, 'Number of Sessions', 0, 200, 20, 60) #Number of Sessions (a cluster of OMR tests)
self.paramLayout.addWidget(self.paramNumSession, 1,0,1,2)
self.paramBetween = LabeledSpinBox(None, 'Between Sessions (s)', 0, 1200, 300, 60)
self.paramLayout.addWidget(self.paramBetween, 1,2,1,2)
self.paramOMRPerSession = LabeledSpinBox(None,'#OMR Per Session', 0 ,10,4,60) # Number of OMR tests per session
self.paramLayout.addWidget(self.paramOMRPerSession, 2,0,1,2)
self.paramOMRDuration = LabeledSpinBox(None,'OMR Duration (s)',0,60,12,60) #duration of each OMR tests
self.paramLayout.addWidget(self.paramOMRDuration, 2,2,1,2)
self.paramOMRInterval = LabeledSpinBox(None,'OMR Interval (s)',0,60 ,3 ,60) #time between OMR tests
self.paramLayout.addWidget(self.paramOMRInterval,3,0,1,2)
#Vision properities of OMR
self.paramOMRPeriod = LabeledSpinBox(None,'OMR Grating Period (mm)',0,50,5,60) #spacing between grating bars
self.paramLayout.addWidget(self.paramOMRPeriod,4,0,1,2)
self.paramOMRDutyCycle = LabeledSpinBox(None, 'OMR DutyCycle %',0,100,50,60) #width of grating bars
self.paramLayout.addWidget(self.paramOMRDutyCycle,4,2,1,2)
self.paramOMRVelocity = LabeledSpinBox(None, 'OMR Speed (mm/s)',0,50,5,60) #velocity of moving gratings.
self.paramLayout.addWidget(self.paramOMRVelocity,5,0,1,2)
(self.paramColorNeutral,self.labelColorNeutral) = self.getColorComboBox('Neutral', 0)
self.paramLayout.addWidget(self.paramColorNeutral,6,0)
self.paramLayout.addWidget(self.labelColorNeutral,6,1)
(self.paramColorOMR,self.labelColorOMR) = self.getColorComboBox('OMR', 5)
self.paramLayout.addWidget(self.paramColorOMR,6,2)
self.paramLayout.addWidget(self.labelColorOMR,6,3)
self.paramGroup.setLayout(self.paramLayout)
#Experimental info group
self.infoGroup = QtGui.QGroupBox()
self.infoGroup.setTitle('Experiment Info')
self.infoLayout = QtGui.QGridLayout()
self.infoLayout.setHorizontalSpacing(3)
self.infoLayout.setVerticalSpacing(3)
self.labelDir = QtGui.QLabel('Dir: ')
self.infoDir = PathSelectorWidget(browseCaption='Experimental Data Directory', default=os.path.expanduser('~/data/test'))
self.infoLayout.addWidget(self.labelDir,0,0)
self.infoLayout.addWidget(self.infoDir,0,1)
self.labelDOB = QtGui.QLabel('DOB: ')
self.infoDOB = QtGui.QDateEdit(QtCore.QDate.currentDate())
self.infoLayout.addWidget(self.labelDOB,1,0)
self.infoLayout.addWidget(self.infoDOB,1,1)
self.labelType = QtGui.QLabel('Line: ')
self.infoType = QtGui.QLineEdit('Nacre')
self.infoLayout.addWidget(self.labelType,2,0)
self.infoLayout.addWidget(self.infoType,2,1)
self.infoFish = QtGui.QPushButton('Snap Fish Image')
self.infoFish.clicked.connect(self.getFishSize)
self.infoLayout.addWidget(self.infoFish,3,0,1,2)
self.infoGroup.setLayout(self.infoLayout)
self.settingsLayout = QtGui.QGridLayout()
self.settingsLayout.addWidget(self.arenaGroup,0,0,1,2)
self.settingsLayout.addWidget(self.trackWidget,1,0,1,2)
self.settingsLayout.addWidget(self.infoGroup,2,0,1,2)
self.settingsLayout.addWidget(self.startButton,3,0,1,1)
self.settingsLayout.addWidget(self.paramSaveMovie,3,1,1,1)
self.settingsLayout.addWidget(self.paramGroup,4,0,1,2)
self.setLayout(self.settingsLayout)
#HACK Couldn't quick initialize arena lcation until after frist image arrives, so stuck in onNewFrame
#initialize projector
self.projectorPositionChanged()
self.t = 0
def __init__(self, states, initial='A'):
self.state = None
Machine.__init__(self, states=states, initial=initial)
def __init__(self, opts):
self.cimc = opts['cimc_ip']
self.cimc_username = opts['cimc_username']
self.cimc_password = opts['cimc_password']
self.apic_password = opts['apic_admin_password']
if opts['verbose'] == "True":
self.verbose = True
else:
self.verbose = False
if opts['quiet'] == 'True':
self.quiet = True
else:
self.quiet = False
if opts['simulator'] == True:
self.simulator = True
else:
self.simulator = False
self.fabric_name = opts['fabric_name']
self.num_controllers = opts['number_of_controllers']
self.controller_id = opts['controller_number']
self.controller_name = opts['controller_name']
self.tep_address_pool = opts['tep_address_pool']
self.infra_vlan_id = opts['infra_vlan_id']
self.bd_mc_address_pool = opts['bd_mc_addresses']
self.oob_ip_addr = opts['oob_ip_address']
self.oob_def_gw = opts['oob_default_gateway']
self.int_speed = opts['int_speed']
self.strong_passwd = opts['strong_passwords']
# Used to execute commands in CIMC
self.cimc_client = None
# Used to do things on the APIC, has to go through CIMC first of course
self.apic_client = None
self.cimc_interact = None
self.provided_fabric_name = False
self.states = [
# Start and initialization states
{'name': 'start'},
{'name': 'connect_cimc', 'on_enter': 'on_enter_connect_cimc'},
# CIMC related states
{'name': 'check_sol', 'on_enter': 'on_enter_check_sol'},
{'name': 'configure_sol', 'on_enter': 'on_enter_configure_sol'},
{'name': 'disconnect_cimc', 'on_enter': 'on_enter_disconnect_cimc'},
{'name': 'cycle_host', 'on_enter': 'on_enter_cycle_host'},
# APIC specific initialization states
{'name': 'connect_apic', 'on_enter': 'on_enter_connect_apic'},
{'name': 'logout_apic', 'on_enter': 'on_enter_logout_apic'},
{'name': 'login_apic', 'on_enter': 'on_enter_login_apic'},
{'name': 'password_login_apic', 'on_enter': 'on_enter_password_login_apic'},
{'name': 'eraseconfig', 'on_enter': 'on_enter_eraseconfig'},
# Setup script related states
{'name': 'press_any_key', 'on_enter': 'on_enter_press_any_key'},
{'name': 'provide_fabric_name', 'on_enter': 'on_enter_provide_fabric_name'},
{'name': 'provide_number_ctrlrs', 'on_enter': 'on_enter_provide_number_ctrlrs'},
{'name': 'provide_ctrlr_id', 'on_enter': 'on_enter_provide_ctrlr_id'},
{'name': 'provide_ctrlr_name', 'on_enter': 'on_enter_provide_ctrlr_name'},
{'name': 'provide_tep_addr_pool', 'on_enter': 'on_enter_provide_tep_addr_pool'},
{'name': 'provide_infra_vlan_id', 'on_enter': 'on_enter_provide_infra_vlan_id'},
{'name': 'provide_bd_mc_addr_pool', 'on_enter': 'on_enter_provide_bd_mc_addr_pool'},
{'name': 'provide_oob_address', 'on_enter': 'on_enter_provide_oob_address'},
{'name': 'provide_oob_def_gw', 'on_enter': 'on_enter_provide_oob_def_gw'},
{'name': 'provide_int_speed', 'on_enter': 'on_enter_provide_int_speed'},
{'name': 'provide_strong_passwd', 'on_enter': 'on_enter_provide_strong_passwd'},
{'name': 'provide_admin_passwd', 'on_enter': 'on_enter_provide_admin_passwd'},
{'name': 'provide_modify_config', 'on_enter': 'on_enter_provide_modify_config'},
]
Machine.__init__(self, states=self.states, initial='start')
self.add_transition(trigger='start', source='start', dest='connect_cimc')
self.add_transition(trigger='cimc_prompt_detected',
source='connect_cimc',
dest='check_sol')
self.add_transition(trigger='sol_not_configured',
source='check_sol',
dest='configure_sol')
self.add_transition(trigger='sol_config_committed',
source='configure_sol',
dest='check_sol')
self.add_transition(trigger='cycle_host',
source='connect_apic',
dest='cycle_host')
# We can enter the connect_apic state from multiple sources, this states
# entry callback will need to be smarter than the average bear.
self.add_transition(trigger='connect_to_apic',
source=['check_sol', 'logout_apic'],
dest='connect_apic')
self.add_transition(trigger='apic_prompt_detected',
source='connect_apic',
dest='logout_apic')
self.add_transition(trigger='apic_login_detected',
source=['connect_apic', 'logout_apic', 'password_login_apic',
'cycle_host'],
dest='login_apic')
self.add_transition(trigger='apic_password_detected',
source=['connect_apic', 'cycle_host'],
dest='password_login_apic')
self.add_transition(trigger='apic_prompt_detected',
source=['login_apic', 'cycle_host'],
dest='eraseconfig')
self.add_transition(trigger='press_any_key',
source=['connect_apic', 'eraseconfig', 'cycle_host'],
dest='press_any_key')
# This transition can happen from connect_apic or provide_modify_config
self.add_transition(trigger='enter_fabric_name',
source=['connect_apic', 'provide_modify_config', 'press_any_key'],
dest='provide_fabric_name')
self.add_transition(trigger='enter_num_ctrlrs',
source=['connect_apic', 'provide_fabric_name'],
dest='provide_number_ctrlrs')
self.add_transition(trigger='enter_ctrlr_id',
source=['connect_apic', 'provide_number_ctrlrs'],
dest='provide_ctrlr_id')
self.add_transition(trigger='enter_ctrlr_name',
source=['connect_apic', 'provide_ctrlr_id'],
dest='provide_ctrlr_name')
self.add_transition(trigger='enter_tep_addr_pool',
source=['connect_apic', 'provide_ctrlr_name'],
dest='provide_tep_addr_pool')
self.add_transition(trigger='enter_infra_vlan_id',
source=['connect_apic', 'provide_tep_addr_pool'],
dest='provide_infra_vlan_id')
self.add_transition(trigger='enter_bd_mc_addr_pool',
source=['connect_apic', 'provide_infra_vlan_id'],
dest='provide_bd_mc_addr_pool')
self.add_transition(trigger='enter_oob_ip_addr',
source=['connect_apic',
'provide_bd_mc_addr_pool',
'provide_infra_vlan_id'],
dest='provide_oob_address')
self.add_transition(trigger='enter_oob_def_gw',
source=['connect_apic', 'provide_oob_address'],
dest='provide_oob_def_gw')
self.add_transition(trigger='enter_int_speed',
source=['connect_apic', 'provide_oob_def_gw'],
dest='provide_int_speed')
self.add_transition(trigger='enter_strong_passwd',
source=['connect_apic', 'provide_int_speed'],
dest='provide_strong_passwd')
self.add_transition(trigger='enter_admin_passwd',
source=['connect_apic', 'provide_strong_passwd'],
dest='provide_admin_passwd')
self.add_transition(trigger='reenter_admin_passwd',
source=['connect_apic', 'provide_admin_passwd'],
dest='provide_admin_passwd')
self.add_transition(trigger='enter_edit_cfg',
source=['connect_apic', 'provide_admin_passwd', 'provide_int_speed'],
dest='provide_modify_config')
self.add_transition(trigger='restart_setup',
source='provide_modify_config',
dest='provide_fabric_name')
def __init__(self):
self.states = [
{'name': 'Begin'}, #
{'name': 'Node1'}, # after VizirMessage before CaravanProfit
{'name': 'Node2'}, # after CaravanProfit before Crisis/Exchange
{'name': 'Node3'}, # after Crisis/Exchange before CaravanSupply
{'name': 'Node4'}, # after CaravanSupply before CaravanRob
{'name': 'Node5'}, # after CaravanRob before Metropolitan
{'name': 'Node6'}, # after Metropolitan before War
{'name': 'Node7'}, # after War before VizirCatch
{'name': 'Node8'}, # after VizirCatch before Inheritance
{'name': 'Node9'}, # after Inheritance before ...
{'name': 'End'}, #
{'name': 'Intro'}, #
{'name': 'MainMenu'}, #
{'name': 'Rules'}, #
{'name': 'NewGame'}, #
{'name': 'StartTurn'}, #
{'name': 'PrintState'}, #
{'name': 'VizirMessage'}, #
{'name': 'CaravanProfit'}, #
{'name': 'Crisis'}, #
{'name': 'Exchange'}, #
{'name': 'CaravanSupply'}, #
{'name': 'CaravanRob'}, #
{'name': 'Metropolitan'}, #
{'name': 'War'}, #
{'name': 'VizirCatch'}, #
{'name': 'Inheritance'}, #
{'name': 'ChildBirthDay'}, #
{'name': 'Marriage'}, #
{'name': 'WifeDead'}, #
{'name': 'WifeIn'}, #
{'name': 'Sickness'}, #
{'name': 'GiveGrain'}, #
{'name': 'MakeTurn'}, #
{'name': 'NextYear'}, #
{'name': 'NYParty'}, #
{'name': 'EndTurn'}, #
{'name': 'EndGame'} #
]
self.transitions = [
{'trigger': 'step', 'source': 'Begin', 'dest': 'Intro'},
{'trigger': 'step', 'source': 'Intro', 'dest': 'MainMenu'},
{'trigger': 'step', 'source': 'MainMenu', 'dest': 'Rules', 'conditions': 'answerIsTwo'},
{'trigger': 'step', 'source': 'Rules', 'dest': 'MainMenu'},
{'trigger': 'step', 'source': 'MainMenu', 'dest': 'End', 'conditions': 'answerIsThree'},
{'trigger': 'step', 'source': 'MainMenu', 'dest': 'NewGame', 'conditions': 'answerIsOne'},
{'trigger': 'step', 'source': 'NewGame', 'dest': 'PrintState'},
{'trigger': 'step', 'source': 'PrintState', 'dest': 'VizirMessage', 'unless': 'isFirstYear'},
{'trigger': 'step', 'source': 'PrintState', 'dest': 'Node1'},
{'trigger': 'step', 'source': 'VizirMessage', 'dest': 'Node1'},
{'trigger': 'step', 'source': 'Node1', 'dest': 'CaravanProfit', 'conditions': 'is5YearCaravan'},
{'trigger': 'step', 'source': 'Node1', 'dest': 'Node2'},
{'trigger': 'step', 'source': 'CaravanProfit', 'dest': 'Node2', 'before': 'update_random'},
{'trigger': 'step', 'source': 'Node2', 'dest': 'Crisis', 'conditions': 'isCrisis'},
{'trigger': 'step', 'source': 'Crisis', 'dest': 'Node3'},
{'trigger': 'step', 'source': 'Node2', 'dest': 'Exchange', 'unless': 'isCrisis'},
{'trigger': 'step', 'source': 'Exchange', 'dest': 'Node3'},
{'trigger': 'step', 'source': 'Node3', 'dest': 'CaravanSupply', 'conditions': 'is0YearCaravan'},
{'trigger': 'step', 'source': 'Node3', 'dest': 'Node4'},
{'trigger': 'step', 'source': 'CaravanSupply', 'dest': 'Node4'},
{'trigger': 'step', 'source': 'Node4', 'dest': 'CaravanRob', 'unless': 'is0YearCaravan'},
{'trigger': 'step', 'source': 'Node4', 'dest': 'Node5'},
{'trigger': 'step', 'source': 'CaravanRob', 'dest': 'Node5'},
{'trigger': 'step', 'source': 'Node5', 'dest': 'Metropolitan', 'conditions': 'isReceiveMetropolitan'},
{'trigger': 'step', 'source': 'Node5', 'dest': 'Node6'},
{'trigger': 'step', 'source': 'Metropolitan', 'dest': 'Node6'},
{'trigger': 'step', 'source': 'Node6', 'dest': 'War', 'conditions': 'isReasonWar'},
{'trigger': 'step', 'source': 'Node6', 'dest': 'Node7'},
{'trigger': 'step', 'source': 'War', 'dest': 'Node7'},
{'trigger': 'step', 'source': 'Node7', 'dest': 'VizirCatch'},
{'trigger': 'step', 'source': 'Node7', 'dest': 'Node8'},
{'trigger': 'step', 'source': 'VizirCatch', 'dest': 'Node8'},
{'trigger': 'step', 'source': 'Node8', 'dest': 'Inheritance'},
{'trigger': 'step', 'source': 'Node8', 'dest': 'Node9'},
{'trigger': 'step', 'source': 'Inheritance', 'dest': 'Node9'},
{'trigger': 'step', 'source': 'Node9', 'dest': 'End'}
]
Machine.__init__(self, states=self.states, transitions=self.transitions,
initial='Begin', send_event=True, before_state_change='update_random')
random.seed()
self.random_number = None
self.answer = 0
self.current_year = 1
def __init__(self, current_time=Time('2018-01-01', scale='utc',
location=P48_loc),
current_ha=0. * u.deg, current_dec=0. * u.deg,
current_domeaz=0. * u.deg,
current_filter='r', filters=['r', 'g'],
current_seeing=2.0 * u.arcsec,
target_skycoord=None,
logfile='../sims/log_ztf_sim',
historical_observability_year=2015):
# Define some states.
states = ['ready', 'cant_observe',
'slewing', 'changing_filters', 'exposing']
# define the transitions
transitions = [
{'trigger': 'start_slew', 'source': 'ready', 'dest': 'slewing',
'after': ['process_slew', 'stop_slew'],
'conditions': 'slew_allowed'},
{'trigger': 'stop_slew', 'source': 'slewing', 'dest': 'ready'},
# for now do not require filter changes to include a slew....
{'trigger': 'start_filter_change', 'source': 'ready',
'dest': 'changing_filters',
'after': ['process_filter_change', 'stop_filter_change']},
{'trigger': 'stop_filter_change', 'source': 'changing_filters',
'dest': 'ready'},
{'trigger': 'start_exposing', 'source': 'ready', 'dest': 'exposing',
'after': ['process_exposure', 'stop_exposing']},
{'trigger': 'stop_exposing', 'source': 'exposing', 'dest': 'ready'},
# I would like to automatically set the cant_observe state from
# start_exposing, but that doesn't seem to work.
{'trigger': 'check_if_ready', 'source': ['ready', 'cant_observe'],
'dest': 'ready', 'conditions': 'can_observe'},
{'trigger': 'set_cant_observe', 'source': '*',
'dest': 'cant_observe'}
]
# Initialize the state machine. syntax from
# https://github.com/tyarkoni/transitions
Machine.__init__(self, states=states,
transitions=transitions,
initial='ready')
self.current_time = current_time
self.current_ha = current_ha
self.current_dec = current_dec
self.current_domeaz = current_domeaz
self.current_filter = current_filter
self.filters = filters
self.current_seeing = current_seeing
self.target_skycoord = target_skycoord
# historical observability
self.historical_observability_year = historical_observability_year
self.observability = PTFObservabilityDB()
# logging. wipe out existing log.
fh = logging.FileHandler(logfile, mode='w')
fh.setLevel(logging.INFO)
self.logger = logger
self.logger.setLevel(logging.INFO)
self.logger.addHandler(fh)
def __init__(self):
self.FirstWAKE = True
self.log = logging.getLogger('L.Machine')
self.zoowrap = ZooWrap()
self.novawrap = NovaWrap()
self.mona = MonaWrap()
states = [{
'name': 'booting'
}, {
'name': 'normal',
'on_enter': 'on_enter_state',
'on_exit': 'on_exit_state'
}, {
'name': 'overload',
'on_enter': 'on_enter_state',
'on_exit': 'on_exit_state'
}, {
'name': 'overload_avoid',
'on_enter': 'on_enter_state',
'on_exit': 'on_exit_state'
}, {
'name': 'underload',
'on_enter': 'on_enter_state',
'on_exit': 'on_exit_state'
}, {
'name': 'underload_avoid',
'on_enter': 'on_enter_state',
'on_exit': 'on_exit_state'
}, {
'name': 'sleeping',
'on_enter': 'on_enter_state',
'on_exit': 'on_exit_state'
}, {
'name': 'wakeup',
'on_enter': 'on_enter_state',
'on_exit': 'on_exit_state'
}, {
'name': 'confirmed',
'on_enter': 'on_enter_state',
'on_exit': 'on_exit_state'
}
]
self.states_aux = {
'normal': {
'res_mood': 'HIGH', 'thr': None},
'overload': {
'res_mood': 'NO', 'thr': None},
'overload_avoid': {
'res_mood': 'NO', 'thr': None},
'underload': {
'res_mood': 'NO', 'thr': None},
'underload_avoid': {
'res_mood': 'MID', 'thr': None},
'sleeping': {
'res_mood': 'SLEEP', 'thr': None},
'wakeup': {
'res_mood': 'NO', 'thr': None},
'confirmed': {
'res_mood': 'NO', 'thr': None}
}
transitions = [
{'trigger': 'boot',
'source': 'booting', 'dest': 'wakeup'},
{'trigger': 'overload',
'source': 'normal', 'dest': 'overload'},
{'trigger': 'avoid',
'source': 'overload', 'dest': 'overload_avoid'},
{'trigger': 'retry',
'source': 'overload_avoid', 'dest': 'overload'},
{'trigger': 'underload',
'source': 'normal', 'dest': 'underload'},
{'trigger': 'avoid',
'source': 'underload', 'dest': 'underload_avoid'},
{'trigger': 'retry',
'source': 'underload_avoid', 'dest': 'underload'},
{'trigger': 'sleep',
'source': 'underload', 'dest': 'sleeping'},
{'trigger': 'wake',
'source': 'sleeping', 'dest': 'wakeup'},
{'trigger': 'chillout',
'source': 'wakeup', 'dest': 'normal'},
{'trigger': 'chillout',
'source': 'sleeping', 'dest': 'normal'},
{'trigger': 'confirm',
'source': 'normal', 'dest': 'confirmed'},
{'trigger': 'confirm',
'source': 'underload_avoid', 'dest': 'confirmed'},
{'trigger': 'chillout',
'source': 'confirmed', 'dest': 'normal'},
{'trigger': 'chillout',
'source': 'overload_avoid', 'dest': 'normal'},
{'trigger': 'chillout',
'source': 'underload_avoid', 'dest': 'normal'},
{'trigger': 'chillout',
'source': 'overload', 'dest': 'normal'},
{'trigger': 'chillout',
'source': 'underload', 'dest': 'normal'}
]
Machine.__init__(self,
states=states, transitions=transitions,
initial='booting')
self.history = [{
'state': 'normal',
'action_id': None
}]
self.receiving_vms = []
self.received_vms = []
self.whoami_host = cc.conf['whoami-host']
self.whoami_man = cc.conf['whoami-man']
self.root_id = '%s-%03d' % (
hashlib.md5(self.whoami_host).hexdigest()[1:4],
random.randrange(1, 999, 1))
self.action_count = 0
self.action_current = None
self.compute_hosts = cc.conf['compute']['managers']
self.hostlist = json.loads(ipc.get("hostlist"))
self.attempts = {
'overload': 0,
'underload': 0
}
self.last = {
'overload': 'OK',
'underload': 'OK'
}
self.quitting = False
self.executor = Executor()
self.executor.start()
self.statser = Statser()
self.statser.start()
self.log.info('Machine started [%s]' % self.whoami_host)
def __init__(self): dealerButton = random.randint(1, 4) self.transit = False Machine.__init__(self, states=self.states, transitions=self.transitions, initial=self.states[0])
