Impinj Radio Interface Toolkit LT for C (ITK-LT-C)¶

// *****************************************************************************
{%- for r in reports%}
{{r}}
{%-endfor%}
// *****************************************************************************
// IRI API - LT Defines
// *****************************************************************************
{{flex_reports}}

/* Report Decoding */
#define REPORT_FIELD_ID(x)          ((x >> 16) & 0xFFFF)
#define REPORT_FIELD_LENGTH(x)      (x & 0xFFFF)
#define ROUNDED_COUNT_32(x)         (((x + sizeof(uint32_t) - 1) & 0xFFFFFFFC) / sizeof(uint32_t))

ipj_error ipj_util_tag_operation_report_handler(
        ipj_iri_device* iri_device,
        uint32_t report_count_32,
        uint32_t* tag_operation_report)
{
    uint32_t index = 0;
    while (index < report_count_32)
    {
        uint32_t field_header = tag_operation_report[index++];
        switch (REPORT_FIELD_ID(field_header))
        {
            case E_IPJ_TAG_OPERATION_REPORT_ERROR:
            {
                IPJ_UTIL_PRINT_ERROR(tag_operation_report[index], "tag_operation_report");
                break;
            }
            case E_IPJ_TAG_OPERATION_REPORT_PC:
            {
                printf("PC: %04X\n", tag_operation_report[index]);
                break;
            }
            case E_IPJ_TAG_OPERATION_REPORT_XPC:
            {
                printf("XPC: %04X\n", tag_operation_report[index]);
                break;
            }
            case E_IPJ_TAG_OPERATION_REPORT_CRC:
            {
                printf("CRC: %04X\n", tag_operation_report[index]);
                break;
            }
            case E_IPJ_TAG_OPERATION_REPORT_RSSI:
            {
                printf("RSSI: %d\n", (int)tag_operation_report[index]);
                break;
            }
            case E_IPJ_TAG_OPERATION_REPORT_PHASE:
            {
                printf("PHASE: %d\n", (int)tag_operation_report[index]);
                break;
            }
            case E_IPJ_TAG_OPERATION_REPORT_CHANNEL:
            {
                printf("CHANNEL: %d\n", tag_operation_report[index]);
                break;
            }
            case E_IPJ_TAG_OPERATION_REPORT_ANTENNA:
            {
                printf("ANTENNA: %d\n", tag_operation_report[index]);
                break;
            }
            case E_IPJ_TAG_OPERATION_REPORT_TAG_OPERATION_TYPE:
            {
                printf("Tag operation: ");
                switch (tag_operation_report[index])
                {
                    case E_IPJ_TAG_OPERATION_TYPE_READ:
                    {
                        printf("READ\n");
                        break;
                    }
                    case E_IPJ_TAG_OPERATION_TYPE_WRITE:
                    {
                        printf("WRITE\n");
                        break;
                    }
                    case E_IPJ_TAG_OPERATION_TYPE_LOCK:
                    {
                        printf("LOCK\n");
                        break;
                    }
                    case E_IPJ_TAG_OPERATION_TYPE_KILL:
                    {
                        printf("KILL\n");
                        break;
                    }
                    case E_IPJ_TAG_OPERATION_TYPE_BLOCKPERMALOCK:
                    {
                        printf("BLOCK PERMALOCK\n");
                        break;
                    }
                    case E_IPJ_TAG_OPERATION_TYPE_WRITE_EPC:
                    {
                        printf("WRITE EPC\n");
                        break;
                    }
                    case E_IPJ_TAG_OPERATION_TYPE_QT:
                    {
                        printf("QT\n");
                        break;
                    }
                    default:
                    {
                        printf("TYPE=%d\n", tag_operation_report[index]);
                    }
                }
                break;
            }
            case E_IPJ_TAG_OPERATION_REPORT_RETRIES:
            {
                printf("RETRIES: %d\n", tag_operation_report[index]);
                break;
            }
            case E_IPJ_TAG_OPERATION_REPORT_DIAGNOSTIC:
            {
                printf("DIAGNOSTIC: %X\n", tag_operation_report[index]);
                break;
            }
            case E_IPJ_TAG_OPERATION_REPORT_TIMESTAMP:
            {
                printf(
                        "TIMESTAMP: %I64d\n",
                        (uint64_t) tag_operation_report[index]
                                | ((uint64_t) (tag_operation_report[index + 1]) << 32));
                break;
            }
            case E_IPJ_TAG_OPERATION_REPORT_EPC:
            {
                printf("EPC: ");
                ipj_util_print_epc(
                        (uint16_t*) &tag_operation_report[index],
                        REPORT_FIELD_LENGTH(field_header) / sizeof(uint16_t),
                        true);
                break;
            }
            case E_IPJ_TAG_OPERATION_REPORT_TID:
            {
                printf("TID: ");
                /* Reuse the print epc method */
                ipj_util_print_epc(
                        (uint16_t*) &tag_operation_report[index],
                        REPORT_FIELD_LENGTH(field_header) / sizeof(uint16_t),
                        true);
                break;
            }
            case E_IPJ_TAG_OPERATION_REPORT_TAG_OPERATION_DATA:
            {
                printf("Report contains data: %d bytes\n", REPORT_FIELD_LENGTH(field_header));
                /* Reuse the print epc method */
                ipj_util_print_epc(
                        (uint16_t*) &tag_operation_report[index],
                        REPORT_FIELD_LENGTH(field_header) / sizeof(uint16_t),
                        true);
                break;
            }
        }

        index += ROUNDED_COUNT_32(REPORT_FIELD_LENGTH(field_header));

    }

    ipj_util_print_divider('-', 80);
    return E_IPJ_ERROR_SUCCESS;
}

/* Stop report handler processes asynchronous reports */
ipj_error ipj_util_stop_report_handler(
        ipj_iri_device* iri_device,
        ipj_stop_report* ipj_stop_report)
{
    if (ipj_stop_report->error == E_IPJ_ERROR_SUCCESS)
    {
        /* Print reader identifier */
        printf("%s: STOPPED\n", (char*) iri_device->reader_identifier);

        /* Set the stopped flag, the stop report does not have any fields that
         * need to be checked */
        ipj_stopped_flag = 1;
    }
    else
    {
        IPJ_UTIL_PRINT_ERROR(ipj_stop_report->error,"stop_report");
    }
    return ipj_stop_report->error;
}

/* GPIO handler processes asynchronous GPIO event reports */
ipj_error ipj_util_gpio_report_handler(
        ipj_iri_device* iri_device,
        ipj_gpio_report* gpio_report)
{
    unsigned int i;
    for (i = 0; i < 40; i++)
        printf("*");

    printf("\n%s: GPIO Report\n", (char*) iri_device->reader_identifier);

    printf("GPIO Modes:  ");
    for (i = 1; i < ARRAY_SIZE(gpio_report->gpio_modes); i++)
    {
        switch (gpio_report->gpio_modes[i])
        {
            case E_IPJ_GPIO_MODE_DISABLED:
            {
                printf("D  ");
                break;
            }
            case E_IPJ_GPIO_MODE_INPUT:
            {
                printf("I  ");
                break;
            }
            case E_IPJ_GPIO_MODE_OUTPUT:
            {
                printf("O  ");
                break;
            }
            case E_IPJ_GPIO_MODE_OUTPUT_PULSE:
            {
                printf("OP ");
                break;
            }
            case E_IPJ_GPIO_MODE_INPUT_ACTION:
            {
                printf("IA ");
                break;
            }
            case E_IPJ_GPIO_MODE_OUTPUT_ACTION:
            {
                printf("OA ");
                break;
            }
            case E_IPJ_GPIO_MODE_OUTPUT_PULSE_ACTION:
            {
                printf("OPA");
                break;
            }
        }

        if (i < ARRAY_SIZE(gpio_report->gpio_modes) - 1)
            printf("|");
    }
    printf("\nGPIO States: ");

    for (i = 1; i < ARRAY_SIZE(gpio_report->gpio_states); i++)
    {
        switch (gpio_report->gpio_states[i])
        {
            case E_IPJ_GPIO_STATE_LO:
            case E_IPJ_GPIO_STATE_FLOAT:
            {
                printf("0  ");
                break;
            }
            case E_IPJ_GPIO_STATE_HI:
            {
                printf("1  ");
                break;
            }
        }

        if (i < ARRAY_SIZE(gpio_report->gpio_states) - 1)
            printf("|");
    }
    printf("\n");

    for (i = 0; i < 40; i++)
        printf("*");

    printf("\n");

    return E_IPJ_ERROR_SUCCESS;
}

ipj_error ipj_util_error_report_handler(
        ipj_iri_device* iri_device,
        ipj_error_report* error_report)
{
    printf("Error Report\n");
    printf("Error:  0x%X, %d\n", error_report->error, error_report->error);
    printf("Param1: 0x%X, %d\n", error_report->param1, error_report->param1);
    printf("Param2: 0x%X, %d\n", error_report->param2, error_report->param2);
    printf("Param3: 0x%X, %d\n", error_report->param3, error_report->param3);
    printf("Param4: 0x%X, %d\n", error_report->param4, error_report->param4);
    return E_IPJ_ERROR_SUCCESS;
}

ipj_error ipj_util_status_report_handler(
        ipj_iri_device* iri_device,
        ipj_status_report* status_report)
{
    uint32_t i;
    printf("Status Report\n");
    printf("status_flag:  0x%X, %d\n", status_report->status_flag, status_report->status_flag);
    printf("status_1: 0x%X, %d\n",     status_report->status_1, status_report->status_1);
    printf("status_2: 0x%X, %d\n",     status_report->status_2, status_report->status_2);
    printf("status_3: 0x%X, %d\n",     status_report->status_3, status_report->status_3);

    printf("Additional Data:\n");
    for (i = 0; i < ARRAY_SIZE(status_report->data); i++)
    {
        printf("[%d] 0x%X, %d\n", i, status_report->data[i], status_report->data[i]);
    }

    return E_IPJ_ERROR_SUCCESS;
}

ipj_error ipj_util_test_report_handler(
        ipj_iri_device* iri_device,
        ipj_test_report* test_report)
{
    uint32_t i;
    if (test_report->error != E_IPJ_ERROR_SUCCESS)
    {
        IPJ_UTIL_PRINT_ERROR(test_report->error, "test");
    }

    printf("\n*** %s Test Report ***\n", (char*) iri_device->reader_identifier);
    printf("Test ID: %d\n", test_report->test_id);
    printf("Test Results (optional):\n");
    printf("Result 1: 0x%X, %d\n", test_report->result_1, test_report->result_1);
    printf("Result 2: 0x%X, %d\n", test_report->result_2, test_report->result_2);
    printf("Result 3: 0x%X, %d\n", test_report->result_3, test_report->result_3);
    printf("Additional Data:\n");

    for (i = 0; i < ARRAY_SIZE(test_report->data); i++)
    {
        printf("[%d] 0x%X, %d\n", i, test_report->data[i], test_report->data[i]);
    }

    return E_IPJ_ERROR_SUCCESS;
}