From: Ralf Jung Date: Thu, 10 Oct 2013 17:06:16 +0000 (+0200) Subject: name some things a bit clearer: open -> unlock, close -> lock X-Git-Url: https://git.ralfj.de/saartuer.git/commitdiff_plain/e99d4446af1d2f2419c4de4fe3874f17b0873a48?ds=inline name some things a bit clearer: open -> unlock, close -> lock --- diff --git a/actor.py b/actor.py index 3abd232..248edeb 100644 --- a/actor.py +++ b/actor.py @@ -3,13 +3,13 @@ import RPi.GPIO as GPIO class Actor: CMD_BUZZ = 0 - CMD_OPEN = 1 - CMD_CLOSE = 2 + CMD_UNLOCK = 1 + CMD_LOCK = 2 CMDs = { CMD_BUZZ: ("buzz", 12, [(True, 0.3), (False, 2.0)]), - CMD_OPEN: ("open", 16, [(None, 0.2), (True, 0.3), (False, 1.0)]), - CMD_CLOSE: ("close", 22, [(None, 0.2), (True, 0.3), (False, 1.0)]), + CMD_UNLOCK: ("unlock", 16, [(None, 0.2), (True, 0.3), (False, 1.0)]), + CMD_LOCK: ("lock", 22, [(None, 0.2), (True, 0.3), (False, 1.0)]), } def __init__(self): diff --git a/statemachine.odg b/statemachine.odg index 3201b42..64b3ceb 100644 Binary files a/statemachine.odg and b/statemachine.odg differ diff --git a/statemachine.py b/statemachine.py index 1be022b..6a3e889 100644 --- a/statemachine.py +++ b/statemachine.py @@ -14,11 +14,11 @@ def play_sound (what): fire_and_forget ([SOUNDS_PLAYER,soundfile], logger.error, "StateMachine: ") -# StateOpening constants +# StateUnlocking constants OPEN_REPEAT_TIMEOUT = 8 OPEN_REPEAT_NUMBER = 3 -# StateClosing constants +# StateLocking constants CLOSE_REPEAT_TIMEOUT = 8 CLOSE_REPEAT_NUMBER = 3 @@ -58,7 +58,7 @@ class StateMachine(): # commands you can send CMD_PINS = 0 CMD_BUZZ = 1 - CMD_OPEN = 2 + CMD_UNLOCK = 2 CMD_WAKEUP = 3 CMD_LAST = 4 @@ -72,7 +72,7 @@ class StateMachine(): def handle_buzz_event(self,arg): # this shouldn't be overwritten self.actor.act(Actor.CMD_BUZZ) arg("200 okay: buzz executed") - def handle_open_event(self,arg): + def handle_cmd_unlock_event(self,arg): 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): @@ -87,8 +87,8 @@ class StateMachine(): self.handle_pins_event() elif arg is CMD_BUZZ: self.handle_buzz_event(arg) - elif arg is CMD_OPEN: - self.handle_open_event(arg) + elif arg is CMD_UNLOCK: + self.handle_cmd_unlock_event(arg) elif arg is CMD_WAKEUP: self.handle_wakeup_event() else: @@ -112,19 +112,19 @@ class StateMachine(): pins = self.pins() if not pins.door_locked: return StateAboutToOpen(self.state_machine) - def handle_open_event(self,callback): + def handle_cmd_unlock_event(self,callback): # intentionally not calling super() implementation - return StateOpening(callback,self.state_machine) + return StateUnlocking(callback,self.state_machine) - class StateOpening(State): + class StateUnlocking(State): def __init__(self,callback,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 = [(t*OPEN_REPEAT_TIMEOUT, lambda: self.actor().act(Actor.CMD_UNLOCK)) 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.actor().act(Actor.CMD_OPEN) + self.actor().act(Actor.CMD_UNLOCK) 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: @@ -136,7 +136,7 @@ class StateMachine(): if not pins.door_locked: self.notify(True) return StateAboutToOpen(self.state_machine) - def handle_open_event(self,callback): + def handle_cmd_unlock_event(self,callback): # intentionally not calling super() implementation # FIXME: 202 notification also here if possible self.callbacks.append(callback) @@ -146,11 +146,11 @@ class StateMachine(): return StateZu(self.state_machine) class AbstractStateWhereOpeningIsRedundant(State): - def handle_open_event(self, callback): + def handle_cmd_unlock_event(self, callback): # intentionally not calling super() implementation callback("299 redundant: Space seems to be already open. Still processing your request tough.") logger.warning("Received OPEN command in StateAboutToOpen. This should not be necessary.") - self.actor().act(Actor.CMD_OPEN) + self.actor().act(Actor.CMD_UNLOCK) class StateAboutToOpen(AbstractStateWhereOpeningIsRedundant): def __init__(self, sm): @@ -185,19 +185,19 @@ class StateMachine(): return StateZu(self.state_machine) # handle_wakeup_event intentionally not overwritten - class StateClosing(State): + class StateLocking(State): # FIXME: Why does this even have callbacks? - # TODO: share code with StateOpening + # TODO: share code with StateUnlocking def __init__(self,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 = [(t*CLOSE_REPEAT_TIMEOUT, lambda: self.actor().act(Actor.CMD_LOCK)) 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 assert self.pins().door_closed, "Door is open while we should close it, this must not happen" - self.actor().act(Actor.CMD_CLOSE) + self.actor().act(Actor.CMD_LOCK) def notify(self, did_it_work): s = "200 okay: door closed" if did_it_work else ("500 internal server error: Couldn't close door with %d tries à %f seconds" % (CLOSE_REPEAT_NUMBER,CLOSE_REPEAT_TIMEOUT)) for cb in self.callbacks: @@ -211,7 +211,7 @@ class StateMachine(): return StateAboutToOpen(self.state_machine) if pins.door_locked: return SpaceZu(self.state_machine) - def handle_open_event(self,callback): + def handle_cmd_unlock_event(self,callback): callback("409 conflict: The server is currently trying to close the door. Try again later.") def could_not_close(self): logger.critical("Couldn't close door after %d tries. Going back to StateAboutToOpen." % CLOSE_REPEAT_NUMBER) @@ -227,12 +227,12 @@ class StateMachine(): def handle_wakeup_event(self): over = time.time() - self.time_entered if over >= LEAVE_TIMEOUT: - return StateClosing(self.state_machine) + return StateLocking(self.state_machine) class StateLeaving(State): def handle_pins_event(self): if self.pins().door_closed: - return StateClosing(self.state_machine) + return StateLocking(self.state_machine) if self.pins().door_locked: return StateZu(self.state_machine) def handle_wakeup_event(self): diff --git a/tyshell b/tyshell index 2280926..1ffccfe 100755 --- a/tyshell +++ b/tyshell @@ -47,8 +47,8 @@ def exitcmd(c): commands = { 'exit': exitcmd, 'help': helpcmd, - 'open': sendcmd(tuerSock, 'open'), - 'close': sendcmd(tuerSock, 'close'), + 'open': sendcmd(tuerSock, 'unlock'), + 'unlock': sendcmd(tuerSock, 'unlock'), 'buzz': sendcmd(tuerSock, 'buzz'), } diff --git a/tysock.py b/tysock.py index 3951d1f..3a0cc3a 100644 --- a/tysock.py +++ b/tysock.py @@ -26,7 +26,7 @@ def forcerm(name): class TySocket(): CMDs = { b'buzz': StateMachine.CMD_BUZZ, - b'open': StateMachine.CMD_OPEN, + b'unlock': StateMachine.CMD_UNLOCK, } def __init__(self, sm):