def __init__(self, tracking, number, size): logger.info("Creating new Frame") # the tracking process this frame is part of: self.tracking = tracking # number of this frame within the tracking process: self.number = number self.size = size # state machine for this frame: self.machine = transitions.Machine( model=self, states=self.module_states, initial='created', transitions=self.transitions, name=self.__repr__(), ) self.ground_truth = None self.capture_image = None self.previous_position = None self.before_previous_position = None self.roi = None self.features = None self.consolidated_features = None self.predicted_position = None self.prediction_quality = None self.target_mask = None self.result = None self.lost = 0 self.updated = 'n' self.mask_scale_factor = None # state markers - only to be changed by state machine self.did_reduction = False
def game(self): game = DummyGame() transitions.Machine(game, states=State, initial=State.Empty, transitions=paulobot.game.GAME_TRANSITIONS, send_event=True, queued=True) return game
def _InitStateMachine(self): """Initializes the internal state machine.""" self.machine = transitions.Machine(states=list(self.STATES), initial='SPLASH', send_event=True) # Used to set our attributes from the Machine object self.machine.SetEnv = self._SetEnv self.machine.IncrementScoreIndex = self._scoreboard.IncrementIndex self.machine.DecrementScoreIndex = self._scoreboard.DecrementIndex self.machine.IncrementGlobalMenuIndex = self._global_menu.IncrementIndex self.machine.DecrementGlobalMenuIndex = self._global_menu.DecrementIndex # Transitions # (trigger, source, destination) self.machine.add_transition('back', '*', 'SCORE', before='SetEnv') self.machine.add_transition('scan', '*', 'SCANNED', before='SetEnv') self.machine.add_transition('error', '*', 'ERROR', before='SetEnv') # TODO: check device "mode" ? self.machine.add_transition('up', 'SCORE', 'SCORE', after='DecrementScoreIndex') self.machine.add_transition('down', 'SCORE', 'SCORE', after='IncrementScoreIndex') self.machine.add_transition('up', 'SPLASH', 'SCORE') self.machine.add_transition('down', 'SPLASH', 'SCORE') self.machine.add_transition('menu1', '*', 'MENUGLOBAL') self.machine.add_transition('up', 'MENUGLOBAL', 'MENUGLOBAL', after='DecrementGlobalMenuIndex') self.machine.add_transition('down', 'MENUGLOBAL', 'MENUGLOBAL', after='IncrementGlobalMenuIndex') self.machine.add_transition('up', 'SPLASH', 'SCORE') self.machine.add_transition('down', 'SPLASH', 'SCORE') # Graphs self.machine.add_transition('right', 'SCORE', 'GRAPH') self.machine.add_transition('right', 'GRAPH', 'GRAPH') self.machine.add_transition('left', 'GRAPH', 'SCORE') self.machine.add_transition('up', 'ERROR', 'SCORE') self.machine.add_transition('down', 'ERROR', 'SCORE') self.machine.add_transition('left', 'ERROR', 'SCORE') self.machine.add_transition('right', 'ERROR', 'SCORE') self.machine.add_transition('menu1', 'MENUGLOBAL', 'SCORE') self.machine.add_transition('menu2', '*', 'SCORE') self.machine.add_transition('up', '*', '=') self.machine.add_transition('down', '*', '=')
def __init__(self): super().__init__() file = QFile("mainwindow.ui") file.open(QFile.ReadOnly) self.ui = QUiLoader().load(file, self) file.close() self.machine = transitions.Machine(model=self, states=["disconnected", "waiting", "placing", "aiming"], initial='disconnected', transitions=[{ "trigger": "get_aim", "source": "waiting", "dest": "aiming" }, { "trigger": "fire", "source": "aiming", "dest": "waiting" }, { "trigger": "get_place", "source": "waiting", "dest": "placing" }, { "trigger": "place", "source": "placing", "dest": "waiting" }, { "trigger": "server_connect", "source": "disconnected", "dest": "waiting", "after": "on_connect" }, { "trigger": "server_disconnect", "source": "*", "dest": "disconnected", "after": "on_disconnect" }], auto_transitions=False, queued=True) self.disconnect_event = asyncio.Event() self.loop = asyncio.get_event_loop() self.ui.connect_btn.clicked.connect(self.handle_connect_disconnect_btn) self.ui.input_edit.returnPressed.connect(self.handle_input) self.ui.execute_btn.clicked.connect(self.handle_input) self.pusher_client = pysherasync.PusherAsyncClient(self.APP_KEY, cluster=self.CLUSTER) self.client_task: Optional[asyncio.Task] = None self.connection_ready = asyncio.Event() self.pusher_socket = None self.ui.show()
def __init__(self, light): """ Initialize the "left" LED in the blink1 :param light object: an instance of busylight to control the led switch """ self.light = light self.colors = busyrgb() self.machine = transitions.Machine(model=self, states=self.states, transitions=self.transitions, initial='available')
def __init__(self, initial_state='starting', doctest_=False): import dawgie.context self.machine = transitions.Machine(model=self, states=FSM.states, initial=initial_state) self.changeset = None self.__doctest = doctest_ self.dot_file_name = "state.dot" self.prior_state = initial_state self.inactive_color = "white" self.active_color = "green" self.time_machine = None self.__prior = None self.priority = None self.crew_thread = None self.doing_thread = None self.todo_thread = None self.wait_on_crew = threading.Event() self.wait_on_doing = threading.Event() self.wait_on_todo = threading.Event() self.reset() self.wait_timeout = 0.001 self.nodes = {} self.graph = pydot.graph_from_dot_file( os.path.join(os.path.abspath(os.path.dirname(__file__)), self.dot_file_name)) idir = os.path.abspath( os.path.join(dawgie.context.fe_path, 'images/svg')) if not os.path.isdir(idir): os.makedirs(idir) fn = os.path.join(idir, 'state.svg') self.graph.write_svg(fn) for edge in self.graph.get_edges(): self.machine.add_transition( **self.construct_attributes(edge.get_attributes())) pass for node in self.graph.get_nodes(): node.set_style("filled") node.set_fillcolor(self.inactive_color) self.nodes[node.get_name()] = node pass return
def __init__(self, metadata): inports = { "in": {}, "axis": {}, } outports = { "out": {}, } super().__init__(inports, outports) self.queued_data = deque() self.machine = transitions.Machine(model=self, states=['start', 'middle', 'end'], initial='end') self.machine.add_transition('begin_group', 'start', 'start', before='pass_begin') self.machine.add_transition('begin_group', 'end', 'start') self.machine.add_transition('data', 'start', 'middle', before='initialise_group') self.machine.add_transition('data', 'middle', 'middle') self.machine.add_transition('end_group', 'middle', 'end', after='process_data') self.machine.add_transition('end_group', 'end', 'end', before='pass_end') self.inports["in"].on("data", self.data) self.inports["in"].on("beginGroup", self.begin_group) self.inports["in"].on("endGroup", self.end_group) self.inports["axis"].on("data", self.set_axis)
def __init__(self, pb, sport): self._pb = pb self._sport = sport # Create the state machine self._machine = transitions.Machine(None, states=State, initial=State.Empty, transitions=GAME_TRANSITIONS, send_event=True, queued=False) self._game_state_handlers = { State.Empty: self._event_game_state_empty, State.Quorate: self._event_game_state_quorate, State.PlayerCheck: self._event_game_state_player_check, State.PlayersNotReady: self._event_game_state_players_not_ready, State.Rolling: self._event_game_state_rolling, } # Dictionary of gtime -> list of games. # Don't use a defaultdict, to avoid bugs where code looks up # a gtime that isn't present and ends up adding an empty list. self._games = {} self._reorg_in_progress = False self._restore_in_progress = False
def fsm_runner(): # sub/pub channels in and from the GUI app subs_channels = ['solver', 'config', 'arms_play'] pubs_channels = ['update'] subs = [ QueuePubSub(queues).subscribe(channel) for channel in subs_channels ] # config for arms config = {} # finite state machine rubiks = RubiksSolver(pubs_channels[0]) machine = transitions.Machine(model=rubiks, states=['rest', 'reading', 'solving'], initial='rest', send_event=True) # FSM's transitions machine.add_transition(trigger='read', source='rest', dest='reading', after='readcube') machine.on_enter_reading('unblock_solve') machine.add_transition(trigger='solve', source='reading', dest='solving', conditions='is_finished', after='solvecube') machine.add_transition(trigger='success', source='solving', dest='rest', conditions='is_finished', after='block_solve') machine.add_transition(trigger='stop', source='*', dest='rest', after='block_solve') machine.add_transition(trigger='command', source='rest', dest='=', after='process_command') while not stop_event.is_set(): for sub, channel in zip(subs, subs_channels): try: message = sub.get(block=False) if channel == 'config': if rubiks.state == 'rest': config = message logger.info( 'save/load button pressed (update solver configs)' ) else: logger.info( 'save/load button pressed, but not updating the solver configs because it\'s in rest state' ) elif channel == 'solver': msg = message.lower() if 'read cube' == msg: rubiks.read(config=config) # change state here elif 'solve cube' == msg: rubiks.solve() # change state here elif 'stop' == msg: rubiks.stop(hard=False) # change state here elif 'cut power' == msg: rubiks.stop(hard=True) # change state here elif 'fix' == msg: rubiks.command( config=config, type='system', action='fix') # reflexive state here elif 'release' == msg: rubiks.command( config=config, type='system', action='release') # reflexive state here logger.info('\'' + msg + '\' button pressed') elif channel == 'arms_play': servo, pos = message rubiks.command(config=config, type='servo', servo=servo, pos=pos) # change state here logger.info('rotate servo {} to position {}'.format( servo, pos)) except Empty: pass except transitions.MachineError as error: logger.warning(error) # transition to rest from the solving state if the cube got solved if rubiks.state == 'solving' and rubiks.is_finished(None): rubiks.success() logger.info('the rubik\'s cube got solved') sleep(0.001)
def __init__(self, tracker, session): Tracking._LAST_SERIAL += 1 self.serial = Tracking._LAST_SERIAL logger.info("Creating new Tracking#%d", self.serial) self.name = "tracking-%04d" % (self.serial) self.tracker = tracker self.configuration = tracker.configuration self.initial_frame = None self.current_frame = None self.total_frames = 0 self.sample = None self.tracking_log = [] # colour map function self.cmap = matplotlib.cm.get_cmap("hot") self.colours = { 'roi': 'cyan', 'ground_truth': 'green', 'prediction': 'yellow', 'candidate': 'magenta' } # size of capture image (determined on sample loading) self.capture_size = None # size of scaled ROI (= feature extractor input size) self.sroi_size = tracker.sroi_size # prediction/target mask size (=feature extractor / consolidator output # size) self.mask_size = tracker.mask_size # self.sroi_to_mask_ratio = (self.sroi_size[0] / self.mask_size[0], self.sroi_size[1] / self.mask_size[1]) # create state machine for this tracking instance: self.machine = transitions.Machine( model=self, states=self.states, initial='created', transitions=self.transitions, name=self.__repr__(), ) # timestamps self.ts_loaded = None self.ts_features_selected = None self.ts_consolidator_trained = None self.ts_tracking_completed = None self.pursuing_total_seconds = 0.0 self.roi_calculation_total_seconds = 0.0 self.sroi_generation_total_seconds = 0.0 self.feature_extraction_total_seconds = 0.0 self.feature_reduction_total_seconds = 0.0 self.feature_consolidation_total_seconds = 0.0 self.se_total_seconds = 0.0 # updates self.updates_max_frames = 0 self.updates_confidence = 0 # object holding module_states of tracker modules: self.module_states = TrackerModuleStates() if tracker.configuration['ros_node']: from .RosPositionPublisher import RosPositionPublisher self.publisher = RosPositionPublisher( tracker.configuration['ros_node']) else: self.publisher = None self.session = session