def __init__(self, driver: Driver, serverAPI: ServerAPI, py_audio: PyAudio): self.logger = logging.getLogger("WalkieTalkie") self.players = {} # userID -> audio player object self.serverAPI = serverAPI self.driver = driver self.py_audio = py_audio self.queue = [] self.max_current_priority = -1 MQTT_BROKER = 'mqtt.item.ntnu.no' MQTT_PORT = 1883 # create MQTT client self.logger.info( f'Connecting to MQTT broker {MQTT_BROKER} at port {MQTT_PORT}') self.mqtt_client = mqtt.Client() self.mqtt_client.on_connect = self.on_connect self.mqtt_client.on_message = self.on_message self.mqtt_client.connect(MQTT_BROKER, MQTT_PORT) self.mqtt_client.loop_start() self.update_subscriptions() # Create state machine self.state_machine = Machine(name="queue_manager", transitions=self._get_transitions(), states=self._get_states(), obj=self) driver.add_machine(self.state_machine)
def test(self): cfc = CompoundFunctionContainer(13) t0 = {"source": "initial", "target": "s1"} t1 = { "trigger": "a", "source": "s1", "function": cfc.compound, "targets": "s2 s3", } t2 = {"trigger": "b", "source": "s2", "target": "final"} t3 = {"trigger": "b", "source": "s3", "target": "final"} stm = Machine(name="stm", transitions=[t0, t1, t2, t3], obj=None) _ = stmpy.get_graphviz_dot(stm) driver = Driver() driver.add_machine(stm) driver.start(keep_active=False) driver.send("a", "stm", args=["hi"], kwargs={"b1": "bbb"}) driver.send("b", "stm") driver.wait_until_finished()
def test(self): terminate = Terminate() t0 = {"source": "initial", "target": "s_1"} t1 = { "trigger": "t", "source": "s_1", "target": "s_2", "effect": "action" } stm_terminate = Machine(name="stm_terminate", transitions=[t0, t1], obj=terminate) terminate.stm = stm_terminate scheduler = Driver() scheduler.add_machine(stm_terminate) scheduler.start(max_transitions=2, keep_active=False) scheduler.send("t", "stm_terminate") scheduler.wait_until_finished() _ = stmpy.get_graphviz_dot(stm_terminate) _ = scheduler.print_status() self.assertTrue(True)
def get_state_machine(name: str, observers: list): recognizer = Recognizer(recognition_keyword='lisa', stm_observers=observers) t_i0 = {'source': 'initial', 'target': 'listening'} t_01 = {'trigger': 'done', 'source': 'listening', 'target': 'recognizing'} t_10_a = { 'trigger': 'recognition_error', 'source': 'recognizing', 'target': 'listening' } t_10_b = { 'trigger': 'recognized', 'source': 'recognizing', 'function': recognizer.was_adressed } s_listening = {'name': 'listening', 'do': 'listen'} s_recognizing = {'name': 'recognizing', 'entry': 'recognize'} stm = Machine(name=name, transitions=[t_i0, t_01, t_10_a, t_10_b], states=[s_listening, s_recognizing], obj=recognizer) recognizer.stm = stm return stm
def test(self): tick1 = EntryExitSelfLogic() t0 = {"source": "initial", "target": "s1"} t1 = { "trigger": "b", "source": "s1", "target": "s1", "effect": "add('b')" } t2 = { "trigger": "done", "source": "s1", "target": "final", "effect": "add('c')", } s1 = {"name": "s1", "do": "do_action('a')"} stm = Machine(name="stm", transitions=[t0, t1, t2], states=[s1], obj=tick1) tick1.stm = stm _ = stmpy.get_graphviz_dot(stm) driver = Driver() driver.add_machine(stm) driver.start() driver.wait_until_finished()
def __init__(self, driver): self.stm_driver = driver self.recording = False self.chunk = 1024 # Record in chunks of 1024 samples self.sample_format = pyaudio.paInt16 # 16 bits per sample self.channels = 1 self.fs = 44100 # Record at 44100 samples per second self.filename = "output.wav" self._logger = logging.getLogger(__name__) t0 = {'source': 'initial', 'target': 'ready'} t1 = {'trigger': 'start', 'source': 'ready', 'target': 'recording'} t2 = {'trigger': 'done', 'source': 'recording', 'target': 'processing'} t3 = {'trigger': 'done', 'source': 'processing', 'target': 'ready'} s_recording = { 'name': 'recording', 'do': 'record()', "stop": "stop()", 'start': 'defer' } s_processing = { 'name': 'processing', 'do': 'process()', 'start': 'defer' } self.stm = Machine(name="recorder", transitions=[t0, t1, t2, t3], states=[s_recording, s_processing], obj=self) self.stm_driver.add_machine(self.stm)
def __init__(self, mqtt_client, device): self.recording = False self.chunk = 1024 self.sample_format = pyaudio.paInt16 self.channels = 2 # you might change this based on your mic self.fs = 44100 self.filename = "output.wav" self.p = pyaudio.PyAudio() self.mqtt_client = mqtt_client self.device = device t0 = {'source': 'initial', 'target': 'ready'} t1 = {'trigger': 'start', 'source': 'ready', 'target': 'recording'} t2 = { 'trigger': 'done', 'source': 'recording', 'target': 'processing', 'effect': 'stop' } t3 = {'trigger': 'done', 'source': 'processing', 'target': 'ready'} s_recording = { 'name': 'recording', 'do': 'record()', "stop": "stop()", "start_timer": "start_timer('stop', 5000)" } s_processing = {'name': 'processing', 'do': 'process()'} self.stm = Machine(name='recorder', transitions=[t0, t1, t2, t3], states=[s_recording, s_processing], obj=self)
def test_blink(): blink = Blink() t0 = {"source": "initial", "target": "blink_on", "effect": "on"} t1 = { "trigger": "t", "source": "blink_on", "target": "blink_off", "effect": "off" } t2 = { "trigger": "t", "source": "blink_off", "target": "blink_on", "effect": "on" } stm_blink = Machine(transitions=[t0, t1, t2], obj=blink, name="blink") blink.stm = stm_blink print(stm_blink.print_graph()) scheduler = Driver() scheduler.add_stm(stm_blink) scheduler.start() print("scheduler started") scheduler.wait_until_finished()
def __init__(self, transitions, states, debug): self.payload = {} self._logger = logging.getLogger(__name__) self._logger.info('logging under name {}.'.format(__name__)) self._logger.info('Starting Component') self.debug = debug self.app = None self.lock = Lock() self.recorder = Recorder(self) self.text_to_speech = Speaker() self.overwrote_last = False self.uuid = uuid4().hex if self.debug: self.uuid = "122ec9e8edda48f8a6dd290747acfa8c" self.channel = "{server}{uuid}".format(server=MQTT_TOPIC_BASE,uuid=self.uuid) self.name = "jonas" stm_walkie_talkie_name = "{}_walkie_talkie".format(self.name) walkie_talkie_machine = Machine(transitions=transitions, states=states, obj=self, name=stm_walkie_talkie_name) self.stm = walkie_talkie_machine recognizer_stm = get_state_machine('stm_recognizer', [stm_walkie_talkie_name]) self.stm_driver = Driver() self.stm_driver.add_machine(walkie_talkie_machine) self.stm_driver.add_machine(recognizer_stm) self.stm_driver.start() self._logger.debug('Component initialization finished')
def test(self): t0 = { "source": "initial", "target": "s1", "effect": "start_timer('t1', 1000)", } t1 = { "trigger": "a", "source": "s1", "target": "s1", "effect": "stop_timer('t1')", } t2 = {"trigger": "b", "source": "s1", "target": "final"} stm = Machine(name="stm", transitions=[t0, t1, t2], obj=None) _ = stmpy.get_graphviz_dot(stm) driver = Driver() driver.add_machine(stm) driver.start(keep_active=False) driver.send("a", "stm") driver.send("b", "stm") driver.wait_until_finished()
def test_tick_2(): logger = logging.getLogger("stmpy.Driver") logger.setLevel(logging.DEBUG) ch = logging.StreamHandler() ch.setLevel(logging.DEBUG) formatter = logging.Formatter( "%(asctime)s - %(name)s - %(levelname)s - %(message)s") ch.setFormatter(formatter) logger.addHandler(ch) scheduler = Driver() tick = Tick_2() t0 = {"source": "initial", "target": "s_tick", "effect": "on_init"} t1 = {"trigger": "tick", "source": "s_tick", "function": tick.t_1} t2 = {"trigger": "tock", "source": "s_tock", "function": tick.t_2} stm_tick = Machine(name="stm_tick", transitions=[t0, t1, t2], obj=tick) # the object may need the stm to add events and control timers tick.stm = stm_tick scheduler.add_stm(stm_tick) scheduler.start(max_transitions=10) scheduler.wait_until_finished()
def test(self): print(__name__) debug_level = logging.DEBUG logger = logging.getLogger(__name__) logger.setLevel(debug_level) ch = logging.StreamHandler() ch.setLevel(debug_level) formatter = logging.Formatter( "%(asctime)s - %(name)-12s - %(levelname)-8s - %(message)s") ch.setFormatter(formatter) logger.addHandler(ch) # terminate = Terminate() t0 = {"source": "initial", "target": "s1"} t1 = {"trigger": "b", "source": "s1", "target": "s2"} t2 = {"trigger": "a", "source": "s2", "target": "final"} s1 = {"name": "s1", "a": "defer", "a2": "defer", "a3": "defer"} s2 = {"name": "s2", "a2": "defer", "a3": "defer"} stm_terminate = Machine(name="stm", transitions=[t0, t1, t2], states=[s1, s2], obj=None) # terminate.stm = stm_terminate _ = stmpy.get_graphviz_dot(stm_terminate) print(_) def unwrap(queue): s = [] if queue is None: return s for event in queue: if event is not None: s.append(event["id"]) return s driver = Driver() driver.add_machine(stm_terminate) driver.start(max_transitions=30, keep_active=False) driver.send("a", "stm") driver.send("a2", "stm") driver.send("a3", "stm") print("Events {}".format(unwrap(driver._event_queue.queue))) print(stm_terminate.state) print("Defers {}".format(unwrap(stm_terminate._defer_queue))) print(driver._max_transitions) driver.send("b", "stm") print("Events {}".format(unwrap(driver._event_queue.queue))) print(stm_terminate.state) print("Defers {}".format(unwrap(stm_terminate._defer_queue))) print(driver._max_transitions) driver.wait_until_finished() print(stm_terminate.state) self.assertTrue(True)
def create_machine(self, name): t0 = {'source': 'initial', 'target': 'ready'} t5 = {'trigger': 'emg_msg', 'source': 'ready', 'target': 'ready', 'effect': 'switch_emg_mode'} t7 = {'trigger': 'change_channel_signal', 'source': 'ready', 'target': 'ready', 'effect': 'change_channel'} stm = Machine(name=name, transitions=[t0, t5, t7], obj=self) self.stm = stm return self.stm
def test_ping_pong(): scheduler = Driver() ping = Ping() t0 = {"source": "initial", "target": "s_1", "effect": "on_init"} t1 = { "trigger": "t", "source": "s_1", "target": "s_2", "effect": "on_timeout" } t2 = { "trigger": "pong", "source": "s_2", "target": "s_1", "effect": "on_pong" } stm_ping = Machine(transitions=[t0, t1, t2], obj=ping, name="stm_ping") ping.stm = stm_ping pong = Pong() t0 = {"source": "initial", "target": "s_1"} t1 = { "trigger": "t", "source": "s_2", "target": "s_1", "effect": "on_timeout" } t2 = { "trigger": "ping", "source": "s_1", "target": "s_2", "effect": "on_ping" } stm_pong = Machine(transitions=[t0, t1, t2], obj=pong, name="stm_pong") pong.stm = stm_pong scheduler.add_stm(stm_ping) scheduler.add_stm(stm_pong) scheduler.step(4) scheduler.print_state() scheduler.step() scheduler.print_state()
def __init__(self, driver: Driver, py_audio: PyAudio): self.logger = logging.getLogger("WalkieTalkie") self.py_audio = py_audio self.state_machine = Machine( name="audio_player_" + str(id(self)), # Unique identifier for each audio player object transitions=self._get_transitions(), states=self._get_states(), obj=self) driver.add_machine(self.state_machine)
def test_timer(): if "s" is "s": print("same!") t0 = {"source": "initial", "target": "s_1"} m = Machine(transitions=[t0], obj=None, name="t") driver = Driver() driver.add_stm(m) m.start_timer("t", 1000) print(driver.print_status()) m.stop_timer("t") print(driver.print_status())
def __init__(self, plant_name, myclient): self._logger = logging.getLogger(__name__) self._logger.warning("Created airHumidity machine") self.plant_name = plant_name self.sh = SenseHat() watering_machine = Machine(transitions=[self.t0, self.t1], obj=self, states=[self.idle], name='AirHumid') self.stm = watering_machine self.mqtt = myclient
def __init__(self, plant_name, humidityCh): self._logger = logging.getLogger(__name__) self._logger.warning("Created watering machine") self.plant_name = plant_name watering_machine = Machine( transitions=[self.t0, self.t1, self.t2], obj=self, states=[self.not_watering, self.watering_plant], name='Watering') self.stm = watering_machine self.humidityCh = humidityCh
def __init__(self): self.recorder = Recorder() t0_r = {'source': 'initial', 'target': 'ready'} t1_r = { 'trigger': 'start_recording', 'source': 'ready', 'target': 'recording' } t2_r = {'trigger': 'done', 'source': 'recording', 'target': 'ready'} s_ready = {'name': 'ready'} s_recording = { 'name': 'recording', 'do': 'record()', "stop": "stop_recording()" } self.stm_recording = Machine(name='stm_recording', transitions=[t0_r, t1_r, t2_r], states=[s_ready, s_recording], obj=self.recorder) self.recorder.stm = self.stm_recording self.speaker = Speaker() t0_s = {'source': 'initial', 'target': 'ready'} t1_s = {'trigger': 'speak', 'source': 'ready', 'target': 'speaking'} t2_s = {'trigger': 'done', 'source': 'speaking', 'target': 'ready'} s1_s = {'name': 'speaking', 'do': 'speak(*)', 'speak': 'defer'} self.stm_speaker = Machine(name='stm_speaker', transitions=[t0_s, t1_s, t2_s], states=[s1_s], obj=self.speaker) self.speaker.stm = self.stm_speaker self.driver = Driver() self.driver.add_machine(self.stm_recording) self.driver.add_machine(self.stm_speaker) self.driver.start() print('Audio Module ready')
def __init__(self, driver): self.stm_driver = driver t0 = {'source': 'initial', 'target': 'ready'} t1 = {'trigger': 'start', 'source': 'ready', 'target': 'playing'} t2 = {'trigger': 'done', 'source': 'playing', 'target': 'ready'} s_playing = {'name': 'playing', 'do': 'play(*)', 'start': 'defer'} self.stm = Machine(name='player', transitions=[t0, t1, t2], states=[s_playing], obj=self) self.stm_driver.add_machine(self.stm)
def __init__(self, driver): self.recording = False self.chunk = 1024 # Record in chunks of 1024 samples self.sample_format = pyaudio.paInt16 # 16 bits per sample self.channels = 2 self.fs = 44100 # Record at 44100 samples per second self.filename = "output.wav" self.p = pyaudio.PyAudio() self.stm_recorder = Machine( name='stm_recorder', transitions=[self.t0, self.t1, self.t2, self.t3], states=[self.s_recording, self.s_processing], obj=self) self.driver = driver self.driver.add_machine(self.stm_recorder)
def __init__(self, driver): self.stm_driver = driver t0 = {'source': 'initial', 'target': 'ready'} t1 = {'trigger': 'saveFile', 'source': 'ready', 'target': 'writing'} t2 = {'trigger': 'done', 'source': 'writing', 'target': 'ready'} t3 = {'trigger': 'deleteFile', 'source': 'ready', 'target': 'deleting'} t4 = {'trigger': 'done', 'source': 'deleting', 'target': 'ready'} s_writing = {'name': 'writing', 'do': 'save(*)', 'saveFile': 'defer', 'deleteFile': 'defer', } s_deleting = {'name': 'deleting', 'do': 'delete(*)', 'saveFile': 'defer', 'deleteFile': 'defer'} self.stm = Machine(name="fileManager", transitions=[t0, t1, t2, t3, t4], states=[s_writing, s_deleting], obj=self) self.stm_driver.add_machine(self.stm)
def create_machine(m_name, component): recorder = Recorder() t0 = {'source': 'initial', 'target': 'ready'} t1 = {'trigger': 'start', 'source': 'ready', 'target': 'recording'} t2 = {'trigger': 'done', 'source': 'recording', 'target': 'processing'} t3 = {'trigger': 'done', 'source': 'processing', 'target': 'ready'} s_recording = {'name': 'recording', 'do': 'record()', "stop": "stop()"} s_processing = {'name': 'processing', 'do': 'process()'} recorder_stm = Machine(name=m_name, transitions=[t0, t1, t2, t3], states=[s_recording, s_processing], obj=recorder) recorder.stm = recorder_stm return recorder
def test(self): busy = Busy() t0 = {"source": "initial", "target": "s_busy", "effect": "on_busy"} t1 = { "trigger": "busy", "source": "s_busy", "target": "s_busy", "effect": "on_busy", } stm_busy = Machine(name="busy", transitions=[t0, t1], obj=busy) busy.stm = stm_busy scheduler = Driver() scheduler.add_machine(stm_busy) scheduler.start(max_transitions=5) scheduler.wait_until_finished() self.assertTrue(True)
def test_busy(): busy = Busy() t0 = {"source": "initial", "target": "s_busy", "effect": "on_busy"} t1 = { "trigger": "busy", "source": "s_busy", "target": "s_busy", "effect": "on_busy", } stm_busy = Machine(transitions=[t0, t1], obj=busy, name="stm_busy") busy.stm = stm_busy scheduler = Driver() scheduler.add_stm(stm_busy) scheduler.start(max_transitions=100) print("scheduler started") scheduler.wait_until_finished()
def __init__(self, mqttAPI: MqttAPI, driver: Driver, py_audio: PyAudio, serverAPI: ServerAPI): self.logger = logging.getLogger("WalkieTalkie") self.serverAPI = serverAPI # Define private variables self._recording = False # Save references self.mqttAPI = mqttAPI self.py_audio = py_audio # Create state machine self.state_machine = Machine(name="audio_recorder", transitions=self._get_transitions(), states=self._get_states(), obj=self) driver.add_machine(self.state_machine)
def test(self): t0 = {"source": "initial", "target": "s1"} t1 = { "trigger": "a", "source": "s1", "function": self.compound, "targets": "final", } stm = Machine(name="stm", transitions=[t0, t1], obj=None) _ = stmpy.get_graphviz_dot(stm) driver = Driver() driver.add_machine(stm) driver.start(keep_active=False) driver.send("a", "stm", args=["hi"], kwargs={"b1": "bbb"}) driver.wait_until_finished()
def test(self): two = TwoMethods() t0 = {"source": "initial", "target": "s_1"} t1 = { "trigger": "t", "source": "s_1", "target": "s_2", "effect": "m1;m2" } stm_two = Machine(name="stm_two", transitions=[t0, t1], obj=two) two.stm = stm_two scheduler = Driver() scheduler.add_machine(stm_two) scheduler.start(max_transitions=2) print("scheduler started") scheduler.send("t", "stm_two") scheduler.wait_until_finished() self.assertTrue(True)
def activate_lights(): global scheduler lights = Lights() t0 = {'source': 'initial', 'target': 's_none', 'effect': 'on_init'} t1 = { 'trigger': 'goto_green', 'source': 's_none', 'target': 's_green', 'effect': 'on_green' } t2 = { 'trigger': 'goto_none', 'source': 's_green', 'target': 's_none', 'effect': 'on_none' } t3 = { 'trigger': 'goto_red', 'source': 's_none', 'target': 's_red', 'effect': 'on_red' } t4 = { 'trigger': 'goto_none', 'source': 's_red', 'target': 's_none', 'effect': 'on_none' } stm_lights = Machine(name='stm_lights', transitions=[t0, t1, t2, t3, t4], obj=lights) lights.stm = stm_lights scheduler.add_machine(stm_lights) scheduler.start()
def test(self): tick1 = EntryExitSelfLogic() t0 = {"source": "initial", "target": "s1"} t1 = { "trigger": "b", "source": "s1", "target": "s1", "effect": "add('b')" } t2 = { "trigger": "c", "source": "s1", "target": "final", "effect": "add('c')" } s1 = { "name": "s1", "a": "add('a')", "entry": "add('entry')", "exit": "add('exit')", } stm = Machine(name="stm", transitions=[t0, t1, t2], states=[s1], obj=tick1) tick1.stm = stm _ = stmpy.get_graphviz_dot(stm) driver = Driver() driver.add_machine(stm) driver.start(max_transitions=30, keep_active=False) driver.send("a", "stm") driver.send("b", "stm") driver.send("c", "stm") driver.wait_until_finished()