From: Ralf Jung <post@ralfj.de>
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

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):