### Navigation

- previous
- Indy ITK 1.8.0 documentation »

# Indy Demo Tool GUI

Impinj has created the Indy Demo Tool graphical user interface (GUI), a Windows application that allows fast and easy testing of Indy based readers. Indy Demo Tool implements the IRI host library, and uses the PC’s COM ports to interact with attached readers. It can easily be used with the Indy Module development kits, which include a USB-UART IC that easily connects a PC’s COM port to the Indy Reader Module UART pins.

## GUI Overview

This section provides an overview of the functionality and behavior of the Indy Demo Tool GUI.

The Indy Demo Tool implements a flexible IRI host, as well as an easy to use graphical user interface that allows configuration and feedback on reader operation.

The tool is made up of three main sections:

1. Connection controls (at the top of the GUI)
2. Core functionality tabs (on the left side of the GUI)
3. Logging tabs (on the right side of the GUI)

The Connection Controls are used to establish a connection with an attached Indy based reader. For example, these controls are used to locate and connect to readers attached via the COM ports.

The Core Functionality Tabs are used to configure and control the connected reader. For example, these tabs can be used to configure the various parameters of reader operation, and instruct it to perform inventory or other actions.

The Logging Tabs provide information about the operation of the GUI and the attached reader. For example, the feedback tabs will log the results of attempts to connect to Modules, and display information about tags seen during inventory.

## GUI Functionality Detail

The following section explains in detail what each of the sections of the Indy Demo Tool GUI is designed to do, and how they do it.

The Connection Controls and Logging tabs are included with the Welcome core functionality tab, which appears when the GUI is first launched, before a reader is connected.

This table briefly explains what each of the core functionality tabs in the Indy Demo Tool GUI are used for. For more details on teach tab, click the links in the table, or scroll to the GUI Functionality Detail section.

Indy Demo Tool Functionality by Tab
Tab | Functionality
--- | ---
Welcome | Gives instructions on connecting to a reader
Inventory | Performs tag inventory
Access | Performs Access operations
Set/Get | Reads and writes reader key codes
Write EPC | Writes tag EPCs
Image Loader | Generates and bootloads images for readers
IO | Controls reader input and output pins
Tx Control | Controls the transmit signal chain for testing purposes
Test Command | Performs reader test commands

### General Operation

This section describes the Welcome tab, and the Connection Controls and Logging Tabs, that are not specific to the Core Functionality tabs listed below.

#### Welcome Tab

The Welcome tab simply welcomes the user to the GUI and gives some simple instructions on how to connect to a reader. When a connection to a reader is established using the Connection Controls, this tab is replaced by the Core Functionality tabs listed below.

#### Connection Controls

The Connection Controls configure the connection between the GUI and an attached reader via a COM port. A reader’s Host UART (UART1) interface must be connected to a COM port for the GUI to communicate with it.

The connection controls have two appearances, depending on whether the GUI has connected to a reader or not:

The Connect button instructs the GUI to attempt to connect to a reader using the COM port selected in the COM Port dropdown, emulating the ipj_connect() API function call. After succesfully connecting to a reader, the GUI will change, with the Welcome tab being replaced by the Core functionality tabs.

The Disconnect button instructs the GUI to disconnect from the connected reader.

The Reset button resets the attached reader by emulating the ipj_disconnect() API function call.

The COM Port dropdown selects the COM port that the GUI should atttempt to connect to a reader on.

The Scan button checks each of the COM ports for a reader device, and then simplifies the COM port dropdown to show only COM ports with reader host connections attached.

In most cases, a reader that is attached to a COM port can be easily connected to by perofmring the following short sequence:

1. Press the Scan button to determine which COM port the reader is attached to.
2. Press the Connect button to connect to that COM port.

At this point the Core functionality tabs will appear and the reader can be configured and controlled using the GUI.

#### Logging Tabs

The Logging Tabs display feedback from the GUI and the reader about events that occur.

There are three controls above the log text field:

The Save button saves the contents of the log text field to a text file on the PC.

The Clear button clears the contents of the log text field.

The Log Level dropdown configures the level of information displayed in the log text field.

There are two different logging tabs in the logging tab interface, the Event Log and the Device Log.

The Event Log prints logs that are made to be human readable, describing the behavior of the GUI (what it is attempting to do) and the behavior of the Module (what has transpired on the reader due to host instruction).

The Device Log prints more abstract information about communication with the reader device. For example, if the Log Level dropdown is set to “debug”, the Device Log will contain individual IRI packets that are sent to and received from the reader.

### Inventory Tab

The Inventory tab performs inventory operations on tags using the attached reader.

The Inventory tab contains two functional groupings of controls: Inventory Control and Inventory Settings.

The Inventory Control panel allows the GUI to instruct the attached reader to start or stop performing an inventory, with or without a tag operation enabled.

The Inventory Settings panel allows the GUI to configure the inventory to be performed by the reader.

#### Inventory Control Panel

The Inventory Control panel allows the GUI to control inventory operations, emulating the C library’s ipj-start() and ipj-stop() API functions.

The Start button starts an inventory, emulating the ipj-start() API function call with the `action` argument E_IPJ_ACTION_INVENTORY. This will perform an inventory using the configuration currently stored in the attached reader’s key codes.

The Start (Tag Operation) button performs an inventory with tag operations enabled, simply by setting the key E_IPJ_KEY_TAG_OPERATION_ENABLE to `TRUE` before emulating the ipj-start() API function call with the `action` argument E_IPJ_ACTION_INVENTORY. The tag operation keys can be set manually using the Set/Get tab, or simply by performing a tag operation using the Access tab.

The Stop button stops any active inventory, emulating the ipj-stop() API function call.

When an inventory is performed, tag reports and other enabled reports will be printed in the Event Log tab.

#### Inventory Settings Panel

The Inventory Settings panel allows the GUI to configure the key values on the attached reader that are used to specify inventory behavior. The configuration entered using the fields and checkboxes must be applied to the reader by pressing the Apply Inventory Settings button. This will cause the appropriate values to be written to the attached reader’s key values. These keys are not non-volatile, and values will be lost if the reader is reset or powered down.

The RF Mode field sets RF mode (AKA Link Profile) using the key E_IPJ_KEY_RF_MODE.

The Stop Tag Count field sets the inventory automatic stop tag count using the key E_IPJ_KEY_AUTOSTOP_TAG_COUNT. When the reader has seen this many tags, the inventory will stop automatically.

The Stop Duration (ms) field sets the inventory automatic stop duration using the key E_IPJ_KEY_AUTOSTOP_DURATION_MS. When the reader has been inventorying for this long, the inventory will stop automatically.

The Stop Round Count field sets the inventory automatic stop round count using the key E_IPJ_KEY_AUTOSTOP_ROUND_COUNT. When the reader has performed this many inventory rounds, the inventory will stop automatically.

The Tag Population Estimate field sets the population estimate using the key E_IPJ_KEY_INVENTORY_TAG_POPULATION.

The Session field configures the inventory’s session using the key E_IPJ_KEY_INVENTORY_SESSION.

The Search Mode field configures the reader’s search mode using the key E_IPJ_KEY_INVENTORY_SEARCH_MODE.

The Antenna Sequence field configures the sequence of antennas that the reader will use for inventory using the key E_IPJ_KEY_ANTENNA_SEQUENCE. This sequence should be integers separated by commas, within the list of valid antennas for the reader.

The FastID checkbox enables the Monza tag FastID functionality using the key E_IPJ_KEY_FAST_ID_ENABLE.

The Tag Focus checkbox enables the Monza tag specific TagFocus behavior both by modifying the Session and Search Mode field values, and by setting the key E_IPJ_KEY_TAG_FOCUS_ENABLE to `TRUE`. Unchecking the box does not modify the field values.

The All Tag Report Fields checkbox enables all of the fields that can be included in tag reports, including things like RSSI, phase, etc. using the key E_IPJ_KEY_REPORT_CONTROL_TAG. These field values will be printed in the Event Log.

The Enable Channel Activity Packets checkbox enables the channel activity information in the status reports using the key E_IPJ_KEY_REPORT_CONTROL_STATUS. This results in the status reports being printed to the Event Log whenever the reader hops from one channel to another.

The Tag Type Indentifier checkbox configures the reader and GUI to detect the model of tags inventoried using a number of keys to read the TID Memory banks. The tag model is printed along with any other information in the tag reports in the Event Log tab.

### Access Tab

The Access tab performs access operations on tags using the attached reader, for example to read, write, or lock tag memory, perform QT operations, etc.

The tab is split up into multiple panels, including one for each different operations type that is supported. Many of the panels interact with one another.

#### Access Password Panel

The Access Password panel allows the user to set the access operation password used with all of the other panels on the tab.

The Password field sets the value for the access password, which is written to the key E_IPJ_KEY_ACCESS_PASSWORD.

#### Read Panel

The Read panel instructs the reader to perform a read command during an access operation, reading data from the contents of tag memory. Data is read from memory and printed in the Event Log tab.

The Membank dropdown sets the memory bank to be read, using the key E_IPJ_KEY_READ_MEM_BANK.

The Word Pointer field sets the location within the memory bank to be read, using the key E_IPJ_KEY_READ_WORD_POINTER.

The Word Count field sets the number of bytes to be read, using the key E_IPJ_KEY_READ_WORD_COUNT.

The Read button instructs the reader to perform the memory read as configured by the other fields. It does this by emulating a ipj-start() API function call after setting the key E_IPJ_KEY_TAG_OPERATION to value to E_IPJ_TAG_OPERATION_TYPE_READ and the key E_IPJ_KEY_TAG_OPERATION_ENABLE value to `TRUE`.

#### Write Panel

The Write panel instructs the reader to perform a write command during an access operation, writing data to the contents of tag memory.

The Membank dropdown sets the memory bank to be written, using the key E_IPJ_KEY_WRITE_MEM_BANK.

The Word Pointer field sets the location within the memory bank to be written, using the key E_IPJ_KEY_WRITE_WORD_POINTER.

The Word Count field sets the number of bytes to be written, using the key E_IPJ_KEY_WRITE_WORD_COUNT.

The Data field sets the data to be written to tag memory, using the key E_IPJ_KEY_WRITE_DATA.

The Write button instructs the reader to perform the memory write as configured by the other fields. It does this by emulating a ipj-start() API function call after setting the key E_IPJ_KEY_TAG_OPERATION to value to E_IPJ_TAG_OPERATION_TYPE_WRITE and the key E_IPJ_KEY_TAG_OPERATION_ENABLE value to `TRUE`.

#### Kill Panel

The Kill panel instructs the reader to perform a kill command during an access operation, rendering the tag permanenely inoperable.

The Password field sets the kill password for the operation using the key E_IPJ_KEY_KILL_PASSWORD.

Note

Tags are initialized with a kill password value of 0. Kill operations will not be performed unless the kill password is nonzero. Thus, a tag’s kill password must be changed to a non-zero value using the write command before it can be killed.

The Kill button performs a kill operation with the specified password. It does this by emulating a ipj-start() API function call after setting the key E_IPJ_KEY_TAG_OPERATION to value to E_IPJ_TAG_OPERATION_TYPE_KILL and the key E_IPJ_KEY_TAG_OPERATION_ENABLE value to `TRUE`.

#### Lock Panel

The Lock panel instructs the reader to perform a lock command during an access operation, locking or unlocking specific tag memory blocks.

The Payload field sets the payload of the lock command, specifying the lock states of tag memory banks, using the key E_IPJ_KEY_LOCK_PAYLOAD.

The Lock button performs a lock operation with the specified payload. It does this by emulating a ipj-start() API function call after setting the key E_IPJ_KEY_TAG_OPERATION to value to E_IPJ_TAG_OPERATION_TYPE_LOCK and the key E_IPJ_KEY_TAG_OPERATION_ENABLE value to `TRUE`.

#### BlockPermalock Panel

The BlockPermalock panel instructs the reader to perform a BlockPermalock command during an access operation, permanently locking specific blocks of tag memory.

The Action dropdown sets ths specific BlockPermalock action to be performed, using the key E_IPJ_KEY_BLOCKPERMALOCK_ACTION.

The Membank dropdown sets the memory bank that the BlockPermalock action should be performed on, using the key E_IPJ_KEY_BLOCKPERMALOCK_MEM_BANK.

The Pointer field sets the location within the memory bank that the BlockPermalock action should be performed on, using the key E_IPJ_KEY_BLOCKPERMALOCK_BLOCK_POINTER.

The Range field sets the number of consecutive memory blocks that the BlockPermalock action should be performed on, using the key E_IPJ_KEY_BLOCKPERMALOCK_BLOCK_RANGE.

The Mask field sets the mask of the BlockPermalock action, specifying what state each block in the range should be left in, using the key E_IPJ_KEY_BLOCKPERMALOCK_MASK

The BlockPermalock button performs a BlockPermalock operation with the specified parameters. It does this by emulating a ipj-start() API function call after setting the key E_IPJ_KEY_TAG_OPERATION to value to E_IPJ_TAG_OPERATION_TYPE_BLOCKPERMALOCK and the key E_IPJ_KEY_TAG_OPERATION_ENABLE value to `TRUE`.

#### QT Panel

The QT panel instructs the reader to perform a QT command during an access operation. QT is a feature of Impinj’s Monza tags allowing them to have both public and private profiles.

The Action dropdown sets the QT action to be performed, using the key E_IPJ_KEY_QT_ACTION.

The Persistence dropdown sets the persistence of the QT action, whether the results should persist across tag singulations, using the key E_IPJ_KEY_QT_PERSISTENCE.

The Range dropdown sets the range in which tags should respond to the QT command, using the key E_IPJ_KEY_QT_ACCESS_RANGE.

The Memory Map dropdown sets which QT data profile should be used for the QT action, using the key E_IPJ_KEY_QT_DATA_PROFILE.

The Tag Operation dropdown sets the tag operation to be performed as part of the QT command, if any, using the key E_IPJ_KEY_QT_TAG_OPERATION.

Note

If the Tag Operation parameter is set to READ or WRITE, then those operations should be configured using the Read or Write panels.

The QT button performs a QT operation with the specified parameters. It does this by emulating a ipj-start() API function call after setting the key E_IPJ_KEY_TAG_OPERATION to value to E_IPJ_TAG_OPERATION_TYPE_QT and the key E_IPJ_KEY_TAG_OPERATION_ENABLE value to `TRUE`.

### Set/Get Tab

The Set/Get tab reads and writes key values on the attached reader. This is especially useful to test out specific configurations of the reader.

#### Key Set and Get Panel

The Key Set and Get panel sets and gets key values on the attached reader by emulating the ipj_set() and ipj_get() functions.

The Key dropdown selects the specific key which should be read or written. For more details on the IRI keys, see the Key Codes section of documentation.

The BankIndex field selects the bank of the key which should be read of written. For more details on key banks, see the Configuration Commands section of documentation.

The ValueIndex field selects the value index of the key which should be read of written. For more details on key value indices, see the Configuration Commands section of documentation.

The Value field sets the value that will be written to the specific key value and/or bank index when the Set button is pressed.

The Set button performs a key set on the specific key bank and/or value specified in the other controls. It does this by emulating the ipj_set API function call, with the arguments `key`, `bank_index`, `value_index`, and `value` set per the relavent controls.

The Get button performs a key get on the specific key bank and/or value specified in the other controls. It does this by emulating the ipj_get API function call, with the arguments `key`, `bank_index`, and `value_index` set per the relavent controls.

The Get Key Info button performs a key info get on the specified key. It does this by emulating the get_info API function call, with the argument `key` set per the Key dropdown.

#### Key Utilities Panel

The Key Utilities panel retrieves specific information about the reader, reading out key values by emulating the ipj_get() and ipj_bulk_get() API functions.

The Retrieve Device Info button reads a sequence of keys with information about the reader, and prints them to the log. It does this by emulating the ipj_get() API function repeatedly.

Specifically, it reads the following key values:

- E_IPJ_KEY_PRODUCT_ID
- E_IPJ_KEY_SERIAL_NUMBER
- E_IPJ_KEY_PRODUCT_SKU
- E_IPJ_KEY_LOT_DATE_CODE
- E_IPJ_KEY_BOOTSTRAP_VERSION
- E_IPJ_KEY_BOOTSTRAP_CRC
- E_IPJ_KEY_APPLICATION_VERSION
- E_IPJ_KEY_APPLICATION_CRC
- E_IPJ_KEY_MICROPROCESSOR_ID
- E_IPJ_KEY_REGION_ID
- E_IPJ_KEY_UNIQUE_ID
- E_IPJ_KEY_HARDWARE_REVISION

The Retrieve All Keys button retrieves the values of all of the keys on the reader. It does this by emulating the ipj_bulk_get() API function repeatedly.

The Get Error Info button retrieves information about error events that have occurred on the reader, by reading the keys E_IPJ_KEY_FIRST_ERROR, E_IPJ_KEY_LAST_ERROR, E_IPJ_KEY_SYSTEM_ERROR. It reads these keys by emulating the ipj_get() API function repeatedly.

The Clear Error button clears recent errors on the reader by emulating a ipj-start() API function call with the `action` argument E_IPJ_ACTION_CLEAR_ERROR.

The Get Temperature button reads temperature values from the reader by reading the keys E_IPJ_KEY_TEMPERATURE_INTERNAL, E_IPJ_KEY_TEMPERATURE_EXTERNAL, and E_IPJ_KEY_TEMPERATURE_PA, by emulating the ipj_bulk_get() API function repeatedly.

### Write EPC Tab

The Write EPC tab writes specifically to the EPC field of tags using the attached reader.

The EPC fields set the values to the written to the tag EPC, using the key E_IPJ_KEY_WRITE_DATA.

The Randomize EPC button generates random values and inserts them in the EPC fields.

The Clear EPC button sets all of the EPC word fields to `0000`.

The Increment EPC checkbox causes the GUI to increment the values in the EPC fields whenever an EPC is successfully written to a tag. This can be very useful when “serailizing” tags.

The Write button performs an EPC write operation using the parameters provided. It does this by emulating a ipj-start() API function call after setting the key E_IPJ_KEY_TAG_OPERATION value to E_IPJ_TAG_OPERATION_TYPE_WRITE_EPC and the key E_IPJ_KEY_TAG_OPERATION_ENABLE value to `TRUE`.

### Image Loader Tab

The Image Loader tab generates and bootloads application or stored settings images into non-volatile memory on the reader.

#### Image Loader Panel

The Image Loader panel bootloads application and stored settings images onto the reader.

The Filename field contains the file name and path which will be loaded onto the reader.

The Open File button selects the file to be loaded, storing the result in the Filename field.

The Load Image button loads the selected image onto the reader. For examples of how to load a firmware image onto a reader, see the Application Update configuration example and the IRI_Loader example program.

The progress bar displays progress as the image is loaded onto the reader.

#### Stored Settings Panel

The Stored Settings panel generates stored settings images that can be loaded onto the reader to streamline runtime configuration.

For more information on creating a stored settings image, see the Stored Settings section of documentation.

The Save Stored Settings to XML button downloads the currently loaded stored settings from the reader, and saves them as an `.XML` file, which can then be edited and used to generate another stored settings image.

The Save Settings Image BIN checkbox caues the Save Stored Settings to XML button to also save a `.BIN` formatted stored settings image when downloading from a reader.

The Make Settings Image button generates a binary `.BIN` stored settings image from an arbitrary `.XML` file.

The Factory Reset button erases the stored settings on the reader.

The Create Example Stored Settings button generates an example of a stored settings `.XML` file, which can be edited to produce the desired configuration.

### Input and Output (IO) Tab

The IO tab configures the user controlled input and output (GPIO) pins of the attached reader.

#### GPIO Panel

The GPIO panel controls the GPIOs of the attached reader.

The GPIO configuration dropdowns set the direction of each of the four GPIOs, by setting the key E_IPJ_KEY_GPIO_MODE to either E_IPJ_GPIO_MODE_INPUT or E_IPJ_GPIO_MODE_OUTPUT.

The State dropdowns set the output value of each of the four GPIOs, if the GPIOs are configured as outputs, by setting the key E_IPJ_KEY_GPIO_STATE to either E_IPJ_GPIO_STATE_LO or E_IPJ_GPIO_STATE_HI.

The Start button configures the GPIOs on the attached reader using the key parameters described above. It does this by writing the values above to the appropriate keys, then emulating a ipj-start() API function call with the `action` argument E_IPJ_ACTION_GPIO.

The Read button reads the current state of the GPIOs on the attached reader. It does this by emulating a ipj-start() API function call with the `action` argument E_IPJ_ACTION_GPIO, and then printing the contents of the GPIO action reports that are received from the reader.

The Stop button ends the configured GPIO behavior. It does this by emulating a ipj-stop() API function call with the `action` argument E_IPJ_ACTION_GPIO

#### Health and Status pins Panel

The Health and Status pins panel controls the behavior of the Health and Status pins of the reader.

The Pin Automatic Control dropdown allows configuration of the method of control of the health and status pins. By default, pin automatic control is enabled, and the health and status pins automatically change state to indicate device operating conditions. If pin automatic control is disabled, the pins no longer change state automatically. This configuration is carried out using the test command E_IPJ_TEST_ID_HARDWARE_CONTROL.

The Manual Health Value and Manual Status Value dropdowns allow manual configuration of the output of the health and status pins. This configuration will take effect regardless of the Pin Automatic Control configuration, but may be changed afterwards by the automatic behavior. This configuration is carried out using the test command E_IPJ_TEST_ID_GPIO_CONTROL.

#### DAC and ADC Panels

The DAC and ADC Panels enable control over the Digital to Analog Converter and Analog to Digital Converter built into certain readers. They do this by using the readers’ test commands to read or write values to the DAC and ADC.

For more details on using the test commands, see the Test Commands configuration examples.

The DAC panel’s Value field sets the digital value to be written to the DAC, which will produce an analog voltage output.

The DAC panel’s Set button writes the value specified above using the test command E_IPJ_TEST_ID_USER_DAC_CONTROL.

The ADC panel’s Read button reads the digital value of the analog voltage applied to the ADC pin, using the test command E_IPJ_TEST_ID_USER_ADC_CONTROL.

### Transmit (Tx) Control Tab

The Tx Control tab manually controls the RF transmitter inside the attached reader, which is expecially useful for performing regulatory region compliance testing.

#### Region and RF Mode Panel

The Region and RF Mode panel controls the regulatory region and RF Mode the reader is configured for.

The Region dropdown selects the regulatory region to be set.

The Set Region button sets the region selected in the dropdown by writing the key E_IPJ_KEY_REGION_ID.

The RF Mode field selects the RF Mode to be set.

The Set RF Mode button sets the RF mode by writing the key E_IPJ_KEY_RF_MODE.

#### Transmit CW Panel

The Transmit CW panel controls the carrier wave (CW) transmit functionality of a reader. It does this by using test commands.

For more details on using the test commands, see the Test Commands configuration examples.

The On button turns on CW transmit, using the test command E_IPJ_TEST_ID_CW_CONTROL.

The Off button turns off CW transmit, using the test command E_IPJ_TEST_ID_CW_CONTROL.

#### PRBS Panel

The PRBS panel controls the Pseudo-random Bitstream (PRBS) behavior of the reader. It does this by using test commands.

For more details on using the test commands, see the Test Commands configuration examples.

The On button turns on continuous PRBS transmit, using the test command E_IPJ_TEST_ID_PRBS_CONTROL.

The Off button turns off PRBS transmit, using the test command E_IPJ_TEST_ID_PRBS_CONTROL.

The Data dropdown selects which data pattern is modulated by the PRBS. Options include random data, or Query repetitions (Q-Rep). This is used as one of the arguments of the PRBS test command.

The On Pulsing button turns on a pulsing PRBS transmit. In this mode, the reader duty cycles the PRBS on and off for the times set using the On Time and Off Time fields. This behavior is configured using the test command E_IPJ_TEST_ID_PRBS_CONTROL.

The On Time field configures the time PRBS data is transmitted for when in pulsing mode.

The Off Time field configures the “dead time” between PRBS data transmissions when in pulsing mode.

#### Set Transmit Power Panel

The Set Transmit Power panel controls the transmit power that the reader transmits at.

The Power field contains the transmit power to be applied to the reader.

The Set button sets the transmit power specified by writing the key E_IPJ_KEY_ANTENNA_TX_POWER.

#### Set CW Frequency Panel

The Set CW Frequency panel controls fixed frequency carrier wave (CW) transmission on the reader. It does this by using test commands.

For more details on using the test commands, see the Test Commands configuration examples.

The Frequency field configures the fixed frequency that the carrier wave is to be transmitted at.

The Set button sets the fixed frequency as configured in the GUI, using the test command E_IPJ_TEST_ID_SET_FREQUENCY.

The Disable button disables fixed frequency behavior, returning the reader to the default hopping behavior, using the test command E_IPJ_TEST_ID_SET_FREQUENCY.

The Continuous button disables frequency hopping behavior during inventory, using the test command E_IPJ_TEST_ID_INVENTORY_CONTROL.

The Hopping button enables frequency hopping behavior during inventory, using the test command E_IPJ_TEST_ID_INVENTORY_CONTROL.

#### RF Switch Controls Panel

The RF Switch Controls panel manually controls the RF switches inside the reader that are used for Antenna Switching and regulatory region switching.

The Ant 1 through Ant 4 buttons set the antenna switches inside the reader (if any are present) to connect the RF port to that specific antenna. This is performed using the test command E_IPJ_TEST_ID_RF_SWITCH_CONTROL.

This antenna selection overrides the automatic configuration of the reader using antenna switching.

The SAW 1 through SAW 3 fields set the SAW filter switches inside the reader (if any are present) to connect RF transmit signal path through the specified SAW filter. This is performed using the test command E_IPJ_TEST_ID_RF_SWITCH_CONTROL.

This SAW filter selection overrides the automatic configuration of the reader using regulatory region configuration.

### Test Command Tab

The Test Command tab tests various aspects of reader performance using test commands.

#### Generic Test Command Panel

The Generic Test Command panel executes test commands on the reader.

For more details on test commands, see the test command section of the configuration examples.

The Test ID field selects the test command to be performed, from the enumerations of the ipj_test_id type. This value will be written to the key E_IPJ_KEY_TEST_ID.

The Test P0 through Test P3 fields set the parameters of the test command to be performed. These values will be written to the banks of key E_IPJ_KEY_TEST_PARAMETERS.

The Start Test button starts a test as configured above, by emulating a ipj-start() API function call with the `action` argument E_IPJ_ACTION_TEST after writing the other keys.

#### Debug UART Print Panel

The Debug UART Print panel controls the behavior of the reader’s debug UART, configuring it to print different information.

For more information about the debug UART, see the Debug UART section of the debugging documentation.

The Enable Debug UART Print button enables IRI packet printing on the reader’s Debug UART port. It does this by writing a value of `1` to the key E_IPJ_KEY_TEST_DEBUG_PORT. This enables the same behavior as described in the IRI Packet Printing section of the library debugging documentation.

### Navigation

- previous
- Indy ITK 1.8.0 documentation »