pyllrp 3.1.0__py3-none-any.whl

pyllrp/AutoDetect.py

@@ -0,0 +1,100 @@
+import socket
+import threading
+from queue import Queue, Empty
+try:
+	from .pyllrp import UnpackMessageFromSocket, ConnectionAttemptEvent_Parameter, ConnectionAttemptStatusType
+except ImportError:
+	from pyllrp import UnpackMessageFromSocket, ConnectionAttemptEvent_Parameter, ConnectionAttemptStatusType
+
+def is_impinj_reader( ip, port ):
+	# Connect to the socket.
+	readerSocket = socket.socket( socket.AF_INET, socket.SOCK_STREAM )
+	readerSocket.settimeout( 4.0 )
+	try:
+		readerSocket.connect( (ip, port) )
+	except Exception as e:
+		return False
+	
+	# Get the reader's default response.
+	try:
+		response = UnpackMessageFromSocket( readerSocket )
+	except Exception as e:
+		return False
+	finally:
+		readerSocket.close()
+		readerSocket = None
+	
+	# Check if the response is valid.
+	try:
+		connectionAttemptEvent = response.getFirstParameterByClass(ConnectionAttemptEvent_Parameter)
+		return connectionAttemptEvent and connectionAttemptEvent.Status == ConnectionAttemptStatusType.Success
+	except Exception as e:
+		return False
+	
+def connection_tester(job_q, results_q, port):
+	while results_q.empty():	# Quit as soon as we detect a reader.
+		ip = job_q.get()
+		if ip is None:
+			break
+		
+		try:
+			if is_impinj_reader(ip, port):
+				results_q.put(ip)
+		except Exception as e:
+			pass
+
+def get_my_ip():
+	s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+	try:
+		# doesn't have to be reachable
+		s.connect(('10.255.255.255', 1))
+		IP = s.getsockname()[0]
+	except Exception as e:
+		IP = '127.0.0.1'
+	finally:
+		s.close()
+	return IP
+
+def check_network(pool_size=255, port=5084):
+	""" Check the network for readers. """
+	""" Multithread the calls for performance. """
+	
+	# get my IP and compose a base like 192.168.1.xxx
+	ip_parts = get_my_ip().split('.')
+	base_ip = ip_parts[0] + '.' + ip_parts[1] + '.' + ip_parts[2] + '.'
+
+	# prepare the jobs queue
+	jobs = Queue()
+	results = Queue()
+	
+	pool = [threading.Thread(target=connection_tester, args=(jobs, results, port)) for i in range(pool_size)]
+	for p in pool:
+		p.start()
+
+	# cue the ping processes
+	my_low_order = int( ip_parts[3] )
+	low_orders = sorted( (i for i in range(1,255) if i != my_low_order), key=lambda v: abs(v-my_low_order) )
+	for i in low_orders:
+		jobs.put('{}{}'.format(base_ip, i))
+		
+	for p in pool:
+		jobs.put(None)
+
+	for p in pool:
+		p.join()
+		
+	try:
+		return results.get(False)
+	except Empty:
+		return None
+
+GetDefaultHost = get_my_ip
+	
+def findImpinjHost( impinjPort=5084 ):
+	return check_network(port=impinjPort)
+
+def AutoDetect( impinjPort=5084 ):
+	return findImpinjHost(impinjPort), GetDefaultHost()
+		
+if __name__ == '__main__':
+	print( AutoDetect() )

pyllrp/LLRPConnector.py

@@ -0,0 +1,183 @@
+#!/usr/bin/env python
+from queue import Queue, Empty
+import socket
+import datetime
+import threading
+try:
+	from .pyllrp import *
+except Exception as e:
+	from pyllrp import *
+
+class LLRPConnector:
+	#--------------------------------------------------------------------------
+	#
+	# A simple LLRP reader connection manager.
+	#
+	# Supports connecting to the reader, transacting commands, message handlers,
+	# and asynchronous/synchronous monitoring of the reader socket.
+	#
+	def __init__( self ):
+		self.TimeoutSecs = 6		# Time for the reader to respond.
+		self._reset()
+		self.handlers = {}
+		
+	def _reset( self ):
+		''' Reset all internal fields. '''
+		self.host = None
+		self.port = None
+		self.readerSocket = None
+		self.thread = None
+		self.shutdownQ = None		# Used to shutdown the thread.
+		self.keepGoing = False
+		self.timeCorrection = None
+	
+	def connect( self, host, port = 5084 ):
+		''' Connect to a reader. '''
+		self._reset()
+		self.readerSocket = socket.socket( socket.AF_INET, socket.SOCK_STREAM )
+		
+		# Set a timeout for the socket.  This is also the maximum time it will take to shut down the listener.
+		self.readerSocket.settimeout( self.TimeoutSecs )
+		self.readerSocket.connect( (host, port) )
+		
+		self.host = host
+		self.port = port
+		
+		# Expecting READER_EVENT_NOTIFICATION message.
+		response = UnpackMessageFromSocket( self.readerSocket )
+		tNow = datetime.datetime.now()	# Get the time here to minimize latency.
+		
+		# Check if the connection succeeded.
+		connectionAttemptEvent = response.getFirstParameterByClass(ConnectionAttemptEvent_Parameter)
+		if connectionAttemptEvent and connectionAttemptEvent.Status != ConnectionAttemptStatusType.Success:
+			self.disconnect()
+			raise EnvironmentError(
+				connectionAttemptEvent.Status,
+				ConnectionAttemptStatusType.getName(connectionAttemptEvent.Status).replace('_',' ')
+			)
+		
+		self.keepGoing = True
+		
+		# Compute a correction between the reader's time and the computer's time.
+		self.timeCorrection = None
+		try:
+			microseconds = response.getFirstParameterByClass(UTCTimestamp_Parameter).Microseconds
+			readerTime = datetime.datetime.utcfromtimestamp( microseconds / 1000000.0 )
+			self.timeCorrection = tNow - readerTime
+		except Exception as e:
+			self.disconnect()
+			raise ValueError('Missing Timestamp: ' + response.__repr__())
+
+		return response
+		
+	def tagTimeToComputerTime( self, tagTime ):
+		# Time is in microseconds from Jan 1, 1970.
+		return datetime.datetime.utcfromtimestamp( tagTime / 1000000.0 ) + self.timeCorrection
+	
+	def disconnect( self ):
+		''' Disconnect from a reader.  Also stops the listener. '''
+		self.timeCorrection = None
+		if not self.readerSocket:
+			return None
+		
+		if self.isListening():
+			self.stopListener()
+		
+		# Send the reader a disconnect message.
+		response = None
+		try:
+			response = self.transact( CLOSE_CONNECTION_Message() )
+		except Exception:
+			pass
+		
+		self.readerSocket.close()
+		self.readerSocket = None
+		return response
+		
+	def addHandler( self, messageClass, handlerFunc ):
+		''' Add a handler for a specific message type. '''
+		''' Support multiple handlers for the same message type. '''
+		self.handlers.setdefault( messageClass, [] ).append( handlerFunc )
+		
+	def removeHandler( self, messageClass, handlerFunc = None ):
+		''' Remove a handler for a specific message type from the reader.
+			If handlerFunc is None, all handlers for the given messageClass will be removed.
+			If handlerFunc is not None, only the specific handler is removed.
+		'''
+		if handlerFunc is None:
+			try:
+				del self.handlers[messageClass]
+			except KeyError:
+				pass
+		else:
+			while True:
+				try:
+					self.handlers[messageClass].remove( handlerFunc )
+				except (KeyError, ValueError):
+					break
+					
+	def removeAllHandlers( self ):
+		self.handlers = {}
+	
+	def transact( self, message ):
+		''' Send a message to the reader and wait for the response. '''
+		assert not self.isListening(), 'Cannot perform transact() while listen thread is active.  Stop it first with stopListener().'
+		message.send( self.readerSocket )
+		response = WaitForMessage( message.MessageID, self.readerSocket, self.callHandler )
+		return response
+		
+	def checkKeepGoing( self ):
+		''' Check if we should continue the reader thread. '''
+		if not self.keepGoing:
+			return False
+			
+		try:
+			# Check the shutdown queue for a message.  If there is one, shutdown.
+			self.shutdownQ.get( False )
+			self.shutdownQ.task_done()
+			self.keepGoing = False
+			return False
+		except (AttributeError, Empty):
+			return True
+	
+	def callHandler( self, message ):
+		''' Call all the handlers for this message. '''
+		for cb in (self.handlers.get(message.__class__, None) or self.handlers.get('default', [])):
+			cb( self, message )
+	
+	def listen( self ):
+		''' Listen for messages from the reader. '''
+		# Calling this by itself will block.
+		# Recommended usage is to use startListener and stopListener.
+		while self.checkKeepGoing():
+			try:
+				response = UnpackMessageFromSocket( self.readerSocket )
+			except socket.timeout:
+				continue
+			self.callHandler( response )
+				
+	def startListener( self ):
+		''' Starts a thread to listen to the reader. '''
+		assert self.readerSocket, 'Cannot start listener without a successful connection.'
+		assert not self.thread, 'Listener is already running.  Stop it first with stopListener().'
+		self.shutdownQ = Queue()
+		self.keepGoing = True
+		self.thread = threading.Thread( target = self.listen, name='LLRP Listener' )
+		self.thread.daemon = True
+		self.thread.start()
+	
+	def stopListener( self ):
+		''' Stops the thread listening to the reader. '''
+		self.shutdownQ.put( 'Shutdown' )
+		self.thread.join()					# Wait for the thread to terminate.
+		self.shutdownQ = None
+		self.thread = None
+	
+	def isListening( self ):
+		return self.thread and self.thread.is_alive()
+		
+	def __enter__( self ):
+		return self
+		
+	def __exit__(self, type, value, traceback):
+		self.disconnect()

pyllrp/ParseDef.py

@@ -0,0 +1,151 @@
+#---------------------------------------------------------------------------
+#
+# Reformats the llrpdef.xml file into a Python-formatted description llrpdef.py
+#
+# The reason we so this is so we avoid a dependency on the xml parser in deployment.
+# It is also much faster to use the .pyc file rather than parsing XML again
+# on startup.
+#
+import sys
+import pprint
+from xml.dom.minidom import parse
+
+# Map the xml field types to our types (bitstring standard, and our custom ones).
+fieldMap = {
+	'u1':		'bool',
+	'u2':		'bits:2',
+	'u8':		'uintbe:8',
+	'u16':		'uintbe:16',
+	'u32':		'uintbe:32',
+	'u64':		'uintbe:64',
+	'u96':		'uintbe:96',
+	
+	's8':		'intbe:8',
+	's16':		'intbe:16',
+	's32':		'intbe:32',
+	's64':		'intbe:64',
+	
+	'utf8v':	'string',
+	
+	'u1v':		'bitarray',
+	'u8v':		'array:8',
+	'u16v':		'array:16',
+	'u32v':		'array:32',
+	
+	'bytesToEnd':	'bytesToEnd',	# Used for the Custom message type.
+}
+
+def toAscii( s ):
+	return s.encode('ascii', 'ignore').decode( 'ascii' )
+
+def getEnum( e ):
+	Name = toAscii(e.attributes['name'].value)
+	Choices = [ (int(toAscii(c.attributes['value'].value)), toAscii(c.attributes['name'].value))
+		for c in e.childNodes if c.nodeName == 'entry' ]
+	return {'name':Name, 'choices':tuple(Choices) }
+
+def getParameterMessage( n, isMessage ):
+	Name = toAscii(n.attributes['name'].value)
+	
+	Fields = []
+	Parameters = []
+	
+	sys.stdout.write( '{} {}\n'.format(Name, 'Message' if isMessage else 'Parameter') )
+	try:
+		TypeNum = int(n.attributes['typeNum'].value)
+	except KeyError:
+		# This is a custom parameter or message.
+		TypeNum = 1023		# Code for custom Message and Parameter.
+		Fields.append( {'name': 'VendorIdentifier', 'type': 'uintbe:32', 'default': vendors[toAscii(n.attributes['vendor'].value)]} )
+		if isMessage:
+			Fields.append( {'name': 'MessageSubtype', 'type': 'uintbe:8', 'default': int(n.attributes['subtype'].value)} )
+		else:
+			Fields.append( {'name': 'ParameterSubtype', 'type': 'uintbe:32', 'default': int(n.attributes['subtype'].value)} )
+	
+	for c in n.childNodes:
+		if c.nodeName == 'field':
+			fieldInfo = { 'name': toAscii(c.attributes['name'].value), 'type': fieldMap[toAscii(c.attributes['type'].value)] }
+			try:
+				fieldInfo['enumeration'] = toAscii(c.attributes['enumeration'].value)
+			except Exception:
+				pass
+			try:
+				fieldInfo['format'] = toAscii(c.attributes['format'].value)
+			except Exception:
+				pass
+			Fields.append( fieldInfo )
+		elif c.nodeName == 'reserved':
+			bitCount = int(toAscii(c.attributes['bitCount'].value))
+			code = 'skip:%d' % bitCount
+			Fields.append( {'name':code, 'type':code} )
+		elif c.nodeName == 'parameter' or c.nodeName == 'choice':
+			repeat = toAscii(c.attributes['repeat'].value)
+			minMax = repeat.split('-')
+			if len(minMax) == 1:
+				rMin = rMax = int(repeat)
+			else:
+				rMin = int(minMax[0])
+				rMax = int(minMax[1]) if minMax[1] != 'N' else 99999
+			Parameter = toAscii(c.attributes['type'].value)
+			Parameters.append( {'parameter':Parameter, 'repeat': (rMin, rMax), 'choice': int(c.nodeName == 'choice')} )
+	pm = {'name':Name, 'typeNum':TypeNum}
+	if Fields:
+		pm['fields'] = tuple(Fields)
+	if Parameters:
+		pm['parameters'] = tuple(Parameters)
+	return pm
+	
+def getVendorCode( n ):
+	name = toAscii(n.attributes['name'].value)
+	id = int(n.attributes['vendorID'].value)
+	return (name, id)
+
+def getChoiceDefinition( n ):
+	choices = {}
+	name = toAscii(n.attributes['name'].value)
+	for c in n.childNodes:
+		if c.nodeName == 'parameter':
+			choices[toAscii(c.attributes['type'].value)] = name	
+	return choices
+
+enums, parameters, messages = [], [], []
+vendors = {}
+choiceDefinitions = {}
+
+llrpDefXml = '../xml/llrp-1x0-def.xml'
+dom = parse( llrpDefXml )
+
+vendors.update( dict(getVendorCode(v) for v in dom.getElementsByTagName('vendorDefinition')) )
+enums = [getEnum(e) for e in dom.getElementsByTagName('enumerationDefinition')]
+parameters = [getParameterMessage(p, False) for p in dom.getElementsByTagName('parameterDefinition')]
+messages = [getParameterMessage(m, True) for m in dom.getElementsByTagName('messageDefinition')]
+for c in dom.getElementsByTagName('choiceDefinition'):
+	choiceDefinitions.update( getChoiceDefinition(c) )
+del choiceDefinitions['Custom']
+
+dom.unlink()
+dom = None
+
+llrpCustomDefXml = '../xml/Impinjdef-1.18-private.xml'
+dom = parse( llrpCustomDefXml )
+
+vendors.update( dict(getVendorCode(v) for v in dom.getElementsByTagName('vendorDefinition')) )
+enums.extend( getEnum(e) for e in dom.getElementsByTagName('customEnumerationDefinition') )
+parameters.extend( getParameterMessage(p, False) for p in dom.getElementsByTagName('customParameterDefinition') )
+messages.extend( getParameterMessage(m, True) for m in dom.getElementsByTagName('customMessageDefinition') )
+for p in dom.getElementsByTagName('customParameterDefinition'):
+	choiceDefinitions[toAscii(p.attributes['name'].value)] = 'Custom'
+
+with open('llrpdef.py', 'w', encoding='utf8') as fp:
+	fp.write( '#-----------------------------------------------------------\n' )
+	fp.write( '# DO NOT EDIT!\n' )
+	fp.write( '# MACHINE GENERATED by ParseDef.py\n' )
+	fp.write( '# XML sources:\n' )
+	fp.write( '#    "{}"\n'.format(llrpDefXml) )
+	fp.write( '#    "{}"\n'.format(llrpCustomDefXml) )
+	fp.write( '# see https://github.com/esitarski/pyllrp for details\n' )
+	fp.write( '#-----------------------------------------------------------\n' )
+	for n in ['vendors', 'enums', 'parameters', 'messages', 'choiceDefinitions']:
+		fp.write( '{}='.format(n) )
+		pprint.pprint( globals()[n], fp, compact=True )
+		fp.write( '\n' )

pyllrp/TagInventory.py

@@ -0,0 +1,204 @@
+#!/usr/bin/env python
+import sys
+import time
+import socket
+try:
+	from .pyllrp import *
+	from .LLRPConnector import LLRPConnector
+except Exception as e:
+	from pyllrp import *
+	from LLRPConnector import LLRPConnector
+
+class TagInventory:
+	roSpecID = 123					# Arbitrary roSpecID.
+	inventoryParameterSpecID = 1234	# Arbitrary inventory parameter spec id.
+	readWaitMilliseconds = 100
+
+	def __init__( self, host='192.168.10.102', defaultAntennas=None, transmitPower=None, receiverSensitivity=None ):
+		self.host = host
+		self.connector = None
+		self.resetTagInventory()
+		self.defaultAntennas = defaultAntennas
+		self.transmitPower = transmitPower
+		self.receiverSensitivity = receiverSensitivity
+		
+	def resetTagInventory( self ):
+		self.tagInventory = set()
+		self.tagDetail = []
+		self.otherMessages = []
+
+	def AccessReportHandler( self, connector, accessReport ):
+		for tag in accessReport.getTagData():
+			tag['Tag'] = HexFormatToStr( tag['EPC'] )
+			self.tagInventory.add( tag['Tag'] )
+			self.tagDetail.append( tag )
+
+	def DefaultHandler( self, connector, message ):
+		self.otherMessages.append( message )
+
+	def _getReaderConfigMessage( self ):
+		# Change receiver sensitivity (if specified).  This value is RFID reader dependent.
+		receiverSensitivityParameter = []
+		if self.receiverSensitivity is not None:
+			receiverSensitivityParameter.append(
+				RFReceiver_Parameter( 
+					ReceiverSensitivity = self.receiverSensitivity
+				)
+			)
+		
+		# Change transmit power (if specified).  This value is RFID reader dependent.
+		transmitPowerParameter = []
+		if self.transmitPower is not None:
+			transmitPowerParameter.append(
+				RFTransmitter_Parameter( 
+					TransmitPower = self.transmitPower,
+					HopTableID = 1,						# Ignored in non-frequency-hopping regulatory regions. 
+					ChannelIndex = 1,					# Ignored in non-frequency-hopping regulatory regions.
+				)
+			)
+		
+		return SET_READER_CONFIG_Message( Parameters = [
+			AntennaConfiguration_Parameter( AntennaID = 0, Parameters =
+				receiverSensitivityParameter +
+				transmitPowerParameter + [
+				C1G2InventoryCommand_Parameter( Parameters = [
+					C1G2SingulationControl_Parameter(
+						Session = 0,
+						TagPopulation = 100,
+						TagTransitTime = 3000,
+					),
+				] ),
+			] ),
+		] )
+
+	def Connect( self ):
+		# Create the reader connection.
+		self.connector = LLRPConnector()
+
+		# Connect to the reader.
+		try:
+			response = self.connector.connect( self.host )
+		except socket.timeout:
+			self.connector.disconnect()
+			raise
+			
+		# Reset to factory defaults.
+		response = self.connector.transact( SET_READER_CONFIG_Message(ResetToFactoryDefault = True) )
+		assert response.success(), f'SET_READER_CONFIG ResetToFactorDefault fails\n{response}'
+
+		message = self._getReaderConfigMessage()
+		response = self.connector.transact( message )
+		assert response.success(), 'SET_READER_CONFIG Configuration fails:\n{}'.format(response)
+		
+	def Disconnect( self ):
+		self.connector.disconnect()
+		self.connector = None
+
+	def GetROSpec( self, antennas = None ):
+		if antennas is not None:
+			if not isinstance(antennas, list):
+				antennas = [antennas]
+		else:
+			antennas = [0]
+	
+		# Create an rospec that reports reads.
+		return ADD_ROSPEC_Message( Parameters = [
+				ROSpec_Parameter(
+					ROSpecID = self.roSpecID,
+					CurrentState = ROSpecState.Disabled,
+					Parameters = [
+						ROBoundarySpec_Parameter(		# Configure boundary spec (start and stop triggers for the reader).
+							Parameters = [
+								ROSpecStartTrigger_Parameter(ROSpecStartTriggerType = ROSpecStartTriggerType.Immediate),
+								ROSpecStopTrigger_Parameter(ROSpecStopTriggerType = ROSpecStopTriggerType.Null),
+							]
+						), # ROBoundarySpec
+						AISpec_Parameter(				# Antenna Inventory Spec (specifies which antennas and protocol to use)
+							AntennaIDs = antennas,
+							Parameters = [
+								AISpecStopTrigger_Parameter(
+									AISpecStopTriggerType = AISpecStopTriggerType.Tag_Observation,
+									Parameters = [
+										TagObservationTrigger_Parameter(
+											TriggerType = TagObservationTriggerType.N_Attempts_To_See_All_Tags_In_FOV_Or_Timeout,
+											NumberOfAttempts = 10,
+											Timeout = self.readWaitMilliseconds,
+										),
+									]
+								),
+								InventoryParameterSpec_Parameter(
+									InventoryParameterSpecID = self.inventoryParameterSpecID,
+									ProtocolID = AirProtocols.EPCGlobalClass1Gen2,
+								),
+							]
+						), # AISpec
+						ROReportSpec_Parameter(			# Report spec (specifies how often and what to send from the reader)
+							ROReportTrigger = ROReportTriggerType.Upon_N_Tags_Or_End_Of_ROSpec,
+							N = 10000,
+							Parameters = [
+								TagReportContentSelector_Parameter(
+									EnableAntennaID = True,
+									EnableFirstSeenTimestamp = True,
+									EnablePeakRSSI = True,
+								),
+							]
+						), # ROReportSpec
+					]
+				), # ROSpec_Parameter
+			]
+		)	# ADD_ROSPEC_Message
+
+	def _prolog( self, antennas = None ):
+		# Disable all the rospecs.  This command may fail so we ignore the response.
+		response = self.connector.transact( DISABLE_ROSPEC_Message(ROSpecID = 0) )
+		# Delete our old rospec if it exists.  This command might fail so we ignore the response.
+		response = self.connector.transact( DELETE_ROSPEC_Message(ROSpecID = self.roSpecID) )
+
+		# Add callbacks so we can record the tag reads and any other messages from the reader.
+		self.resetTagInventory()
+		self.connector.addHandler( RO_ACCESS_REPORT_Message, self.AccessReportHandler )
+		self.connector.addHandler( 'default', self.DefaultHandler )
+
+		# Add and enable our ROSpec
+		response = self.connector.transact( self.GetROSpec(antennas) )
+		assert response.success(), 'Add ROSpec Fails\n{}'.format(response)
+		
+	def _execute( self ):
+		response = self.connector.transact( ENABLE_ROSPEC_Message(ROSpecID = self.roSpecID) )
+		assert response.success(), 'Enable ROSpec Fails\n{}'.format(response)
+		
+		# Wait for the reader to do its work.
+		time.sleep( (1.5*self.readWaitMilliseconds) / 1000.0 )
+		
+		response = self.connector.transact( DISABLE_ROSPEC_Message(ROSpecID = self.roSpecID) )
+		assert response.success(), 'Disable ROSpec Fails\n{}'.format(response)
+		
+	def _epilog( self ):
+		# Cleanup.
+		response = self.connector.transact( DELETE_ROSPEC_Message(ROSpecID = self.roSpecID) )
+		assert response.success(), 'Delete ROSpec Fails\n{}'.format(response)
+		self.connector.removeAllHandlers()
+		
+	def GetTagInventory( self, antennas = None ):
+		self._prolog( antennas if antennas is not None else self.defaultAntennas )
+		self._execute()
+		self._epilog()
+		return self.tagInventory, self.otherMessages
+
+if __name__ == '__main__':
+	'''Read a tag inventory from the reader and shutdown.'''
+	print( '**** full power' )
+	host = '192.168.0.101'
+	ti = TagInventory( host )
+	ti.Connect()
+	tagInventory, otherMessages = ti.GetTagInventory()
+	print( '\n'.join(tagInventory) )
+	ti.Disconnect()
+	
+	for p in range(1, 100, 10):
+		ti = TagInventory( host, transmitPower = p )
+		ti.Connect()
+		tagInventory, otherMessages = ti.GetTagInventory()
+		print( f'**** power={p}' )
+		print( '\n'.join(tagInventory) )
+		ti.Disconnect()