Uhf Reader

PulsarLR UHF RFID Reader

PulsarLR

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

PulsarMX

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

DeskId Uhf

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.