From 4f929e668c842100aaaf31008c4624c75b280a1b Mon Sep 17 00:00:00 2001 From: Ralf Jung Date: Thu, 10 Oct 2013 19:03:22 +0200 Subject: [PATCH] implement a general nerv mechanism and also use it for door closing/opening --- statemachine.py | 85 +++++++++++++++++++++++++------------------------ 1 file changed, 43 insertions(+), 42 deletions(-) diff --git a/statemachine.py b/statemachine.py index 3332858..1be022b 100644 --- a/statemachine.py +++ b/statemachine.py @@ -39,6 +39,21 @@ SOUNDS_DIRECTORY = "/opt/tuer/sounds/" SOUNDS_PLAYER = "/usr/bin/mplayer" +class Nerver(): + # A little utility class used to run the nervlists. A nervlist is a list of (n, f) tuples where f() is run after n seconds. + # If f returns something, that's also returned by nerv. + def __init__(self, nervlist): + self.nervlist = list(nervlist) + + def nerv(self, total_time): + if len(self.nervlist): + (time, f) = self.nervlist[0] + # check if the first element is to be triggered + if time >= total_time: + self.nervlist = self.nervlist[1:] # "pop" the first element, but do not modify original list + return f() + + class StateMachine(): # commands you can send CMD_PINS = 0 @@ -48,11 +63,10 @@ class StateMachine(): CMD_LAST = 4 class State(): - def __init__(self, state_machine): + def __init__(self, state_machine, nervlist = None): self.state_machine = state_machine self.time_entered = time.time() - self.theDict = None - self.last_wakeup = self.time_entered + self._nerver = None if nervlist is None else Nerver(nervlist) def handle_pins_event(self): pass # one needn't implement this def handle_buzz_event(self,arg): # this shouldn't be overwritten @@ -62,7 +76,8 @@ class StateMachine(): if arg is not None: arg("412 Precondition Failed: The current state (%s) cannot handle the OPEN event" % self.__class__.__name__) def handle_wakeup_event(self): - self.last_wakeup = time.time() + if self._nerver is not None: + return self._nerver.nerv(time.time() - self.time_entered) def pins(self): return self.state_machine.pins def actor(self): @@ -103,15 +118,17 @@ class StateMachine(): class StateOpening(State): def __init__(self,callback,sm): - super().__init__(self,sm) + # construct a nervlist + nervlist = [(t*OPEN_REPEAT_TIMEOUT, lambda: self.actor().act(Actor.CMD_OPEN)) for t in xrange(1, OPEN_REPEAT_NUMBER+1)] + nervlist += [((OPEN_REPEAT_NUMBER+1)*OPEN_REPEAT_TIMEOUT, self.could_not_open)] + super().__init__(sm,nervlist) self.callbacks=[callback] # FIXME: can we send "202 processing: Trying to open the door" here? Are the callbacks multi-use? - self.tries = 0 self.actor().act(Actor.CMD_OPEN) def notify(self, did_it_work): s = "200 okay: door open" if did_it_work else ("500 internal server error: Couldn't open door with %d tries à %f seconds" % (OPEN_REPEAT_NUMBER,OPEN_REPEAT_TIMEOUT)) for cb in self.callbacks: - if cb is not None: + if cb is not None: # FIXME why this check? shouldn't be needed cb(s) def handle_pins_event(self): super().handle_pins_event() @@ -123,18 +140,10 @@ class StateMachine(): # intentionally not calling super() implementation # FIXME: 202 notification also here if possible self.callbacks.append(callback) - def handle_wakeup_event(self): - super().handle_wakeup_event() - over = time.time() - self.time_entered - nexttry = (self.tries+1) * OPEN_REPEAT_TIMEOUT - if over > nexttry: - if self.tries < OPEN_REPEAT_NUMBER: - self.actor().act(Actor.CMD_OPEN) - self.tries += 1 - else: - logger.critical("Couldn't open door after %d tries. Going back to StateZu." % OPEN_REPEAT_NUMBER) - self.notify(False) - return StateZu(self.state_machine) + def could_not_open(self): + logger.critical("Couldn't open door after %d tries. Going back to StateZu." % OPEN_REPEAT_NUMBER) + self.notify(False) + return StateZu(self.state_machine) class AbstractStateWhereOpeningIsRedundant(State): def handle_open_event(self, callback): @@ -144,6 +153,8 @@ class StateMachine(): self.actor().act(Actor.CMD_OPEN) class StateAboutToOpen(AbstractStateWhereOpeningIsRedundant): + def __init__(self, sm): + super().__init__(sm, ABOUTOPEN_NERVLIST) def handle_pins_event(self): super().handle_pins_event() pins = self.pins() @@ -151,15 +162,6 @@ class StateMachine(): return StateZu(self.state_machine) elif pins.space_active: return StateAuf(self.state_machine) - def handle_wakeup_event(self): - super().handle_wakeup_event() - now = time.time() - lasttime = self.last_wakeup - self.time_entered - thistime = now - self.time_entered - for (t,f) in filter(lambda (t,f): t<=thistime and t>lasttime, ABOUTOPEN_NERVLIST): - ret = f(); - if ret is not None: - return ret class StateAuf(AbstractStateWhereOpeningIsRedundant): def __init__(self,sm): @@ -185,9 +187,12 @@ class StateMachine(): class StateClosing(State): # FIXME: Why does this even have callbacks? - # TODO: share code with StateOpening, and possibly also with the nerv-mechanism from StateAboutToOpen + # TODO: share code with StateOpening def __init__(self,sm): - super().__init__(sm) + # construct a nervlist + nervlist = [(t*CLOSE_REPEAT_TIMEOUT, lambda: self.actor().act(Actor.CMD_CLOSE)) for t in xrange(1, CLOSE_REPEAT_NUMBER+1)] + nervlist += [((CLOSE_REPEAT_NUMBER+1)*CLOSE_REPEAT_TIMEOUT, self.could_not_close)] + super().__init__(sm, nervlist) self.callbacks=[] # FIXME: can we send "202 processing: Trying to close the door" here? Are the callbacks multi-use? self.tries = 0 @@ -200,22 +205,18 @@ class StateMachine(): cb(s) def handle_pins_event(self): pins = self.pins() - if not pins.door_locked: + if not pins.door_closed: + # TODO play a sound? This shouldn't happen, door was opened while we are locking self.notify(True) return StateAboutToOpen(self.state_machine) + if pins.door_locked: + return SpaceZu(self.state_machine) def handle_open_event(self,callback): callback("409 conflict: The server is currently trying to close the door. Try again later.") - def handle_wakeup_event(self): - over = time.time() - self.time_entered - nexttry = (self.tries+1) * CLOSE_REPEAT_TIMEOUT - if over > nexttry: - if self.tries < CLOSE_REPEAT_NUMBER: - self.actor().act(Actor.CMD_CLOSE) - self.tries += 1 - else: - logger.critical("Couldn't close door after %d tries. Going back to StateAboutToOpen." % CLOSE_REPEAT_NUMBER) - self.notify(False) - return StateAboutToOpen(self.state_machine) + def could_not_close(self): + logger.critical("Couldn't close door after %d tries. Going back to StateAboutToOpen." % CLOSE_REPEAT_NUMBER) + self.notify(False) + return StateAboutToOpen(self.state_machine) class StateAboutToLeave(State): def handle_pins_event(self): -- 2.30.2