name some things a bit clearer: open -> unlock, close -> lock

diff --git a/actor.py b/actor.py
index 3abd2328af97172cd04481b28d7dc7d5f7f77c48..248edebc4593159c00bb06802a8876126a819116 100644 (file)
--- a/actor.py
+++ b/actor.py
@@ -3,13 +3,13 @@ import RPi.GPIO as GPIO
        
 class Actor:
        CMD_BUZZ = 0
        
 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)]),
        
        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):
        }
        
        def __init__(self):

diff --git a/statemachine.odg b/statemachine.odg
index 3201b4288b15c73cc4c24aee8d92f4bf9333b7e6..64b3cebbac907a6b1941c82b35deab817b6c0882 100644 (file)
Binary files a/statemachine.odg and b/statemachine.odg differ

diff --git a/statemachine.py b/statemachine.py
index 1be022b863f5a28d96765bfb343ee867a320cab3..6a3e88961c2749d567ff7b406896f6d9fffc42da 100644 (file)
--- a/statemachine.py
+++ b/statemachine.py
@@ -14,11 +14,11 @@ def play_sound (what):
        fire_and_forget ([SOUNDS_PLAYER,soundfile], logger.error, "StateMachine: ")
 
 
        fire_and_forget ([SOUNDS_PLAYER,soundfile], logger.error, "StateMachine: ")
 
 

-# StateOpening constants
+# StateUnlocking constants

 OPEN_REPEAT_TIMEOUT = 8
 OPEN_REPEAT_NUMBER = 3
 
 OPEN_REPEAT_TIMEOUT = 8
 OPEN_REPEAT_NUMBER = 3
 

-# StateClosing constants
+# StateLocking constants

 CLOSE_REPEAT_TIMEOUT = 8
 CLOSE_REPEAT_NUMBER = 3
 
 CLOSE_REPEAT_TIMEOUT = 8
 CLOSE_REPEAT_NUMBER = 3
 


@@ -58,7 +58,7 @@ class StateMachine():
        # commands you can send
        CMD_PINS = 0
        CMD_BUZZ = 1
        # commands you can send
        CMD_PINS = 0
        CMD_BUZZ = 1

-       CMD_OPEN = 2
+       CMD_UNLOCK = 2

        CMD_WAKEUP = 3
        CMD_LAST = 4
        
        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_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):
                        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)
                                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:
                        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)
                        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
                        # 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
                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?
                        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:
                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)
                        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)
                        # 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):
                        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.")
                        # 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):
        
        class StateAboutToOpen(AbstractStateWhereOpeningIsRedundant):
                def __init__(self, sm):


@@ -185,19 +185,19 @@ class StateMachine():
                                return StateZu(self.state_machine)
                # handle_wakeup_event intentionally not overwritten
        
                                return StateZu(self.state_machine)
                # handle_wakeup_event intentionally not overwritten
        

-       class StateClosing(State):
+       class StateLocking(State):

                # FIXME: Why does this even have callbacks?
                # FIXME: Why does this even have callbacks?

-               # TODO: share code with StateOpening
+               # TODO: share code with StateUnlocking

                def __init__(self,sm):
                        # construct a nervlist
                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"
                        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:
                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)
                                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)
                        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:
                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:
        
        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):
                        if self.pins().door_locked:
                                return StateZu(self.state_machine)
                def handle_wakeup_event(self):

diff --git a/tyshell b/tyshell
index 22809262fd4598b150428e7d8a4ea0fe1aef54e2..1ffccfeb098230594fcf34c53bf18052826b29a8 100755 (executable)
--- a/tyshell
+++ b/tyshell
@@ -47,8 +47,8 @@ def exitcmd(c):
 commands = {
        'exit': exitcmd,
        'help': helpcmd,
 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'),
 }
 
        'buzz': sendcmd(tuerSock, 'buzz'),
 }
 

diff --git a/tysock.py b/tysock.py
index 3951d1f12b8a9adb8b59b0155dc270c6f1f5573e..3a0cc3a183adbf4cea6ce14c6898d63e0667292b 100644 (file)
--- a/tysock.py
+++ b/tysock.py
@@ -26,7 +26,7 @@ def forcerm(name):
 class TySocket():
        CMDs = {
                b'buzz': StateMachine.CMD_BUZZ,
 class TySocket():
        CMDs = {
                b'buzz': StateMachine.CMD_BUZZ,

-               b'open': StateMachine.CMD_OPEN,
+               b'unlock': StateMachine.CMD_UNLOCK,

        }
        
        def __init__(self, sm):
        }
        
        def __init__(self, sm):