pyllrp 3.1.0__tar.gz

pyllrp-3.1.0/License.txt

@@ -0,0 +1,17 @@
+
+Copyright (C) 2013-2019 Edward Sitarski
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software 
+and associated documentation files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

pyllrp-3.1.0/PKG-INFO

@@ -0,0 +1,105 @@
+Metadata-Version: 2.1
+Name: pyllrp
+Version: 3.1.0
+Summary: A complete implementation of LLRP (Low Level Reader Protocol) in pure Python.
+Home-page: http://www.sites.google.com/site/crossmgrsoftware/
+Author: Edward Sitarski
+Author-email: Edward Sitarski <edward.sitarski@gmail.com>
+License: 
+        Copyright (C) 2013-2019 Edward Sitarski
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy of this software 
+        and associated documentation files (the "Software"), to deal in the Software without
+        restriction, including without limitation the rights to use, copy, modify, merge, publish,
+        distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the
+        Software is furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all copies or
+        substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+        BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+        NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+        DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/esitarski/pyllrp
+Project-URL: Repository, https://github.com/esitarski/pyllrp
+Project-URL: Issues, https://github.com/esitarski/pyllrp/issues
+Keywords: LLRP,RFID,Impinj Reader
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: System :: Hardware :: Hardware Drivers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.8
+Description-Content-Type: text/plain
+Requires-Dist: bitstring>=3.1.1
+
+
+======
+pyllrp
+======
+
+A pure Python implementation of LLRP (Low Level Reader Protocol)
+used to communicate with LLRP-compliant RFID readers including Impinj, Alien and ThingMagic.
+See the LLRP spec ) for details:
+   https://www.gs1.org/sites/default/files/docs/epc/llrp_1_0_1-standard-20070813.pdf
+
+pyllrp enables quick-and-easy scripting in portable pure Python to
+create LLRP applications.
+
+It is used extensively in CrossMgr, RaceDB, TagReadWrite for RFID and race timing.
+
+The implementation is 100% complete.  All LLRP features and full Impinj custom extensions are
+supported.
+
+* Message and Parameters are full Python classes.
+* Full validation of all LLRP Messages and Parameters including data types, data ranges, parameter sequence and count.
+* Full support for enumerated values - no hardcoded values.
+* "Impossible" to pass incorrect or malformed LLRP messages to the reader.
+
+See TinyExample.py for how to use.
+
+A reader connection manager is also included that can connect to a reader, transact commands,
+then start/stop a thread to listen for tag reads.
+A message handler can be configured to respond to any reader message.
+See wxExample.py for a simple method to show reader messages in
+a wxPython application with a Queue (requires wxPython install).
+
+The module also supports reading and writing messages in XML format.
+
+Unlike other implementations, pyllrp generates the interfaces from the LLRP XML spec itself.
+It is 100% compliant with the LLRP spec and Impinj extensions.
+
+pyllrp is also 100% pedantic regarding LLRP Messages and Parameters.
+For example, pyllrp is strict about bool and ints: passing 1/0 for True/False doesn't work.
+The names of all fields must be specified, with the exception of Parameters which have only one field.
+In this case, the single parameter is taken to be the value.
+
+How to use it:
+
+The only files you need are pyllrp.py and llrpdef.py.
+TinyExample.py shows how to formulate LLRP specs, messages and parameters.
+To run TinyExample, from the top pyllrp directory, enter "python3 -m pyllrp.TinyExample".
+
+
+How it works:
+
+ParseDef.py reads the LLRP XML spec files and generates the llrpdef.py file.
+During this process, it translates the LLRP data types into bitstream representation and processes the XML into Python-friendly structures.
+ParseDef must be run every time the XML files change.
+
+At run time, pyllrp.py imports llrpdef and does a 1-time augmentation on the Messages, Parameters and Enums into classes.
+It adds the binary pack/unpack, validation and human-readable formating functions.
+Startup time is minimal due to the llrpdef.py pre-processing.
+
+Stuff to do:
+
+Because the classes are created dynamically, python linters (eg. flake8) do not understand pyllrp classes.
+The only way I can think of to migitate this is to code-generate the full signatures for the class functions,
+but this would be messier than dynamically creating the classes from the llrpdef.py info.

pyllrp-3.1.0/README.txt

@@ -0,0 +1,63 @@
+
+======
+pyllrp
+======
+
+A pure Python implementation of LLRP (Low Level Reader Protocol)
+used to communicate with LLRP-compliant RFID readers including Impinj, Alien and ThingMagic.
+See the LLRP spec ) for details:
+   https://www.gs1.org/sites/default/files/docs/epc/llrp_1_0_1-standard-20070813.pdf
+
+pyllrp enables quick-and-easy scripting in portable pure Python to
+create LLRP applications.
+
+It is used extensively in CrossMgr, RaceDB, TagReadWrite for RFID and race timing.
+
+The implementation is 100% complete.  All LLRP features and full Impinj custom extensions are
+supported.
+
+* Message and Parameters are full Python classes.
+* Full validation of all LLRP Messages and Parameters including data types, data ranges, parameter sequence and count.
+* Full support for enumerated values - no hardcoded values.
+* "Impossible" to pass incorrect or malformed LLRP messages to the reader.
+
+See TinyExample.py for how to use.
+
+A reader connection manager is also included that can connect to a reader, transact commands,
+then start/stop a thread to listen for tag reads.
+A message handler can be configured to respond to any reader message.
+See wxExample.py for a simple method to show reader messages in
+a wxPython application with a Queue (requires wxPython install).
+
+The module also supports reading and writing messages in XML format.
+
+Unlike other implementations, pyllrp generates the interfaces from the LLRP XML spec itself.
+It is 100% compliant with the LLRP spec and Impinj extensions.
+
+pyllrp is also 100% pedantic regarding LLRP Messages and Parameters.
+For example, pyllrp is strict about bool and ints: passing 1/0 for True/False doesn't work.
+The names of all fields must be specified, with the exception of Parameters which have only one field.
+In this case, the single parameter is taken to be the value.
+
+How to use it:
+
+The only files you need are pyllrp.py and llrpdef.py.
+TinyExample.py shows how to formulate LLRP specs, messages and parameters.
+To run TinyExample, from the top pyllrp directory, enter "python3 -m pyllrp.TinyExample".
+
+
+How it works:
+
+ParseDef.py reads the LLRP XML spec files and generates the llrpdef.py file.
+During this process, it translates the LLRP data types into bitstream representation and processes the XML into Python-friendly structures.
+ParseDef must be run every time the XML files change.
+
+At run time, pyllrp.py imports llrpdef and does a 1-time augmentation on the Messages, Parameters and Enums into classes.
+It adds the binary pack/unpack, validation and human-readable formating functions.
+Startup time is minimal due to the llrpdef.py pre-processing.
+
+Stuff to do:
+
+Because the classes are created dynamically, python linters (eg. flake8) do not understand pyllrp classes.
+The only way I can think of to migitate this is to code-generate the full signatures for the class functions,
+but this would be messier than dynamically creating the classes from the llrpdef.py info.

pyllrp-3.1.0/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-3.1.0/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-3.1.0/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' )