X-Git-Url: https://git.ralfj.de/saartuer.git/blobdiff_plain/05d80f06d0d28433e7b730e6290b79c7d0e32c6b..110416af543da9bffe1d02fa31885b5731a22aef:/statemachine.py diff --git a/statemachine.py b/statemachine.py index f2fb817..7c75a7a 100644 --- a/statemachine.py +++ b/statemachine.py @@ -79,6 +79,8 @@ class StateMachine(): def handle_wakeup_event(self): if self._nerver is not None: return self._nerver.nerv() + def on_leave(self): + pass def pins(self): return self.state_machine.pins def old_pins(self): @@ -97,29 +99,45 @@ class StateMachine(): else: raise Exception("Unknown command number: %d" % ev) - class AbstractLockedState(State): + class AbstractNonStartState(State): + def handle_pins_event(self): + if self.pins().door_locked != (not self.pins().space_active): + self.actor().act(Actor.CMD_RED_ON) + else: + self.actor().act(Actor.CMD_RED_OFF) + return super().handle_pins_event() + + class AbstractLockedState(AbstractNonStartState): '''A state with invariant "The space is locked", switching to StateAboutToOpen when the space becomes unlocked''' + def __init__(self, sm, nervlist = None): + super().__init__(sm, nervlist) + self.actor().act(Actor.CMD_GREEN_OFF) def handle_pins_event(self): if not self.pins().door_locked: - return StateAboutToOpen(self.state_machine) - return super().handle_pins_event + logger.info("Door unlocked, space is about to open") + return StateMachine.StateAboutToOpen(self.state_machine) + return super().handle_pins_event() - class AbstractUnlockedState(State): + class AbstractUnlockedState(AbstractNonStartState): '''A state with invariant "The space is unlocked", switching to StateZu when the space becomes locked''' + def __init__(self, sm, nervlist = None): + super().__init__(sm, nervlist) + self.actor().act(Actor.CMD_GREEN_ON) def handle_pins_event(self): if self.pins().door_locked: + logger.info("Door locked, closing space") if self.pins().space_active: # FIXME the same state can be reached by first locking the door, and then activating the space. What to do then? - logger.info("StateMachine: door manually locked, but space switch is still on - going to StateZu") + logger.warning("StateMachine: door manually locked, but space switch is still on - going to StateZu") play_sound("manual_lock") - return StateZu(self.state_machine) - return super().handle_pins_event + return StateMachine.StateZu(self.state_machine) + return super().handle_pins_event() class StateStart(State): 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): - # All sensors got a value, switch to a proper state + logger.info("All sensors got a value, switching to a proper state") if pins.door_locked: return StateMachine.StateZu(self.state_machine) else: @@ -144,37 +162,35 @@ class StateMachine(): for cb in self.callbacks: if cb is not None: cb(s) - def handle_pins_event(self): - # overriding superclass as we need to do notification (TODO can this be done better? on_leave?) - if not self.pins().door_locked: - self.notify(True) - return StateMachine.StateAboutToOpen(self.state_machine) + def on_leave(self): + self.notify(not self.pins().door_locked) def handle_cmd_unlock_event(self,callback): # TODO: 202 notification also here if possible 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) - self.notify(False) return StateMachine.StateZu(self.state_machine) - class AbstractStateWhereOpeningIsRedundant(AbstractUnlockedState): + class AbstractStateWhereUnlockingIsRedundant(AbstractUnlockedState): def handle_cmd_unlock_event(self, callback): callback("299 redundant: Space seems to be already open. Still processing your request tough.") logger.info("StateMachine: Received UNLOCK command in %s. This should not be necessary." % self.__class__.__name__) self.actor().act(Actor.CMD_UNLOCK) - class StateAboutToOpen(AbstractStateWhereOpeningIsRedundant): + class StateAboutToOpen(AbstractStateWhereUnlockingIsRedundant): def __init__(self, sm): super().__init__(sm, ABOUTOPEN_NERVLIST) def handle_pins_event(self): pins = self.pins() if pins.space_active: + logger.info("Space activated, opening procedure completed") return StateMachine.StateAuf(self.state_machine) return super().handle_pins_event() - class StateAuf(AbstractStateWhereOpeningIsRedundant): + class StateAuf(AbstractStateWhereUnlockingIsRedundant): def __init__(self,sm): - super().__init__(sm) + 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 def handle_pins_event(self): pins = self.pins() @@ -217,6 +233,7 @@ class StateMachine(): if not self.pins().door_closed: return StateMachine.StateLeaving(self.state_machine) if self.pins().space_active: + logger.info("Space re-activated, cancelling leaving procedure") return StateMachine.StateAuf(self.state_machine) return super().handle_pins_event() @@ -226,8 +243,10 @@ class StateMachine(): super().__init__(sm, nervlist) def handle_pins_event(self): if self.pins().door_closed: + logger.info("The space was left, locking the door") return StateMachine.StateLocking(self.state_machine) if self.pins().space_active: + logger.info("Space re-activated, cancelling leaving procedure") return StateMachine.StateAuf(self.state_machine) return super().handle_pins_event() @@ -249,6 +268,8 @@ class StateMachine(): newstate = self.current_state.handle_event(cmd,arg) # returns None or an instance of the new state self.old_pins = self.pins while newstate is not None: + assert isinstance(newstate, StateMachine.State), "I should get a state" + self.current_state.on_leave() logger.debug("StateMachine: Doing state transition %s -> %s" % (self.current_state.__class__.__name__, newstate.__class__.__name__)) self.current_state = newstate newstate = self.current_state.handle_event(StateMachine.CMD_PINS, self.pins)