-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathmain.py
More file actions
162 lines (130 loc) · 5.77 KB
/
main.py
File metadata and controls
162 lines (130 loc) · 5.77 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
import sys
import os
sys.path.append(os.path.abspath(os.path.join(__file__, '..', '..', '..')))
from argparse import ArgumentParser
from logging import getLogger, INFO, Formatter, StreamHandler, WARN
from sllurp.llrp import LLRP_PORT, LLRPClientFactory
import smokesignal
from tornado.escape import json_decode
from tornado.platform.twisted import TwistedIOLoop
from tornado.template import Loader
from tornado.web import RequestHandler, Application
from tornado.websocket import WebSocketClosedError, WebSocketHandler
from twisted.internet import reactor
'''
Sllurp/Tornado Example
This file contains an example showing how to use Sllurp with Tornado
to update a web page via websockets when rfid tags are seen.
'''
logger = getLogger('sllurp')
def setup_logging():
logger.setLevel(INFO)
logFormat = '%(asctime)s %(name)s: %(levelname)s: %(message)s'
formatter = Formatter(logFormat)
handler = StreamHandler()
handler.setFormatter(formatter)
logger.addHandler(handler)
stream_handler_warn = StreamHandler()
stream_handler_warn.setLevel(WARN)
stream_handler_warn.setFormatter(formatter)
access_log = getLogger("tornado.access")
access_log.addHandler(stream_handler_warn)
app_log = getLogger("tornado.application")
app_log.addHandler(handler)
gen_log = getLogger("tornado.general")
gen_log.addHandler(handler)
class DefaultHandler(RequestHandler):
def get(self):
loader = Loader(os.path.dirname(__file__))
template = loader.load("index.html")
self.write(template.generate())
class WebSocketHandler(WebSocketHandler):
def __init__(self, *args, **kwargs):
super(WebSocketHandler, self).__init__(*args, **kwargs)
self.connected_clients = 0
@smokesignal.on('rfid')
def _RFID_cb(payload):
self.update_rfid(payload)
def open(self):
self.connected_clients += 1
logger.debug("WebSocket opened")
def on_message(self, message):
try:
data = json_decode(message)
logger.info(data)
except ValueError:
logger.info('error loading json: {}'.format(message))
def on_close(self):
self.connected_clients -= 1
logger.debug("WebSocket closed")
def update_rfid(self, payload):
if self.connected_clients > 0:
try:
if self.get_argument('reader_ip') == payload['reader_ip']:
self.write_message(payload)
# logger.debug('websocket write: {}'.format(pformat(payload)))
except WebSocketClosedError:
logger.debug('attempting to send websocket message with no connected clients')
def tag_seen_callback(llrpMsg):
"""Function to run each time the reader reports seeing tags."""
tags = llrpMsg.msgdict['RO_ACCESS_REPORT']['TagReportData']
if tags:
smokesignal.emit('rfid', {
'tags': tags,
'reader_ip': llrpMsg.peername[0],
})
def parse_args():
parser = ArgumentParser(description='Simple RFID Reader Inventory')
parser.add_argument('host', help='hostname or IP address of RFID reader',
nargs='*')
parser.add_argument('-p', '--port', default=LLRP_PORT, type=int,
help='port to connect to (default {})'.format(LLRP_PORT))
parser.add_argument('-n', '--report-every-n-tags', default=1, type=int,
dest='every_n', metavar='N', help='issue a TagReport every N tags')
parser.add_argument('-a', '--antennas', default='1',
help='comma-separated list of antennas to enable')
parser.add_argument('-X', '--tx-power', default=0, type=int,
dest='tx_power', help='Transmit power (default 0=max power)')
parser.add_argument('-M', '--modulation', default='M8',
help='modulation (default M8)')
parser.add_argument('-T', '--tari', default=0, type=int,
help='Tari value (default 0=auto)')
return parser.parse_args()
def polite_shutdown(factory):
return factory.politeShutdown()
if __name__ == '__main__':
setup_logging()
# Set up tornado to use reactor
TwistedIOLoop().install()
# Set up web server
application = Application([(r"/", DefaultHandler),
(r"/ws", WebSocketHandler)])
application.listen(8888)
# Load Sllurp config
args = parse_args()
enabled_antennas = map(lambda x: int(x.strip()), args.antennas.split(','))
# Create Clients and set them to connect
fac = LLRPClientFactory(report_every_n_tags=args.every_n,
antennas=enabled_antennas,
tx_power=args.tx_power,
modulation=args.modulation,
tari=args.tari,
start_inventory=True,
tag_content_selector={
'EnableROSpecID': True,
'EnableSpecIndex': True,
'EnableInventoryParameterSpecID': True,
'EnableAntennaID': True,
'EnableChannelIndex': True,
'EnablePeakRRSI': True,
'EnableFirstSeenTimestamp': True,
'EnableLastSeenTimestamp': True,
'EnableTagSeenCount': True,
'EnableAccessSpecID': True,
})
fac.addTagReportCallback(tag_seen_callback)
for host in args.host:
reactor.connectTCP(host, args.port, fac, timeout=3)
reactor.addSystemEventTrigger('before', 'shutdown', polite_shutdown, fac)
# Start server & connect to readers
reactor.run()