fallback mode usable from tyshell

diff --git a/statemachine.py b/statemachine.py
index 62f523a346305c39f125bcfeb08a3b8a7897300c..e6a27570c45c2731607d95c3f0d9646ff45024db 100644 (file)
--- a/statemachine.py
+++ b/statemachine.py
@@ -83,6 +83,9 @@ class StateMachine():
        CMD_UNLOCK = 2
        CMD_WAKEUP = 3
        CMD_LAST = 4
        CMD_UNLOCK = 2
        CMD_WAKEUP = 3
        CMD_LAST = 4

+       CMD_LOCK = 5
+       CMD_FALLBACK_ON = 6
+       CMD_FALLBACK_OFF = 7

        
        class State():
                def __init__(self, state_machine, nervlist = None):
        
        class State():
                def __init__(self, state_machine, nervlist = None):


@@ -99,6 +102,14 @@ class StateMachine():
                def handle_wakeup_event(self):
                        if self._nerver is not None:
                                return self._nerver.nerv()
                def handle_wakeup_event(self):
                        if self._nerver is not None:
                                return self._nerver.nerv()

+               def handle_cmd_lock_event(self,arg):
+                       arg("412 Precondition Failed: If not in fallback mode, use the hardware switch to lock the space.")
+               def handle_cmd_fallback_on_event(self,arg):
+                       arg("200 okay: Entering fallback mode and notifying admins.")
+                       logger.critical("Entering fallback mode. Somebody thinks, the hardware sensors are broken.")
+                       return StateMachine.StateFallback(self.state_machine)
+               def handle_cmd_fallback_off_event(self,arg):
+                       arg("412 Precondition Failed: Not in fallback mode!")

                def on_leave(self):
                        pass
                def pins(self):
                def on_leave(self):
                        pass
                def pins(self):


@@ -118,6 +129,12 @@ class StateMachine():
                                return self.handle_cmd_unlock_event(arg)
                        elif ev == StateMachine.CMD_WAKEUP:
                                return self.handle_wakeup_event()
                                return self.handle_cmd_unlock_event(arg)
                        elif ev == StateMachine.CMD_WAKEUP:
                                return self.handle_wakeup_event()

+                       elif ev == StateMachine.CMD_LOCK:
+                               return self.handle_cmd_lock_event(arg)
+                       elif ev == StateMachine.CMD_FALLBACK_ON:
+                               return self.handle_cmd_fallback_on_event(arg)
+                       elif ev == StateMachine.CMD_FALLBACK_OFF:
+                               return self.handle_cmd_fallback_off_event(arg)

                        else:
                                raise Exception("Unknown command number: %d" % ev)
        
                        else:
                                raise Exception("Unknown command number: %d" % ev)
        


@@ -178,10 +195,6 @@ class StateMachine():
                        self._red_state = False
                def handle_pins_event(self):
                        pins = self.pins()
                        self._red_state = False
                def handle_pins_event(self):
                        pins = self.pins()

-                       # buzz if open and bell rang
-                       if pins.space_active and pins.bell_ringing and not self.old_pins().bell_ringing:
-                               logger.info("StateFallback: Space switch on and door bell rung => buzzing")
-                               self.actor().act(Actor.CMD_BUZZ)

                        # set green LED according to space switch
                        if pins.space_active:
                                self.actor().act(Actor.CMD_GREEN_ON)
                        # set green LED according to space switch
                        if pins.space_active:
                                self.actor().act(Actor.CMD_GREEN_ON)


@@ -204,8 +217,18 @@ class StateMachine():
                                self._red_state = True
                def handle_cmd_unlock_event(self,arg):
                        if arg is not None:
                                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.")
+                               arg("200 okay: Trying to unlock the door. The System is in fallback mode, success information is not available.")

                        self.actor().act(Actor.CMD_UNLOCK)
                        self.actor().act(Actor.CMD_UNLOCK)

+               def handle_cmd_lock_event(self,arg):
+                       if arg is not None:
+                               arg("200 okay: Trying to lock the door. The System is in fallback mode, success information is not available.")
+                       self.actor().act(Actor.CMD_LOCK)
+               def handle_cmd_fallback_on_event(self,arg):
+                       arg("412 Precondition Failed: Fallback mode already active.")
+               def handle_cmd_fallback_off_event(self,arg):
+                       arg("200 okay: Leaving fallback mode and notifying admins.")
+                       logger.critical("Leaving fallback mode. Somebody thinks, the sensors are working again.")
+                       return StateMachine.StateStart(self.state_machine)

        
        class StateZu(AbstractLockedState):
                def handle_cmd_unlock_event(self,callback):
        
        class StateZu(AbstractLockedState):
                def handle_cmd_unlock_event(self,callback):


@@ -340,6 +363,7 @@ class StateMachine():
        def stop (self):
                self.callback.stop()
        
        def stop (self):
                self.callback.stop()
        

+       # actually call this.callback (is set in the constructor to make this thread safe)

        def _callback(self, cmd, arg=None):
                # update pins
                if cmd == StateMachine.CMD_PINS:
        def _callback(self, cmd, arg=None):
                # update pins
                if cmd == StateMachine.CMD_PINS:

diff --git a/tyshell b/tyshell
index 2df0a229b5069a4a4e292a9bcbaf87ccdff1906c..70ad6df0746316232e8f15a72dead40663215573 100755 (executable)
--- a/tyshell
+++ b/tyshell
@@ -64,14 +64,28 @@ def alias (cmds, aliases):
                cmds[newname] = cmds[oldname]
        return cmds
 
                cmds[newname] = cmds[oldname]
        return cmds
 

+def prompt_sure(f,msg):
+       def run(c):
+               try:
+                       command = input("%s Are you sure? (yes/no) > " % msg)
+               except EOFError:
+                       print()
+                       return
+               if command[0] == 'y':
+                       return f(c)
+       return run
+

 CmdEntry = namedtuple('CmdEntry','function helpstring')
 
 commands = alias({
        'exit': CmdEntry(exitcmd, 'Quits this shell'),
        'help': CmdEntry(helpcmd, 'Helps you getting to know the available commands'),
        'unlock': CmdEntry(sendcmd(tuerSock, 'unlock'), 'Will try to unlock the apartment door'),
 CmdEntry = namedtuple('CmdEntry','function helpstring')
 
 commands = alias({
        'exit': CmdEntry(exitcmd, 'Quits this shell'),
        'help': CmdEntry(helpcmd, 'Helps you getting to know the available commands'),
        'unlock': CmdEntry(sendcmd(tuerSock, 'unlock'), 'Will try to unlock the apartment door'),

+       'lock': CmdEntry(sendcmd(tuerSock, 'lock'), 'If in fallback mode, try to lock the apartment door. If not in fallback mode, you must use the switch near the door.'),

        'buzz': CmdEntry(sendcmd(tuerSock, 'buzz'), 'Will buzz the buzzer for the street door'),
        'who': CmdEntry(whocmd, 'Shows the list of people, who are allowed to control this system'),
        'buzz': CmdEntry(sendcmd(tuerSock, 'buzz'), 'Will buzz the buzzer for the street door'),
        'who': CmdEntry(whocmd, 'Shows the list of people, who are allowed to control this system'),

+       'fallback_mode_on': CmdEntry(prompt_sure(sendcmd(tuerSock, 'fallback_mode_on'),'WARNING: This action will be reported to the admins. Use this only in case of Sphinx hardware failure when you need to ignore erroneous sensor input!'), 'Sets the system in a state where it is less dependent on sensoric input. Use it only when sensors are broken.'),
+       'fallback_mode_off': CmdEntry(prompt_sure(sendcmd(tuerSock, 'fallback_mode_off'),'WARNING: This action will be reported to the admins. Use this only if you have fixed the sensors of the Sphinx or activated fallback mode by accident!'), 'Resets the system to the default state. Use this when you have just repaired the sensors of the Sphinx.'),

 },{
        # aliases
        'open': 'unlock',
 },{
        # aliases
        'open': 'unlock',

diff --git a/tysock.py b/tysock.py
index 676f57398b28b73f81e5882b79fefd831e84e6ca..b7cb1cc6b09e2cb909481a256b9f9ee203534d82 100644 (file)
--- a/tysock.py
+++ b/tysock.py
@@ -27,6 +27,9 @@ class TySocket():
        CMDs = {
                b'buzz': StateMachine.CMD_BUZZ,
                b'unlock': StateMachine.CMD_UNLOCK,
        CMDs = {
                b'buzz': StateMachine.CMD_BUZZ,
                b'unlock': StateMachine.CMD_UNLOCK,

+               b'lock': StateMachine.CMD_LOCK,
+               b'fallback_mode_on': StateMachine.CMD_FALLBACK_ON,
+               b'fallback_mode_off': StateMachine.CMD_FALLBACK_OFF,

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