X-Git-Url: https://git.ralfj.de/saartuer.git/blobdiff_plain/f821d08610f37224ff13df938715da4438592907..344d58d13b3ec1d7fb26d13de114d6e8afbe3218:/statemachine.py

diff --git a/statemachine.py b/statemachine.py
index 7c75a7a..a3c4aff 100644
--- a/statemachine.py
+++ b/statemachine.py
@@ -1,6 +1,6 @@
 from libtuer import ThreadFunction, logger, fire_and_forget
 from actor import Actor
-import os, random, time
+import os, random, time, threading
 
 # logger.{debug,info,warning,error,critical}
 
@@ -22,6 +22,10 @@ OPEN_REPEAT_NUMBER = 3
 CLOSE_REPEAT_TIMEOUT = 7
 CLOSE_REPEAT_NUMBER = 3
 
+# StateFallback constants
+FALLBACK_BLINK_SPEED = 0.5 # seconds
+FALLBACK_LEAVE_DELAY_LOCK = 5 # seconds
+
 # StateAboutToOpen constants
 ABOUTOPEN_NERVLIST = [(5, lambda : play_sound("flipswitch")), (5, lambda:play_sound("flipswitch")), (0, lambda:logger.warning("Space open but switch not flipped for 10 seconds")),\
 	(10, lambda:play_sound("flipswitch")), (10, lambda:play_sound("flipswitch")), (0, lambda:logger.error("Space open but switch not flipped for 30 seconds")),\
@@ -127,26 +131,77 @@ class StateMachine():
 			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.warning("StateMachine: door manually locked, but space switch is still on - going to StateZu")
 					play_sound("manual_lock")
 				return StateMachine.StateZu(self.state_machine)
 			return super().handle_pins_event()
 	
 	class StateStart(State):
+		def __init__(self, sm, nervlist = None, fallback=False):
+			super().__init__(self, sm, nervlist)
+			self.fallback = fallback
 		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):
-				logger.info("All sensors got a value, switching to a proper state")
+				if self.fallback:
+					logger.info("Going to StateFallback because running in fallback mode")
+					return StateMachine.StateFallback(self.state_machine)
 				if pins.door_locked:
+					logger.info("All sensors got a value, switching to a proper state: Space is closed")
 					return StateMachine.StateZu(self.state_machine)
 				else:
+					logger.info("All sensors got a value, switching to a proper state: Space is (about to) open")
 					return StateMachine.StateAboutToOpen(self.state_machine)
 			return super().handle_pins_event()
 	
+	class StateFallback(State):
+		def __init__(self, sm, nervlist = None):
+			super().__init__(self, sm, nervlist)
+			self._last_blink_time = time.time()
+			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)
+			else:
+				self.actor().act(Actor.CMD_GREEN_OFF)
+			# primitive leaving procedure if space switch turned off
+			if not pins.space_active and self.old_pins().space_active:
+				def _close_after_time():
+					time.sleep(FALLBACK_LEAVE_DELAY_LOCK)
+					self.actor().act(Actor.CMD_LOCK)
+				t = threading.Thread(target=_close_after_time)
+				t.start()
+			# not calling superclass because we want to stay in fallback mode
+		def handle_wakeup_event(self):
+			# blink red LED
+			now = time.time()
+			if now - self._last_blink_time < FALLBACK_BLINK_SPEED:
+				if self._red_state:
+					self.actor().act(Actor.CMD_RED_OFF)
+					self._red_state = False
+				else:
+					self.actor().act(Actor.CMD_RED_ON)
+					self._red_state = True
+				self._last_blink_time = now
+		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.")
+			self.actor().act(Actor.CMD_UNLOCK)
+	
 	class StateZu(AbstractLockedState):
 		def handle_cmd_unlock_event(self,callback):
 			return StateMachine.StateUnlocking(self.state_machine, callback)
+		def handle_pins_event(self):
+			if not self.old_pins().space_active and self.pins().space_active: # first thing to check: edge detection
+				logger.info("Space toggled to active while it was closed - unlocking the door")
+				return StateMachine.StateUnlocking(self.state_machine)
+			return super().handle_pins_event()
 	
 	class StateUnlocking(AbstractLockedState):
 		def __init__(self,sm,callback=None):
@@ -194,7 +249,7 @@ class StateMachine():
 			self.last_buzzed = None
 		def handle_pins_event(self):
 			pins = self.pins()
-			if pins.bell_ringing and not self.old_pins().bell_ringing:
+			if pins.bell_ringing and not self.old_pins().bell_ringing: # first thing to check: edge detection
 				# someone just pressed the bell
 				logger.info("StateMachine: buzzing because of bell ringing in StateAuf")
 				self.actor().act(Actor.CMD_BUZZ)
@@ -250,10 +305,10 @@ class StateMachine():
 				return StateMachine.StateAuf(self.state_machine)
 			return super().handle_pins_event()
 	
-	def __init__(self, actor):
+	def __init__(self, actor, fallback = False):
 		self.actor = actor
 		self.callback = ThreadFunction(self._callback, name="StateMachine")
-		self.current_state = StateMachine.StateStart(self)
+		self.current_state = StateMachine.StateStart(self, fallback)
 		self.pins = None
 		self.old_pins = None