Uhf Reader
PulsarLR UHF RFID Reader

The right tool for the hardest UHF RFID applications. This reader can reach a reading distance of up to 12m with a modern UHF RFID transponder and easily scan a few hundred tags per second. The four antenna ports give you the flexibility to build complex RFID devices, such as RFID gates and tunnels.
- class metratec_rfid.PulsarLR(instance: str, address: str, port: int = 10001)
Pulsar LR
- __init__(instance: str, address: str, port: int = 10001) None
Create a new PulsarLR object
- Args:
instance (str): The reader name
serial_port (str): The serial port to use
- async call_impinj_authentication_service() List[Dict[str, Any]]
This command tags to an Impinj M775 tag using the proprietory authencation command. It sends a random challenge to the transponder and gets the authentication payload in return. You can use this to check the authenticity of the transponder with Impinj Authentication Service. For further details, please contact Impinj directly.
- Raises:
RfidReaderException: if an error occurs
- Returns:
List[Dict[str, Any]]: a list with the transponders. The transponders contains the keys: ‘epc’, ‘has_error’,’short_tid’, ‘response’, ‘challenge’
- async check_antennas() None
Check the antennas
- async connect(timeout: float = 5.0) None
Connect the reader
- Args:
timeout (float, optional): Maximum waiting time for the connection. Defaults to 2.0.
- Raises:
TimeoutError: timeout error
- async disable_high_on_tag()
Disable the “high on tag” feature
- async disconnect() None
Disconnect the reader
- enable_fire_empty_inventory(enable: bool)
If the event handler for new inventory is set and this value is true, an empty inventory also triggers the event handler
- Args:
enable (bool): Set to true, to trigger empty inventories events as well. Defaults to false
- enable_fire_empty_reports(enable: bool)
If the event handler for new inventory report is set and this value is true, an empty report also triggers the event handler Args:
enable (bool): Set to true, to trigger empty reports events as well. Defaults to false
- async enable_input_events(enable: bool = True) None
Enable the reader input events
- Args:
enable (bool, optional): True for enable. Defaults to True.
- Raises:
RfidReaderException: if an reader error occurs
- async fetch_inventory(wait_for_tags: bool = True) List[UhfTag]
Can be called when an inventory has been started. Waits until at least one tag is found and returns all currently scanned transponders from a continuous scan
- Args:
wait_for_tags (bool): Set to true, to wait until transponders are available
- Returns:
List[UhfTag]: a list with the founded transponder
- async get_antenna() int
Return the currently used antenna port
- Raises:
RfidReaderException: if an reader error occurs
- Returns:
int: the antenna to use
- async get_antenna_multiplex() List[int]
Gets the antenna multiplex sequence
- Returns:
sequence (List[int]): the antenna sequence
- Raises:
RfidReaderException: if an error occurs
- async get_antenna_power(antenna: int) int
Return the current antenna power
- Args:
antenna (int): antenna
- Raises:
RfidReaderException: if an reader error occurs
- Returns:
int: the current antenna power
- async get_antenna_powers() List[int]
the power value per antenna (index 0 == antenna 1)
- Returns:
List[int]: list with the power values
- async get_bit_mask() Dict[str, Any]
Gets current reader mask.
- Raises:
RfidReaderException: if an reader error occurs
- Returns:
- dict: dictionary with the mask settings
available entries: memory (str), start (int), mask (str), enabled (bool)
- get_connection() Connection
returns the reader connection
- Returns:
Connection: the reader connection
- async get_custom_impinj_settings() Dict[str, Any]
Returns the custom impinj settings. See set_custom_settings for more detail.
- Raises:
RfidReaderException: if an reader error occurs
- Returns:
dict: with ‘fast_id’ and ‘tag_focus’ entries
- async get_high_on_tag_output() Dict[str, Any]
Return the current high on tag output pin
- Returns:
dict: with ‘enable’, ‘pin’ and ‘duration’ entries
- async get_input(pin: int) bool
Return the current input pin value
- Raises:
RfidReaderException: if an reader error occurs
- Returns:
int: the input pin value
- async get_inputs() Dict[int, bool]
Return the current input pin values
- Raises:
RfidReaderException: if an reader error occurs
- Returns:
dict: the input pin values by the pin
- async get_inventory() List[UhfTag]
get the current inventory from the current antenna (see set_antenna)
- Raises:
RfidReaderException: if an reader error occurs
- Returns:
List[Tag]: An array with the founded transponder
- async get_inventory_multi(ignore_error: bool = False) List[UhfTag]
get the current inventory. Multiple antennas are used (see set_antenna_multiplex)
- Args:
ignore_error (bool, optional): Set to True to ignore antenna errors. Defaults to False.
- Raises:
RfidReaderException: if an reader error occurs
- Returns:
List[Tag]: An array with the founded transponder
- async get_inventory_report(duration: float = 0.0, ignore_error: bool = False) List[UhfTag]
gets an inventory report from the current antenna (see set_antenna)
- Args:
duration (int, optional): inventory report duration in seconds. Defaults to 0.1 seconds. ignore_error (bool, optional): Set to True to ignore antenna errors. Defaults to False.
- Raises:
RfidReaderException: if an reader error occurs
- Returns:
List[Tag]: An array with the founded transponder
- async get_inventory_settings() Dict[str, Any]
Gets the current reader inventory settings
- Raises:
RfidReaderException: if an reader error occurs
- Returns:
dict: with ‘only_new_tag’, ‘with_rssi’ and ‘with_tid’ entries
- get_logger() Logger
return the logger
- Returns:
logging.Logger: the logger for this instance
- async get_mask() Dict[str, Any]
Gets current reader mask.
- Raises:
RfidReaderException: if an reader error occurs
- Returns:
- dict: dictionary with the mask settings
available entries: memory (str), start (int), mask (str)
- async get_multiplexer(antenna_port: int) int
Get the connected multiplexer (connected antennas per antenna port)
- Args:
antenna_port (int): the antenna port to which the multiplexer is connected
- Raises:
RfidReaderException: if an error occurs
- Returns:
int: the multiplexer size
- get_name() str
the reader name
- Returns:
str: the reader name
- async get_output(pin: int) bool
Return the current output pin value
- Raises:
RfidReaderException: if an reader error occurs
- Returns:
int: the output pin value
- async get_outputs() Dict[int, bool]
Return the current output pin values
- Raises:
RfidReaderException: if an reader error occurs
- Returns:
dict: the output pin values by the pin
- async get_q_value() Dict
Returns the configured q value. See set_q_value for more details.
- Raises:
RfidReaderException: if an reader error occurs
- Returns:
dict: with ‘q_start’, ‘q_min’ and ‘q_max’ entries
- async get_reader_info() Dict[str, str]
Returns the reader information
- Raises:
RfidReaderException: if an reader error occurs
- Returns:
- dict: With the ‘firmware’, ‘firmware_version’, ‘hardware’, ‘hardware_version’
and ‘serial_number’ information
- async get_region() str
Return the configured uhf region
- Raises:
RfidReaderException: if an reader error occurs
- Returns:
Region: the used uhf region
- async get_rf_mode() int
Return the rf mode id. Each mode ID corresponds to a set of RF parameters that fit together. Not all devices support all modes and not all modes can be access in all regions. See reader description for more detail.
- Returns:
int: the current rf mode id
- async get_selected_session() str
Returns the current selected session. See set_selected_session for more details.
- Returns:
str: the current selected session
- get_status() Dict[str, Any]
return the current status information
- Returns:
- dict: status information which contains at least following keys:
name (str): receiver name address (str): receiver communication address port (int): receiver communication port eid (str): receiver eid status (int): current status message (str): status message
- async get_tag_size() int
Returns the configured tag size
- Raises:
RfidReaderException: if an reader error occurs
- Returns:
int: the configured tag size
- async get_tag_size_settings() Dict[str, Any]
Returns the configured tag size
- Raises:
RfidReaderException: if an reader error occurs
- Returns:
dict: with ‘tag_size’, ‘min_tags’ and ‘max_tags’ entries
- is_connected() bool
True if connected
- Returns:
bool: connected
- is_running() bool
True if the reader is working correctly
- Returns:
bool: running
- async kill_tag(password: str, epc_mask: str | None = None) List[UhfTag]
Kill a transponder
- Args:
password (str): the kill password (32 bit, 8 hex signs)
epc_mask (str, optional): Epc mask filter. Defaults to None.
- Returns:
List[UhfTag]: List with handled tag. If the tag has error, the kill was not successful
- async lock_epc_memory(password: str, epc_mask: str | None = None) List[UhfTag]
Locking of the epc memory bank of the transponder
- Args:
password (str): the access password (32 bit, 8 hex signs)
epc_mask (str, optional): Epc mask filter. Defaults to None.
- Returns:
List[UhfTag]: List with handled tag. If the tag has error, the lock was not successful
- async lock_epc_memory_permament(password: str, epc_mask: str | None = None) List[UhfTag]
Permament l of the epc memory bank of the transponder
- Args:
password (str): the access password (32 bit, 8 hex signs)
epc_mask (str, optional): Epc mask filter. Defaults to None.
- Returns:
List[UhfTag]: List with handled tag. If the tag has error, the lock was not successful
- async lock_tag(membank: str, password: str, epc_mask: str | None = None) List[UhfTag]
Locking of a memory bank of the transponder
- Args:
membank (str): the memory to lock [‘EPC’, ‘USR’]
password (str): the access password (32 bit, 8 hex signs)
epc_mask (str, optional): Epc mask filter. Defaults to None.
- Returns:
List[UhfTag]: List with handled tag. If the tag has error, the lock was not successful
- async lock_tag_permament(membank: str, password: str, epc_mask: str | None = None) List[UhfTag]
Permament locking of a memory bank of the transponder
- Args:
membank (str): the memory to lock [‘EPC’, ‘USR’]
password (str): the access password (32 bit, 8 hex signs)
epc_mask (str, optional): Epc mask filter. Defaults to None.
- Returns:
List[UhfTag]: List with handled tag. If the tag has error, the lock was not successful
- async lock_user_memory(password: str, epc_mask: str | None = None) List[UhfTag]
Locking of the user memory bank of the transponder
- Args:
password (str): the access password (32 bit, 8 hex signs)
epc_mask (str, optional): Epc mask filter. Defaults to None.
- Returns:
List[UhfTag]: List with handled tag. If the tag has error, the lock was not successful
- async lock_user_memory_permament(password: str, epc_mask: str | None = None) List[UhfTag]
Permament l of the user memory bank of the transponder
- Args:
password (str): the access password (32 bit, 8 hex signs)
epc_mask (str, optional): Epc mask filter. Defaults to None.
- Returns:
List[UhfTag]: List with handled tag. If the tag has error, the lock was not successful
- async read_tag_data(start: int = 0, length: int = 1, memory: str = 'USR', epc_mask: str | None = None) List[UhfTag]
read the memory of the founded transponder
- Args:
start (int, optional): Start address. Defaults to 0.
length (int, optional): Bytes to read. Defaults to 1.
epc_mask (str, optional): Epc mask filter. Defaults to None.
memory (str, optional): Memory bank to read [“PC”,”EPC”,”USR”,”TID”]. Defaults to “USR”.
- Raises:
RfidReaderException: if an reader error occurs
- Returns:
List[UhfTag]: A list of transponders found.
- async read_tag_tid(start: int = 0, length: int = 4, epc_mask: str | None = None) List[UhfTag]
read the tid of the founded transponder
- Args:
start (int, optional): Start address. Defaults to 0.
length (int, optional): Bytes to read. Defaults to 1.
epc_mask (str, optional): Epc mask filter. Defaults to None.
- Raises:
RfidReaderException: if an reader error occurs
- Returns:
List[UhfTag]: A list with the transponder found.
- async read_tag_usr(start: int = 0, length: int = 1, epc_mask: str | None = None) List[UhfTag]
read the usr memory of the founded transponder
- Args:
start (int, optional): Start address. Defaults to 0.
length (int, optional): Bytes to read. Defaults to 1.
epc_mask (str, optional): Epc mask filter. Defaults to None.
- Raises:
RfidReaderException: if an reader error occurs
- Returns:
List[UhfTag]: A list with the transponder found.
- async reset_bit_mask() None
Remove the bit mask
- async reset_mask() None
Remove the mask
- async send_custom_command(command: str, timeout: float = 2.0) List[str]
Send a command to the reader and return the response
- Args:
command (str): the command
timeout (float, optional): The response timeout. Defaults to 2.0.
- Raises:
RfidReaderException: if an reader error occurs
- Returns:
list[str]: The reader responses. In case of an set command the list is empty
- async set_antenna(antenna: int) None
Setting the antenna to be used
- Args:
antenna (int): the antenna port to be use. Must lie in the interval [1,4]
- Raises:
RfidReaderException: if an reader error occurs
- async set_antenna_multiplex(antennas: int | List[int]) None
Number of antennas to be multiplexed
- Args:
antennas (int or List): Number of antennas to be multiplexed or the antenna sequence list
- Raises:
RfidReaderException: if an reader error occurs
- async set_antenna_power(antenna: int, power: int) None
Sets the antenna power
- Args:
antenna (int): antenna power (int): antenna power in dbm [0,30]
- Raises:
RfidReaderException: if an reader error occurs
- async set_antenna_powers(antenna_powers: List[int]) None
set the power values for the antennas
- Args:
antenna_powers (List[int]): list with the multiplexer size for each antenna (the index 0 corresponds to the antenna 1)
- async set_bit_mask(mask: str, start: int = 0, memory: str = 'EPC') None
Set a mask
- Args:
mask (str): the binary mask, e.g. ‘0110’
start (int, optional): start bit. Defaults to 0.
bit_length (int, optional): Bits to check. Defaults to 0.
memory (str, optional): the memory for the mask. [‘PC’,’EPC’,’USR’,’TID’] Defaults to “EPC”.
- Raises:
RfidReaderException: if an reader error occurs
- set_cb_input_changed(callback: Callable | None) Callable | None
Set the callback for the input changed event. The callback has the following arguments: * pin (int) - the changed pin * value (boolean) - the new value
- Returns:
Optional[Callable]: the old callback
- set_cb_inventory(callback: Callable[[List[UhfTag]], None] | None) Callable[[List[UhfTag]], None] | None
Set the callback for a new inventory. The callback has the following arguments: * tags (List[UhfTag]) - the tags
- Returns:
Optional[Callable]: the old callback
- set_cb_inventory_report(callback: Callable[[List[UhfTag]], None] | None) Callable[[List[UhfTag]], None] | None
Set the callback for a new inventory report. The callback has the following arguments: * tags (List[Tag]) - the tags
- Returns:
Optional[Callable]: the old callback
- set_cb_status(callback: Callable | None) Callable | None
Set the callback for status changes. The callback has the following arguments: * status (Dict[str, Any]) - the new reader status dictionary, which contains at
least the ‘status’, the ‘message’, ‘timestamp’ and the instance name if specified
- Returns:
Optional[Callable]: the old callback
- async set_custom_impinj_settings(fast_id: bool = False, tag_focus: bool = False) None
The RFID tag IC manufacturer Impinj has added two custom features to its tag ICs that are not compatible with tag ICs from other manufacturers. Activate these features with this command - but make sure that you only use tags with Impinj ICs like Monza6 or M7xx or M8xx series. Tags from other manufacturers will most likely not answer at all when those options are active!
- Args:
fast_id (bool, optional): True, to allows to read the TagID together with the EPC and can speed up getting TID data. Defaults to False.
tag_focus (bool, optional): True, to use a proprietory tag feature where each tag only answers once until it is repowered. This allows to scan a high number of tags because each tag only answers once and makes anti-collision easier for the following tags.
- Raises:
RfidReaderException: if an reader error occurs
- async set_heartbeat(interval: int) None
set the reader heartbeat
- Args:
interval (float): interval in seconds
- async set_high_on_tag_output(output_pin: int, duration: int = 100)
Enable the “high on tag” feature which triggers the selected output to go to the “high” state, when a tag is found. This allows to trigger an external device whenever a tag is in the field. This corresponds to the blue LED.
- Args:
output_pin (int): Output pin [1,4] duration (int, optional): High duration in milliseconds [10, 10000]. Defaults to 100.
- async set_inventory_settings(only_new_tag: bool = False, with_rssi: bool = True, with_tid: bool = False, fast_start: bool = False) None
Configure the inventory response
- Args:
only_new_tag (bool, optional): Only return new tags. Defaults to False.
with_rssi (bool, optional): Append the rssi value to the response. Defaults to True.
with_tid (bool, optional): Append the tid to the response. Defaults to False.
fast_start (bool, optional): Append the tid to the response. Defaults to False.
- Raises:
RfidReaderException: if an reader error occurs
- async set_kill_password(password: str, new_password, epc_mask: str | None = None) List[UhfTag]
sets the kill password
- Args:
password (str): the access password (32 bit, 8 hex signs)
new_password (_type_): the new access password (32 bit, 8 hex signs)
epc_mask (str, optional): Epc mask filter. Defaults to None.
- Returns:
List[UhfTag]: List with handled tag. If the tag has error, the password change was not successful
- async set_lock_password(password: str, new_password, epc_mask: str | None = None) List[UhfTag]
sets the lock password
- Args:
password (str): the access password (32 bit, 8 hex signs)
new_password (_type_): the new access password (32 bit, 8 hex signs)
epc_mask (str, optional): Epc mask filter. Defaults to None.
- Returns:
List[UhfTag]: List with handled tag. If the tag has error, the password change was not successful
- async set_mask(mask: str, start: int = 0, memory: str = 'EPC') None
Set a mask
- Args:
mask (str): the mask (hex)
start (int, optional): start byte. Defaults to 0.
bit_length (int, optional): Bits to check. Defaults to 0.
memory (str, optional): the memory for the mask. [‘PC’,’EPC’,’USR’,’TID’] Defaults to “EPC”.
- Raises:
RfidReaderException: if an reader error occurs
- async set_multiplexer(antenna_port: int, multiplexer_size: int)
Sets the connected multiplexer (connected antennas per antenna port)
- Args:
antenna_port (int): the antenna port to which the multiplexer is connected multiplexer_size (int): the multiplexer size
- Raises:
RfidReaderException: if an error occurs
- async set_output(pin: int, value: bool) None
Return the current output pin values
- Raises:
RfidReaderException: if an reader error occurs
- Returns:
dict: the output pin values by the pin
- async set_outputs(outputs: Dict[int, bool]) None
Return the current output pin values
- Raises:
RfidReaderException: if an reader error occurs
- Returns:
dict: the output pin values by the pin
- async set_q_value(q_start: int, q_min: int = -1, q_max: int = -1) None
Configure the expected numbers of transponders in the field as q value. Alternatively, the set_tag_size method can be used. The Q value is the exponent of 2 and should be around or above the expected number of tags. Setting this value too low will result in tags being missed. Setting the value too high will lead to unnecessary slow inventories.
- Args:
q_start (int): start q value
q_min (int, optional): minimum q value
q_max (int, optional): maximum q value
- Raises:
RfidReaderException: if an reader error occurs
- async set_region(region: str) None
Sets the used uhf region
- Args:
region (Region): the uhf region
- Raises:
RfidReaderException: if an reader error occurs
- async set_rf_mode(mode_id: int) None
Configure the internal RF communication settings between tag and reader. Each mode ID corresponds to a set of RF parameters that fit together. Not all devices support all modes and not all modes can be access in all regions. See reader description for more detail.
- Args:
mode_id (int): the rf mode id to set
- Returns:
int: the current rf mode id
- async set_selected_session(session: str = 'AUTO')
Manually select the session according to the EPC Gen 2 Protocol to use during inventory scan. Default value is “auto” and in most cases this should stay auto. Only change this if you absolutely know what you are doing and if you can control the types of tags you scan. Otherwise, unexpected results during inventory scans with “only new tags” active might happen.
- Args:
session (str, optional): Session to set [“0”, “1”, “2”, “3”, “AUTO”]. Defaults to “AUTO”.
- async set_tag_size(tags_size: int, min_tags: int = -1, max_tags: int = -1) None
Configure the expected numbers of transponders in the field. Alternatively, the set_q_value method can be used.
- Args:
tags_size (int): expected numbers of transponders
min_tags (int, optional): minimum numbers of transponders.
max_tags (int, optional): maximum numbers of transponders.
- Raises:
RfidReaderException: if an reader error occurs
- async start_inventory() None
Starts the continuos inventory. Multiple antennas are used (see set_antenna_multiplex)
- Raises:
RfidReaderException: if an reader error occurs
- async start_inventory_multi(ignore_error: bool = False) None
Starts the continuos inventory. Multiple antennas are used (see set_antenna_multiplex)
- Args:
ignore_error (bool, optional): Set to True to ignore antenna errors. Defaults to False.
- Raises:
RfidReaderException: if an reader error occurs
- async start_inventory_report(duration: float = 0.25, ignore_error: bool = False) None
Start the inventory report. Multiple antennas are used (see set_antenna_multiplex)
- Args:
duration (float, optional): inventory report duration in seconds. Defaults to 0.25 ignore_error (bool, optional): Set to True to ignore antenna errors. Defaults to False.
- Raises:
RfidReaderException: if an reader error occurs
- async stop_inventory() None
stop the continuos inventory
- Raises:
RfidReaderException: if an reader error occurs
- async stop_inventory_multi() None
stop the continuos inventory
- Raises:
RfidReaderException: if an reader error occurs
- async stop_inventory_report() None
stop the inventory report
- Raises:
RfidReaderException: if an reader error occurs
- async unlock_epc_memory(password: str, epc_mask: str | None = None) List[UhfTag]
Unlocking of the epc memory bank of the transponder
- Args:
password (str): the access password (32 bit, 8 hex signs)
epc_mask (str, optional): Epc mask filter. Defaults to None.
- Returns:
List[UhfTag]: List with handled tag. If the tag has error, the unlock was not successful
- async unlock_tag(membank: str, password: str, epc_mask: str | None = None) List[UhfTag]
Unlocking of a memory bank of the transponder
- Args:
membank (str): the memory to lock [‘EPC’, ‘USR’]
password (str): the access password (32 bit, 8 hex signs)
epc_mask (str, optional): Epc mask filter. Defaults to None.
- Returns:
List[UhfTag]: List with handled tag. If the tag has error, the unlock was not successful
- async unlock_user_memory(password: str, epc_mask: str | None = None) List[UhfTag]
Unlocking of the user memory bank of the transponder
- Args:
password (str): the access password (32 bit, 8 hex signs)
epc_mask (str, optional): Epc mask filter. Defaults to None.
- Returns:
List[UhfTag]: List with handled tag. If the tag has error, the unlock was not successful
- async write_tag_data(data: str, start: int = 0, memory: str = 'USR', epc_mask: str | None = None) List[UhfTag]
write the data to the founded transponder
- Args:
data (str): data to write
start (int, optional): Start address. Defaults to 0.
memory (str, optional): Memory bank to read [“PC”,”EPC”,”USR”]. Defaults to “USR”.
epc_mask (str, optional): Epc mask filter. Defaults to None.
- Raises:
RfidReaderException: if an reader error occurs
- Returns:
List[UhfTag]: list with written tags, if a tag was not written the has_error boolean is true
- async write_tag_epc(tid: str, new_epc: str, start: int = 0) List[UhfTag]
write the tag epc
- Args:
tid (str): the tag id
new_epc: the new epc
start (int, optional): Start address. Defaults to 0.
- Raises:
RfidReaderException: if an reader error occurs
- Returns:
list[UhfTag]: list with written tags, if a tag was not written the has_error boolean is true
- async write_tag_usr(data: str, start: int = 0, epc_mask: str | None = None) List[UhfTag]
write the data to the founded transponder
- Args:
data (str): _description_
start (int, optional): Start address. Defaults to 0.
epc_mask (str, optional): Epc mask filter. Defaults to None.
- Raises:
RfidReaderException: if an reader error occurs
- Returns:
List[UhfTag]: list with written tags, if a tag was not written the has_error boolean is true
PulsarMX UHF RFID Reader

The PulsarMX is a UHF RFID Reader for applications with medium read range between 2 and 5 m and up to 100 tags at the same time in the field (anti collision). Typical applications include container tracking, reading data from sensor tags or as a scanning station on a conveyor belt. With its low cost, it open up new possibilities for RFID which were not economical before.
DeskID UHF Desktop Reader

The DeskID UHF is a small and economical RFID reader and writer for the use with 868 MHz (UHF RFID, EU frequency). It allows reading and writing EPC Class 1 Gen 2 tags directly with your PC or notebook computer. This makes it an indispensable tool in UHF applications in which tags have to be tested, written to or initialized easily. The low profile design housing looks great on any desktop and is connected to the PC via USB. As it is also USB powered, setup is especially easy. Reading range depends on tag type and is typically in the range of 10 to 30 cm. Reading several tags at once (anti collision mode) is also possible.