def test_correct_tcp(self, subprocess, socket):
"""
Test for correct tcp connection
"""
#HRP.set_log_level_debug()
subprocess.call.return_value = 0
socket.return_value.connect_ex.return_value = 0
socket.return_value.recv.side_effect = BASIC_CONNECT
conn = HRP('192.168.1.116')
conn.connect()
subprocess.call.assert_called()
socket.return_value.connect_ex.assert_called_with(('192.168.1.116', 9090))
def test_correct_connect(self, subprocess, socket):
"""
test for correct tco and initial data reading
"""
#HRP.set_log_level_debug()
subprocess.call.return_value = 0
socket.return_value.connect_ex.return_value = 0
socket.return_value.recv.side_effect = BASIC_CONNECT
conn = HRP('192.168.1.116')
conn.connect() # parsed reader_info & reader_ability
self.assertEqual(conn.name, "CL7206B2_20170606", "incorrect name %s" % conn.name)
self.assertEqual(conn.version, "1.1.16", "incorrect version %s" % conn.version)
self.assertEqual(conn.deltalive, datetime.timedelta(seconds=90178), "incorrect live %s" % conn.deltalive)
self.assertEqual(conn.min_power, 0, "incorrect min_pow %s" % conn.min_power)
self.assertEqual(conn.max_power, 36, "incorrect max_pow %s" % conn.max_power)
self.assertEqual(conn.antennas, 4, "incorrect antennas %s" % conn.antennas)
def __init__(self, request, client_address, server):
self.request = request
self.client_address = client_address
self.server = server
# for partial data transfers
self.expectingRemainingBytes = 0
self.partialData = ''
# set up HRP connection
if not FAKE_MODE:
self.hrp = HRP(ip=HRP_HOST,
port=HRP_PORT,
ommit_ping=False,
timeout=10)
# self.hrp.set_log_level_debug()
logger.info('Connecting to HRP reader...')
if HAVE_LCD:
display.lcd_display_string('Connecting:HRP', 2)
connected = False
while not connected:
try:
self.hrp.connect()
self.hrp_filter_time, self.hrp_rssi_threshold = self.hrp.tag_filter(
)
self.hrp.tag_filter(HRP_TAG_FILTER_MS, HRP_TAG_FILTER_RSSI)
connected = True
except HRPFrameError:
logger.warning(
'Connect didn\'t work, disconnecting and trying again ...'
)
self.hrp.disconnect()
except HRPNetworkError:
logger.warning(
'Could not connect to reader, waiting and trying again ...'
)
self.hrp.disconnect()
time.sleep(BACKOFF_TIME)
self.setup()
try:
self.handle()
finally:
self.finish()
def test_incorrect_ping(self, subprocess):
"""
test for incorrect ping
"""
#HRP.set_log_level_debug()
subprocess.call.return_value = 1
conn = HRP('192.168.1.116')
self.assertRaisesRegex(HRPNetworkError, "can't reach reader", conn.connect)
def test_correct_ping(self, subprocess, socket):
"""
test for correct ping, but missing tcp connection
"""
#HRP.set_log_level_debug()
subprocess.call.return_value = 0
socket.return_value.connect_ex.return_value = 1
conn = HRP('192.168.1.116')
self.assertRaisesRegex(HRPNetworkError, "can't connect tcp reader", conn.connect)
def test_command_send(self, subprocess, socket):
"""
test send packets
"""
#HRP.set_log_level_debug()
subprocess.call.return_value = 0
socket.return_value.connect_ex.return_value = 0
socket.return_value.recv.side_effect = BASIC_CONNECT
conn = HRP('192.168.1.116')
conn.connect()
conn._send_packet(5, 5) # TEST,swr detect,""
socket.return_value.send.assert_called_with(codecs.decode("AA050500004444",'hex'))
conn._send_packet(2, 255) # OP, stop command
socket.return_value.send.assert_called_with(codecs.decode("AA02FF0000A40F",'hex'))
"""
import sys
import os
import traceback
import codecs
#fix path to use local module
sys.path.insert(1,
os.path.dirname(os.path.dirname(os.path.realpath(__file__))))
from hrp import HRP, const, exception
from hrp.tag import TidReadParameter, TagAddress, MatchParameter
try:
conn = HRP(ip='192.168.1.116', port=9090, ommit_ping=False, timeout=10)
#conn.set_log_level_debug() # enable for debug information
print("Connecting")
conn.connect()
filter_time, RSSI_threshold = conn.tag_filter()
conn.stop() #always before reading tag!
conn.tag_filter(100, 0)
print("Connected! press Ctrl+C to break")
# tid=TidReadParameter(0, 6), #test read 6 word tid (12 bytes 24 chars)
# edata=TagAddress(0x02, 8), #test read exendend EPC with 8 words
# edata=TagAddress(0x02, 8), #test read exendend EPC with 8 words
counter = 0
for tag in conn.read_tag(antennas=const.ANTENNA_1 | const.ANTENNA_2,
tid=TidReadParameter(0, 6),
udata=TagAddress(0x28, 40),
from hrp import HRP portfolio_1 = HRP() portfolio_1.main()
def tearDown(self):
""" clear test """
HRP.set_log_level()# reset
class LLRPMessageHandler(SocketServer.StreamRequestHandler):
def __init__(self, request, client_address, server):
self.request = request
self.client_address = client_address
self.server = server
# for partial data transfers
self.expectingRemainingBytes = 0
self.partialData = ''
# set up HRP connection
if not FAKE_MODE:
self.hrp = HRP(ip=HRP_HOST,
port=HRP_PORT,
ommit_ping=False,
timeout=10)
# self.hrp.set_log_level_debug()
logger.info('Connecting to HRP reader...')
if HAVE_LCD:
display.lcd_display_string('Connecting:HRP', 2)
connected = False
while not connected:
try:
self.hrp.connect()
self.hrp_filter_time, self.hrp_rssi_threshold = self.hrp.tag_filter(
)
self.hrp.tag_filter(HRP_TAG_FILTER_MS, HRP_TAG_FILTER_RSSI)
connected = True
except HRPFrameError:
logger.warning(
'Connect didn\'t work, disconnecting and trying again ...'
)
self.hrp.disconnect()
except HRPNetworkError:
logger.warning(
'Could not connect to reader, waiting and trying again ...'
)
self.hrp.disconnect()
time.sleep(BACKOFF_TIME)
self.setup()
try:
self.handle()
finally:
self.finish()
def handle(self):
global message_seq
# send a ReaderEventNotification on connection
msg_dict = {
'READER_EVENT_NOTIFICATION': {
'Ver': 1,
'Type': 63,
'ID': 0,
'ReaderEventNotificationData': {
'UTCTimestamp': {
'Microseconds': int(time.time() * 10e5)
},
'ConnectionAttemptEvent': {
'Status': 'Success'
}
}
}
}
llrp_msg = LLRPMessage(msgdict=msg_dict)
self.request.send(llrp_msg.msgbytes)
message_seq = message_seq + 1
data = self.request.recv(1024)
logger.debug('got %d bytes from reader: %s', len(data), hexlify(data))
"""
XXX this block could be deleted
"""
if self.expectingRemainingBytes:
if len(data) >= self.expectingRemainingBytes:
data = self.partialData + data
self.partialData = ''
self.expectingRemainingBytes -= len(data)
else:
# still not enough; wait until next time
self.partialData += data
self.expectingRemainingBytes -= len(data)
return
while data:
# parse the message header to grab its length
if len(data) >= LLRPMessage.full_hdr_len:
msg_type, msg_len, message_id = \
struct.unpack(LLRPMessage.full_hdr_fmt,
data[:LLRPMessage.full_hdr_len])
else:
# XXX
logger.warning('Too few bytes (%d) to unpack message header',
len(data))
self.partialData = data
self.expectingRemainingBytes = \
LLRPMessage.full_hdr_len - len(data)
break
logger.debug('expect %d bytes (have %d)', msg_len, len(data))
if len(data) < msg_len:
# XXX
# got too few bytes
logger.debug("Less than an LLRP Message Size")
self.partialData = data
self.expectingRemainingBytes = msg_len - len(data)
break
else:
# got at least the right number of bytes
self.expectingRemainingBytes = 0
try:
lmsg = LLRPMessage(msgbytes=data[:msg_len])
self.handle_message(lmsg, message_seq)
message_seq = message_seq + 1
data = self.request.recv(1024)
except LLRPError:
logger.exception(
'Failed to decode LLRPMessage; '
'will not decode %d remaining bytes', len(data))
break
except HRPFrameError:
logger.exception('Error with HRP Reader. Disconnecting')
break
message_seq = 1
def handle_message(self, lmsg, message_seq):
msg_type = lmsg.getName()
if msg_type == 'GET_SUPPORTED_VERSION':
# we only support reader version 1, this is a v2 command.
msg_dict = {
'GET_SUPPORTED_VERSION_RESPONSE': {
'Ver': 1,
'Type': 56,
'ID': message_seq,
'CurrentVersion': 1,
'SupportedVersion': 1,
'LLRPStatus': {
'Type': 287,
'StatusCode': 'UnsupportedVersion',
'ErrorDescription': 'We only support v1',
}
}
}
llrp_msg = LLRPMessage(msgdict=msg_dict)
self.request.send(llrp_msg.msgbytes)
if msg_type == 'GET_READER_CAPABILITIES':
msg_dict = {
'GET_READER_CAPABILITIES_RESPONSE': {
'Ver': 1,
'Type': 11,
'ID': message_seq,
'LLRPStatus': {
'Type': 287,
'StatusCode': 'Success',
'ErrorDescription': '',
},
'GeneralDeviceCapabilities': {
'MaxNumberOfAntennaSupported': 4,
'CanSetAntennaProperties': 0,
'HasUTCClockCapability': 1,
'DeviceManufacturerName': 0,
'ModelName': 7206,
'ReaderFirmwareVersion': '1',
},
}
}
llrp_msg = LLRPMessage(msgdict=msg_dict)
self.request.send(llrp_msg.msgbytes)
if msg_type == 'GET_ROSPECS':
# send a GET_ROSPECS_RESPONSE
msg_dict = {
'GET_ROSPECS_RESPONSE': {
'Ver': 1,
'Type': 36,
'ID': message_seq,
'LLRPStatus': {
'Type': 287,
'StatusCode': 'Success',
'ErrorDescription': '',
},
}
}
llrp_msg = LLRPMessage(msgdict=msg_dict)
self.request.send(llrp_msg.msgbytes)
if msg_type == 'DELETE_ACCESSSPEC':
# send a DELETE_ACCESSSPEC_RESPONSE
msg_dict = {
'DELETE_ACCESSSPEC_RESPONSE': {
'Ver': 1,
'Type': 51,
'ID': message_seq,
'LLRPStatus': {
'Type': 287,
'StatusCode': 'Success',
'ErrorDescription': '',
},
}
}
llrp_msg = LLRPMessage(msgdict=msg_dict)
self.request.send(llrp_msg.msgbytes)
if msg_type == 'DELETE_ROSPEC':
# send a DELETE_ROSPEC_RESPONSE
msg_dict = {
'DELETE_ROSPEC_RESPONSE': {
'Ver': 1,
'Type': 31,
'ID': message_seq,
'LLRPStatus': {
'Type': 287,
'StatusCode': 'Success',
'ErrorDescription': '',
},
}
}
llrp_msg = LLRPMessage(msgdict=msg_dict)
self.request.send(llrp_msg.msgbytes)
# New in WebScorer 4.3.0 update
if msg_type == 'GET_READER_CONFIG':
# send a GET_READER_CONFIG_RESPONSE
msg_dict = {
'GET_READER_CONFIG_RESPONSE': {
'Ver': 1,
'Type': 12,
'ID': message_seq,
'LLRPStatus': {
'Type': 287,
'StatusCode': 'Success',
'ErrorDescription': '',
},
}
}
llrp_msg = LLRPMessage(msgdict=msg_dict)
self.request.send(llrp_msg.msgbytes)
if msg_type == 'SET_READER_CONFIG':
# send a SET_READER_CONFIG_RESPONSE
msg_dict = {
'SET_READER_CONFIG_RESPONSE': {
'Ver': 1,
'Type': 13,
'ID': message_seq,
'LLRPStatus': {
'Type': 287,
'StatusCode': 'Success',
'ErrorDescription': '',
},
}
}
llrp_msg = LLRPMessage(msgdict=msg_dict)
self.request.send(llrp_msg.msgbytes)
if msg_type == 'ADD_ROSPEC':
# send a ADD_ROSPEC_RESPONSE
msg_dict = {
'ADD_ROSPEC_RESPONSE': {
'Ver': 1,
'Type': 30,
'ID': message_seq,
'LLRPStatus': {
'Type': 287,
'StatusCode': 'Success',
'ErrorDescription': '',
},
}
}
llrp_msg = LLRPMessage(msgdict=msg_dict)
self.request.send(llrp_msg.msgbytes)
if msg_type == 'ENABLE_ROSPEC':
# send a ADD_ROSPEC_RESPONSE
msg_dict = {
'ENABLE_ROSPEC_RESPONSE': {
'Ver': 1,
'Type': 34,
'ID': message_seq,
'LLRPStatus': {
'Type': 287,
'StatusCode': 'Success',
'ErrorDescription': '',
},
}
}
llrp_msg = LLRPMessage(msgdict=msg_dict)
self.request.send(llrp_msg.msgbytes)
if HAVE_LCD:
display.lcd_display_string('Reading tags ', 2)
if msg_type == 'ENABLE_ROSPEC' or msg_type == 'KEEPALIVE_ACK':
# send some tags!
if FAKE_MODE:
timestamp = int(time.time() * 10e5)
msg_dict = {
'RO_ACCESS_REPORT': {
'Ver':
1,
'Type':
61,
'ID':
message_seq,
'TagReportData': [{
'Type': 240,
'EPCData': {
'Type': 241,
'EPCLengthBits': 96,
'EPC': '001060310000000000000881'
},
'FirstSeenTimestampUTC': {
'Type': 2,
'Microseconds': timestamp
},
'LastSeenTimestampUTC': {
'Type': 4,
'Microseconds': timestamp
}
}, {
'Type': 240,
'EPCData': {
'Type': 241,
'EPCLengthBits': 96,
'EPC': '001060310000000000000882'
},
'FirstSeenTimestampUTC': {
'Type': 2,
'Microseconds': timestamp
},
'LastSeenTimestampUTC': {
'Type': 4,
'Microseconds': timestamp
}
}],
}
}
llrp_msg = LLRPMessage(msgdict=msg_dict)
self.request.send(llrp_msg.msgbytes)
if not FAKE_MODE:
keepalive_timer = 0
# This enables antenna port 1 and 3.
for tag in self.hrp.read_tag(antennas=5,
match=MatchParameter(
const.MATCH_EPC, 0x20,
codecs.decode(
'b20200411666', 'hex'))):
#for tag in self.hrp.read_tag(antennas=5):
if tag is not None:
timestamp = int(time.time() * 10e5)
tag_hex = codecs.encode(tag.epc, 'hex')
logger.info("TAG FOUND: " + tag_hex)
msg_dict = {
'RO_ACCESS_REPORT': {
'Ver':
1,
'Type':
61,
'ID':
message_seq,
'TagReportData': [{
'Type': 240,
'EPCData': {
'Type': 241,
'EPCLengthBits': len(tag_hex) * 4,
'EPC': tag_hex
},
'FirstSeenTimestampUTC': {
'Type': 2,
'Microseconds': timestamp
},
'LastSeenTimestampUTC': {
'Type': 4,
'Microseconds': timestamp
},
'PeakRSSI': {
'Type': 6,
'PeakRSSI': tag.rssi
}
}]
}
}
llrp_msg = LLRPMessage(msgdict=msg_dict)
self.request.send(llrp_msg.msgbytes)
else:
logger.info("TIMEOUT")
keepalive_timer = keepalive_timer + 1
if keepalive_timer > KEEPALIVE_THRESHOLD:
self.hrp.end_read_tag = True
message_seq = message_seq + 1
msg_dict = {
'KEEPALIVE': {
'Ver': 1,
'Type': 62,
'ID': message_seq
}
}
llrp_msg = LLRPMessage(msgdict=msg_dict)
self.request.send(llrp_msg.msgbytes)
self.hrp.tag_filter(self.hrp_filter_time,
self.hrp_rssi_threshold)
if msg_type == 'CLOSE_CONNECTION':
# send a CLOSE_CONNECTION_RESPONSE
msg_dict = {
'CLOSE_CONNECTION_RESPONSE': {
'Ver': 1,
'Type': 4,
'ID': message_seq,
'LLRPStatus': {
'Type': 287,
'StatusCode': 'Success',
'ErrorDescription': '',
},
}
}
llrp_msg = LLRPMessage(msgdict=msg_dict)
self.request.send(llrp_msg.msgbytes)
def finish(self):
if not FAKE_MODE:
self.hrp.disconnect()
if HAVE_LCD:
display.lcd_display_string('Disconnected', 2)
import sys
import os
import traceback
import codecs
import time
#fix path to use local module
sys.path.insert(1,
os.path.dirname(os.path.dirname(os.path.realpath(__file__))))
from hrp import HRP, const, exception
from hrp.tag import TidReadParameter, TagAddress, MatchParameter
try:
conn = HRP(ip='192.168.1.116', port=9090, ommit_ping=False, timeout=10)
conn.set_log_level_debug() # enable for debug information
print("Connecting")
conn.connect()
conn.stop() #always before reading tag!
#conn.read_tag(tid=TidReadParameter(0, 10)) #test
#conn.read_tag(edata=TagAddress(0x2D, 2)) #test
tags = conn.read_single_scan(
antennas=const.ANTENNA_1 | const.ANTENNA_2,
#match=MatchParameter(const.MATCH_EPC, 32, codecs.decode('560179','hex')), # match EPC starting with 56 01 79
#match=MatchParameter(const.MATCH_TID, 0, codecs.decode('e280b0a020','hex')), # match TID starting with e2 80 b0 a0 20
tid=TidReadParameter(0, 6),
#edata=TagAddress(0x02, 8)
) #test single read!
if not tags:
print("No tag found")
"""
import sys
import os
import traceback
import codecs
#fix path to use local module
sys.path.insert(1,os.path.dirname(os.path.dirname(os.path.realpath(__file__))))
from hrp import HRP, const, exception
from hrp.tag import TidReadParameter, TagAddress, MatchParameter
try:
conn = HRP(ip='192.168.1.116', port=9090, ommit_ping=False, timeout=10)
conn.set_log_level_debug() # enable for debug information
print ("Connecting")
conn.connect()
filter_time, RSSI_threshold = conn.tag_filter()
conn.stop() #always before reading tag!
conn.tag_filter(100, 0)
print ("Connected! press Ctrl+C to break")
#conn.read_tag(tid=TidReadParameter(0, 10)) #test
#conn.read_tag(edata=TagAddress(0x2D, 2)) #test
counter = 0
for tag in conn.read_tag(
antennas=const.ANTENNA_1 | const.ANTENNA_2,
#match=MatchParameter(const.MATCH_EPC, 0x20, codecs.decode('560179','hex')), # match EPC starting with 56 01 79
match=MatchParameter(const.MATCH_TID, 0x00, codecs.decode('e280b0a020','hex')), # match TID starting with e2 80 b0 a0 20
tid=TidReadParameter(0, 6),