X-Git-Url: https://git.ralfj.de/saartuer.git/blobdiff_plain/78609160138984cdd732e2a27c73f4dbd7a12935..7a99a7eb3b2f2c539836875d2cc8ea15a42ea49f:/statemachine.py

diff --git a/statemachine.py b/statemachine.py
index a019eef..b647ac9 100644
--- a/statemachine.py
+++ b/statemachine.py
@@ -1,4 +1,4 @@
-from libtuer import ThreadFunction, logger, fire_and_forget
+from libtuer import ThreadFunction, logger, fire_and_forget, fire_and_forget_cmd
 from actor import Actor
 import os, random, time, threading
 
@@ -13,6 +13,15 @@ def play_sound (what):
 	soundfile = SOUNDS_DIRECTORY + what + '/' + random.choice(soundfiles)
 	fire_and_forget_cmd ([SOUNDS_PLAYER,soundfile], logger.error, "StateMachine: ")
 
+# convert an absolute nervlist to a relative one
+def nervlist_abs2rel(nervlist_abs):
+	nervlist_rel = []
+	last_t = 0
+	for (t, f) in nervlist_abs:
+		assert t >= last_t
+		nervlist_rel.append((t-last_t, f))
+	return nervlist_rel
+
 
 # StateUnlocking constants
 OPEN_REPEAT_TIMEOUT = 7
@@ -26,10 +35,12 @@ CLOSE_REPEAT_NUMBER = 3
 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")),\
-	(10, lambda:play_sound("flipswitch")), (10, lambda:play_sound("flipswitch")), (6, lambda:play_sound("flipswitch")), (4, lambda:logger.critical("Space open but switch not flipped for 60 seconds")),
-	(59*60, lambda:logger.critical("Space open but switch not flipped for one hour"))]
+ABOUTOPEN_NERVLIST = nervlist_abs2rel([(5, lambda : play_sound("flipswitch")), (10, lambda:play_sound("flipswitch")),\
+	(20, lambda:play_sound("flipswitch")), (30, lambda:play_sound("flipswitch")), (30, lambda:logger.error("Space open but switch not flipped for 30 seconds")),\
+	(40, lambda:play_sound("flipswitch")), (50, lambda:play_sound("flipswitch")), (60, lambda:play_sound("flipswitch")),
+	(60, lambda:logger.critical("Space open but switch not flipped for 60 seconds")), (120, lambda:play_sound("flipswitch")),
+	(10*60, lambda:logger.critical("Space open but switch not flipped for 10 minutes")),
+	(60*60, lambda:logger.critical("Space open but switch not flipped for one hour"))])
 
 # Timeout we wait after the switch was switched to "Closed", until we assume nobody will open the door and we just lock it
 # ALso the time we wait after the door was opend, till we assume something went wrong and start nerving
@@ -90,6 +101,8 @@ class StateMachine():
 			return self.state_machine.old_pins
 		def actor(self):
 			return self.state_machine.actor
+		def api(self):
+			return self.state_machine.api
 		def handle_event(self,ev,arg): # don't override
 			if ev == StateMachine.CMD_PINS:
 				return self.handle_pins_event()
@@ -156,7 +169,6 @@ class StateMachine():
 	class StateFallback(State):
 		def __init__(self, sm, nervlist = None):
 			super().__init__(sm, nervlist)
-			self._last_blink_time = time.time()
 			self._red_state = False
 		def handle_pins_event(self):
 			pins = self.pins()
@@ -178,14 +190,12 @@ class StateMachine():
 			# not calling superclass because we want to stay in fallback mode
 		def handle_wakeup_event(self):
 			# blink red LED
-			now = time.time()
 			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.")
@@ -206,19 +216,20 @@ class StateMachine():
 			nervlist = [(OPEN_REPEAT_TIMEOUT, lambda: self.actor().act(Actor.CMD_UNLOCK)) for t in range(OPEN_REPEAT_NUMBER)]
 			nervlist += [(OPEN_REPEAT_TIMEOUT, self.could_not_open)]
 			super().__init__(sm,nervlist)
-			self.callbacks=[callback]
-			# TODO: can we send "202 processing: Trying to unlock the door" here? Are the callbacks multi-use?
+			self.callbacks = []
 			self.actor().act(Actor.CMD_UNLOCK)
-		def notify(self, did_it_work):
-			s = "200 okay: door unlocked" if did_it_work else ("500 internal server error: Couldn't unlock door with %d tries à %f seconds" % (OPEN_REPEAT_NUMBER,OPEN_REPEAT_TIMEOUT))
+			# enqueue the callback
+			self.handle_cmd_unlock_event(callback)
+		def notify(self, s, lastMsg):
 			for cb in self.callbacks:
-				if cb is not None:
-					cb(s)
+				cb(s, lastMsg)
 		def on_leave(self):
-			self.notify(not self.pins().door_locked)
+			s = "200 okay: door unlocked" if not self.pins().door_locked else ("500 internal server error: Couldn't unlock door with %d tries à %f seconds" % (OPEN_REPEAT_NUMBER,OPEN_REPEAT_TIMEOUT))
+			self.notify(s, lastMsg=True)
 		def handle_cmd_unlock_event(self,callback):
-			# TODO: 202 notification also here if possible
-			self.callbacks.append(callback)
+			if callback is not None:
+				callback("202 processing: Trying to unlock the door", lastMsg=False)
+				self.callbacks.append(callback)
 		def could_not_open(self):
 			logger.critical("StateMachine: Couldn't open door after %d tries. Going back to StateZu." % OPEN_REPEAT_NUMBER)
 			return StateMachine.StateZu(self.state_machine)
@@ -244,6 +255,7 @@ class StateMachine():
 			nervlist = [(24*60*60, lambda: logger.critical("Space is now open for 24h. Is everything all right?"))]
 			super().__init__(sm, nervlist)
 			self.last_buzzed = None
+			self.api().set_state(True)
 		def handle_pins_event(self):
 			pins = self.pins()
 			if pins.bell_ringing and not self.old_pins().bell_ringing: # first thing to check: edge detection
@@ -254,6 +266,8 @@ class StateMachine():
 				logger.info("StateMachine: space switch turned off - starting leaving procedure")
 				return StateMachine.StateAboutToLeave(self.state_machine)
 			return super().handle_pins_event()
+		def on_leave(self):
+			self.api().set_state(False)
 	
 	class StateLocking(AbstractUnlockedState):
 		def __init__(self,sm):
@@ -302,13 +316,16 @@ class StateMachine():
 				return StateMachine.StateAuf(self.state_machine)
 			return super().handle_pins_event()
 	
-	def __init__(self, actor, waker, fallback = False):
+	def __init__(self, actor, waker, api, fallback = False):
 		self.actor = actor
+		self.api = api
 		self.callback = ThreadFunction(self._callback, name="StateMachine")
 		self.current_state = StateMachine.StateStart(self, fallback=fallback)
 		self.pins = None
 		self.old_pins = None
 		waker.register(lambda: self.callback(StateMachine.CMD_WAKEUP), 1.0) # wake up every second
+		# initially, the space is closed
+		api.set_state(False)
 	
 	def stop (self):
 		self.callback.stop()