IRI Configuration Examples¶

/* Tag report handler processes asynchronous reports */
ipj_error ipj_util_tag_operation_report_handler(
        ipj_iri_device* iri_device,
        ipj_tag_operation_report* tag_operation_report)
{
    /* If tag report has epc, print epc */
    if (tag_operation_report->tag.has_epc)
    {
        ipj_util_print_epc(
                (uint16_t*) tag_operation_report->tag.epc.bytes,
                (int) tag_operation_report->tag.epc.size / 2,
                true);
    }

    return E_IPJ_ERROR_SUCCESS;
}

ipj_set_value(&iri_device, E_IPJ_KEY_REPORT_CONTROL_TAG, E_IPJ_TAG_FLAG_BIT_RSSI);

/* Tag report handler processes asynchronous reports */
ipj_error ipj_util_tag_operation_report_handler(
        ipj_iri_device* iri_device,
        ipj_tag_operation_report* tag_operation_report)
{
    /* If tag report has RSSI, print RSSI */
    if (tag_operation_report->tag.has_rssi)
    {
        printf(" rssi = %d cdBm", tag_operation_report->tag.rssi);
    }

    return E_IPJ_ERROR_SUCCESS;
}

ipj_set_value(&iri_device, E_IPJ_KEY_REPORT_CONTROL_STATUS, E_IPJ_STATUS_FLAG_BIT_CHANNEL_ACTIVITY);

/* Status report handler processes asynchronous reports */
ipj_error ipj_util_status_report_handler(
        ipj_iri_device* iri_device,
        ipj_status_report* status_report)
{
    printf(" reverse power = %d cdBm", status_report->data[1]);

    return E_IPJ_ERROR_SUCCESS;
}

ipj_set_value(&iri_device, E_IPJ_KEY_REGION_ID, E_IPJ_REGION_ETSI_EN_302_208_V1_4_1);

ipj_set_value(&iri_device, E_IPJ_KEY_ANTENNA_TX_POWER, 2000);

ipj_set_value(&iri_device, E_IPJ_KEY_RF_MODE, 3);

ipj_key_list    key_list;
uint32_t        key_list_count;

memset(&key_list, 0, sizeof(key_list));

key_list_count = 1;
key_list.key = E_IPJ_KEY_ANTENNA_SEQUENCE;

key_list.list_count = 16;
key_list.list[0] = 1;
key_list.list[1] = 2;
key_list.list[2] = 4;
key_list.list[3] = 3;
key_list.list[4] = 2;
// All other list items initialized to 0 by memset

ipj_bulk_set(&iri_device, 0, 0, &key_list, key_list_count);

ipj_set(&iri_device, E_IPJ_KEY_GPIO_MODE, 1, 0, E_IPJ_GPIO_MODE_OUTPUT);
ipj_set(&iri_device, E_IPJ_KEY_GPIO_STATE, 1, 0, E_IPJ_GPIO_STATE_HI);
ipj_start(&iri_device, E_IPJ_ACTION_GPIO);
ipj_stop(&iri_device, E_IPJ_ACTION_GPIO);

ipj_set(&iri_device, E_IPJ_KEY_GPIO_MODE, 1, 0, E_IPJ_GPIO_MODE_INPUT);
ipj_set(&iri_device, E_IPJ_KEY_GPIO_STATE, 1, 0, E_IPJ_GPIO_STATE_HI);
ipj_start(&iri_device, E_IPJ_ACTION_GPIO);
/* At this point, the user should call ipj_receive and handle any
 * incoming GPIO reports.  When the desired amount of reports have
 * been collected, the user should call ipj_stop and poll for the gpio
 * stop report */
ipj_stop(&iri_device, E_IPJ_ACTION_GPIO);

ipj_set(&iri_device, E_IPJ_KEY_GPIO_MODE, 1, 0, E_IPJ_GPIO_MODE_INPUT_ACTION);
ipj_set(&iri_device, E_IPJ_KEY_GPIO_STATE, 1, 0, E_IPJ_GPIO_STATE_FLOAT);
ipj_set(&iri_device, E_IPJ_KEY_GPIO_HI_ACTION, 1, 0, E_IPJ_GPI_ACTION_START_INVENTORY);
ipj_start(&iri_device, E_IPJ_ACTION_GPIO);
/* At this point, the user should begin calling ipj_receive().  When
 * there is a logic-high event on the selected pin, the user will
 * receive a GPIO report, followed by tag reports as tags come into
 * the field.  When the user has received the desired number of tag
 * reports, they should:
 * 1. issue an ipj_stop(&iri_device, E_IPJ_ACTION_INVENTORY) command
 * 2. call ipj_receive until they receive an inventory stop report.
 * 3. issue an ipj_stop(&iri_device, E_IPJ_ACTION_GPIO) command
 * 4. call ipj_receive until they receive a gpio stop report
 */
ipj_stop(&iri_device, E_IPJ_ACTION_GPIO);

ipj_set_value(
        &iri_device,
        E_IPJ_KEY_REPORT_CONTROL_TAG,
        E_IPJ_TAG_FLAG_BIT_EPC       | E_IPJ_TAG_FLAG_BIT_TID |
        E_IPJ_TAG_FLAG_BIT_TIMESTAMP | E_IPJ_TAG_FLAG_BIT_CHANNEL);

ipj_error setup_custom_region_fcc(ipj_iri_device* iri_device)
{
    unsigned int i;
    ipj_error error;
    ipj_key_value   key_value[16];
    uint32_t        key_value_count=0;
    ipj_key_list    key_list;
    uint32_t        key_list_count=0;

    /*
    * 1. Setup Custom Region
    */
    key_value_count = 9;

    memset(key_value, 0, sizeof(key_value));
    memset(&key_list, 0, sizeof(key_list));

    key_value[0].key   = E_IPJ_KEY_REGION_ON_TIME_NOMINAL;
    key_value[0].value = 200;

    key_value[1].key   = E_IPJ_KEY_REGION_ON_TIME_ACCESS;
    key_value[1].value = 400;

    key_value[2].key   = E_IPJ_KEY_REGION_OFF_TIME;
    key_value[2].value = 0;

    key_value[3].key   = E_IPJ_KEY_REGION_OFF_TIME_SAME_CHANNEL;
    key_value[3].value = 0;

    key_value[4].key   = E_IPJ_KEY_REGION_START_FREQUENCY_KHZ;
    key_value[4].value = 902750;

    key_value[5].key   = E_IPJ_KEY_REGION_CHANNEL_SPACING_KHZ;
    key_value[5].value = 500;

    key_value[6].key   = E_IPJ_KEY_REGION_RANDOM_HOP;
    key_value[6].value = 1;

    key_value[7].key   = E_IPJ_KEY_REGION_INDY_PLL_R_DIVIDER;
    key_value[7].value = 24;

    key_value[8].key   = E_IPJ_KEY_REGION_RF_FILTER;
    key_value[8].value = 0;

    error = ipj_bulk_set(iri_device, &key_value[0], key_value_count, NULL, 0);
    if (error)
    {
        printf("ERROR: IPJ_BULK_SET FAILED - ERROR CODE: %d\n\n", error);
        return error;
    }

    /*
    * 2. Change Region
    * Note: Custom region params are only applied once and cannot be updated on the fly. Further
    * they are only applied if the region changes. Force the region to something non-custom,
    * then change to custom so the settings are applied.
    */
    error = ipj_set_value(iri_device, E_IPJ_KEY_REGION_ID, E_IPJ_REGION_FCC_PART_15_247);
    if (error)
    {
        printf("ERROR: Set E_IPJ_KEY_REGION_ID FAILED - ERROR CODE: %d\n\n", error);
        return error;
    }
    error = ipj_set_value(iri_device, E_IPJ_KEY_REGION_ID, E_IPJ_REGION_CUSTOM);
    if (error)
    {
        printf("ERROR: Set E_IPJ_KEY_REGION_ID FAILED - ERROR CODE: %d\n\n", error);
        return error;
    }

    /*
    * 3. Setup Channel Table
    */
    key_list_count = 1;
    key_list.key = E_IPJ_KEY_REGION_CHANNEL_TABLE;
    key_list.list_count = 32; /* Max size for key_list */
    key_list.has_value_index = true;
    key_list.value_index = 0;

    /* Set the first part of the channel table*/
    for (i = 0; i < key_list.list_count; i++)
    {
        /* Channels are one based */
        key_list.list[i] = i + 1;
    }

    error = ipj_bulk_set(iri_device, NULL, 0, &key_list, key_list_count);
    if (error)
    {
        printf("ERROR: IPJ_BULK_SET FAILED - ERROR CODE: %d\n\n", error);
        return error;
    }

    /* The rest of the channels */
    key_list.list_count = 18;
    key_list.has_value_index = true;
    key_list.value_index = 32;

    /* Set the first part of the channel table*/
    for (i = 0; i < key_list.list_count; i++)
    {
        /* Channels are one based, pick up where we left off */
        key_list.list[i] = i + 32 + 1;
    }

    error = ipj_bulk_set(iri_device, NULL, 0, &key_list, key_list_count);
    if (error)
    {
        printf("ERROR: IPJ_BULK_SET FAILED - ERROR CODE: %d\n\n", error);
        return error;
    }

    error = ipj_set_value(iri_device, E_IPJ_KEY_REGION_CHANNEL_TABLE_SIZE, 50);
    if (error)
    {
        printf("ERROR: Set E_IPJ_KEY_REGION_CHANNEL_TABLE_SIZE FAILED - ERROR CODE: %d\n\n", error);
        return error;
    }

   return E_IPJ_ERROR_SUCCESS;
}

ipj_error setup_custom_region_etsi(ipj_iri_device* iri_device)
{
    ipj_error error;
    ipj_key_value   key_value[16];
    uint32_t        key_value_count=0;
    ipj_key_list    key_list;
    uint32_t        key_list_count=0;

    /*
    * 1. Setup Custom Region
    */
    key_value_count = 8;

    memset(key_value, 0, sizeof(key_value));
    memset(&key_list, 0, sizeof(key_list));

    key_value[0].key   = E_IPJ_KEY_REGION_ON_TIME_NOMINAL;
    key_value[0].value = 3800;

    key_value[1].key   = E_IPJ_KEY_REGION_ON_TIME_ACCESS;
    key_value[1].value = 4000;

    key_value[2].key   = E_IPJ_KEY_REGION_OFF_TIME;
    key_value[2].value = 0;

    key_value[3].key   = E_IPJ_KEY_REGION_OFF_TIME_SAME_CHANNEL;
    key_value[3].value = 100;

    key_value[4].key   = E_IPJ_KEY_REGION_START_FREQUENCY_KHZ;
    key_value[4].value = 865100;

    key_value[5].key   = E_IPJ_KEY_REGION_CHANNEL_SPACING_KHZ;
    key_value[5].value = 200;

    key_value[6].key   = E_IPJ_KEY_REGION_RANDOM_HOP;
    key_value[6].value = 0;

    key_value[7].key   = E_IPJ_KEY_REGION_INDY_PLL_R_DIVIDER;
    key_value[7].value = 60;

    error = ipj_bulk_set(iri_device, &key_value[0], key_value_count, NULL, 0);
    if (error)
    {
        printf("ERROR: IPJ_BULK_SET FAILED - ERROR CODE: %d\n\n", error);
        return error;
    }

    /*
    * 2. Change Region
    * Note: Custom region params are only applied once and cannot be updated on the fly. Further
    * they are only applied if the region changes. Force the region to something non-custom,
    * then change to custom so the settings are applied.
    */
    error = ipj_set_value(iri_device, E_IPJ_KEY_REGION_ID, E_IPJ_REGION_FCC_PART_15_247);
    if (error)
    {
        printf("ERROR: Set E_IPJ_KEY_REGION_ID FAILED - ERROR CODE: %d\n\n", error);
        return error;
    }
    error = ipj_set_value(iri_device, E_IPJ_KEY_REGION_ID, E_IPJ_REGION_CUSTOM);
    if (error)
    {
        printf("ERROR: Set E_IPJ_KEY_REGION_ID FAILED - ERROR CODE: %d\n\n", error);
        return error;
    }

    /*
    * 3. Setup Channel Table
    */
    key_list_count = 1;
    key_list.key = E_IPJ_KEY_REGION_CHANNEL_TABLE;
    key_list.list_count = 4;

    key_list.list[0] = 4;
    key_list.list[1] = 7;
    key_list.list[2] = 10;
    key_list.list[3] = 13;

    error = ipj_bulk_set(iri_device, NULL, 0, &key_list, key_list_count);
    if (error)
    {
        printf("ERROR: IPJ_BULK_SET FAILED - ERROR CODE: %d\n\n", error);
        return error;
    }

    error = ipj_set_value(iri_device, E_IPJ_KEY_REGION_CHANNEL_TABLE_SIZE, key_list.list_count);
    if (error)
    {
        printf("ERROR: Set E_IPJ_KEY_REGION_CHANNEL_TABLE_SIZE FAILED - ERROR CODE: %d\n\n", error);
        return error;
    }

    return E_IPJ_ERROR_SUCCESS;
}

ipj_connection_params connection_params;
connection_params.serial.baudrate = E_IPJ_BAUD_RATE_BR57600;
error = ipj_modify_connection(&iri_device, E_IPJ_CONNECTION_TYPE_SERIAL, &connection_params);

ipj_key_list key_list;
memset(&key_list, 0, sizeof(key_list));
key_list.key = E_IPJ_KEY_FIRST_ERROR;
key_list.list_count = 5;
error = ipj_bulk_get(&iri_device, NULL, 0, &key_list, 1);
if (error)
{
    printf("ERROR: IPJ_BULK_GET FAILED - ERROR CODE: %d\n\n", error);
    return error;
}

error = ipj_start(&iri_device, E_IPJ_ACTION_CLEAR_ERROR);
if (error)
{
    printf("ERROR: IPJ_START FAILED - ERROR CODE: %d\n\n", error);
    return error;
}

/* Sets the idle power mode to standard. This automatically takes effect */
ipj_set_value(&iri_device, E_IPJ_KEY_DEVICE_IDLE_POWER_MODE,
              E_IPJ_IDLE_POWER_MODE_STANDARD);

/* Sets the idle power mode to low-latency. This automatically takes effect */
ipj_set_value(&iri_device, E_IPJ_KEY_DEVICE_IDLE_POWER_MODE,
              E_IPJ_IDLE_POWER_MODE_LOW_LATENCY);

/* Put the device into standby mode */
error = ipj_start(&iri_device, E_IPJ_ACTION_STANDBY);
if (error)
{
    printf("ERROR: STANDBY FAILED - ERROR CODE: %x\n\n", error);
    return error;
}

printf("Attempting to wake Indy Module\n");

/* Set the receive timeout MS to a lower number (100ms) */
error = ipj_set_receive_timeout_ms(&iri_device, 100);
if (error)
{
    printf("ERROR: SET RX TIMEOUT FAILED - ERROR CODE: %x\n\n", error);
    return error;
}

/* Spin on IPJ_GET_VALUE (any key will do) until the device responds */
do
{
    error = ipj_get_value(&iri_device,  E_IPJ_KEY_APPLICATION_VERSION, &value);
}
while (error && retries--);
if (error)
{
    printf("ERROR: Failed to wake Indy Module - ERROR CODE: %x\n\n", error);
    return error;
}

/* At this point, the device is active and can perform RFID operations */

/* Now put the device in sleep mode */
error = ipj_start(&iri_device, E_IPJ_ACTION_SLEEP);
if (error)
{
    printf("ERROR: STANDBY FAILED - ERROR CODE: %x\n\n", error);
    return error;
}

/* The host application must toggle either the RESET or WKUP pins to
 * bring the device out of sleep */

int32_t forward_power_cdBm;
int32_t reverse_power_cdBm;

/* Set frequency to 912.25 MHz (specified in kHz)*/
ipj_util_test_command(&iri_device, E_IPJ_TEST_ID_SET_FREQUENCY, 912250, 0, 0, 0);
/* Enable CW */
ipj_util_test_command(&iri_device, E_IPJ_TEST_ID_CW_CONTROL, 1, 0, 0, 0);
/* Leave CW on for 1 second */
platform_sleep_ms_handler(1000);
/* Run forward power test */
ipj_util_test_command(&iri_device, E_IPJ_TEST_ID_SENSOR_CONTROL, 1, 2, 0, 0);
/* Retrieve forward power measurement */
ipj_get_value(&iri_device, E_IPJ_KEY_TEST_RESULT_1, (uint32_t*)&forward_power_cdBm);
/* Print forward power value */
printf("Forward Power: %d cdBm\n", forward_power_cdBm);
/* Run reverse power test */
ipj_util_test_command(&iri_device, E_IPJ_TEST_ID_SENSOR_CONTROL, 1, 3, 0, 0);
/* Retrieve reverse power measurement */
ipj_get_value(&iri_device, E_IPJ_KEY_TEST_RESULT_1, (uint32_t*)&reverse_power_cdBm);
/* Print reverse power value */
printf("Reverse Power: %d cdBm\n", reverse_power_cdBm);
/* Disable CW */
ipj_util_test_command(&iri_device, E_IPJ_TEST_ID_CW_CONTROL, 0, 0, 0, 0);