341 lines
9.6 KiB
Python
341 lines
9.6 KiB
Python
#!/usr/bin/python
|
|
import os, serial, socket, subprocess, select, datetime, sys
|
|
import paho.mqtt.client as mqcl
|
|
import argparse
|
|
|
|
OPEN_THRESHOLD = 80
|
|
CLOSED_THRESHOLD = 100
|
|
CLOSED_WANT = 160
|
|
|
|
parser = argparse.ArgumentParser()
|
|
parser.add_argument("--serial_port", default="/dev/serial/by-id/usb-Imaginaerraum.de_DoorControl_43363220195053573A002C0-if01")
|
|
parser.add_argument("--nfc_fifo", default="/tmp/nfc_fifo")
|
|
parser.add_argument("--control_socket", default="/tmp/nfc.sock")
|
|
parser.add_argument("--valid_tokens", default="/etc/door_tokens")
|
|
parser.add_argument("--log_file", default="/tmp/nfc.log")
|
|
parser.add_argument("--state_timeout", type=float, default=10)
|
|
parser.add_argument("--repeat_time", type=float, default=5)
|
|
parser.add_argument("--mqtt_host", default="10.10.21.2")
|
|
|
|
config = parser.parse_args()
|
|
|
|
mqttc = mqcl.Client()
|
|
|
|
def timestamp():
|
|
return datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
|
|
|
|
# Log data to stdout and the log file
|
|
def log(*args):
|
|
data = "%s %s" % (timestamp(), " ".join(str(i) for i in args))
|
|
lgf.write(data + "\n")
|
|
lgf.flush()
|
|
print(data)
|
|
|
|
def mqtt(topic, msg, persistent = True):
|
|
mqttc.publish("door/" + topic, msg, qos=2, retain=persistent)
|
|
|
|
# Opens the socket that can control the daemon
|
|
# Commands are TBD
|
|
def open_control_socket():
|
|
global control_socket
|
|
global config
|
|
global comm_channels
|
|
|
|
if os.path.exists(config.control_socket):
|
|
os.unlink(config.control_socket)
|
|
|
|
control_socket = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
|
|
control_socket.bind(config.control_socket)
|
|
control_socket.listen(5)
|
|
comm_channels = []
|
|
|
|
# Opens the serial port to talk to the lock actuator
|
|
# Might return a failure. In that case, it will be tried again later
|
|
def open_serial_port():
|
|
global serial_port
|
|
global config
|
|
|
|
try:
|
|
serial_port = serial.Serial(config.serial_port, timeout=2)
|
|
except:
|
|
serial_port = None
|
|
pass
|
|
|
|
# Detected tokens are passed in through a FIFO
|
|
def open_nfc_fifo():
|
|
global nfc_fifo
|
|
global config
|
|
|
|
nfc_fifo = open(config.nfc_fifo, "r")
|
|
|
|
# Refresh valid tokens from the configured file
|
|
def read_valid_tokens():
|
|
global valid
|
|
global config
|
|
|
|
try:
|
|
log("Loading tokens")
|
|
valid = {}
|
|
lines =[ s.strip() for s in open(config.valid_tokens, "r").readlines() ]
|
|
for l in lines:
|
|
l = l.split(' ', 1)
|
|
if len(l) > 1:
|
|
if l[0] in valid:
|
|
log("Warning: Overwriting token %s" % (l[0],))
|
|
log("Got token: %s (%s)" % (l[0], l[1]))
|
|
valid[l[0]] = l[1]
|
|
else:
|
|
log("Got unnamed token: %s" % (l[0],))
|
|
valid[l[0]] = None
|
|
except:
|
|
valid = {}
|
|
log("Error reading token file")
|
|
raise
|
|
|
|
# Opens the log file for writing
|
|
def open_logfile():
|
|
global lgf
|
|
global config
|
|
|
|
lgf = open(config.log_file, "a+")
|
|
|
|
# Actions
|
|
IDLE, CLOSE, OPEN_THEN_CLOSE, OPEN, CLOSE_THEN_OPEN = range(5)
|
|
state_names = {
|
|
OPEN: "open",
|
|
CLOSE: "close"
|
|
}
|
|
action_names = {
|
|
IDLE: "idling",
|
|
OPEN: "waiting for open door",
|
|
CLOSE: "waiting for closed door",
|
|
OPEN_THEN_CLOSE: "waiting for open door, then closing again",
|
|
CLOSE_THEN_OPEN: "waiting for closed door, then opening again"
|
|
}
|
|
# Current door state
|
|
state = None
|
|
state_pos = 0
|
|
# Current target action
|
|
action = CLOSE
|
|
# Start time of the current action
|
|
start_time = None
|
|
# How often the action was repeated
|
|
repeats = 0
|
|
|
|
# Read the state of the door from the serial port
|
|
def poll_door_state():
|
|
global state
|
|
global state_pos
|
|
global serial_port
|
|
serial_port.reset_input_buffer()
|
|
serial_port.write(b"R")
|
|
data = serial_port.readline().strip().split()
|
|
if data[0] == b'pos:':
|
|
data = int(data[1])
|
|
if state_pos != data:
|
|
mqtt("position/value", data, True)
|
|
state_pos = data
|
|
changed = False
|
|
if data < OPEN_THRESHOLD and state != OPEN:
|
|
state = OPEN
|
|
changed = True
|
|
mqtt("state/value", "open", True)
|
|
elif data > CLOSED_THRESHOLD and state != CLOSE:
|
|
state = CLOSE
|
|
changed = True
|
|
mqtt("state/value", "closed", True)
|
|
return state
|
|
|
|
# Check the door state and send commands through a state machine
|
|
def handle_door_state():
|
|
global action, target, serial_port, start_time, repeats
|
|
|
|
# Commands associated with each target state
|
|
target_state_cmd = {
|
|
OPEN: b'O',
|
|
CLOSE: b'C'
|
|
}
|
|
|
|
old_state = state
|
|
|
|
# If no serial port, try to open it or return
|
|
if not serial_port:
|
|
try:
|
|
open_serial_port()
|
|
except:
|
|
return
|
|
|
|
# Get new state
|
|
poll_door_state()
|
|
|
|
# Idle + change = key?
|
|
if action == IDLE:
|
|
if state != old_state:
|
|
log("Door changed unexpectedly:", state_names[state])
|
|
start_time = datetime.datetime.now()
|
|
if start_time and (datetime.datetime.now() - start_time).total_seconds() >= config.state_timeout:
|
|
start_time = None
|
|
if state_pos >= CLOSED_THRESHOLD and state_pos < CLOSED_WANT:
|
|
log("Closing door a bit more")
|
|
serial_port.write(target_state_cmd[CLOSE])
|
|
return
|
|
|
|
# Target state, next action, timeout action
|
|
actions = {
|
|
OPEN: (OPEN, IDLE, CLOSE_THEN_OPEN ),
|
|
CLOSE: (CLOSE, IDLE, OPEN_THEN_CLOSE ),
|
|
OPEN_THEN_CLOSE: (OPEN, CLOSE, CLOSE ),
|
|
CLOSE_THEN_OPEN: (CLOSE, OPEN, OPEN )
|
|
}
|
|
|
|
if start_time == None:
|
|
start_time = datetime.datetime.now()
|
|
serial_port.write(target_state_cmd[actions[action][0]])
|
|
|
|
# Target state reached
|
|
if state == actions[action][0]:
|
|
# Select next action, reset start time and repetitions
|
|
action = actions[action][1]
|
|
start_time = datetime.datetime.now()
|
|
repeats = 0
|
|
# On idle, we're done
|
|
if action == IDLE:
|
|
log("Reached target position:", state_names[state])
|
|
return
|
|
|
|
# Execution time
|
|
t = (datetime.datetime.now() - start_time).total_seconds()
|
|
if t >= config.state_timeout:
|
|
# Timeout -> switch to timeout action
|
|
action = actions[action][2]
|
|
start_time = None
|
|
repeats = 0
|
|
log("Timeout. Switching to", action_names[action])
|
|
elif t >= (1 + repeats) * config.repeat_time:
|
|
# Repeat every couple of seconds
|
|
repeats += 1
|
|
serial_port.write(target_state_cmd[actions[action][0]])
|
|
log("Repeating command:", target_state_cmd[actions[action][0]])
|
|
|
|
def open_door():
|
|
global action
|
|
global start_time
|
|
log("Opening the door")
|
|
action = OPEN
|
|
start_time = None
|
|
mqtt("state/target", "open", True)
|
|
handle_door_state()
|
|
|
|
def close_door():
|
|
global action
|
|
global start_time
|
|
log("Closing the door")
|
|
action = CLOSE
|
|
start_time = None
|
|
mqtt("state/target", "closed", True)
|
|
handle_door_state()
|
|
|
|
def toggle_door_state():
|
|
global state, action
|
|
if state == CLOSE:
|
|
open_door()
|
|
else:
|
|
close_door()
|
|
|
|
def handle_nfc_token(token = None):
|
|
global valid
|
|
|
|
if not token:
|
|
token = nfc_fifo.readline()
|
|
if token == "":
|
|
open_nfc_fifo()
|
|
|
|
token = token.strip()
|
|
if token in valid:
|
|
name = valid[token]
|
|
if name:
|
|
name = "%s (%s)" % (token, name)
|
|
else:
|
|
name = token
|
|
log("Valid token: %s" % name)
|
|
toggle_door_state()
|
|
else:
|
|
log("Invalid token:", token)
|
|
mqtt("token/last_invalid", "%s;%s" % (timestamp(), token))
|
|
|
|
class LineBuffer(object):
|
|
def __init__(self, f, handler):
|
|
self.data = b''
|
|
self.f = f
|
|
self.handler = handler
|
|
|
|
def update(self):
|
|
data = self.f.recv(1024)
|
|
if not data:
|
|
return False
|
|
self.data += data
|
|
d = self.data.split(b'\n')
|
|
d, self.data = d[:-1], d[-1]
|
|
for i in d:
|
|
self.handler(self.f, i)
|
|
return True
|
|
|
|
def handle_cmd(comm, data):
|
|
cmd = data.decode('utf8').split()
|
|
cmd, args = cmd[0], cmd[1:]
|
|
log("Got command:", data)
|
|
|
|
send = lambda x: comm.send(x.encode('utf8'))
|
|
|
|
if cmd == 'fake':
|
|
log("Faking token", args[0])
|
|
send("Handling token\n")
|
|
handle_nfc_token(args[0])
|
|
elif cmd == 'open':
|
|
log("Control socket opening door")
|
|
send("Opening door")
|
|
open_door()
|
|
elif cmd == 'close':
|
|
log("Control socket closing door")
|
|
send("Closing door")
|
|
close_door()
|
|
elif cmd == 'rld':
|
|
log("Reloading tokens")
|
|
send("Reloading tokens")
|
|
read_valid_tokens()
|
|
elif cmd == 'stat':
|
|
send("Door status is %s, position is %d. Current action: %s (%g seconds ago)\n" % (
|
|
state_names.get(state, "None"),
|
|
state_pos,
|
|
action_names[action],
|
|
(datetime.datetime.now() - start_time).total_seconds()))
|
|
|
|
open_logfile()
|
|
read_valid_tokens()
|
|
open_nfc_fifo()
|
|
open_serial_port()
|
|
open_control_socket()
|
|
|
|
mqttc.on_connect = lambda client, userdata, flags, rc: log("Connected to mqtt host with result %s" % (str(rc), ))
|
|
mqttc.connect_async(config.mqtt_host, keepalive = 60)
|
|
mqttc.loop_start()
|
|
|
|
buffers = {}
|
|
while True:
|
|
readable = select.select([ nfc_fifo, control_socket ] + comm_channels, [], [], 1)[0]
|
|
|
|
for c in readable:
|
|
if c == nfc_fifo:
|
|
handle_nfc_token()
|
|
elif c == control_socket:
|
|
log("Got connection")
|
|
sock = control_socket.accept()[0]
|
|
buffers[sock] = LineBuffer(sock, handle_cmd)
|
|
comm_channels += [sock]
|
|
else:
|
|
if not buffers[c].update():
|
|
log("Lost connection")
|
|
del buffers[c]
|
|
comm_channels.remove(c)
|
|
handle_door_state()
|