X-Git-Url: https://git.ralfj.de/saartuer.git/blobdiff_plain/bdf4adf1c9155148f713dd6e7eda955c495155b3..dfd60ef69a6fa4b790250431f9b7fde6da084ec9:/statemachine.py?ds=inline diff --git a/statemachine.py b/statemachine.py index 3a27ada..5ad83dd 100644 --- a/statemachine.py +++ b/statemachine.py @@ -1,4 +1,4 @@ -from libtuer import ThreadFunction, logger, fire_and_forget +from libtuer import ThreadFunction, logger, fire_and_forget, fire_and_forget_cmd from actor import Actor import os, random, time, threading @@ -11,7 +11,7 @@ def play_sound (what): logger.error("StateMachine: Unable to list sound files in %s" % (SOUNDS_DIRECTORY+what)) return soundfile = SOUNDS_DIRECTORY + what + '/' + random.choice(soundfiles) - fire_and_forget ([SOUNDS_PLAYER,soundfile], logger.error, "StateMachine: ") + fire_and_forget_cmd ([SOUNDS_PLAYER,soundfile], logger.error, "StateMachine: ") # StateUnlocking constants @@ -23,7 +23,6 @@ CLOSE_REPEAT_TIMEOUT = 7 CLOSE_REPEAT_NUMBER = 3 # StateFallback constants -FALLBACK_BLINK_SPEED = 0.5 # seconds FALLBACK_LEAVE_DELAY_LOCK = 5 # seconds # StateAboutToOpen constants @@ -91,6 +90,8 @@ class StateMachine(): return self.state_machine.old_pins def actor(self): return self.state_machine.actor + def api(self): + return self.state_machine.api def handle_event(self,ev,arg): # don't override if ev == StateMachine.CMD_PINS: return self.handle_pins_event() @@ -138,25 +139,25 @@ class StateMachine(): class StateStart(State): def __init__(self, sm, nervlist = None, fallback=False): - super().__init__(self, sm, nervlist) + super().__init__(sm, nervlist) self.fallback = fallback def handle_pins_event(self): pins = self.pins() if not (pins.door_locked is None or pins.door_closed is None or pins.space_active is None or pins.bell_ringing is None): - logger.info("All sensors got a value, switching to a proper state") if self.fallback: logger.info("Going to StateFallback because running in fallback mode") return StateMachine.StateFallback(self.state_machine) if pins.door_locked: + logger.info("All sensors got a value, switching to a proper state: Space is closed") return StateMachine.StateZu(self.state_machine) else: + logger.info("All sensors got a value, switching to a proper state: Space is (about to) open") return StateMachine.StateAboutToOpen(self.state_machine) return super().handle_pins_event() class StateFallback(State): def __init__(self, sm, nervlist = None): - super().__init__(self, sm, nervlist) - self._last_blink_time = time.time() + super().__init__(sm, nervlist) self._red_state = False def handle_pins_event(self): pins = self.pins() @@ -174,21 +175,16 @@ class StateMachine(): def _close_after_time(): time.sleep(FALLBACK_LEAVE_DELAY_LOCK) self.actor().act(Actor.CMD_LOCK) - t = threading.Thread(target=_close_after_time) - t.start() - # without return because we want to stay in fallback mode - super().handle_pins_event() + fire_and_forget(_close_after_time) + # not calling superclass because we want to stay in fallback mode def handle_wakeup_event(self): # blink red LED - now = time.time() - if now - self._last_blink_time < FALLBACK_BLINK_SPEED: - if self._red_state: - self.actor().act(Actor.CMD_RED_OFF) - self._red_state = False - else: - self.actor().act(Actor.CMD_RED_ON) - self._red_state = True - self._last_blink_time = now + if self._red_state: + self.actor().act(Actor.CMD_RED_OFF) + self._red_state = False + else: + self.actor().act(Actor.CMD_RED_ON) + self._red_state = True def handle_cmd_unlock_event(self,arg): if arg is not None: arg("298 Fallback Okay: Trying to unlock the door. The System is in fallback mode, success information is not available.") @@ -209,19 +205,20 @@ class StateMachine(): nervlist = [(OPEN_REPEAT_TIMEOUT, lambda: self.actor().act(Actor.CMD_UNLOCK)) for t in range(OPEN_REPEAT_NUMBER)] nervlist += [(OPEN_REPEAT_TIMEOUT, self.could_not_open)] super().__init__(sm,nervlist) - self.callbacks=[callback] - # TODO: can we send "202 processing: Trying to unlock the door" here? Are the callbacks multi-use? + self.callbacks = [] self.actor().act(Actor.CMD_UNLOCK) - def notify(self, did_it_work): - s = "200 okay: door unlocked" if did_it_work else ("500 internal server error: Couldn't unlock door with %d tries à %f seconds" % (OPEN_REPEAT_NUMBER,OPEN_REPEAT_TIMEOUT)) + # enqueue the callback + self.handle_cmd_unlock_event(callback) + def notify(self, s, lastMsg): for cb in self.callbacks: - if cb is not None: - cb(s) + cb(s, lastMsg) def on_leave(self): - self.notify(not self.pins().door_locked) + s = "200 okay: door unlocked" if not self.pins().door_locked else ("500 internal server error: Couldn't unlock door with %d tries à %f seconds" % (OPEN_REPEAT_NUMBER,OPEN_REPEAT_TIMEOUT)) + self.notify(s, lastMsg=True) def handle_cmd_unlock_event(self,callback): - # TODO: 202 notification also here if possible - self.callbacks.append(callback) + if callback is not None: + callback("202 processing: Trying to unlock the door", lastMsg=False) + self.callbacks.append(callback) def could_not_open(self): logger.critical("StateMachine: Couldn't open door after %d tries. Going back to StateZu." % OPEN_REPEAT_NUMBER) return StateMachine.StateZu(self.state_machine) @@ -247,6 +244,7 @@ class StateMachine(): nervlist = [(24*60*60, lambda: logger.critical("Space is now open for 24h. Is everything all right?"))] super().__init__(sm, nervlist) self.last_buzzed = None + self.api().set_state(True) def handle_pins_event(self): pins = self.pins() if pins.bell_ringing and not self.old_pins().bell_ringing: # first thing to check: edge detection @@ -257,6 +255,8 @@ class StateMachine(): logger.info("StateMachine: space switch turned off - starting leaving procedure") return StateMachine.StateAboutToLeave(self.state_machine) return super().handle_pins_event() + def on_leave(self): + self.api().set_state(False) class StateLocking(AbstractUnlockedState): def __init__(self,sm): @@ -305,12 +305,16 @@ class StateMachine(): return StateMachine.StateAuf(self.state_machine) return super().handle_pins_event() - def __init__(self, actor, fallback = False): + def __init__(self, actor, waker, api, fallback = False): self.actor = actor + self.api = api self.callback = ThreadFunction(self._callback, name="StateMachine") - self.current_state = StateMachine.StateStart(self, fallback) + self.current_state = StateMachine.StateStart(self, fallback=fallback) self.pins = None self.old_pins = None + waker.register(lambda: self.callback(StateMachine.CMD_WAKEUP), 1.0) # wake up every second + # initially, the space is closed + api.set_state(False) def stop (self): self.callback.stop()