diff --git a/flake.nix b/flake.nix index 0ef8c4b..92ed48e 100644 --- a/flake.nix +++ b/flake.nix @@ -47,6 +47,9 @@ zls lldb + # deps + duckdb + # linters octoscan diff --git a/vendor/libltkc/examples/CMakeLists.txt b/vendor/libltkc/examples/CMakeLists.txt new file mode 100644 index 0000000..55d63ee --- /dev/null +++ b/vendor/libltkc/examples/CMakeLists.txt @@ -0,0 +1,3 @@ +cmake_minimum_required(VERSION 3.9) +project(docsamples) +add_subdirectory(docsample1) diff --git a/vendor/libltkc/examples/README.md b/vendor/libltkc/examples/README.md new file mode 100644 index 0000000..96ecec8 --- /dev/null +++ b/vendor/libltkc/examples/README.md @@ -0,0 +1,49 @@ +# Impinj Example Application + +## Overview + +This example illustrates using CMake to build an Impinj Reader application for +host (i.e. x86\_64) and Impinj Reader CPU architectures. The example +application uses Impinj LTK libraries that are found inside the ETK. The +'build.sh' script is intended to be run from within the Impinj ETK. + +The ETK contains: + * a cross compilation toolchain that targets an Impinj Reader architecture + * libraries built for an Impinj Reader architecture + * host architecture versions of libraries to allow host builds for faster + development and debugging) + +## Building + +To build the project, call the build script from the command line: + +```bash +[user@machine]$ ./build.sh +``` + +The script accepts overrides for certain variables. See 'build.sh' for more +information. + +## Running + +To run on the host machine, simply run the exectuable: + +```bash +[user@machine]$ output/host/docsample1/docsample1 ${READER_HOSTNAME} +``` + +To run on an Impinj Reader, e.g. an R700, copy the binary to the Reader and +execute it: + +```bash +[user@machine]$ ssh root@r700 +Password: ******** +> + +# drop in to osshell +> osshell + +# copy the binary and execute it +root@r700:~# scp user@machine:/path/to/output/target/docsample1/docsample1 /tmp +root@r700:~# /tmp/docsample1 localhost +``` diff --git a/vendor/libltkc/examples/build.sh b/vendor/libltkc/examples/build.sh new file mode 100755 index 0000000..4810010 --- /dev/null +++ b/vendor/libltkc/examples/build.sh @@ -0,0 +1,49 @@ +#!/bin/bash -eu + +# +# Example build script for use with Impinj ETK +# +# The target libraries are contained inside the sysroot at +# "$ETK_ROOT/arm-buildroot-linux-gnueabihf/sysroot/lib". The host libraries +# are contained in "$ETK_ROOT/lib". +# +# For a host build, CMake must be configured to correctly search for host +# headers and libraries in the correct location inside the ETK. +# +# For a target build, CMake must be configured to use the correct cross +# compiler and informed about the sysroot location in the ETK. +# +# The script allows overriding some variables when building, e.g.: +# +# [user@machine]$ BUILD_TYPE=Release VERBOSE=ON ./build.sh +# + +SCRIPT_PATH=$(dirname $(realpath $0)) +OUTPUT_PATH=${SCRIPT_PATH}/output + +# defaults when building with ETK; override on command line for custom setup +ETK_PATH=${ETK_PATH:-$(realpath ${SCRIPT_PATH}/../../arm-toolchain)} +BUILD_TYPE=${BUILD_TYPE:-Debug} +VERBOSE=${VERBOSE:-OFF} + +# host build; override on command line for custom setup +INC=${INC:-${ETK_PATH}/include} +LIB=${LIB:-${ETK_PATH}/lib} +cmake ${SCRIPT_PATH} -B"${OUTPUT_PATH}/host" \ + -DCMAKE_VERBOSE_MAKEFILE:BOOL=${VERBOSE} \ + -DCMAKE_BUILD_TYPE=${BUILD_TYPE} \ + -DCMAKE_C_FLAGS="-isystem ${INC}" \ + -DCMAKE_LIBRARY_PATH=${LIB} +cmake --build "${OUTPUT_PATH}/host" + +# target build +CC=$(find ${ETK_PATH}/bin -name arm-*-linux-*-gcc) +CC=${CC%gcc} +SYSROOT_PATH="$(${CC}gcc -print-sysroot)" +cmake ${SCRIPT_PATH} -B"${OUTPUT_PATH}/target" \ + -DCMAKE_VERBOSE_MAKEFILE:BOOL=${VERBOSE} \ + -DCMAKE_BUILD_TYPE=${BUILD_TYPE} \ + -DCMAKE_C_COMPILER=${CC}gcc \ + -DCMAKE_CXX_COMPILER=${CC}g++ \ + -DCMAKE_FIND_ROOT_PATH=${SYSROOT_PATH} +cmake --build "${OUTPUT_PATH}/target" diff --git a/vendor/libltkc/examples/docsample1/CMakeLists.txt b/vendor/libltkc/examples/docsample1/CMakeLists.txt new file mode 100644 index 0000000..13dcd65 --- /dev/null +++ b/vendor/libltkc/examples/docsample1/CMakeLists.txt @@ -0,0 +1,28 @@ +# +# This example statically links when possible. While not required, it is meant +# to illustrate how to handle both static and dynamic linking. Note that +# producing a fully statically linked application (i.e. linking with '-static') +# will raise a _lot_ of issues, if it works at all, and is not recommended. +# + +cmake_minimum_required(VERSION 3.9) +project(docsample1) + +find_library(LIBLTKC libltkc.a REQUIRED) +find_library(LIBLTKC_IMPINJ libltkcimpinj.a REQUIRED) +# it is not recommended to statically link for ssl and crypto libraries +find_library(LIBSSL ssl REQUIRED) +find_library(LIBCRYPTO crypto REQUIRED) +# The ETK does not contain a host static library for xml2. Add the generic +# name 'xml2' to link against the dynmaic library when compiling for host. +find_library(LIBXML2 NAMES libxml2.a xml2 REQUIRED) +set(LIBS + ${LIBLTKC} + ${LIBLTKC_IMPINJ} + ${LIBXML2} + ${LIBCRYPTO} + ${LIBSSL} +) + +add_executable(${PROJECT_NAME} ${PROJECT_NAME}.c) +target_link_libraries(${PROJECT_NAME} PRIVATE ${LIBS}) diff --git a/vendor/libltkc/examples/docsample1/docsample1.c b/vendor/libltkc/examples/docsample1/docsample1.c new file mode 100755 index 0000000..629a71c --- /dev/null +++ b/vendor/libltkc/examples/docsample1/docsample1.c @@ -0,0 +1,1921 @@ + +/* + ***************************************************************************** + * * + * IMPINJ CONFIDENTIAL AND PROPRIETARY * + * * + * This source code is the sole property of Impinj, Inc. Reproduction or * + * utilization of this source code in whole or in part is forbidden without * + * the prior written consent of Impinj, Inc. * + * * + * (c) Copyright Impinj, Inc. 2007,2008. All rights reserved. * + * * + *****************************************************************************/ + +/** + ***************************************************************************** + ** + ** @file docsample1.c + ** + ** @brief Simple example of LTKC that talks to an actual reader + ** + ** This is sometimes called the "LLRP Hello World" program + ** + ** The steps: + ** - Connect to the reader (TCP) + ** - Make sure the connection status is good + ** - Clear (scrub) the reader configuration + ** - Add and enable a ROSpec that does a simple operation + ** - Uses mostly default settings except for ROReportSpec + ** - Uses all antennas + ** - Starts on command + ** - Runs for 5 seconds + ** - Reports all accumulated tag observations + ** - Run the ROSpec 5 times + ** - Clear (scrub) the reader configuration + ** + ** This program can be run with zero, one, or two verbose options (-v). + ** no -v -- Only prints the tag report and errors + ** -v -- Also prints one line progress messages + ** -vv -- Also prints all LLRP messages as XML text + ** + ** IMPORTANT: + ** This example was written before best practices were determined. + ** Most of the command messages (including subparameters) are + ** composed using local (auto) variables with initializers. + ** It has been determined that this approach has drawbacks. + ** Best practice is to use the constructor and accessors. + ** + ** Function deleteAllROSpecs() was recoded to demonstrate + ** good technique. Someday we might be able to fix the rest. + ** + *****************************************************************************/ + + +#include + +#include "ltkc.h" +#include "impinj_ltkc.h" + +/* + * BEGIN forward declarations + */ +int +main ( + int ac, + char * av[]); + +void +usage ( + char * pProgName); + +int +run ( + const char * pReaderHostName); + +int +checkConnectionStatus (void); + +int +scrubConfiguration (void); + +int +enableImpinjExtensions (void); + +int +resetConfigurationToFactoryDefaults (void); + +int +deleteAllROSpecs (void); + +int +addROSpec (void); + +int +enableROSpec (void); + +int +startROSpec (void); + +int +awaitAndPrintReport (void); + +void +printTagReportData ( + LLRP_tSRO_ACCESS_REPORT * pRO_ACCESS_REPORT); + +void +printOneTagReportData ( + LLRP_tSTagReportData * pTagReportData); + +void +handleReaderEventNotification ( + LLRP_tSReaderEventNotificationData *pNtfData); + +void +handleAntennaEvent ( + LLRP_tSAntennaEvent * pAntennaEvent); + +void +handleReaderExceptionEvent ( + LLRP_tSReaderExceptionEvent * pReaderExceptionEvent); + +int +checkLLRPStatus ( + LLRP_tSLLRPStatus * pLLRPStatus, + char * pWhatStr); + +LLRP_tSMessage * +transact ( + LLRP_tSMessage * pSendMsg); + +LLRP_tSMessage * +recvMessage ( + int nMaxMS); + +int +sendMessage ( + LLRP_tSMessage * pSendMsg); + +void +freeMessage ( + LLRP_tSMessage * pMessage); + +void +printXMLMessage ( + LLRP_tSMessage * pMessage); + +/* + * END forward declarations + */ + + +/* + * Global variables + */ +/** Verbose level, incremented by each -v on command line */ +int g_Verbose; +/** Connection to the LLRP reader */ +LLRP_tSConnection * g_pConnectionToReader; + + + +/** + ***************************************************************************** + ** + ** @brief Command main routine + ** + ** Command synopsis: + ** + ** dx201 READERHOSTNAME + ** + ** @exitcode 0 Everything *seemed* to work. + ** 1 Bad usage + ** 2 Run failed + ** + *****************************************************************************/ + +int +main ( + int ac, + char * av[]) +{ + char * pReaderHostName; + int rc; + + /* + * Process comand arguments, determine reader name + * and verbosity level. + */ + if(ac == 2) + { + pReaderHostName = av[1]; + } + else if(ac == 3) + { + char * p = av[1]; + + while(*p) + { + switch(*p++) + { + case '-': /* linux conventional option warn char */ + case '/': /* Windows/DOS conventional option warn char */ + break; + + case 'v': + case 'V': + g_Verbose++; + break; + + default: + usage(av[0]); + /* no return */ + break; + } + } + + pReaderHostName = av[2]; + } + else + { + usage(av[0]); + /* no return */ + } + + /* + * Run application, capture return value for exit status + */ + rc = run(pReaderHostName); + + printf("INFO: Done\n"); + + /* + * Exit with the right status. + */ + if(0 == rc) + { + exit(0); + } + else + { + exit(2); + } + /*NOTREACHED*/ +} + + +/** + ***************************************************************************** + ** + ** @brief Print usage message and exit + ** + ** @param[in] nProgName Program name string + ** + ** @return none, exits + ** + *****************************************************************************/ + +void +usage ( + char * pProgName) +{ + printf("Usage: %s [-v] READERHOSTNAME\n", pProgName); + printf("\n"); + printf("Each -v increases verbosity level\n"); + exit(1); +} + + +/** + ***************************************************************************** + ** + ** @brief Run the application + ** + ** The steps: + ** - Instantiate connection + ** - Connect to LLRP reader (TCP) + ** - Make sure the connection status is good + ** - Clear (scrub) the reader configuration + ** - Configure for what we want to do + ** - Run inventory operation 5 times + ** - Again, clear (scrub) the reader configuration + ** - Disconnect from reader + ** - Destruct connection + ** + ** @param[in] pReaderHostName String with reader name + ** + ** @return 0 Everything worked. + ** -1 Failed allocation of type registry + ** -2 Failed construction of connection + ** -3 Could not connect to reader + ** 1 Reader connection status bad + ** 2 Cleaning reader config failed + ** 3 Enable Impinj Extensions failed + ** 4 Adding ROSpec failed + ** 5 Enabling ROSpec failed + ** 6 Something went wrong running the ROSpec + ** + *****************************************************************************/ + +int +run ( + const char * pReaderHostName) +{ + LLRP_tSTypeRegistry * pTypeRegistry; + LLRP_tSConnection * pConn; + int rc; + + /* + * Allocate the type registry. This is needed + * by the connection to decode. + */ + pTypeRegistry = LLRP_getTheTypeRegistry(); + if(NULL == pTypeRegistry) + { + printf("ERROR: getTheTypeRegistry failed\n"); + return -1; + } + + /* + * Enroll impinj extension types into the + * type registry, in praparation for using + * Impinj extension params. + */ + LLRP_enrollImpinjTypesIntoRegistry(pTypeRegistry); + + /* + * Construct a connection (LLRP_tSConnection). + * Using a 32kb max frame size for send/recv. + * The connection object is ready for business + * but not actually connected to the reader yet. + */ + pConn = LLRP_Conn_construct(pTypeRegistry, 32u*1024u); + if(NULL == pConn) + { + printf("ERROR: Conn_construct failed\n"); + return -2; + } + + /* + * Open the connection to the reader + */ + if(g_Verbose) + { + printf("INFO: Connecting to %s....\n", pReaderHostName); + } + + rc = LLRP_Conn_openConnectionToReader(pConn, pReaderHostName); + if(0 != rc) + { + printf("ERROR: connect: %s (%d)\n", pConn->pConnectErrorStr, rc); + LLRP_Conn_destruct(pConn); + return -3; + } + + /* + * Record the pointer to the connection object so other + * routines can use it. + */ + g_pConnectionToReader = pConn; + + if(g_Verbose) + { + printf("INFO: Connected, checking status....\n"); + } + + /* + * Commence the sequence and check for errors as we go. + * See comments for each routine for details. + * Each routine prints messages per verbose level. + */ + rc = 1; + if(0 == checkConnectionStatus()) + { + rc = 2; + if(0 == scrubConfiguration()) + { + rc = 3; + if(0 == enableImpinjExtensions()) + { + rc = 4; + if(0 == addROSpec()) + { + rc = 5; + if(0 == enableROSpec()) + { + int i; + + rc = 6; + + for(i = 1; i <= 5; i++) + { + printf("INFO: Starting run %d ================\n", i); + if(0 != startROSpec()) + { + /* already tattled */ + break; + } + if(0 != awaitAndPrintReport()) + { + /* already tattled */ + break; + } + } + + if(i == 5) + { + rc = 0; + } + } + } + } + /* + * After we're done, try to leave the reader + * in a clean state for next use. This is best + * effort and no checking of the result is done. + */ + if(g_Verbose) + { + printf("INFO: Clean up reader configuration...\n"); + } + scrubConfiguration(); + } + } + + if(g_Verbose) + { + printf("INFO: Finished\n"); + } + + /* + * Close the connection and release its resources + */ + LLRP_Conn_closeConnectionToReader(pConn); + LLRP_Conn_destruct(pConn); + + /* + * Done with the registry. + */ + LLRP_TypeRegistry_destruct(pTypeRegistry); + + /* + * When we get here all allocated memory should have been deallocated. + */ + + return rc; +} + + +/** + ***************************************************************************** + ** + ** @brief Await and check the connection status message from the reader + ** + ** We are expecting a READER_EVENT_NOTIFICATION message that + ** tells us the connection is OK. The reader is suppose to + ** send the message promptly upon connection. + ** + ** If there is already another LLRP connection to the + ** reader we'll get a bad Status. + ** + ** The message should be something like: + ** + ** + ** + ** + ** 1184491439614224 + ** + ** + ** Success + ** + ** + ** + ** + ** @return ==0 Everything OK + ** !=0 Something went wrong + ** + *****************************************************************************/ + +int +checkConnectionStatus (void) +{ + LLRP_tSMessage * pMessage; + LLRP_tSREADER_EVENT_NOTIFICATION *pNtf; + LLRP_tSReaderEventNotificationData *pNtfData; + LLRP_tSConnectionAttemptEvent *pEvent; + + /* + * Expect the notification within 10 seconds. + * It is suppose to be the very first message sent. + */ + pMessage = recvMessage(10000); + + /* + * recvMessage() returns NULL if something went wrong. + */ + if(NULL == pMessage) + { + /* recvMessage() already tattled. */ + goto fail; + } + + /* + * Check to make sure the message is of the right type. + * The type label (pointer) in the message should be + * the type descriptor for READER_EVENT_NOTIFICATION. + */ + if(&LLRP_tdREADER_EVENT_NOTIFICATION != pMessage->elementHdr.pType) + { + goto fail; + } + + /* + * Now that we are sure it is a READER_EVENT_NOTIFICATION, + * traverse to the ReaderEventNotificationData parameter. + */ + pNtf = (LLRP_tSREADER_EVENT_NOTIFICATION *) pMessage; + pNtfData = pNtf->pReaderEventNotificationData; + if(NULL == pNtfData) + { + goto fail; + } + + /* + * The ConnectionAttemptEvent parameter must be present. + */ + pEvent = pNtfData->pConnectionAttemptEvent; + if(NULL == pEvent) + { + goto fail; + } + + /* + * The status in the ConnectionAttemptEvent parameter + * must indicate connection success. + */ + if(LLRP_ConnectionAttemptStatusType_Success != pEvent->eStatus) + { + goto fail; + } + + /* + * Done with the message + */ + freeMessage(pMessage); + + if(g_Verbose) + { + printf("INFO: Connection status OK\n"); + } + + /* + * Victory. + */ + return 0; + + fail: + /* + * Something went wrong. Tattle. Clean up. Return error. + */ + printf("ERROR: checkConnectionStatus failed\n"); + freeMessage(pMessage); + return -1; +} + + +/** + ***************************************************************************** + ** + ** @brief Scrub the reader configuration + ** + ** The steps: + ** - Try to reset configuration to factory defaults, + ** this feature is optional and may not be supported + ** by the reader. + ** - Delete all ROSpecs + ** + ** @return ==0 Everything OK + ** !=0 Something went wrong + ** + *****************************************************************************/ + +int +scrubConfiguration (void) +{ + if(0 != resetConfigurationToFactoryDefaults()) + { + return -1; + } + + if(0 != deleteAllROSpecs()) + { + return -2; + } + + return 0; +} + + +/** + ***************************************************************************** + ** + ** @brief Enable Impinj extensions using IMPINJ_ENABLE_EXTENSIONS message + ** + ** This routine sends an IMPINJ_ENABLE_EXTENSIONS message. It then waits for + ** the IMPINJ_ENABLE_EXTENSIONS_RESPONSE message and checks everything is OK. + ** + ** @return ==0 Everything OK + ** !=0 Something went wrong + ** + *****************************************************************************/ +int +enableImpinjExtensions (void) +{ + LLRP_tSIMPINJ_ENABLE_EXTENSIONS Cmd = { + .hdr.elementHdr.pType = &LLRP_tdIMPINJ_ENABLE_EXTENSIONS, + .hdr.MessageID = 103, + }; + LLRP_tSMessage * pRspMsg; + LLRP_tSIMPINJ_ENABLE_EXTENSIONS_RESPONSE *pRsp; + + /* + * Send the message, expect the response of certain type + */ + pRspMsg = transact(&Cmd.hdr); + if(NULL == pRspMsg) + { + /* transact already tattled */ + return -1; + } + + /* + * Cast to a LLRP_tSIMPINJ_ENABLE_EXTENSIONS_RESPONSE message. + */ + pRsp = (LLRP_tSIMPINJ_ENABLE_EXTENSIONS_RESPONSE *) pRspMsg; + + /* + * Check the LLRPStatus parameter. + */ + if(0 != checkLLRPStatus(pRsp->pLLRPStatus, "enableImpinjExtensions")) + { + /* checkLLRPStatus already tattled */ + freeMessage(pRspMsg); + return -1; + } + + /* + * Done with the response message. + */ + freeMessage(pRspMsg); + + /* + * Tattle progress, maybe + */ + if(g_Verbose) + { + printf("INFO: ImpinjExtension enabled\n"); + } + + /* + * Victory. + */ + return 0; +} + +/** + ***************************************************************************** + ** + ** @brief Send a SET_READER_CONFIG message that resets the + ** reader to factory defaults. + ** + ** NB: The ResetToFactoryDefault semantics vary between readers. + ** It might have no effect because it is optional. + ** + ** The message is: + ** + ** + ** 1 + ** + ** + ** @return ==0 Everything OK + ** !=0 Something went wrong + ** + *****************************************************************************/ + +int +resetConfigurationToFactoryDefaults (void) +{ + LLRP_tSSET_READER_CONFIG Cmd = { + .hdr.elementHdr.pType = &LLRP_tdSET_READER_CONFIG, + .hdr.MessageID = 101, + + .ResetToFactoryDefault = 1 + }; + LLRP_tSMessage * pRspMsg; + LLRP_tSSET_READER_CONFIG_RESPONSE *pRsp; + + /* + * Send the message, expect the response of certain type + */ + pRspMsg = transact(&Cmd.hdr); + if(NULL == pRspMsg) + { + /* transact already tattled */ + return -1; + } + + /* + * Cast to a SET_READER_CONFIG_RESPONSE message. + */ + pRsp = (LLRP_tSSET_READER_CONFIG_RESPONSE *) pRspMsg; + + /* + * Check the LLRPStatus parameter. + */ + if(0 != checkLLRPStatus(pRsp->pLLRPStatus, + "resetConfigurationToFactoryDefaults")) + { + /* checkLLRPStatus already tattled */ + freeMessage(pRspMsg); + return -1; + } + + /* + * Done with the response message. + */ + freeMessage(pRspMsg); + + /* + * Tattle progress, maybe + */ + if(g_Verbose) + { + printf("INFO: Configuration reset to factory defaults\n"); + } + + /* + * Victory. + */ + return 0; +} + + +/** + ***************************************************************************** + ** + ** @brief Delete all ROSpecs using DELETE_ROSPEC message + ** + ** Per the spec, the DELETE_ROSPEC message contains an ROSpecID + ** of 0 to indicate we want all ROSpecs deleted. + ** + ** The message is + ** + ** + ** 0 + ** + ** + ** @return ==0 Everything OK + ** !=0 Something went wrong + ** + ** IMPORANT: + ** The coding of this function demonstrates best practices. + ** Please see IMPORTANT comment at the top of this file. + ** + *****************************************************************************/ + +int +deleteAllROSpecs (void) +{ + LLRP_tSDELETE_ROSPEC * pCmd; + LLRP_tSMessage * pCmdMsg; + LLRP_tSMessage * pRspMsg; + LLRP_tSDELETE_ROSPEC_RESPONSE *pRsp; + + /* + * Compose the command message + */ + pCmd = LLRP_DELETE_ROSPEC_construct(); + pCmdMsg = &pCmd->hdr; + LLRP_Message_setMessageID(pCmdMsg, 102); + LLRP_DELETE_ROSPEC_setROSpecID(pCmd, 0); /* All */ + + /* + * Send the message, expect the response of certain type + */ + pRspMsg = transact(pCmdMsg); + + /* + * Done with the command message + */ + freeMessage(pCmdMsg); + + /* + * transact() returns NULL if something went wrong. + */ + if(NULL == pRspMsg) + { + /* transact already tattled */ + return -1; + } + + /* + * Cast to a DELETE_ROSPEC_RESPONSE message. + */ + pRsp = (LLRP_tSDELETE_ROSPEC_RESPONSE *) pRspMsg; + + /* + * Check the LLRPStatus parameter. + */ + if(0 != checkLLRPStatus(pRsp->pLLRPStatus, "deleteAllROSpecs")) + { + /* checkLLRPStatus already tattled */ + freeMessage(pRspMsg); + return -1; + } + + /* + * Done with the response message. + */ + freeMessage(pRspMsg); + + /* + * Tattle progress, maybe + */ + if(g_Verbose) + { + printf("INFO: All ROSpecs are deleted\n"); + } + + /* + * Victory. + */ + return 0; +} + + +/** + ***************************************************************************** + ** + ** @brief Add our ROSpec using ADD_ROSPEC message + ** + ** This ROSpec waits for a START_ROSPEC message, + ** then takes inventory on all antennas for 5 seconds. + ** + ** The tag report is generated after the ROSpec is done. + ** + ** This example is deliberately streamlined. + ** Nothing here configures the antennas, RF, or Gen2. + ** The current defaults are used. Remember we just reset + ** the reader to factory defaults (above). Normally an + ** application would be more precise in configuring the + ** reader and in its ROSpecs. + ** + ** Experience suggests that typical ROSpecs are about + ** double this in size. + ** + ** The message is + ** + ** + ** + ** 123 + ** 0 + ** Disabled + ** + ** + ** Null + ** + ** + ** Null + ** 0 + ** + ** + ** + ** 0 + ** + ** Duration + ** 5000 + ** + ** + ** 1234 + ** EPCGlobalClass1Gen2 + ** + ** + ** + ** Upon_N_Tags_Or_End_Of_ROSpec + ** 0 + ** + ** 0 + ** 0 + ** 0 + ** 0 + ** 0 + ** 0 + ** 0 + ** 0 + ** 0 + ** 0 + ** + ** + ** + ** + ** + ** @return ==0 Everything OK + ** !=0 Something went wrong + ** + *****************************************************************************/ + +int +addROSpec (void) +{ + LLRP_tSROSpecStartTrigger ROSpecStartTrigger = { + .hdr.elementHdr.pType = &LLRP_tdROSpecStartTrigger, + + .eROSpecStartTriggerType = LLRP_ROSpecStartTriggerType_Null, + }; + LLRP_tSROSpecStopTrigger ROSpecStopTrigger = { + .hdr.elementHdr.pType = &LLRP_tdROSpecStopTrigger, + + .eROSpecStopTriggerType = LLRP_ROSpecStopTriggerType_Null, + .DurationTriggerValue = 0 /* n/a */ + }; + LLRP_tSROBoundarySpec ROBoundarySpec = { + .hdr.elementHdr.pType = &LLRP_tdROBoundarySpec, + + .pROSpecStartTrigger = &ROSpecStartTrigger, + .pROSpecStopTrigger = &ROSpecStopTrigger, + }; + llrp_u16_t AntennaIDs[1] = { 0 }; /* All */ + LLRP_tSAISpecStopTrigger AISpecStopTrigger = { + .hdr.elementHdr.pType = &LLRP_tdAISpecStopTrigger, + + .eAISpecStopTriggerType = LLRP_AISpecStopTriggerType_Duration, + .DurationTrigger = 5000, + }; + LLRP_tSInventoryParameterSpec InventoryParameterSpec = { + .hdr.elementHdr.pType = &LLRP_tdInventoryParameterSpec, + + .InventoryParameterSpecID = 1234, + .eProtocolID = LLRP_AirProtocols_EPCGlobalClass1Gen2, + }; + LLRP_tSAISpec AISpec = { + .hdr.elementHdr.pType = &LLRP_tdAISpec, + + .AntennaIDs = { + .nValue = 1, + .pValue = AntennaIDs + }, + .pAISpecStopTrigger = &AISpecStopTrigger, + .listInventoryParameterSpec = &InventoryParameterSpec, + }; + LLRP_tSTagReportContentSelector TagReportContentSelector = { + .hdr.elementHdr.pType = &LLRP_tdTagReportContentSelector, + + .EnableROSpecID = 0, + .EnableSpecIndex = 0, + .EnableInventoryParameterSpecID = 0, + .EnableAntennaID = 0, + .EnableChannelIndex = 0, + .EnablePeakRSSI = 0, + .EnableFirstSeenTimestamp = 0, + .EnableLastSeenTimestamp = 0, + .EnableTagSeenCount = 0, + .EnableAccessSpecID = 0, + }; + LLRP_tSROReportSpec ROReportSpec = { + .hdr.elementHdr.pType = &LLRP_tdROReportSpec, + + .eROReportTrigger = + LLRP_ROReportTriggerType_Upon_N_Tags_Or_End_Of_ROSpec, + .N = 0, + .pTagReportContentSelector = &TagReportContentSelector, + }; + LLRP_tSROSpec ROSpec = { + .hdr.elementHdr.pType = &LLRP_tdROSpec, + + .ROSpecID = 123, + .Priority = 0, + .eCurrentState = LLRP_ROSpecState_Disabled, + .pROBoundarySpec = &ROBoundarySpec, + .listSpecParameter = &AISpec.hdr, + .pROReportSpec = &ROReportSpec, + }; + LLRP_tSADD_ROSPEC Cmd = { + .hdr.elementHdr.pType = &LLRP_tdADD_ROSPEC, + + .hdr.MessageID = 201, + .pROSpec = &ROSpec, + }; + LLRP_tSMessage * pRspMsg; + LLRP_tSADD_ROSPEC_RESPONSE *pRsp; + + /* + * Send the message, expect the response of certain type + */ + pRspMsg = transact(&Cmd.hdr); + if(NULL == pRspMsg) + { + /* transact already tattled */ + return -1; + } + + /* + * Cast to a ADD_ROSPEC_RESPONSE message. + */ + pRsp = (LLRP_tSADD_ROSPEC_RESPONSE *) pRspMsg; + + /* + * Check the LLRPStatus parameter. + */ + if(0 != checkLLRPStatus(pRsp->pLLRPStatus, "addROSpec")) + { + /* checkLLRPStatus already tattled */ + freeMessage(pRspMsg); + return -1; + } + + /* + * Done with the response message. + */ + freeMessage(pRspMsg); + + /* + * Tattle progress, maybe + */ + if(g_Verbose) + { + printf("INFO: ROSpec added\n"); + } + + /* + * Victory. + */ + return 0; +} + + +/** + ***************************************************************************** + ** + ** @brief Enable our ROSpec using ENABLE_ROSPEC message + ** + ** Enable the ROSpec that was added above. + ** + ** The message we send is: + ** + ** 123 + ** + ** + ** @return ==0 Everything OK + ** !=0 Something went wrong + ** + *****************************************************************************/ + +int +enableROSpec (void) +{ + LLRP_tSENABLE_ROSPEC Cmd = { + .hdr.elementHdr.pType = &LLRP_tdENABLE_ROSPEC, + .hdr.MessageID = 202, + + .ROSpecID = 123, + }; + LLRP_tSMessage * pRspMsg; + LLRP_tSENABLE_ROSPEC_RESPONSE *pRsp; + + /* + * Send the message, expect the response of certain type + */ + pRspMsg = transact(&Cmd.hdr); + if(NULL == pRspMsg) + { + /* transact already tattled */ + return -1; + } + + /* + * Cast to a ENABLE_ROSPEC_RESPONSE message. + */ + pRsp = (LLRP_tSENABLE_ROSPEC_RESPONSE *) pRspMsg; + + /* + * Check the LLRPStatus parameter. + */ + if(0 != checkLLRPStatus(pRsp->pLLRPStatus, "enableROSpec")) + { + /* checkLLRPStatus already tattled */ + freeMessage(pRspMsg); + return -1; + } + + /* + * Done with the response message. + */ + freeMessage(pRspMsg); + + /* + * Tattle progress, maybe + */ + if(g_Verbose) + { + printf("INFO: ROSpec enabled\n"); + } + + /* + * Victory. + */ + return 0; +} + + +/** + ***************************************************************************** + ** + ** @brief Start our ROSpec using START_ROSPEC message + ** + ** Start the ROSpec that was added above. + ** + ** The message we send is: + ** + ** 123 + ** + ** + ** @return ==0 Everything OK + ** !=0 Something went wrong + ** + *****************************************************************************/ + +int +startROSpec (void) +{ + LLRP_tSSTART_ROSPEC Cmd = { + .hdr.elementHdr.pType = &LLRP_tdSTART_ROSPEC, + .hdr.MessageID = 202, + + .ROSpecID = 123, + }; + LLRP_tSMessage * pRspMsg; + LLRP_tSSTART_ROSPEC_RESPONSE *pRsp; + + /* + * Send the message, expect the response of certain type + */ + pRspMsg = transact(&Cmd.hdr); + if(NULL == pRspMsg) + { + /* transact already tattled */ + return -1; + } + + /* + * Cast to a START_ROSPEC_RESPONSE message. + */ + pRsp = (LLRP_tSSTART_ROSPEC_RESPONSE *) pRspMsg; + + /* + * Check the LLRPStatus parameter. + */ + if(0 != checkLLRPStatus(pRsp->pLLRPStatus, "startROSpec")) + { + /* checkLLRPStatus already tattled */ + freeMessage(pRspMsg); + return -1; + } + + /* + * Done with the response message. + */ + freeMessage(pRspMsg); + + /* + * Tattle progress, maybe + */ + if(g_Verbose) + { + printf("INFO: ROSpec started\n"); + } + + /* + * Victory. + */ + return 0; +} + +/** + ***************************************************************************** + ** + ** @brief Receive and print the RO_ACCESS_REPORT + ** + ** Receive messages until an RO_ACCESS_REPORT is received. + ** Time limit is 7 seconds. We expect a report within 5 seconds. + ** + ** This shows how to determine the type of a received message. + ** + ** @return ==0 Everything OK + ** !=0 Something went wrong + ** + *****************************************************************************/ + +int +awaitAndPrintReport (void) +{ + int bDone = 0; + int retVal = 0; + + /* + * Keep receiving messages until done or until + * something bad happens. + */ + while(!bDone) + { + LLRP_tSMessage * pMessage; + const LLRP_tSTypeDescriptor *pType; + + /* + * Wait up to 7 seconds for a message. The report + * should occur within 5 seconds. + */ + pMessage = recvMessage(7000); + if(NULL == pMessage) + { + /* + * Did not receive a message within a reasonable + * amount of time. recvMessage() already tattled + */ + retVal = -2; + bDone = 1; + continue; + } + + /* + * What happens depends on what kind of message + * received. Use the type label (pType) to + * discriminate message types. + */ + pType = pMessage->elementHdr.pType; + + /* + * Is it a tag report? If so, print it out. + */ + if(&LLRP_tdRO_ACCESS_REPORT == pType) + { + LLRP_tSRO_ACCESS_REPORT *pNtf; + + pNtf = (LLRP_tSRO_ACCESS_REPORT *) pMessage; + + printTagReportData(pNtf); + bDone = 1; + retVal = 0; + } + + /* + * Is it a reader event? This example only recognizes + * AntennaEvents. + */ + else if(&LLRP_tdREADER_EVENT_NOTIFICATION == pType) + { + LLRP_tSREADER_EVENT_NOTIFICATION *pNtf; + LLRP_tSReaderEventNotificationData *pNtfData; + + pNtf = (LLRP_tSREADER_EVENT_NOTIFICATION *) pMessage; + + pNtfData = + LLRP_READER_EVENT_NOTIFICATION_getReaderEventNotificationData( + pNtf); + + if(NULL != pNtfData) + { + handleReaderEventNotification(pNtfData); + } + else + { + /* + * This should never happen. Using continue + * to keep indent depth down. + */ + printf("WARNING: READER_EVENT_NOTIFICATION without data\n"); + } + } + + /* + * Hmmm. Something unexpected. Just tattle and keep going. + */ + else + { + printf("WARNING: Ignored unexpected message during monitor: %s\n", + pType->pName); + } + + /* + * Done with the received message + */ + freeMessage(pMessage); + } + + return retVal; +} + + +/** + ***************************************************************************** + ** + ** @brief Helper routine to print a tag report + ** + ** The report is printed in list order, which is arbitrary. + ** + ** TODO: It would be cool to sort the list by EPC and antenna, + ** then print it. + ** + ** @return void + ** + *****************************************************************************/ + +void +printTagReportData ( + LLRP_tSRO_ACCESS_REPORT * pRO_ACCESS_REPORT) +{ + LLRP_tSTagReportData * pTagReportData; + unsigned int nEntry = 0; + + /* + * Loop through and count the number of entries + */ + for( + pTagReportData = pRO_ACCESS_REPORT->listTagReportData; + NULL != pTagReportData; + pTagReportData = (LLRP_tSTagReportData *) + pTagReportData->hdr.pNextSubParameter) + { + nEntry++; + } + + printf("INFO: %u tag report entries\n", nEntry); + + /* + * Loop through again and print each entry. + */ + for( + pTagReportData = pRO_ACCESS_REPORT->listTagReportData; + NULL != pTagReportData; + pTagReportData = (LLRP_tSTagReportData *) + pTagReportData->hdr.pNextSubParameter) + { + printOneTagReportData(pTagReportData); + } +} + + +/** + ***************************************************************************** + ** + ** @brief Helper routine to print one tag report entry on one line + ** + ** @return void + ** + *****************************************************************************/ + +void +printOneTagReportData ( + LLRP_tSTagReportData * pTagReportData) +{ + const LLRP_tSTypeDescriptor *pType; + char aBuf[100*1024]; + + /* + * Print the EPC. It could be an 96-bit EPC_96 parameter + * or an variable length EPCData parameter. + */ + if(NULL != pTagReportData->pEPCParameter) + { + char * p = aBuf; + llrp_u8_t * pValue = NULL; + unsigned int n, i; + + pType = pTagReportData->pEPCParameter->elementHdr.pType; + if(&LLRP_tdEPC_96 == pType) + { + LLRP_tSEPC_96 * pE96; + + pE96 = (LLRP_tSEPC_96 *) pTagReportData->pEPCParameter; + pValue = pE96->EPC.aValue; + n = 12u; + } + else if(&LLRP_tdEPCData == pType) + { + LLRP_tSEPCData *pEPCData; + + pEPCData = (LLRP_tSEPCData *) pTagReportData->pEPCParameter; + pValue = pEPCData->EPC.pValue; + n = (pEPCData->EPC.nBit + 7u) / 8u; + } + + if(NULL != pValue) + { + for(i = 0; i < n; i++) + { + if(0 < i && i%2 == 0) + { + *p++ = '-'; + } + sprintf(p, "%02X", pValue[i]); + while(*p) p++; + } + } + else + { + strcpy(aBuf, "---unknown-epc-data-type---"); + } + } + else + { + strcpy(aBuf, "---missing-epc-data---"); + } + printf("%-32s", aBuf); + + /* + * End of line + */ + printf("\n"); +} + + +/** + ***************************************************************************** + ** + ** @brief Handle a ReaderEventNotification + ** + ** Handle the payload of a READER_EVENT_NOTIFICATION message. + ** This routine simply dispatches to handlers of specific + ** event types. + ** + ** @return void + ** + *****************************************************************************/ + +void +handleReaderEventNotification ( + LLRP_tSReaderEventNotificationData *pNtfData) +{ + LLRP_tSAntennaEvent * pAntennaEvent; + LLRP_tSReaderExceptionEvent *pReaderExceptionEvent; + int nReported = 0; + + pAntennaEvent = + LLRP_ReaderEventNotificationData_getAntennaEvent(pNtfData); + if(NULL != pAntennaEvent) + { + handleAntennaEvent(pAntennaEvent); + nReported++; + } + + pReaderExceptionEvent = + LLRP_ReaderEventNotificationData_getReaderExceptionEvent(pNtfData); + if(NULL != pReaderExceptionEvent) + { + handleReaderExceptionEvent(pReaderExceptionEvent); + nReported++; + } + + /* + * Similarly handle other events here: + * HoppingEvent + * GPIEvent + * ROSpecEvent + * ReportBufferLevelWarningEvent + * ReportBufferOverflowErrorEvent + * RFSurveyEvent + * AISpecEvent + * ConnectionAttemptEvent + * ConnectionCloseEvent + * Custom + */ + + if(0 == nReported) + { + printf("NOTICE: Unexpected (unhandled) ReaderEvent\n"); + } +} + + +/** + ***************************************************************************** + ** + ** @brief Handle an AntennaEvent + ** + ** An antenna was disconnected or (re)connected. Tattle. + ** + ** @return void + ** + *****************************************************************************/ + +void +handleAntennaEvent ( + LLRP_tSAntennaEvent * pAntennaEvent) +{ + LLRP_tEAntennaEventType eEventType; + llrp_u16_t AntennaID; + char * pStateStr; + + eEventType = LLRP_AntennaEvent_getEventType(pAntennaEvent); + AntennaID = LLRP_AntennaEvent_getAntennaID(pAntennaEvent); + + switch(eEventType) + { + case LLRP_AntennaEventType_Antenna_Disconnected: + pStateStr = "disconnected"; + break; + + case LLRP_AntennaEventType_Antenna_Connected: + pStateStr = "connected"; + break; + + default: + pStateStr = "?unknown-event?"; + break; + } + + printf("NOTICE: Antenna %d is %s\n", AntennaID, pStateStr); +} + + +/** + ***************************************************************************** + ** + ** @brief Handle a ReaderExceptionEvent + ** + ** Something has gone wrong. There are lots of details but + ** all this does is print the message, if one. + ** + ** @return void + ** + *****************************************************************************/ + +void +handleReaderExceptionEvent ( + LLRP_tSReaderExceptionEvent * pReaderExceptionEvent) +{ + llrp_utf8v_t Message; + + Message = LLRP_ReaderExceptionEvent_getMessage(pReaderExceptionEvent); + + if(0 < Message.nValue && NULL != Message.pValue) + { + printf("NOTICE: ReaderException '%.*s'\n", + Message.nValue, Message.pValue); + } + else + { + printf("NOTICE: ReaderException but no message\n"); + } +} + + +/** + ***************************************************************************** + ** + ** @brief Helper routine to check an LLRPStatus parameter + ** and tattle on errors + ** + ** Helper routine to interpret the LLRPStatus subparameter + ** that is in all responses. It tattles on an error, if one, + ** and tries to safely provide details. + ** + ** This simplifies the code, above, for common check/tattle + ** sequences. + ** + ** @return ==0 Everything OK + ** !=0 Something went wrong, already tattled + ** + *****************************************************************************/ + +int +checkLLRPStatus ( + LLRP_tSLLRPStatus * pLLRPStatus, + char * pWhatStr) +{ + /* + * The LLRPStatus parameter is mandatory in all responses. + * If it is missing there should have been a decode error. + * This just makes sure (remember, this program is a + * diagnostic and suppose to catch LTKC mistakes). + */ + if(NULL == pLLRPStatus) + { + printf("ERROR: %s missing LLRP status\n", pWhatStr); + return -1; + } + + /* + * Make sure the status is M_Success. + * If it isn't, print the error string if one. + * This does not try to pretty-print the status + * code. To get that, run this program with -vv + * and examine the XML output. + */ + if(LLRP_StatusCode_M_Success != pLLRPStatus->eStatusCode) + { + if(0 == pLLRPStatus->ErrorDescription.nValue) + { + printf("ERROR: %s failed, no error description given\n", + pWhatStr); + } + else + { + printf("ERROR: %s failed, %.*s\n", + pWhatStr, + pLLRPStatus->ErrorDescription.nValue, + pLLRPStatus->ErrorDescription.pValue); + } + return -2; + } + + /* + * Victory. Everything is fine. + */ + return 0; +} + + +/** + ***************************************************************************** + ** + ** @brief Wrapper routine to do an LLRP transaction + ** + ** Wrapper to transact a request/resposne. + ** - Print the outbound message in XML if verbose level is at least 2 + ** - Send it using the LLRP_Conn_transact() + ** - LLRP_Conn_transact() receives the response or recognizes an error + ** - Tattle on errors, if any + ** - Print the received message in XML if verbose level is at least 2 + ** - If the response is ERROR_MESSAGE, the request was sufficiently + ** misunderstood that the reader could not send a proper reply. + ** Deem this an error, free the message. + ** + ** The message returned resides in allocated memory. It is the + ** caller's obligtation to free it. + ** + ** @return ==NULL Something went wrong, already tattled + ** !=NULL Pointer to a message + ** + *****************************************************************************/ + +LLRP_tSMessage * +transact ( + LLRP_tSMessage * pSendMsg) +{ + LLRP_tSConnection * pConn = g_pConnectionToReader; + LLRP_tSMessage * pRspMsg; + + /* + * Print the XML text for the outbound message if + * verbosity is 2 or higher. + */ + if(1 < g_Verbose) + { + printf("\n===================================\n"); + printf("INFO: Transact sending\n"); + printXMLMessage(pSendMsg); + } + + /* + * Send the message, expect the response of certain type. + * If LLRP_Conn_transact() returns NULL then there was + * an error. In that case we try to print the error details. + */ + pRspMsg = LLRP_Conn_transact(pConn, pSendMsg, 5000); + if(NULL == pRspMsg) + { + const LLRP_tSErrorDetails *pError = LLRP_Conn_getTransactError(pConn); + + printf("ERROR: %s transact failed, %s\n", + pSendMsg->elementHdr.pType->pName, + pError->pWhatStr ? pError->pWhatStr : "no reason given"); + + if(NULL != pError->pRefType) + { + printf("ERROR: ... reference type %s\n", + pError->pRefType->pName); + } + + if(NULL != pError->pRefField) + { + printf("ERROR: ... reference field %s\n", + pError->pRefField->pName); + } + + return NULL; + } + + /* + * Print the XML text for the inbound message if + * verbosity is 2 or higher. + */ + if(1 < g_Verbose) + { + printf("\n- - - - - - - - - - - - - - - - - -\n"); + printf("INFO: Transact received response\n"); + printXMLMessage(pRspMsg); + } + + /* + * If it is an ERROR_MESSAGE (response from reader + * when it can't understand the request), tattle + * and declare defeat. + */ + if(&LLRP_tdERROR_MESSAGE == pRspMsg->elementHdr.pType) + { + const LLRP_tSTypeDescriptor *pResponseType; + + pResponseType = pSendMsg->elementHdr.pType->pResponseType; + + printf("ERROR: Received ERROR_MESSAGE instead of %s\n", + pResponseType->pName); + freeMessage(pRspMsg); + pRspMsg = NULL; + } + + return pRspMsg; +} + + +/** + ***************************************************************************** + ** + ** @brief Wrapper routine to receive a message + ** + ** This can receive notifications as well as responses. + ** - Recv a message using the LLRP_Conn_recvMessage() + ** - Tattle on errors, if any + ** - Print the message in XML if verbose level is at least 2 + ** + ** The message returned resides in allocated memory. It is the + ** caller's obligtation to free it. + ** + ** @param[in] nMaxMS -1 => block indefinitely + ** 0 => just peek at input queue and + ** socket queue, return immediately + ** no matter what + ** >0 => ms to await complete frame + ** + ** @return ==NULL Something went wrong, already tattled + ** !=NULL Pointer to a message + ** + *****************************************************************************/ + +LLRP_tSMessage * +recvMessage ( + int nMaxMS) +{ + LLRP_tSConnection * pConn = g_pConnectionToReader; + LLRP_tSMessage * pMessage; + + /* + * Receive the message subject to a time limit + */ + pMessage = LLRP_Conn_recvMessage(pConn, nMaxMS); + + /* + * If LLRP_Conn_recvMessage() returns NULL then there was + * an error. In that case we try to print the error details. + */ + if(NULL == pMessage) + { + const LLRP_tSErrorDetails *pError = LLRP_Conn_getRecvError(pConn); + + printf("ERROR: recvMessage failed, %s\n", + pError->pWhatStr ? pError->pWhatStr : "no reason given"); + + if(NULL != pError->pRefType) + { + printf("ERROR: ... reference type %s\n", + pError->pRefType->pName); + } + + if(NULL != pError->pRefField) + { + printf("ERROR: ... reference field %s\n", + pError->pRefField->pName); + } + + return NULL; + } + + /* + * Print the XML text for the inbound message if + * verbosity is 2 or higher. + */ + if(1 < g_Verbose) + { + printf("\n===================================\n"); + printf("INFO: Message received\n"); + printXMLMessage(pMessage); + } + + return pMessage; +} + + +/** + ***************************************************************************** + ** + ** @brief Wrapper routine to send a message + ** + ** Wrapper to send a message. + ** - Print the message in XML if verbose level is at least 2 + ** - Send it using the LLRP_Conn_sendMessage() + ** - Tattle on errors, if any + ** + ** @param[in] pSendMsg Pointer to message to send + ** + ** @return ==0 Everything OK + ** !=0 Something went wrong, already tattled + ** + *****************************************************************************/ + +int +sendMessage ( + LLRP_tSMessage * pSendMsg) +{ + LLRP_tSConnection * pConn = g_pConnectionToReader; + + /* + * Print the XML text for the outbound message if + * verbosity is 2 or higher. + */ + if(1 < g_Verbose) + { + printf("\n===================================\n"); + printf("INFO: Sending\n"); + printXMLMessage(pSendMsg); + } + + /* + * If LLRP_Conn_sendMessage() returns other than LLRP_RC_OK + * then there was an error. In that case we try to print + * the error details. + */ + if(LLRP_RC_OK != LLRP_Conn_sendMessage(pConn, pSendMsg)) + { + const LLRP_tSErrorDetails *pError = LLRP_Conn_getSendError(pConn); + + printf("ERROR: %s sendMessage failed, %s\n", + pSendMsg->elementHdr.pType->pName, + pError->pWhatStr ? pError->pWhatStr : "no reason given"); + + if(NULL != pError->pRefType) + { + printf("ERROR: ... reference type %s\n", + pError->pRefType->pName); + } + + if(NULL != pError->pRefField) + { + printf("ERROR: ... reference field %s\n", + pError->pRefField->pName); + } + + return -1; + } + + /* + * Victory + */ + return 0; +} + + +/** + ***************************************************************************** + ** + ** @brief Wrapper to free a message. + ** + ** All it does is cast pMessage and let + ** LLRP_Element_destruct() do the work. + ** + ** @param[in] pMessage Pointer to message to destruct + ** + ** @return void + ** + *****************************************************************************/ + +void +freeMessage ( + LLRP_tSMessage * pMessage) +{ + LLRP_Element_destruct(&pMessage->elementHdr); +} + + +/** + ***************************************************************************** + ** + ** @brief Helper to print a message as XML text + ** + ** Print a LLRP message as XML text + ** + ** @param[in] pMessage Pointer to message to print + ** + ** @return void + ** + *****************************************************************************/ + +void +printXMLMessage ( + LLRP_tSMessage * pMessage) +{ + char aBuf[100*1024]; + + /* + * Convert the message to an XML string. + * This fills the buffer with either the XML string + * or an error message. The return value could + * be checked. + */ + + LLRP_toXMLString(&pMessage->elementHdr, aBuf, sizeof aBuf); + + /* + * Print the XML Text to the standard output. + */ + printf("%s", aBuf); +} diff --git a/vendor/libltkc/impinj_ltkc.h b/vendor/libltkc/impinj_ltkc.h new file mode 100644 index 0000000..adbe175 --- /dev/null +++ b/vendor/libltkc/impinj_ltkc.h @@ -0,0 +1,23 @@ + +/* + ***************************************************************************** + * * + * IMPINJ CONFIDENTIAL AND PROPRIETARY * + * * + * This source code is the sole property of Impinj, Inc. Reproduction or * + * utilization of this source code in whole or in part is forbidden without * + * the prior written consent of Impinj, Inc. * + * * + * (c) Copyright Impinj, Inc. 2007,2008. All rights reserved. * + * * + *****************************************************************************/ + +#ifndef _IMPINJ_LTKC_H +#define _IMPINJ_LTKC_H + +#include "ltkc.h" + +#include "out_impinj_ltkc.h" + +#endif /* !_IMPINJ_LTKC_H */ + diff --git a/vendor/libltkc/libcrypto_armv7l.a b/vendor/libltkc/libcrypto_armv7l.a new file mode 100644 index 0000000..be95321 Binary files /dev/null and b/vendor/libltkc/libcrypto_armv7l.a differ diff --git a/vendor/libltkc/libcrypto_atmel.a b/vendor/libltkc/libcrypto_atmel.a new file mode 100644 index 0000000..40348c6 Binary files /dev/null and b/vendor/libltkc/libcrypto_atmel.a differ diff --git a/vendor/libltkc/libdl_armv7l.a b/vendor/libltkc/libdl_armv7l.a new file mode 100644 index 0000000..e2d738f Binary files /dev/null and b/vendor/libltkc/libdl_armv7l.a differ diff --git a/vendor/libltkc/libdl_atmel.a b/vendor/libltkc/libdl_atmel.a new file mode 100644 index 0000000..8725eb9 Binary files /dev/null and b/vendor/libltkc/libdl_atmel.a differ diff --git a/vendor/libltkc/libltkc_armv7l.a b/vendor/libltkc/libltkc_armv7l.a new file mode 100644 index 0000000..5ee0f06 Binary files /dev/null and b/vendor/libltkc/libltkc_armv7l.a differ diff --git a/vendor/libltkc/libltkc_armv7l.so b/vendor/libltkc/libltkc_armv7l.so new file mode 100755 index 0000000..a60f18a Binary files /dev/null and b/vendor/libltkc/libltkc_armv7l.so differ diff --git a/vendor/libltkc/libltkc_atmel.a b/vendor/libltkc/libltkc_atmel.a new file mode 100644 index 0000000..d308c3f Binary files /dev/null and b/vendor/libltkc/libltkc_atmel.a differ diff --git a/vendor/libltkc/libltkc_atmel.so b/vendor/libltkc/libltkc_atmel.so new file mode 100755 index 0000000..b889f94 Binary files /dev/null and b/vendor/libltkc/libltkc_atmel.so differ diff --git a/vendor/libltkc/libltkc_x86.a b/vendor/libltkc/libltkc_x86.a new file mode 100644 index 0000000..6446016 Binary files /dev/null and b/vendor/libltkc/libltkc_x86.a differ diff --git a/vendor/libltkc/libltkc_x86.so b/vendor/libltkc/libltkc_x86.so new file mode 100755 index 0000000..4b6a4ec Binary files /dev/null and b/vendor/libltkc/libltkc_x86.so differ diff --git a/vendor/libltkc/libltkc_x86_64.a b/vendor/libltkc/libltkc_x86_64.a new file mode 100644 index 0000000..ab7489b Binary files /dev/null and b/vendor/libltkc/libltkc_x86_64.a differ diff --git a/vendor/libltkc/libltkc_x86_64.so b/vendor/libltkc/libltkc_x86_64.so new file mode 100755 index 0000000..eb62619 Binary files /dev/null and b/vendor/libltkc/libltkc_x86_64.so differ diff --git a/vendor/libltkc/libltkcimpinj_armv7l.a b/vendor/libltkc/libltkcimpinj_armv7l.a new file mode 100644 index 0000000..f7d4dc1 Binary files /dev/null and b/vendor/libltkc/libltkcimpinj_armv7l.a differ diff --git a/vendor/libltkc/libltkcimpinj_armv7l.so b/vendor/libltkc/libltkcimpinj_armv7l.so new file mode 100755 index 0000000..b09005e Binary files /dev/null and b/vendor/libltkc/libltkcimpinj_armv7l.so differ diff --git a/vendor/libltkc/libltkcimpinj_atmel.a b/vendor/libltkc/libltkcimpinj_atmel.a new file mode 100644 index 0000000..f20a3ce Binary files /dev/null and b/vendor/libltkc/libltkcimpinj_atmel.a differ diff --git a/vendor/libltkc/libltkcimpinj_atmel.so b/vendor/libltkc/libltkcimpinj_atmel.so new file mode 100755 index 0000000..33ce74b Binary files /dev/null and b/vendor/libltkc/libltkcimpinj_atmel.so differ diff --git a/vendor/libltkc/libltkcimpinj_x86.a b/vendor/libltkc/libltkcimpinj_x86.a new file mode 100644 index 0000000..842613b Binary files /dev/null and b/vendor/libltkc/libltkcimpinj_x86.a differ diff --git a/vendor/libltkc/libltkcimpinj_x86.so b/vendor/libltkc/libltkcimpinj_x86.so new file mode 100755 index 0000000..9565ef0 Binary files /dev/null and b/vendor/libltkc/libltkcimpinj_x86.so differ diff --git a/vendor/libltkc/libltkcimpinj_x86_64.a b/vendor/libltkc/libltkcimpinj_x86_64.a new file mode 100644 index 0000000..3b085e5 Binary files /dev/null and b/vendor/libltkc/libltkcimpinj_x86_64.a differ diff --git a/vendor/libltkc/libltkcimpinj_x86_64.so b/vendor/libltkc/libltkcimpinj_x86_64.so new file mode 100755 index 0000000..4c5d184 Binary files /dev/null and b/vendor/libltkc/libltkcimpinj_x86_64.so differ diff --git a/vendor/libltkc/libssl_armv7l.a b/vendor/libltkc/libssl_armv7l.a new file mode 100644 index 0000000..727aee7 Binary files /dev/null and b/vendor/libltkc/libssl_armv7l.a differ diff --git a/vendor/libltkc/libssl_atmel.a b/vendor/libltkc/libssl_atmel.a new file mode 100644 index 0000000..e144e3f Binary files /dev/null and b/vendor/libltkc/libssl_atmel.a differ diff --git a/vendor/libltkc/libxml2_armv7l.a b/vendor/libltkc/libxml2_armv7l.a new file mode 100644 index 0000000..2388e59 Binary files /dev/null and b/vendor/libltkc/libxml2_armv7l.a differ diff --git a/vendor/libltkc/libxml2_atmel.a b/vendor/libltkc/libxml2_atmel.a new file mode 100644 index 0000000..613a1d1 Binary files /dev/null and b/vendor/libltkc/libxml2_atmel.a differ diff --git a/vendor/libltkc/libxml2_x86.a b/vendor/libltkc/libxml2_x86.a new file mode 100644 index 0000000..67faa3a Binary files /dev/null and b/vendor/libltkc/libxml2_x86.a differ diff --git a/vendor/libltkc/libxml2_x86_64.a b/vendor/libltkc/libxml2_x86_64.a new file mode 100644 index 0000000..4cbbed7 Binary files /dev/null and b/vendor/libltkc/libxml2_x86_64.a differ diff --git a/vendor/libltkc/llrp2xml b/vendor/libltkc/llrp2xml new file mode 100755 index 0000000..63403fe Binary files /dev/null and b/vendor/libltkc/llrp2xml differ diff --git a/vendor/libltkc/ltkc.h b/vendor/libltkc/ltkc.h new file mode 100755 index 0000000..8703a61 --- /dev/null +++ b/vendor/libltkc/ltkc.h @@ -0,0 +1,39 @@ + +/* + ***************************************************************************** + * * + * IMPINJ CONFIDENTIAL AND PROPRIETARY * + * * + * This source code is the sole property of Impinj, Inc. Reproduction or * + * utilization of this source code in whole or in part is forbidden without * + * the prior written consent of Impinj, Inc. * + * * + * (c) Copyright Impinj, Inc. 2007,2008. All rights reserved. * + * * + *****************************************************************************/ + +#ifndef _LTKC_H +#define _LTKC_H + +#include "ltkc_platform.h" +#include "ltkc_base.h" + +#include "ltkc_frame.h" +#include "ltkc_xmltext.h" +#include "ltkc_connection.h" + +#include "out_ltkc.h" + +/* for passing version information as a define */ +#define STRINGIFY(x) XSTRINGIFY(x) +#define XSTRINGIFY(x) #x + +#include "version.inc" + + +extern LLRP_tSTypeRegistry * +LLRP_getTheTypeRegistry (void); + + +#endif /* !_LTKC_H */ + diff --git a/vendor/libltkc/ltkc_base.h b/vendor/libltkc/ltkc_base.h new file mode 100755 index 0000000..9c0b521 --- /dev/null +++ b/vendor/libltkc/ltkc_base.h @@ -0,0 +1,1216 @@ + +/* + ***************************************************************************** + * * + * IMPINJ CONFIDENTIAL AND PROPRIETARY * + * * + * This source code is the sole property of Impinj, Inc. Reproduction or * + * utilization of this source code in whole or in part is forbidden without * + * the prior written consent of Impinj, Inc. * + * * + * (c) Copyright Impinj, Inc. 2007,2008. All rights reserved. * + * * + *****************************************************************************/ + +struct LLRP_SErrorDetails; +struct LLRP_SVendorDescriptor; +struct LLRP_SNamespaceDescriptor; +struct LLRP_STypeDescriptor; +struct LLRP_SFieldDescriptor; +struct LLRP_SEnumTableEntry; +struct LLRP_STypeRegistry; +struct LLRP_SElement; +struct LLRP_SMessage; +struct LLRP_SParameter; +struct LLRP_SDecoder; +struct LLRP_SDecoderOps; +struct LLRP_SDecoderStream; +struct LLRP_SDecoderStreamOps; +struct LLRP_SEncoder; +struct LLRP_SEncoderOps; +struct LLRP_SEncoderStream; +struct LLRP_SEncoderStreamOps; + + +typedef struct LLRP_SErrorDetails LLRP_tSErrorDetails; +typedef struct LLRP_SVendorDescriptor LLRP_tSVendorDescriptor; +typedef struct LLRP_SNamespaceDescriptor LLRP_tSNamespaceDescriptor; +typedef struct LLRP_STypeDescriptor LLRP_tSTypeDescriptor; +typedef struct LLRP_SFieldDescriptor LLRP_tSFieldDescriptor; +typedef struct LLRP_SEnumTableEntry LLRP_tSEnumTableEntry; +typedef struct LLRP_STypeRegistry LLRP_tSTypeRegistry; +typedef struct LLRP_SElement LLRP_tSElement; +typedef struct LLRP_SMessage LLRP_tSMessage; +typedef struct LLRP_SParameter LLRP_tSParameter; +typedef struct LLRP_SDecoder LLRP_tSDecoder; +typedef struct LLRP_SDecoderOps LLRP_tSDecoderOps; +typedef struct LLRP_SDecoderStream LLRP_tSDecoderStream; +typedef struct LLRP_SDecoderStreamOps LLRP_tSDecoderStreamOps; +typedef struct LLRP_SEncoder LLRP_tSEncoder; +typedef struct LLRP_SEncoderOps LLRP_tSEncoderOps; +typedef struct LLRP_SEncoderStream LLRP_tSEncoderStream; +typedef struct LLRP_SEncoderStreamOps LLRP_tSEncoderStreamOps; + + +typedef struct +{ + llrp_u16_t nValue; + llrp_u8_t * pValue; +} llrp_u8v_t; + +extern llrp_u8v_t LLRP_u8v_construct(llrp_u16_t nValue); +extern void LLRP_u8v_clear(llrp_u8v_t *pDst); +extern void LLRP_u8v_set(llrp_u8v_t *pDst, llrp_u8v_t Value); +extern llrp_u8v_t LLRP_u8v_copy(llrp_u8v_t Value); + +typedef struct +{ + llrp_u16_t nValue; + llrp_s8_t * pValue; +} llrp_s8v_t; + +extern llrp_s8v_t LLRP_s8v_construct(llrp_u16_t nValue); +extern void LLRP_s8v_clear(llrp_s8v_t *pDst); +extern void LLRP_s8v_set(llrp_s8v_t *pDst, llrp_s8v_t Value); +extern llrp_s8v_t LLRP_s8v_copy(llrp_s8v_t Value); + +typedef struct +{ + llrp_u16_t nValue; + llrp_u16_t * pValue; +} llrp_u16v_t; + +extern llrp_u16v_t LLRP_u16v_construct(llrp_u16_t nValue); +extern void LLRP_u16v_clear(llrp_u16v_t *pDst); +extern void LLRP_u16v_set(llrp_u16v_t *pDst, llrp_u16v_t Value); +extern llrp_u16v_t LLRP_u16v_copy(llrp_u16v_t Value); + +typedef struct +{ + llrp_u16_t nValue; + llrp_s16_t * pValue; +} llrp_s16v_t; + +extern llrp_s16v_t LLRP_s16v_construct(llrp_u16_t nValue); +extern void LLRP_s16v_clear(llrp_s16v_t *pDst); +extern void LLRP_s16v_set(llrp_s16v_t *pDst, llrp_s16v_t Value); +extern llrp_s16v_t LLRP_s16v_copy(llrp_s16v_t Value); + +typedef struct +{ + llrp_u16_t nValue; + llrp_u32_t * pValue; +} llrp_u32v_t; + +extern llrp_u32v_t LLRP_u32v_construct(llrp_u16_t nValue); +extern void LLRP_u32v_clear(llrp_u32v_t *pDst); +extern void LLRP_u32v_set(llrp_u32v_t *pDst, llrp_u32v_t Value); +extern llrp_u32v_t LLRP_u32v_copy(llrp_u32v_t Value); + +typedef struct +{ + llrp_u16_t nValue; + llrp_s32_t * pValue; +} llrp_s32v_t; + +extern llrp_s32v_t LLRP_s32v_construct(llrp_u16_t nValue); +extern void LLRP_s32v_clear(llrp_s32v_t *pDst); +extern void LLRP_s32v_set(llrp_s32v_t *pDst, llrp_s32v_t Value); +extern llrp_s32v_t LLRP_s32v_copy(llrp_s32v_t Value); + +typedef struct +{ + llrp_u16_t nValue; + llrp_u64_t * pValue; +} llrp_u64v_t; + +extern llrp_u64v_t LLRP_u64v_construct(llrp_u16_t nValue); +extern void LLRP_u64v_clear(llrp_u64v_t *pDst); +extern void LLRP_u64v_set(llrp_u64v_t *pDst, llrp_u64v_t Value); +extern llrp_u64v_t LLRP_u64v_copy(llrp_u64v_t Value); + +typedef struct +{ + llrp_u16_t nValue; + llrp_s64_t * pValue; +} llrp_s64v_t; + +extern llrp_s64v_t LLRP_s64v_construct(llrp_u16_t nValue); +extern void LLRP_s64v_clear(llrp_s64v_t *pDst); +extern void LLRP_s64v_set(llrp_s64v_t *pDst, llrp_s64v_t Value); +extern llrp_s64v_t LLRP_s64v_copy(llrp_s64v_t Value); + +typedef struct +{ + llrp_u16_t nBit; + llrp_u8_t * pValue; +} llrp_u1v_t; + +extern llrp_u1v_t LLRP_u1v_construct(llrp_u16_t nBit); +extern void LLRP_u1v_clear(llrp_u1v_t *pDst); +extern void LLRP_u1v_set(llrp_u1v_t *pDst, llrp_u1v_t Value); +extern llrp_u1v_t LLRP_u1v_copy(llrp_u1v_t Value); + +typedef struct +{ + llrp_u16_t nValue; + llrp_utf8_t * pValue; +} llrp_utf8v_t; + +extern llrp_utf8v_t LLRP_utf8v_construct(llrp_u16_t nValue); +extern void LLRP_utf8v_clear(llrp_utf8v_t *pDst); +extern void LLRP_utf8v_set(llrp_utf8v_t *pDst, llrp_utf8v_t Value); +extern llrp_utf8v_t LLRP_utf8v_copy(llrp_utf8v_t Value); + +typedef struct +{ + llrp_u16_t nValue; + llrp_byte_t * pValue; +} llrp_bytesToEnd_t; + +extern llrp_bytesToEnd_t LLRP_bytesToEnd_construct(llrp_u16_t nValue); +extern void LLRP_bytesToEnd_clear(llrp_bytesToEnd_t *pDst); +extern void +LLRP_bytesToEnd_set(llrp_bytesToEnd_t *pDst, llrp_bytesToEnd_t Value); +extern llrp_bytesToEnd_t LLRP_bytesToEnd_copy(llrp_bytesToEnd_t Value); + +typedef struct +{ + llrp_u8_t aValue[12u]; +} llrp_u96_t; + +enum LLRP_ResultCode +{ + LLRP_RC_OK = 0, + LLRP_RC_MiscError = 100, + LLRP_RC_Botch, + LLRP_RC_SendIOError, + LLRP_RC_RecvIOError, + LLRP_RC_RecvEOF, + LLRP_RC_RecvTimeout, + LLRP_RC_RecvFramingError, + LLRP_RC_RecvBufferOverflow, + LLRP_RC_BadVersion, + LLRP_RC_MissingResponseType, + LLRP_RC_UnknownMessageType, + LLRP_RC_UnknownParameterType, + LLRP_RC_ExcessiveLength, + LLRP_RC_InvalidLength, + LLRP_RC_FieldUnderrun, + LLRP_RC_ReservedBitsUnderrun, + LLRP_RC_FieldOverrun, + LLRP_RC_ReservedBitsOverrun, + LLRP_RC_UnalignedBitField, + LLRP_RC_UnalignedReservedBits, + LLRP_RC_MessageAllocationFailed, + LLRP_RC_ParameterAllocationFailed, + LLRP_RC_FieldAllocationFailed, + LLRP_RC_ExtraBytes, + LLRP_RC_MissingParameter, + LLRP_RC_UnexpectedParameter, + LLRP_RC_InvalidChoiceMember, + LLRP_RC_EnrollBadTypeNumber, + LLRP_RC_NotAllowedAtExtensionPoint, + LLRP_RC_XMLInvalidNodeType, + LLRP_RC_XMLMissingField, + LLRP_RC_XMLExtraNode, + LLRP_RC_XMLInvalidFieldCharacters, + LLRP_RC_XMLOutOfRange, + +}; +typedef enum LLRP_ResultCode LLRP_tResultCode; + + +struct LLRP_SErrorDetails +{ + LLRP_tResultCode eResultCode; + const LLRP_tSTypeDescriptor *pRefType; + const LLRP_tSFieldDescriptor *pRefField; + const char * pWhatStr; + int OtherDetail; +}; + +extern void +LLRP_Error_clear ( + LLRP_tSErrorDetails * pError); + +extern void +LLRP_Error_missingParameter ( + LLRP_tSErrorDetails * pError, + const LLRP_tSTypeDescriptor * pRefType); + +extern void +LLRP_Error_unexpectedParameter ( + LLRP_tSErrorDetails * pError, + const LLRP_tSParameter * pParameter); + +extern void +LLRP_Error_resultCodeAndWhatStr ( + LLRP_tSErrorDetails * pError, + LLRP_tResultCode eResultCode, + const char * pWhatStr); + + + + +struct LLRP_SVendorDescriptor +{ + /* Short name for the vendor, e.g. "Acme" */ + char * pName; + + /* Vendor PEN of a custom message or parameter */ + llrp_u32_t VendorID; +}; + +struct LLRP_SNamespaceDescriptor +{ + /* Short name for the namespace, e.g. "acmeNS" */ + char * pPrefix; + + /* URI for the namespace, this is the true namespace name */ + char * pURI; + + /* URI for the XSD (schema) for custom parameters and messages + * defined within the namespace */ + char * pSchemaLocation; +}; + + +/* + * + * +-----------------------+ + * | | + * | TypeDescriptor --------+ ppFieldDescriptorTable + * | | | + * +-----------------------+ | + * | + * +-------------------+ + * V + * +-----------------------+ + * | | [field number] + * ~ FieldDescriptor *[] --------+ + * | | | + * +-----------------------+ | + * | + * +-------------------+ + * V + * +-----------------------+ + * | | Optional pEnumTable + * | FieldDescriptor --------+ + * | | | + * +-----------------------+ | + * | + * +-------------------+ + * V + * +-----------------------+ + * | | + * | EnumTableEntry[] | + * | | + * +-----------------------+ + * + */ + + + +/* + * STypeDescriptor + * + * Describes a message or parameter type. + */ + +struct LLRP_STypeDescriptor +{ + /* TRUE for a message type, FALSE for a parameter type */ + llrp_bool_t bIsMessage; + + /* String name of parameter/message type (e.g. "ROSpec") */ + char * pName; + + /* NULL=>standard LLRP, !NULL=>Vendor (PEN) of custom + * message or parameter */ + const LLRP_tSVendorDescriptor * pVendorDescriptor; + + /* Namespace of message or parameter, for XML */ + const LLRP_tSNamespaceDescriptor *pNamespaceDescriptor; + + /* Type number or, for custom, subtype number */ + llrp_u32_t TypeNum; + + /* For messages (bIsMessage==TRUE), this is the type descriptor for + * the corresponding response. NULL for a request or notification. */ + const LLRP_tSTypeDescriptor * pResponseType; + + /* Table of pointers to the field descriptors */ + const LLRP_tSFieldDescriptor * const * const ppFieldDescriptorTable; + + /* Size of an instance of this element type */ + unsigned int nSizeBytes; + + /* Function to make an instance of the parameter or message */ + LLRP_tSElement * + (*pfConstruct)(void); + + /* Destruct instance, dealloc memory */ + void + (*pfDestruct) ( + LLRP_tSElement * pElement); + + /* Decoder, sometimes used when we want to decode w/o an instance */ + /* Function provided by each specific element type + * to decode fields (simple values). Leaves pDecoderStream + * at first subparameter. */ + + void + (*pfDecodeFields) ( + LLRP_tSElement * pElement, + LLRP_tSDecoderStream * pDecoderStream); + + /* After fields are decoded, the CDecoder itself takes care + * of gathering the subparameters into m_listAllSubParameters. + * Once the end of the enclosing TLV (or message) is reached + * this assimilateSubParameters() function is called to + * create parameter refrences from the primary member variables. + */ + void + (*pfAssimilateSubParameters) ( + LLRP_tSElement * pElement, + LLRP_tSErrorDetails * pError); + + /* Encode fields and subparameters */ + void + (*pfEncode) ( + const LLRP_tSElement * pElement, + LLRP_tSEncoderStream * pEncoderStream); + + /* For extension parameters, ask if they are allowed in + * an enclosing parameter or message */ + llrp_bool_t + (*pfIsAllowedIn) ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); +}; + +enum LLRP_EFieldType { + LLRP_FT_U8, LLRP_FT_S8, LLRP_FT_U8V, LLRP_FT_S8V, + LLRP_FT_U16, LLRP_FT_S16, LLRP_FT_U16V, LLRP_FT_S16V, + LLRP_FT_U32, LLRP_FT_S32, LLRP_FT_U32V, LLRP_FT_S32V, + LLRP_FT_U64, LLRP_FT_S64, LLRP_FT_U64V, LLRP_FT_S64V, + + LLRP_FT_U1, LLRP_FT_U1V, LLRP_FT_U2, LLRP_FT_U96, + LLRP_FT_UTF8V, + + LLRP_FT_E1, LLRP_FT_E2, LLRP_FT_E8, LLRP_FT_E16, LLRP_FT_E32, + LLRP_FT_E8V, + + LLRP_FT_BYTESTOEND, +}; +typedef enum LLRP_EFieldType LLRP_tEFieldType; + + +enum LLRP_EFieldFormat { + LLRP_FMT_NORMAL, + LLRP_FMT_DEC, + LLRP_FMT_HEX, + LLRP_FMT_UTF8, + LLRP_FMT_DATETIME, +}; +typedef enum LLRP_EFieldFormat LLRP_tEFieldFormat; + + +/* + * SFieldDescriptor + * + * Describes a single field. + */ +struct LLRP_SFieldDescriptor +{ + /* A code for the field type */ + LLRP_tEFieldType eFieldType; + /* A code for how the field should be formatted */ + LLRP_tEFieldFormat eFieldFormat; + /* String name of field (e.g. "ROSpecID") */ + char * pName; + /* NULL or ptr to table base for enumerated fields */ + const LLRP_tSEnumTableEntry * pEnumTable; +}; + + +extern LLRP_tSFieldDescriptor LLRP_g_fdMessageHeader_Type; +extern LLRP_tSFieldDescriptor LLRP_g_fdMessageHeader_Length; +extern LLRP_tSFieldDescriptor LLRP_g_fdMessageHeader_MessageID; +extern LLRP_tSFieldDescriptor LLRP_g_fdMessageHeader_VendorPEN; +extern LLRP_tSFieldDescriptor LLRP_g_fdMessageHeader_Subtype; +extern LLRP_tSFieldDescriptor LLRP_g_fdParameterHeader_TVType; +extern LLRP_tSFieldDescriptor LLRP_g_fdParameterHeader_TLVType; +extern LLRP_tSFieldDescriptor LLRP_g_fdParameterHeader_TLVLength; +extern LLRP_tSFieldDescriptor LLRP_g_fdParameterHeader_VendorPEN; +extern LLRP_tSFieldDescriptor LLRP_g_fdParameterHeader_Subtype; + + +/* + * SEnumTableEntry + * + * Simple table of enumerations. Table is terminated + * by an entry with pName==NULL. + */ +struct LLRP_SEnumTableEntry +{ + /* String name, (e.g. "Immediate") */ + char * pName; + int Value; +}; + +/* + * STypeRegistry + * + * A collection of pointers to STypeDescriptors. + * During decode operations types can be looked up + * by code (vendor and typenum) or by name. + */ +#define LTKC_MAX_CUSTOM_MESSAGE 1024u +#define LTKC_MAX_CUSTOM_PARAMETER 1024u +struct LLRP_STypeRegistry +{ + /* Standard messages subscripted by type number */ + const LLRP_tSTypeDescriptor * apStdMessageTypeDescriptors[1024u]; + /* Standard parameters subscripted by type number */ + const LLRP_tSTypeDescriptor * apStdParameterTypeDescriptors[1024u]; + + /* Custom messages, sequential search */ + const LLRP_tSTypeDescriptor * + apCustMessageTypeDescriptors[LTKC_MAX_CUSTOM_MESSAGE]; + unsigned int nCustMessageTypeDescriptors; + /* Custom parameters, sequential search */ + const LLRP_tSTypeDescriptor * + apCustParameterTypeDescriptors[LTKC_MAX_CUSTOM_PARAMETER]; + unsigned int nCustParameterTypeDescriptors; +}; + +/* Create a new TypeRegistry */ +extern LLRP_tSTypeRegistry * +LLRP_TypeRegistry_construct (void); + +/* Destruct a TypeRegistry */ +extern void +LLRP_TypeRegistry_destruct ( + LLRP_tSTypeRegistry * pTypeRegistry); + +/* Add a type descriptor to the registry */ +extern LLRP_tResultCode +LLRP_TypeRegistry_enroll ( + LLRP_tSTypeRegistry * pTypeRegistry, + const LLRP_tSTypeDescriptor * pTypeDescriptor); + +/* Lookup a standard message type descriptor. NULL=>not found */ +const LLRP_tSTypeDescriptor * +LLRP_TypeRegistry_lookupMessage ( + const LLRP_tSTypeRegistry * pTypeRegistry, + unsigned int MessageTypeNum); + +/* Lookup a standard parameter type descriptor. NULL=>not found */ +const LLRP_tSTypeDescriptor * +LLRP_TypeRegistry_lookupParameter ( + const LLRP_tSTypeRegistry * pTypeRegistry, + unsigned int ParameterTypeNum); + +/* Lookup a custom message type descriptor. NULL=>not found */ +const LLRP_tSTypeDescriptor * +LLRP_TypeRegistry_lookupCustomMessage ( + const LLRP_tSTypeRegistry * pTypeRegistry, + unsigned int VendorID, + unsigned int MessageSubTypeNum); + +/* Lookup a custom parameter type descriptor. NULL=>not found */ +const LLRP_tSTypeDescriptor * +LLRP_TypeRegistry_lookupCustomParameter ( + const LLRP_tSTypeRegistry * pTypeRegistry, + unsigned int VendorID, + unsigned int ParameterSubTypeNum); + +/* Lookup a typedesciptor (custom or regular) by name. NULL->not found */ +const LLRP_tSTypeDescriptor * +LLRP_TypeRegistry_lookupByName ( + const LLRP_tSTypeRegistry * pTypeRegistry, + const char * pElementName); + +/* + * SElement + * + * This is the base class for all parameter and message types. + * + * During decode, all subparameters found are entered + * on m_listAllSubParameters. Then the element's + * assimilateSubParameters() member function is called + * to iterate through the list and attach the parameters + * to specific fields. + * + * The m_listAllSubParameters is a secondary reference to + * all the subparameters. When the element is destructed + * all parameters referenced by m_listAllSubParameters + * are deleted. The C++ intrinsic destructors take care + * of deleting the list itself. + * + * During destruct the specific fields are not processed. + * The fields that are lists are automatically desctructed. + * So are the fields that are array types (i.e. utf8v) are + * also automatically destructed. The fields that are simple + * pointers are simply ignored. + * + * This works because every parameter referenced by specific + * fields is also referenced by m_listAllSubParameters. + */ + +struct LLRP_SElement +{ + /* The type descriptor desribing this element */ + const LLRP_tSTypeDescriptor * pType; + + /* Element that encloses this one, NULL if this is top-level element */ + LLRP_tSElement * pParent; + + /* List of all sub elements */ + LLRP_tSParameter * listAllSubParameters; +}; + +struct LLRP_SMessage +{ + LLRP_tSElement elementHdr; + + llrp_u32_t MessageID; + + LLRP_tSMessage * pQueueNext; +}; + +struct LLRP_SParameter +{ + LLRP_tSElement elementHdr; + + /* Next pointer for list of all sub elements */ + LLRP_tSParameter * pNextAllSubParameters; + + /* Next pointer for element headed by specific member */ + LLRP_tSParameter * pNextSubParameter; +}; + + +/* + * ltkc_element.c + */ +LLRP_tSElement * +LLRP_Element_construct ( + const LLRP_tSTypeDescriptor * pTypeDescriptor); + +extern void +LLRP_Element_destruct ( + LLRP_tSElement * pElement); + +extern void +LLRP_Element_finalDestruct ( + LLRP_tSElement * pElement); + +extern void +LLRP_Element_addSubParameterToAllList ( + LLRP_tSElement * pElement, + LLRP_tSParameter * pParameter); + +extern void +LLRP_Element_removeSubParameterFromAllList ( + LLRP_tSElement * pElement, + LLRP_tSParameter * pParameter); + +extern void +LLRP_Element_clearSubParameterAllList ( + LLRP_tSElement * pElement); + +extern void +LLRP_Element_setSubParameterPtr ( + LLRP_tSElement * pElement, + LLRP_tSParameter ** ppPtr, + LLRP_tSParameter * pValue); + +extern void +LLRP_Element_addToSubParameterList ( + LLRP_tSElement * pElement, + LLRP_tSParameter ** ppListHead, + LLRP_tSParameter * pValue); + +extern void +LLRP_Element_attachToSubParameterList ( + LLRP_tSParameter ** ppListHead, + LLRP_tSParameter * pValue); + +extern void +LLRP_Element_clearSubParameterList ( + LLRP_tSElement * pElement, + LLRP_tSParameter ** ppListHead); + +extern int +LLRP_Element_countSubParameterList ( + LLRP_tSElement * pElement, + LLRP_tSParameter ** ppListHead); + +extern int +LLRP_Element_walk ( + const LLRP_tSElement * pElement, + int (*pFunc)( + const LLRP_tSElement * pElement, + void * pArg), + void * pArg, + int iDepth, + int nMaxDepth); + +extern void +LLRP_Message_setMessageID ( + LLRP_tSMessage * pMessage, + llrp_u32_t MessageID); + +extern llrp_bool_t +LLRP_Parameter_isAllowedIn ( + LLRP_tSParameter * pParameter, + const LLRP_tSTypeDescriptor * pEnclosingTypeDescriptor); + +extern llrp_bool_t +LLRP_Parameter_isAllowedExtension ( + LLRP_tSParameter * pParameter, + const LLRP_tSTypeDescriptor * pEnclosingTypeDescriptor); + + +/* + * + * By way of example, this is how the CDecoder and CDecoderStream + * classes work. This example is for decoding a binary frame. + * + * +-------------------+ +---------------+ + * | | | | + * | CDecoder --------------->| CTypeRegistry | + * | | | | + * +--|----------------+ +---------------+ + * | ^ + * pointer | | + * to next | | +-------------------+ + * byte | | | | pointer to msg end + * | ^---- CDecoderStream ----------------+ + * | | | | | + * | | +-------------------+ | + * | | ^ | + * | | | | + * | | +-------------------+ ptr to | + * | | | | TLV end | + * | ^---- CDecoderStream ------------+ | + * | | | | | | + * | | +-------------------+ | | + * | | ^ | | + * | | | | | + * | | +-------------------+ | | + * | | | | | | + * | ^---- CDecoderStream --------+ | | + * | | | | | | + * | +-------------------+ | | | + * | | | | + * +-------------------+ | | | + * | | | | + * v v v v + * +---------------------------------------------------------------+ + * | Binary Frame Buffer | + * +---------------------------------------------------------------+ + * + * \_________________/ Nestec TLVs + * \________________/\___________________________/ Nested TLVs + * \_________________________________________________/ Message + * + * + * In the case of binary frame the references are to + * bytes within the buffer. Lookups are by type number. + * + * In the case of an XML DOM tree, the references are + * to nodes in the DOM tre. Lookups are by string name. + */ + +struct LLRP_SDecoder +{ + const LLRP_tSDecoderOps * pDecoderOps; + + const LLRP_tSTypeRegistry * pRegistry; + + LLRP_tSElement * pRootElement; + + LLRP_tSErrorDetails ErrorDetails; +}; + +struct LLRP_SDecoderOps +{ + void + (*pfDestruct) ( + LLRP_tSDecoder * pDecoder); + + LLRP_tSMessage * + (*pfDecodeMessage) ( + LLRP_tSDecoder * pDecoder); +}; + +struct LLRP_SDecoderStream +{ + LLRP_tSDecoderStreamOps * pDecoderStreamOps; +}; + +struct LLRP_SDecoderStreamOps +{ + /* + * 8-bit types + */ + + llrp_u8_t + (*pfGet_u8) ( + LLRP_tSDecoderStream * pDecoderStream, + const LLRP_tSFieldDescriptor *pFieldDescriptor); + + llrp_s8_t + (*pfGet_s8) ( + LLRP_tSDecoderStream * pDecoderStream, + const LLRP_tSFieldDescriptor *pFieldDescriptor); + + llrp_u8v_t + (*pfGet_u8v) ( + LLRP_tSDecoderStream * pDecoderStream, + const LLRP_tSFieldDescriptor *pFieldDescriptor); + + llrp_s8v_t + (*pfGet_s8v) ( + LLRP_tSDecoderStream * pDecoderStream, + const LLRP_tSFieldDescriptor *pFieldDescriptor); + + /* + * 16-bit types + */ + + llrp_u16_t + (*pfGet_u16) ( + LLRP_tSDecoderStream * pDecoderStream, + const LLRP_tSFieldDescriptor *pFieldDescriptor); + + llrp_s16_t + (*pfGet_s16) ( + LLRP_tSDecoderStream * pDecoderStream, + const LLRP_tSFieldDescriptor *pFieldDescriptor); + + llrp_u16v_t + (*pfGet_u16v) ( + LLRP_tSDecoderStream * pDecoderStream, + const LLRP_tSFieldDescriptor *pFieldDescriptor); + + llrp_s16v_t + (*pfGet_s16v) ( + LLRP_tSDecoderStream * pDecoderStream, + const LLRP_tSFieldDescriptor *pFieldDescriptor); + + /* + * 32-bit types + */ + + llrp_u32_t + (*pfGet_u32) ( + LLRP_tSDecoderStream * pDecoderStream, + const LLRP_tSFieldDescriptor *pFieldDescriptor); + + llrp_s32_t + (*pfGet_s32) ( + LLRP_tSDecoderStream * pDecoderStream, + const LLRP_tSFieldDescriptor *pFieldDescriptor); + + llrp_u32v_t + (*pfGet_u32v) ( + LLRP_tSDecoderStream * pDecoderStream, + const LLRP_tSFieldDescriptor *pFieldDescriptor); + + llrp_s32v_t + (*pfGet_s32v) ( + LLRP_tSDecoderStream * pDecoderStream, + const LLRP_tSFieldDescriptor *pFieldDescriptor); + + /* + * 64-bit types + */ + + llrp_u64_t + (*pfGet_u64) ( + LLRP_tSDecoderStream * pDecoderStream, + const LLRP_tSFieldDescriptor *pFieldDescriptor); + + llrp_s64_t + (*pfGet_s64) ( + LLRP_tSDecoderStream * pDecoderStream, + const LLRP_tSFieldDescriptor *pFieldDescriptor); + + llrp_u64v_t + (*pfGet_u64v) ( + LLRP_tSDecoderStream * pDecoderStream, + const LLRP_tSFieldDescriptor *pFieldDescriptor); + + llrp_s64v_t + (*pfGet_s64v) ( + LLRP_tSDecoderStream * pDecoderStream, + const LLRP_tSFieldDescriptor *pFieldDescriptor); + + /* + * Special types + */ + + llrp_u1_t + (*pfGet_u1) ( + LLRP_tSDecoderStream * pDecoderStream, + const LLRP_tSFieldDescriptor *pFieldDescriptor); + + llrp_u1v_t + (*pfGet_u1v) ( + LLRP_tSDecoderStream * pDecoderStream, + const LLRP_tSFieldDescriptor *pFieldDescriptor); + + llrp_u2_t + (*pfGet_u2) ( + LLRP_tSDecoderStream * pDecoderStream, + const LLRP_tSFieldDescriptor *pFieldDescriptor); + + llrp_u96_t + (*pfGet_u96) ( + LLRP_tSDecoderStream * pDecoderStream, + const LLRP_tSFieldDescriptor *pFieldDescriptor); + + llrp_utf8v_t + (*pfGet_utf8v) ( + LLRP_tSDecoderStream * pDecoderStream, + const LLRP_tSFieldDescriptor *pFieldDescriptor); + + llrp_bytesToEnd_t + (*pfGet_bytesToEnd) ( + LLRP_tSDecoderStream * pDecoderStream, + const LLRP_tSFieldDescriptor *pFieldDescriptor); + + + /* + * Enumerated types of various sizes + */ + + int + (*pfGet_e1) ( + LLRP_tSDecoderStream * pDecoderStream, + const LLRP_tSFieldDescriptor *pFieldDescriptor); + + int + (*pfGet_e2) ( + LLRP_tSDecoderStream * pDecoderStream, + const LLRP_tSFieldDescriptor *pFieldDescriptor); + + int + (*pfGet_e8) ( + LLRP_tSDecoderStream * pDecoderStream, + const LLRP_tSFieldDescriptor *pFieldDescriptor); + + int + (*pfGet_e16) ( + LLRP_tSDecoderStream * pDecoderStream, + const LLRP_tSFieldDescriptor *pFieldDescriptor); + + int + (*pfGet_e32) ( + LLRP_tSDecoderStream * pDecoderStream, + const LLRP_tSFieldDescriptor *pFieldDescriptor); + + llrp_u8v_t + (*pfGet_e8v) ( + LLRP_tSDecoderStream * pDecoderStream, + const LLRP_tSFieldDescriptor *pFieldDescriptor); + + /* + * Reserved means some number of bits + */ + + void + (*pfGet_reserved) ( + LLRP_tSDecoderStream * pDecoderStream, + unsigned int nBits); +}; + + + +struct LLRP_SEncoder +{ + const LLRP_tSEncoderOps * pEncoderOps; + + LLRP_tSErrorDetails ErrorDetails; +}; + +struct LLRP_SEncoderOps +{ + void + (*pfDestruct) ( + LLRP_tSEncoder * pEncoder); + + void + (*pfEncodeElement) ( + LLRP_tSEncoder * pEncoder, + const LLRP_tSElement * pElement); +}; + +struct LLRP_SEncoderStream +{ + LLRP_tSEncoderStreamOps * pEncoderStreamOps; +}; + +struct LLRP_SEncoderStreamOps +{ + void + (*pfPutRequiredSubParameter) ( + LLRP_tSEncoderStream * pEncoderStream, + const LLRP_tSParameter * pParameter, + const LLRP_tSTypeDescriptor *pRefType); + + void + (*pfPutOptionalSubParameter) ( + LLRP_tSEncoderStream * pEncoderStream, + const LLRP_tSParameter * pParameter, + const LLRP_tSTypeDescriptor *pRefType); + + void + (*pfPutRequiredSubParameterList) ( + LLRP_tSEncoderStream * pEncoderStream, + const LLRP_tSParameter * pParameterList, + const LLRP_tSTypeDescriptor *pRefType); + + void + (*pfPutOptionalSubParameterList) ( + LLRP_tSEncoderStream * pEncoderStream, + const LLRP_tSParameter * pParameterList, + const LLRP_tSTypeDescriptor *pRefType); + + /* + * 8-bit types + */ + + void + (*pfPut_u8) ( + LLRP_tSEncoderStream * pEncoderStream, + const llrp_u8_t Value, + const LLRP_tSFieldDescriptor *pFieldDescriptor); + + void + (*pfPut_s8) ( + LLRP_tSEncoderStream * pEncoderStream, + const llrp_s8_t Value, + const LLRP_tSFieldDescriptor *pFieldDescriptor); + + void + (*pfPut_u8v) ( + LLRP_tSEncoderStream * pEncoderStream, + const llrp_u8v_t Value, + const LLRP_tSFieldDescriptor *pFieldDescriptor); + + void + (*pfPut_s8v) ( + LLRP_tSEncoderStream * pEncoderStream, + const llrp_s8v_t Value, + const LLRP_tSFieldDescriptor *pFieldDescriptor); + + /* + * 16-bit types + */ + + void + (*pfPut_u16) ( + LLRP_tSEncoderStream * pEncoderStream, + const llrp_u16_t Value, + const LLRP_tSFieldDescriptor *pFieldDescriptor); + + void + (*pfPut_s16) ( + LLRP_tSEncoderStream * pEncoderStream, + const llrp_s16_t Value, + const LLRP_tSFieldDescriptor *pFieldDescriptor); + + void + (*pfPut_u16v) ( + LLRP_tSEncoderStream * pEncoderStream, + const llrp_u16v_t Value, + const LLRP_tSFieldDescriptor *pFieldDescriptor); + + void + (*pfPut_s16v) ( + LLRP_tSEncoderStream * pEncoderStream, + const llrp_s16v_t Value, + const LLRP_tSFieldDescriptor *pFieldDescriptor); + + /* + * 32-bit types + */ + + void + (*pfPut_u32) ( + LLRP_tSEncoderStream * pEncoderStream, + const llrp_u32_t Value, + const LLRP_tSFieldDescriptor *pFieldDescriptor); + + void + (*pfPut_s32) ( + LLRP_tSEncoderStream * pEncoderStream, + const llrp_s32_t Value, + const LLRP_tSFieldDescriptor *pFieldDescriptor); + + void + (*pfPut_u32v) ( + LLRP_tSEncoderStream * pEncoderStream, + const llrp_u32v_t Value, + const LLRP_tSFieldDescriptor *pFieldDescriptor); + + void + (*pfPut_s32v) ( + LLRP_tSEncoderStream * pEncoderStream, + const llrp_s32v_t Value, + const LLRP_tSFieldDescriptor *pFieldDescriptor); + + /* + * 64-bit types + */ + + void + (*pfPut_u64) ( + LLRP_tSEncoderStream * pEncoderStream, + const llrp_u64_t Value, + const LLRP_tSFieldDescriptor *pFieldDescriptor); + + void + (*pfPut_s64) ( + LLRP_tSEncoderStream * pEncoderStream, + const llrp_s64_t Value, + const LLRP_tSFieldDescriptor *pFieldDescriptor); + + void + (*pfPut_u64v) ( + LLRP_tSEncoderStream * pEncoderStream, + const llrp_u64v_t Value, + const LLRP_tSFieldDescriptor *pFieldDescriptor); + + void + (*pfPut_s64v) ( + LLRP_tSEncoderStream * pEncoderStream, + const llrp_s64v_t Value, + const LLRP_tSFieldDescriptor *pFieldDescriptor); + + /* + * Special types + */ + + void + (*pfPut_u1) ( + LLRP_tSEncoderStream * pEncoderStream, + const llrp_u1_t Value, + const LLRP_tSFieldDescriptor *pFieldDescriptor); + + void + (*pfPut_u1v) ( + LLRP_tSEncoderStream * pEncoderStream, + const llrp_u1v_t Value, + const LLRP_tSFieldDescriptor *pFieldDescriptor); + + void + (*pfPut_u2) ( + LLRP_tSEncoderStream * pEncoderStream, + const llrp_u2_t Value, + const LLRP_tSFieldDescriptor *pFieldDescriptor); + + void + (*pfPut_u96) ( + LLRP_tSEncoderStream * pEncoderStream, + const llrp_u96_t Value, + const LLRP_tSFieldDescriptor *pFieldDescriptor); + + void + (*pfPut_utf8v) ( + LLRP_tSEncoderStream * pEncoderStream, + const llrp_utf8v_t Value, + const LLRP_tSFieldDescriptor *pFieldDescriptor); + + void + (*pfPut_bytesToEnd) ( + LLRP_tSEncoderStream * pEncoderStream, + const llrp_bytesToEnd_t Value, + const LLRP_tSFieldDescriptor *pFieldDescriptor); + + /* + * Enumerated types of various sizes + */ + + void + (*pfPut_e1) ( + LLRP_tSEncoderStream * pEncoderStream, + const int Value, + const LLRP_tSFieldDescriptor *pFieldDescriptor); + + void + (*pfPut_e2) ( + LLRP_tSEncoderStream * pEncoderStream, + const int Value, + const LLRP_tSFieldDescriptor *pFieldDescriptor); + + void + (*pfPut_e8) ( + LLRP_tSEncoderStream * pEncoderStream, + const int Value, + const LLRP_tSFieldDescriptor *pFieldDescriptor); + + void + (*pfPut_e16) ( + LLRP_tSEncoderStream * pEncoderStream, + const int Value, + const LLRP_tSFieldDescriptor *pFieldDescriptor); + + void + (*pfPut_e32) ( + LLRP_tSEncoderStream * pEncoderStream, + const int Value, + const LLRP_tSFieldDescriptor *pFieldDescriptor); + + void + (*pfPut_e8v) ( + LLRP_tSEncoderStream * pEncoderStream, + const llrp_u8v_t Value, + const LLRP_tSFieldDescriptor *pFieldDescriptor); + + + /* + * Reserved means some number of bits + */ + + void + (*pfPut_reserved) ( + LLRP_tSEncoderStream * pEncoderStream, + unsigned int nBits); +}; + +/* + * ltkc_encdec.c + */ +extern void +LLRP_Decoder_destruct ( + LLRP_tSDecoder * pDecoder); + +LLRP_tSMessage * +LLRP_Decoder_decodeMessage ( + LLRP_tSDecoder * pDecoder); + +extern void +LLRP_Encoder_destruct ( + LLRP_tSEncoder * pEncoder); + +extern void +LLRP_Encoder_encodeElement ( + LLRP_tSEncoder * pEncoder, + const LLRP_tSElement * pElement); + + +/* + * ltkc_xmltextencode.c + */ + +extern LLRP_tResultCode +LLRP_toXMLString ( + const LLRP_tSElement * pElement, + char * pBuffer, + int nBuffer); diff --git a/vendor/libltkc/ltkc_connection.h b/vendor/libltkc/ltkc_connection.h new file mode 100755 index 0000000..498a2bc --- /dev/null +++ b/vendor/libltkc/ltkc_connection.h @@ -0,0 +1,190 @@ + +/* + ***************************************************************************** + * * + * IMPINJ CONFIDENTIAL AND PROPRIETARY * + * * + * This source code is the sole property of Impinj, Inc. Reproduction or * + * utilization of this source code in whole or in part is forbidden without * + * the prior written consent of Impinj, Inc. * + * * + * (c) Copyright Impinj, Inc. 2007,2008. All rights reserved. * + * * + *****************************************************************************/ + +/** + ***************************************************************************** + ** + ** @file ltkc_connection.h + ** + ** @brief Types and function prototypes for handling + ** two-way LLRP message traffic + ** + *****************************************************************************/ + + +/* Forward type declarations */ +struct LLRP_SConnection; +typedef struct LLRP_SConnection LLRP_tSConnection; +struct bio_st; + +/** + ***************************************************************************** + ** + ** @brief Structure of an LLRP connection instance + ** + ** An LLRP connection consists of: + ** - A file descriptor (fd) likely, but not necessarily, a socket + ** - An input queue of messages already received. Used to hold + ** asynchronous messages while awaiting a response. + ** - Receiver state. + ** - The receive buffer and count + ** - Whether a frame is valid. Valid means that the receive + ** buffer holds a frame and the MessageLength, MessageType, + ** ProtocolVersion, and MessageID are valid (usable). + ** Not valid with a nBuffer greater than 0 means that a frame + ** is being received. Sometimes we want to look at the frame + ** after it has been (or attempted to be) decoded. + ** - Top-level frame variables: tSFrameExtract + ** - Details of the last receiver error, including I/O errors, + ** end-of-file (EOF), timeout, or decode errors. + ** - Send state + ** - The send buffer and count + ** - Details of the last send error, including I/O errors, + ** or encode errors. + ** + *****************************************************************************/ + +struct LLRP_SConnection +{ + /** The OpenSSL provided socket abstraction */ + struct bio_st * pBio; + + /** Error message if openConnectionToReader() or close...() fail */ + const char * pConnectErrorStr; + + /** The registry to consult for message/parameter types during decode. */ + const LLRP_tSTypeRegistry * pTypeRegistry; + + /** Head of queue of messages already received. Probably events. + ** the queue is a one-way, NULL terminated linked list. */ + LLRP_tSMessage * pInputQueue; + + /** Size of the send/recv buffers, below, specified at construct() time */ + unsigned int nBufferSize; + + /** Receive state */ + struct + { + /** The buffer. Contains incomming frame. */ + unsigned char * pBuffer; + + /** Count of bytes currently in buffer */ + unsigned int nBuffer; + + /** Valid boolean. TRUE means the buffer and frame summary + ** variables are valid (usable). This is always + ** FALSE mid receive */ + int bFrameValid; + + /** Frame summary variables. Derived by LLRP_FrameExtract() */ + LLRP_tSFrameExtract FrameExtract; + + /** Details of last I/O or decoder error. */ + LLRP_tSErrorDetails ErrorDetails; + } Recv; + + /** Send state */ + struct + { + /** The buffer. Contains outgoing frame. */ + unsigned char * pBuffer; + + /** Count of bytes currently in buffer (from last send) */ + unsigned int nBuffer; + + /** Details of last I/O or encoder error. */ + LLRP_tSErrorDetails ErrorDetails; + } Send; +}; + + + + +/* + * ltkc_connection.c + */ +extern LLRP_tSConnection * +LLRP_Conn_construct ( + const LLRP_tSTypeRegistry * pTypeRegistry, + unsigned int nBufferSize); + +extern void +LLRP_Conn_destruct ( + LLRP_tSConnection * pConn); + +extern int +LLRP_Conn_openConnectionToReader ( + LLRP_tSConnection * pConn, + const char * pReaderHostName); + +extern int +LLRP_Conn_openSecureConnectionToReader ( + LLRP_tSConnection * pConn, + const char * pReaderHostName); + +extern int +LLRP_Conn_openConnectionToReaderWithPort ( + LLRP_tSConnection * pConn, + const char * pReaderHostName, + const char * pPort); + +extern int +LLRP_Conn_openSecureConnectionToReaderWithPort ( + LLRP_tSConnection * pConn, + const char * pReaderHostName, + const char * pPort); + +extern int +LLRP_Conn_closeConnectionToReader ( + LLRP_tSConnection * pConn); + +extern const char * +LLRP_Conn_getConnectError ( + LLRP_tSConnection * pConn); + +extern LLRP_tSMessage * +LLRP_Conn_transact ( + LLRP_tSConnection * pConn, + LLRP_tSMessage * pSendMessage, + int nMaxMS); + +extern const LLRP_tSErrorDetails * +LLRP_Conn_getTransactError ( + LLRP_tSConnection * pConn); + +extern LLRP_tResultCode +LLRP_Conn_sendMessage ( + LLRP_tSConnection * pConn, + LLRP_tSMessage * pMessage); + +extern const LLRP_tSErrorDetails * +LLRP_Conn_getSendError ( + LLRP_tSConnection * pConn); + +extern LLRP_tSMessage * +LLRP_Conn_recvMessage ( + LLRP_tSConnection * pConn, + int nMaxMS); + +extern LLRP_tSMessage * +LLRP_Conn_recvResponse ( + LLRP_tSConnection * pConn, + int nMaxMS, + const LLRP_tSTypeDescriptor * pResponseType, + llrp_u32_t ResponseMessageID); + +extern const LLRP_tSErrorDetails * +LLRP_Conn_getRecvError ( + LLRP_tSConnection * pConn); + diff --git a/vendor/libltkc/ltkc_frame.h b/vendor/libltkc/ltkc_frame.h new file mode 100755 index 0000000..3a28ff5 --- /dev/null +++ b/vendor/libltkc/ltkc_frame.h @@ -0,0 +1,108 @@ + +/* + ***************************************************************************** + * * + * IMPINJ CONFIDENTIAL AND PROPRIETARY * + * * + * This source code is the sole property of Impinj, Inc. Reproduction or * + * utilization of this source code in whole or in part is forbidden without * + * the prior written consent of Impinj, Inc. * + * * + * (c) Copyright Impinj, Inc. 2007,2008. All rights reserved. * + * * + *****************************************************************************/ + + + + +struct LLRP_SFrameExtract; +struct LLRP_SFrameDecoder; +struct LLRP_SFrameDecoderStream; +struct LLRP_SFrameEncoder; +struct LLRP_SFrameEncoderStream; + +typedef struct LLRP_SFrameExtract LLRP_tSFrameExtract; +typedef struct LLRP_SFrameDecoder LLRP_tSFrameDecoder; +typedef struct LLRP_SFrameDecoderStream LLRP_tSFrameDecoderStream; +typedef struct LLRP_SFrameEncoder LLRP_tSFrameEncoder; +typedef struct LLRP_SFrameEncoderStream LLRP_tSFrameEncoderStream; + + +struct LLRP_SFrameExtract +{ + enum { + LLRP_FRAME_UNKNOWN, + LLRP_FRAME_READY, + LLRP_FRAME_ERROR, + LLRP_FRAME_NEED_MORE + } eStatus; + + llrp_u32_t MessageLength; + llrp_u16_t MessageType; + llrp_u8_t ProtocolVersion; + llrp_u32_t MessageID; + + unsigned int nBytesNeeded; +}; + +struct LLRP_SFrameDecoder +{ + LLRP_tSDecoder decoderHdr; + + unsigned char * pBuffer; + unsigned int nBuffer; + + unsigned int iNext; + unsigned int BitFieldBuffer; + unsigned int nBitFieldResid; +}; + +extern LLRP_tSFrameExtract +LLRP_FrameExtract ( + const unsigned char * pBuffer, + unsigned int nBuffer); + +struct LLRP_SFrameDecoderStream +{ + LLRP_tSDecoderStream decoderStreamHdr; + + LLRP_tSFrameDecoder * pDecoder; + LLRP_tSFrameDecoderStream * pEnclosingDecoderStream; + const LLRP_tSTypeDescriptor *pRefType; + unsigned int iBegin; + unsigned int iLimit; +}; + +extern LLRP_tSFrameDecoder * +LLRP_FrameDecoder_construct ( + const LLRP_tSTypeRegistry * pTypeRegistry, + unsigned char * pBuffer, + unsigned int nBuffer); + + +struct LLRP_SFrameEncoder +{ + LLRP_tSEncoder encoderHdr; + + unsigned char * pBuffer; + unsigned int nBuffer; + + unsigned int iNext; + unsigned int BitFieldBuffer; + unsigned int nBitFieldResid; +}; + +struct LLRP_SFrameEncoderStream +{ + LLRP_tSEncoderStream encoderStreamHdr; + + LLRP_tSFrameEncoder * pEncoder; + LLRP_tSFrameEncoderStream * pEnclosingEncoderStream; + const LLRP_tSTypeDescriptor *pRefType; + unsigned int iBegin; +}; + +extern LLRP_tSFrameEncoder * +LLRP_FrameEncoder_construct ( + unsigned char * pBuffer, + unsigned int nBuffer); diff --git a/vendor/libltkc/ltkc_genoutmac.h b/vendor/libltkc/ltkc_genoutmac.h new file mode 100644 index 0000000..87fa399 --- /dev/null +++ b/vendor/libltkc/ltkc_genoutmac.h @@ -0,0 +1,41 @@ + +/* + ***************************************************************************** + * * + * IMPINJ CONFIDENTIAL AND PROPRIETARY * + * * + * This source code is the sole property of Impinj, Inc. Reproduction or * + * utilization of this source code in whole or in part is forbidden without * + * the prior written consent of Impinj, Inc. * + * * + * (c) Copyright Impinj, Inc. 2007,2008. All rights reserved. * + * * + *****************************************************************************/ + + +#define SUBPARAM_SET(MEMBER,VALUE) \ + LLRP_Element_setSubParameterPtr( \ + (LLRP_tSElement *)pThis, \ + (LLRP_tSParameter**)&pThis->MEMBER, \ + (LLRP_tSParameter*)(VALUE)) + +#define SUBPARAM_ADD(MEMBER,VALUE) \ + LLRP_Element_addToSubParameterList( \ + (LLRP_tSElement *)pThis, \ + (LLRP_tSParameter**)&pThis->MEMBER, \ + (LLRP_tSParameter*)(VALUE)) + +#define SUBPARAM_ATTACH(MEMBER,VALUE) \ + LLRP_Element_attachToSubParameterList( \ + (LLRP_tSParameter**)&pThis->MEMBER, \ + (LLRP_tSParameter*)(VALUE)) + +#define SUBPARAM_CLEAR(MEMBER) \ + LLRP_Element_clearSubParameterList( \ + (LLRP_tSElement *)pThis, \ + (LLRP_tSParameter**)&pThis->MEMBER) + +#define SUBPARAM_COUNT(MEMBER) \ + LLRP_Element_countSubParameterList( \ + (LLRP_tSElement *)pThis, \ + (LLRP_tSParameter**)&pThis->MEMBER) diff --git a/vendor/libltkc/ltkc_platform.h b/vendor/libltkc/ltkc_platform.h new file mode 100755 index 0000000..6fa3e20 --- /dev/null +++ b/vendor/libltkc/ltkc_platform.h @@ -0,0 +1,52 @@ + +/* + ***************************************************************************** + * * + * IMPINJ CONFIDENTIAL AND PROPRIETARY * + * * + * This source code is the sole property of Impinj, Inc. Reproduction or * + * utilization of this source code in whole or in part is forbidden without * + * the prior written consent of Impinj, Inc. * + * * + * (c) Copyright Impinj, Inc. 2007,2008. All rights reserved. * + * * + *****************************************************************************/ + + +/* + * Include file to establish context + * for the LLRP Tool Kit (LTK) C++ platform. + */ + +#include +#include /* malloc() */ +#include /* memcpy() */ + +#define FALSE 0 +#define TRUE 1 + +/* + * Typedefs of simple types. + * The LTK/C++ uses these types extensively. + * To retarget to another C++ platform change + * these typedefs. Everything else should be + * good to go. + */ + +#ifdef _STDINT_H + +typedef uint8_t llrp_u8_t; +typedef int8_t llrp_s8_t; +typedef uint16_t llrp_u16_t; +typedef int16_t llrp_s16_t; +typedef uint32_t llrp_u32_t; +typedef int32_t llrp_s32_t; +typedef uint64_t llrp_u64_t; +typedef int64_t llrp_s64_t; +typedef uint8_t llrp_u1_t; +typedef uint8_t llrp_u2_t; +typedef uint8_t llrp_utf8_t; +typedef int llrp_bool_t; +typedef uint8_t llrp_byte_t; + +#endif /* _STDINT_H */ diff --git a/vendor/libltkc/ltkc_xmltext.h b/vendor/libltkc/ltkc_xmltext.h new file mode 100644 index 0000000..1ef9f6c --- /dev/null +++ b/vendor/libltkc/ltkc_xmltext.h @@ -0,0 +1,87 @@ + +/* + ***************************************************************************** + * * + * IMPINJ CONFIDENTIAL AND PROPRIETARY * + * * + * This source code is the sole property of Impinj, Inc. Reproduction or * + * utilization of this source code in whole or in part is forbidden without * + * the prior written consent of Impinj, Inc. * + * * + * (c) Copyright Impinj, Inc. 2007,2010. All rights reserved. * + * * + *****************************************************************************/ + + +struct LLRP_SLibXMLTextDecoder; +struct LLRP_SLibXMLTextDecoderStream; +struct LLRP_SXMLTextEncoder; +struct LLRP_SXMLTextEncoderStream; + +typedef struct LLRP_SLibXMLTextDecoder LLRP_tSLibXMLTextDecoder; +typedef struct LLRP_SLibXMLTextDecoderStream LLRP_tSLibXMLTextDecoderStream; +typedef struct LLRP_SXMLTextEncoder LLRP_tSXMLTextEncoder; +typedef struct LLRP_SXMLTextEncoderStream LLRP_tSXMLTextEncoderStream; + +struct LLRP_SLibXMLTextDecoder +{ + LLRP_tSDecoder decoderHdr; + struct _xmlDoc * doc; + struct _xmlNode * pxmlNodeTree; +}; + +struct LLRP_SLibXMLTextDecoderStream +{ + LLRP_tSDecoderStream decoderStreamHdr; + + LLRP_tSLibXMLTextDecoder * pDecoder; + LLRP_tSLibXMLTextDecoderStream * pEnclosingDecoderStream; + struct _xmlNode * pTargetNode; + struct _xmlNode * pCurrentChildNode; + struct _xmlNode * pLastFieldNode; + const LLRP_tSTypeDescriptor * pRefType; +}; + +extern LLRP_tSLibXMLTextDecoder * +LLRP_LibXMLTextDecoder_construct ( + const LLRP_tSTypeRegistry * pTypeRegistry, + unsigned char * pBuffer, + unsigned int nBuffer); + + +struct LLRP_SXMLTextEncoder +{ + LLRP_tSEncoder encoderHdr; + + unsigned char * pBuffer; + unsigned int nBuffer; + + unsigned int iNext; + + int bOverflow; +}; + +struct LLRP_SXMLTextEncoderStream +{ + LLRP_tSEncoderStream encoderStreamHdr; + + LLRP_tSXMLTextEncoder * pEncoder; + LLRP_tSXMLTextEncoderStream * pEnclosingEncoderStream; + const LLRP_tSTypeDescriptor *pRefType; + unsigned int nDepth; +}; + +extern LLRP_tSXMLTextEncoder * +LLRP_XMLTextEncoder_construct ( + unsigned char * pBuffer, + unsigned int nBuffer); + +LLRP_tSLibXMLTextDecoder * +LLRP_LibXMLTextDecoder_construct_file ( + const LLRP_tSTypeRegistry * pTypeRegistry, + char * fname); + +LLRP_tSLibXMLTextDecoder * +LLRP_LibXMLTextDecoder_construct_nodetree ( + const LLRP_tSTypeRegistry * pTypeRegistry, + struct _xmlNode * pNodeTree); diff --git a/vendor/libltkc/out_impinj_ltkc.h b/vendor/libltkc/out_impinj_ltkc.h new file mode 100644 index 0000000..37ccc14 --- /dev/null +++ b/vendor/libltkc/out_impinj_ltkc.h @@ -0,0 +1,11415 @@ + +/* + * Generated file - DO NOT EDIT + * + * This is the header file for the LLRP Tool Kit (LTK) + * C++ (aka cpp) implementation. It is generated into a .inc file + * that is included by a platform specific .h header file. + * That .h file takes care of prerequisites needed by this file. + */ + + + + +/* + * Message classes - forward decls + */ + + +/* Custom messages */ + +struct LLRP_SIMPINJ_ENABLE_EXTENSIONS; +typedef struct LLRP_SIMPINJ_ENABLE_EXTENSIONS + LLRP_tSIMPINJ_ENABLE_EXTENSIONS; + +struct LLRP_SIMPINJ_ENABLE_EXTENSIONS_RESPONSE; +typedef struct LLRP_SIMPINJ_ENABLE_EXTENSIONS_RESPONSE + LLRP_tSIMPINJ_ENABLE_EXTENSIONS_RESPONSE; + +struct LLRP_SIMPINJ_SAVE_SETTINGS; +typedef struct LLRP_SIMPINJ_SAVE_SETTINGS + LLRP_tSIMPINJ_SAVE_SETTINGS; + +struct LLRP_SIMPINJ_SAVE_SETTINGS_RESPONSE; +typedef struct LLRP_SIMPINJ_SAVE_SETTINGS_RESPONSE + LLRP_tSIMPINJ_SAVE_SETTINGS_RESPONSE; + + +/* + * Parameter classes - forward decls + */ + + +/* Custom parameters */ + +struct LLRP_SImpinjRequestedData; +typedef struct LLRP_SImpinjRequestedData + LLRP_tSImpinjRequestedData; + +struct LLRP_SImpinjSubRegulatoryRegion; +typedef struct LLRP_SImpinjSubRegulatoryRegion + LLRP_tSImpinjSubRegulatoryRegion; + +struct LLRP_SImpinjInventorySearchMode; +typedef struct LLRP_SImpinjInventorySearchMode + LLRP_tSImpinjInventorySearchMode; + +struct LLRP_SImpinjFixedFrequencyList; +typedef struct LLRP_SImpinjFixedFrequencyList + LLRP_tSImpinjFixedFrequencyList; + +struct LLRP_SImpinjReducedPowerFrequencyList; +typedef struct LLRP_SImpinjReducedPowerFrequencyList + LLRP_tSImpinjReducedPowerFrequencyList; + +struct LLRP_SImpinjLowDutyCycle; +typedef struct LLRP_SImpinjLowDutyCycle + LLRP_tSImpinjLowDutyCycle; + +struct LLRP_SImpinjHubVersions; +typedef struct LLRP_SImpinjHubVersions + LLRP_tSImpinjHubVersions; + +struct LLRP_SImpinjDetailedVersion; +typedef struct LLRP_SImpinjDetailedVersion + LLRP_tSImpinjDetailedVersion; + +struct LLRP_SImpinjFrequencyCapabilities; +typedef struct LLRP_SImpinjFrequencyCapabilities + LLRP_tSImpinjFrequencyCapabilities; + +struct LLRP_SImpinjGPIDebounceConfiguration; +typedef struct LLRP_SImpinjGPIDebounceConfiguration + LLRP_tSImpinjGPIDebounceConfiguration; + +struct LLRP_SImpinjReaderTemperature; +typedef struct LLRP_SImpinjReaderTemperature + LLRP_tSImpinjReaderTemperature; + +struct LLRP_SImpinjLinkMonitorConfiguration; +typedef struct LLRP_SImpinjLinkMonitorConfiguration + LLRP_tSImpinjLinkMonitorConfiguration; + +struct LLRP_SImpinjReportBufferConfiguration; +typedef struct LLRP_SImpinjReportBufferConfiguration + LLRP_tSImpinjReportBufferConfiguration; + +struct LLRP_SImpinjAccessSpecConfiguration; +typedef struct LLRP_SImpinjAccessSpecConfiguration + LLRP_tSImpinjAccessSpecConfiguration; + +struct LLRP_SImpinjBlockWriteWordCount; +typedef struct LLRP_SImpinjBlockWriteWordCount + LLRP_tSImpinjBlockWriteWordCount; + +struct LLRP_SImpinjBlockPermalock; +typedef struct LLRP_SImpinjBlockPermalock + LLRP_tSImpinjBlockPermalock; + +struct LLRP_SImpinjBlockPermalockOpSpecResult; +typedef struct LLRP_SImpinjBlockPermalockOpSpecResult + LLRP_tSImpinjBlockPermalockOpSpecResult; + +struct LLRP_SImpinjGetBlockPermalockStatus; +typedef struct LLRP_SImpinjGetBlockPermalockStatus + LLRP_tSImpinjGetBlockPermalockStatus; + +struct LLRP_SImpinjGetBlockPermalockStatusOpSpecResult; +typedef struct LLRP_SImpinjGetBlockPermalockStatusOpSpecResult + LLRP_tSImpinjGetBlockPermalockStatusOpSpecResult; + +struct LLRP_SImpinjSetQTConfig; +typedef struct LLRP_SImpinjSetQTConfig + LLRP_tSImpinjSetQTConfig; + +struct LLRP_SImpinjSetQTConfigOpSpecResult; +typedef struct LLRP_SImpinjSetQTConfigOpSpecResult + LLRP_tSImpinjSetQTConfigOpSpecResult; + +struct LLRP_SImpinjGetQTConfig; +typedef struct LLRP_SImpinjGetQTConfig + LLRP_tSImpinjGetQTConfig; + +struct LLRP_SImpinjGetQTConfigOpSpecResult; +typedef struct LLRP_SImpinjGetQTConfigOpSpecResult + LLRP_tSImpinjGetQTConfigOpSpecResult; + +struct LLRP_SImpinjTagReportContentSelector; +typedef struct LLRP_SImpinjTagReportContentSelector + LLRP_tSImpinjTagReportContentSelector; + +struct LLRP_SImpinjEnableSerializedTID; +typedef struct LLRP_SImpinjEnableSerializedTID + LLRP_tSImpinjEnableSerializedTID; + +struct LLRP_SImpinjEnableRFPhaseAngle; +typedef struct LLRP_SImpinjEnableRFPhaseAngle + LLRP_tSImpinjEnableRFPhaseAngle; + +struct LLRP_SImpinjEnablePeakRSSI; +typedef struct LLRP_SImpinjEnablePeakRSSI + LLRP_tSImpinjEnablePeakRSSI; + +struct LLRP_SImpinjEnableGPSCoordinates; +typedef struct LLRP_SImpinjEnableGPSCoordinates + LLRP_tSImpinjEnableGPSCoordinates; + +struct LLRP_SImpinjSerializedTID; +typedef struct LLRP_SImpinjSerializedTID + LLRP_tSImpinjSerializedTID; + +struct LLRP_SImpinjRFPhaseAngle; +typedef struct LLRP_SImpinjRFPhaseAngle + LLRP_tSImpinjRFPhaseAngle; + +struct LLRP_SImpinjPeakRSSI; +typedef struct LLRP_SImpinjPeakRSSI + LLRP_tSImpinjPeakRSSI; + +struct LLRP_SImpinjGPSCoordinates; +typedef struct LLRP_SImpinjGPSCoordinates + LLRP_tSImpinjGPSCoordinates; + +struct LLRP_SImpinjLoopSpec; +typedef struct LLRP_SImpinjLoopSpec + LLRP_tSImpinjLoopSpec; + +struct LLRP_SImpinjGPSNMEASentences; +typedef struct LLRP_SImpinjGPSNMEASentences + LLRP_tSImpinjGPSNMEASentences; + +struct LLRP_SImpinjGGASentence; +typedef struct LLRP_SImpinjGGASentence + LLRP_tSImpinjGGASentence; + +struct LLRP_SImpinjRMCSentence; +typedef struct LLRP_SImpinjRMCSentence + LLRP_tSImpinjRMCSentence; + +struct LLRP_SImpinjOpSpecRetryCount; +typedef struct LLRP_SImpinjOpSpecRetryCount + LLRP_tSImpinjOpSpecRetryCount; + +struct LLRP_SImpinjAdvancedGPOConfiguration; +typedef struct LLRP_SImpinjAdvancedGPOConfiguration + LLRP_tSImpinjAdvancedGPOConfiguration; + +struct LLRP_SImpinjEnableOptimizedRead; +typedef struct LLRP_SImpinjEnableOptimizedRead + LLRP_tSImpinjEnableOptimizedRead; + +struct LLRP_SImpinjAccessSpecOrdering; +typedef struct LLRP_SImpinjAccessSpecOrdering + LLRP_tSImpinjAccessSpecOrdering; + +struct LLRP_SImpinjEnableRFDopplerFrequency; +typedef struct LLRP_SImpinjEnableRFDopplerFrequency + LLRP_tSImpinjEnableRFDopplerFrequency; + +struct LLRP_SImpinjRFDopplerFrequency; +typedef struct LLRP_SImpinjRFDopplerFrequency + LLRP_tSImpinjRFDopplerFrequency; + +struct LLRP_SImpinjInventoryConfiguration; +typedef struct LLRP_SImpinjInventoryConfiguration + LLRP_tSImpinjInventoryConfiguration; + +struct LLRP_SImpinjEnableTxPower; +typedef struct LLRP_SImpinjEnableTxPower + LLRP_tSImpinjEnableTxPower; + +struct LLRP_SImpinjTxPower; +typedef struct LLRP_SImpinjTxPower + LLRP_tSImpinjTxPower; + +struct LLRP_SImpinjEnableXPCWords; +typedef struct LLRP_SImpinjEnableXPCWords + LLRP_tSImpinjEnableXPCWords; + +struct LLRP_SImpinjXPCWords; +typedef struct LLRP_SImpinjXPCWords + LLRP_tSImpinjXPCWords; + +struct LLRP_SImpinjArrayVersion; +typedef struct LLRP_SImpinjArrayVersion + LLRP_tSImpinjArrayVersion; + +struct LLRP_SImpinjxArrayCapabilities; +typedef struct LLRP_SImpinjxArrayCapabilities + LLRP_tSImpinjxArrayCapabilities; + +struct LLRP_SImpinjTiltConfiguration; +typedef struct LLRP_SImpinjTiltConfiguration + LLRP_tSImpinjTiltConfiguration; + +struct LLRP_SImpinjBeaconConfiguration; +typedef struct LLRP_SImpinjBeaconConfiguration + LLRP_tSImpinjBeaconConfiguration; + +struct LLRP_SImpinjAntennaConfiguration; +typedef struct LLRP_SImpinjAntennaConfiguration + LLRP_tSImpinjAntennaConfiguration; + +struct LLRP_SImpinjAntennaEventHysteresis; +typedef struct LLRP_SImpinjAntennaEventHysteresis + LLRP_tSImpinjAntennaEventHysteresis; + +struct LLRP_SImpinjAntennaEventConfiguration; +typedef struct LLRP_SImpinjAntennaEventConfiguration + LLRP_tSImpinjAntennaEventConfiguration; + +struct LLRP_SImpinjAntennaAttemptEvent; +typedef struct LLRP_SImpinjAntennaAttemptEvent + LLRP_tSImpinjAntennaAttemptEvent; + +struct LLRP_SImpinjHubConfiguration; +typedef struct LLRP_SImpinjHubConfiguration + LLRP_tSImpinjHubConfiguration; + +struct LLRP_SImpinjDiagnosticReport; +typedef struct LLRP_SImpinjDiagnosticReport + LLRP_tSImpinjDiagnosticReport; + +struct LLRP_SImpinjPlacementConfiguration; +typedef struct LLRP_SImpinjPlacementConfiguration + LLRP_tSImpinjPlacementConfiguration; + +struct LLRP_SImpinjLISpec; +typedef struct LLRP_SImpinjLISpec + LLRP_tSImpinjLISpec; + +struct LLRP_SImpinjLocationConfig; +typedef struct LLRP_SImpinjLocationConfig + LLRP_tSImpinjLocationConfig; + +struct LLRP_SImpinjC1G2LocationConfig; +typedef struct LLRP_SImpinjC1G2LocationConfig + LLRP_tSImpinjC1G2LocationConfig; + +struct LLRP_SImpinjLocationReporting; +typedef struct LLRP_SImpinjLocationReporting + LLRP_tSImpinjLocationReporting; + +struct LLRP_SImpinjLocationConfidence; +typedef struct LLRP_SImpinjLocationConfidence + LLRP_tSImpinjLocationConfidence; + +struct LLRP_SImpinjLocationReportData; +typedef struct LLRP_SImpinjLocationReportData + LLRP_tSImpinjLocationReportData; + +struct LLRP_SImpinjDISpec; +typedef struct LLRP_SImpinjDISpec + LLRP_tSImpinjDISpec; + +struct LLRP_SImpinjDirectionSectors; +typedef struct LLRP_SImpinjDirectionSectors + LLRP_tSImpinjDirectionSectors; + +struct LLRP_SImpinjDirectionConfig; +typedef struct LLRP_SImpinjDirectionConfig + LLRP_tSImpinjDirectionConfig; + +struct LLRP_SImpinjDirectionUserTagPopulationLimit; +typedef struct LLRP_SImpinjDirectionUserTagPopulationLimit + LLRP_tSImpinjDirectionUserTagPopulationLimit; + +struct LLRP_SImpinjC1G2DirectionConfig; +typedef struct LLRP_SImpinjC1G2DirectionConfig + LLRP_tSImpinjC1G2DirectionConfig; + +struct LLRP_SImpinjExtendedTagInformation; +typedef struct LLRP_SImpinjExtendedTagInformation + LLRP_tSImpinjExtendedTagInformation; + +struct LLRP_SImpinjDirectionReporting; +typedef struct LLRP_SImpinjDirectionReporting + LLRP_tSImpinjDirectionReporting; + +struct LLRP_SImpinjDirectionReportData; +typedef struct LLRP_SImpinjDirectionReportData + LLRP_tSImpinjDirectionReportData; + +struct LLRP_SImpinjDirectionDiagnosticData; +typedef struct LLRP_SImpinjDirectionDiagnosticData + LLRP_tSImpinjDirectionDiagnosticData; + +struct LLRP_SImpinjxArrayDirectionCapabilities; +typedef struct LLRP_SImpinjxArrayDirectionCapabilities + LLRP_tSImpinjxArrayDirectionCapabilities; + +struct LLRP_SImpinjIntelligentAntennaManagement; +typedef struct LLRP_SImpinjIntelligentAntennaManagement + LLRP_tSImpinjIntelligentAntennaManagement; + +struct LLRP_SImpinjTransmitPower; +typedef struct LLRP_SImpinjTransmitPower + LLRP_tSImpinjTransmitPower; + +struct LLRP_SImpinjPolarizationControl; +typedef struct LLRP_SImpinjPolarizationControl + LLRP_tSImpinjPolarizationControl; + +struct LLRP_SImpinjAntennaCapabilities; +typedef struct LLRP_SImpinjAntennaCapabilities + LLRP_tSImpinjAntennaCapabilities; + +struct LLRP_SImpinjAntennaPolarizationCapability; +typedef struct LLRP_SImpinjAntennaPolarizationCapability + LLRP_tSImpinjAntennaPolarizationCapability; + +struct LLRP_SImpinjDisabledAntennas; +typedef struct LLRP_SImpinjDisabledAntennas + LLRP_tSImpinjDisabledAntennas; + +struct LLRP_SImpinjTIDParity; +typedef struct LLRP_SImpinjTIDParity + LLRP_tSImpinjTIDParity; + +struct LLRP_SImpinjMarginRead; +typedef struct LLRP_SImpinjMarginRead + LLRP_tSImpinjMarginRead; + +struct LLRP_SImpinjMarginReadOpSpecResult; +typedef struct LLRP_SImpinjMarginReadOpSpecResult + LLRP_tSImpinjMarginReadOpSpecResult; + +struct LLRP_SImpinjBLEVersion; +typedef struct LLRP_SImpinjBLEVersion + LLRP_tSImpinjBLEVersion; + +struct LLRP_SImpinjLocationAlgorithmControl; +typedef struct LLRP_SImpinjLocationAlgorithmControl + LLRP_tSImpinjLocationAlgorithmControl; + +struct LLRP_SImpinjRFPowerSweep; +typedef struct LLRP_SImpinjRFPowerSweep + LLRP_tSImpinjRFPowerSweep; + +struct LLRP_SImpinjTruncatedReplyConfiguration; +typedef struct LLRP_SImpinjTruncatedReplyConfiguration + LLRP_tSImpinjTruncatedReplyConfiguration; + +struct LLRP_SImpinjAuthenticate; +typedef struct LLRP_SImpinjAuthenticate + LLRP_tSImpinjAuthenticate; + +struct LLRP_SImpinjAuthenticateOpSpecResult; +typedef struct LLRP_SImpinjAuthenticateOpSpecResult + LLRP_tSImpinjAuthenticateOpSpecResult; + +struct LLRP_SImpinjTagFilterVerificationConfiguration; +typedef struct LLRP_SImpinjTagFilterVerificationConfiguration + LLRP_tSImpinjTagFilterVerificationConfiguration; + +struct LLRP_SImpinjEnableTagPopulationEstimationAlgorithm; +typedef struct LLRP_SImpinjEnableTagPopulationEstimationAlgorithm + LLRP_tSImpinjEnableTagPopulationEstimationAlgorithm; + +struct LLRP_SImpinjEnableCRHandle; +typedef struct LLRP_SImpinjEnableCRHandle + LLRP_tSImpinjEnableCRHandle; + +struct LLRP_SImpinjCRHandle; +typedef struct LLRP_SImpinjCRHandle + LLRP_tSImpinjCRHandle; + +struct LLRP_SImpinjEnableEnhancedIntegra; +typedef struct LLRP_SImpinjEnableEnhancedIntegra + LLRP_tSImpinjEnableEnhancedIntegra; + +struct LLRP_SImpinjEnhancedIntegraReport; +typedef struct LLRP_SImpinjEnhancedIntegraReport + LLRP_tSImpinjEnhancedIntegraReport; + +struct LLRP_SImpinjEndpointICVerificationConfig; +typedef struct LLRP_SImpinjEndpointICVerificationConfig + LLRP_tSImpinjEndpointICVerificationConfig; + +struct LLRP_SImpinjEnableEndpointICVerification; +typedef struct LLRP_SImpinjEnableEndpointICVerification + LLRP_tSImpinjEnableEndpointICVerification; + +struct LLRP_SImpinjEndpointICVerificationReport; +typedef struct LLRP_SImpinjEndpointICVerificationReport + LLRP_tSImpinjEndpointICVerificationReport; + + +/* + * Vendor descriptor declarations. + */ + +extern const LLRP_tSVendorDescriptor +LLRP_vdescImpinj; + + +/* + * Namespace descriptor declarations. + */ + +extern const LLRP_tSNamespaceDescriptor +LLRP_nsdescImpinj; + + +/* + * Enumeration definitions and declarations of + * enumeration string tables. + */ + + +enum LLRP_EImpinjRequestedDataType +{ + + LLRP_ImpinjRequestedDataType_All_Capabilities = 1000, + LLRP_ImpinjRequestedDataType_Impinj_Detailed_Version = 1001, + LLRP_ImpinjRequestedDataType_Impinj_Frequency_Capabilities = 1002, + LLRP_ImpinjRequestedDataType_Impinj_xArray_Capabilities = 1003, + LLRP_ImpinjRequestedDataType_Impinj_Antenna_Capabilities = 1004, + LLRP_ImpinjRequestedDataType_All_Configuration = 2000, + LLRP_ImpinjRequestedDataType_Impinj_Sub_Regulatory_Region = 2001, + LLRP_ImpinjRequestedDataType_Impinj_GPI_Debounce_Configuration = 2003, + LLRP_ImpinjRequestedDataType_Impinj_Reader_Temperature = 2004, + LLRP_ImpinjRequestedDataType_Impinj_Link_Monitor_Configuration = 2005, + LLRP_ImpinjRequestedDataType_Impinj_Report_Buffer_Configuration = 2006, + LLRP_ImpinjRequestedDataType_Impinj_Access_Spec_Configuration = 2007, + LLRP_ImpinjRequestedDataType_Impinj_GPS_NMEA_Sentences = 2008, + LLRP_ImpinjRequestedDataType_Impinj_Advanced_GPO_Configuration = 2009, + LLRP_ImpinjRequestedDataType_Impinj_Tilt_Configuration = 2010, + LLRP_ImpinjRequestedDataType_Impinj_Beacon_Configuration = 2011, + LLRP_ImpinjRequestedDataType_Impinj_Antenna_Configuration = 2012, + LLRP_ImpinjRequestedDataType_Impinj_Location_Configuration = 2013, + LLRP_ImpinjRequestedDataType_Impinj_Transition_Configuration = 2014, + LLRP_ImpinjRequestedDataType_Impinj_Hub_Configuration = 2015, + LLRP_ImpinjRequestedDataType_Impinj_PolarizationControl_Configuration = 2017, + LLRP_ImpinjRequestedDataType_Impinj_Direction_Configuration = 2018, +}; + +typedef enum LLRP_EImpinjRequestedDataType + LLRP_tEImpinjRequestedDataType; + +extern const LLRP_tSEnumTableEntry +LLRP_estImpinjRequestedDataType[]; + + +enum LLRP_EImpinjRegulatoryRegion +{ + + LLRP_ImpinjRegulatoryRegion_FCC_Part_15_247 = 0, + LLRP_ImpinjRegulatoryRegion_ETSI_EN_300_220 = 1, + LLRP_ImpinjRegulatoryRegion_ETSI_EN_302_208_With_LBT = 2, + LLRP_ImpinjRegulatoryRegion_Hong_Kong_920_925_MHz = 3, + LLRP_ImpinjRegulatoryRegion_Taiwan_922_928_MHz = 4, + LLRP_ImpinjRegulatoryRegion_ETSI_EN_302_208_v1_2_1 = 7, + LLRP_ImpinjRegulatoryRegion_Korea_917_921_MHz = 8, + LLRP_ImpinjRegulatoryRegion_Malaysia_919_923_MHz = 9, + LLRP_ImpinjRegulatoryRegion_China_920_925_MHz = 10, + LLRP_ImpinjRegulatoryRegion_South_Africa_915_919_MHz = 12, + LLRP_ImpinjRegulatoryRegion_Brazil_902_907_and_915_928_MHz = 13, + LLRP_ImpinjRegulatoryRegion_Thailand_920_925_MHz = 14, + LLRP_ImpinjRegulatoryRegion_Singapore_920_925_MHz = 15, + LLRP_ImpinjRegulatoryRegion_Australia_920_926_MHz = 16, + LLRP_ImpinjRegulatoryRegion_India_865_867_MHz = 17, + LLRP_ImpinjRegulatoryRegion_Uruguay_916_928_MHz = 18, + LLRP_ImpinjRegulatoryRegion_Vietnam_918_923_MHz = 19, + LLRP_ImpinjRegulatoryRegion_Israel_915_917_MHz = 20, + LLRP_ImpinjRegulatoryRegion_Philippines_918_920_MHz = 21, + LLRP_ImpinjRegulatoryRegion_Vietnam_920_923_MHz = 22, + LLRP_ImpinjRegulatoryRegion_Indonesia_920_923_MHz = 23, + LLRP_ImpinjRegulatoryRegion_New_Zealand_921p5_928_MHz = 24, + LLRP_ImpinjRegulatoryRegion_Japan_916_921_MHz_Without_LBT = 25, + LLRP_ImpinjRegulatoryRegion_Latin_America_902_928_MHz = 26, + LLRP_ImpinjRegulatoryRegion_Peru_916_928_MHz = 27, + LLRP_ImpinjRegulatoryRegion_Bangladesh_925_927_MHz = 28, + LLRP_ImpinjRegulatoryRegion_ETSI_915_921_MHz = 29, + LLRP_ImpinjRegulatoryRegion_Morocco_867_868_MHz = 30, + LLRP_ImpinjRegulatoryRegion_Paraguay_918_928_MHz = 31, + LLRP_ImpinjRegulatoryRegion_Morocco = 32, + LLRP_ImpinjRegulatoryRegion_Chile = 33, + LLRP_ImpinjRegulatoryRegion_Colombia = 34, + LLRP_ImpinjRegulatoryRegion_South_Africa_915_919_MHz_Alternate = 35, + LLRP_ImpinjRegulatoryRegion_Venezuela = 36, +}; + +typedef enum LLRP_EImpinjRegulatoryRegion + LLRP_tEImpinjRegulatoryRegion; + +extern const LLRP_tSEnumTableEntry +LLRP_estImpinjRegulatoryRegion[]; + + +enum LLRP_EImpinjInventorySearchType +{ + + LLRP_ImpinjInventorySearchType_Reader_Selected = 0, + LLRP_ImpinjInventorySearchType_Single_Target = 1, + LLRP_ImpinjInventorySearchType_Dual_Target = 2, + LLRP_ImpinjInventorySearchType_Single_Target_With_Suppression = 3, + LLRP_ImpinjInventorySearchType_No_Target = 4, + LLRP_ImpinjInventorySearchType_Single_Target_BtoA = 5, + LLRP_ImpinjInventorySearchType_Dual_Target_with_BtoASelect = 6, +}; + +typedef enum LLRP_EImpinjInventorySearchType + LLRP_tEImpinjInventorySearchType; + +extern const LLRP_tSEnumTableEntry +LLRP_estImpinjInventorySearchType[]; + + +enum LLRP_EImpinjFixedFrequencyMode +{ + + LLRP_ImpinjFixedFrequencyMode_Disabled = 0, + LLRP_ImpinjFixedFrequencyMode_Auto_Select = 1, + LLRP_ImpinjFixedFrequencyMode_Channel_List = 2, +}; + +typedef enum LLRP_EImpinjFixedFrequencyMode + LLRP_tEImpinjFixedFrequencyMode; + +extern const LLRP_tSEnumTableEntry +LLRP_estImpinjFixedFrequencyMode[]; + + +enum LLRP_EImpinjReducedPowerMode +{ + + LLRP_ImpinjReducedPowerMode_Disabled = 0, + LLRP_ImpinjReducedPowerMode_Enabled = 1, +}; + +typedef enum LLRP_EImpinjReducedPowerMode + LLRP_tEImpinjReducedPowerMode; + +extern const LLRP_tSEnumTableEntry +LLRP_estImpinjReducedPowerMode[]; + + +enum LLRP_EImpinjLowDutyCycleMode +{ + + LLRP_ImpinjLowDutyCycleMode_Disabled = 0, + LLRP_ImpinjLowDutyCycleMode_Enabled = 1, +}; + +typedef enum LLRP_EImpinjLowDutyCycleMode + LLRP_tEImpinjLowDutyCycleMode; + +extern const LLRP_tSEnumTableEntry +LLRP_estImpinjLowDutyCycleMode[]; + + +enum LLRP_EImpinjLinkMonitorMode +{ + + LLRP_ImpinjLinkMonitorMode_Disabled = 0, + LLRP_ImpinjLinkMonitorMode_Enabled = 1, +}; + +typedef enum LLRP_EImpinjLinkMonitorMode + LLRP_tEImpinjLinkMonitorMode; + +extern const LLRP_tSEnumTableEntry +LLRP_estImpinjLinkMonitorMode[]; + + +enum LLRP_EImpinjReportBufferMode +{ + + LLRP_ImpinjReportBufferMode_Normal = 0, + LLRP_ImpinjReportBufferMode_Low_Latency = 1, +}; + +typedef enum LLRP_EImpinjReportBufferMode + LLRP_tEImpinjReportBufferMode; + +extern const LLRP_tSEnumTableEntry +LLRP_estImpinjReportBufferMode[]; + + +enum LLRP_EImpinjBlockPermalockResultType +{ + + LLRP_ImpinjBlockPermalockResultType_Success = 0, + LLRP_ImpinjBlockPermalockResultType_Insufficient_Power = 1, + LLRP_ImpinjBlockPermalockResultType_Nonspecific_Tag_Error = 2, + LLRP_ImpinjBlockPermalockResultType_No_Response_From_Tag = 3, + LLRP_ImpinjBlockPermalockResultType_Nonspecific_Reader_Error = 4, + LLRP_ImpinjBlockPermalockResultType_Incorrect_Password_Error = 5, + LLRP_ImpinjBlockPermalockResultType_Tag_Memory_Overrun_Error = 6, +}; + +typedef enum LLRP_EImpinjBlockPermalockResultType + LLRP_tEImpinjBlockPermalockResultType; + +extern const LLRP_tSEnumTableEntry +LLRP_estImpinjBlockPermalockResultType[]; + + +enum LLRP_EImpinjGetBlockPermalockStatusResultType +{ + + LLRP_ImpinjGetBlockPermalockStatusResultType_Success = 0, + LLRP_ImpinjGetBlockPermalockStatusResultType_Nonspecific_Tag_Error = 1, + LLRP_ImpinjGetBlockPermalockStatusResultType_No_Response_From_Tag = 2, + LLRP_ImpinjGetBlockPermalockStatusResultType_Nonspecific_Reader_Error = 3, + LLRP_ImpinjGetBlockPermalockStatusResultType_Incorrect_Password_Error = 4, + LLRP_ImpinjGetBlockPermalockStatusResultType_Tag_Memory_Overrun_Error = 5, +}; + +typedef enum LLRP_EImpinjGetBlockPermalockStatusResultType + LLRP_tEImpinjGetBlockPermalockStatusResultType; + +extern const LLRP_tSEnumTableEntry +LLRP_estImpinjGetBlockPermalockStatusResultType[]; + + +enum LLRP_EImpinjQTDataProfile +{ + + LLRP_ImpinjQTDataProfile_Unknown = 0, + LLRP_ImpinjQTDataProfile_Private = 1, + LLRP_ImpinjQTDataProfile_Public = 2, +}; + +typedef enum LLRP_EImpinjQTDataProfile + LLRP_tEImpinjQTDataProfile; + +extern const LLRP_tSEnumTableEntry +LLRP_estImpinjQTDataProfile[]; + + +enum LLRP_EImpinjQTAccessRange +{ + + LLRP_ImpinjQTAccessRange_Unknown = 0, + LLRP_ImpinjQTAccessRange_Normal_Range = 1, + LLRP_ImpinjQTAccessRange_Short_Range = 2, +}; + +typedef enum LLRP_EImpinjQTAccessRange + LLRP_tEImpinjQTAccessRange; + +extern const LLRP_tSEnumTableEntry +LLRP_estImpinjQTAccessRange[]; + + +enum LLRP_EImpinjQTPersistence +{ + + LLRP_ImpinjQTPersistence_Unknown = 0, + LLRP_ImpinjQTPersistence_Temporary = 1, + LLRP_ImpinjQTPersistence_Permanent = 2, +}; + +typedef enum LLRP_EImpinjQTPersistence + LLRP_tEImpinjQTPersistence; + +extern const LLRP_tSEnumTableEntry +LLRP_estImpinjQTPersistence[]; + + +enum LLRP_EImpinjSetQTConfigResultType +{ + + LLRP_ImpinjSetQTConfigResultType_Success = 0, + LLRP_ImpinjSetQTConfigResultType_Insufficient_Power = 1, + LLRP_ImpinjSetQTConfigResultType_Nonspecific_Tag_Error = 2, + LLRP_ImpinjSetQTConfigResultType_No_Response_From_Tag = 3, + LLRP_ImpinjSetQTConfigResultType_Nonspecific_Reader_Error = 4, + LLRP_ImpinjSetQTConfigResultType_Incorrect_Password_Error = 5, +}; + +typedef enum LLRP_EImpinjSetQTConfigResultType + LLRP_tEImpinjSetQTConfigResultType; + +extern const LLRP_tSEnumTableEntry +LLRP_estImpinjSetQTConfigResultType[]; + + +enum LLRP_EImpinjGetQTConfigResultType +{ + + LLRP_ImpinjGetQTConfigResultType_Success = 0, + LLRP_ImpinjGetQTConfigResultType_Nonspecific_Tag_Error = 1, + LLRP_ImpinjGetQTConfigResultType_No_Response_From_Tag = 2, + LLRP_ImpinjGetQTConfigResultType_Nonspecific_Reader_Error = 3, + LLRP_ImpinjGetQTConfigResultType_Incorrect_Password_Error = 4, +}; + +typedef enum LLRP_EImpinjGetQTConfigResultType + LLRP_tEImpinjGetQTConfigResultType; + +extern const LLRP_tSEnumTableEntry +LLRP_estImpinjGetQTConfigResultType[]; + + +enum LLRP_EImpinjSerializedTIDMode +{ + + LLRP_ImpinjSerializedTIDMode_Disabled = 0, + LLRP_ImpinjSerializedTIDMode_Enabled = 1, +}; + +typedef enum LLRP_EImpinjSerializedTIDMode + LLRP_tEImpinjSerializedTIDMode; + +extern const LLRP_tSEnumTableEntry +LLRP_estImpinjSerializedTIDMode[]; + + +enum LLRP_EImpinjRFPhaseAngleMode +{ + + LLRP_ImpinjRFPhaseAngleMode_Disabled = 0, + LLRP_ImpinjRFPhaseAngleMode_Enabled = 1, +}; + +typedef enum LLRP_EImpinjRFPhaseAngleMode + LLRP_tEImpinjRFPhaseAngleMode; + +extern const LLRP_tSEnumTableEntry +LLRP_estImpinjRFPhaseAngleMode[]; + + +enum LLRP_EImpinjPeakRSSIMode +{ + + LLRP_ImpinjPeakRSSIMode_Disabled = 0, + LLRP_ImpinjPeakRSSIMode_Enabled = 1, +}; + +typedef enum LLRP_EImpinjPeakRSSIMode + LLRP_tEImpinjPeakRSSIMode; + +extern const LLRP_tSEnumTableEntry +LLRP_estImpinjPeakRSSIMode[]; + + +enum LLRP_EImpinjGPSCoordinatesMode +{ + + LLRP_ImpinjGPSCoordinatesMode_Disabled = 0, + LLRP_ImpinjGPSCoordinatesMode_Enabled = 1, +}; + +typedef enum LLRP_EImpinjGPSCoordinatesMode + LLRP_tEImpinjGPSCoordinatesMode; + +extern const LLRP_tSEnumTableEntry +LLRP_estImpinjGPSCoordinatesMode[]; + + +enum LLRP_EImpinjAdvancedGPOMode +{ + + LLRP_ImpinjAdvancedGPOMode_Normal = 0, + LLRP_ImpinjAdvancedGPOMode_Pulsed = 1, + LLRP_ImpinjAdvancedGPOMode_Reader_Operational_Status = 2, + LLRP_ImpinjAdvancedGPOMode_LLRP_Connection_Status = 3, + LLRP_ImpinjAdvancedGPOMode_Reader_Inventory_Status = 4, + LLRP_ImpinjAdvancedGPOMode_Network_Connection_Status = 5, + LLRP_ImpinjAdvancedGPOMode_Reader_Inventory_Tags_Status = 6, +}; + +typedef enum LLRP_EImpinjAdvancedGPOMode + LLRP_tEImpinjAdvancedGPOMode; + +extern const LLRP_tSEnumTableEntry +LLRP_estImpinjAdvancedGPOMode[]; + + +enum LLRP_EImpinjOptimizedReadMode +{ + + LLRP_ImpinjOptimizedReadMode_Disabled = 0, + LLRP_ImpinjOptimizedReadMode_Enabled = 1, +}; + +typedef enum LLRP_EImpinjOptimizedReadMode + LLRP_tEImpinjOptimizedReadMode; + +extern const LLRP_tSEnumTableEntry +LLRP_estImpinjOptimizedReadMode[]; + + +enum LLRP_EImpinjAccessSpecOrderingMode +{ + + LLRP_ImpinjAccessSpecOrderingMode_FIFO = 0, + LLRP_ImpinjAccessSpecOrderingMode_Ascending = 1, +}; + +typedef enum LLRP_EImpinjAccessSpecOrderingMode + LLRP_tEImpinjAccessSpecOrderingMode; + +extern const LLRP_tSEnumTableEntry +LLRP_estImpinjAccessSpecOrderingMode[]; + + +enum LLRP_EImpinjRFDopplerFrequencyMode +{ + + LLRP_ImpinjRFDopplerFrequencyMode_Disabled = 0, + LLRP_ImpinjRFDopplerFrequencyMode_Enabled = 1, +}; + +typedef enum LLRP_EImpinjRFDopplerFrequencyMode + LLRP_tEImpinjRFDopplerFrequencyMode; + +extern const LLRP_tSEnumTableEntry +LLRP_estImpinjRFDopplerFrequencyMode[]; + + +enum LLRP_EImpinjTxPowerReportingModeEnum +{ + + LLRP_ImpinjTxPowerReportingModeEnum_Disabled = 0, + LLRP_ImpinjTxPowerReportingModeEnum_Enabled = 1, +}; + +typedef enum LLRP_EImpinjTxPowerReportingModeEnum + LLRP_tEImpinjTxPowerReportingModeEnum; + +extern const LLRP_tSEnumTableEntry +LLRP_estImpinjTxPowerReportingModeEnum[]; + + +enum LLRP_EImpinjXPCWordsMode +{ + + LLRP_ImpinjXPCWordsMode_Disabled = 0, + LLRP_ImpinjXPCWordsMode_Enabled = 1, +}; + +typedef enum LLRP_EImpinjXPCWordsMode + LLRP_tEImpinjXPCWordsMode; + +extern const LLRP_tSEnumTableEntry +LLRP_estImpinjXPCWordsMode[]; + + +enum LLRP_EImpinjHubConnectedType +{ + + LLRP_ImpinjHubConnectedType_Unknown = 0, + LLRP_ImpinjHubConnectedType_Disconnected = 1, + LLRP_ImpinjHubConnectedType_Connected = 2, +}; + +typedef enum LLRP_EImpinjHubConnectedType + LLRP_tEImpinjHubConnectedType; + +extern const LLRP_tSEnumTableEntry +LLRP_estImpinjHubConnectedType[]; + + +enum LLRP_EImpinjHubFaultType +{ + + LLRP_ImpinjHubFaultType_No_Fault = 0, + LLRP_ImpinjHubFaultType_RF_Power = 1, + LLRP_ImpinjHubFaultType_RF_Power_On_Hub_1 = 2, + LLRP_ImpinjHubFaultType_RF_Power_On_Hub_2 = 3, + LLRP_ImpinjHubFaultType_RF_Power_On_Hub_3 = 4, + LLRP_ImpinjHubFaultType_RF_Power_On_Hub_4 = 5, + LLRP_ImpinjHubFaultType_No_Init = 6, + LLRP_ImpinjHubFaultType_Serial_Overflow = 7, + LLRP_ImpinjHubFaultType_Disconnected = 8, +}; + +typedef enum LLRP_EImpinjHubFaultType + LLRP_tEImpinjHubFaultType; + +extern const LLRP_tSEnumTableEntry +LLRP_estImpinjHubFaultType[]; + + +enum LLRP_EImpinjLocationReportType +{ + + LLRP_ImpinjLocationReportType_Entry = 0, + LLRP_ImpinjLocationReportType_Update = 1, + LLRP_ImpinjLocationReportType_Exit = 2, +}; + +typedef enum LLRP_EImpinjLocationReportType + LLRP_tEImpinjLocationReportType; + +extern const LLRP_tSEnumTableEntry +LLRP_estImpinjLocationReportType[]; + + +enum LLRP_EImpinjDirectionFieldOfView +{ + + LLRP_ImpinjDirectionFieldOfView_ReaderSelected = 0, + LLRP_ImpinjDirectionFieldOfView_Wide = 1, + LLRP_ImpinjDirectionFieldOfView_Narrow = 2, +}; + +typedef enum LLRP_EImpinjDirectionFieldOfView + LLRP_tEImpinjDirectionFieldOfView; + +extern const LLRP_tSEnumTableEntry +LLRP_estImpinjDirectionFieldOfView[]; + + +enum LLRP_EImpinjDirectionRFMode +{ + + LLRP_ImpinjDirectionRFMode_HighSensitivity = 0, + LLRP_ImpinjDirectionRFMode_HighPerformance = 1, +}; + +typedef enum LLRP_EImpinjDirectionRFMode + LLRP_tEImpinjDirectionRFMode; + +extern const LLRP_tSEnumTableEntry +LLRP_estImpinjDirectionRFMode[]; + + +enum LLRP_EImpinjDirectionDiagnosticReportLevel +{ + + LLRP_ImpinjDirectionDiagnosticReportLevel_Off = 0, + LLRP_ImpinjDirectionDiagnosticReportLevel_Basic = 1, + LLRP_ImpinjDirectionDiagnosticReportLevel_Extended = 2, + LLRP_ImpinjDirectionDiagnosticReportLevel_Debug = 3, +}; + +typedef enum LLRP_EImpinjDirectionDiagnosticReportLevel + LLRP_tEImpinjDirectionDiagnosticReportLevel; + +extern const LLRP_tSEnumTableEntry +LLRP_estImpinjDirectionDiagnosticReportLevel[]; + + +enum LLRP_EImpinjDirectionReportType +{ + + LLRP_ImpinjDirectionReportType_Entry = 0, + LLRP_ImpinjDirectionReportType_Update = 1, + LLRP_ImpinjDirectionReportType_Exit = 2, +}; + +typedef enum LLRP_EImpinjDirectionReportType + LLRP_tEImpinjDirectionReportType; + +extern const LLRP_tSEnumTableEntry +LLRP_estImpinjDirectionReportType[]; + + +enum LLRP_EImpinjDirectionTagPopulationStatus +{ + + LLRP_ImpinjDirectionTagPopulationStatus_OK = 0, + LLRP_ImpinjDirectionTagPopulationStatus_UserOverflow = 1, + LLRP_ImpinjDirectionTagPopulationStatus_SystemOverflow = 2, +}; + +typedef enum LLRP_EImpinjDirectionTagPopulationStatus + LLRP_tEImpinjDirectionTagPopulationStatus; + +extern const LLRP_tSEnumTableEntry +LLRP_estImpinjDirectionTagPopulationStatus[]; + + +enum LLRP_EImpinjIntelligentAntennaMode +{ + + LLRP_ImpinjIntelligentAntennaMode_Disabled = 0, + LLRP_ImpinjIntelligentAntennaMode_Enabled = 1, +}; + +typedef enum LLRP_EImpinjIntelligentAntennaMode + LLRP_tEImpinjIntelligentAntennaMode; + +extern const LLRP_tSEnumTableEntry +LLRP_estImpinjIntelligentAntennaMode[]; + + +enum LLRP_EImpinjAntennaPolarizationType +{ + + LLRP_ImpinjAntennaPolarizationType_LinearHorizontal = 0, + LLRP_ImpinjAntennaPolarizationType_LinearVertical = 1, + LLRP_ImpinjAntennaPolarizationType_CircularRight = 2, + LLRP_ImpinjAntennaPolarizationType_CircularLeft = 3, +}; + +typedef enum LLRP_EImpinjAntennaPolarizationType + LLRP_tEImpinjAntennaPolarizationType; + +extern const LLRP_tSEnumTableEntry +LLRP_estImpinjAntennaPolarizationType[]; + + +enum LLRP_EImpinjMarginReadResultType +{ + + LLRP_ImpinjMarginReadResultType_Success = 0, + LLRP_ImpinjMarginReadResultType_Failure = 1, + LLRP_ImpinjMarginReadResultType_Insufficient_Power = 2, + LLRP_ImpinjMarginReadResultType_Nonspecific_Tag_Error = 3, + LLRP_ImpinjMarginReadResultType_No_Response_From_Tag = 4, + LLRP_ImpinjMarginReadResultType_Nonspecific_Reader_Error = 5, + LLRP_ImpinjMarginReadResultType_Incorrect_Password_Error = 6, + LLRP_ImpinjMarginReadResultType_Tag_Memory_Overrun_Error = 7, + LLRP_ImpinjMarginReadResultType_Tag_Memory_Locked_Error = 8, +}; + +typedef enum LLRP_EImpinjMarginReadResultType + LLRP_tEImpinjMarginReadResultType; + +extern const LLRP_tSEnumTableEntry +LLRP_estImpinjMarginReadResultType[]; + + +enum LLRP_EImpinjAuthenticateResultType +{ + + LLRP_ImpinjAuthenticateResultType_Success = 0, + LLRP_ImpinjAuthenticateResultType_Insufficient_Power = 1, + LLRP_ImpinjAuthenticateResultType_Not_Supported_Error = 2, + LLRP_ImpinjAuthenticateResultType_Nonspecific_Tag_Error = 3, + LLRP_ImpinjAuthenticateResultType_Nonspecific_Reader_Error = 4, + LLRP_ImpinjAuthenticateResultType_No_Response_From_Tag = 5, +}; + +typedef enum LLRP_EImpinjAuthenticateResultType + LLRP_tEImpinjAuthenticateResultType; + +extern const LLRP_tSEnumTableEntry +LLRP_estImpinjAuthenticateResultType[]; + + +enum LLRP_EImpinjTagFilterVerificationMode +{ + + LLRP_ImpinjTagFilterVerificationMode_Disabled = 0, + LLRP_ImpinjTagFilterVerificationMode_Active = 1, + LLRP_ImpinjTagFilterVerificationMode_Passive = 2, +}; + +typedef enum LLRP_EImpinjTagFilterVerificationMode + LLRP_tEImpinjTagFilterVerificationMode; + +extern const LLRP_tSEnumTableEntry +LLRP_estImpinjTagFilterVerificationMode[]; + + +enum LLRP_EImpinjTagPopulationEstimationMode +{ + + LLRP_ImpinjTagPopulationEstimationMode_Disabled = 0, + LLRP_ImpinjTagPopulationEstimationMode_Enabled = 1, +}; + +typedef enum LLRP_EImpinjTagPopulationEstimationMode + LLRP_tEImpinjTagPopulationEstimationMode; + +extern const LLRP_tSEnumTableEntry +LLRP_estImpinjTagPopulationEstimationMode[]; + + +enum LLRP_EImpinjCRHandleMode +{ + + LLRP_ImpinjCRHandleMode_Disabled = 0, + LLRP_ImpinjCRHandleMode_Enabled = 1, +}; + +typedef enum LLRP_EImpinjCRHandleMode + LLRP_tEImpinjCRHandleMode; + +extern const LLRP_tSEnumTableEntry +LLRP_estImpinjCRHandleMode[]; + + +enum LLRP_EImpinjEnhancedIntegraMode +{ + + LLRP_ImpinjEnhancedIntegraMode_Disabled = 0, + LLRP_ImpinjEnhancedIntegraMode_Enabled = 1, +}; + +typedef enum LLRP_EImpinjEnhancedIntegraMode + LLRP_tEImpinjEnhancedIntegraMode; + +extern const LLRP_tSEnumTableEntry +LLRP_estImpinjEnhancedIntegraMode[]; + + +enum LLRP_EImpinjEnhancedIntegraResultType +{ + + LLRP_ImpinjEnhancedIntegraResultType_No_Parity_Error = 0, + LLRP_ImpinjEnhancedIntegraResultType_PC_or_EPC_Parity_Error = 1, + LLRP_ImpinjEnhancedIntegraResultType_PC_or_EPC_or_TID_Parity_Error = 3, + LLRP_ImpinjEnhancedIntegraResultType_Memory_Read_Parity_Error = 5, +}; + +typedef enum LLRP_EImpinjEnhancedIntegraResultType + LLRP_tEImpinjEnhancedIntegraResultType; + +extern const LLRP_tSEnumTableEntry +LLRP_estImpinjEnhancedIntegraResultType[]; + + +enum LLRP_EImpinjEndpointICVerificationMode +{ + + LLRP_ImpinjEndpointICVerificationMode_Disabled = 0, + LLRP_ImpinjEndpointICVerificationMode_Enabled = 1, +}; + +typedef enum LLRP_EImpinjEndpointICVerificationMode + LLRP_tEImpinjEndpointICVerificationMode; + +extern const LLRP_tSEnumTableEntry +LLRP_estImpinjEndpointICVerificationMode[]; + + +enum LLRP_EImpinjEndpointICVerificationReportMode +{ + + LLRP_ImpinjEndpointICVerificationReportMode_Disabled = 0, + LLRP_ImpinjEndpointICVerificationReportMode_Enabled = 1, +}; + +typedef enum LLRP_EImpinjEndpointICVerificationReportMode + LLRP_tEImpinjEndpointICVerificationReportMode; + +extern const LLRP_tSEnumTableEntry +LLRP_estImpinjEndpointICVerificationReportMode[]; + + + +struct LLRP_SIMPINJ_ENABLE_EXTENSIONS +{ + LLRP_tSMessage hdr; + + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdIMPINJ_ENABLE_EXTENSIONS; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdIMPINJ_ENABLE_EXTENSIONS[]; + +extern LLRP_tSIMPINJ_ENABLE_EXTENSIONS * +LLRP_IMPINJ_ENABLE_EXTENSIONS_construct (void); + +extern void +LLRP_IMPINJ_ENABLE_EXTENSIONS_destruct ( + LLRP_tSIMPINJ_ENABLE_EXTENSIONS * pThis); + +extern void +LLRP_IMPINJ_ENABLE_EXTENSIONS_decodeFields ( + LLRP_tSIMPINJ_ENABLE_EXTENSIONS * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_IMPINJ_ENABLE_EXTENSIONS_assimilateSubParameters ( + LLRP_tSIMPINJ_ENABLE_EXTENSIONS * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_IMPINJ_ENABLE_EXTENSIONS_encode ( + const LLRP_tSIMPINJ_ENABLE_EXTENSIONS *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + + +extern LLRP_tSParameter * +LLRP_IMPINJ_ENABLE_EXTENSIONS_beginCustom ( + LLRP_tSIMPINJ_ENABLE_EXTENSIONS *pThis); + +extern LLRP_tSParameter * +LLRP_IMPINJ_ENABLE_EXTENSIONS_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_IMPINJ_ENABLE_EXTENSIONS_clearCustom ( + LLRP_tSIMPINJ_ENABLE_EXTENSIONS *pThis); + +extern int +LLRP_IMPINJ_ENABLE_EXTENSIONS_countCustom ( + LLRP_tSIMPINJ_ENABLE_EXTENSIONS *pThis); + +extern LLRP_tResultCode +LLRP_IMPINJ_ENABLE_EXTENSIONS_addCustom ( + LLRP_tSIMPINJ_ENABLE_EXTENSIONS *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SIMPINJ_ENABLE_EXTENSIONS_RESPONSE +{ + LLRP_tSMessage hdr; + + + LLRP_tSLLRPStatus * pLLRPStatus; + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdIMPINJ_ENABLE_EXTENSIONS_RESPONSE; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdIMPINJ_ENABLE_EXTENSIONS_RESPONSE[]; + +extern LLRP_tSIMPINJ_ENABLE_EXTENSIONS_RESPONSE * +LLRP_IMPINJ_ENABLE_EXTENSIONS_RESPONSE_construct (void); + +extern void +LLRP_IMPINJ_ENABLE_EXTENSIONS_RESPONSE_destruct ( + LLRP_tSIMPINJ_ENABLE_EXTENSIONS_RESPONSE * pThis); + +extern void +LLRP_IMPINJ_ENABLE_EXTENSIONS_RESPONSE_decodeFields ( + LLRP_tSIMPINJ_ENABLE_EXTENSIONS_RESPONSE * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_IMPINJ_ENABLE_EXTENSIONS_RESPONSE_assimilateSubParameters ( + LLRP_tSIMPINJ_ENABLE_EXTENSIONS_RESPONSE * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_IMPINJ_ENABLE_EXTENSIONS_RESPONSE_encode ( + const LLRP_tSIMPINJ_ENABLE_EXTENSIONS_RESPONSE *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + + +extern LLRP_tSLLRPStatus * +LLRP_IMPINJ_ENABLE_EXTENSIONS_RESPONSE_getLLRPStatus ( + LLRP_tSIMPINJ_ENABLE_EXTENSIONS_RESPONSE *pThis); + +extern LLRP_tResultCode +LLRP_IMPINJ_ENABLE_EXTENSIONS_RESPONSE_setLLRPStatus ( + LLRP_tSIMPINJ_ENABLE_EXTENSIONS_RESPONSE *pThis, + LLRP_tSLLRPStatus *pValue); + +extern LLRP_tSParameter * +LLRP_IMPINJ_ENABLE_EXTENSIONS_RESPONSE_beginCustom ( + LLRP_tSIMPINJ_ENABLE_EXTENSIONS_RESPONSE *pThis); + +extern LLRP_tSParameter * +LLRP_IMPINJ_ENABLE_EXTENSIONS_RESPONSE_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_IMPINJ_ENABLE_EXTENSIONS_RESPONSE_clearCustom ( + LLRP_tSIMPINJ_ENABLE_EXTENSIONS_RESPONSE *pThis); + +extern int +LLRP_IMPINJ_ENABLE_EXTENSIONS_RESPONSE_countCustom ( + LLRP_tSIMPINJ_ENABLE_EXTENSIONS_RESPONSE *pThis); + +extern LLRP_tResultCode +LLRP_IMPINJ_ENABLE_EXTENSIONS_RESPONSE_addCustom ( + LLRP_tSIMPINJ_ENABLE_EXTENSIONS_RESPONSE *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SIMPINJ_SAVE_SETTINGS +{ + LLRP_tSMessage hdr; + + llrp_u1_t SaveConfiguration; + + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdIMPINJ_SAVE_SETTINGS; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdIMPINJ_SAVE_SETTINGS[]; + +extern LLRP_tSIMPINJ_SAVE_SETTINGS * +LLRP_IMPINJ_SAVE_SETTINGS_construct (void); + +extern void +LLRP_IMPINJ_SAVE_SETTINGS_destruct ( + LLRP_tSIMPINJ_SAVE_SETTINGS * pThis); + +extern void +LLRP_IMPINJ_SAVE_SETTINGS_decodeFields ( + LLRP_tSIMPINJ_SAVE_SETTINGS * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_IMPINJ_SAVE_SETTINGS_assimilateSubParameters ( + LLRP_tSIMPINJ_SAVE_SETTINGS * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_IMPINJ_SAVE_SETTINGS_encode ( + const LLRP_tSIMPINJ_SAVE_SETTINGS *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdIMPINJ_SAVE_SETTINGS_SaveConfiguration; + +extern llrp_u1_t +LLRP_IMPINJ_SAVE_SETTINGS_getSaveConfiguration ( + LLRP_tSIMPINJ_SAVE_SETTINGS *pThis); + +extern LLRP_tResultCode +LLRP_IMPINJ_SAVE_SETTINGS_setSaveConfiguration ( + LLRP_tSIMPINJ_SAVE_SETTINGS *pThis, + llrp_u1_t Value); + + +extern LLRP_tSParameter * +LLRP_IMPINJ_SAVE_SETTINGS_beginCustom ( + LLRP_tSIMPINJ_SAVE_SETTINGS *pThis); + +extern LLRP_tSParameter * +LLRP_IMPINJ_SAVE_SETTINGS_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_IMPINJ_SAVE_SETTINGS_clearCustom ( + LLRP_tSIMPINJ_SAVE_SETTINGS *pThis); + +extern int +LLRP_IMPINJ_SAVE_SETTINGS_countCustom ( + LLRP_tSIMPINJ_SAVE_SETTINGS *pThis); + +extern LLRP_tResultCode +LLRP_IMPINJ_SAVE_SETTINGS_addCustom ( + LLRP_tSIMPINJ_SAVE_SETTINGS *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SIMPINJ_SAVE_SETTINGS_RESPONSE +{ + LLRP_tSMessage hdr; + + + LLRP_tSLLRPStatus * pLLRPStatus; + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdIMPINJ_SAVE_SETTINGS_RESPONSE; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdIMPINJ_SAVE_SETTINGS_RESPONSE[]; + +extern LLRP_tSIMPINJ_SAVE_SETTINGS_RESPONSE * +LLRP_IMPINJ_SAVE_SETTINGS_RESPONSE_construct (void); + +extern void +LLRP_IMPINJ_SAVE_SETTINGS_RESPONSE_destruct ( + LLRP_tSIMPINJ_SAVE_SETTINGS_RESPONSE * pThis); + +extern void +LLRP_IMPINJ_SAVE_SETTINGS_RESPONSE_decodeFields ( + LLRP_tSIMPINJ_SAVE_SETTINGS_RESPONSE * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_IMPINJ_SAVE_SETTINGS_RESPONSE_assimilateSubParameters ( + LLRP_tSIMPINJ_SAVE_SETTINGS_RESPONSE * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_IMPINJ_SAVE_SETTINGS_RESPONSE_encode ( + const LLRP_tSIMPINJ_SAVE_SETTINGS_RESPONSE *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + + +extern LLRP_tSLLRPStatus * +LLRP_IMPINJ_SAVE_SETTINGS_RESPONSE_getLLRPStatus ( + LLRP_tSIMPINJ_SAVE_SETTINGS_RESPONSE *pThis); + +extern LLRP_tResultCode +LLRP_IMPINJ_SAVE_SETTINGS_RESPONSE_setLLRPStatus ( + LLRP_tSIMPINJ_SAVE_SETTINGS_RESPONSE *pThis, + LLRP_tSLLRPStatus *pValue); + +extern LLRP_tSParameter * +LLRP_IMPINJ_SAVE_SETTINGS_RESPONSE_beginCustom ( + LLRP_tSIMPINJ_SAVE_SETTINGS_RESPONSE *pThis); + +extern LLRP_tSParameter * +LLRP_IMPINJ_SAVE_SETTINGS_RESPONSE_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_IMPINJ_SAVE_SETTINGS_RESPONSE_clearCustom ( + LLRP_tSIMPINJ_SAVE_SETTINGS_RESPONSE *pThis); + +extern int +LLRP_IMPINJ_SAVE_SETTINGS_RESPONSE_countCustom ( + LLRP_tSIMPINJ_SAVE_SETTINGS_RESPONSE *pThis); + +extern LLRP_tResultCode +LLRP_IMPINJ_SAVE_SETTINGS_RESPONSE_addCustom ( + LLRP_tSIMPINJ_SAVE_SETTINGS_RESPONSE *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjRequestedData +{ + LLRP_tSParameter hdr; + + LLRP_tEImpinjRequestedDataType eRequestedData; + + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjRequestedData; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjRequestedData[]; + +extern LLRP_tSImpinjRequestedData * +LLRP_ImpinjRequestedData_construct (void); + +extern void +LLRP_ImpinjRequestedData_destruct ( + LLRP_tSImpinjRequestedData * pThis); + +extern void +LLRP_ImpinjRequestedData_decodeFields ( + LLRP_tSImpinjRequestedData * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjRequestedData_assimilateSubParameters ( + LLRP_tSImpinjRequestedData * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjRequestedData_encode ( + const LLRP_tSImpinjRequestedData *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjRequestedData_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjRequestedData_RequestedData; + +extern LLRP_tEImpinjRequestedDataType +LLRP_ImpinjRequestedData_getRequestedData ( + LLRP_tSImpinjRequestedData *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjRequestedData_setRequestedData ( + LLRP_tSImpinjRequestedData *pThis, + LLRP_tEImpinjRequestedDataType Value); + + +extern LLRP_tSParameter * +LLRP_ImpinjRequestedData_beginCustom ( + LLRP_tSImpinjRequestedData *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjRequestedData_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjRequestedData_clearCustom ( + LLRP_tSImpinjRequestedData *pThis); + +extern int +LLRP_ImpinjRequestedData_countCustom ( + LLRP_tSImpinjRequestedData *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjRequestedData_addCustom ( + LLRP_tSImpinjRequestedData *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjSubRegulatoryRegion +{ + LLRP_tSParameter hdr; + + LLRP_tEImpinjRegulatoryRegion eRegulatoryRegion; + + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjSubRegulatoryRegion; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjSubRegulatoryRegion[]; + +extern LLRP_tSImpinjSubRegulatoryRegion * +LLRP_ImpinjSubRegulatoryRegion_construct (void); + +extern void +LLRP_ImpinjSubRegulatoryRegion_destruct ( + LLRP_tSImpinjSubRegulatoryRegion * pThis); + +extern void +LLRP_ImpinjSubRegulatoryRegion_decodeFields ( + LLRP_tSImpinjSubRegulatoryRegion * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjSubRegulatoryRegion_assimilateSubParameters ( + LLRP_tSImpinjSubRegulatoryRegion * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjSubRegulatoryRegion_encode ( + const LLRP_tSImpinjSubRegulatoryRegion *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjSubRegulatoryRegion_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjSubRegulatoryRegion_RegulatoryRegion; + +extern LLRP_tEImpinjRegulatoryRegion +LLRP_ImpinjSubRegulatoryRegion_getRegulatoryRegion ( + LLRP_tSImpinjSubRegulatoryRegion *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjSubRegulatoryRegion_setRegulatoryRegion ( + LLRP_tSImpinjSubRegulatoryRegion *pThis, + LLRP_tEImpinjRegulatoryRegion Value); + + +extern LLRP_tSParameter * +LLRP_ImpinjSubRegulatoryRegion_beginCustom ( + LLRP_tSImpinjSubRegulatoryRegion *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjSubRegulatoryRegion_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjSubRegulatoryRegion_clearCustom ( + LLRP_tSImpinjSubRegulatoryRegion *pThis); + +extern int +LLRP_ImpinjSubRegulatoryRegion_countCustom ( + LLRP_tSImpinjSubRegulatoryRegion *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjSubRegulatoryRegion_addCustom ( + LLRP_tSImpinjSubRegulatoryRegion *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjInventorySearchMode +{ + LLRP_tSParameter hdr; + + LLRP_tEImpinjInventorySearchType eInventorySearchMode; + + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjInventorySearchMode; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjInventorySearchMode[]; + +extern LLRP_tSImpinjInventorySearchMode * +LLRP_ImpinjInventorySearchMode_construct (void); + +extern void +LLRP_ImpinjInventorySearchMode_destruct ( + LLRP_tSImpinjInventorySearchMode * pThis); + +extern void +LLRP_ImpinjInventorySearchMode_decodeFields ( + LLRP_tSImpinjInventorySearchMode * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjInventorySearchMode_assimilateSubParameters ( + LLRP_tSImpinjInventorySearchMode * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjInventorySearchMode_encode ( + const LLRP_tSImpinjInventorySearchMode *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjInventorySearchMode_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjInventorySearchMode_InventorySearchMode; + +extern LLRP_tEImpinjInventorySearchType +LLRP_ImpinjInventorySearchMode_getInventorySearchMode ( + LLRP_tSImpinjInventorySearchMode *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjInventorySearchMode_setInventorySearchMode ( + LLRP_tSImpinjInventorySearchMode *pThis, + LLRP_tEImpinjInventorySearchType Value); + + +extern LLRP_tSParameter * +LLRP_ImpinjInventorySearchMode_beginCustom ( + LLRP_tSImpinjInventorySearchMode *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjInventorySearchMode_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjInventorySearchMode_clearCustom ( + LLRP_tSImpinjInventorySearchMode *pThis); + +extern int +LLRP_ImpinjInventorySearchMode_countCustom ( + LLRP_tSImpinjInventorySearchMode *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjInventorySearchMode_addCustom ( + LLRP_tSImpinjInventorySearchMode *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjFixedFrequencyList +{ + LLRP_tSParameter hdr; + + LLRP_tEImpinjFixedFrequencyMode eFixedFrequencyMode; + + llrp_u16v_t ChannelList; + + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjFixedFrequencyList; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjFixedFrequencyList[]; + +extern LLRP_tSImpinjFixedFrequencyList * +LLRP_ImpinjFixedFrequencyList_construct (void); + +extern void +LLRP_ImpinjFixedFrequencyList_destruct ( + LLRP_tSImpinjFixedFrequencyList * pThis); + +extern void +LLRP_ImpinjFixedFrequencyList_decodeFields ( + LLRP_tSImpinjFixedFrequencyList * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjFixedFrequencyList_assimilateSubParameters ( + LLRP_tSImpinjFixedFrequencyList * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjFixedFrequencyList_encode ( + const LLRP_tSImpinjFixedFrequencyList *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjFixedFrequencyList_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjFixedFrequencyList_FixedFrequencyMode; + +extern LLRP_tEImpinjFixedFrequencyMode +LLRP_ImpinjFixedFrequencyList_getFixedFrequencyMode ( + LLRP_tSImpinjFixedFrequencyList *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjFixedFrequencyList_setFixedFrequencyMode ( + LLRP_tSImpinjFixedFrequencyList *pThis, + LLRP_tEImpinjFixedFrequencyMode Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjFixedFrequencyList_ChannelList; + +extern llrp_u16v_t +LLRP_ImpinjFixedFrequencyList_getChannelList ( + LLRP_tSImpinjFixedFrequencyList *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjFixedFrequencyList_setChannelList ( + LLRP_tSImpinjFixedFrequencyList *pThis, + llrp_u16v_t Value); + + +extern LLRP_tSParameter * +LLRP_ImpinjFixedFrequencyList_beginCustom ( + LLRP_tSImpinjFixedFrequencyList *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjFixedFrequencyList_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjFixedFrequencyList_clearCustom ( + LLRP_tSImpinjFixedFrequencyList *pThis); + +extern int +LLRP_ImpinjFixedFrequencyList_countCustom ( + LLRP_tSImpinjFixedFrequencyList *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjFixedFrequencyList_addCustom ( + LLRP_tSImpinjFixedFrequencyList *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjReducedPowerFrequencyList +{ + LLRP_tSParameter hdr; + + LLRP_tEImpinjReducedPowerMode eReducedPowerMode; + + llrp_u16v_t ChannelList; + + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjReducedPowerFrequencyList; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjReducedPowerFrequencyList[]; + +extern LLRP_tSImpinjReducedPowerFrequencyList * +LLRP_ImpinjReducedPowerFrequencyList_construct (void); + +extern void +LLRP_ImpinjReducedPowerFrequencyList_destruct ( + LLRP_tSImpinjReducedPowerFrequencyList * pThis); + +extern void +LLRP_ImpinjReducedPowerFrequencyList_decodeFields ( + LLRP_tSImpinjReducedPowerFrequencyList * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjReducedPowerFrequencyList_assimilateSubParameters ( + LLRP_tSImpinjReducedPowerFrequencyList * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjReducedPowerFrequencyList_encode ( + const LLRP_tSImpinjReducedPowerFrequencyList *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjReducedPowerFrequencyList_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjReducedPowerFrequencyList_ReducedPowerMode; + +extern LLRP_tEImpinjReducedPowerMode +LLRP_ImpinjReducedPowerFrequencyList_getReducedPowerMode ( + LLRP_tSImpinjReducedPowerFrequencyList *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjReducedPowerFrequencyList_setReducedPowerMode ( + LLRP_tSImpinjReducedPowerFrequencyList *pThis, + LLRP_tEImpinjReducedPowerMode Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjReducedPowerFrequencyList_ChannelList; + +extern llrp_u16v_t +LLRP_ImpinjReducedPowerFrequencyList_getChannelList ( + LLRP_tSImpinjReducedPowerFrequencyList *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjReducedPowerFrequencyList_setChannelList ( + LLRP_tSImpinjReducedPowerFrequencyList *pThis, + llrp_u16v_t Value); + + +extern LLRP_tSParameter * +LLRP_ImpinjReducedPowerFrequencyList_beginCustom ( + LLRP_tSImpinjReducedPowerFrequencyList *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjReducedPowerFrequencyList_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjReducedPowerFrequencyList_clearCustom ( + LLRP_tSImpinjReducedPowerFrequencyList *pThis); + +extern int +LLRP_ImpinjReducedPowerFrequencyList_countCustom ( + LLRP_tSImpinjReducedPowerFrequencyList *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjReducedPowerFrequencyList_addCustom ( + LLRP_tSImpinjReducedPowerFrequencyList *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjLowDutyCycle +{ + LLRP_tSParameter hdr; + + LLRP_tEImpinjLowDutyCycleMode eLowDutyCycleMode; + + llrp_u16_t EmptyFieldTimeout; + + llrp_u16_t FieldPingInterval; + + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjLowDutyCycle; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjLowDutyCycle[]; + +extern LLRP_tSImpinjLowDutyCycle * +LLRP_ImpinjLowDutyCycle_construct (void); + +extern void +LLRP_ImpinjLowDutyCycle_destruct ( + LLRP_tSImpinjLowDutyCycle * pThis); + +extern void +LLRP_ImpinjLowDutyCycle_decodeFields ( + LLRP_tSImpinjLowDutyCycle * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjLowDutyCycle_assimilateSubParameters ( + LLRP_tSImpinjLowDutyCycle * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjLowDutyCycle_encode ( + const LLRP_tSImpinjLowDutyCycle *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjLowDutyCycle_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjLowDutyCycle_LowDutyCycleMode; + +extern LLRP_tEImpinjLowDutyCycleMode +LLRP_ImpinjLowDutyCycle_getLowDutyCycleMode ( + LLRP_tSImpinjLowDutyCycle *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjLowDutyCycle_setLowDutyCycleMode ( + LLRP_tSImpinjLowDutyCycle *pThis, + LLRP_tEImpinjLowDutyCycleMode Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjLowDutyCycle_EmptyFieldTimeout; + +extern llrp_u16_t +LLRP_ImpinjLowDutyCycle_getEmptyFieldTimeout ( + LLRP_tSImpinjLowDutyCycle *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjLowDutyCycle_setEmptyFieldTimeout ( + LLRP_tSImpinjLowDutyCycle *pThis, + llrp_u16_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjLowDutyCycle_FieldPingInterval; + +extern llrp_u16_t +LLRP_ImpinjLowDutyCycle_getFieldPingInterval ( + LLRP_tSImpinjLowDutyCycle *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjLowDutyCycle_setFieldPingInterval ( + LLRP_tSImpinjLowDutyCycle *pThis, + llrp_u16_t Value); + + +extern LLRP_tSParameter * +LLRP_ImpinjLowDutyCycle_beginCustom ( + LLRP_tSImpinjLowDutyCycle *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjLowDutyCycle_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjLowDutyCycle_clearCustom ( + LLRP_tSImpinjLowDutyCycle *pThis); + +extern int +LLRP_ImpinjLowDutyCycle_countCustom ( + LLRP_tSImpinjLowDutyCycle *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjLowDutyCycle_addCustom ( + LLRP_tSImpinjLowDutyCycle *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjHubVersions +{ + LLRP_tSParameter hdr; + + + LLRP_tSImpinjArrayVersion * listImpinjArrayVersion; + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjHubVersions; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjHubVersions[]; + +extern LLRP_tSImpinjHubVersions * +LLRP_ImpinjHubVersions_construct (void); + +extern void +LLRP_ImpinjHubVersions_destruct ( + LLRP_tSImpinjHubVersions * pThis); + +extern void +LLRP_ImpinjHubVersions_decodeFields ( + LLRP_tSImpinjHubVersions * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjHubVersions_assimilateSubParameters ( + LLRP_tSImpinjHubVersions * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjHubVersions_encode ( + const LLRP_tSImpinjHubVersions *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjHubVersions_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + + +extern LLRP_tSImpinjArrayVersion * +LLRP_ImpinjHubVersions_beginImpinjArrayVersion ( + LLRP_tSImpinjHubVersions *pThis); + +extern LLRP_tSImpinjArrayVersion * +LLRP_ImpinjHubVersions_nextImpinjArrayVersion ( + LLRP_tSImpinjArrayVersion *pCurrent); + +extern void +LLRP_ImpinjHubVersions_clearImpinjArrayVersion ( + LLRP_tSImpinjHubVersions *pThis); + +extern int +LLRP_ImpinjHubVersions_countImpinjArrayVersion ( + LLRP_tSImpinjHubVersions *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjHubVersions_addImpinjArrayVersion ( + LLRP_tSImpinjHubVersions *pThis, + LLRP_tSImpinjArrayVersion *pValue); + + +extern LLRP_tSParameter * +LLRP_ImpinjHubVersions_beginCustom ( + LLRP_tSImpinjHubVersions *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjHubVersions_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjHubVersions_clearCustom ( + LLRP_tSImpinjHubVersions *pThis); + +extern int +LLRP_ImpinjHubVersions_countCustom ( + LLRP_tSImpinjHubVersions *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjHubVersions_addCustom ( + LLRP_tSImpinjHubVersions *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjDetailedVersion +{ + LLRP_tSParameter hdr; + + llrp_utf8v_t ModelName; + + llrp_utf8v_t SerialNumber; + + llrp_utf8v_t SoftwareVersion; + + llrp_utf8v_t FirmwareVersion; + + llrp_utf8v_t FPGAVersion; + + llrp_utf8v_t PCBAVersion; + + + LLRP_tSImpinjHubVersions * pImpinjHubVersions; + + LLRP_tSImpinjArrayVersion * pImpinjArrayVersion; + + LLRP_tSImpinjBLEVersion * pImpinjBLEVersion; + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjDetailedVersion; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjDetailedVersion[]; + +extern LLRP_tSImpinjDetailedVersion * +LLRP_ImpinjDetailedVersion_construct (void); + +extern void +LLRP_ImpinjDetailedVersion_destruct ( + LLRP_tSImpinjDetailedVersion * pThis); + +extern void +LLRP_ImpinjDetailedVersion_decodeFields ( + LLRP_tSImpinjDetailedVersion * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjDetailedVersion_assimilateSubParameters ( + LLRP_tSImpinjDetailedVersion * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjDetailedVersion_encode ( + const LLRP_tSImpinjDetailedVersion *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjDetailedVersion_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjDetailedVersion_ModelName; + +extern llrp_utf8v_t +LLRP_ImpinjDetailedVersion_getModelName ( + LLRP_tSImpinjDetailedVersion *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjDetailedVersion_setModelName ( + LLRP_tSImpinjDetailedVersion *pThis, + llrp_utf8v_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjDetailedVersion_SerialNumber; + +extern llrp_utf8v_t +LLRP_ImpinjDetailedVersion_getSerialNumber ( + LLRP_tSImpinjDetailedVersion *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjDetailedVersion_setSerialNumber ( + LLRP_tSImpinjDetailedVersion *pThis, + llrp_utf8v_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjDetailedVersion_SoftwareVersion; + +extern llrp_utf8v_t +LLRP_ImpinjDetailedVersion_getSoftwareVersion ( + LLRP_tSImpinjDetailedVersion *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjDetailedVersion_setSoftwareVersion ( + LLRP_tSImpinjDetailedVersion *pThis, + llrp_utf8v_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjDetailedVersion_FirmwareVersion; + +extern llrp_utf8v_t +LLRP_ImpinjDetailedVersion_getFirmwareVersion ( + LLRP_tSImpinjDetailedVersion *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjDetailedVersion_setFirmwareVersion ( + LLRP_tSImpinjDetailedVersion *pThis, + llrp_utf8v_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjDetailedVersion_FPGAVersion; + +extern llrp_utf8v_t +LLRP_ImpinjDetailedVersion_getFPGAVersion ( + LLRP_tSImpinjDetailedVersion *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjDetailedVersion_setFPGAVersion ( + LLRP_tSImpinjDetailedVersion *pThis, + llrp_utf8v_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjDetailedVersion_PCBAVersion; + +extern llrp_utf8v_t +LLRP_ImpinjDetailedVersion_getPCBAVersion ( + LLRP_tSImpinjDetailedVersion *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjDetailedVersion_setPCBAVersion ( + LLRP_tSImpinjDetailedVersion *pThis, + llrp_utf8v_t Value); + + +extern LLRP_tSImpinjHubVersions * +LLRP_ImpinjDetailedVersion_getImpinjHubVersions ( + LLRP_tSImpinjDetailedVersion *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjDetailedVersion_setImpinjHubVersions ( + LLRP_tSImpinjDetailedVersion *pThis, + LLRP_tSImpinjHubVersions *pValue); + +extern LLRP_tSImpinjArrayVersion * +LLRP_ImpinjDetailedVersion_getImpinjArrayVersion ( + LLRP_tSImpinjDetailedVersion *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjDetailedVersion_setImpinjArrayVersion ( + LLRP_tSImpinjDetailedVersion *pThis, + LLRP_tSImpinjArrayVersion *pValue); + +extern LLRP_tSImpinjBLEVersion * +LLRP_ImpinjDetailedVersion_getImpinjBLEVersion ( + LLRP_tSImpinjDetailedVersion *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjDetailedVersion_setImpinjBLEVersion ( + LLRP_tSImpinjDetailedVersion *pThis, + LLRP_tSImpinjBLEVersion *pValue); + +extern LLRP_tSParameter * +LLRP_ImpinjDetailedVersion_beginCustom ( + LLRP_tSImpinjDetailedVersion *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjDetailedVersion_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjDetailedVersion_clearCustom ( + LLRP_tSImpinjDetailedVersion *pThis); + +extern int +LLRP_ImpinjDetailedVersion_countCustom ( + LLRP_tSImpinjDetailedVersion *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjDetailedVersion_addCustom ( + LLRP_tSImpinjDetailedVersion *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjFrequencyCapabilities +{ + LLRP_tSParameter hdr; + + llrp_u32v_t FrequencyList; + + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjFrequencyCapabilities; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjFrequencyCapabilities[]; + +extern LLRP_tSImpinjFrequencyCapabilities * +LLRP_ImpinjFrequencyCapabilities_construct (void); + +extern void +LLRP_ImpinjFrequencyCapabilities_destruct ( + LLRP_tSImpinjFrequencyCapabilities * pThis); + +extern void +LLRP_ImpinjFrequencyCapabilities_decodeFields ( + LLRP_tSImpinjFrequencyCapabilities * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjFrequencyCapabilities_assimilateSubParameters ( + LLRP_tSImpinjFrequencyCapabilities * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjFrequencyCapabilities_encode ( + const LLRP_tSImpinjFrequencyCapabilities *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjFrequencyCapabilities_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjFrequencyCapabilities_FrequencyList; + +extern llrp_u32v_t +LLRP_ImpinjFrequencyCapabilities_getFrequencyList ( + LLRP_tSImpinjFrequencyCapabilities *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjFrequencyCapabilities_setFrequencyList ( + LLRP_tSImpinjFrequencyCapabilities *pThis, + llrp_u32v_t Value); + + +extern LLRP_tSParameter * +LLRP_ImpinjFrequencyCapabilities_beginCustom ( + LLRP_tSImpinjFrequencyCapabilities *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjFrequencyCapabilities_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjFrequencyCapabilities_clearCustom ( + LLRP_tSImpinjFrequencyCapabilities *pThis); + +extern int +LLRP_ImpinjFrequencyCapabilities_countCustom ( + LLRP_tSImpinjFrequencyCapabilities *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjFrequencyCapabilities_addCustom ( + LLRP_tSImpinjFrequencyCapabilities *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjGPIDebounceConfiguration +{ + LLRP_tSParameter hdr; + + llrp_u16_t GPIPortNum; + + llrp_u32_t GPIDebounceTimerMSec; + + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjGPIDebounceConfiguration; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjGPIDebounceConfiguration[]; + +extern LLRP_tSImpinjGPIDebounceConfiguration * +LLRP_ImpinjGPIDebounceConfiguration_construct (void); + +extern void +LLRP_ImpinjGPIDebounceConfiguration_destruct ( + LLRP_tSImpinjGPIDebounceConfiguration * pThis); + +extern void +LLRP_ImpinjGPIDebounceConfiguration_decodeFields ( + LLRP_tSImpinjGPIDebounceConfiguration * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjGPIDebounceConfiguration_assimilateSubParameters ( + LLRP_tSImpinjGPIDebounceConfiguration * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjGPIDebounceConfiguration_encode ( + const LLRP_tSImpinjGPIDebounceConfiguration *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjGPIDebounceConfiguration_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjGPIDebounceConfiguration_GPIPortNum; + +extern llrp_u16_t +LLRP_ImpinjGPIDebounceConfiguration_getGPIPortNum ( + LLRP_tSImpinjGPIDebounceConfiguration *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjGPIDebounceConfiguration_setGPIPortNum ( + LLRP_tSImpinjGPIDebounceConfiguration *pThis, + llrp_u16_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjGPIDebounceConfiguration_GPIDebounceTimerMSec; + +extern llrp_u32_t +LLRP_ImpinjGPIDebounceConfiguration_getGPIDebounceTimerMSec ( + LLRP_tSImpinjGPIDebounceConfiguration *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjGPIDebounceConfiguration_setGPIDebounceTimerMSec ( + LLRP_tSImpinjGPIDebounceConfiguration *pThis, + llrp_u32_t Value); + + +extern LLRP_tSParameter * +LLRP_ImpinjGPIDebounceConfiguration_beginCustom ( + LLRP_tSImpinjGPIDebounceConfiguration *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjGPIDebounceConfiguration_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjGPIDebounceConfiguration_clearCustom ( + LLRP_tSImpinjGPIDebounceConfiguration *pThis); + +extern int +LLRP_ImpinjGPIDebounceConfiguration_countCustom ( + LLRP_tSImpinjGPIDebounceConfiguration *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjGPIDebounceConfiguration_addCustom ( + LLRP_tSImpinjGPIDebounceConfiguration *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjReaderTemperature +{ + LLRP_tSParameter hdr; + + llrp_s16_t Temperature; + + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjReaderTemperature; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjReaderTemperature[]; + +extern LLRP_tSImpinjReaderTemperature * +LLRP_ImpinjReaderTemperature_construct (void); + +extern void +LLRP_ImpinjReaderTemperature_destruct ( + LLRP_tSImpinjReaderTemperature * pThis); + +extern void +LLRP_ImpinjReaderTemperature_decodeFields ( + LLRP_tSImpinjReaderTemperature * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjReaderTemperature_assimilateSubParameters ( + LLRP_tSImpinjReaderTemperature * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjReaderTemperature_encode ( + const LLRP_tSImpinjReaderTemperature *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjReaderTemperature_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjReaderTemperature_Temperature; + +extern llrp_s16_t +LLRP_ImpinjReaderTemperature_getTemperature ( + LLRP_tSImpinjReaderTemperature *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjReaderTemperature_setTemperature ( + LLRP_tSImpinjReaderTemperature *pThis, + llrp_s16_t Value); + + +extern LLRP_tSParameter * +LLRP_ImpinjReaderTemperature_beginCustom ( + LLRP_tSImpinjReaderTemperature *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjReaderTemperature_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjReaderTemperature_clearCustom ( + LLRP_tSImpinjReaderTemperature *pThis); + +extern int +LLRP_ImpinjReaderTemperature_countCustom ( + LLRP_tSImpinjReaderTemperature *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjReaderTemperature_addCustom ( + LLRP_tSImpinjReaderTemperature *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjLinkMonitorConfiguration +{ + LLRP_tSParameter hdr; + + LLRP_tEImpinjLinkMonitorMode eLinkMonitorMode; + + llrp_u16_t LinkDownThreshold; + + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjLinkMonitorConfiguration; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjLinkMonitorConfiguration[]; + +extern LLRP_tSImpinjLinkMonitorConfiguration * +LLRP_ImpinjLinkMonitorConfiguration_construct (void); + +extern void +LLRP_ImpinjLinkMonitorConfiguration_destruct ( + LLRP_tSImpinjLinkMonitorConfiguration * pThis); + +extern void +LLRP_ImpinjLinkMonitorConfiguration_decodeFields ( + LLRP_tSImpinjLinkMonitorConfiguration * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjLinkMonitorConfiguration_assimilateSubParameters ( + LLRP_tSImpinjLinkMonitorConfiguration * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjLinkMonitorConfiguration_encode ( + const LLRP_tSImpinjLinkMonitorConfiguration *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjLinkMonitorConfiguration_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjLinkMonitorConfiguration_LinkMonitorMode; + +extern LLRP_tEImpinjLinkMonitorMode +LLRP_ImpinjLinkMonitorConfiguration_getLinkMonitorMode ( + LLRP_tSImpinjLinkMonitorConfiguration *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjLinkMonitorConfiguration_setLinkMonitorMode ( + LLRP_tSImpinjLinkMonitorConfiguration *pThis, + LLRP_tEImpinjLinkMonitorMode Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjLinkMonitorConfiguration_LinkDownThreshold; + +extern llrp_u16_t +LLRP_ImpinjLinkMonitorConfiguration_getLinkDownThreshold ( + LLRP_tSImpinjLinkMonitorConfiguration *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjLinkMonitorConfiguration_setLinkDownThreshold ( + LLRP_tSImpinjLinkMonitorConfiguration *pThis, + llrp_u16_t Value); + + +extern LLRP_tSParameter * +LLRP_ImpinjLinkMonitorConfiguration_beginCustom ( + LLRP_tSImpinjLinkMonitorConfiguration *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjLinkMonitorConfiguration_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjLinkMonitorConfiguration_clearCustom ( + LLRP_tSImpinjLinkMonitorConfiguration *pThis); + +extern int +LLRP_ImpinjLinkMonitorConfiguration_countCustom ( + LLRP_tSImpinjLinkMonitorConfiguration *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjLinkMonitorConfiguration_addCustom ( + LLRP_tSImpinjLinkMonitorConfiguration *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjReportBufferConfiguration +{ + LLRP_tSParameter hdr; + + LLRP_tEImpinjReportBufferMode eReportBufferMode; + + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjReportBufferConfiguration; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjReportBufferConfiguration[]; + +extern LLRP_tSImpinjReportBufferConfiguration * +LLRP_ImpinjReportBufferConfiguration_construct (void); + +extern void +LLRP_ImpinjReportBufferConfiguration_destruct ( + LLRP_tSImpinjReportBufferConfiguration * pThis); + +extern void +LLRP_ImpinjReportBufferConfiguration_decodeFields ( + LLRP_tSImpinjReportBufferConfiguration * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjReportBufferConfiguration_assimilateSubParameters ( + LLRP_tSImpinjReportBufferConfiguration * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjReportBufferConfiguration_encode ( + const LLRP_tSImpinjReportBufferConfiguration *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjReportBufferConfiguration_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjReportBufferConfiguration_ReportBufferMode; + +extern LLRP_tEImpinjReportBufferMode +LLRP_ImpinjReportBufferConfiguration_getReportBufferMode ( + LLRP_tSImpinjReportBufferConfiguration *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjReportBufferConfiguration_setReportBufferMode ( + LLRP_tSImpinjReportBufferConfiguration *pThis, + LLRP_tEImpinjReportBufferMode Value); + + +extern LLRP_tSParameter * +LLRP_ImpinjReportBufferConfiguration_beginCustom ( + LLRP_tSImpinjReportBufferConfiguration *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjReportBufferConfiguration_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjReportBufferConfiguration_clearCustom ( + LLRP_tSImpinjReportBufferConfiguration *pThis); + +extern int +LLRP_ImpinjReportBufferConfiguration_countCustom ( + LLRP_tSImpinjReportBufferConfiguration *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjReportBufferConfiguration_addCustom ( + LLRP_tSImpinjReportBufferConfiguration *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjAccessSpecConfiguration +{ + LLRP_tSParameter hdr; + + + LLRP_tSImpinjBlockWriteWordCount * pImpinjBlockWriteWordCount; + + LLRP_tSImpinjOpSpecRetryCount * pImpinjOpSpecRetryCount; + + LLRP_tSImpinjAccessSpecOrdering * pImpinjAccessSpecOrdering; + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjAccessSpecConfiguration; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjAccessSpecConfiguration[]; + +extern LLRP_tSImpinjAccessSpecConfiguration * +LLRP_ImpinjAccessSpecConfiguration_construct (void); + +extern void +LLRP_ImpinjAccessSpecConfiguration_destruct ( + LLRP_tSImpinjAccessSpecConfiguration * pThis); + +extern void +LLRP_ImpinjAccessSpecConfiguration_decodeFields ( + LLRP_tSImpinjAccessSpecConfiguration * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjAccessSpecConfiguration_assimilateSubParameters ( + LLRP_tSImpinjAccessSpecConfiguration * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjAccessSpecConfiguration_encode ( + const LLRP_tSImpinjAccessSpecConfiguration *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjAccessSpecConfiguration_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + + +extern LLRP_tSImpinjBlockWriteWordCount * +LLRP_ImpinjAccessSpecConfiguration_getImpinjBlockWriteWordCount ( + LLRP_tSImpinjAccessSpecConfiguration *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjAccessSpecConfiguration_setImpinjBlockWriteWordCount ( + LLRP_tSImpinjAccessSpecConfiguration *pThis, + LLRP_tSImpinjBlockWriteWordCount *pValue); + +extern LLRP_tSImpinjOpSpecRetryCount * +LLRP_ImpinjAccessSpecConfiguration_getImpinjOpSpecRetryCount ( + LLRP_tSImpinjAccessSpecConfiguration *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjAccessSpecConfiguration_setImpinjOpSpecRetryCount ( + LLRP_tSImpinjAccessSpecConfiguration *pThis, + LLRP_tSImpinjOpSpecRetryCount *pValue); + +extern LLRP_tSImpinjAccessSpecOrdering * +LLRP_ImpinjAccessSpecConfiguration_getImpinjAccessSpecOrdering ( + LLRP_tSImpinjAccessSpecConfiguration *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjAccessSpecConfiguration_setImpinjAccessSpecOrdering ( + LLRP_tSImpinjAccessSpecConfiguration *pThis, + LLRP_tSImpinjAccessSpecOrdering *pValue); + +extern LLRP_tSParameter * +LLRP_ImpinjAccessSpecConfiguration_beginCustom ( + LLRP_tSImpinjAccessSpecConfiguration *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjAccessSpecConfiguration_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjAccessSpecConfiguration_clearCustom ( + LLRP_tSImpinjAccessSpecConfiguration *pThis); + +extern int +LLRP_ImpinjAccessSpecConfiguration_countCustom ( + LLRP_tSImpinjAccessSpecConfiguration *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjAccessSpecConfiguration_addCustom ( + LLRP_tSImpinjAccessSpecConfiguration *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjBlockWriteWordCount +{ + LLRP_tSParameter hdr; + + llrp_u16_t WordCount; + + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjBlockWriteWordCount; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjBlockWriteWordCount[]; + +extern LLRP_tSImpinjBlockWriteWordCount * +LLRP_ImpinjBlockWriteWordCount_construct (void); + +extern void +LLRP_ImpinjBlockWriteWordCount_destruct ( + LLRP_tSImpinjBlockWriteWordCount * pThis); + +extern void +LLRP_ImpinjBlockWriteWordCount_decodeFields ( + LLRP_tSImpinjBlockWriteWordCount * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjBlockWriteWordCount_assimilateSubParameters ( + LLRP_tSImpinjBlockWriteWordCount * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjBlockWriteWordCount_encode ( + const LLRP_tSImpinjBlockWriteWordCount *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjBlockWriteWordCount_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjBlockWriteWordCount_WordCount; + +extern llrp_u16_t +LLRP_ImpinjBlockWriteWordCount_getWordCount ( + LLRP_tSImpinjBlockWriteWordCount *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjBlockWriteWordCount_setWordCount ( + LLRP_tSImpinjBlockWriteWordCount *pThis, + llrp_u16_t Value); + + +extern LLRP_tSParameter * +LLRP_ImpinjBlockWriteWordCount_beginCustom ( + LLRP_tSImpinjBlockWriteWordCount *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjBlockWriteWordCount_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjBlockWriteWordCount_clearCustom ( + LLRP_tSImpinjBlockWriteWordCount *pThis); + +extern int +LLRP_ImpinjBlockWriteWordCount_countCustom ( + LLRP_tSImpinjBlockWriteWordCount *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjBlockWriteWordCount_addCustom ( + LLRP_tSImpinjBlockWriteWordCount *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjBlockPermalock +{ + LLRP_tSParameter hdr; + + llrp_u16_t OpSpecID; + + llrp_u32_t AccessPassword; + + llrp_u2_t MB; + + llrp_u16_t BlockPointer; + + llrp_u16v_t BlockMask; + + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjBlockPermalock; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjBlockPermalock[]; + +extern LLRP_tSImpinjBlockPermalock * +LLRP_ImpinjBlockPermalock_construct (void); + +extern void +LLRP_ImpinjBlockPermalock_destruct ( + LLRP_tSImpinjBlockPermalock * pThis); + +extern void +LLRP_ImpinjBlockPermalock_decodeFields ( + LLRP_tSImpinjBlockPermalock * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjBlockPermalock_assimilateSubParameters ( + LLRP_tSImpinjBlockPermalock * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjBlockPermalock_encode ( + const LLRP_tSImpinjBlockPermalock *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjBlockPermalock_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjBlockPermalock_OpSpecID; + +extern llrp_u16_t +LLRP_ImpinjBlockPermalock_getOpSpecID ( + LLRP_tSImpinjBlockPermalock *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjBlockPermalock_setOpSpecID ( + LLRP_tSImpinjBlockPermalock *pThis, + llrp_u16_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjBlockPermalock_AccessPassword; + +extern llrp_u32_t +LLRP_ImpinjBlockPermalock_getAccessPassword ( + LLRP_tSImpinjBlockPermalock *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjBlockPermalock_setAccessPassword ( + LLRP_tSImpinjBlockPermalock *pThis, + llrp_u32_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjBlockPermalock_MB; + +extern llrp_u2_t +LLRP_ImpinjBlockPermalock_getMB ( + LLRP_tSImpinjBlockPermalock *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjBlockPermalock_setMB ( + LLRP_tSImpinjBlockPermalock *pThis, + llrp_u2_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjBlockPermalock_BlockPointer; + +extern llrp_u16_t +LLRP_ImpinjBlockPermalock_getBlockPointer ( + LLRP_tSImpinjBlockPermalock *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjBlockPermalock_setBlockPointer ( + LLRP_tSImpinjBlockPermalock *pThis, + llrp_u16_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjBlockPermalock_BlockMask; + +extern llrp_u16v_t +LLRP_ImpinjBlockPermalock_getBlockMask ( + LLRP_tSImpinjBlockPermalock *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjBlockPermalock_setBlockMask ( + LLRP_tSImpinjBlockPermalock *pThis, + llrp_u16v_t Value); + + +extern LLRP_tSParameter * +LLRP_ImpinjBlockPermalock_beginCustom ( + LLRP_tSImpinjBlockPermalock *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjBlockPermalock_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjBlockPermalock_clearCustom ( + LLRP_tSImpinjBlockPermalock *pThis); + +extern int +LLRP_ImpinjBlockPermalock_countCustom ( + LLRP_tSImpinjBlockPermalock *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjBlockPermalock_addCustom ( + LLRP_tSImpinjBlockPermalock *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjBlockPermalockOpSpecResult +{ + LLRP_tSParameter hdr; + + LLRP_tEImpinjBlockPermalockResultType eResult; + + llrp_u16_t OpSpecID; + + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjBlockPermalockOpSpecResult; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjBlockPermalockOpSpecResult[]; + +extern LLRP_tSImpinjBlockPermalockOpSpecResult * +LLRP_ImpinjBlockPermalockOpSpecResult_construct (void); + +extern void +LLRP_ImpinjBlockPermalockOpSpecResult_destruct ( + LLRP_tSImpinjBlockPermalockOpSpecResult * pThis); + +extern void +LLRP_ImpinjBlockPermalockOpSpecResult_decodeFields ( + LLRP_tSImpinjBlockPermalockOpSpecResult * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjBlockPermalockOpSpecResult_assimilateSubParameters ( + LLRP_tSImpinjBlockPermalockOpSpecResult * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjBlockPermalockOpSpecResult_encode ( + const LLRP_tSImpinjBlockPermalockOpSpecResult *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjBlockPermalockOpSpecResult_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjBlockPermalockOpSpecResult_Result; + +extern LLRP_tEImpinjBlockPermalockResultType +LLRP_ImpinjBlockPermalockOpSpecResult_getResult ( + LLRP_tSImpinjBlockPermalockOpSpecResult *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjBlockPermalockOpSpecResult_setResult ( + LLRP_tSImpinjBlockPermalockOpSpecResult *pThis, + LLRP_tEImpinjBlockPermalockResultType Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjBlockPermalockOpSpecResult_OpSpecID; + +extern llrp_u16_t +LLRP_ImpinjBlockPermalockOpSpecResult_getOpSpecID ( + LLRP_tSImpinjBlockPermalockOpSpecResult *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjBlockPermalockOpSpecResult_setOpSpecID ( + LLRP_tSImpinjBlockPermalockOpSpecResult *pThis, + llrp_u16_t Value); + + +extern LLRP_tSParameter * +LLRP_ImpinjBlockPermalockOpSpecResult_beginCustom ( + LLRP_tSImpinjBlockPermalockOpSpecResult *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjBlockPermalockOpSpecResult_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjBlockPermalockOpSpecResult_clearCustom ( + LLRP_tSImpinjBlockPermalockOpSpecResult *pThis); + +extern int +LLRP_ImpinjBlockPermalockOpSpecResult_countCustom ( + LLRP_tSImpinjBlockPermalockOpSpecResult *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjBlockPermalockOpSpecResult_addCustom ( + LLRP_tSImpinjBlockPermalockOpSpecResult *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjGetBlockPermalockStatus +{ + LLRP_tSParameter hdr; + + llrp_u16_t OpSpecID; + + llrp_u32_t AccessPassword; + + llrp_u2_t MB; + + llrp_u16_t BlockPointer; + + llrp_u16_t BlockRange; + + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjGetBlockPermalockStatus; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjGetBlockPermalockStatus[]; + +extern LLRP_tSImpinjGetBlockPermalockStatus * +LLRP_ImpinjGetBlockPermalockStatus_construct (void); + +extern void +LLRP_ImpinjGetBlockPermalockStatus_destruct ( + LLRP_tSImpinjGetBlockPermalockStatus * pThis); + +extern void +LLRP_ImpinjGetBlockPermalockStatus_decodeFields ( + LLRP_tSImpinjGetBlockPermalockStatus * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjGetBlockPermalockStatus_assimilateSubParameters ( + LLRP_tSImpinjGetBlockPermalockStatus * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjGetBlockPermalockStatus_encode ( + const LLRP_tSImpinjGetBlockPermalockStatus *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjGetBlockPermalockStatus_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjGetBlockPermalockStatus_OpSpecID; + +extern llrp_u16_t +LLRP_ImpinjGetBlockPermalockStatus_getOpSpecID ( + LLRP_tSImpinjGetBlockPermalockStatus *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjGetBlockPermalockStatus_setOpSpecID ( + LLRP_tSImpinjGetBlockPermalockStatus *pThis, + llrp_u16_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjGetBlockPermalockStatus_AccessPassword; + +extern llrp_u32_t +LLRP_ImpinjGetBlockPermalockStatus_getAccessPassword ( + LLRP_tSImpinjGetBlockPermalockStatus *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjGetBlockPermalockStatus_setAccessPassword ( + LLRP_tSImpinjGetBlockPermalockStatus *pThis, + llrp_u32_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjGetBlockPermalockStatus_MB; + +extern llrp_u2_t +LLRP_ImpinjGetBlockPermalockStatus_getMB ( + LLRP_tSImpinjGetBlockPermalockStatus *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjGetBlockPermalockStatus_setMB ( + LLRP_tSImpinjGetBlockPermalockStatus *pThis, + llrp_u2_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjGetBlockPermalockStatus_BlockPointer; + +extern llrp_u16_t +LLRP_ImpinjGetBlockPermalockStatus_getBlockPointer ( + LLRP_tSImpinjGetBlockPermalockStatus *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjGetBlockPermalockStatus_setBlockPointer ( + LLRP_tSImpinjGetBlockPermalockStatus *pThis, + llrp_u16_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjGetBlockPermalockStatus_BlockRange; + +extern llrp_u16_t +LLRP_ImpinjGetBlockPermalockStatus_getBlockRange ( + LLRP_tSImpinjGetBlockPermalockStatus *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjGetBlockPermalockStatus_setBlockRange ( + LLRP_tSImpinjGetBlockPermalockStatus *pThis, + llrp_u16_t Value); + + +extern LLRP_tSParameter * +LLRP_ImpinjGetBlockPermalockStatus_beginCustom ( + LLRP_tSImpinjGetBlockPermalockStatus *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjGetBlockPermalockStatus_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjGetBlockPermalockStatus_clearCustom ( + LLRP_tSImpinjGetBlockPermalockStatus *pThis); + +extern int +LLRP_ImpinjGetBlockPermalockStatus_countCustom ( + LLRP_tSImpinjGetBlockPermalockStatus *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjGetBlockPermalockStatus_addCustom ( + LLRP_tSImpinjGetBlockPermalockStatus *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjGetBlockPermalockStatusOpSpecResult +{ + LLRP_tSParameter hdr; + + LLRP_tEImpinjGetBlockPermalockStatusResultType eResult; + + llrp_u16_t OpSpecID; + + llrp_u16v_t PermalockStatus; + + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjGetBlockPermalockStatusOpSpecResult; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjGetBlockPermalockStatusOpSpecResult[]; + +extern LLRP_tSImpinjGetBlockPermalockStatusOpSpecResult * +LLRP_ImpinjGetBlockPermalockStatusOpSpecResult_construct (void); + +extern void +LLRP_ImpinjGetBlockPermalockStatusOpSpecResult_destruct ( + LLRP_tSImpinjGetBlockPermalockStatusOpSpecResult * pThis); + +extern void +LLRP_ImpinjGetBlockPermalockStatusOpSpecResult_decodeFields ( + LLRP_tSImpinjGetBlockPermalockStatusOpSpecResult * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjGetBlockPermalockStatusOpSpecResult_assimilateSubParameters ( + LLRP_tSImpinjGetBlockPermalockStatusOpSpecResult * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjGetBlockPermalockStatusOpSpecResult_encode ( + const LLRP_tSImpinjGetBlockPermalockStatusOpSpecResult *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjGetBlockPermalockStatusOpSpecResult_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjGetBlockPermalockStatusOpSpecResult_Result; + +extern LLRP_tEImpinjGetBlockPermalockStatusResultType +LLRP_ImpinjGetBlockPermalockStatusOpSpecResult_getResult ( + LLRP_tSImpinjGetBlockPermalockStatusOpSpecResult *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjGetBlockPermalockStatusOpSpecResult_setResult ( + LLRP_tSImpinjGetBlockPermalockStatusOpSpecResult *pThis, + LLRP_tEImpinjGetBlockPermalockStatusResultType Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjGetBlockPermalockStatusOpSpecResult_OpSpecID; + +extern llrp_u16_t +LLRP_ImpinjGetBlockPermalockStatusOpSpecResult_getOpSpecID ( + LLRP_tSImpinjGetBlockPermalockStatusOpSpecResult *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjGetBlockPermalockStatusOpSpecResult_setOpSpecID ( + LLRP_tSImpinjGetBlockPermalockStatusOpSpecResult *pThis, + llrp_u16_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjGetBlockPermalockStatusOpSpecResult_PermalockStatus; + +extern llrp_u16v_t +LLRP_ImpinjGetBlockPermalockStatusOpSpecResult_getPermalockStatus ( + LLRP_tSImpinjGetBlockPermalockStatusOpSpecResult *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjGetBlockPermalockStatusOpSpecResult_setPermalockStatus ( + LLRP_tSImpinjGetBlockPermalockStatusOpSpecResult *pThis, + llrp_u16v_t Value); + + +extern LLRP_tSParameter * +LLRP_ImpinjGetBlockPermalockStatusOpSpecResult_beginCustom ( + LLRP_tSImpinjGetBlockPermalockStatusOpSpecResult *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjGetBlockPermalockStatusOpSpecResult_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjGetBlockPermalockStatusOpSpecResult_clearCustom ( + LLRP_tSImpinjGetBlockPermalockStatusOpSpecResult *pThis); + +extern int +LLRP_ImpinjGetBlockPermalockStatusOpSpecResult_countCustom ( + LLRP_tSImpinjGetBlockPermalockStatusOpSpecResult *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjGetBlockPermalockStatusOpSpecResult_addCustom ( + LLRP_tSImpinjGetBlockPermalockStatusOpSpecResult *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjSetQTConfig +{ + LLRP_tSParameter hdr; + + llrp_u16_t OpSpecID; + + llrp_u32_t AccessPassword; + + LLRP_tEImpinjQTDataProfile eDataProfile; + + LLRP_tEImpinjQTAccessRange eAccessRange; + + LLRP_tEImpinjQTPersistence ePersistence; + + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjSetQTConfig; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjSetQTConfig[]; + +extern LLRP_tSImpinjSetQTConfig * +LLRP_ImpinjSetQTConfig_construct (void); + +extern void +LLRP_ImpinjSetQTConfig_destruct ( + LLRP_tSImpinjSetQTConfig * pThis); + +extern void +LLRP_ImpinjSetQTConfig_decodeFields ( + LLRP_tSImpinjSetQTConfig * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjSetQTConfig_assimilateSubParameters ( + LLRP_tSImpinjSetQTConfig * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjSetQTConfig_encode ( + const LLRP_tSImpinjSetQTConfig *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjSetQTConfig_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjSetQTConfig_OpSpecID; + +extern llrp_u16_t +LLRP_ImpinjSetQTConfig_getOpSpecID ( + LLRP_tSImpinjSetQTConfig *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjSetQTConfig_setOpSpecID ( + LLRP_tSImpinjSetQTConfig *pThis, + llrp_u16_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjSetQTConfig_AccessPassword; + +extern llrp_u32_t +LLRP_ImpinjSetQTConfig_getAccessPassword ( + LLRP_tSImpinjSetQTConfig *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjSetQTConfig_setAccessPassword ( + LLRP_tSImpinjSetQTConfig *pThis, + llrp_u32_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjSetQTConfig_DataProfile; + +extern LLRP_tEImpinjQTDataProfile +LLRP_ImpinjSetQTConfig_getDataProfile ( + LLRP_tSImpinjSetQTConfig *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjSetQTConfig_setDataProfile ( + LLRP_tSImpinjSetQTConfig *pThis, + LLRP_tEImpinjQTDataProfile Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjSetQTConfig_AccessRange; + +extern LLRP_tEImpinjQTAccessRange +LLRP_ImpinjSetQTConfig_getAccessRange ( + LLRP_tSImpinjSetQTConfig *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjSetQTConfig_setAccessRange ( + LLRP_tSImpinjSetQTConfig *pThis, + LLRP_tEImpinjQTAccessRange Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjSetQTConfig_Persistence; + +extern LLRP_tEImpinjQTPersistence +LLRP_ImpinjSetQTConfig_getPersistence ( + LLRP_tSImpinjSetQTConfig *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjSetQTConfig_setPersistence ( + LLRP_tSImpinjSetQTConfig *pThis, + LLRP_tEImpinjQTPersistence Value); + + +extern LLRP_tSParameter * +LLRP_ImpinjSetQTConfig_beginCustom ( + LLRP_tSImpinjSetQTConfig *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjSetQTConfig_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjSetQTConfig_clearCustom ( + LLRP_tSImpinjSetQTConfig *pThis); + +extern int +LLRP_ImpinjSetQTConfig_countCustom ( + LLRP_tSImpinjSetQTConfig *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjSetQTConfig_addCustom ( + LLRP_tSImpinjSetQTConfig *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjSetQTConfigOpSpecResult +{ + LLRP_tSParameter hdr; + + LLRP_tEImpinjSetQTConfigResultType eResult; + + llrp_u16_t OpSpecID; + + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjSetQTConfigOpSpecResult; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjSetQTConfigOpSpecResult[]; + +extern LLRP_tSImpinjSetQTConfigOpSpecResult * +LLRP_ImpinjSetQTConfigOpSpecResult_construct (void); + +extern void +LLRP_ImpinjSetQTConfigOpSpecResult_destruct ( + LLRP_tSImpinjSetQTConfigOpSpecResult * pThis); + +extern void +LLRP_ImpinjSetQTConfigOpSpecResult_decodeFields ( + LLRP_tSImpinjSetQTConfigOpSpecResult * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjSetQTConfigOpSpecResult_assimilateSubParameters ( + LLRP_tSImpinjSetQTConfigOpSpecResult * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjSetQTConfigOpSpecResult_encode ( + const LLRP_tSImpinjSetQTConfigOpSpecResult *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjSetQTConfigOpSpecResult_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjSetQTConfigOpSpecResult_Result; + +extern LLRP_tEImpinjSetQTConfigResultType +LLRP_ImpinjSetQTConfigOpSpecResult_getResult ( + LLRP_tSImpinjSetQTConfigOpSpecResult *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjSetQTConfigOpSpecResult_setResult ( + LLRP_tSImpinjSetQTConfigOpSpecResult *pThis, + LLRP_tEImpinjSetQTConfigResultType Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjSetQTConfigOpSpecResult_OpSpecID; + +extern llrp_u16_t +LLRP_ImpinjSetQTConfigOpSpecResult_getOpSpecID ( + LLRP_tSImpinjSetQTConfigOpSpecResult *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjSetQTConfigOpSpecResult_setOpSpecID ( + LLRP_tSImpinjSetQTConfigOpSpecResult *pThis, + llrp_u16_t Value); + + +extern LLRP_tSParameter * +LLRP_ImpinjSetQTConfigOpSpecResult_beginCustom ( + LLRP_tSImpinjSetQTConfigOpSpecResult *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjSetQTConfigOpSpecResult_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjSetQTConfigOpSpecResult_clearCustom ( + LLRP_tSImpinjSetQTConfigOpSpecResult *pThis); + +extern int +LLRP_ImpinjSetQTConfigOpSpecResult_countCustom ( + LLRP_tSImpinjSetQTConfigOpSpecResult *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjSetQTConfigOpSpecResult_addCustom ( + LLRP_tSImpinjSetQTConfigOpSpecResult *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjGetQTConfig +{ + LLRP_tSParameter hdr; + + llrp_u16_t OpSpecID; + + llrp_u32_t AccessPassword; + + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjGetQTConfig; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjGetQTConfig[]; + +extern LLRP_tSImpinjGetQTConfig * +LLRP_ImpinjGetQTConfig_construct (void); + +extern void +LLRP_ImpinjGetQTConfig_destruct ( + LLRP_tSImpinjGetQTConfig * pThis); + +extern void +LLRP_ImpinjGetQTConfig_decodeFields ( + LLRP_tSImpinjGetQTConfig * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjGetQTConfig_assimilateSubParameters ( + LLRP_tSImpinjGetQTConfig * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjGetQTConfig_encode ( + const LLRP_tSImpinjGetQTConfig *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjGetQTConfig_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjGetQTConfig_OpSpecID; + +extern llrp_u16_t +LLRP_ImpinjGetQTConfig_getOpSpecID ( + LLRP_tSImpinjGetQTConfig *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjGetQTConfig_setOpSpecID ( + LLRP_tSImpinjGetQTConfig *pThis, + llrp_u16_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjGetQTConfig_AccessPassword; + +extern llrp_u32_t +LLRP_ImpinjGetQTConfig_getAccessPassword ( + LLRP_tSImpinjGetQTConfig *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjGetQTConfig_setAccessPassword ( + LLRP_tSImpinjGetQTConfig *pThis, + llrp_u32_t Value); + + +extern LLRP_tSParameter * +LLRP_ImpinjGetQTConfig_beginCustom ( + LLRP_tSImpinjGetQTConfig *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjGetQTConfig_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjGetQTConfig_clearCustom ( + LLRP_tSImpinjGetQTConfig *pThis); + +extern int +LLRP_ImpinjGetQTConfig_countCustom ( + LLRP_tSImpinjGetQTConfig *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjGetQTConfig_addCustom ( + LLRP_tSImpinjGetQTConfig *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjGetQTConfigOpSpecResult +{ + LLRP_tSParameter hdr; + + LLRP_tEImpinjGetQTConfigResultType eResult; + + llrp_u16_t OpSpecID; + + LLRP_tEImpinjQTDataProfile eDataProfile; + + LLRP_tEImpinjQTAccessRange eAccessRange; + + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjGetQTConfigOpSpecResult; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjGetQTConfigOpSpecResult[]; + +extern LLRP_tSImpinjGetQTConfigOpSpecResult * +LLRP_ImpinjGetQTConfigOpSpecResult_construct (void); + +extern void +LLRP_ImpinjGetQTConfigOpSpecResult_destruct ( + LLRP_tSImpinjGetQTConfigOpSpecResult * pThis); + +extern void +LLRP_ImpinjGetQTConfigOpSpecResult_decodeFields ( + LLRP_tSImpinjGetQTConfigOpSpecResult * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjGetQTConfigOpSpecResult_assimilateSubParameters ( + LLRP_tSImpinjGetQTConfigOpSpecResult * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjGetQTConfigOpSpecResult_encode ( + const LLRP_tSImpinjGetQTConfigOpSpecResult *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjGetQTConfigOpSpecResult_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjGetQTConfigOpSpecResult_Result; + +extern LLRP_tEImpinjGetQTConfigResultType +LLRP_ImpinjGetQTConfigOpSpecResult_getResult ( + LLRP_tSImpinjGetQTConfigOpSpecResult *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjGetQTConfigOpSpecResult_setResult ( + LLRP_tSImpinjGetQTConfigOpSpecResult *pThis, + LLRP_tEImpinjGetQTConfigResultType Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjGetQTConfigOpSpecResult_OpSpecID; + +extern llrp_u16_t +LLRP_ImpinjGetQTConfigOpSpecResult_getOpSpecID ( + LLRP_tSImpinjGetQTConfigOpSpecResult *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjGetQTConfigOpSpecResult_setOpSpecID ( + LLRP_tSImpinjGetQTConfigOpSpecResult *pThis, + llrp_u16_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjGetQTConfigOpSpecResult_DataProfile; + +extern LLRP_tEImpinjQTDataProfile +LLRP_ImpinjGetQTConfigOpSpecResult_getDataProfile ( + LLRP_tSImpinjGetQTConfigOpSpecResult *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjGetQTConfigOpSpecResult_setDataProfile ( + LLRP_tSImpinjGetQTConfigOpSpecResult *pThis, + LLRP_tEImpinjQTDataProfile Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjGetQTConfigOpSpecResult_AccessRange; + +extern LLRP_tEImpinjQTAccessRange +LLRP_ImpinjGetQTConfigOpSpecResult_getAccessRange ( + LLRP_tSImpinjGetQTConfigOpSpecResult *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjGetQTConfigOpSpecResult_setAccessRange ( + LLRP_tSImpinjGetQTConfigOpSpecResult *pThis, + LLRP_tEImpinjQTAccessRange Value); + + +extern LLRP_tSParameter * +LLRP_ImpinjGetQTConfigOpSpecResult_beginCustom ( + LLRP_tSImpinjGetQTConfigOpSpecResult *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjGetQTConfigOpSpecResult_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjGetQTConfigOpSpecResult_clearCustom ( + LLRP_tSImpinjGetQTConfigOpSpecResult *pThis); + +extern int +LLRP_ImpinjGetQTConfigOpSpecResult_countCustom ( + LLRP_tSImpinjGetQTConfigOpSpecResult *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjGetQTConfigOpSpecResult_addCustom ( + LLRP_tSImpinjGetQTConfigOpSpecResult *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjTagReportContentSelector +{ + LLRP_tSParameter hdr; + + + LLRP_tSImpinjEnableSerializedTID * pImpinjEnableSerializedTID; + + LLRP_tSImpinjEnableRFPhaseAngle * pImpinjEnableRFPhaseAngle; + + LLRP_tSImpinjEnablePeakRSSI * pImpinjEnablePeakRSSI; + + LLRP_tSImpinjEnableGPSCoordinates * pImpinjEnableGPSCoordinates; + + LLRP_tSImpinjEnableOptimizedRead * pImpinjEnableOptimizedRead; + + LLRP_tSImpinjEnableRFDopplerFrequency * pImpinjEnableRFDopplerFrequency; + + LLRP_tSImpinjEnableTxPower * pImpinjEnableTxPower; + + LLRP_tSImpinjEnableXPCWords * pImpinjEnableXPCWords; + + LLRP_tSImpinjEnableCRHandle * pImpinjEnableCRHandle; + + LLRP_tSImpinjEnableEnhancedIntegra * pImpinjEnableEnhancedIntegra; + + LLRP_tSImpinjEnableEndpointICVerification * pImpinjEnableEndpointICVerification; + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjTagReportContentSelector; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjTagReportContentSelector[]; + +extern LLRP_tSImpinjTagReportContentSelector * +LLRP_ImpinjTagReportContentSelector_construct (void); + +extern void +LLRP_ImpinjTagReportContentSelector_destruct ( + LLRP_tSImpinjTagReportContentSelector * pThis); + +extern void +LLRP_ImpinjTagReportContentSelector_decodeFields ( + LLRP_tSImpinjTagReportContentSelector * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjTagReportContentSelector_assimilateSubParameters ( + LLRP_tSImpinjTagReportContentSelector * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjTagReportContentSelector_encode ( + const LLRP_tSImpinjTagReportContentSelector *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjTagReportContentSelector_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + + +extern LLRP_tSImpinjEnableSerializedTID * +LLRP_ImpinjTagReportContentSelector_getImpinjEnableSerializedTID ( + LLRP_tSImpinjTagReportContentSelector *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjTagReportContentSelector_setImpinjEnableSerializedTID ( + LLRP_tSImpinjTagReportContentSelector *pThis, + LLRP_tSImpinjEnableSerializedTID *pValue); + +extern LLRP_tSImpinjEnableRFPhaseAngle * +LLRP_ImpinjTagReportContentSelector_getImpinjEnableRFPhaseAngle ( + LLRP_tSImpinjTagReportContentSelector *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjTagReportContentSelector_setImpinjEnableRFPhaseAngle ( + LLRP_tSImpinjTagReportContentSelector *pThis, + LLRP_tSImpinjEnableRFPhaseAngle *pValue); + +extern LLRP_tSImpinjEnablePeakRSSI * +LLRP_ImpinjTagReportContentSelector_getImpinjEnablePeakRSSI ( + LLRP_tSImpinjTagReportContentSelector *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjTagReportContentSelector_setImpinjEnablePeakRSSI ( + LLRP_tSImpinjTagReportContentSelector *pThis, + LLRP_tSImpinjEnablePeakRSSI *pValue); + +extern LLRP_tSImpinjEnableGPSCoordinates * +LLRP_ImpinjTagReportContentSelector_getImpinjEnableGPSCoordinates ( + LLRP_tSImpinjTagReportContentSelector *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjTagReportContentSelector_setImpinjEnableGPSCoordinates ( + LLRP_tSImpinjTagReportContentSelector *pThis, + LLRP_tSImpinjEnableGPSCoordinates *pValue); + +extern LLRP_tSImpinjEnableOptimizedRead * +LLRP_ImpinjTagReportContentSelector_getImpinjEnableOptimizedRead ( + LLRP_tSImpinjTagReportContentSelector *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjTagReportContentSelector_setImpinjEnableOptimizedRead ( + LLRP_tSImpinjTagReportContentSelector *pThis, + LLRP_tSImpinjEnableOptimizedRead *pValue); + +extern LLRP_tSImpinjEnableRFDopplerFrequency * +LLRP_ImpinjTagReportContentSelector_getImpinjEnableRFDopplerFrequency ( + LLRP_tSImpinjTagReportContentSelector *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjTagReportContentSelector_setImpinjEnableRFDopplerFrequency ( + LLRP_tSImpinjTagReportContentSelector *pThis, + LLRP_tSImpinjEnableRFDopplerFrequency *pValue); + +extern LLRP_tSImpinjEnableTxPower * +LLRP_ImpinjTagReportContentSelector_getImpinjEnableTxPower ( + LLRP_tSImpinjTagReportContentSelector *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjTagReportContentSelector_setImpinjEnableTxPower ( + LLRP_tSImpinjTagReportContentSelector *pThis, + LLRP_tSImpinjEnableTxPower *pValue); + +extern LLRP_tSImpinjEnableXPCWords * +LLRP_ImpinjTagReportContentSelector_getImpinjEnableXPCWords ( + LLRP_tSImpinjTagReportContentSelector *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjTagReportContentSelector_setImpinjEnableXPCWords ( + LLRP_tSImpinjTagReportContentSelector *pThis, + LLRP_tSImpinjEnableXPCWords *pValue); + +extern LLRP_tSImpinjEnableCRHandle * +LLRP_ImpinjTagReportContentSelector_getImpinjEnableCRHandle ( + LLRP_tSImpinjTagReportContentSelector *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjTagReportContentSelector_setImpinjEnableCRHandle ( + LLRP_tSImpinjTagReportContentSelector *pThis, + LLRP_tSImpinjEnableCRHandle *pValue); + +extern LLRP_tSImpinjEnableEnhancedIntegra * +LLRP_ImpinjTagReportContentSelector_getImpinjEnableEnhancedIntegra ( + LLRP_tSImpinjTagReportContentSelector *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjTagReportContentSelector_setImpinjEnableEnhancedIntegra ( + LLRP_tSImpinjTagReportContentSelector *pThis, + LLRP_tSImpinjEnableEnhancedIntegra *pValue); + +extern LLRP_tSImpinjEnableEndpointICVerification * +LLRP_ImpinjTagReportContentSelector_getImpinjEnableEndpointICVerification ( + LLRP_tSImpinjTagReportContentSelector *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjTagReportContentSelector_setImpinjEnableEndpointICVerification ( + LLRP_tSImpinjTagReportContentSelector *pThis, + LLRP_tSImpinjEnableEndpointICVerification *pValue); + +extern LLRP_tSParameter * +LLRP_ImpinjTagReportContentSelector_beginCustom ( + LLRP_tSImpinjTagReportContentSelector *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjTagReportContentSelector_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjTagReportContentSelector_clearCustom ( + LLRP_tSImpinjTagReportContentSelector *pThis); + +extern int +LLRP_ImpinjTagReportContentSelector_countCustom ( + LLRP_tSImpinjTagReportContentSelector *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjTagReportContentSelector_addCustom ( + LLRP_tSImpinjTagReportContentSelector *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjEnableSerializedTID +{ + LLRP_tSParameter hdr; + + LLRP_tEImpinjSerializedTIDMode eSerializedTIDMode; + + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjEnableSerializedTID; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjEnableSerializedTID[]; + +extern LLRP_tSImpinjEnableSerializedTID * +LLRP_ImpinjEnableSerializedTID_construct (void); + +extern void +LLRP_ImpinjEnableSerializedTID_destruct ( + LLRP_tSImpinjEnableSerializedTID * pThis); + +extern void +LLRP_ImpinjEnableSerializedTID_decodeFields ( + LLRP_tSImpinjEnableSerializedTID * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjEnableSerializedTID_assimilateSubParameters ( + LLRP_tSImpinjEnableSerializedTID * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjEnableSerializedTID_encode ( + const LLRP_tSImpinjEnableSerializedTID *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjEnableSerializedTID_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjEnableSerializedTID_SerializedTIDMode; + +extern LLRP_tEImpinjSerializedTIDMode +LLRP_ImpinjEnableSerializedTID_getSerializedTIDMode ( + LLRP_tSImpinjEnableSerializedTID *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjEnableSerializedTID_setSerializedTIDMode ( + LLRP_tSImpinjEnableSerializedTID *pThis, + LLRP_tEImpinjSerializedTIDMode Value); + + +extern LLRP_tSParameter * +LLRP_ImpinjEnableSerializedTID_beginCustom ( + LLRP_tSImpinjEnableSerializedTID *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjEnableSerializedTID_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjEnableSerializedTID_clearCustom ( + LLRP_tSImpinjEnableSerializedTID *pThis); + +extern int +LLRP_ImpinjEnableSerializedTID_countCustom ( + LLRP_tSImpinjEnableSerializedTID *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjEnableSerializedTID_addCustom ( + LLRP_tSImpinjEnableSerializedTID *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjEnableRFPhaseAngle +{ + LLRP_tSParameter hdr; + + LLRP_tEImpinjRFPhaseAngleMode eRFPhaseAngleMode; + + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjEnableRFPhaseAngle; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjEnableRFPhaseAngle[]; + +extern LLRP_tSImpinjEnableRFPhaseAngle * +LLRP_ImpinjEnableRFPhaseAngle_construct (void); + +extern void +LLRP_ImpinjEnableRFPhaseAngle_destruct ( + LLRP_tSImpinjEnableRFPhaseAngle * pThis); + +extern void +LLRP_ImpinjEnableRFPhaseAngle_decodeFields ( + LLRP_tSImpinjEnableRFPhaseAngle * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjEnableRFPhaseAngle_assimilateSubParameters ( + LLRP_tSImpinjEnableRFPhaseAngle * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjEnableRFPhaseAngle_encode ( + const LLRP_tSImpinjEnableRFPhaseAngle *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjEnableRFPhaseAngle_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjEnableRFPhaseAngle_RFPhaseAngleMode; + +extern LLRP_tEImpinjRFPhaseAngleMode +LLRP_ImpinjEnableRFPhaseAngle_getRFPhaseAngleMode ( + LLRP_tSImpinjEnableRFPhaseAngle *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjEnableRFPhaseAngle_setRFPhaseAngleMode ( + LLRP_tSImpinjEnableRFPhaseAngle *pThis, + LLRP_tEImpinjRFPhaseAngleMode Value); + + +extern LLRP_tSParameter * +LLRP_ImpinjEnableRFPhaseAngle_beginCustom ( + LLRP_tSImpinjEnableRFPhaseAngle *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjEnableRFPhaseAngle_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjEnableRFPhaseAngle_clearCustom ( + LLRP_tSImpinjEnableRFPhaseAngle *pThis); + +extern int +LLRP_ImpinjEnableRFPhaseAngle_countCustom ( + LLRP_tSImpinjEnableRFPhaseAngle *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjEnableRFPhaseAngle_addCustom ( + LLRP_tSImpinjEnableRFPhaseAngle *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjEnablePeakRSSI +{ + LLRP_tSParameter hdr; + + LLRP_tEImpinjPeakRSSIMode ePeakRSSIMode; + + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjEnablePeakRSSI; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjEnablePeakRSSI[]; + +extern LLRP_tSImpinjEnablePeakRSSI * +LLRP_ImpinjEnablePeakRSSI_construct (void); + +extern void +LLRP_ImpinjEnablePeakRSSI_destruct ( + LLRP_tSImpinjEnablePeakRSSI * pThis); + +extern void +LLRP_ImpinjEnablePeakRSSI_decodeFields ( + LLRP_tSImpinjEnablePeakRSSI * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjEnablePeakRSSI_assimilateSubParameters ( + LLRP_tSImpinjEnablePeakRSSI * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjEnablePeakRSSI_encode ( + const LLRP_tSImpinjEnablePeakRSSI *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjEnablePeakRSSI_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjEnablePeakRSSI_PeakRSSIMode; + +extern LLRP_tEImpinjPeakRSSIMode +LLRP_ImpinjEnablePeakRSSI_getPeakRSSIMode ( + LLRP_tSImpinjEnablePeakRSSI *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjEnablePeakRSSI_setPeakRSSIMode ( + LLRP_tSImpinjEnablePeakRSSI *pThis, + LLRP_tEImpinjPeakRSSIMode Value); + + +extern LLRP_tSParameter * +LLRP_ImpinjEnablePeakRSSI_beginCustom ( + LLRP_tSImpinjEnablePeakRSSI *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjEnablePeakRSSI_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjEnablePeakRSSI_clearCustom ( + LLRP_tSImpinjEnablePeakRSSI *pThis); + +extern int +LLRP_ImpinjEnablePeakRSSI_countCustom ( + LLRP_tSImpinjEnablePeakRSSI *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjEnablePeakRSSI_addCustom ( + LLRP_tSImpinjEnablePeakRSSI *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjEnableGPSCoordinates +{ + LLRP_tSParameter hdr; + + LLRP_tEImpinjGPSCoordinatesMode eGPSCoordinatesMode; + + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjEnableGPSCoordinates; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjEnableGPSCoordinates[]; + +extern LLRP_tSImpinjEnableGPSCoordinates * +LLRP_ImpinjEnableGPSCoordinates_construct (void); + +extern void +LLRP_ImpinjEnableGPSCoordinates_destruct ( + LLRP_tSImpinjEnableGPSCoordinates * pThis); + +extern void +LLRP_ImpinjEnableGPSCoordinates_decodeFields ( + LLRP_tSImpinjEnableGPSCoordinates * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjEnableGPSCoordinates_assimilateSubParameters ( + LLRP_tSImpinjEnableGPSCoordinates * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjEnableGPSCoordinates_encode ( + const LLRP_tSImpinjEnableGPSCoordinates *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjEnableGPSCoordinates_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjEnableGPSCoordinates_GPSCoordinatesMode; + +extern LLRP_tEImpinjGPSCoordinatesMode +LLRP_ImpinjEnableGPSCoordinates_getGPSCoordinatesMode ( + LLRP_tSImpinjEnableGPSCoordinates *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjEnableGPSCoordinates_setGPSCoordinatesMode ( + LLRP_tSImpinjEnableGPSCoordinates *pThis, + LLRP_tEImpinjGPSCoordinatesMode Value); + + +extern LLRP_tSParameter * +LLRP_ImpinjEnableGPSCoordinates_beginCustom ( + LLRP_tSImpinjEnableGPSCoordinates *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjEnableGPSCoordinates_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjEnableGPSCoordinates_clearCustom ( + LLRP_tSImpinjEnableGPSCoordinates *pThis); + +extern int +LLRP_ImpinjEnableGPSCoordinates_countCustom ( + LLRP_tSImpinjEnableGPSCoordinates *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjEnableGPSCoordinates_addCustom ( + LLRP_tSImpinjEnableGPSCoordinates *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjSerializedTID +{ + LLRP_tSParameter hdr; + + llrp_u16v_t TID; + + + LLRP_tSImpinjTIDParity * pImpinjTIDParity; + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjSerializedTID; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjSerializedTID[]; + +extern LLRP_tSImpinjSerializedTID * +LLRP_ImpinjSerializedTID_construct (void); + +extern void +LLRP_ImpinjSerializedTID_destruct ( + LLRP_tSImpinjSerializedTID * pThis); + +extern void +LLRP_ImpinjSerializedTID_decodeFields ( + LLRP_tSImpinjSerializedTID * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjSerializedTID_assimilateSubParameters ( + LLRP_tSImpinjSerializedTID * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjSerializedTID_encode ( + const LLRP_tSImpinjSerializedTID *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjSerializedTID_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjSerializedTID_TID; + +extern llrp_u16v_t +LLRP_ImpinjSerializedTID_getTID ( + LLRP_tSImpinjSerializedTID *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjSerializedTID_setTID ( + LLRP_tSImpinjSerializedTID *pThis, + llrp_u16v_t Value); + + +extern LLRP_tSImpinjTIDParity * +LLRP_ImpinjSerializedTID_getImpinjTIDParity ( + LLRP_tSImpinjSerializedTID *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjSerializedTID_setImpinjTIDParity ( + LLRP_tSImpinjSerializedTID *pThis, + LLRP_tSImpinjTIDParity *pValue); + +extern LLRP_tSParameter * +LLRP_ImpinjSerializedTID_beginCustom ( + LLRP_tSImpinjSerializedTID *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjSerializedTID_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjSerializedTID_clearCustom ( + LLRP_tSImpinjSerializedTID *pThis); + +extern int +LLRP_ImpinjSerializedTID_countCustom ( + LLRP_tSImpinjSerializedTID *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjSerializedTID_addCustom ( + LLRP_tSImpinjSerializedTID *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjRFPhaseAngle +{ + LLRP_tSParameter hdr; + + llrp_u16_t PhaseAngle; + + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjRFPhaseAngle; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjRFPhaseAngle[]; + +extern LLRP_tSImpinjRFPhaseAngle * +LLRP_ImpinjRFPhaseAngle_construct (void); + +extern void +LLRP_ImpinjRFPhaseAngle_destruct ( + LLRP_tSImpinjRFPhaseAngle * pThis); + +extern void +LLRP_ImpinjRFPhaseAngle_decodeFields ( + LLRP_tSImpinjRFPhaseAngle * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjRFPhaseAngle_assimilateSubParameters ( + LLRP_tSImpinjRFPhaseAngle * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjRFPhaseAngle_encode ( + const LLRP_tSImpinjRFPhaseAngle *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjRFPhaseAngle_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjRFPhaseAngle_PhaseAngle; + +extern llrp_u16_t +LLRP_ImpinjRFPhaseAngle_getPhaseAngle ( + LLRP_tSImpinjRFPhaseAngle *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjRFPhaseAngle_setPhaseAngle ( + LLRP_tSImpinjRFPhaseAngle *pThis, + llrp_u16_t Value); + + +extern LLRP_tSParameter * +LLRP_ImpinjRFPhaseAngle_beginCustom ( + LLRP_tSImpinjRFPhaseAngle *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjRFPhaseAngle_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjRFPhaseAngle_clearCustom ( + LLRP_tSImpinjRFPhaseAngle *pThis); + +extern int +LLRP_ImpinjRFPhaseAngle_countCustom ( + LLRP_tSImpinjRFPhaseAngle *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjRFPhaseAngle_addCustom ( + LLRP_tSImpinjRFPhaseAngle *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjPeakRSSI +{ + LLRP_tSParameter hdr; + + llrp_s16_t RSSI; + + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjPeakRSSI; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjPeakRSSI[]; + +extern LLRP_tSImpinjPeakRSSI * +LLRP_ImpinjPeakRSSI_construct (void); + +extern void +LLRP_ImpinjPeakRSSI_destruct ( + LLRP_tSImpinjPeakRSSI * pThis); + +extern void +LLRP_ImpinjPeakRSSI_decodeFields ( + LLRP_tSImpinjPeakRSSI * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjPeakRSSI_assimilateSubParameters ( + LLRP_tSImpinjPeakRSSI * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjPeakRSSI_encode ( + const LLRP_tSImpinjPeakRSSI *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjPeakRSSI_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjPeakRSSI_RSSI; + +extern llrp_s16_t +LLRP_ImpinjPeakRSSI_getRSSI ( + LLRP_tSImpinjPeakRSSI *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjPeakRSSI_setRSSI ( + LLRP_tSImpinjPeakRSSI *pThis, + llrp_s16_t Value); + + +extern LLRP_tSParameter * +LLRP_ImpinjPeakRSSI_beginCustom ( + LLRP_tSImpinjPeakRSSI *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjPeakRSSI_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjPeakRSSI_clearCustom ( + LLRP_tSImpinjPeakRSSI *pThis); + +extern int +LLRP_ImpinjPeakRSSI_countCustom ( + LLRP_tSImpinjPeakRSSI *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjPeakRSSI_addCustom ( + LLRP_tSImpinjPeakRSSI *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjGPSCoordinates +{ + LLRP_tSParameter hdr; + + llrp_s32_t Latitude; + + llrp_s32_t Longitude; + + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjGPSCoordinates; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjGPSCoordinates[]; + +extern LLRP_tSImpinjGPSCoordinates * +LLRP_ImpinjGPSCoordinates_construct (void); + +extern void +LLRP_ImpinjGPSCoordinates_destruct ( + LLRP_tSImpinjGPSCoordinates * pThis); + +extern void +LLRP_ImpinjGPSCoordinates_decodeFields ( + LLRP_tSImpinjGPSCoordinates * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjGPSCoordinates_assimilateSubParameters ( + LLRP_tSImpinjGPSCoordinates * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjGPSCoordinates_encode ( + const LLRP_tSImpinjGPSCoordinates *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjGPSCoordinates_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjGPSCoordinates_Latitude; + +extern llrp_s32_t +LLRP_ImpinjGPSCoordinates_getLatitude ( + LLRP_tSImpinjGPSCoordinates *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjGPSCoordinates_setLatitude ( + LLRP_tSImpinjGPSCoordinates *pThis, + llrp_s32_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjGPSCoordinates_Longitude; + +extern llrp_s32_t +LLRP_ImpinjGPSCoordinates_getLongitude ( + LLRP_tSImpinjGPSCoordinates *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjGPSCoordinates_setLongitude ( + LLRP_tSImpinjGPSCoordinates *pThis, + llrp_s32_t Value); + + +extern LLRP_tSParameter * +LLRP_ImpinjGPSCoordinates_beginCustom ( + LLRP_tSImpinjGPSCoordinates *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjGPSCoordinates_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjGPSCoordinates_clearCustom ( + LLRP_tSImpinjGPSCoordinates *pThis); + +extern int +LLRP_ImpinjGPSCoordinates_countCustom ( + LLRP_tSImpinjGPSCoordinates *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjGPSCoordinates_addCustom ( + LLRP_tSImpinjGPSCoordinates *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjLoopSpec +{ + LLRP_tSParameter hdr; + + llrp_u32_t LoopCount; + + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjLoopSpec; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjLoopSpec[]; + +extern LLRP_tSImpinjLoopSpec * +LLRP_ImpinjLoopSpec_construct (void); + +extern void +LLRP_ImpinjLoopSpec_destruct ( + LLRP_tSImpinjLoopSpec * pThis); + +extern void +LLRP_ImpinjLoopSpec_decodeFields ( + LLRP_tSImpinjLoopSpec * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjLoopSpec_assimilateSubParameters ( + LLRP_tSImpinjLoopSpec * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjLoopSpec_encode ( + const LLRP_tSImpinjLoopSpec *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjLoopSpec_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjLoopSpec_LoopCount; + +extern llrp_u32_t +LLRP_ImpinjLoopSpec_getLoopCount ( + LLRP_tSImpinjLoopSpec *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjLoopSpec_setLoopCount ( + LLRP_tSImpinjLoopSpec *pThis, + llrp_u32_t Value); + + +extern LLRP_tSParameter * +LLRP_ImpinjLoopSpec_beginCustom ( + LLRP_tSImpinjLoopSpec *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjLoopSpec_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjLoopSpec_clearCustom ( + LLRP_tSImpinjLoopSpec *pThis); + +extern int +LLRP_ImpinjLoopSpec_countCustom ( + LLRP_tSImpinjLoopSpec *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjLoopSpec_addCustom ( + LLRP_tSImpinjLoopSpec *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjGPSNMEASentences +{ + LLRP_tSParameter hdr; + + + LLRP_tSImpinjGGASentence * pImpinjGGASentence; + + LLRP_tSImpinjRMCSentence * pImpinjRMCSentence; + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjGPSNMEASentences; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjGPSNMEASentences[]; + +extern LLRP_tSImpinjGPSNMEASentences * +LLRP_ImpinjGPSNMEASentences_construct (void); + +extern void +LLRP_ImpinjGPSNMEASentences_destruct ( + LLRP_tSImpinjGPSNMEASentences * pThis); + +extern void +LLRP_ImpinjGPSNMEASentences_decodeFields ( + LLRP_tSImpinjGPSNMEASentences * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjGPSNMEASentences_assimilateSubParameters ( + LLRP_tSImpinjGPSNMEASentences * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjGPSNMEASentences_encode ( + const LLRP_tSImpinjGPSNMEASentences *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjGPSNMEASentences_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + + +extern LLRP_tSImpinjGGASentence * +LLRP_ImpinjGPSNMEASentences_getImpinjGGASentence ( + LLRP_tSImpinjGPSNMEASentences *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjGPSNMEASentences_setImpinjGGASentence ( + LLRP_tSImpinjGPSNMEASentences *pThis, + LLRP_tSImpinjGGASentence *pValue); + +extern LLRP_tSImpinjRMCSentence * +LLRP_ImpinjGPSNMEASentences_getImpinjRMCSentence ( + LLRP_tSImpinjGPSNMEASentences *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjGPSNMEASentences_setImpinjRMCSentence ( + LLRP_tSImpinjGPSNMEASentences *pThis, + LLRP_tSImpinjRMCSentence *pValue); + +extern LLRP_tSParameter * +LLRP_ImpinjGPSNMEASentences_beginCustom ( + LLRP_tSImpinjGPSNMEASentences *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjGPSNMEASentences_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjGPSNMEASentences_clearCustom ( + LLRP_tSImpinjGPSNMEASentences *pThis); + +extern int +LLRP_ImpinjGPSNMEASentences_countCustom ( + LLRP_tSImpinjGPSNMEASentences *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjGPSNMEASentences_addCustom ( + LLRP_tSImpinjGPSNMEASentences *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjGGASentence +{ + LLRP_tSParameter hdr; + + llrp_utf8v_t GGASentence; + + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjGGASentence; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjGGASentence[]; + +extern LLRP_tSImpinjGGASentence * +LLRP_ImpinjGGASentence_construct (void); + +extern void +LLRP_ImpinjGGASentence_destruct ( + LLRP_tSImpinjGGASentence * pThis); + +extern void +LLRP_ImpinjGGASentence_decodeFields ( + LLRP_tSImpinjGGASentence * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjGGASentence_assimilateSubParameters ( + LLRP_tSImpinjGGASentence * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjGGASentence_encode ( + const LLRP_tSImpinjGGASentence *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjGGASentence_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjGGASentence_GGASentence; + +extern llrp_utf8v_t +LLRP_ImpinjGGASentence_getGGASentence ( + LLRP_tSImpinjGGASentence *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjGGASentence_setGGASentence ( + LLRP_tSImpinjGGASentence *pThis, + llrp_utf8v_t Value); + + +extern LLRP_tSParameter * +LLRP_ImpinjGGASentence_beginCustom ( + LLRP_tSImpinjGGASentence *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjGGASentence_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjGGASentence_clearCustom ( + LLRP_tSImpinjGGASentence *pThis); + +extern int +LLRP_ImpinjGGASentence_countCustom ( + LLRP_tSImpinjGGASentence *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjGGASentence_addCustom ( + LLRP_tSImpinjGGASentence *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjRMCSentence +{ + LLRP_tSParameter hdr; + + llrp_utf8v_t RMCSentence; + + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjRMCSentence; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjRMCSentence[]; + +extern LLRP_tSImpinjRMCSentence * +LLRP_ImpinjRMCSentence_construct (void); + +extern void +LLRP_ImpinjRMCSentence_destruct ( + LLRP_tSImpinjRMCSentence * pThis); + +extern void +LLRP_ImpinjRMCSentence_decodeFields ( + LLRP_tSImpinjRMCSentence * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjRMCSentence_assimilateSubParameters ( + LLRP_tSImpinjRMCSentence * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjRMCSentence_encode ( + const LLRP_tSImpinjRMCSentence *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjRMCSentence_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjRMCSentence_RMCSentence; + +extern llrp_utf8v_t +LLRP_ImpinjRMCSentence_getRMCSentence ( + LLRP_tSImpinjRMCSentence *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjRMCSentence_setRMCSentence ( + LLRP_tSImpinjRMCSentence *pThis, + llrp_utf8v_t Value); + + +extern LLRP_tSParameter * +LLRP_ImpinjRMCSentence_beginCustom ( + LLRP_tSImpinjRMCSentence *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjRMCSentence_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjRMCSentence_clearCustom ( + LLRP_tSImpinjRMCSentence *pThis); + +extern int +LLRP_ImpinjRMCSentence_countCustom ( + LLRP_tSImpinjRMCSentence *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjRMCSentence_addCustom ( + LLRP_tSImpinjRMCSentence *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjOpSpecRetryCount +{ + LLRP_tSParameter hdr; + + llrp_u16_t RetryCount; + + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjOpSpecRetryCount; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjOpSpecRetryCount[]; + +extern LLRP_tSImpinjOpSpecRetryCount * +LLRP_ImpinjOpSpecRetryCount_construct (void); + +extern void +LLRP_ImpinjOpSpecRetryCount_destruct ( + LLRP_tSImpinjOpSpecRetryCount * pThis); + +extern void +LLRP_ImpinjOpSpecRetryCount_decodeFields ( + LLRP_tSImpinjOpSpecRetryCount * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjOpSpecRetryCount_assimilateSubParameters ( + LLRP_tSImpinjOpSpecRetryCount * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjOpSpecRetryCount_encode ( + const LLRP_tSImpinjOpSpecRetryCount *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjOpSpecRetryCount_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjOpSpecRetryCount_RetryCount; + +extern llrp_u16_t +LLRP_ImpinjOpSpecRetryCount_getRetryCount ( + LLRP_tSImpinjOpSpecRetryCount *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjOpSpecRetryCount_setRetryCount ( + LLRP_tSImpinjOpSpecRetryCount *pThis, + llrp_u16_t Value); + + +extern LLRP_tSParameter * +LLRP_ImpinjOpSpecRetryCount_beginCustom ( + LLRP_tSImpinjOpSpecRetryCount *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjOpSpecRetryCount_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjOpSpecRetryCount_clearCustom ( + LLRP_tSImpinjOpSpecRetryCount *pThis); + +extern int +LLRP_ImpinjOpSpecRetryCount_countCustom ( + LLRP_tSImpinjOpSpecRetryCount *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjOpSpecRetryCount_addCustom ( + LLRP_tSImpinjOpSpecRetryCount *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjAdvancedGPOConfiguration +{ + LLRP_tSParameter hdr; + + llrp_u16_t GPOPortNum; + + LLRP_tEImpinjAdvancedGPOMode eGPOMode; + + llrp_u32_t GPOPulseDurationMSec; + + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjAdvancedGPOConfiguration; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjAdvancedGPOConfiguration[]; + +extern LLRP_tSImpinjAdvancedGPOConfiguration * +LLRP_ImpinjAdvancedGPOConfiguration_construct (void); + +extern void +LLRP_ImpinjAdvancedGPOConfiguration_destruct ( + LLRP_tSImpinjAdvancedGPOConfiguration * pThis); + +extern void +LLRP_ImpinjAdvancedGPOConfiguration_decodeFields ( + LLRP_tSImpinjAdvancedGPOConfiguration * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjAdvancedGPOConfiguration_assimilateSubParameters ( + LLRP_tSImpinjAdvancedGPOConfiguration * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjAdvancedGPOConfiguration_encode ( + const LLRP_tSImpinjAdvancedGPOConfiguration *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjAdvancedGPOConfiguration_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjAdvancedGPOConfiguration_GPOPortNum; + +extern llrp_u16_t +LLRP_ImpinjAdvancedGPOConfiguration_getGPOPortNum ( + LLRP_tSImpinjAdvancedGPOConfiguration *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjAdvancedGPOConfiguration_setGPOPortNum ( + LLRP_tSImpinjAdvancedGPOConfiguration *pThis, + llrp_u16_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjAdvancedGPOConfiguration_GPOMode; + +extern LLRP_tEImpinjAdvancedGPOMode +LLRP_ImpinjAdvancedGPOConfiguration_getGPOMode ( + LLRP_tSImpinjAdvancedGPOConfiguration *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjAdvancedGPOConfiguration_setGPOMode ( + LLRP_tSImpinjAdvancedGPOConfiguration *pThis, + LLRP_tEImpinjAdvancedGPOMode Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjAdvancedGPOConfiguration_GPOPulseDurationMSec; + +extern llrp_u32_t +LLRP_ImpinjAdvancedGPOConfiguration_getGPOPulseDurationMSec ( + LLRP_tSImpinjAdvancedGPOConfiguration *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjAdvancedGPOConfiguration_setGPOPulseDurationMSec ( + LLRP_tSImpinjAdvancedGPOConfiguration *pThis, + llrp_u32_t Value); + + +extern LLRP_tSParameter * +LLRP_ImpinjAdvancedGPOConfiguration_beginCustom ( + LLRP_tSImpinjAdvancedGPOConfiguration *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjAdvancedGPOConfiguration_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjAdvancedGPOConfiguration_clearCustom ( + LLRP_tSImpinjAdvancedGPOConfiguration *pThis); + +extern int +LLRP_ImpinjAdvancedGPOConfiguration_countCustom ( + LLRP_tSImpinjAdvancedGPOConfiguration *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjAdvancedGPOConfiguration_addCustom ( + LLRP_tSImpinjAdvancedGPOConfiguration *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjEnableOptimizedRead +{ + LLRP_tSParameter hdr; + + LLRP_tEImpinjOptimizedReadMode eOptimizedReadMode; + + + LLRP_tSC1G2Read * listC1G2Read; + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjEnableOptimizedRead; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjEnableOptimizedRead[]; + +extern LLRP_tSImpinjEnableOptimizedRead * +LLRP_ImpinjEnableOptimizedRead_construct (void); + +extern void +LLRP_ImpinjEnableOptimizedRead_destruct ( + LLRP_tSImpinjEnableOptimizedRead * pThis); + +extern void +LLRP_ImpinjEnableOptimizedRead_decodeFields ( + LLRP_tSImpinjEnableOptimizedRead * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjEnableOptimizedRead_assimilateSubParameters ( + LLRP_tSImpinjEnableOptimizedRead * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjEnableOptimizedRead_encode ( + const LLRP_tSImpinjEnableOptimizedRead *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjEnableOptimizedRead_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjEnableOptimizedRead_OptimizedReadMode; + +extern LLRP_tEImpinjOptimizedReadMode +LLRP_ImpinjEnableOptimizedRead_getOptimizedReadMode ( + LLRP_tSImpinjEnableOptimizedRead *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjEnableOptimizedRead_setOptimizedReadMode ( + LLRP_tSImpinjEnableOptimizedRead *pThis, + LLRP_tEImpinjOptimizedReadMode Value); + + +extern LLRP_tSC1G2Read * +LLRP_ImpinjEnableOptimizedRead_beginC1G2Read ( + LLRP_tSImpinjEnableOptimizedRead *pThis); + +extern LLRP_tSC1G2Read * +LLRP_ImpinjEnableOptimizedRead_nextC1G2Read ( + LLRP_tSC1G2Read *pCurrent); + +extern void +LLRP_ImpinjEnableOptimizedRead_clearC1G2Read ( + LLRP_tSImpinjEnableOptimizedRead *pThis); + +extern int +LLRP_ImpinjEnableOptimizedRead_countC1G2Read ( + LLRP_tSImpinjEnableOptimizedRead *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjEnableOptimizedRead_addC1G2Read ( + LLRP_tSImpinjEnableOptimizedRead *pThis, + LLRP_tSC1G2Read *pValue); + + +extern LLRP_tSParameter * +LLRP_ImpinjEnableOptimizedRead_beginCustom ( + LLRP_tSImpinjEnableOptimizedRead *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjEnableOptimizedRead_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjEnableOptimizedRead_clearCustom ( + LLRP_tSImpinjEnableOptimizedRead *pThis); + +extern int +LLRP_ImpinjEnableOptimizedRead_countCustom ( + LLRP_tSImpinjEnableOptimizedRead *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjEnableOptimizedRead_addCustom ( + LLRP_tSImpinjEnableOptimizedRead *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjAccessSpecOrdering +{ + LLRP_tSParameter hdr; + + LLRP_tEImpinjAccessSpecOrderingMode eOrderingMode; + + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjAccessSpecOrdering; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjAccessSpecOrdering[]; + +extern LLRP_tSImpinjAccessSpecOrdering * +LLRP_ImpinjAccessSpecOrdering_construct (void); + +extern void +LLRP_ImpinjAccessSpecOrdering_destruct ( + LLRP_tSImpinjAccessSpecOrdering * pThis); + +extern void +LLRP_ImpinjAccessSpecOrdering_decodeFields ( + LLRP_tSImpinjAccessSpecOrdering * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjAccessSpecOrdering_assimilateSubParameters ( + LLRP_tSImpinjAccessSpecOrdering * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjAccessSpecOrdering_encode ( + const LLRP_tSImpinjAccessSpecOrdering *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjAccessSpecOrdering_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjAccessSpecOrdering_OrderingMode; + +extern LLRP_tEImpinjAccessSpecOrderingMode +LLRP_ImpinjAccessSpecOrdering_getOrderingMode ( + LLRP_tSImpinjAccessSpecOrdering *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjAccessSpecOrdering_setOrderingMode ( + LLRP_tSImpinjAccessSpecOrdering *pThis, + LLRP_tEImpinjAccessSpecOrderingMode Value); + + +extern LLRP_tSParameter * +LLRP_ImpinjAccessSpecOrdering_beginCustom ( + LLRP_tSImpinjAccessSpecOrdering *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjAccessSpecOrdering_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjAccessSpecOrdering_clearCustom ( + LLRP_tSImpinjAccessSpecOrdering *pThis); + +extern int +LLRP_ImpinjAccessSpecOrdering_countCustom ( + LLRP_tSImpinjAccessSpecOrdering *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjAccessSpecOrdering_addCustom ( + LLRP_tSImpinjAccessSpecOrdering *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjEnableRFDopplerFrequency +{ + LLRP_tSParameter hdr; + + LLRP_tEImpinjRFDopplerFrequencyMode eRFDopplerFrequencyMode; + + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjEnableRFDopplerFrequency; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjEnableRFDopplerFrequency[]; + +extern LLRP_tSImpinjEnableRFDopplerFrequency * +LLRP_ImpinjEnableRFDopplerFrequency_construct (void); + +extern void +LLRP_ImpinjEnableRFDopplerFrequency_destruct ( + LLRP_tSImpinjEnableRFDopplerFrequency * pThis); + +extern void +LLRP_ImpinjEnableRFDopplerFrequency_decodeFields ( + LLRP_tSImpinjEnableRFDopplerFrequency * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjEnableRFDopplerFrequency_assimilateSubParameters ( + LLRP_tSImpinjEnableRFDopplerFrequency * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjEnableRFDopplerFrequency_encode ( + const LLRP_tSImpinjEnableRFDopplerFrequency *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjEnableRFDopplerFrequency_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjEnableRFDopplerFrequency_RFDopplerFrequencyMode; + +extern LLRP_tEImpinjRFDopplerFrequencyMode +LLRP_ImpinjEnableRFDopplerFrequency_getRFDopplerFrequencyMode ( + LLRP_tSImpinjEnableRFDopplerFrequency *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjEnableRFDopplerFrequency_setRFDopplerFrequencyMode ( + LLRP_tSImpinjEnableRFDopplerFrequency *pThis, + LLRP_tEImpinjRFDopplerFrequencyMode Value); + + +extern LLRP_tSParameter * +LLRP_ImpinjEnableRFDopplerFrequency_beginCustom ( + LLRP_tSImpinjEnableRFDopplerFrequency *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjEnableRFDopplerFrequency_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjEnableRFDopplerFrequency_clearCustom ( + LLRP_tSImpinjEnableRFDopplerFrequency *pThis); + +extern int +LLRP_ImpinjEnableRFDopplerFrequency_countCustom ( + LLRP_tSImpinjEnableRFDopplerFrequency *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjEnableRFDopplerFrequency_addCustom ( + LLRP_tSImpinjEnableRFDopplerFrequency *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjRFDopplerFrequency +{ + LLRP_tSParameter hdr; + + llrp_s16_t DopplerFrequency; + + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjRFDopplerFrequency; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjRFDopplerFrequency[]; + +extern LLRP_tSImpinjRFDopplerFrequency * +LLRP_ImpinjRFDopplerFrequency_construct (void); + +extern void +LLRP_ImpinjRFDopplerFrequency_destruct ( + LLRP_tSImpinjRFDopplerFrequency * pThis); + +extern void +LLRP_ImpinjRFDopplerFrequency_decodeFields ( + LLRP_tSImpinjRFDopplerFrequency * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjRFDopplerFrequency_assimilateSubParameters ( + LLRP_tSImpinjRFDopplerFrequency * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjRFDopplerFrequency_encode ( + const LLRP_tSImpinjRFDopplerFrequency *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjRFDopplerFrequency_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjRFDopplerFrequency_DopplerFrequency; + +extern llrp_s16_t +LLRP_ImpinjRFDopplerFrequency_getDopplerFrequency ( + LLRP_tSImpinjRFDopplerFrequency *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjRFDopplerFrequency_setDopplerFrequency ( + LLRP_tSImpinjRFDopplerFrequency *pThis, + llrp_s16_t Value); + + +extern LLRP_tSParameter * +LLRP_ImpinjRFDopplerFrequency_beginCustom ( + LLRP_tSImpinjRFDopplerFrequency *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjRFDopplerFrequency_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjRFDopplerFrequency_clearCustom ( + LLRP_tSImpinjRFDopplerFrequency *pThis); + +extern int +LLRP_ImpinjRFDopplerFrequency_countCustom ( + LLRP_tSImpinjRFDopplerFrequency *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjRFDopplerFrequency_addCustom ( + LLRP_tSImpinjRFDopplerFrequency *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjInventoryConfiguration +{ + LLRP_tSParameter hdr; + + llrp_u1_t EnableAntDwellTimeLimit; + + llrp_u1_t EnableSelectGapClose; + + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjInventoryConfiguration; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjInventoryConfiguration[]; + +extern LLRP_tSImpinjInventoryConfiguration * +LLRP_ImpinjInventoryConfiguration_construct (void); + +extern void +LLRP_ImpinjInventoryConfiguration_destruct ( + LLRP_tSImpinjInventoryConfiguration * pThis); + +extern void +LLRP_ImpinjInventoryConfiguration_decodeFields ( + LLRP_tSImpinjInventoryConfiguration * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjInventoryConfiguration_assimilateSubParameters ( + LLRP_tSImpinjInventoryConfiguration * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjInventoryConfiguration_encode ( + const LLRP_tSImpinjInventoryConfiguration *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjInventoryConfiguration_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjInventoryConfiguration_EnableAntDwellTimeLimit; + +extern llrp_u1_t +LLRP_ImpinjInventoryConfiguration_getEnableAntDwellTimeLimit ( + LLRP_tSImpinjInventoryConfiguration *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjInventoryConfiguration_setEnableAntDwellTimeLimit ( + LLRP_tSImpinjInventoryConfiguration *pThis, + llrp_u1_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjInventoryConfiguration_EnableSelectGapClose; + +extern llrp_u1_t +LLRP_ImpinjInventoryConfiguration_getEnableSelectGapClose ( + LLRP_tSImpinjInventoryConfiguration *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjInventoryConfiguration_setEnableSelectGapClose ( + LLRP_tSImpinjInventoryConfiguration *pThis, + llrp_u1_t Value); + + +extern LLRP_tSParameter * +LLRP_ImpinjInventoryConfiguration_beginCustom ( + LLRP_tSImpinjInventoryConfiguration *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjInventoryConfiguration_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjInventoryConfiguration_clearCustom ( + LLRP_tSImpinjInventoryConfiguration *pThis); + +extern int +LLRP_ImpinjInventoryConfiguration_countCustom ( + LLRP_tSImpinjInventoryConfiguration *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjInventoryConfiguration_addCustom ( + LLRP_tSImpinjInventoryConfiguration *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjEnableTxPower +{ + LLRP_tSParameter hdr; + + LLRP_tEImpinjTxPowerReportingModeEnum eTxPowerReportingMode; + + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjEnableTxPower; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjEnableTxPower[]; + +extern LLRP_tSImpinjEnableTxPower * +LLRP_ImpinjEnableTxPower_construct (void); + +extern void +LLRP_ImpinjEnableTxPower_destruct ( + LLRP_tSImpinjEnableTxPower * pThis); + +extern void +LLRP_ImpinjEnableTxPower_decodeFields ( + LLRP_tSImpinjEnableTxPower * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjEnableTxPower_assimilateSubParameters ( + LLRP_tSImpinjEnableTxPower * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjEnableTxPower_encode ( + const LLRP_tSImpinjEnableTxPower *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjEnableTxPower_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjEnableTxPower_TxPowerReportingMode; + +extern LLRP_tEImpinjTxPowerReportingModeEnum +LLRP_ImpinjEnableTxPower_getTxPowerReportingMode ( + LLRP_tSImpinjEnableTxPower *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjEnableTxPower_setTxPowerReportingMode ( + LLRP_tSImpinjEnableTxPower *pThis, + LLRP_tEImpinjTxPowerReportingModeEnum Value); + + +extern LLRP_tSParameter * +LLRP_ImpinjEnableTxPower_beginCustom ( + LLRP_tSImpinjEnableTxPower *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjEnableTxPower_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjEnableTxPower_clearCustom ( + LLRP_tSImpinjEnableTxPower *pThis); + +extern int +LLRP_ImpinjEnableTxPower_countCustom ( + LLRP_tSImpinjEnableTxPower *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjEnableTxPower_addCustom ( + LLRP_tSImpinjEnableTxPower *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjTxPower +{ + LLRP_tSParameter hdr; + + llrp_u16_t TxPower; + + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjTxPower; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjTxPower[]; + +extern LLRP_tSImpinjTxPower * +LLRP_ImpinjTxPower_construct (void); + +extern void +LLRP_ImpinjTxPower_destruct ( + LLRP_tSImpinjTxPower * pThis); + +extern void +LLRP_ImpinjTxPower_decodeFields ( + LLRP_tSImpinjTxPower * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjTxPower_assimilateSubParameters ( + LLRP_tSImpinjTxPower * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjTxPower_encode ( + const LLRP_tSImpinjTxPower *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjTxPower_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjTxPower_TxPower; + +extern llrp_u16_t +LLRP_ImpinjTxPower_getTxPower ( + LLRP_tSImpinjTxPower *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjTxPower_setTxPower ( + LLRP_tSImpinjTxPower *pThis, + llrp_u16_t Value); + + +extern LLRP_tSParameter * +LLRP_ImpinjTxPower_beginCustom ( + LLRP_tSImpinjTxPower *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjTxPower_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjTxPower_clearCustom ( + LLRP_tSImpinjTxPower *pThis); + +extern int +LLRP_ImpinjTxPower_countCustom ( + LLRP_tSImpinjTxPower *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjTxPower_addCustom ( + LLRP_tSImpinjTxPower *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjEnableXPCWords +{ + LLRP_tSParameter hdr; + + LLRP_tEImpinjXPCWordsMode eXPCWordsMode; + + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjEnableXPCWords; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjEnableXPCWords[]; + +extern LLRP_tSImpinjEnableXPCWords * +LLRP_ImpinjEnableXPCWords_construct (void); + +extern void +LLRP_ImpinjEnableXPCWords_destruct ( + LLRP_tSImpinjEnableXPCWords * pThis); + +extern void +LLRP_ImpinjEnableXPCWords_decodeFields ( + LLRP_tSImpinjEnableXPCWords * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjEnableXPCWords_assimilateSubParameters ( + LLRP_tSImpinjEnableXPCWords * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjEnableXPCWords_encode ( + const LLRP_tSImpinjEnableXPCWords *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjEnableXPCWords_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjEnableXPCWords_XPCWordsMode; + +extern LLRP_tEImpinjXPCWordsMode +LLRP_ImpinjEnableXPCWords_getXPCWordsMode ( + LLRP_tSImpinjEnableXPCWords *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjEnableXPCWords_setXPCWordsMode ( + LLRP_tSImpinjEnableXPCWords *pThis, + LLRP_tEImpinjXPCWordsMode Value); + + +extern LLRP_tSParameter * +LLRP_ImpinjEnableXPCWords_beginCustom ( + LLRP_tSImpinjEnableXPCWords *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjEnableXPCWords_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjEnableXPCWords_clearCustom ( + LLRP_tSImpinjEnableXPCWords *pThis); + +extern int +LLRP_ImpinjEnableXPCWords_countCustom ( + LLRP_tSImpinjEnableXPCWords *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjEnableXPCWords_addCustom ( + LLRP_tSImpinjEnableXPCWords *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjXPCWords +{ + LLRP_tSParameter hdr; + + llrp_u16v_t XPCWords; + + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjXPCWords; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjXPCWords[]; + +extern LLRP_tSImpinjXPCWords * +LLRP_ImpinjXPCWords_construct (void); + +extern void +LLRP_ImpinjXPCWords_destruct ( + LLRP_tSImpinjXPCWords * pThis); + +extern void +LLRP_ImpinjXPCWords_decodeFields ( + LLRP_tSImpinjXPCWords * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjXPCWords_assimilateSubParameters ( + LLRP_tSImpinjXPCWords * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjXPCWords_encode ( + const LLRP_tSImpinjXPCWords *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjXPCWords_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjXPCWords_XPCWords; + +extern llrp_u16v_t +LLRP_ImpinjXPCWords_getXPCWords ( + LLRP_tSImpinjXPCWords *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjXPCWords_setXPCWords ( + LLRP_tSImpinjXPCWords *pThis, + llrp_u16v_t Value); + + +extern LLRP_tSParameter * +LLRP_ImpinjXPCWords_beginCustom ( + LLRP_tSImpinjXPCWords *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjXPCWords_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjXPCWords_clearCustom ( + LLRP_tSImpinjXPCWords *pThis); + +extern int +LLRP_ImpinjXPCWords_countCustom ( + LLRP_tSImpinjXPCWords *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjXPCWords_addCustom ( + LLRP_tSImpinjXPCWords *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjArrayVersion +{ + LLRP_tSParameter hdr; + + llrp_utf8v_t SerialNumber; + + llrp_utf8v_t FirmwareVersion; + + llrp_utf8v_t PCBAVersion; + + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjArrayVersion; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjArrayVersion[]; + +extern LLRP_tSImpinjArrayVersion * +LLRP_ImpinjArrayVersion_construct (void); + +extern void +LLRP_ImpinjArrayVersion_destruct ( + LLRP_tSImpinjArrayVersion * pThis); + +extern void +LLRP_ImpinjArrayVersion_decodeFields ( + LLRP_tSImpinjArrayVersion * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjArrayVersion_assimilateSubParameters ( + LLRP_tSImpinjArrayVersion * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjArrayVersion_encode ( + const LLRP_tSImpinjArrayVersion *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjArrayVersion_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjArrayVersion_SerialNumber; + +extern llrp_utf8v_t +LLRP_ImpinjArrayVersion_getSerialNumber ( + LLRP_tSImpinjArrayVersion *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjArrayVersion_setSerialNumber ( + LLRP_tSImpinjArrayVersion *pThis, + llrp_utf8v_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjArrayVersion_FirmwareVersion; + +extern llrp_utf8v_t +LLRP_ImpinjArrayVersion_getFirmwareVersion ( + LLRP_tSImpinjArrayVersion *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjArrayVersion_setFirmwareVersion ( + LLRP_tSImpinjArrayVersion *pThis, + llrp_utf8v_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjArrayVersion_PCBAVersion; + +extern llrp_utf8v_t +LLRP_ImpinjArrayVersion_getPCBAVersion ( + LLRP_tSImpinjArrayVersion *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjArrayVersion_setPCBAVersion ( + LLRP_tSImpinjArrayVersion *pThis, + llrp_utf8v_t Value); + + +extern LLRP_tSParameter * +LLRP_ImpinjArrayVersion_beginCustom ( + LLRP_tSImpinjArrayVersion *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjArrayVersion_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjArrayVersion_clearCustom ( + LLRP_tSImpinjArrayVersion *pThis); + +extern int +LLRP_ImpinjArrayVersion_countCustom ( + LLRP_tSImpinjArrayVersion *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjArrayVersion_addCustom ( + LLRP_tSImpinjArrayVersion *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjxArrayCapabilities +{ + LLRP_tSParameter hdr; + + llrp_u32_t MaxNumSectors; + + llrp_u1_t SupportsLISpecs; + + llrp_u1_t SupportsTISpecs; + + llrp_u1_t SupportsTSISpecs; + + llrp_u1_t SupportsDISpecs; + + llrp_u1_t SupportsESSpecs; + + + LLRP_tSImpinjxArrayDirectionCapabilities * pImpinjxArrayDirectionCapabilities; + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjxArrayCapabilities; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjxArrayCapabilities[]; + +extern LLRP_tSImpinjxArrayCapabilities * +LLRP_ImpinjxArrayCapabilities_construct (void); + +extern void +LLRP_ImpinjxArrayCapabilities_destruct ( + LLRP_tSImpinjxArrayCapabilities * pThis); + +extern void +LLRP_ImpinjxArrayCapabilities_decodeFields ( + LLRP_tSImpinjxArrayCapabilities * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjxArrayCapabilities_assimilateSubParameters ( + LLRP_tSImpinjxArrayCapabilities * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjxArrayCapabilities_encode ( + const LLRP_tSImpinjxArrayCapabilities *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjxArrayCapabilities_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjxArrayCapabilities_MaxNumSectors; + +extern llrp_u32_t +LLRP_ImpinjxArrayCapabilities_getMaxNumSectors ( + LLRP_tSImpinjxArrayCapabilities *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjxArrayCapabilities_setMaxNumSectors ( + LLRP_tSImpinjxArrayCapabilities *pThis, + llrp_u32_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjxArrayCapabilities_SupportsLISpecs; + +extern llrp_u1_t +LLRP_ImpinjxArrayCapabilities_getSupportsLISpecs ( + LLRP_tSImpinjxArrayCapabilities *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjxArrayCapabilities_setSupportsLISpecs ( + LLRP_tSImpinjxArrayCapabilities *pThis, + llrp_u1_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjxArrayCapabilities_SupportsTISpecs; + +extern llrp_u1_t +LLRP_ImpinjxArrayCapabilities_getSupportsTISpecs ( + LLRP_tSImpinjxArrayCapabilities *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjxArrayCapabilities_setSupportsTISpecs ( + LLRP_tSImpinjxArrayCapabilities *pThis, + llrp_u1_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjxArrayCapabilities_SupportsTSISpecs; + +extern llrp_u1_t +LLRP_ImpinjxArrayCapabilities_getSupportsTSISpecs ( + LLRP_tSImpinjxArrayCapabilities *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjxArrayCapabilities_setSupportsTSISpecs ( + LLRP_tSImpinjxArrayCapabilities *pThis, + llrp_u1_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjxArrayCapabilities_SupportsDISpecs; + +extern llrp_u1_t +LLRP_ImpinjxArrayCapabilities_getSupportsDISpecs ( + LLRP_tSImpinjxArrayCapabilities *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjxArrayCapabilities_setSupportsDISpecs ( + LLRP_tSImpinjxArrayCapabilities *pThis, + llrp_u1_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjxArrayCapabilities_SupportsESSpecs; + +extern llrp_u1_t +LLRP_ImpinjxArrayCapabilities_getSupportsESSpecs ( + LLRP_tSImpinjxArrayCapabilities *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjxArrayCapabilities_setSupportsESSpecs ( + LLRP_tSImpinjxArrayCapabilities *pThis, + llrp_u1_t Value); + + +extern LLRP_tSImpinjxArrayDirectionCapabilities * +LLRP_ImpinjxArrayCapabilities_getImpinjxArrayDirectionCapabilities ( + LLRP_tSImpinjxArrayCapabilities *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjxArrayCapabilities_setImpinjxArrayDirectionCapabilities ( + LLRP_tSImpinjxArrayCapabilities *pThis, + LLRP_tSImpinjxArrayDirectionCapabilities *pValue); + +extern LLRP_tSParameter * +LLRP_ImpinjxArrayCapabilities_beginCustom ( + LLRP_tSImpinjxArrayCapabilities *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjxArrayCapabilities_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjxArrayCapabilities_clearCustom ( + LLRP_tSImpinjxArrayCapabilities *pThis); + +extern int +LLRP_ImpinjxArrayCapabilities_countCustom ( + LLRP_tSImpinjxArrayCapabilities *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjxArrayCapabilities_addCustom ( + LLRP_tSImpinjxArrayCapabilities *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjTiltConfiguration +{ + LLRP_tSParameter hdr; + + llrp_s32_t XAxis; + + llrp_s32_t YAxis; + + llrp_s32_t ZAxis; + + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjTiltConfiguration; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjTiltConfiguration[]; + +extern LLRP_tSImpinjTiltConfiguration * +LLRP_ImpinjTiltConfiguration_construct (void); + +extern void +LLRP_ImpinjTiltConfiguration_destruct ( + LLRP_tSImpinjTiltConfiguration * pThis); + +extern void +LLRP_ImpinjTiltConfiguration_decodeFields ( + LLRP_tSImpinjTiltConfiguration * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjTiltConfiguration_assimilateSubParameters ( + LLRP_tSImpinjTiltConfiguration * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjTiltConfiguration_encode ( + const LLRP_tSImpinjTiltConfiguration *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjTiltConfiguration_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjTiltConfiguration_XAxis; + +extern llrp_s32_t +LLRP_ImpinjTiltConfiguration_getXAxis ( + LLRP_tSImpinjTiltConfiguration *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjTiltConfiguration_setXAxis ( + LLRP_tSImpinjTiltConfiguration *pThis, + llrp_s32_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjTiltConfiguration_YAxis; + +extern llrp_s32_t +LLRP_ImpinjTiltConfiguration_getYAxis ( + LLRP_tSImpinjTiltConfiguration *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjTiltConfiguration_setYAxis ( + LLRP_tSImpinjTiltConfiguration *pThis, + llrp_s32_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjTiltConfiguration_ZAxis; + +extern llrp_s32_t +LLRP_ImpinjTiltConfiguration_getZAxis ( + LLRP_tSImpinjTiltConfiguration *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjTiltConfiguration_setZAxis ( + LLRP_tSImpinjTiltConfiguration *pThis, + llrp_s32_t Value); + + +extern LLRP_tSParameter * +LLRP_ImpinjTiltConfiguration_beginCustom ( + LLRP_tSImpinjTiltConfiguration *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjTiltConfiguration_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjTiltConfiguration_clearCustom ( + LLRP_tSImpinjTiltConfiguration *pThis); + +extern int +LLRP_ImpinjTiltConfiguration_countCustom ( + LLRP_tSImpinjTiltConfiguration *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjTiltConfiguration_addCustom ( + LLRP_tSImpinjTiltConfiguration *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjBeaconConfiguration +{ + LLRP_tSParameter hdr; + + llrp_u1_t BeaconState; + + llrp_u64_t BeaconDurationSeconds; + + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjBeaconConfiguration; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjBeaconConfiguration[]; + +extern LLRP_tSImpinjBeaconConfiguration * +LLRP_ImpinjBeaconConfiguration_construct (void); + +extern void +LLRP_ImpinjBeaconConfiguration_destruct ( + LLRP_tSImpinjBeaconConfiguration * pThis); + +extern void +LLRP_ImpinjBeaconConfiguration_decodeFields ( + LLRP_tSImpinjBeaconConfiguration * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjBeaconConfiguration_assimilateSubParameters ( + LLRP_tSImpinjBeaconConfiguration * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjBeaconConfiguration_encode ( + const LLRP_tSImpinjBeaconConfiguration *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjBeaconConfiguration_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjBeaconConfiguration_BeaconState; + +extern llrp_u1_t +LLRP_ImpinjBeaconConfiguration_getBeaconState ( + LLRP_tSImpinjBeaconConfiguration *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjBeaconConfiguration_setBeaconState ( + LLRP_tSImpinjBeaconConfiguration *pThis, + llrp_u1_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjBeaconConfiguration_BeaconDurationSeconds; + +extern llrp_u64_t +LLRP_ImpinjBeaconConfiguration_getBeaconDurationSeconds ( + LLRP_tSImpinjBeaconConfiguration *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjBeaconConfiguration_setBeaconDurationSeconds ( + LLRP_tSImpinjBeaconConfiguration *pThis, + llrp_u64_t Value); + + +extern LLRP_tSParameter * +LLRP_ImpinjBeaconConfiguration_beginCustom ( + LLRP_tSImpinjBeaconConfiguration *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjBeaconConfiguration_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjBeaconConfiguration_clearCustom ( + LLRP_tSImpinjBeaconConfiguration *pThis); + +extern int +LLRP_ImpinjBeaconConfiguration_countCustom ( + LLRP_tSImpinjBeaconConfiguration *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjBeaconConfiguration_addCustom ( + LLRP_tSImpinjBeaconConfiguration *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjAntennaConfiguration +{ + LLRP_tSParameter hdr; + + + LLRP_tSImpinjAntennaEventHysteresis * pImpinjAntennaEventHysteresis; + + LLRP_tSImpinjAntennaEventConfiguration * pImpinjAntennaEventConfiguration; + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjAntennaConfiguration; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjAntennaConfiguration[]; + +extern LLRP_tSImpinjAntennaConfiguration * +LLRP_ImpinjAntennaConfiguration_construct (void); + +extern void +LLRP_ImpinjAntennaConfiguration_destruct ( + LLRP_tSImpinjAntennaConfiguration * pThis); + +extern void +LLRP_ImpinjAntennaConfiguration_decodeFields ( + LLRP_tSImpinjAntennaConfiguration * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjAntennaConfiguration_assimilateSubParameters ( + LLRP_tSImpinjAntennaConfiguration * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjAntennaConfiguration_encode ( + const LLRP_tSImpinjAntennaConfiguration *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjAntennaConfiguration_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + + +extern LLRP_tSImpinjAntennaEventHysteresis * +LLRP_ImpinjAntennaConfiguration_getImpinjAntennaEventHysteresis ( + LLRP_tSImpinjAntennaConfiguration *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjAntennaConfiguration_setImpinjAntennaEventHysteresis ( + LLRP_tSImpinjAntennaConfiguration *pThis, + LLRP_tSImpinjAntennaEventHysteresis *pValue); + +extern LLRP_tSImpinjAntennaEventConfiguration * +LLRP_ImpinjAntennaConfiguration_getImpinjAntennaEventConfiguration ( + LLRP_tSImpinjAntennaConfiguration *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjAntennaConfiguration_setImpinjAntennaEventConfiguration ( + LLRP_tSImpinjAntennaConfiguration *pThis, + LLRP_tSImpinjAntennaEventConfiguration *pValue); + +extern LLRP_tSParameter * +LLRP_ImpinjAntennaConfiguration_beginCustom ( + LLRP_tSImpinjAntennaConfiguration *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjAntennaConfiguration_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjAntennaConfiguration_clearCustom ( + LLRP_tSImpinjAntennaConfiguration *pThis); + +extern int +LLRP_ImpinjAntennaConfiguration_countCustom ( + LLRP_tSImpinjAntennaConfiguration *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjAntennaConfiguration_addCustom ( + LLRP_tSImpinjAntennaConfiguration *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjAntennaEventHysteresis +{ + LLRP_tSParameter hdr; + + llrp_u64_t AntennaEventConnected; + + llrp_u64_t AntennaEventDisconnected; + + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjAntennaEventHysteresis; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjAntennaEventHysteresis[]; + +extern LLRP_tSImpinjAntennaEventHysteresis * +LLRP_ImpinjAntennaEventHysteresis_construct (void); + +extern void +LLRP_ImpinjAntennaEventHysteresis_destruct ( + LLRP_tSImpinjAntennaEventHysteresis * pThis); + +extern void +LLRP_ImpinjAntennaEventHysteresis_decodeFields ( + LLRP_tSImpinjAntennaEventHysteresis * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjAntennaEventHysteresis_assimilateSubParameters ( + LLRP_tSImpinjAntennaEventHysteresis * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjAntennaEventHysteresis_encode ( + const LLRP_tSImpinjAntennaEventHysteresis *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjAntennaEventHysteresis_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjAntennaEventHysteresis_AntennaEventConnected; + +extern llrp_u64_t +LLRP_ImpinjAntennaEventHysteresis_getAntennaEventConnected ( + LLRP_tSImpinjAntennaEventHysteresis *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjAntennaEventHysteresis_setAntennaEventConnected ( + LLRP_tSImpinjAntennaEventHysteresis *pThis, + llrp_u64_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjAntennaEventHysteresis_AntennaEventDisconnected; + +extern llrp_u64_t +LLRP_ImpinjAntennaEventHysteresis_getAntennaEventDisconnected ( + LLRP_tSImpinjAntennaEventHysteresis *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjAntennaEventHysteresis_setAntennaEventDisconnected ( + LLRP_tSImpinjAntennaEventHysteresis *pThis, + llrp_u64_t Value); + + +extern LLRP_tSParameter * +LLRP_ImpinjAntennaEventHysteresis_beginCustom ( + LLRP_tSImpinjAntennaEventHysteresis *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjAntennaEventHysteresis_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjAntennaEventHysteresis_clearCustom ( + LLRP_tSImpinjAntennaEventHysteresis *pThis); + +extern int +LLRP_ImpinjAntennaEventHysteresis_countCustom ( + LLRP_tSImpinjAntennaEventHysteresis *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjAntennaEventHysteresis_addCustom ( + LLRP_tSImpinjAntennaEventHysteresis *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjAntennaEventConfiguration +{ + LLRP_tSParameter hdr; + + llrp_u1_t EnableAntennaAttemptNotification; + + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjAntennaEventConfiguration; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjAntennaEventConfiguration[]; + +extern LLRP_tSImpinjAntennaEventConfiguration * +LLRP_ImpinjAntennaEventConfiguration_construct (void); + +extern void +LLRP_ImpinjAntennaEventConfiguration_destruct ( + LLRP_tSImpinjAntennaEventConfiguration * pThis); + +extern void +LLRP_ImpinjAntennaEventConfiguration_decodeFields ( + LLRP_tSImpinjAntennaEventConfiguration * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjAntennaEventConfiguration_assimilateSubParameters ( + LLRP_tSImpinjAntennaEventConfiguration * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjAntennaEventConfiguration_encode ( + const LLRP_tSImpinjAntennaEventConfiguration *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjAntennaEventConfiguration_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjAntennaEventConfiguration_EnableAntennaAttemptNotification; + +extern llrp_u1_t +LLRP_ImpinjAntennaEventConfiguration_getEnableAntennaAttemptNotification ( + LLRP_tSImpinjAntennaEventConfiguration *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjAntennaEventConfiguration_setEnableAntennaAttemptNotification ( + LLRP_tSImpinjAntennaEventConfiguration *pThis, + llrp_u1_t Value); + + +extern LLRP_tSParameter * +LLRP_ImpinjAntennaEventConfiguration_beginCustom ( + LLRP_tSImpinjAntennaEventConfiguration *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjAntennaEventConfiguration_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjAntennaEventConfiguration_clearCustom ( + LLRP_tSImpinjAntennaEventConfiguration *pThis); + +extern int +LLRP_ImpinjAntennaEventConfiguration_countCustom ( + LLRP_tSImpinjAntennaEventConfiguration *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjAntennaEventConfiguration_addCustom ( + LLRP_tSImpinjAntennaEventConfiguration *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjAntennaAttemptEvent +{ + LLRP_tSParameter hdr; + + llrp_u16_t AntennaID; + + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjAntennaAttemptEvent; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjAntennaAttemptEvent[]; + +extern LLRP_tSImpinjAntennaAttemptEvent * +LLRP_ImpinjAntennaAttemptEvent_construct (void); + +extern void +LLRP_ImpinjAntennaAttemptEvent_destruct ( + LLRP_tSImpinjAntennaAttemptEvent * pThis); + +extern void +LLRP_ImpinjAntennaAttemptEvent_decodeFields ( + LLRP_tSImpinjAntennaAttemptEvent * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjAntennaAttemptEvent_assimilateSubParameters ( + LLRP_tSImpinjAntennaAttemptEvent * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjAntennaAttemptEvent_encode ( + const LLRP_tSImpinjAntennaAttemptEvent *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjAntennaAttemptEvent_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjAntennaAttemptEvent_AntennaID; + +extern llrp_u16_t +LLRP_ImpinjAntennaAttemptEvent_getAntennaID ( + LLRP_tSImpinjAntennaAttemptEvent *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjAntennaAttemptEvent_setAntennaID ( + LLRP_tSImpinjAntennaAttemptEvent *pThis, + llrp_u16_t Value); + + +extern LLRP_tSParameter * +LLRP_ImpinjAntennaAttemptEvent_beginCustom ( + LLRP_tSImpinjAntennaAttemptEvent *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjAntennaAttemptEvent_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjAntennaAttemptEvent_clearCustom ( + LLRP_tSImpinjAntennaAttemptEvent *pThis); + +extern int +LLRP_ImpinjAntennaAttemptEvent_countCustom ( + LLRP_tSImpinjAntennaAttemptEvent *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjAntennaAttemptEvent_addCustom ( + LLRP_tSImpinjAntennaAttemptEvent *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjHubConfiguration +{ + LLRP_tSParameter hdr; + + llrp_u16_t HubID; + + LLRP_tEImpinjHubConnectedType eConnected; + + LLRP_tEImpinjHubFaultType eFault; + + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjHubConfiguration; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjHubConfiguration[]; + +extern LLRP_tSImpinjHubConfiguration * +LLRP_ImpinjHubConfiguration_construct (void); + +extern void +LLRP_ImpinjHubConfiguration_destruct ( + LLRP_tSImpinjHubConfiguration * pThis); + +extern void +LLRP_ImpinjHubConfiguration_decodeFields ( + LLRP_tSImpinjHubConfiguration * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjHubConfiguration_assimilateSubParameters ( + LLRP_tSImpinjHubConfiguration * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjHubConfiguration_encode ( + const LLRP_tSImpinjHubConfiguration *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjHubConfiguration_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjHubConfiguration_HubID; + +extern llrp_u16_t +LLRP_ImpinjHubConfiguration_getHubID ( + LLRP_tSImpinjHubConfiguration *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjHubConfiguration_setHubID ( + LLRP_tSImpinjHubConfiguration *pThis, + llrp_u16_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjHubConfiguration_Connected; + +extern LLRP_tEImpinjHubConnectedType +LLRP_ImpinjHubConfiguration_getConnected ( + LLRP_tSImpinjHubConfiguration *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjHubConfiguration_setConnected ( + LLRP_tSImpinjHubConfiguration *pThis, + LLRP_tEImpinjHubConnectedType Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjHubConfiguration_Fault; + +extern LLRP_tEImpinjHubFaultType +LLRP_ImpinjHubConfiguration_getFault ( + LLRP_tSImpinjHubConfiguration *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjHubConfiguration_setFault ( + LLRP_tSImpinjHubConfiguration *pThis, + LLRP_tEImpinjHubFaultType Value); + + +extern LLRP_tSParameter * +LLRP_ImpinjHubConfiguration_beginCustom ( + LLRP_tSImpinjHubConfiguration *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjHubConfiguration_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjHubConfiguration_clearCustom ( + LLRP_tSImpinjHubConfiguration *pThis); + +extern int +LLRP_ImpinjHubConfiguration_countCustom ( + LLRP_tSImpinjHubConfiguration *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjHubConfiguration_addCustom ( + LLRP_tSImpinjHubConfiguration *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjDiagnosticReport +{ + LLRP_tSParameter hdr; + + llrp_u32v_t Metric; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjDiagnosticReport; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjDiagnosticReport[]; + +extern LLRP_tSImpinjDiagnosticReport * +LLRP_ImpinjDiagnosticReport_construct (void); + +extern void +LLRP_ImpinjDiagnosticReport_destruct ( + LLRP_tSImpinjDiagnosticReport * pThis); + +extern void +LLRP_ImpinjDiagnosticReport_decodeFields ( + LLRP_tSImpinjDiagnosticReport * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjDiagnosticReport_assimilateSubParameters ( + LLRP_tSImpinjDiagnosticReport * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjDiagnosticReport_encode ( + const LLRP_tSImpinjDiagnosticReport *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjDiagnosticReport_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjDiagnosticReport_Metric; + +extern llrp_u32v_t +LLRP_ImpinjDiagnosticReport_getMetric ( + LLRP_tSImpinjDiagnosticReport *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjDiagnosticReport_setMetric ( + LLRP_tSImpinjDiagnosticReport *pThis, + llrp_u32v_t Value); + + + + + +struct LLRP_SImpinjPlacementConfiguration +{ + LLRP_tSParameter hdr; + + llrp_u16_t HeightCm; + + llrp_s32_t FacilityXLocationCm; + + llrp_s32_t FacilityYLocationCm; + + llrp_s16_t OrientationDegrees; + + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjPlacementConfiguration; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjPlacementConfiguration[]; + +extern LLRP_tSImpinjPlacementConfiguration * +LLRP_ImpinjPlacementConfiguration_construct (void); + +extern void +LLRP_ImpinjPlacementConfiguration_destruct ( + LLRP_tSImpinjPlacementConfiguration * pThis); + +extern void +LLRP_ImpinjPlacementConfiguration_decodeFields ( + LLRP_tSImpinjPlacementConfiguration * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjPlacementConfiguration_assimilateSubParameters ( + LLRP_tSImpinjPlacementConfiguration * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjPlacementConfiguration_encode ( + const LLRP_tSImpinjPlacementConfiguration *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjPlacementConfiguration_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjPlacementConfiguration_HeightCm; + +extern llrp_u16_t +LLRP_ImpinjPlacementConfiguration_getHeightCm ( + LLRP_tSImpinjPlacementConfiguration *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjPlacementConfiguration_setHeightCm ( + LLRP_tSImpinjPlacementConfiguration *pThis, + llrp_u16_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjPlacementConfiguration_FacilityXLocationCm; + +extern llrp_s32_t +LLRP_ImpinjPlacementConfiguration_getFacilityXLocationCm ( + LLRP_tSImpinjPlacementConfiguration *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjPlacementConfiguration_setFacilityXLocationCm ( + LLRP_tSImpinjPlacementConfiguration *pThis, + llrp_s32_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjPlacementConfiguration_FacilityYLocationCm; + +extern llrp_s32_t +LLRP_ImpinjPlacementConfiguration_getFacilityYLocationCm ( + LLRP_tSImpinjPlacementConfiguration *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjPlacementConfiguration_setFacilityYLocationCm ( + LLRP_tSImpinjPlacementConfiguration *pThis, + llrp_s32_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjPlacementConfiguration_OrientationDegrees; + +extern llrp_s16_t +LLRP_ImpinjPlacementConfiguration_getOrientationDegrees ( + LLRP_tSImpinjPlacementConfiguration *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjPlacementConfiguration_setOrientationDegrees ( + LLRP_tSImpinjPlacementConfiguration *pThis, + llrp_s16_t Value); + + +extern LLRP_tSParameter * +LLRP_ImpinjPlacementConfiguration_beginCustom ( + LLRP_tSImpinjPlacementConfiguration *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjPlacementConfiguration_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjPlacementConfiguration_clearCustom ( + LLRP_tSImpinjPlacementConfiguration *pThis); + +extern int +LLRP_ImpinjPlacementConfiguration_countCustom ( + LLRP_tSImpinjPlacementConfiguration *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjPlacementConfiguration_addCustom ( + LLRP_tSImpinjPlacementConfiguration *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjLISpec +{ + LLRP_tSParameter hdr; + + + LLRP_tSImpinjLocationConfig * pImpinjLocationConfig; + + LLRP_tSImpinjC1G2LocationConfig * pImpinjC1G2LocationConfig; + + LLRP_tSImpinjLocationReporting * pImpinjLocationReporting; + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjLISpec; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjLISpec[]; + +extern LLRP_tSImpinjLISpec * +LLRP_ImpinjLISpec_construct (void); + +extern void +LLRP_ImpinjLISpec_destruct ( + LLRP_tSImpinjLISpec * pThis); + +extern void +LLRP_ImpinjLISpec_decodeFields ( + LLRP_tSImpinjLISpec * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjLISpec_assimilateSubParameters ( + LLRP_tSImpinjLISpec * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjLISpec_encode ( + const LLRP_tSImpinjLISpec *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjLISpec_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + + +extern LLRP_tSImpinjLocationConfig * +LLRP_ImpinjLISpec_getImpinjLocationConfig ( + LLRP_tSImpinjLISpec *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjLISpec_setImpinjLocationConfig ( + LLRP_tSImpinjLISpec *pThis, + LLRP_tSImpinjLocationConfig *pValue); + +extern LLRP_tSImpinjC1G2LocationConfig * +LLRP_ImpinjLISpec_getImpinjC1G2LocationConfig ( + LLRP_tSImpinjLISpec *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjLISpec_setImpinjC1G2LocationConfig ( + LLRP_tSImpinjLISpec *pThis, + LLRP_tSImpinjC1G2LocationConfig *pValue); + +extern LLRP_tSImpinjLocationReporting * +LLRP_ImpinjLISpec_getImpinjLocationReporting ( + LLRP_tSImpinjLISpec *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjLISpec_setImpinjLocationReporting ( + LLRP_tSImpinjLISpec *pThis, + LLRP_tSImpinjLocationReporting *pValue); + +extern LLRP_tSParameter * +LLRP_ImpinjLISpec_beginCustom ( + LLRP_tSImpinjLISpec *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjLISpec_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjLISpec_clearCustom ( + LLRP_tSImpinjLISpec *pThis); + +extern int +LLRP_ImpinjLISpec_countCustom ( + LLRP_tSImpinjLISpec *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjLISpec_addCustom ( + LLRP_tSImpinjLISpec *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjLocationConfig +{ + LLRP_tSParameter hdr; + + llrp_u16_t ComputeWindowSeconds; + + llrp_u16_t TagAgeIntervalSeconds; + + llrp_u16_t UpdateIntervalSeconds; + + + LLRP_tSImpinjDisabledAntennas * pImpinjDisabledAntennas; + + LLRP_tSImpinjLocationAlgorithmControl * pImpinjLocationAlgorithmControl; + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjLocationConfig; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjLocationConfig[]; + +extern LLRP_tSImpinjLocationConfig * +LLRP_ImpinjLocationConfig_construct (void); + +extern void +LLRP_ImpinjLocationConfig_destruct ( + LLRP_tSImpinjLocationConfig * pThis); + +extern void +LLRP_ImpinjLocationConfig_decodeFields ( + LLRP_tSImpinjLocationConfig * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjLocationConfig_assimilateSubParameters ( + LLRP_tSImpinjLocationConfig * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjLocationConfig_encode ( + const LLRP_tSImpinjLocationConfig *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjLocationConfig_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjLocationConfig_ComputeWindowSeconds; + +extern llrp_u16_t +LLRP_ImpinjLocationConfig_getComputeWindowSeconds ( + LLRP_tSImpinjLocationConfig *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjLocationConfig_setComputeWindowSeconds ( + LLRP_tSImpinjLocationConfig *pThis, + llrp_u16_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjLocationConfig_TagAgeIntervalSeconds; + +extern llrp_u16_t +LLRP_ImpinjLocationConfig_getTagAgeIntervalSeconds ( + LLRP_tSImpinjLocationConfig *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjLocationConfig_setTagAgeIntervalSeconds ( + LLRP_tSImpinjLocationConfig *pThis, + llrp_u16_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjLocationConfig_UpdateIntervalSeconds; + +extern llrp_u16_t +LLRP_ImpinjLocationConfig_getUpdateIntervalSeconds ( + LLRP_tSImpinjLocationConfig *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjLocationConfig_setUpdateIntervalSeconds ( + LLRP_tSImpinjLocationConfig *pThis, + llrp_u16_t Value); + + +extern LLRP_tSImpinjDisabledAntennas * +LLRP_ImpinjLocationConfig_getImpinjDisabledAntennas ( + LLRP_tSImpinjLocationConfig *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjLocationConfig_setImpinjDisabledAntennas ( + LLRP_tSImpinjLocationConfig *pThis, + LLRP_tSImpinjDisabledAntennas *pValue); + +extern LLRP_tSImpinjLocationAlgorithmControl * +LLRP_ImpinjLocationConfig_getImpinjLocationAlgorithmControl ( + LLRP_tSImpinjLocationConfig *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjLocationConfig_setImpinjLocationAlgorithmControl ( + LLRP_tSImpinjLocationConfig *pThis, + LLRP_tSImpinjLocationAlgorithmControl *pValue); + +extern LLRP_tSParameter * +LLRP_ImpinjLocationConfig_beginCustom ( + LLRP_tSImpinjLocationConfig *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjLocationConfig_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjLocationConfig_clearCustom ( + LLRP_tSImpinjLocationConfig *pThis); + +extern int +LLRP_ImpinjLocationConfig_countCustom ( + LLRP_tSImpinjLocationConfig *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjLocationConfig_addCustom ( + LLRP_tSImpinjLocationConfig *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjC1G2LocationConfig +{ + LLRP_tSParameter hdr; + + llrp_u16_t ModeIndex; + + llrp_u2_t Session; + + + LLRP_tSC1G2Filter * listC1G2Filter; + + LLRP_tSImpinjTransmitPower * pImpinjTransmitPower; + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjC1G2LocationConfig; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjC1G2LocationConfig[]; + +extern LLRP_tSImpinjC1G2LocationConfig * +LLRP_ImpinjC1G2LocationConfig_construct (void); + +extern void +LLRP_ImpinjC1G2LocationConfig_destruct ( + LLRP_tSImpinjC1G2LocationConfig * pThis); + +extern void +LLRP_ImpinjC1G2LocationConfig_decodeFields ( + LLRP_tSImpinjC1G2LocationConfig * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjC1G2LocationConfig_assimilateSubParameters ( + LLRP_tSImpinjC1G2LocationConfig * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjC1G2LocationConfig_encode ( + const LLRP_tSImpinjC1G2LocationConfig *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjC1G2LocationConfig_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjC1G2LocationConfig_ModeIndex; + +extern llrp_u16_t +LLRP_ImpinjC1G2LocationConfig_getModeIndex ( + LLRP_tSImpinjC1G2LocationConfig *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjC1G2LocationConfig_setModeIndex ( + LLRP_tSImpinjC1G2LocationConfig *pThis, + llrp_u16_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjC1G2LocationConfig_Session; + +extern llrp_u2_t +LLRP_ImpinjC1G2LocationConfig_getSession ( + LLRP_tSImpinjC1G2LocationConfig *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjC1G2LocationConfig_setSession ( + LLRP_tSImpinjC1G2LocationConfig *pThis, + llrp_u2_t Value); + + +extern LLRP_tSC1G2Filter * +LLRP_ImpinjC1G2LocationConfig_beginC1G2Filter ( + LLRP_tSImpinjC1G2LocationConfig *pThis); + +extern LLRP_tSC1G2Filter * +LLRP_ImpinjC1G2LocationConfig_nextC1G2Filter ( + LLRP_tSC1G2Filter *pCurrent); + +extern void +LLRP_ImpinjC1G2LocationConfig_clearC1G2Filter ( + LLRP_tSImpinjC1G2LocationConfig *pThis); + +extern int +LLRP_ImpinjC1G2LocationConfig_countC1G2Filter ( + LLRP_tSImpinjC1G2LocationConfig *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjC1G2LocationConfig_addC1G2Filter ( + LLRP_tSImpinjC1G2LocationConfig *pThis, + LLRP_tSC1G2Filter *pValue); + + +extern LLRP_tSImpinjTransmitPower * +LLRP_ImpinjC1G2LocationConfig_getImpinjTransmitPower ( + LLRP_tSImpinjC1G2LocationConfig *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjC1G2LocationConfig_setImpinjTransmitPower ( + LLRP_tSImpinjC1G2LocationConfig *pThis, + LLRP_tSImpinjTransmitPower *pValue); + +extern LLRP_tSParameter * +LLRP_ImpinjC1G2LocationConfig_beginCustom ( + LLRP_tSImpinjC1G2LocationConfig *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjC1G2LocationConfig_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjC1G2LocationConfig_clearCustom ( + LLRP_tSImpinjC1G2LocationConfig *pThis); + +extern int +LLRP_ImpinjC1G2LocationConfig_countCustom ( + LLRP_tSImpinjC1G2LocationConfig *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjC1G2LocationConfig_addCustom ( + LLRP_tSImpinjC1G2LocationConfig *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjLocationReporting +{ + LLRP_tSParameter hdr; + + llrp_u1_t EnableUpdateReport; + + llrp_u1_t EnableEntryReport; + + llrp_u1_t EnableExitReport; + + llrp_u1_t EnableDiagnosticReport; + + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjLocationReporting; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjLocationReporting[]; + +extern LLRP_tSImpinjLocationReporting * +LLRP_ImpinjLocationReporting_construct (void); + +extern void +LLRP_ImpinjLocationReporting_destruct ( + LLRP_tSImpinjLocationReporting * pThis); + +extern void +LLRP_ImpinjLocationReporting_decodeFields ( + LLRP_tSImpinjLocationReporting * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjLocationReporting_assimilateSubParameters ( + LLRP_tSImpinjLocationReporting * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjLocationReporting_encode ( + const LLRP_tSImpinjLocationReporting *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjLocationReporting_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjLocationReporting_EnableUpdateReport; + +extern llrp_u1_t +LLRP_ImpinjLocationReporting_getEnableUpdateReport ( + LLRP_tSImpinjLocationReporting *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjLocationReporting_setEnableUpdateReport ( + LLRP_tSImpinjLocationReporting *pThis, + llrp_u1_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjLocationReporting_EnableEntryReport; + +extern llrp_u1_t +LLRP_ImpinjLocationReporting_getEnableEntryReport ( + LLRP_tSImpinjLocationReporting *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjLocationReporting_setEnableEntryReport ( + LLRP_tSImpinjLocationReporting *pThis, + llrp_u1_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjLocationReporting_EnableExitReport; + +extern llrp_u1_t +LLRP_ImpinjLocationReporting_getEnableExitReport ( + LLRP_tSImpinjLocationReporting *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjLocationReporting_setEnableExitReport ( + LLRP_tSImpinjLocationReporting *pThis, + llrp_u1_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjLocationReporting_EnableDiagnosticReport; + +extern llrp_u1_t +LLRP_ImpinjLocationReporting_getEnableDiagnosticReport ( + LLRP_tSImpinjLocationReporting *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjLocationReporting_setEnableDiagnosticReport ( + LLRP_tSImpinjLocationReporting *pThis, + llrp_u1_t Value); + + +extern LLRP_tSParameter * +LLRP_ImpinjLocationReporting_beginCustom ( + LLRP_tSImpinjLocationReporting *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjLocationReporting_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjLocationReporting_clearCustom ( + LLRP_tSImpinjLocationReporting *pThis); + +extern int +LLRP_ImpinjLocationReporting_countCustom ( + LLRP_tSImpinjLocationReporting *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjLocationReporting_addCustom ( + LLRP_tSImpinjLocationReporting *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjLocationConfidence +{ + LLRP_tSParameter hdr; + + llrp_u16_t ReadCount; + + llrp_u32v_t ConfidenceData; + + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjLocationConfidence; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjLocationConfidence[]; + +extern LLRP_tSImpinjLocationConfidence * +LLRP_ImpinjLocationConfidence_construct (void); + +extern void +LLRP_ImpinjLocationConfidence_destruct ( + LLRP_tSImpinjLocationConfidence * pThis); + +extern void +LLRP_ImpinjLocationConfidence_decodeFields ( + LLRP_tSImpinjLocationConfidence * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjLocationConfidence_assimilateSubParameters ( + LLRP_tSImpinjLocationConfidence * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjLocationConfidence_encode ( + const LLRP_tSImpinjLocationConfidence *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjLocationConfidence_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjLocationConfidence_ReadCount; + +extern llrp_u16_t +LLRP_ImpinjLocationConfidence_getReadCount ( + LLRP_tSImpinjLocationConfidence *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjLocationConfidence_setReadCount ( + LLRP_tSImpinjLocationConfidence *pThis, + llrp_u16_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjLocationConfidence_ConfidenceData; + +extern llrp_u32v_t +LLRP_ImpinjLocationConfidence_getConfidenceData ( + LLRP_tSImpinjLocationConfidence *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjLocationConfidence_setConfidenceData ( + LLRP_tSImpinjLocationConfidence *pThis, + llrp_u32v_t Value); + + +extern LLRP_tSParameter * +LLRP_ImpinjLocationConfidence_beginCustom ( + LLRP_tSImpinjLocationConfidence *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjLocationConfidence_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjLocationConfidence_clearCustom ( + LLRP_tSImpinjLocationConfidence *pThis); + +extern int +LLRP_ImpinjLocationConfidence_countCustom ( + LLRP_tSImpinjLocationConfidence *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjLocationConfidence_addCustom ( + LLRP_tSImpinjLocationConfidence *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjLocationReportData +{ + LLRP_tSParameter hdr; + + llrp_u64_t LastSeenTimestampUTC; + + llrp_s32_t LocXCentimeters; + + llrp_s32_t LocYCentimeters; + + LLRP_tEImpinjLocationReportType eType; + + + LLRP_tSImpinjLocationConfidence * pImpinjLocationConfidence; + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjLocationReportData; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjLocationReportData[]; + +extern LLRP_tSImpinjLocationReportData * +LLRP_ImpinjLocationReportData_construct (void); + +extern void +LLRP_ImpinjLocationReportData_destruct ( + LLRP_tSImpinjLocationReportData * pThis); + +extern void +LLRP_ImpinjLocationReportData_decodeFields ( + LLRP_tSImpinjLocationReportData * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjLocationReportData_assimilateSubParameters ( + LLRP_tSImpinjLocationReportData * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjLocationReportData_encode ( + const LLRP_tSImpinjLocationReportData *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjLocationReportData_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjLocationReportData_LastSeenTimestampUTC; + +extern llrp_u64_t +LLRP_ImpinjLocationReportData_getLastSeenTimestampUTC ( + LLRP_tSImpinjLocationReportData *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjLocationReportData_setLastSeenTimestampUTC ( + LLRP_tSImpinjLocationReportData *pThis, + llrp_u64_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjLocationReportData_LocXCentimeters; + +extern llrp_s32_t +LLRP_ImpinjLocationReportData_getLocXCentimeters ( + LLRP_tSImpinjLocationReportData *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjLocationReportData_setLocXCentimeters ( + LLRP_tSImpinjLocationReportData *pThis, + llrp_s32_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjLocationReportData_LocYCentimeters; + +extern llrp_s32_t +LLRP_ImpinjLocationReportData_getLocYCentimeters ( + LLRP_tSImpinjLocationReportData *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjLocationReportData_setLocYCentimeters ( + LLRP_tSImpinjLocationReportData *pThis, + llrp_s32_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjLocationReportData_Type; + +extern LLRP_tEImpinjLocationReportType +LLRP_ImpinjLocationReportData_getType ( + LLRP_tSImpinjLocationReportData *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjLocationReportData_setType ( + LLRP_tSImpinjLocationReportData *pThis, + LLRP_tEImpinjLocationReportType Value); + + +extern LLRP_tSImpinjLocationConfidence * +LLRP_ImpinjLocationReportData_getImpinjLocationConfidence ( + LLRP_tSImpinjLocationReportData *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjLocationReportData_setImpinjLocationConfidence ( + LLRP_tSImpinjLocationReportData *pThis, + LLRP_tSImpinjLocationConfidence *pValue); + +extern LLRP_tSParameter * +LLRP_ImpinjLocationReportData_beginCustom ( + LLRP_tSImpinjLocationReportData *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjLocationReportData_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjLocationReportData_clearCustom ( + LLRP_tSImpinjLocationReportData *pThis); + +extern int +LLRP_ImpinjLocationReportData_countCustom ( + LLRP_tSImpinjLocationReportData *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjLocationReportData_addCustom ( + LLRP_tSImpinjLocationReportData *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjDISpec +{ + LLRP_tSParameter hdr; + + + LLRP_tSImpinjDirectionSectors * pImpinjDirectionSectors; + + LLRP_tSImpinjDirectionConfig * pImpinjDirectionConfig; + + LLRP_tSImpinjC1G2DirectionConfig * pImpinjC1G2DirectionConfig; + + LLRP_tSImpinjDirectionReporting * pImpinjDirectionReporting; + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjDISpec; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjDISpec[]; + +extern LLRP_tSImpinjDISpec * +LLRP_ImpinjDISpec_construct (void); + +extern void +LLRP_ImpinjDISpec_destruct ( + LLRP_tSImpinjDISpec * pThis); + +extern void +LLRP_ImpinjDISpec_decodeFields ( + LLRP_tSImpinjDISpec * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjDISpec_assimilateSubParameters ( + LLRP_tSImpinjDISpec * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjDISpec_encode ( + const LLRP_tSImpinjDISpec *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjDISpec_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + + +extern LLRP_tSImpinjDirectionSectors * +LLRP_ImpinjDISpec_getImpinjDirectionSectors ( + LLRP_tSImpinjDISpec *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjDISpec_setImpinjDirectionSectors ( + LLRP_tSImpinjDISpec *pThis, + LLRP_tSImpinjDirectionSectors *pValue); + +extern LLRP_tSImpinjDirectionConfig * +LLRP_ImpinjDISpec_getImpinjDirectionConfig ( + LLRP_tSImpinjDISpec *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjDISpec_setImpinjDirectionConfig ( + LLRP_tSImpinjDISpec *pThis, + LLRP_tSImpinjDirectionConfig *pValue); + +extern LLRP_tSImpinjC1G2DirectionConfig * +LLRP_ImpinjDISpec_getImpinjC1G2DirectionConfig ( + LLRP_tSImpinjDISpec *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjDISpec_setImpinjC1G2DirectionConfig ( + LLRP_tSImpinjDISpec *pThis, + LLRP_tSImpinjC1G2DirectionConfig *pValue); + +extern LLRP_tSImpinjDirectionReporting * +LLRP_ImpinjDISpec_getImpinjDirectionReporting ( + LLRP_tSImpinjDISpec *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjDISpec_setImpinjDirectionReporting ( + LLRP_tSImpinjDISpec *pThis, + LLRP_tSImpinjDirectionReporting *pValue); + +extern LLRP_tSParameter * +LLRP_ImpinjDISpec_beginCustom ( + LLRP_tSImpinjDISpec *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjDISpec_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjDISpec_clearCustom ( + LLRP_tSImpinjDISpec *pThis); + +extern int +LLRP_ImpinjDISpec_countCustom ( + LLRP_tSImpinjDISpec *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjDISpec_addCustom ( + LLRP_tSImpinjDISpec *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjDirectionSectors +{ + LLRP_tSParameter hdr; + + llrp_u16v_t EnabledSectorIDs; + + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjDirectionSectors; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjDirectionSectors[]; + +extern LLRP_tSImpinjDirectionSectors * +LLRP_ImpinjDirectionSectors_construct (void); + +extern void +LLRP_ImpinjDirectionSectors_destruct ( + LLRP_tSImpinjDirectionSectors * pThis); + +extern void +LLRP_ImpinjDirectionSectors_decodeFields ( + LLRP_tSImpinjDirectionSectors * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjDirectionSectors_assimilateSubParameters ( + LLRP_tSImpinjDirectionSectors * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjDirectionSectors_encode ( + const LLRP_tSImpinjDirectionSectors *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjDirectionSectors_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjDirectionSectors_EnabledSectorIDs; + +extern llrp_u16v_t +LLRP_ImpinjDirectionSectors_getEnabledSectorIDs ( + LLRP_tSImpinjDirectionSectors *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjDirectionSectors_setEnabledSectorIDs ( + LLRP_tSImpinjDirectionSectors *pThis, + llrp_u16v_t Value); + + +extern LLRP_tSParameter * +LLRP_ImpinjDirectionSectors_beginCustom ( + LLRP_tSImpinjDirectionSectors *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjDirectionSectors_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjDirectionSectors_clearCustom ( + LLRP_tSImpinjDirectionSectors *pThis); + +extern int +LLRP_ImpinjDirectionSectors_countCustom ( + LLRP_tSImpinjDirectionSectors *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjDirectionSectors_addCustom ( + LLRP_tSImpinjDirectionSectors *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjDirectionConfig +{ + LLRP_tSParameter hdr; + + llrp_u16_t TagAgeIntervalSeconds; + + llrp_u16_t UpdateIntervalSeconds; + + LLRP_tEImpinjDirectionFieldOfView eFieldOfView; + + + LLRP_tSImpinjDirectionUserTagPopulationLimit * pImpinjDirectionUserTagPopulationLimit; + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjDirectionConfig; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjDirectionConfig[]; + +extern LLRP_tSImpinjDirectionConfig * +LLRP_ImpinjDirectionConfig_construct (void); + +extern void +LLRP_ImpinjDirectionConfig_destruct ( + LLRP_tSImpinjDirectionConfig * pThis); + +extern void +LLRP_ImpinjDirectionConfig_decodeFields ( + LLRP_tSImpinjDirectionConfig * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjDirectionConfig_assimilateSubParameters ( + LLRP_tSImpinjDirectionConfig * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjDirectionConfig_encode ( + const LLRP_tSImpinjDirectionConfig *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjDirectionConfig_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjDirectionConfig_TagAgeIntervalSeconds; + +extern llrp_u16_t +LLRP_ImpinjDirectionConfig_getTagAgeIntervalSeconds ( + LLRP_tSImpinjDirectionConfig *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjDirectionConfig_setTagAgeIntervalSeconds ( + LLRP_tSImpinjDirectionConfig *pThis, + llrp_u16_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjDirectionConfig_UpdateIntervalSeconds; + +extern llrp_u16_t +LLRP_ImpinjDirectionConfig_getUpdateIntervalSeconds ( + LLRP_tSImpinjDirectionConfig *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjDirectionConfig_setUpdateIntervalSeconds ( + LLRP_tSImpinjDirectionConfig *pThis, + llrp_u16_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjDirectionConfig_FieldOfView; + +extern LLRP_tEImpinjDirectionFieldOfView +LLRP_ImpinjDirectionConfig_getFieldOfView ( + LLRP_tSImpinjDirectionConfig *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjDirectionConfig_setFieldOfView ( + LLRP_tSImpinjDirectionConfig *pThis, + LLRP_tEImpinjDirectionFieldOfView Value); + + +extern LLRP_tSImpinjDirectionUserTagPopulationLimit * +LLRP_ImpinjDirectionConfig_getImpinjDirectionUserTagPopulationLimit ( + LLRP_tSImpinjDirectionConfig *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjDirectionConfig_setImpinjDirectionUserTagPopulationLimit ( + LLRP_tSImpinjDirectionConfig *pThis, + LLRP_tSImpinjDirectionUserTagPopulationLimit *pValue); + +extern LLRP_tSParameter * +LLRP_ImpinjDirectionConfig_beginCustom ( + LLRP_tSImpinjDirectionConfig *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjDirectionConfig_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjDirectionConfig_clearCustom ( + LLRP_tSImpinjDirectionConfig *pThis); + +extern int +LLRP_ImpinjDirectionConfig_countCustom ( + LLRP_tSImpinjDirectionConfig *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjDirectionConfig_addCustom ( + LLRP_tSImpinjDirectionConfig *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjDirectionUserTagPopulationLimit +{ + LLRP_tSParameter hdr; + + llrp_u16_t UserTagPopulationLimit; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjDirectionUserTagPopulationLimit; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjDirectionUserTagPopulationLimit[]; + +extern LLRP_tSImpinjDirectionUserTagPopulationLimit * +LLRP_ImpinjDirectionUserTagPopulationLimit_construct (void); + +extern void +LLRP_ImpinjDirectionUserTagPopulationLimit_destruct ( + LLRP_tSImpinjDirectionUserTagPopulationLimit * pThis); + +extern void +LLRP_ImpinjDirectionUserTagPopulationLimit_decodeFields ( + LLRP_tSImpinjDirectionUserTagPopulationLimit * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjDirectionUserTagPopulationLimit_assimilateSubParameters ( + LLRP_tSImpinjDirectionUserTagPopulationLimit * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjDirectionUserTagPopulationLimit_encode ( + const LLRP_tSImpinjDirectionUserTagPopulationLimit *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjDirectionUserTagPopulationLimit_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjDirectionUserTagPopulationLimit_UserTagPopulationLimit; + +extern llrp_u16_t +LLRP_ImpinjDirectionUserTagPopulationLimit_getUserTagPopulationLimit ( + LLRP_tSImpinjDirectionUserTagPopulationLimit *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjDirectionUserTagPopulationLimit_setUserTagPopulationLimit ( + LLRP_tSImpinjDirectionUserTagPopulationLimit *pThis, + llrp_u16_t Value); + + + + + +struct LLRP_SImpinjC1G2DirectionConfig +{ + LLRP_tSParameter hdr; + + LLRP_tEImpinjDirectionRFMode eRFMode; + + + LLRP_tSImpinjTransmitPower * pImpinjTransmitPower; + + LLRP_tSC1G2Filter * listC1G2Filter; + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjC1G2DirectionConfig; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjC1G2DirectionConfig[]; + +extern LLRP_tSImpinjC1G2DirectionConfig * +LLRP_ImpinjC1G2DirectionConfig_construct (void); + +extern void +LLRP_ImpinjC1G2DirectionConfig_destruct ( + LLRP_tSImpinjC1G2DirectionConfig * pThis); + +extern void +LLRP_ImpinjC1G2DirectionConfig_decodeFields ( + LLRP_tSImpinjC1G2DirectionConfig * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjC1G2DirectionConfig_assimilateSubParameters ( + LLRP_tSImpinjC1G2DirectionConfig * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjC1G2DirectionConfig_encode ( + const LLRP_tSImpinjC1G2DirectionConfig *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjC1G2DirectionConfig_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjC1G2DirectionConfig_RFMode; + +extern LLRP_tEImpinjDirectionRFMode +LLRP_ImpinjC1G2DirectionConfig_getRFMode ( + LLRP_tSImpinjC1G2DirectionConfig *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjC1G2DirectionConfig_setRFMode ( + LLRP_tSImpinjC1G2DirectionConfig *pThis, + LLRP_tEImpinjDirectionRFMode Value); + + +extern LLRP_tSImpinjTransmitPower * +LLRP_ImpinjC1G2DirectionConfig_getImpinjTransmitPower ( + LLRP_tSImpinjC1G2DirectionConfig *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjC1G2DirectionConfig_setImpinjTransmitPower ( + LLRP_tSImpinjC1G2DirectionConfig *pThis, + LLRP_tSImpinjTransmitPower *pValue); + +extern LLRP_tSC1G2Filter * +LLRP_ImpinjC1G2DirectionConfig_beginC1G2Filter ( + LLRP_tSImpinjC1G2DirectionConfig *pThis); + +extern LLRP_tSC1G2Filter * +LLRP_ImpinjC1G2DirectionConfig_nextC1G2Filter ( + LLRP_tSC1G2Filter *pCurrent); + +extern void +LLRP_ImpinjC1G2DirectionConfig_clearC1G2Filter ( + LLRP_tSImpinjC1G2DirectionConfig *pThis); + +extern int +LLRP_ImpinjC1G2DirectionConfig_countC1G2Filter ( + LLRP_tSImpinjC1G2DirectionConfig *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjC1G2DirectionConfig_addC1G2Filter ( + LLRP_tSImpinjC1G2DirectionConfig *pThis, + LLRP_tSC1G2Filter *pValue); + + +extern LLRP_tSParameter * +LLRP_ImpinjC1G2DirectionConfig_beginCustom ( + LLRP_tSImpinjC1G2DirectionConfig *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjC1G2DirectionConfig_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjC1G2DirectionConfig_clearCustom ( + LLRP_tSImpinjC1G2DirectionConfig *pThis); + +extern int +LLRP_ImpinjC1G2DirectionConfig_countCustom ( + LLRP_tSImpinjC1G2DirectionConfig *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjC1G2DirectionConfig_addCustom ( + LLRP_tSImpinjC1G2DirectionConfig *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjExtendedTagInformation +{ + LLRP_tSParameter hdr; + + + LLRP_tSEPCData * listEPCData; + + LLRP_tSImpinjLocationReportData * pImpinjLocationReportData; + + LLRP_tSImpinjDirectionReportData * pImpinjDirectionReportData; + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjExtendedTagInformation; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjExtendedTagInformation[]; + +extern LLRP_tSImpinjExtendedTagInformation * +LLRP_ImpinjExtendedTagInformation_construct (void); + +extern void +LLRP_ImpinjExtendedTagInformation_destruct ( + LLRP_tSImpinjExtendedTagInformation * pThis); + +extern void +LLRP_ImpinjExtendedTagInformation_decodeFields ( + LLRP_tSImpinjExtendedTagInformation * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjExtendedTagInformation_assimilateSubParameters ( + LLRP_tSImpinjExtendedTagInformation * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjExtendedTagInformation_encode ( + const LLRP_tSImpinjExtendedTagInformation *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjExtendedTagInformation_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + + +extern LLRP_tSEPCData * +LLRP_ImpinjExtendedTagInformation_beginEPCData ( + LLRP_tSImpinjExtendedTagInformation *pThis); + +extern LLRP_tSEPCData * +LLRP_ImpinjExtendedTagInformation_nextEPCData ( + LLRP_tSEPCData *pCurrent); + +extern void +LLRP_ImpinjExtendedTagInformation_clearEPCData ( + LLRP_tSImpinjExtendedTagInformation *pThis); + +extern int +LLRP_ImpinjExtendedTagInformation_countEPCData ( + LLRP_tSImpinjExtendedTagInformation *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjExtendedTagInformation_addEPCData ( + LLRP_tSImpinjExtendedTagInformation *pThis, + LLRP_tSEPCData *pValue); + + +extern LLRP_tSImpinjLocationReportData * +LLRP_ImpinjExtendedTagInformation_getImpinjLocationReportData ( + LLRP_tSImpinjExtendedTagInformation *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjExtendedTagInformation_setImpinjLocationReportData ( + LLRP_tSImpinjExtendedTagInformation *pThis, + LLRP_tSImpinjLocationReportData *pValue); + +extern LLRP_tSImpinjDirectionReportData * +LLRP_ImpinjExtendedTagInformation_getImpinjDirectionReportData ( + LLRP_tSImpinjExtendedTagInformation *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjExtendedTagInformation_setImpinjDirectionReportData ( + LLRP_tSImpinjExtendedTagInformation *pThis, + LLRP_tSImpinjDirectionReportData *pValue); + +extern LLRP_tSParameter * +LLRP_ImpinjExtendedTagInformation_beginCustom ( + LLRP_tSImpinjExtendedTagInformation *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjExtendedTagInformation_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjExtendedTagInformation_clearCustom ( + LLRP_tSImpinjExtendedTagInformation *pThis); + +extern int +LLRP_ImpinjExtendedTagInformation_countCustom ( + LLRP_tSImpinjExtendedTagInformation *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjExtendedTagInformation_addCustom ( + LLRP_tSImpinjExtendedTagInformation *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjDirectionReporting +{ + LLRP_tSParameter hdr; + + llrp_u1_t EnableUpdateReport; + + llrp_u1_t EnableEntryReport; + + llrp_u1_t EnableExitReport; + + llrp_u1_t EnableDiagnosticReport; + + LLRP_tEImpinjDirectionDiagnosticReportLevel eDiagnosticReportLevel; + + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjDirectionReporting; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjDirectionReporting[]; + +extern LLRP_tSImpinjDirectionReporting * +LLRP_ImpinjDirectionReporting_construct (void); + +extern void +LLRP_ImpinjDirectionReporting_destruct ( + LLRP_tSImpinjDirectionReporting * pThis); + +extern void +LLRP_ImpinjDirectionReporting_decodeFields ( + LLRP_tSImpinjDirectionReporting * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjDirectionReporting_assimilateSubParameters ( + LLRP_tSImpinjDirectionReporting * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjDirectionReporting_encode ( + const LLRP_tSImpinjDirectionReporting *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjDirectionReporting_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjDirectionReporting_EnableUpdateReport; + +extern llrp_u1_t +LLRP_ImpinjDirectionReporting_getEnableUpdateReport ( + LLRP_tSImpinjDirectionReporting *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjDirectionReporting_setEnableUpdateReport ( + LLRP_tSImpinjDirectionReporting *pThis, + llrp_u1_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjDirectionReporting_EnableEntryReport; + +extern llrp_u1_t +LLRP_ImpinjDirectionReporting_getEnableEntryReport ( + LLRP_tSImpinjDirectionReporting *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjDirectionReporting_setEnableEntryReport ( + LLRP_tSImpinjDirectionReporting *pThis, + llrp_u1_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjDirectionReporting_EnableExitReport; + +extern llrp_u1_t +LLRP_ImpinjDirectionReporting_getEnableExitReport ( + LLRP_tSImpinjDirectionReporting *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjDirectionReporting_setEnableExitReport ( + LLRP_tSImpinjDirectionReporting *pThis, + llrp_u1_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjDirectionReporting_EnableDiagnosticReport; + +extern llrp_u1_t +LLRP_ImpinjDirectionReporting_getEnableDiagnosticReport ( + LLRP_tSImpinjDirectionReporting *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjDirectionReporting_setEnableDiagnosticReport ( + LLRP_tSImpinjDirectionReporting *pThis, + llrp_u1_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjDirectionReporting_DiagnosticReportLevel; + +extern LLRP_tEImpinjDirectionDiagnosticReportLevel +LLRP_ImpinjDirectionReporting_getDiagnosticReportLevel ( + LLRP_tSImpinjDirectionReporting *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjDirectionReporting_setDiagnosticReportLevel ( + LLRP_tSImpinjDirectionReporting *pThis, + LLRP_tEImpinjDirectionDiagnosticReportLevel Value); + + +extern LLRP_tSParameter * +LLRP_ImpinjDirectionReporting_beginCustom ( + LLRP_tSImpinjDirectionReporting *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjDirectionReporting_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjDirectionReporting_clearCustom ( + LLRP_tSImpinjDirectionReporting *pThis); + +extern int +LLRP_ImpinjDirectionReporting_countCustom ( + LLRP_tSImpinjDirectionReporting *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjDirectionReporting_addCustom ( + LLRP_tSImpinjDirectionReporting *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjDirectionReportData +{ + LLRP_tSParameter hdr; + + LLRP_tEImpinjDirectionReportType eType; + + LLRP_tEImpinjDirectionTagPopulationStatus eTagPopulationStatus; + + llrp_u8_t FirstSeenSectorID; + + llrp_u64_t FirstSeenTimestampUTC; + + llrp_u8_t LastSeenSectorID; + + llrp_u64_t LastSeenTimestampUTC; + + + LLRP_tSImpinjDirectionDiagnosticData * pImpinjDirectionDiagnosticData; + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjDirectionReportData; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjDirectionReportData[]; + +extern LLRP_tSImpinjDirectionReportData * +LLRP_ImpinjDirectionReportData_construct (void); + +extern void +LLRP_ImpinjDirectionReportData_destruct ( + LLRP_tSImpinjDirectionReportData * pThis); + +extern void +LLRP_ImpinjDirectionReportData_decodeFields ( + LLRP_tSImpinjDirectionReportData * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjDirectionReportData_assimilateSubParameters ( + LLRP_tSImpinjDirectionReportData * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjDirectionReportData_encode ( + const LLRP_tSImpinjDirectionReportData *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjDirectionReportData_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjDirectionReportData_Type; + +extern LLRP_tEImpinjDirectionReportType +LLRP_ImpinjDirectionReportData_getType ( + LLRP_tSImpinjDirectionReportData *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjDirectionReportData_setType ( + LLRP_tSImpinjDirectionReportData *pThis, + LLRP_tEImpinjDirectionReportType Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjDirectionReportData_TagPopulationStatus; + +extern LLRP_tEImpinjDirectionTagPopulationStatus +LLRP_ImpinjDirectionReportData_getTagPopulationStatus ( + LLRP_tSImpinjDirectionReportData *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjDirectionReportData_setTagPopulationStatus ( + LLRP_tSImpinjDirectionReportData *pThis, + LLRP_tEImpinjDirectionTagPopulationStatus Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjDirectionReportData_FirstSeenSectorID; + +extern llrp_u8_t +LLRP_ImpinjDirectionReportData_getFirstSeenSectorID ( + LLRP_tSImpinjDirectionReportData *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjDirectionReportData_setFirstSeenSectorID ( + LLRP_tSImpinjDirectionReportData *pThis, + llrp_u8_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjDirectionReportData_FirstSeenTimestampUTC; + +extern llrp_u64_t +LLRP_ImpinjDirectionReportData_getFirstSeenTimestampUTC ( + LLRP_tSImpinjDirectionReportData *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjDirectionReportData_setFirstSeenTimestampUTC ( + LLRP_tSImpinjDirectionReportData *pThis, + llrp_u64_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjDirectionReportData_LastSeenSectorID; + +extern llrp_u8_t +LLRP_ImpinjDirectionReportData_getLastSeenSectorID ( + LLRP_tSImpinjDirectionReportData *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjDirectionReportData_setLastSeenSectorID ( + LLRP_tSImpinjDirectionReportData *pThis, + llrp_u8_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjDirectionReportData_LastSeenTimestampUTC; + +extern llrp_u64_t +LLRP_ImpinjDirectionReportData_getLastSeenTimestampUTC ( + LLRP_tSImpinjDirectionReportData *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjDirectionReportData_setLastSeenTimestampUTC ( + LLRP_tSImpinjDirectionReportData *pThis, + llrp_u64_t Value); + + +extern LLRP_tSImpinjDirectionDiagnosticData * +LLRP_ImpinjDirectionReportData_getImpinjDirectionDiagnosticData ( + LLRP_tSImpinjDirectionReportData *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjDirectionReportData_setImpinjDirectionDiagnosticData ( + LLRP_tSImpinjDirectionReportData *pThis, + LLRP_tSImpinjDirectionDiagnosticData *pValue); + +extern LLRP_tSParameter * +LLRP_ImpinjDirectionReportData_beginCustom ( + LLRP_tSImpinjDirectionReportData *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjDirectionReportData_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjDirectionReportData_clearCustom ( + LLRP_tSImpinjDirectionReportData *pThis); + +extern int +LLRP_ImpinjDirectionReportData_countCustom ( + LLRP_tSImpinjDirectionReportData *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjDirectionReportData_addCustom ( + LLRP_tSImpinjDirectionReportData *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjDirectionDiagnosticData +{ + LLRP_tSParameter hdr; + + llrp_u32v_t Metric; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjDirectionDiagnosticData; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjDirectionDiagnosticData[]; + +extern LLRP_tSImpinjDirectionDiagnosticData * +LLRP_ImpinjDirectionDiagnosticData_construct (void); + +extern void +LLRP_ImpinjDirectionDiagnosticData_destruct ( + LLRP_tSImpinjDirectionDiagnosticData * pThis); + +extern void +LLRP_ImpinjDirectionDiagnosticData_decodeFields ( + LLRP_tSImpinjDirectionDiagnosticData * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjDirectionDiagnosticData_assimilateSubParameters ( + LLRP_tSImpinjDirectionDiagnosticData * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjDirectionDiagnosticData_encode ( + const LLRP_tSImpinjDirectionDiagnosticData *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjDirectionDiagnosticData_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjDirectionDiagnosticData_Metric; + +extern llrp_u32v_t +LLRP_ImpinjDirectionDiagnosticData_getMetric ( + LLRP_tSImpinjDirectionDiagnosticData *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjDirectionDiagnosticData_setMetric ( + LLRP_tSImpinjDirectionDiagnosticData *pThis, + llrp_u32v_t Value); + + + + + +struct LLRP_SImpinjxArrayDirectionCapabilities +{ + LLRP_tSParameter hdr; + + llrp_u16_t SystemTagPopulationLimitHighSensitivity; + + llrp_u16_t SystemTagPopulationLimitHighPerformance; + + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjxArrayDirectionCapabilities; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjxArrayDirectionCapabilities[]; + +extern LLRP_tSImpinjxArrayDirectionCapabilities * +LLRP_ImpinjxArrayDirectionCapabilities_construct (void); + +extern void +LLRP_ImpinjxArrayDirectionCapabilities_destruct ( + LLRP_tSImpinjxArrayDirectionCapabilities * pThis); + +extern void +LLRP_ImpinjxArrayDirectionCapabilities_decodeFields ( + LLRP_tSImpinjxArrayDirectionCapabilities * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjxArrayDirectionCapabilities_assimilateSubParameters ( + LLRP_tSImpinjxArrayDirectionCapabilities * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjxArrayDirectionCapabilities_encode ( + const LLRP_tSImpinjxArrayDirectionCapabilities *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjxArrayDirectionCapabilities_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjxArrayDirectionCapabilities_SystemTagPopulationLimitHighSensitivity; + +extern llrp_u16_t +LLRP_ImpinjxArrayDirectionCapabilities_getSystemTagPopulationLimitHighSensitivity ( + LLRP_tSImpinjxArrayDirectionCapabilities *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjxArrayDirectionCapabilities_setSystemTagPopulationLimitHighSensitivity ( + LLRP_tSImpinjxArrayDirectionCapabilities *pThis, + llrp_u16_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjxArrayDirectionCapabilities_SystemTagPopulationLimitHighPerformance; + +extern llrp_u16_t +LLRP_ImpinjxArrayDirectionCapabilities_getSystemTagPopulationLimitHighPerformance ( + LLRP_tSImpinjxArrayDirectionCapabilities *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjxArrayDirectionCapabilities_setSystemTagPopulationLimitHighPerformance ( + LLRP_tSImpinjxArrayDirectionCapabilities *pThis, + llrp_u16_t Value); + + +extern LLRP_tSParameter * +LLRP_ImpinjxArrayDirectionCapabilities_beginCustom ( + LLRP_tSImpinjxArrayDirectionCapabilities *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjxArrayDirectionCapabilities_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjxArrayDirectionCapabilities_clearCustom ( + LLRP_tSImpinjxArrayDirectionCapabilities *pThis); + +extern int +LLRP_ImpinjxArrayDirectionCapabilities_countCustom ( + LLRP_tSImpinjxArrayDirectionCapabilities *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjxArrayDirectionCapabilities_addCustom ( + LLRP_tSImpinjxArrayDirectionCapabilities *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjIntelligentAntennaManagement +{ + LLRP_tSParameter hdr; + + LLRP_tEImpinjIntelligentAntennaMode eManagementEnabled; + + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjIntelligentAntennaManagement; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjIntelligentAntennaManagement[]; + +extern LLRP_tSImpinjIntelligentAntennaManagement * +LLRP_ImpinjIntelligentAntennaManagement_construct (void); + +extern void +LLRP_ImpinjIntelligentAntennaManagement_destruct ( + LLRP_tSImpinjIntelligentAntennaManagement * pThis); + +extern void +LLRP_ImpinjIntelligentAntennaManagement_decodeFields ( + LLRP_tSImpinjIntelligentAntennaManagement * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjIntelligentAntennaManagement_assimilateSubParameters ( + LLRP_tSImpinjIntelligentAntennaManagement * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjIntelligentAntennaManagement_encode ( + const LLRP_tSImpinjIntelligentAntennaManagement *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjIntelligentAntennaManagement_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjIntelligentAntennaManagement_ManagementEnabled; + +extern LLRP_tEImpinjIntelligentAntennaMode +LLRP_ImpinjIntelligentAntennaManagement_getManagementEnabled ( + LLRP_tSImpinjIntelligentAntennaManagement *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjIntelligentAntennaManagement_setManagementEnabled ( + LLRP_tSImpinjIntelligentAntennaManagement *pThis, + LLRP_tEImpinjIntelligentAntennaMode Value); + + +extern LLRP_tSParameter * +LLRP_ImpinjIntelligentAntennaManagement_beginCustom ( + LLRP_tSImpinjIntelligentAntennaManagement *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjIntelligentAntennaManagement_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjIntelligentAntennaManagement_clearCustom ( + LLRP_tSImpinjIntelligentAntennaManagement *pThis); + +extern int +LLRP_ImpinjIntelligentAntennaManagement_countCustom ( + LLRP_tSImpinjIntelligentAntennaManagement *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjIntelligentAntennaManagement_addCustom ( + LLRP_tSImpinjIntelligentAntennaManagement *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjTransmitPower +{ + LLRP_tSParameter hdr; + + llrp_u16_t TransmitPower; + + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjTransmitPower; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjTransmitPower[]; + +extern LLRP_tSImpinjTransmitPower * +LLRP_ImpinjTransmitPower_construct (void); + +extern void +LLRP_ImpinjTransmitPower_destruct ( + LLRP_tSImpinjTransmitPower * pThis); + +extern void +LLRP_ImpinjTransmitPower_decodeFields ( + LLRP_tSImpinjTransmitPower * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjTransmitPower_assimilateSubParameters ( + LLRP_tSImpinjTransmitPower * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjTransmitPower_encode ( + const LLRP_tSImpinjTransmitPower *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjTransmitPower_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjTransmitPower_TransmitPower; + +extern llrp_u16_t +LLRP_ImpinjTransmitPower_getTransmitPower ( + LLRP_tSImpinjTransmitPower *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjTransmitPower_setTransmitPower ( + LLRP_tSImpinjTransmitPower *pThis, + llrp_u16_t Value); + + +extern LLRP_tSParameter * +LLRP_ImpinjTransmitPower_beginCustom ( + LLRP_tSImpinjTransmitPower *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjTransmitPower_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjTransmitPower_clearCustom ( + LLRP_tSImpinjTransmitPower *pThis); + +extern int +LLRP_ImpinjTransmitPower_countCustom ( + LLRP_tSImpinjTransmitPower *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjTransmitPower_addCustom ( + LLRP_tSImpinjTransmitPower *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjPolarizationControl +{ + LLRP_tSParameter hdr; + + llrp_u1_t PolarizationControlEnabled; + + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjPolarizationControl; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjPolarizationControl[]; + +extern LLRP_tSImpinjPolarizationControl * +LLRP_ImpinjPolarizationControl_construct (void); + +extern void +LLRP_ImpinjPolarizationControl_destruct ( + LLRP_tSImpinjPolarizationControl * pThis); + +extern void +LLRP_ImpinjPolarizationControl_decodeFields ( + LLRP_tSImpinjPolarizationControl * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjPolarizationControl_assimilateSubParameters ( + LLRP_tSImpinjPolarizationControl * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjPolarizationControl_encode ( + const LLRP_tSImpinjPolarizationControl *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjPolarizationControl_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjPolarizationControl_PolarizationControlEnabled; + +extern llrp_u1_t +LLRP_ImpinjPolarizationControl_getPolarizationControlEnabled ( + LLRP_tSImpinjPolarizationControl *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjPolarizationControl_setPolarizationControlEnabled ( + LLRP_tSImpinjPolarizationControl *pThis, + llrp_u1_t Value); + + +extern LLRP_tSParameter * +LLRP_ImpinjPolarizationControl_beginCustom ( + LLRP_tSImpinjPolarizationControl *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjPolarizationControl_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjPolarizationControl_clearCustom ( + LLRP_tSImpinjPolarizationControl *pThis); + +extern int +LLRP_ImpinjPolarizationControl_countCustom ( + LLRP_tSImpinjPolarizationControl *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjPolarizationControl_addCustom ( + LLRP_tSImpinjPolarizationControl *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjAntennaCapabilities +{ + LLRP_tSParameter hdr; + + + LLRP_tSImpinjAntennaPolarizationCapability * listImpinjAntennaPolarizationCapability; + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjAntennaCapabilities; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjAntennaCapabilities[]; + +extern LLRP_tSImpinjAntennaCapabilities * +LLRP_ImpinjAntennaCapabilities_construct (void); + +extern void +LLRP_ImpinjAntennaCapabilities_destruct ( + LLRP_tSImpinjAntennaCapabilities * pThis); + +extern void +LLRP_ImpinjAntennaCapabilities_decodeFields ( + LLRP_tSImpinjAntennaCapabilities * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjAntennaCapabilities_assimilateSubParameters ( + LLRP_tSImpinjAntennaCapabilities * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjAntennaCapabilities_encode ( + const LLRP_tSImpinjAntennaCapabilities *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjAntennaCapabilities_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + + +extern LLRP_tSImpinjAntennaPolarizationCapability * +LLRP_ImpinjAntennaCapabilities_beginImpinjAntennaPolarizationCapability ( + LLRP_tSImpinjAntennaCapabilities *pThis); + +extern LLRP_tSImpinjAntennaPolarizationCapability * +LLRP_ImpinjAntennaCapabilities_nextImpinjAntennaPolarizationCapability ( + LLRP_tSImpinjAntennaPolarizationCapability *pCurrent); + +extern void +LLRP_ImpinjAntennaCapabilities_clearImpinjAntennaPolarizationCapability ( + LLRP_tSImpinjAntennaCapabilities *pThis); + +extern int +LLRP_ImpinjAntennaCapabilities_countImpinjAntennaPolarizationCapability ( + LLRP_tSImpinjAntennaCapabilities *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjAntennaCapabilities_addImpinjAntennaPolarizationCapability ( + LLRP_tSImpinjAntennaCapabilities *pThis, + LLRP_tSImpinjAntennaPolarizationCapability *pValue); + + +extern LLRP_tSParameter * +LLRP_ImpinjAntennaCapabilities_beginCustom ( + LLRP_tSImpinjAntennaCapabilities *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjAntennaCapabilities_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjAntennaCapabilities_clearCustom ( + LLRP_tSImpinjAntennaCapabilities *pThis); + +extern int +LLRP_ImpinjAntennaCapabilities_countCustom ( + LLRP_tSImpinjAntennaCapabilities *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjAntennaCapabilities_addCustom ( + LLRP_tSImpinjAntennaCapabilities *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjAntennaPolarizationCapability +{ + LLRP_tSParameter hdr; + + LLRP_tEImpinjAntennaPolarizationType eType; + + llrp_u16_t AntennaIDOffset; + + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjAntennaPolarizationCapability; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjAntennaPolarizationCapability[]; + +extern LLRP_tSImpinjAntennaPolarizationCapability * +LLRP_ImpinjAntennaPolarizationCapability_construct (void); + +extern void +LLRP_ImpinjAntennaPolarizationCapability_destruct ( + LLRP_tSImpinjAntennaPolarizationCapability * pThis); + +extern void +LLRP_ImpinjAntennaPolarizationCapability_decodeFields ( + LLRP_tSImpinjAntennaPolarizationCapability * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjAntennaPolarizationCapability_assimilateSubParameters ( + LLRP_tSImpinjAntennaPolarizationCapability * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjAntennaPolarizationCapability_encode ( + const LLRP_tSImpinjAntennaPolarizationCapability *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjAntennaPolarizationCapability_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjAntennaPolarizationCapability_Type; + +extern LLRP_tEImpinjAntennaPolarizationType +LLRP_ImpinjAntennaPolarizationCapability_getType ( + LLRP_tSImpinjAntennaPolarizationCapability *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjAntennaPolarizationCapability_setType ( + LLRP_tSImpinjAntennaPolarizationCapability *pThis, + LLRP_tEImpinjAntennaPolarizationType Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjAntennaPolarizationCapability_AntennaIDOffset; + +extern llrp_u16_t +LLRP_ImpinjAntennaPolarizationCapability_getAntennaIDOffset ( + LLRP_tSImpinjAntennaPolarizationCapability *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjAntennaPolarizationCapability_setAntennaIDOffset ( + LLRP_tSImpinjAntennaPolarizationCapability *pThis, + llrp_u16_t Value); + + +extern LLRP_tSParameter * +LLRP_ImpinjAntennaPolarizationCapability_beginCustom ( + LLRP_tSImpinjAntennaPolarizationCapability *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjAntennaPolarizationCapability_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjAntennaPolarizationCapability_clearCustom ( + LLRP_tSImpinjAntennaPolarizationCapability *pThis); + +extern int +LLRP_ImpinjAntennaPolarizationCapability_countCustom ( + LLRP_tSImpinjAntennaPolarizationCapability *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjAntennaPolarizationCapability_addCustom ( + LLRP_tSImpinjAntennaPolarizationCapability *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjDisabledAntennas +{ + LLRP_tSParameter hdr; + + llrp_u16v_t AntennaIDs; + + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjDisabledAntennas; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjDisabledAntennas[]; + +extern LLRP_tSImpinjDisabledAntennas * +LLRP_ImpinjDisabledAntennas_construct (void); + +extern void +LLRP_ImpinjDisabledAntennas_destruct ( + LLRP_tSImpinjDisabledAntennas * pThis); + +extern void +LLRP_ImpinjDisabledAntennas_decodeFields ( + LLRP_tSImpinjDisabledAntennas * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjDisabledAntennas_assimilateSubParameters ( + LLRP_tSImpinjDisabledAntennas * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjDisabledAntennas_encode ( + const LLRP_tSImpinjDisabledAntennas *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjDisabledAntennas_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjDisabledAntennas_AntennaIDs; + +extern llrp_u16v_t +LLRP_ImpinjDisabledAntennas_getAntennaIDs ( + LLRP_tSImpinjDisabledAntennas *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjDisabledAntennas_setAntennaIDs ( + LLRP_tSImpinjDisabledAntennas *pThis, + llrp_u16v_t Value); + + +extern LLRP_tSParameter * +LLRP_ImpinjDisabledAntennas_beginCustom ( + LLRP_tSImpinjDisabledAntennas *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjDisabledAntennas_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjDisabledAntennas_clearCustom ( + LLRP_tSImpinjDisabledAntennas *pThis); + +extern int +LLRP_ImpinjDisabledAntennas_countCustom ( + LLRP_tSImpinjDisabledAntennas *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjDisabledAntennas_addCustom ( + LLRP_tSImpinjDisabledAntennas *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjTIDParity +{ + LLRP_tSParameter hdr; + + llrp_u1_t ParityError; + + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjTIDParity; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjTIDParity[]; + +extern LLRP_tSImpinjTIDParity * +LLRP_ImpinjTIDParity_construct (void); + +extern void +LLRP_ImpinjTIDParity_destruct ( + LLRP_tSImpinjTIDParity * pThis); + +extern void +LLRP_ImpinjTIDParity_decodeFields ( + LLRP_tSImpinjTIDParity * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjTIDParity_assimilateSubParameters ( + LLRP_tSImpinjTIDParity * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjTIDParity_encode ( + const LLRP_tSImpinjTIDParity *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjTIDParity_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjTIDParity_ParityError; + +extern llrp_u1_t +LLRP_ImpinjTIDParity_getParityError ( + LLRP_tSImpinjTIDParity *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjTIDParity_setParityError ( + LLRP_tSImpinjTIDParity *pThis, + llrp_u1_t Value); + + +extern LLRP_tSParameter * +LLRP_ImpinjTIDParity_beginCustom ( + LLRP_tSImpinjTIDParity *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjTIDParity_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjTIDParity_clearCustom ( + LLRP_tSImpinjTIDParity *pThis); + +extern int +LLRP_ImpinjTIDParity_countCustom ( + LLRP_tSImpinjTIDParity *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjTIDParity_addCustom ( + LLRP_tSImpinjTIDParity *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjMarginRead +{ + LLRP_tSParameter hdr; + + llrp_u16_t OpSpecID; + + llrp_u32_t AccessPassword; + + llrp_u2_t MB; + + llrp_u16_t BitPointer; + + llrp_u8_t BitLength; + + llrp_u16v_t Mask; + + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjMarginRead; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjMarginRead[]; + +extern LLRP_tSImpinjMarginRead * +LLRP_ImpinjMarginRead_construct (void); + +extern void +LLRP_ImpinjMarginRead_destruct ( + LLRP_tSImpinjMarginRead * pThis); + +extern void +LLRP_ImpinjMarginRead_decodeFields ( + LLRP_tSImpinjMarginRead * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjMarginRead_assimilateSubParameters ( + LLRP_tSImpinjMarginRead * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjMarginRead_encode ( + const LLRP_tSImpinjMarginRead *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjMarginRead_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjMarginRead_OpSpecID; + +extern llrp_u16_t +LLRP_ImpinjMarginRead_getOpSpecID ( + LLRP_tSImpinjMarginRead *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjMarginRead_setOpSpecID ( + LLRP_tSImpinjMarginRead *pThis, + llrp_u16_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjMarginRead_AccessPassword; + +extern llrp_u32_t +LLRP_ImpinjMarginRead_getAccessPassword ( + LLRP_tSImpinjMarginRead *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjMarginRead_setAccessPassword ( + LLRP_tSImpinjMarginRead *pThis, + llrp_u32_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjMarginRead_MB; + +extern llrp_u2_t +LLRP_ImpinjMarginRead_getMB ( + LLRP_tSImpinjMarginRead *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjMarginRead_setMB ( + LLRP_tSImpinjMarginRead *pThis, + llrp_u2_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjMarginRead_BitPointer; + +extern llrp_u16_t +LLRP_ImpinjMarginRead_getBitPointer ( + LLRP_tSImpinjMarginRead *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjMarginRead_setBitPointer ( + LLRP_tSImpinjMarginRead *pThis, + llrp_u16_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjMarginRead_BitLength; + +extern llrp_u8_t +LLRP_ImpinjMarginRead_getBitLength ( + LLRP_tSImpinjMarginRead *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjMarginRead_setBitLength ( + LLRP_tSImpinjMarginRead *pThis, + llrp_u8_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjMarginRead_Mask; + +extern llrp_u16v_t +LLRP_ImpinjMarginRead_getMask ( + LLRP_tSImpinjMarginRead *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjMarginRead_setMask ( + LLRP_tSImpinjMarginRead *pThis, + llrp_u16v_t Value); + + +extern LLRP_tSParameter * +LLRP_ImpinjMarginRead_beginCustom ( + LLRP_tSImpinjMarginRead *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjMarginRead_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjMarginRead_clearCustom ( + LLRP_tSImpinjMarginRead *pThis); + +extern int +LLRP_ImpinjMarginRead_countCustom ( + LLRP_tSImpinjMarginRead *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjMarginRead_addCustom ( + LLRP_tSImpinjMarginRead *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjMarginReadOpSpecResult +{ + LLRP_tSParameter hdr; + + LLRP_tEImpinjMarginReadResultType eResult; + + llrp_u16_t OpSpecID; + + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjMarginReadOpSpecResult; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjMarginReadOpSpecResult[]; + +extern LLRP_tSImpinjMarginReadOpSpecResult * +LLRP_ImpinjMarginReadOpSpecResult_construct (void); + +extern void +LLRP_ImpinjMarginReadOpSpecResult_destruct ( + LLRP_tSImpinjMarginReadOpSpecResult * pThis); + +extern void +LLRP_ImpinjMarginReadOpSpecResult_decodeFields ( + LLRP_tSImpinjMarginReadOpSpecResult * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjMarginReadOpSpecResult_assimilateSubParameters ( + LLRP_tSImpinjMarginReadOpSpecResult * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjMarginReadOpSpecResult_encode ( + const LLRP_tSImpinjMarginReadOpSpecResult *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjMarginReadOpSpecResult_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjMarginReadOpSpecResult_Result; + +extern LLRP_tEImpinjMarginReadResultType +LLRP_ImpinjMarginReadOpSpecResult_getResult ( + LLRP_tSImpinjMarginReadOpSpecResult *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjMarginReadOpSpecResult_setResult ( + LLRP_tSImpinjMarginReadOpSpecResult *pThis, + LLRP_tEImpinjMarginReadResultType Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjMarginReadOpSpecResult_OpSpecID; + +extern llrp_u16_t +LLRP_ImpinjMarginReadOpSpecResult_getOpSpecID ( + LLRP_tSImpinjMarginReadOpSpecResult *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjMarginReadOpSpecResult_setOpSpecID ( + LLRP_tSImpinjMarginReadOpSpecResult *pThis, + llrp_u16_t Value); + + +extern LLRP_tSParameter * +LLRP_ImpinjMarginReadOpSpecResult_beginCustom ( + LLRP_tSImpinjMarginReadOpSpecResult *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjMarginReadOpSpecResult_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjMarginReadOpSpecResult_clearCustom ( + LLRP_tSImpinjMarginReadOpSpecResult *pThis); + +extern int +LLRP_ImpinjMarginReadOpSpecResult_countCustom ( + LLRP_tSImpinjMarginReadOpSpecResult *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjMarginReadOpSpecResult_addCustom ( + LLRP_tSImpinjMarginReadOpSpecResult *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjBLEVersion +{ + LLRP_tSParameter hdr; + + llrp_utf8v_t FirmwareVersion; + + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjBLEVersion; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjBLEVersion[]; + +extern LLRP_tSImpinjBLEVersion * +LLRP_ImpinjBLEVersion_construct (void); + +extern void +LLRP_ImpinjBLEVersion_destruct ( + LLRP_tSImpinjBLEVersion * pThis); + +extern void +LLRP_ImpinjBLEVersion_decodeFields ( + LLRP_tSImpinjBLEVersion * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjBLEVersion_assimilateSubParameters ( + LLRP_tSImpinjBLEVersion * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjBLEVersion_encode ( + const LLRP_tSImpinjBLEVersion *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjBLEVersion_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjBLEVersion_FirmwareVersion; + +extern llrp_utf8v_t +LLRP_ImpinjBLEVersion_getFirmwareVersion ( + LLRP_tSImpinjBLEVersion *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjBLEVersion_setFirmwareVersion ( + LLRP_tSImpinjBLEVersion *pThis, + llrp_utf8v_t Value); + + +extern LLRP_tSParameter * +LLRP_ImpinjBLEVersion_beginCustom ( + LLRP_tSImpinjBLEVersion *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjBLEVersion_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjBLEVersion_clearCustom ( + LLRP_tSImpinjBLEVersion *pThis); + +extern int +LLRP_ImpinjBLEVersion_countCustom ( + LLRP_tSImpinjBLEVersion *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjBLEVersion_addCustom ( + LLRP_tSImpinjBLEVersion *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjLocationAlgorithmControl +{ + LLRP_tSParameter hdr; + + llrp_u32v_t ControlData; + + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjLocationAlgorithmControl; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjLocationAlgorithmControl[]; + +extern LLRP_tSImpinjLocationAlgorithmControl * +LLRP_ImpinjLocationAlgorithmControl_construct (void); + +extern void +LLRP_ImpinjLocationAlgorithmControl_destruct ( + LLRP_tSImpinjLocationAlgorithmControl * pThis); + +extern void +LLRP_ImpinjLocationAlgorithmControl_decodeFields ( + LLRP_tSImpinjLocationAlgorithmControl * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjLocationAlgorithmControl_assimilateSubParameters ( + LLRP_tSImpinjLocationAlgorithmControl * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjLocationAlgorithmControl_encode ( + const LLRP_tSImpinjLocationAlgorithmControl *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjLocationAlgorithmControl_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjLocationAlgorithmControl_ControlData; + +extern llrp_u32v_t +LLRP_ImpinjLocationAlgorithmControl_getControlData ( + LLRP_tSImpinjLocationAlgorithmControl *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjLocationAlgorithmControl_setControlData ( + LLRP_tSImpinjLocationAlgorithmControl *pThis, + llrp_u32v_t Value); + + +extern LLRP_tSParameter * +LLRP_ImpinjLocationAlgorithmControl_beginCustom ( + LLRP_tSImpinjLocationAlgorithmControl *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjLocationAlgorithmControl_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjLocationAlgorithmControl_clearCustom ( + LLRP_tSImpinjLocationAlgorithmControl *pThis); + +extern int +LLRP_ImpinjLocationAlgorithmControl_countCustom ( + LLRP_tSImpinjLocationAlgorithmControl *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjLocationAlgorithmControl_addCustom ( + LLRP_tSImpinjLocationAlgorithmControl *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjRFPowerSweep +{ + LLRP_tSParameter hdr; + + llrp_u1_t EnableRFPowerSweep; + + llrp_u16_t MinimumPowerLevel; + + llrp_u16_t PowerLevelStepSize; + + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjRFPowerSweep; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjRFPowerSweep[]; + +extern LLRP_tSImpinjRFPowerSweep * +LLRP_ImpinjRFPowerSweep_construct (void); + +extern void +LLRP_ImpinjRFPowerSweep_destruct ( + LLRP_tSImpinjRFPowerSweep * pThis); + +extern void +LLRP_ImpinjRFPowerSweep_decodeFields ( + LLRP_tSImpinjRFPowerSweep * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjRFPowerSweep_assimilateSubParameters ( + LLRP_tSImpinjRFPowerSweep * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjRFPowerSweep_encode ( + const LLRP_tSImpinjRFPowerSweep *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjRFPowerSweep_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjRFPowerSweep_EnableRFPowerSweep; + +extern llrp_u1_t +LLRP_ImpinjRFPowerSweep_getEnableRFPowerSweep ( + LLRP_tSImpinjRFPowerSweep *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjRFPowerSweep_setEnableRFPowerSweep ( + LLRP_tSImpinjRFPowerSweep *pThis, + llrp_u1_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjRFPowerSweep_MinimumPowerLevel; + +extern llrp_u16_t +LLRP_ImpinjRFPowerSweep_getMinimumPowerLevel ( + LLRP_tSImpinjRFPowerSweep *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjRFPowerSweep_setMinimumPowerLevel ( + LLRP_tSImpinjRFPowerSweep *pThis, + llrp_u16_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjRFPowerSweep_PowerLevelStepSize; + +extern llrp_u16_t +LLRP_ImpinjRFPowerSweep_getPowerLevelStepSize ( + LLRP_tSImpinjRFPowerSweep *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjRFPowerSweep_setPowerLevelStepSize ( + LLRP_tSImpinjRFPowerSweep *pThis, + llrp_u16_t Value); + + +extern LLRP_tSParameter * +LLRP_ImpinjRFPowerSweep_beginCustom ( + LLRP_tSImpinjRFPowerSweep *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjRFPowerSweep_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjRFPowerSweep_clearCustom ( + LLRP_tSImpinjRFPowerSweep *pThis); + +extern int +LLRP_ImpinjRFPowerSweep_countCustom ( + LLRP_tSImpinjRFPowerSweep *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjRFPowerSweep_addCustom ( + LLRP_tSImpinjRFPowerSweep *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjTruncatedReplyConfiguration +{ + LLRP_tSParameter hdr; + + llrp_u1_t Gen2v2TagsOnly; + + llrp_u8_t EPCLength; + + llrp_u16_t Pointer; + + llrp_u1v_t TagMask; + + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjTruncatedReplyConfiguration; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjTruncatedReplyConfiguration[]; + +extern LLRP_tSImpinjTruncatedReplyConfiguration * +LLRP_ImpinjTruncatedReplyConfiguration_construct (void); + +extern void +LLRP_ImpinjTruncatedReplyConfiguration_destruct ( + LLRP_tSImpinjTruncatedReplyConfiguration * pThis); + +extern void +LLRP_ImpinjTruncatedReplyConfiguration_decodeFields ( + LLRP_tSImpinjTruncatedReplyConfiguration * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjTruncatedReplyConfiguration_assimilateSubParameters ( + LLRP_tSImpinjTruncatedReplyConfiguration * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjTruncatedReplyConfiguration_encode ( + const LLRP_tSImpinjTruncatedReplyConfiguration *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjTruncatedReplyConfiguration_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjTruncatedReplyConfiguration_Gen2v2TagsOnly; + +extern llrp_u1_t +LLRP_ImpinjTruncatedReplyConfiguration_getGen2v2TagsOnly ( + LLRP_tSImpinjTruncatedReplyConfiguration *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjTruncatedReplyConfiguration_setGen2v2TagsOnly ( + LLRP_tSImpinjTruncatedReplyConfiguration *pThis, + llrp_u1_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjTruncatedReplyConfiguration_EPCLength; + +extern llrp_u8_t +LLRP_ImpinjTruncatedReplyConfiguration_getEPCLength ( + LLRP_tSImpinjTruncatedReplyConfiguration *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjTruncatedReplyConfiguration_setEPCLength ( + LLRP_tSImpinjTruncatedReplyConfiguration *pThis, + llrp_u8_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjTruncatedReplyConfiguration_Pointer; + +extern llrp_u16_t +LLRP_ImpinjTruncatedReplyConfiguration_getPointer ( + LLRP_tSImpinjTruncatedReplyConfiguration *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjTruncatedReplyConfiguration_setPointer ( + LLRP_tSImpinjTruncatedReplyConfiguration *pThis, + llrp_u16_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjTruncatedReplyConfiguration_TagMask; + +extern llrp_u1v_t +LLRP_ImpinjTruncatedReplyConfiguration_getTagMask ( + LLRP_tSImpinjTruncatedReplyConfiguration *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjTruncatedReplyConfiguration_setTagMask ( + LLRP_tSImpinjTruncatedReplyConfiguration *pThis, + llrp_u1v_t Value); + + +extern LLRP_tSParameter * +LLRP_ImpinjTruncatedReplyConfiguration_beginCustom ( + LLRP_tSImpinjTruncatedReplyConfiguration *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjTruncatedReplyConfiguration_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjTruncatedReplyConfiguration_clearCustom ( + LLRP_tSImpinjTruncatedReplyConfiguration *pThis); + +extern int +LLRP_ImpinjTruncatedReplyConfiguration_countCustom ( + LLRP_tSImpinjTruncatedReplyConfiguration *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjTruncatedReplyConfiguration_addCustom ( + LLRP_tSImpinjTruncatedReplyConfiguration *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjAuthenticate +{ + LLRP_tSParameter hdr; + + llrp_u16_t OpSpecID; + + llrp_u32_t AccessPassword; + + llrp_u1_t SendRep; + + llrp_u1_t IncRepLen; + + llrp_u8_t CSI; + + llrp_u1v_t Message; + + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjAuthenticate; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjAuthenticate[]; + +extern LLRP_tSImpinjAuthenticate * +LLRP_ImpinjAuthenticate_construct (void); + +extern void +LLRP_ImpinjAuthenticate_destruct ( + LLRP_tSImpinjAuthenticate * pThis); + +extern void +LLRP_ImpinjAuthenticate_decodeFields ( + LLRP_tSImpinjAuthenticate * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjAuthenticate_assimilateSubParameters ( + LLRP_tSImpinjAuthenticate * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjAuthenticate_encode ( + const LLRP_tSImpinjAuthenticate *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjAuthenticate_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjAuthenticate_OpSpecID; + +extern llrp_u16_t +LLRP_ImpinjAuthenticate_getOpSpecID ( + LLRP_tSImpinjAuthenticate *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjAuthenticate_setOpSpecID ( + LLRP_tSImpinjAuthenticate *pThis, + llrp_u16_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjAuthenticate_AccessPassword; + +extern llrp_u32_t +LLRP_ImpinjAuthenticate_getAccessPassword ( + LLRP_tSImpinjAuthenticate *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjAuthenticate_setAccessPassword ( + LLRP_tSImpinjAuthenticate *pThis, + llrp_u32_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjAuthenticate_SendRep; + +extern llrp_u1_t +LLRP_ImpinjAuthenticate_getSendRep ( + LLRP_tSImpinjAuthenticate *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjAuthenticate_setSendRep ( + LLRP_tSImpinjAuthenticate *pThis, + llrp_u1_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjAuthenticate_IncRepLen; + +extern llrp_u1_t +LLRP_ImpinjAuthenticate_getIncRepLen ( + LLRP_tSImpinjAuthenticate *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjAuthenticate_setIncRepLen ( + LLRP_tSImpinjAuthenticate *pThis, + llrp_u1_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjAuthenticate_CSI; + +extern llrp_u8_t +LLRP_ImpinjAuthenticate_getCSI ( + LLRP_tSImpinjAuthenticate *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjAuthenticate_setCSI ( + LLRP_tSImpinjAuthenticate *pThis, + llrp_u8_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjAuthenticate_Message; + +extern llrp_u1v_t +LLRP_ImpinjAuthenticate_getMessage ( + LLRP_tSImpinjAuthenticate *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjAuthenticate_setMessage ( + LLRP_tSImpinjAuthenticate *pThis, + llrp_u1v_t Value); + + +extern LLRP_tSParameter * +LLRP_ImpinjAuthenticate_beginCustom ( + LLRP_tSImpinjAuthenticate *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjAuthenticate_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjAuthenticate_clearCustom ( + LLRP_tSImpinjAuthenticate *pThis); + +extern int +LLRP_ImpinjAuthenticate_countCustom ( + LLRP_tSImpinjAuthenticate *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjAuthenticate_addCustom ( + LLRP_tSImpinjAuthenticate *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjAuthenticateOpSpecResult +{ + LLRP_tSParameter hdr; + + LLRP_tEImpinjAuthenticateResultType eResult; + + llrp_u16_t OpSpecID; + + llrp_u1v_t Response; + + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjAuthenticateOpSpecResult; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjAuthenticateOpSpecResult[]; + +extern LLRP_tSImpinjAuthenticateOpSpecResult * +LLRP_ImpinjAuthenticateOpSpecResult_construct (void); + +extern void +LLRP_ImpinjAuthenticateOpSpecResult_destruct ( + LLRP_tSImpinjAuthenticateOpSpecResult * pThis); + +extern void +LLRP_ImpinjAuthenticateOpSpecResult_decodeFields ( + LLRP_tSImpinjAuthenticateOpSpecResult * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjAuthenticateOpSpecResult_assimilateSubParameters ( + LLRP_tSImpinjAuthenticateOpSpecResult * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjAuthenticateOpSpecResult_encode ( + const LLRP_tSImpinjAuthenticateOpSpecResult *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjAuthenticateOpSpecResult_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjAuthenticateOpSpecResult_Result; + +extern LLRP_tEImpinjAuthenticateResultType +LLRP_ImpinjAuthenticateOpSpecResult_getResult ( + LLRP_tSImpinjAuthenticateOpSpecResult *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjAuthenticateOpSpecResult_setResult ( + LLRP_tSImpinjAuthenticateOpSpecResult *pThis, + LLRP_tEImpinjAuthenticateResultType Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjAuthenticateOpSpecResult_OpSpecID; + +extern llrp_u16_t +LLRP_ImpinjAuthenticateOpSpecResult_getOpSpecID ( + LLRP_tSImpinjAuthenticateOpSpecResult *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjAuthenticateOpSpecResult_setOpSpecID ( + LLRP_tSImpinjAuthenticateOpSpecResult *pThis, + llrp_u16_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjAuthenticateOpSpecResult_Response; + +extern llrp_u1v_t +LLRP_ImpinjAuthenticateOpSpecResult_getResponse ( + LLRP_tSImpinjAuthenticateOpSpecResult *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjAuthenticateOpSpecResult_setResponse ( + LLRP_tSImpinjAuthenticateOpSpecResult *pThis, + llrp_u1v_t Value); + + +extern LLRP_tSParameter * +LLRP_ImpinjAuthenticateOpSpecResult_beginCustom ( + LLRP_tSImpinjAuthenticateOpSpecResult *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjAuthenticateOpSpecResult_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjAuthenticateOpSpecResult_clearCustom ( + LLRP_tSImpinjAuthenticateOpSpecResult *pThis); + +extern int +LLRP_ImpinjAuthenticateOpSpecResult_countCustom ( + LLRP_tSImpinjAuthenticateOpSpecResult *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjAuthenticateOpSpecResult_addCustom ( + LLRP_tSImpinjAuthenticateOpSpecResult *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjTagFilterVerificationConfiguration +{ + LLRP_tSParameter hdr; + + LLRP_tEImpinjTagFilterVerificationMode eTagFilterVerificationMode; + + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjTagFilterVerificationConfiguration; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjTagFilterVerificationConfiguration[]; + +extern LLRP_tSImpinjTagFilterVerificationConfiguration * +LLRP_ImpinjTagFilterVerificationConfiguration_construct (void); + +extern void +LLRP_ImpinjTagFilterVerificationConfiguration_destruct ( + LLRP_tSImpinjTagFilterVerificationConfiguration * pThis); + +extern void +LLRP_ImpinjTagFilterVerificationConfiguration_decodeFields ( + LLRP_tSImpinjTagFilterVerificationConfiguration * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjTagFilterVerificationConfiguration_assimilateSubParameters ( + LLRP_tSImpinjTagFilterVerificationConfiguration * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjTagFilterVerificationConfiguration_encode ( + const LLRP_tSImpinjTagFilterVerificationConfiguration *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjTagFilterVerificationConfiguration_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjTagFilterVerificationConfiguration_TagFilterVerificationMode; + +extern LLRP_tEImpinjTagFilterVerificationMode +LLRP_ImpinjTagFilterVerificationConfiguration_getTagFilterVerificationMode ( + LLRP_tSImpinjTagFilterVerificationConfiguration *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjTagFilterVerificationConfiguration_setTagFilterVerificationMode ( + LLRP_tSImpinjTagFilterVerificationConfiguration *pThis, + LLRP_tEImpinjTagFilterVerificationMode Value); + + +extern LLRP_tSParameter * +LLRP_ImpinjTagFilterVerificationConfiguration_beginCustom ( + LLRP_tSImpinjTagFilterVerificationConfiguration *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjTagFilterVerificationConfiguration_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjTagFilterVerificationConfiguration_clearCustom ( + LLRP_tSImpinjTagFilterVerificationConfiguration *pThis); + +extern int +LLRP_ImpinjTagFilterVerificationConfiguration_countCustom ( + LLRP_tSImpinjTagFilterVerificationConfiguration *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjTagFilterVerificationConfiguration_addCustom ( + LLRP_tSImpinjTagFilterVerificationConfiguration *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjEnableTagPopulationEstimationAlgorithm +{ + LLRP_tSParameter hdr; + + LLRP_tEImpinjTagPopulationEstimationMode eTagPopulationEstimationMode; + + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjEnableTagPopulationEstimationAlgorithm; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjEnableTagPopulationEstimationAlgorithm[]; + +extern LLRP_tSImpinjEnableTagPopulationEstimationAlgorithm * +LLRP_ImpinjEnableTagPopulationEstimationAlgorithm_construct (void); + +extern void +LLRP_ImpinjEnableTagPopulationEstimationAlgorithm_destruct ( + LLRP_tSImpinjEnableTagPopulationEstimationAlgorithm * pThis); + +extern void +LLRP_ImpinjEnableTagPopulationEstimationAlgorithm_decodeFields ( + LLRP_tSImpinjEnableTagPopulationEstimationAlgorithm * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjEnableTagPopulationEstimationAlgorithm_assimilateSubParameters ( + LLRP_tSImpinjEnableTagPopulationEstimationAlgorithm * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjEnableTagPopulationEstimationAlgorithm_encode ( + const LLRP_tSImpinjEnableTagPopulationEstimationAlgorithm *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjEnableTagPopulationEstimationAlgorithm_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjEnableTagPopulationEstimationAlgorithm_TagPopulationEstimationMode; + +extern LLRP_tEImpinjTagPopulationEstimationMode +LLRP_ImpinjEnableTagPopulationEstimationAlgorithm_getTagPopulationEstimationMode ( + LLRP_tSImpinjEnableTagPopulationEstimationAlgorithm *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjEnableTagPopulationEstimationAlgorithm_setTagPopulationEstimationMode ( + LLRP_tSImpinjEnableTagPopulationEstimationAlgorithm *pThis, + LLRP_tEImpinjTagPopulationEstimationMode Value); + + +extern LLRP_tSParameter * +LLRP_ImpinjEnableTagPopulationEstimationAlgorithm_beginCustom ( + LLRP_tSImpinjEnableTagPopulationEstimationAlgorithm *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjEnableTagPopulationEstimationAlgorithm_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjEnableTagPopulationEstimationAlgorithm_clearCustom ( + LLRP_tSImpinjEnableTagPopulationEstimationAlgorithm *pThis); + +extern int +LLRP_ImpinjEnableTagPopulationEstimationAlgorithm_countCustom ( + LLRP_tSImpinjEnableTagPopulationEstimationAlgorithm *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjEnableTagPopulationEstimationAlgorithm_addCustom ( + LLRP_tSImpinjEnableTagPopulationEstimationAlgorithm *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjEnableCRHandle +{ + LLRP_tSParameter hdr; + + LLRP_tEImpinjCRHandleMode eCRHandleMode; + + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjEnableCRHandle; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjEnableCRHandle[]; + +extern LLRP_tSImpinjEnableCRHandle * +LLRP_ImpinjEnableCRHandle_construct (void); + +extern void +LLRP_ImpinjEnableCRHandle_destruct ( + LLRP_tSImpinjEnableCRHandle * pThis); + +extern void +LLRP_ImpinjEnableCRHandle_decodeFields ( + LLRP_tSImpinjEnableCRHandle * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjEnableCRHandle_assimilateSubParameters ( + LLRP_tSImpinjEnableCRHandle * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjEnableCRHandle_encode ( + const LLRP_tSImpinjEnableCRHandle *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjEnableCRHandle_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjEnableCRHandle_CRHandleMode; + +extern LLRP_tEImpinjCRHandleMode +LLRP_ImpinjEnableCRHandle_getCRHandleMode ( + LLRP_tSImpinjEnableCRHandle *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjEnableCRHandle_setCRHandleMode ( + LLRP_tSImpinjEnableCRHandle *pThis, + LLRP_tEImpinjCRHandleMode Value); + + +extern LLRP_tSParameter * +LLRP_ImpinjEnableCRHandle_beginCustom ( + LLRP_tSImpinjEnableCRHandle *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjEnableCRHandle_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjEnableCRHandle_clearCustom ( + LLRP_tSImpinjEnableCRHandle *pThis); + +extern int +LLRP_ImpinjEnableCRHandle_countCustom ( + LLRP_tSImpinjEnableCRHandle *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjEnableCRHandle_addCustom ( + LLRP_tSImpinjEnableCRHandle *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjCRHandle +{ + LLRP_tSParameter hdr; + + llrp_u32_t CRHandle; + + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjCRHandle; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjCRHandle[]; + +extern LLRP_tSImpinjCRHandle * +LLRP_ImpinjCRHandle_construct (void); + +extern void +LLRP_ImpinjCRHandle_destruct ( + LLRP_tSImpinjCRHandle * pThis); + +extern void +LLRP_ImpinjCRHandle_decodeFields ( + LLRP_tSImpinjCRHandle * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjCRHandle_assimilateSubParameters ( + LLRP_tSImpinjCRHandle * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjCRHandle_encode ( + const LLRP_tSImpinjCRHandle *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjCRHandle_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjCRHandle_CRHandle; + +extern llrp_u32_t +LLRP_ImpinjCRHandle_getCRHandle ( + LLRP_tSImpinjCRHandle *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjCRHandle_setCRHandle ( + LLRP_tSImpinjCRHandle *pThis, + llrp_u32_t Value); + + +extern LLRP_tSParameter * +LLRP_ImpinjCRHandle_beginCustom ( + LLRP_tSImpinjCRHandle *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjCRHandle_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjCRHandle_clearCustom ( + LLRP_tSImpinjCRHandle *pThis); + +extern int +LLRP_ImpinjCRHandle_countCustom ( + LLRP_tSImpinjCRHandle *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjCRHandle_addCustom ( + LLRP_tSImpinjCRHandle *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjEnableEnhancedIntegra +{ + LLRP_tSParameter hdr; + + LLRP_tEImpinjEnhancedIntegraMode eEnhancedIntegraMode; + + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjEnableEnhancedIntegra; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjEnableEnhancedIntegra[]; + +extern LLRP_tSImpinjEnableEnhancedIntegra * +LLRP_ImpinjEnableEnhancedIntegra_construct (void); + +extern void +LLRP_ImpinjEnableEnhancedIntegra_destruct ( + LLRP_tSImpinjEnableEnhancedIntegra * pThis); + +extern void +LLRP_ImpinjEnableEnhancedIntegra_decodeFields ( + LLRP_tSImpinjEnableEnhancedIntegra * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjEnableEnhancedIntegra_assimilateSubParameters ( + LLRP_tSImpinjEnableEnhancedIntegra * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjEnableEnhancedIntegra_encode ( + const LLRP_tSImpinjEnableEnhancedIntegra *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjEnableEnhancedIntegra_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjEnableEnhancedIntegra_EnhancedIntegraMode; + +extern LLRP_tEImpinjEnhancedIntegraMode +LLRP_ImpinjEnableEnhancedIntegra_getEnhancedIntegraMode ( + LLRP_tSImpinjEnableEnhancedIntegra *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjEnableEnhancedIntegra_setEnhancedIntegraMode ( + LLRP_tSImpinjEnableEnhancedIntegra *pThis, + LLRP_tEImpinjEnhancedIntegraMode Value); + + +extern LLRP_tSParameter * +LLRP_ImpinjEnableEnhancedIntegra_beginCustom ( + LLRP_tSImpinjEnableEnhancedIntegra *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjEnableEnhancedIntegra_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjEnableEnhancedIntegra_clearCustom ( + LLRP_tSImpinjEnableEnhancedIntegra *pThis); + +extern int +LLRP_ImpinjEnableEnhancedIntegra_countCustom ( + LLRP_tSImpinjEnableEnhancedIntegra *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjEnableEnhancedIntegra_addCustom ( + LLRP_tSImpinjEnableEnhancedIntegra *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjEnhancedIntegraReport +{ + LLRP_tSParameter hdr; + + LLRP_tEImpinjEnhancedIntegraResultType eResult; + + llrp_u16_t OpSpecID; + + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjEnhancedIntegraReport; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjEnhancedIntegraReport[]; + +extern LLRP_tSImpinjEnhancedIntegraReport * +LLRP_ImpinjEnhancedIntegraReport_construct (void); + +extern void +LLRP_ImpinjEnhancedIntegraReport_destruct ( + LLRP_tSImpinjEnhancedIntegraReport * pThis); + +extern void +LLRP_ImpinjEnhancedIntegraReport_decodeFields ( + LLRP_tSImpinjEnhancedIntegraReport * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjEnhancedIntegraReport_assimilateSubParameters ( + LLRP_tSImpinjEnhancedIntegraReport * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjEnhancedIntegraReport_encode ( + const LLRP_tSImpinjEnhancedIntegraReport *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjEnhancedIntegraReport_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjEnhancedIntegraReport_Result; + +extern LLRP_tEImpinjEnhancedIntegraResultType +LLRP_ImpinjEnhancedIntegraReport_getResult ( + LLRP_tSImpinjEnhancedIntegraReport *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjEnhancedIntegraReport_setResult ( + LLRP_tSImpinjEnhancedIntegraReport *pThis, + LLRP_tEImpinjEnhancedIntegraResultType Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjEnhancedIntegraReport_OpSpecID; + +extern llrp_u16_t +LLRP_ImpinjEnhancedIntegraReport_getOpSpecID ( + LLRP_tSImpinjEnhancedIntegraReport *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjEnhancedIntegraReport_setOpSpecID ( + LLRP_tSImpinjEnhancedIntegraReport *pThis, + llrp_u16_t Value); + + +extern LLRP_tSParameter * +LLRP_ImpinjEnhancedIntegraReport_beginCustom ( + LLRP_tSImpinjEnhancedIntegraReport *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjEnhancedIntegraReport_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjEnhancedIntegraReport_clearCustom ( + LLRP_tSImpinjEnhancedIntegraReport *pThis); + +extern int +LLRP_ImpinjEnhancedIntegraReport_countCustom ( + LLRP_tSImpinjEnhancedIntegraReport *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjEnhancedIntegraReport_addCustom ( + LLRP_tSImpinjEnhancedIntegraReport *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjEndpointICVerificationConfig +{ + LLRP_tSParameter hdr; + + LLRP_tEImpinjEndpointICVerificationMode eEndpointICVerificationMode; + + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjEndpointICVerificationConfig; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjEndpointICVerificationConfig[]; + +extern LLRP_tSImpinjEndpointICVerificationConfig * +LLRP_ImpinjEndpointICVerificationConfig_construct (void); + +extern void +LLRP_ImpinjEndpointICVerificationConfig_destruct ( + LLRP_tSImpinjEndpointICVerificationConfig * pThis); + +extern void +LLRP_ImpinjEndpointICVerificationConfig_decodeFields ( + LLRP_tSImpinjEndpointICVerificationConfig * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjEndpointICVerificationConfig_assimilateSubParameters ( + LLRP_tSImpinjEndpointICVerificationConfig * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjEndpointICVerificationConfig_encode ( + const LLRP_tSImpinjEndpointICVerificationConfig *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjEndpointICVerificationConfig_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjEndpointICVerificationConfig_EndpointICVerificationMode; + +extern LLRP_tEImpinjEndpointICVerificationMode +LLRP_ImpinjEndpointICVerificationConfig_getEndpointICVerificationMode ( + LLRP_tSImpinjEndpointICVerificationConfig *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjEndpointICVerificationConfig_setEndpointICVerificationMode ( + LLRP_tSImpinjEndpointICVerificationConfig *pThis, + LLRP_tEImpinjEndpointICVerificationMode Value); + + +extern LLRP_tSParameter * +LLRP_ImpinjEndpointICVerificationConfig_beginCustom ( + LLRP_tSImpinjEndpointICVerificationConfig *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjEndpointICVerificationConfig_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjEndpointICVerificationConfig_clearCustom ( + LLRP_tSImpinjEndpointICVerificationConfig *pThis); + +extern int +LLRP_ImpinjEndpointICVerificationConfig_countCustom ( + LLRP_tSImpinjEndpointICVerificationConfig *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjEndpointICVerificationConfig_addCustom ( + LLRP_tSImpinjEndpointICVerificationConfig *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjEnableEndpointICVerification +{ + LLRP_tSParameter hdr; + + LLRP_tEImpinjEndpointICVerificationReportMode eEndpointICVerificationReportMode; + + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjEnableEndpointICVerification; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjEnableEndpointICVerification[]; + +extern LLRP_tSImpinjEnableEndpointICVerification * +LLRP_ImpinjEnableEndpointICVerification_construct (void); + +extern void +LLRP_ImpinjEnableEndpointICVerification_destruct ( + LLRP_tSImpinjEnableEndpointICVerification * pThis); + +extern void +LLRP_ImpinjEnableEndpointICVerification_decodeFields ( + LLRP_tSImpinjEnableEndpointICVerification * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjEnableEndpointICVerification_assimilateSubParameters ( + LLRP_tSImpinjEnableEndpointICVerification * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjEnableEndpointICVerification_encode ( + const LLRP_tSImpinjEnableEndpointICVerification *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjEnableEndpointICVerification_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjEnableEndpointICVerification_EndpointICVerificationReportMode; + +extern LLRP_tEImpinjEndpointICVerificationReportMode +LLRP_ImpinjEnableEndpointICVerification_getEndpointICVerificationReportMode ( + LLRP_tSImpinjEnableEndpointICVerification *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjEnableEndpointICVerification_setEndpointICVerificationReportMode ( + LLRP_tSImpinjEnableEndpointICVerification *pThis, + LLRP_tEImpinjEndpointICVerificationReportMode Value); + + +extern LLRP_tSParameter * +LLRP_ImpinjEnableEndpointICVerification_beginCustom ( + LLRP_tSImpinjEnableEndpointICVerification *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjEnableEndpointICVerification_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjEnableEndpointICVerification_clearCustom ( + LLRP_tSImpinjEnableEndpointICVerification *pThis); + +extern int +LLRP_ImpinjEnableEndpointICVerification_countCustom ( + LLRP_tSImpinjEnableEndpointICVerification *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjEnableEndpointICVerification_addCustom ( + LLRP_tSImpinjEnableEndpointICVerification *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SImpinjEndpointICVerificationReport +{ + LLRP_tSParameter hdr; + + llrp_u8_t EndpointICVerificationOn; + + llrp_u8_t EndpointICIdentifier; + + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdImpinjEndpointICVerificationReport; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdImpinjEndpointICVerificationReport[]; + +extern LLRP_tSImpinjEndpointICVerificationReport * +LLRP_ImpinjEndpointICVerificationReport_construct (void); + +extern void +LLRP_ImpinjEndpointICVerificationReport_destruct ( + LLRP_tSImpinjEndpointICVerificationReport * pThis); + +extern void +LLRP_ImpinjEndpointICVerificationReport_decodeFields ( + LLRP_tSImpinjEndpointICVerificationReport * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ImpinjEndpointICVerificationReport_assimilateSubParameters ( + LLRP_tSImpinjEndpointICVerificationReport * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ImpinjEndpointICVerificationReport_encode ( + const LLRP_tSImpinjEndpointICVerificationReport *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + +extern llrp_bool_t +LLRP_ImpinjEndpointICVerificationReport_isAllowedIn ( + const LLRP_tSTypeDescriptor *pEnclosingElementType); + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjEndpointICVerificationReport_EndpointICVerificationOn; + +extern llrp_u8_t +LLRP_ImpinjEndpointICVerificationReport_getEndpointICVerificationOn ( + LLRP_tSImpinjEndpointICVerificationReport *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjEndpointICVerificationReport_setEndpointICVerificationOn ( + LLRP_tSImpinjEndpointICVerificationReport *pThis, + llrp_u8_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdImpinjEndpointICVerificationReport_EndpointICIdentifier; + +extern llrp_u8_t +LLRP_ImpinjEndpointICVerificationReport_getEndpointICIdentifier ( + LLRP_tSImpinjEndpointICVerificationReport *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjEndpointICVerificationReport_setEndpointICIdentifier ( + LLRP_tSImpinjEndpointICVerificationReport *pThis, + llrp_u8_t Value); + + +extern LLRP_tSParameter * +LLRP_ImpinjEndpointICVerificationReport_beginCustom ( + LLRP_tSImpinjEndpointICVerificationReport *pThis); + +extern LLRP_tSParameter * +LLRP_ImpinjEndpointICVerificationReport_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ImpinjEndpointICVerificationReport_clearCustom ( + LLRP_tSImpinjEndpointICVerificationReport *pThis); + +extern int +LLRP_ImpinjEndpointICVerificationReport_countCustom ( + LLRP_tSImpinjEndpointICVerificationReport *pThis); + +extern LLRP_tResultCode +LLRP_ImpinjEndpointICVerificationReport_addCustom ( + LLRP_tSImpinjEndpointICVerificationReport *pThis, + LLRP_tSParameter *pValue); + + + + + +void +LLRP_enrollImpinjTypesIntoRegistry ( + LLRP_tSTypeRegistry * pTypeRegistry); + diff --git a/vendor/libltkc/out_ltkc.h b/vendor/libltkc/out_ltkc.h new file mode 100644 index 0000000..ecbd000 --- /dev/null +++ b/vendor/libltkc/out_ltkc.h @@ -0,0 +1,13843 @@ + +/* + * Generated file - DO NOT EDIT + * + * This is the header file for the LLRP Tool Kit (LTK) + * C++ (aka cpp) implementation. It is generated into a .inc file + * that is included by a platform specific .h header file. + * That .h file takes care of prerequisites needed by this file. + */ + + + + +/* + * Message classes - forward decls + */ + +struct LLRP_SCUSTOM_MESSAGE; +typedef struct LLRP_SCUSTOM_MESSAGE + LLRP_tSCUSTOM_MESSAGE; + +struct LLRP_SGET_READER_CAPABILITIES; +typedef struct LLRP_SGET_READER_CAPABILITIES + LLRP_tSGET_READER_CAPABILITIES; + +struct LLRP_SGET_READER_CAPABILITIES_RESPONSE; +typedef struct LLRP_SGET_READER_CAPABILITIES_RESPONSE + LLRP_tSGET_READER_CAPABILITIES_RESPONSE; + +struct LLRP_SADD_ROSPEC; +typedef struct LLRP_SADD_ROSPEC + LLRP_tSADD_ROSPEC; + +struct LLRP_SADD_ROSPEC_RESPONSE; +typedef struct LLRP_SADD_ROSPEC_RESPONSE + LLRP_tSADD_ROSPEC_RESPONSE; + +struct LLRP_SDELETE_ROSPEC; +typedef struct LLRP_SDELETE_ROSPEC + LLRP_tSDELETE_ROSPEC; + +struct LLRP_SDELETE_ROSPEC_RESPONSE; +typedef struct LLRP_SDELETE_ROSPEC_RESPONSE + LLRP_tSDELETE_ROSPEC_RESPONSE; + +struct LLRP_SSTART_ROSPEC; +typedef struct LLRP_SSTART_ROSPEC + LLRP_tSSTART_ROSPEC; + +struct LLRP_SSTART_ROSPEC_RESPONSE; +typedef struct LLRP_SSTART_ROSPEC_RESPONSE + LLRP_tSSTART_ROSPEC_RESPONSE; + +struct LLRP_SSTOP_ROSPEC; +typedef struct LLRP_SSTOP_ROSPEC + LLRP_tSSTOP_ROSPEC; + +struct LLRP_SSTOP_ROSPEC_RESPONSE; +typedef struct LLRP_SSTOP_ROSPEC_RESPONSE + LLRP_tSSTOP_ROSPEC_RESPONSE; + +struct LLRP_SENABLE_ROSPEC; +typedef struct LLRP_SENABLE_ROSPEC + LLRP_tSENABLE_ROSPEC; + +struct LLRP_SENABLE_ROSPEC_RESPONSE; +typedef struct LLRP_SENABLE_ROSPEC_RESPONSE + LLRP_tSENABLE_ROSPEC_RESPONSE; + +struct LLRP_SDISABLE_ROSPEC; +typedef struct LLRP_SDISABLE_ROSPEC + LLRP_tSDISABLE_ROSPEC; + +struct LLRP_SDISABLE_ROSPEC_RESPONSE; +typedef struct LLRP_SDISABLE_ROSPEC_RESPONSE + LLRP_tSDISABLE_ROSPEC_RESPONSE; + +struct LLRP_SGET_ROSPECS; +typedef struct LLRP_SGET_ROSPECS + LLRP_tSGET_ROSPECS; + +struct LLRP_SGET_ROSPECS_RESPONSE; +typedef struct LLRP_SGET_ROSPECS_RESPONSE + LLRP_tSGET_ROSPECS_RESPONSE; + +struct LLRP_SADD_ACCESSSPEC; +typedef struct LLRP_SADD_ACCESSSPEC + LLRP_tSADD_ACCESSSPEC; + +struct LLRP_SADD_ACCESSSPEC_RESPONSE; +typedef struct LLRP_SADD_ACCESSSPEC_RESPONSE + LLRP_tSADD_ACCESSSPEC_RESPONSE; + +struct LLRP_SDELETE_ACCESSSPEC; +typedef struct LLRP_SDELETE_ACCESSSPEC + LLRP_tSDELETE_ACCESSSPEC; + +struct LLRP_SDELETE_ACCESSSPEC_RESPONSE; +typedef struct LLRP_SDELETE_ACCESSSPEC_RESPONSE + LLRP_tSDELETE_ACCESSSPEC_RESPONSE; + +struct LLRP_SENABLE_ACCESSSPEC; +typedef struct LLRP_SENABLE_ACCESSSPEC + LLRP_tSENABLE_ACCESSSPEC; + +struct LLRP_SENABLE_ACCESSSPEC_RESPONSE; +typedef struct LLRP_SENABLE_ACCESSSPEC_RESPONSE + LLRP_tSENABLE_ACCESSSPEC_RESPONSE; + +struct LLRP_SDISABLE_ACCESSSPEC; +typedef struct LLRP_SDISABLE_ACCESSSPEC + LLRP_tSDISABLE_ACCESSSPEC; + +struct LLRP_SDISABLE_ACCESSSPEC_RESPONSE; +typedef struct LLRP_SDISABLE_ACCESSSPEC_RESPONSE + LLRP_tSDISABLE_ACCESSSPEC_RESPONSE; + +struct LLRP_SGET_ACCESSSPECS; +typedef struct LLRP_SGET_ACCESSSPECS + LLRP_tSGET_ACCESSSPECS; + +struct LLRP_SGET_ACCESSSPECS_RESPONSE; +typedef struct LLRP_SGET_ACCESSSPECS_RESPONSE + LLRP_tSGET_ACCESSSPECS_RESPONSE; + +struct LLRP_SCLIENT_REQUEST_OP; +typedef struct LLRP_SCLIENT_REQUEST_OP + LLRP_tSCLIENT_REQUEST_OP; + +struct LLRP_SCLIENT_REQUEST_OP_RESPONSE; +typedef struct LLRP_SCLIENT_REQUEST_OP_RESPONSE + LLRP_tSCLIENT_REQUEST_OP_RESPONSE; + +struct LLRP_SGET_READER_CONFIG; +typedef struct LLRP_SGET_READER_CONFIG + LLRP_tSGET_READER_CONFIG; + +struct LLRP_SGET_READER_CONFIG_RESPONSE; +typedef struct LLRP_SGET_READER_CONFIG_RESPONSE + LLRP_tSGET_READER_CONFIG_RESPONSE; + +struct LLRP_SSET_READER_CONFIG; +typedef struct LLRP_SSET_READER_CONFIG + LLRP_tSSET_READER_CONFIG; + +struct LLRP_SSET_READER_CONFIG_RESPONSE; +typedef struct LLRP_SSET_READER_CONFIG_RESPONSE + LLRP_tSSET_READER_CONFIG_RESPONSE; + +struct LLRP_SCLOSE_CONNECTION; +typedef struct LLRP_SCLOSE_CONNECTION + LLRP_tSCLOSE_CONNECTION; + +struct LLRP_SCLOSE_CONNECTION_RESPONSE; +typedef struct LLRP_SCLOSE_CONNECTION_RESPONSE + LLRP_tSCLOSE_CONNECTION_RESPONSE; + +struct LLRP_SGET_REPORT; +typedef struct LLRP_SGET_REPORT + LLRP_tSGET_REPORT; + +struct LLRP_SRO_ACCESS_REPORT; +typedef struct LLRP_SRO_ACCESS_REPORT + LLRP_tSRO_ACCESS_REPORT; + +struct LLRP_SKEEPALIVE; +typedef struct LLRP_SKEEPALIVE + LLRP_tSKEEPALIVE; + +struct LLRP_SKEEPALIVE_ACK; +typedef struct LLRP_SKEEPALIVE_ACK + LLRP_tSKEEPALIVE_ACK; + +struct LLRP_SREADER_EVENT_NOTIFICATION; +typedef struct LLRP_SREADER_EVENT_NOTIFICATION + LLRP_tSREADER_EVENT_NOTIFICATION; + +struct LLRP_SENABLE_EVENTS_AND_REPORTS; +typedef struct LLRP_SENABLE_EVENTS_AND_REPORTS + LLRP_tSENABLE_EVENTS_AND_REPORTS; + +struct LLRP_SERROR_MESSAGE; +typedef struct LLRP_SERROR_MESSAGE + LLRP_tSERROR_MESSAGE; + + +/* Custom messages */ + + +/* + * Parameter classes - forward decls + */ + +struct LLRP_SUTCTimestamp; +typedef struct LLRP_SUTCTimestamp + LLRP_tSUTCTimestamp; + +struct LLRP_SUptime; +typedef struct LLRP_SUptime + LLRP_tSUptime; + +struct LLRP_SCustom; +typedef struct LLRP_SCustom + LLRP_tSCustom; + +struct LLRP_SGeneralDeviceCapabilities; +typedef struct LLRP_SGeneralDeviceCapabilities + LLRP_tSGeneralDeviceCapabilities; + +struct LLRP_SReceiveSensitivityTableEntry; +typedef struct LLRP_SReceiveSensitivityTableEntry + LLRP_tSReceiveSensitivityTableEntry; + +struct LLRP_SPerAntennaReceiveSensitivityRange; +typedef struct LLRP_SPerAntennaReceiveSensitivityRange + LLRP_tSPerAntennaReceiveSensitivityRange; + +struct LLRP_SPerAntennaAirProtocol; +typedef struct LLRP_SPerAntennaAirProtocol + LLRP_tSPerAntennaAirProtocol; + +struct LLRP_SGPIOCapabilities; +typedef struct LLRP_SGPIOCapabilities + LLRP_tSGPIOCapabilities; + +struct LLRP_SLLRPCapabilities; +typedef struct LLRP_SLLRPCapabilities + LLRP_tSLLRPCapabilities; + +struct LLRP_SRegulatoryCapabilities; +typedef struct LLRP_SRegulatoryCapabilities + LLRP_tSRegulatoryCapabilities; + +struct LLRP_SUHFBandCapabilities; +typedef struct LLRP_SUHFBandCapabilities + LLRP_tSUHFBandCapabilities; + +struct LLRP_STransmitPowerLevelTableEntry; +typedef struct LLRP_STransmitPowerLevelTableEntry + LLRP_tSTransmitPowerLevelTableEntry; + +struct LLRP_SFrequencyInformation; +typedef struct LLRP_SFrequencyInformation + LLRP_tSFrequencyInformation; + +struct LLRP_SFrequencyHopTable; +typedef struct LLRP_SFrequencyHopTable + LLRP_tSFrequencyHopTable; + +struct LLRP_SFixedFrequencyTable; +typedef struct LLRP_SFixedFrequencyTable + LLRP_tSFixedFrequencyTable; + +struct LLRP_SROSpec; +typedef struct LLRP_SROSpec + LLRP_tSROSpec; + +struct LLRP_SROBoundarySpec; +typedef struct LLRP_SROBoundarySpec + LLRP_tSROBoundarySpec; + +struct LLRP_SROSpecStartTrigger; +typedef struct LLRP_SROSpecStartTrigger + LLRP_tSROSpecStartTrigger; + +struct LLRP_SPeriodicTriggerValue; +typedef struct LLRP_SPeriodicTriggerValue + LLRP_tSPeriodicTriggerValue; + +struct LLRP_SGPITriggerValue; +typedef struct LLRP_SGPITriggerValue + LLRP_tSGPITriggerValue; + +struct LLRP_SROSpecStopTrigger; +typedef struct LLRP_SROSpecStopTrigger + LLRP_tSROSpecStopTrigger; + +struct LLRP_SAISpec; +typedef struct LLRP_SAISpec + LLRP_tSAISpec; + +struct LLRP_SAISpecStopTrigger; +typedef struct LLRP_SAISpecStopTrigger + LLRP_tSAISpecStopTrigger; + +struct LLRP_STagObservationTrigger; +typedef struct LLRP_STagObservationTrigger + LLRP_tSTagObservationTrigger; + +struct LLRP_SInventoryParameterSpec; +typedef struct LLRP_SInventoryParameterSpec + LLRP_tSInventoryParameterSpec; + +struct LLRP_SRFSurveySpec; +typedef struct LLRP_SRFSurveySpec + LLRP_tSRFSurveySpec; + +struct LLRP_SRFSurveySpecStopTrigger; +typedef struct LLRP_SRFSurveySpecStopTrigger + LLRP_tSRFSurveySpecStopTrigger; + +struct LLRP_SAccessSpec; +typedef struct LLRP_SAccessSpec + LLRP_tSAccessSpec; + +struct LLRP_SAccessSpecStopTrigger; +typedef struct LLRP_SAccessSpecStopTrigger + LLRP_tSAccessSpecStopTrigger; + +struct LLRP_SAccessCommand; +typedef struct LLRP_SAccessCommand + LLRP_tSAccessCommand; + +struct LLRP_SClientRequestOpSpec; +typedef struct LLRP_SClientRequestOpSpec + LLRP_tSClientRequestOpSpec; + +struct LLRP_SClientRequestResponse; +typedef struct LLRP_SClientRequestResponse + LLRP_tSClientRequestResponse; + +struct LLRP_SLLRPConfigurationStateValue; +typedef struct LLRP_SLLRPConfigurationStateValue + LLRP_tSLLRPConfigurationStateValue; + +struct LLRP_SIdentification; +typedef struct LLRP_SIdentification + LLRP_tSIdentification; + +struct LLRP_SGPOWriteData; +typedef struct LLRP_SGPOWriteData + LLRP_tSGPOWriteData; + +struct LLRP_SKeepaliveSpec; +typedef struct LLRP_SKeepaliveSpec + LLRP_tSKeepaliveSpec; + +struct LLRP_SAntennaProperties; +typedef struct LLRP_SAntennaProperties + LLRP_tSAntennaProperties; + +struct LLRP_SAntennaConfiguration; +typedef struct LLRP_SAntennaConfiguration + LLRP_tSAntennaConfiguration; + +struct LLRP_SRFReceiver; +typedef struct LLRP_SRFReceiver + LLRP_tSRFReceiver; + +struct LLRP_SRFTransmitter; +typedef struct LLRP_SRFTransmitter + LLRP_tSRFTransmitter; + +struct LLRP_SGPIPortCurrentState; +typedef struct LLRP_SGPIPortCurrentState + LLRP_tSGPIPortCurrentState; + +struct LLRP_SEventsAndReports; +typedef struct LLRP_SEventsAndReports + LLRP_tSEventsAndReports; + +struct LLRP_SROReportSpec; +typedef struct LLRP_SROReportSpec + LLRP_tSROReportSpec; + +struct LLRP_STagReportContentSelector; +typedef struct LLRP_STagReportContentSelector + LLRP_tSTagReportContentSelector; + +struct LLRP_SAccessReportSpec; +typedef struct LLRP_SAccessReportSpec + LLRP_tSAccessReportSpec; + +struct LLRP_STagReportData; +typedef struct LLRP_STagReportData + LLRP_tSTagReportData; + +struct LLRP_SEPCData; +typedef struct LLRP_SEPCData + LLRP_tSEPCData; + +struct LLRP_SEPC_96; +typedef struct LLRP_SEPC_96 + LLRP_tSEPC_96; + +struct LLRP_SROSpecID; +typedef struct LLRP_SROSpecID + LLRP_tSROSpecID; + +struct LLRP_SSpecIndex; +typedef struct LLRP_SSpecIndex + LLRP_tSSpecIndex; + +struct LLRP_SInventoryParameterSpecID; +typedef struct LLRP_SInventoryParameterSpecID + LLRP_tSInventoryParameterSpecID; + +struct LLRP_SAntennaID; +typedef struct LLRP_SAntennaID + LLRP_tSAntennaID; + +struct LLRP_SPeakRSSI; +typedef struct LLRP_SPeakRSSI + LLRP_tSPeakRSSI; + +struct LLRP_SChannelIndex; +typedef struct LLRP_SChannelIndex + LLRP_tSChannelIndex; + +struct LLRP_SFirstSeenTimestampUTC; +typedef struct LLRP_SFirstSeenTimestampUTC + LLRP_tSFirstSeenTimestampUTC; + +struct LLRP_SFirstSeenTimestampUptime; +typedef struct LLRP_SFirstSeenTimestampUptime + LLRP_tSFirstSeenTimestampUptime; + +struct LLRP_SLastSeenTimestampUTC; +typedef struct LLRP_SLastSeenTimestampUTC + LLRP_tSLastSeenTimestampUTC; + +struct LLRP_SLastSeenTimestampUptime; +typedef struct LLRP_SLastSeenTimestampUptime + LLRP_tSLastSeenTimestampUptime; + +struct LLRP_STagSeenCount; +typedef struct LLRP_STagSeenCount + LLRP_tSTagSeenCount; + +struct LLRP_SClientRequestOpSpecResult; +typedef struct LLRP_SClientRequestOpSpecResult + LLRP_tSClientRequestOpSpecResult; + +struct LLRP_SAccessSpecID; +typedef struct LLRP_SAccessSpecID + LLRP_tSAccessSpecID; + +struct LLRP_SRFSurveyReportData; +typedef struct LLRP_SRFSurveyReportData + LLRP_tSRFSurveyReportData; + +struct LLRP_SFrequencyRSSILevelEntry; +typedef struct LLRP_SFrequencyRSSILevelEntry + LLRP_tSFrequencyRSSILevelEntry; + +struct LLRP_SReaderEventNotificationSpec; +typedef struct LLRP_SReaderEventNotificationSpec + LLRP_tSReaderEventNotificationSpec; + +struct LLRP_SEventNotificationState; +typedef struct LLRP_SEventNotificationState + LLRP_tSEventNotificationState; + +struct LLRP_SReaderEventNotificationData; +typedef struct LLRP_SReaderEventNotificationData + LLRP_tSReaderEventNotificationData; + +struct LLRP_SHoppingEvent; +typedef struct LLRP_SHoppingEvent + LLRP_tSHoppingEvent; + +struct LLRP_SGPIEvent; +typedef struct LLRP_SGPIEvent + LLRP_tSGPIEvent; + +struct LLRP_SROSpecEvent; +typedef struct LLRP_SROSpecEvent + LLRP_tSROSpecEvent; + +struct LLRP_SReportBufferLevelWarningEvent; +typedef struct LLRP_SReportBufferLevelWarningEvent + LLRP_tSReportBufferLevelWarningEvent; + +struct LLRP_SReportBufferOverflowErrorEvent; +typedef struct LLRP_SReportBufferOverflowErrorEvent + LLRP_tSReportBufferOverflowErrorEvent; + +struct LLRP_SReaderExceptionEvent; +typedef struct LLRP_SReaderExceptionEvent + LLRP_tSReaderExceptionEvent; + +struct LLRP_SOpSpecID; +typedef struct LLRP_SOpSpecID + LLRP_tSOpSpecID; + +struct LLRP_SRFSurveyEvent; +typedef struct LLRP_SRFSurveyEvent + LLRP_tSRFSurveyEvent; + +struct LLRP_SAISpecEvent; +typedef struct LLRP_SAISpecEvent + LLRP_tSAISpecEvent; + +struct LLRP_SAntennaEvent; +typedef struct LLRP_SAntennaEvent + LLRP_tSAntennaEvent; + +struct LLRP_SConnectionAttemptEvent; +typedef struct LLRP_SConnectionAttemptEvent + LLRP_tSConnectionAttemptEvent; + +struct LLRP_SConnectionCloseEvent; +typedef struct LLRP_SConnectionCloseEvent + LLRP_tSConnectionCloseEvent; + +struct LLRP_SLLRPStatus; +typedef struct LLRP_SLLRPStatus + LLRP_tSLLRPStatus; + +struct LLRP_SFieldError; +typedef struct LLRP_SFieldError + LLRP_tSFieldError; + +struct LLRP_SParameterError; +typedef struct LLRP_SParameterError + LLRP_tSParameterError; + +struct LLRP_SC1G2LLRPCapabilities; +typedef struct LLRP_SC1G2LLRPCapabilities + LLRP_tSC1G2LLRPCapabilities; + +struct LLRP_SC1G2UHFRFModeTable; +typedef struct LLRP_SC1G2UHFRFModeTable + LLRP_tSC1G2UHFRFModeTable; + +struct LLRP_SC1G2UHFRFModeTableEntry; +typedef struct LLRP_SC1G2UHFRFModeTableEntry + LLRP_tSC1G2UHFRFModeTableEntry; + +struct LLRP_SC1G2InventoryCommand; +typedef struct LLRP_SC1G2InventoryCommand + LLRP_tSC1G2InventoryCommand; + +struct LLRP_SC1G2Filter; +typedef struct LLRP_SC1G2Filter + LLRP_tSC1G2Filter; + +struct LLRP_SC1G2TagInventoryMask; +typedef struct LLRP_SC1G2TagInventoryMask + LLRP_tSC1G2TagInventoryMask; + +struct LLRP_SC1G2TagInventoryStateAwareFilterAction; +typedef struct LLRP_SC1G2TagInventoryStateAwareFilterAction + LLRP_tSC1G2TagInventoryStateAwareFilterAction; + +struct LLRP_SC1G2TagInventoryStateUnawareFilterAction; +typedef struct LLRP_SC1G2TagInventoryStateUnawareFilterAction + LLRP_tSC1G2TagInventoryStateUnawareFilterAction; + +struct LLRP_SC1G2RFControl; +typedef struct LLRP_SC1G2RFControl + LLRP_tSC1G2RFControl; + +struct LLRP_SC1G2SingulationControl; +typedef struct LLRP_SC1G2SingulationControl + LLRP_tSC1G2SingulationControl; + +struct LLRP_SC1G2TagInventoryStateAwareSingulationAction; +typedef struct LLRP_SC1G2TagInventoryStateAwareSingulationAction + LLRP_tSC1G2TagInventoryStateAwareSingulationAction; + +struct LLRP_SC1G2TagSpec; +typedef struct LLRP_SC1G2TagSpec + LLRP_tSC1G2TagSpec; + +struct LLRP_SC1G2TargetTag; +typedef struct LLRP_SC1G2TargetTag + LLRP_tSC1G2TargetTag; + +struct LLRP_SC1G2Read; +typedef struct LLRP_SC1G2Read + LLRP_tSC1G2Read; + +struct LLRP_SC1G2Write; +typedef struct LLRP_SC1G2Write + LLRP_tSC1G2Write; + +struct LLRP_SC1G2Kill; +typedef struct LLRP_SC1G2Kill + LLRP_tSC1G2Kill; + +struct LLRP_SC1G2Lock; +typedef struct LLRP_SC1G2Lock + LLRP_tSC1G2Lock; + +struct LLRP_SC1G2LockPayload; +typedef struct LLRP_SC1G2LockPayload + LLRP_tSC1G2LockPayload; + +struct LLRP_SC1G2BlockErase; +typedef struct LLRP_SC1G2BlockErase + LLRP_tSC1G2BlockErase; + +struct LLRP_SC1G2BlockWrite; +typedef struct LLRP_SC1G2BlockWrite + LLRP_tSC1G2BlockWrite; + +struct LLRP_SC1G2EPCMemorySelector; +typedef struct LLRP_SC1G2EPCMemorySelector + LLRP_tSC1G2EPCMemorySelector; + +struct LLRP_SC1G2_PC; +typedef struct LLRP_SC1G2_PC + LLRP_tSC1G2_PC; + +struct LLRP_SC1G2_CRC; +typedef struct LLRP_SC1G2_CRC + LLRP_tSC1G2_CRC; + +struct LLRP_SC1G2SingulationDetails; +typedef struct LLRP_SC1G2SingulationDetails + LLRP_tSC1G2SingulationDetails; + +struct LLRP_SC1G2ReadOpSpecResult; +typedef struct LLRP_SC1G2ReadOpSpecResult + LLRP_tSC1G2ReadOpSpecResult; + +struct LLRP_SC1G2WriteOpSpecResult; +typedef struct LLRP_SC1G2WriteOpSpecResult + LLRP_tSC1G2WriteOpSpecResult; + +struct LLRP_SC1G2KillOpSpecResult; +typedef struct LLRP_SC1G2KillOpSpecResult + LLRP_tSC1G2KillOpSpecResult; + +struct LLRP_SC1G2LockOpSpecResult; +typedef struct LLRP_SC1G2LockOpSpecResult + LLRP_tSC1G2LockOpSpecResult; + +struct LLRP_SC1G2BlockEraseOpSpecResult; +typedef struct LLRP_SC1G2BlockEraseOpSpecResult + LLRP_tSC1G2BlockEraseOpSpecResult; + +struct LLRP_SC1G2BlockWriteOpSpecResult; +typedef struct LLRP_SC1G2BlockWriteOpSpecResult + LLRP_tSC1G2BlockWriteOpSpecResult; + + +/* Custom parameters */ + + +/* + * Vendor descriptor declarations. + */ + + +/* + * Namespace descriptor declarations. + */ + +extern const LLRP_tSNamespaceDescriptor +LLRP_nsdescllrp; + + +/* + * Enumeration definitions and declarations of + * enumeration string tables. + */ + + +enum LLRP_EAirProtocols +{ + + LLRP_AirProtocols_Unspecified = 0, + LLRP_AirProtocols_EPCGlobalClass1Gen2 = 1, +}; + +typedef enum LLRP_EAirProtocols + LLRP_tEAirProtocols; + +extern const LLRP_tSEnumTableEntry +LLRP_estAirProtocols[]; + + +enum LLRP_EGetReaderCapabilitiesRequestedData +{ + + LLRP_GetReaderCapabilitiesRequestedData_All = 0, + LLRP_GetReaderCapabilitiesRequestedData_General_Device_Capabilities = 1, + LLRP_GetReaderCapabilitiesRequestedData_LLRP_Capabilities = 2, + LLRP_GetReaderCapabilitiesRequestedData_Regulatory_Capabilities = 3, + LLRP_GetReaderCapabilitiesRequestedData_LLRP_Air_Protocol_Capabilities = 4, +}; + +typedef enum LLRP_EGetReaderCapabilitiesRequestedData + LLRP_tEGetReaderCapabilitiesRequestedData; + +extern const LLRP_tSEnumTableEntry +LLRP_estGetReaderCapabilitiesRequestedData[]; + + +enum LLRP_ECommunicationsStandard +{ + + LLRP_CommunicationsStandard_Unspecified = 0, + LLRP_CommunicationsStandard_US_FCC_Part_15 = 1, + LLRP_CommunicationsStandard_ETSI_302_208 = 2, + LLRP_CommunicationsStandard_ETSI_300_220 = 3, + LLRP_CommunicationsStandard_Australia_LIPD_1W = 4, + LLRP_CommunicationsStandard_Australia_LIPD_4W = 5, + LLRP_CommunicationsStandard_Japan_ARIB_STD_T89 = 6, + LLRP_CommunicationsStandard_Hong_Kong_OFTA_1049 = 7, + LLRP_CommunicationsStandard_Taiwan_DGT_LP0002 = 8, + LLRP_CommunicationsStandard_Korea_MIC_Article_5_2 = 9, +}; + +typedef enum LLRP_ECommunicationsStandard + LLRP_tECommunicationsStandard; + +extern const LLRP_tSEnumTableEntry +LLRP_estCommunicationsStandard[]; + + +enum LLRP_EROSpecState +{ + + LLRP_ROSpecState_Disabled = 0, + LLRP_ROSpecState_Inactive = 1, + LLRP_ROSpecState_Active = 2, +}; + +typedef enum LLRP_EROSpecState + LLRP_tEROSpecState; + +extern const LLRP_tSEnumTableEntry +LLRP_estROSpecState[]; + + +enum LLRP_EROSpecStartTriggerType +{ + + LLRP_ROSpecStartTriggerType_Null = 0, + LLRP_ROSpecStartTriggerType_Immediate = 1, + LLRP_ROSpecStartTriggerType_Periodic = 2, + LLRP_ROSpecStartTriggerType_GPI = 3, +}; + +typedef enum LLRP_EROSpecStartTriggerType + LLRP_tEROSpecStartTriggerType; + +extern const LLRP_tSEnumTableEntry +LLRP_estROSpecStartTriggerType[]; + + +enum LLRP_EROSpecStopTriggerType +{ + + LLRP_ROSpecStopTriggerType_Null = 0, + LLRP_ROSpecStopTriggerType_Duration = 1, + LLRP_ROSpecStopTriggerType_GPI_With_Timeout = 2, +}; + +typedef enum LLRP_EROSpecStopTriggerType + LLRP_tEROSpecStopTriggerType; + +extern const LLRP_tSEnumTableEntry +LLRP_estROSpecStopTriggerType[]; + + +enum LLRP_EAISpecStopTriggerType +{ + + LLRP_AISpecStopTriggerType_Null = 0, + LLRP_AISpecStopTriggerType_Duration = 1, + LLRP_AISpecStopTriggerType_GPI_With_Timeout = 2, + LLRP_AISpecStopTriggerType_Tag_Observation = 3, +}; + +typedef enum LLRP_EAISpecStopTriggerType + LLRP_tEAISpecStopTriggerType; + +extern const LLRP_tSEnumTableEntry +LLRP_estAISpecStopTriggerType[]; + + +enum LLRP_ETagObservationTriggerType +{ + + LLRP_TagObservationTriggerType_Upon_Seeing_N_Tags_Or_Timeout = 0, + LLRP_TagObservationTriggerType_Upon_Seeing_No_More_New_Tags_For_Tms_Or_Timeout = 1, + LLRP_TagObservationTriggerType_N_Attempts_To_See_All_Tags_In_FOV_Or_Timeout = 2, +}; + +typedef enum LLRP_ETagObservationTriggerType + LLRP_tETagObservationTriggerType; + +extern const LLRP_tSEnumTableEntry +LLRP_estTagObservationTriggerType[]; + + +enum LLRP_ERFSurveySpecStopTriggerType +{ + + LLRP_RFSurveySpecStopTriggerType_Null = 0, + LLRP_RFSurveySpecStopTriggerType_Duration = 1, + LLRP_RFSurveySpecStopTriggerType_N_Iterations_Through_Frequency_Range = 2, +}; + +typedef enum LLRP_ERFSurveySpecStopTriggerType + LLRP_tERFSurveySpecStopTriggerType; + +extern const LLRP_tSEnumTableEntry +LLRP_estRFSurveySpecStopTriggerType[]; + + +enum LLRP_EAccessSpecState +{ + + LLRP_AccessSpecState_Disabled = 0, + LLRP_AccessSpecState_Active = 1, +}; + +typedef enum LLRP_EAccessSpecState + LLRP_tEAccessSpecState; + +extern const LLRP_tSEnumTableEntry +LLRP_estAccessSpecState[]; + + +enum LLRP_EAccessSpecStopTriggerType +{ + + LLRP_AccessSpecStopTriggerType_Null = 0, + LLRP_AccessSpecStopTriggerType_Operation_Count = 1, +}; + +typedef enum LLRP_EAccessSpecStopTriggerType + LLRP_tEAccessSpecStopTriggerType; + +extern const LLRP_tSEnumTableEntry +LLRP_estAccessSpecStopTriggerType[]; + + +enum LLRP_EGetReaderConfigRequestedData +{ + + LLRP_GetReaderConfigRequestedData_All = 0, + LLRP_GetReaderConfigRequestedData_Identification = 1, + LLRP_GetReaderConfigRequestedData_AntennaProperties = 2, + LLRP_GetReaderConfigRequestedData_AntennaConfiguration = 3, + LLRP_GetReaderConfigRequestedData_ROReportSpec = 4, + LLRP_GetReaderConfigRequestedData_ReaderEventNotificationSpec = 5, + LLRP_GetReaderConfigRequestedData_AccessReportSpec = 6, + LLRP_GetReaderConfigRequestedData_LLRPConfigurationStateValue = 7, + LLRP_GetReaderConfigRequestedData_KeepaliveSpec = 8, + LLRP_GetReaderConfigRequestedData_GPIPortCurrentState = 9, + LLRP_GetReaderConfigRequestedData_GPOWriteData = 10, + LLRP_GetReaderConfigRequestedData_EventsAndReports = 11, +}; + +typedef enum LLRP_EGetReaderConfigRequestedData + LLRP_tEGetReaderConfigRequestedData; + +extern const LLRP_tSEnumTableEntry +LLRP_estGetReaderConfigRequestedData[]; + + +enum LLRP_EIdentificationType +{ + + LLRP_IdentificationType_MAC_Address = 0, + LLRP_IdentificationType_EPC = 1, +}; + +typedef enum LLRP_EIdentificationType + LLRP_tEIdentificationType; + +extern const LLRP_tSEnumTableEntry +LLRP_estIdentificationType[]; + + +enum LLRP_EKeepaliveTriggerType +{ + + LLRP_KeepaliveTriggerType_Null = 0, + LLRP_KeepaliveTriggerType_Periodic = 1, +}; + +typedef enum LLRP_EKeepaliveTriggerType + LLRP_tEKeepaliveTriggerType; + +extern const LLRP_tSEnumTableEntry +LLRP_estKeepaliveTriggerType[]; + + +enum LLRP_EGPIPortState +{ + + LLRP_GPIPortState_Low = 0, + LLRP_GPIPortState_High = 1, + LLRP_GPIPortState_Unknown = 2, +}; + +typedef enum LLRP_EGPIPortState + LLRP_tEGPIPortState; + +extern const LLRP_tSEnumTableEntry +LLRP_estGPIPortState[]; + + +enum LLRP_EROReportTriggerType +{ + + LLRP_ROReportTriggerType_None = 0, + LLRP_ROReportTriggerType_Upon_N_Tags_Or_End_Of_AISpec = 1, + LLRP_ROReportTriggerType_Upon_N_Tags_Or_End_Of_ROSpec = 2, +}; + +typedef enum LLRP_EROReportTriggerType + LLRP_tEROReportTriggerType; + +extern const LLRP_tSEnumTableEntry +LLRP_estROReportTriggerType[]; + + +enum LLRP_EAccessReportTriggerType +{ + + LLRP_AccessReportTriggerType_Whenever_ROReport_Is_Generated = 0, + LLRP_AccessReportTriggerType_End_Of_AccessSpec = 1, +}; + +typedef enum LLRP_EAccessReportTriggerType + LLRP_tEAccessReportTriggerType; + +extern const LLRP_tSEnumTableEntry +LLRP_estAccessReportTriggerType[]; + + +enum LLRP_ENotificationEventType +{ + + LLRP_NotificationEventType_Upon_Hopping_To_Next_Channel = 0, + LLRP_NotificationEventType_GPI_Event = 1, + LLRP_NotificationEventType_ROSpec_Event = 2, + LLRP_NotificationEventType_Report_Buffer_Fill_Warning = 3, + LLRP_NotificationEventType_Reader_Exception_Event = 4, + LLRP_NotificationEventType_RFSurvey_Event = 5, + LLRP_NotificationEventType_AISpec_Event = 6, + LLRP_NotificationEventType_AISpec_Event_With_Details = 7, + LLRP_NotificationEventType_Antenna_Event = 8, +}; + +typedef enum LLRP_ENotificationEventType + LLRP_tENotificationEventType; + +extern const LLRP_tSEnumTableEntry +LLRP_estNotificationEventType[]; + + +enum LLRP_EROSpecEventType +{ + + LLRP_ROSpecEventType_Start_Of_ROSpec = 0, + LLRP_ROSpecEventType_End_Of_ROSpec = 1, + LLRP_ROSpecEventType_Preemption_Of_ROSpec = 2, +}; + +typedef enum LLRP_EROSpecEventType + LLRP_tEROSpecEventType; + +extern const LLRP_tSEnumTableEntry +LLRP_estROSpecEventType[]; + + +enum LLRP_ERFSurveyEventType +{ + + LLRP_RFSurveyEventType_Start_Of_RFSurvey = 0, + LLRP_RFSurveyEventType_End_Of_RFSurvey = 1, +}; + +typedef enum LLRP_ERFSurveyEventType + LLRP_tERFSurveyEventType; + +extern const LLRP_tSEnumTableEntry +LLRP_estRFSurveyEventType[]; + + +enum LLRP_EAISpecEventType +{ + + LLRP_AISpecEventType_End_Of_AISpec = 0, +}; + +typedef enum LLRP_EAISpecEventType + LLRP_tEAISpecEventType; + +extern const LLRP_tSEnumTableEntry +LLRP_estAISpecEventType[]; + + +enum LLRP_EAntennaEventType +{ + + LLRP_AntennaEventType_Antenna_Disconnected = 0, + LLRP_AntennaEventType_Antenna_Connected = 1, +}; + +typedef enum LLRP_EAntennaEventType + LLRP_tEAntennaEventType; + +extern const LLRP_tSEnumTableEntry +LLRP_estAntennaEventType[]; + + +enum LLRP_EConnectionAttemptStatusType +{ + + LLRP_ConnectionAttemptStatusType_Success = 0, + LLRP_ConnectionAttemptStatusType_Failed_A_Reader_Initiated_Connection_Already_Exists = 1, + LLRP_ConnectionAttemptStatusType_Failed_A_Client_Initiated_Connection_Already_Exists = 2, + LLRP_ConnectionAttemptStatusType_Failed_Reason_Other_Than_A_Connection_Already_Exists = 3, + LLRP_ConnectionAttemptStatusType_Another_Connection_Attempted = 4, +}; + +typedef enum LLRP_EConnectionAttemptStatusType + LLRP_tEConnectionAttemptStatusType; + +extern const LLRP_tSEnumTableEntry +LLRP_estConnectionAttemptStatusType[]; + + +enum LLRP_EStatusCode +{ + + LLRP_StatusCode_M_Success = 0, + LLRP_StatusCode_M_ParameterError = 100, + LLRP_StatusCode_M_FieldError = 101, + LLRP_StatusCode_M_UnexpectedParameter = 102, + LLRP_StatusCode_M_MissingParameter = 103, + LLRP_StatusCode_M_DuplicateParameter = 104, + LLRP_StatusCode_M_OverflowParameter = 105, + LLRP_StatusCode_M_OverflowField = 106, + LLRP_StatusCode_M_UnknownParameter = 107, + LLRP_StatusCode_M_UnknownField = 108, + LLRP_StatusCode_M_UnsupportedMessage = 109, + LLRP_StatusCode_M_UnsupportedVersion = 110, + LLRP_StatusCode_M_UnsupportedParameter = 111, + LLRP_StatusCode_P_ParameterError = 200, + LLRP_StatusCode_P_FieldError = 201, + LLRP_StatusCode_P_UnexpectedParameter = 202, + LLRP_StatusCode_P_MissingParameter = 203, + LLRP_StatusCode_P_DuplicateParameter = 204, + LLRP_StatusCode_P_OverflowParameter = 205, + LLRP_StatusCode_P_OverflowField = 206, + LLRP_StatusCode_P_UnknownParameter = 207, + LLRP_StatusCode_P_UnknownField = 208, + LLRP_StatusCode_P_UnsupportedParameter = 209, + LLRP_StatusCode_A_Invalid = 300, + LLRP_StatusCode_A_OutOfRange = 301, + LLRP_StatusCode_R_DeviceError = 401, +}; + +typedef enum LLRP_EStatusCode + LLRP_tEStatusCode; + +extern const LLRP_tSEnumTableEntry +LLRP_estStatusCode[]; + + +enum LLRP_EC1G2DRValue +{ + + LLRP_C1G2DRValue_DRV_8 = 0, + LLRP_C1G2DRValue_DRV_64_3 = 1, +}; + +typedef enum LLRP_EC1G2DRValue + LLRP_tEC1G2DRValue; + +extern const LLRP_tSEnumTableEntry +LLRP_estC1G2DRValue[]; + + +enum LLRP_EC1G2MValue +{ + + LLRP_C1G2MValue_MV_FM0 = 0, + LLRP_C1G2MValue_MV_2 = 1, + LLRP_C1G2MValue_MV_4 = 2, + LLRP_C1G2MValue_MV_8 = 3, +}; + +typedef enum LLRP_EC1G2MValue + LLRP_tEC1G2MValue; + +extern const LLRP_tSEnumTableEntry +LLRP_estC1G2MValue[]; + + +enum LLRP_EC1G2ForwardLinkModulation +{ + + LLRP_C1G2ForwardLinkModulation_PR_ASK = 0, + LLRP_C1G2ForwardLinkModulation_SSB_ASK = 1, + LLRP_C1G2ForwardLinkModulation_DSB_ASK = 2, +}; + +typedef enum LLRP_EC1G2ForwardLinkModulation + LLRP_tEC1G2ForwardLinkModulation; + +extern const LLRP_tSEnumTableEntry +LLRP_estC1G2ForwardLinkModulation[]; + + +enum LLRP_EC1G2SpectralMaskIndicator +{ + + LLRP_C1G2SpectralMaskIndicator_Unknown = 0, + LLRP_C1G2SpectralMaskIndicator_SI = 1, + LLRP_C1G2SpectralMaskIndicator_MI = 2, + LLRP_C1G2SpectralMaskIndicator_DI = 3, +}; + +typedef enum LLRP_EC1G2SpectralMaskIndicator + LLRP_tEC1G2SpectralMaskIndicator; + +extern const LLRP_tSEnumTableEntry +LLRP_estC1G2SpectralMaskIndicator[]; + + +enum LLRP_EC1G2TruncateAction +{ + + LLRP_C1G2TruncateAction_Unspecified = 0, + LLRP_C1G2TruncateAction_Do_Not_Truncate = 1, + LLRP_C1G2TruncateAction_Truncate = 2, +}; + +typedef enum LLRP_EC1G2TruncateAction + LLRP_tEC1G2TruncateAction; + +extern const LLRP_tSEnumTableEntry +LLRP_estC1G2TruncateAction[]; + + +enum LLRP_EC1G2StateAwareTarget +{ + + LLRP_C1G2StateAwareTarget_SL = 0, + LLRP_C1G2StateAwareTarget_Inventoried_State_For_Session_S0 = 1, + LLRP_C1G2StateAwareTarget_Inventoried_State_For_Session_S1 = 2, + LLRP_C1G2StateAwareTarget_Inventoried_State_For_Session_S2 = 3, + LLRP_C1G2StateAwareTarget_Inventoried_State_For_Session_S3 = 4, +}; + +typedef enum LLRP_EC1G2StateAwareTarget + LLRP_tEC1G2StateAwareTarget; + +extern const LLRP_tSEnumTableEntry +LLRP_estC1G2StateAwareTarget[]; + + +enum LLRP_EC1G2StateAwareAction +{ + + LLRP_C1G2StateAwareAction_AssertSLOrA_DeassertSLOrB = 0, + LLRP_C1G2StateAwareAction_AssertSLOrA_Noop = 1, + LLRP_C1G2StateAwareAction_Noop_DeassertSLOrB = 2, + LLRP_C1G2StateAwareAction_NegateSLOrABBA_Noop = 3, + LLRP_C1G2StateAwareAction_DeassertSLOrB_AssertSLOrA = 4, + LLRP_C1G2StateAwareAction_DeassertSLOrB_Noop = 5, + LLRP_C1G2StateAwareAction_Noop_AssertSLOrA = 6, + LLRP_C1G2StateAwareAction_Noop_NegateSLOrABBA = 7, +}; + +typedef enum LLRP_EC1G2StateAwareAction + LLRP_tEC1G2StateAwareAction; + +extern const LLRP_tSEnumTableEntry +LLRP_estC1G2StateAwareAction[]; + + +enum LLRP_EC1G2StateUnawareAction +{ + + LLRP_C1G2StateUnawareAction_Select_Unselect = 0, + LLRP_C1G2StateUnawareAction_Select_DoNothing = 1, + LLRP_C1G2StateUnawareAction_DoNothing_Unselect = 2, + LLRP_C1G2StateUnawareAction_Unselect_DoNothing = 3, + LLRP_C1G2StateUnawareAction_Unselect_Select = 4, + LLRP_C1G2StateUnawareAction_DoNothing_Select = 5, +}; + +typedef enum LLRP_EC1G2StateUnawareAction + LLRP_tEC1G2StateUnawareAction; + +extern const LLRP_tSEnumTableEntry +LLRP_estC1G2StateUnawareAction[]; + + +enum LLRP_EC1G2TagInventoryStateAwareI +{ + + LLRP_C1G2TagInventoryStateAwareI_State_A = 0, + LLRP_C1G2TagInventoryStateAwareI_State_B = 1, +}; + +typedef enum LLRP_EC1G2TagInventoryStateAwareI + LLRP_tEC1G2TagInventoryStateAwareI; + +extern const LLRP_tSEnumTableEntry +LLRP_estC1G2TagInventoryStateAwareI[]; + + +enum LLRP_EC1G2TagInventoryStateAwareS +{ + + LLRP_C1G2TagInventoryStateAwareS_SL = 0, + LLRP_C1G2TagInventoryStateAwareS_Not_SL = 1, +}; + +typedef enum LLRP_EC1G2TagInventoryStateAwareS + LLRP_tEC1G2TagInventoryStateAwareS; + +extern const LLRP_tSEnumTableEntry +LLRP_estC1G2TagInventoryStateAwareS[]; + + +enum LLRP_EC1G2LockPrivilege +{ + + LLRP_C1G2LockPrivilege_Read_Write = 0, + LLRP_C1G2LockPrivilege_Perma_Lock = 1, + LLRP_C1G2LockPrivilege_Perma_Unlock = 2, + LLRP_C1G2LockPrivilege_Unlock = 3, +}; + +typedef enum LLRP_EC1G2LockPrivilege + LLRP_tEC1G2LockPrivilege; + +extern const LLRP_tSEnumTableEntry +LLRP_estC1G2LockPrivilege[]; + + +enum LLRP_EC1G2LockDataField +{ + + LLRP_C1G2LockDataField_Kill_Password = 0, + LLRP_C1G2LockDataField_Access_Password = 1, + LLRP_C1G2LockDataField_EPC_Memory = 2, + LLRP_C1G2LockDataField_TID_Memory = 3, + LLRP_C1G2LockDataField_User_Memory = 4, +}; + +typedef enum LLRP_EC1G2LockDataField + LLRP_tEC1G2LockDataField; + +extern const LLRP_tSEnumTableEntry +LLRP_estC1G2LockDataField[]; + + +enum LLRP_EC1G2ReadResultType +{ + + LLRP_C1G2ReadResultType_Success = 0, + LLRP_C1G2ReadResultType_Nonspecific_Tag_Error = 1, + LLRP_C1G2ReadResultType_No_Response_From_Tag = 2, + LLRP_C1G2ReadResultType_Nonspecific_Reader_Error = 3, + LLRP_C1G2ReadResultType_Memory_Overrun_Error = 4, + LLRP_C1G2ReadResultType_Memory_Locked_Error = 5, + LLRP_C1G2ReadResultType_Incorrect_Password_Error = 6, +}; + +typedef enum LLRP_EC1G2ReadResultType + LLRP_tEC1G2ReadResultType; + +extern const LLRP_tSEnumTableEntry +LLRP_estC1G2ReadResultType[]; + + +enum LLRP_EC1G2WriteResultType +{ + + LLRP_C1G2WriteResultType_Success = 0, + LLRP_C1G2WriteResultType_Tag_Memory_Overrun_Error = 1, + LLRP_C1G2WriteResultType_Tag_Memory_Locked_Error = 2, + LLRP_C1G2WriteResultType_Insufficient_Power = 3, + LLRP_C1G2WriteResultType_Nonspecific_Tag_Error = 4, + LLRP_C1G2WriteResultType_No_Response_From_Tag = 5, + LLRP_C1G2WriteResultType_Nonspecific_Reader_Error = 6, + LLRP_C1G2WriteResultType_Incorrect_Password_Error = 7, +}; + +typedef enum LLRP_EC1G2WriteResultType + LLRP_tEC1G2WriteResultType; + +extern const LLRP_tSEnumTableEntry +LLRP_estC1G2WriteResultType[]; + + +enum LLRP_EC1G2KillResultType +{ + + LLRP_C1G2KillResultType_Success = 0, + LLRP_C1G2KillResultType_Zero_Kill_Password_Error = 1, + LLRP_C1G2KillResultType_Insufficient_Power = 2, + LLRP_C1G2KillResultType_Nonspecific_Tag_Error = 3, + LLRP_C1G2KillResultType_No_Response_From_Tag = 4, + LLRP_C1G2KillResultType_Nonspecific_Reader_Error = 5, + LLRP_C1G2KillResultType_Incorrect_Password_Error = 6, +}; + +typedef enum LLRP_EC1G2KillResultType + LLRP_tEC1G2KillResultType; + +extern const LLRP_tSEnumTableEntry +LLRP_estC1G2KillResultType[]; + + +enum LLRP_EC1G2LockResultType +{ + + LLRP_C1G2LockResultType_Success = 0, + LLRP_C1G2LockResultType_Insufficient_Power = 1, + LLRP_C1G2LockResultType_Nonspecific_Tag_Error = 2, + LLRP_C1G2LockResultType_No_Response_From_Tag = 3, + LLRP_C1G2LockResultType_Nonspecific_Reader_Error = 4, + LLRP_C1G2LockResultType_Incorrect_Password_Error = 5, + LLRP_C1G2LockResultType_Tag_Memory_Overrun_Error = 6, + LLRP_C1G2LockResultType_Tag_Memory_Locked_Error = 7, +}; + +typedef enum LLRP_EC1G2LockResultType + LLRP_tEC1G2LockResultType; + +extern const LLRP_tSEnumTableEntry +LLRP_estC1G2LockResultType[]; + + +enum LLRP_EC1G2BlockEraseResultType +{ + + LLRP_C1G2BlockEraseResultType_Success = 0, + LLRP_C1G2BlockEraseResultType_Tag_Memory_Overrun_Error = 1, + LLRP_C1G2BlockEraseResultType_Tag_Memory_Locked_Error = 2, + LLRP_C1G2BlockEraseResultType_Insufficient_Power = 3, + LLRP_C1G2BlockEraseResultType_Nonspecific_Tag_Error = 4, + LLRP_C1G2BlockEraseResultType_No_Response_From_Tag = 5, + LLRP_C1G2BlockEraseResultType_Nonspecific_Reader_Error = 6, + LLRP_C1G2BlockEraseResultType_Incorrect_Password_Error = 7, +}; + +typedef enum LLRP_EC1G2BlockEraseResultType + LLRP_tEC1G2BlockEraseResultType; + +extern const LLRP_tSEnumTableEntry +LLRP_estC1G2BlockEraseResultType[]; + + +enum LLRP_EC1G2BlockWriteResultType +{ + + LLRP_C1G2BlockWriteResultType_Success = 0, + LLRP_C1G2BlockWriteResultType_Tag_Memory_Overrun_Error = 1, + LLRP_C1G2BlockWriteResultType_Tag_Memory_Locked_Error = 2, + LLRP_C1G2BlockWriteResultType_Insufficient_Power = 3, + LLRP_C1G2BlockWriteResultType_Nonspecific_Tag_Error = 4, + LLRP_C1G2BlockWriteResultType_No_Response_From_Tag = 5, + LLRP_C1G2BlockWriteResultType_Nonspecific_Reader_Error = 6, + LLRP_C1G2BlockWriteResultType_Incorrect_Password_Error = 7, +}; + +typedef enum LLRP_EC1G2BlockWriteResultType + LLRP_tEC1G2BlockWriteResultType; + +extern const LLRP_tSEnumTableEntry +LLRP_estC1G2BlockWriteResultType[]; + + + +struct LLRP_SCUSTOM_MESSAGE +{ + LLRP_tSMessage hdr; + + llrp_u32_t VendorIdentifier; + + llrp_u8_t MessageSubtype; + + llrp_bytesToEnd_t Data; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdCUSTOM_MESSAGE; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdCUSTOM_MESSAGE[]; + +extern LLRP_tSCUSTOM_MESSAGE * +LLRP_CUSTOM_MESSAGE_construct (void); + +extern void +LLRP_CUSTOM_MESSAGE_destruct ( + LLRP_tSCUSTOM_MESSAGE * pThis); + +extern void +LLRP_CUSTOM_MESSAGE_decodeFields ( + LLRP_tSCUSTOM_MESSAGE * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_CUSTOM_MESSAGE_assimilateSubParameters ( + LLRP_tSCUSTOM_MESSAGE * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_CUSTOM_MESSAGE_encode ( + const LLRP_tSCUSTOM_MESSAGE *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdCUSTOM_MESSAGE_VendorIdentifier; + +extern llrp_u32_t +LLRP_CUSTOM_MESSAGE_getVendorIdentifier ( + LLRP_tSCUSTOM_MESSAGE *pThis); + +extern LLRP_tResultCode +LLRP_CUSTOM_MESSAGE_setVendorIdentifier ( + LLRP_tSCUSTOM_MESSAGE *pThis, + llrp_u32_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdCUSTOM_MESSAGE_MessageSubtype; + +extern llrp_u8_t +LLRP_CUSTOM_MESSAGE_getMessageSubtype ( + LLRP_tSCUSTOM_MESSAGE *pThis); + +extern LLRP_tResultCode +LLRP_CUSTOM_MESSAGE_setMessageSubtype ( + LLRP_tSCUSTOM_MESSAGE *pThis, + llrp_u8_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdCUSTOM_MESSAGE_Data; + +extern llrp_bytesToEnd_t +LLRP_CUSTOM_MESSAGE_getData ( + LLRP_tSCUSTOM_MESSAGE *pThis); + +extern LLRP_tResultCode +LLRP_CUSTOM_MESSAGE_setData ( + LLRP_tSCUSTOM_MESSAGE *pThis, + llrp_bytesToEnd_t Value); + + + + + +struct LLRP_SGET_READER_CAPABILITIES +{ + LLRP_tSMessage hdr; + + LLRP_tEGetReaderCapabilitiesRequestedData eRequestedData; + + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdGET_READER_CAPABILITIES; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdGET_READER_CAPABILITIES[]; + +extern LLRP_tSGET_READER_CAPABILITIES * +LLRP_GET_READER_CAPABILITIES_construct (void); + +extern void +LLRP_GET_READER_CAPABILITIES_destruct ( + LLRP_tSGET_READER_CAPABILITIES * pThis); + +extern void +LLRP_GET_READER_CAPABILITIES_decodeFields ( + LLRP_tSGET_READER_CAPABILITIES * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_GET_READER_CAPABILITIES_assimilateSubParameters ( + LLRP_tSGET_READER_CAPABILITIES * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_GET_READER_CAPABILITIES_encode ( + const LLRP_tSGET_READER_CAPABILITIES *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdGET_READER_CAPABILITIES_RequestedData; + +extern LLRP_tEGetReaderCapabilitiesRequestedData +LLRP_GET_READER_CAPABILITIES_getRequestedData ( + LLRP_tSGET_READER_CAPABILITIES *pThis); + +extern LLRP_tResultCode +LLRP_GET_READER_CAPABILITIES_setRequestedData ( + LLRP_tSGET_READER_CAPABILITIES *pThis, + LLRP_tEGetReaderCapabilitiesRequestedData Value); + + +extern LLRP_tSParameter * +LLRP_GET_READER_CAPABILITIES_beginCustom ( + LLRP_tSGET_READER_CAPABILITIES *pThis); + +extern LLRP_tSParameter * +LLRP_GET_READER_CAPABILITIES_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_GET_READER_CAPABILITIES_clearCustom ( + LLRP_tSGET_READER_CAPABILITIES *pThis); + +extern int +LLRP_GET_READER_CAPABILITIES_countCustom ( + LLRP_tSGET_READER_CAPABILITIES *pThis); + +extern LLRP_tResultCode +LLRP_GET_READER_CAPABILITIES_addCustom ( + LLRP_tSGET_READER_CAPABILITIES *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SGET_READER_CAPABILITIES_RESPONSE +{ + LLRP_tSMessage hdr; + + + LLRP_tSLLRPStatus * pLLRPStatus; + + LLRP_tSGeneralDeviceCapabilities * pGeneralDeviceCapabilities; + + LLRP_tSLLRPCapabilities * pLLRPCapabilities; + + LLRP_tSRegulatoryCapabilities * pRegulatoryCapabilities; + + LLRP_tSParameter * pAirProtocolLLRPCapabilities; + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdGET_READER_CAPABILITIES_RESPONSE; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdGET_READER_CAPABILITIES_RESPONSE[]; + +extern LLRP_tSGET_READER_CAPABILITIES_RESPONSE * +LLRP_GET_READER_CAPABILITIES_RESPONSE_construct (void); + +extern void +LLRP_GET_READER_CAPABILITIES_RESPONSE_destruct ( + LLRP_tSGET_READER_CAPABILITIES_RESPONSE * pThis); + +extern void +LLRP_GET_READER_CAPABILITIES_RESPONSE_decodeFields ( + LLRP_tSGET_READER_CAPABILITIES_RESPONSE * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_GET_READER_CAPABILITIES_RESPONSE_assimilateSubParameters ( + LLRP_tSGET_READER_CAPABILITIES_RESPONSE * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_GET_READER_CAPABILITIES_RESPONSE_encode ( + const LLRP_tSGET_READER_CAPABILITIES_RESPONSE *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + + +extern LLRP_tSLLRPStatus * +LLRP_GET_READER_CAPABILITIES_RESPONSE_getLLRPStatus ( + LLRP_tSGET_READER_CAPABILITIES_RESPONSE *pThis); + +extern LLRP_tResultCode +LLRP_GET_READER_CAPABILITIES_RESPONSE_setLLRPStatus ( + LLRP_tSGET_READER_CAPABILITIES_RESPONSE *pThis, + LLRP_tSLLRPStatus *pValue); + +extern LLRP_tSGeneralDeviceCapabilities * +LLRP_GET_READER_CAPABILITIES_RESPONSE_getGeneralDeviceCapabilities ( + LLRP_tSGET_READER_CAPABILITIES_RESPONSE *pThis); + +extern LLRP_tResultCode +LLRP_GET_READER_CAPABILITIES_RESPONSE_setGeneralDeviceCapabilities ( + LLRP_tSGET_READER_CAPABILITIES_RESPONSE *pThis, + LLRP_tSGeneralDeviceCapabilities *pValue); + +extern LLRP_tSLLRPCapabilities * +LLRP_GET_READER_CAPABILITIES_RESPONSE_getLLRPCapabilities ( + LLRP_tSGET_READER_CAPABILITIES_RESPONSE *pThis); + +extern LLRP_tResultCode +LLRP_GET_READER_CAPABILITIES_RESPONSE_setLLRPCapabilities ( + LLRP_tSGET_READER_CAPABILITIES_RESPONSE *pThis, + LLRP_tSLLRPCapabilities *pValue); + +extern LLRP_tSRegulatoryCapabilities * +LLRP_GET_READER_CAPABILITIES_RESPONSE_getRegulatoryCapabilities ( + LLRP_tSGET_READER_CAPABILITIES_RESPONSE *pThis); + +extern LLRP_tResultCode +LLRP_GET_READER_CAPABILITIES_RESPONSE_setRegulatoryCapabilities ( + LLRP_tSGET_READER_CAPABILITIES_RESPONSE *pThis, + LLRP_tSRegulatoryCapabilities *pValue); + +extern LLRP_tSParameter * +LLRP_GET_READER_CAPABILITIES_RESPONSE_getAirProtocolLLRPCapabilities ( + LLRP_tSGET_READER_CAPABILITIES_RESPONSE *pThis); + +extern LLRP_tResultCode +LLRP_GET_READER_CAPABILITIES_RESPONSE_setAirProtocolLLRPCapabilities ( + LLRP_tSGET_READER_CAPABILITIES_RESPONSE *pThis, + LLRP_tSParameter *pValue); + +extern LLRP_tSParameter * +LLRP_GET_READER_CAPABILITIES_RESPONSE_beginCustom ( + LLRP_tSGET_READER_CAPABILITIES_RESPONSE *pThis); + +extern LLRP_tSParameter * +LLRP_GET_READER_CAPABILITIES_RESPONSE_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_GET_READER_CAPABILITIES_RESPONSE_clearCustom ( + LLRP_tSGET_READER_CAPABILITIES_RESPONSE *pThis); + +extern int +LLRP_GET_READER_CAPABILITIES_RESPONSE_countCustom ( + LLRP_tSGET_READER_CAPABILITIES_RESPONSE *pThis); + +extern LLRP_tResultCode +LLRP_GET_READER_CAPABILITIES_RESPONSE_addCustom ( + LLRP_tSGET_READER_CAPABILITIES_RESPONSE *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SADD_ROSPEC +{ + LLRP_tSMessage hdr; + + + LLRP_tSROSpec * pROSpec; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdADD_ROSPEC; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdADD_ROSPEC[]; + +extern LLRP_tSADD_ROSPEC * +LLRP_ADD_ROSPEC_construct (void); + +extern void +LLRP_ADD_ROSPEC_destruct ( + LLRP_tSADD_ROSPEC * pThis); + +extern void +LLRP_ADD_ROSPEC_decodeFields ( + LLRP_tSADD_ROSPEC * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ADD_ROSPEC_assimilateSubParameters ( + LLRP_tSADD_ROSPEC * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ADD_ROSPEC_encode ( + const LLRP_tSADD_ROSPEC *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + + +extern LLRP_tSROSpec * +LLRP_ADD_ROSPEC_getROSpec ( + LLRP_tSADD_ROSPEC *pThis); + +extern LLRP_tResultCode +LLRP_ADD_ROSPEC_setROSpec ( + LLRP_tSADD_ROSPEC *pThis, + LLRP_tSROSpec *pValue); + + + + +struct LLRP_SADD_ROSPEC_RESPONSE +{ + LLRP_tSMessage hdr; + + + LLRP_tSLLRPStatus * pLLRPStatus; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdADD_ROSPEC_RESPONSE; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdADD_ROSPEC_RESPONSE[]; + +extern LLRP_tSADD_ROSPEC_RESPONSE * +LLRP_ADD_ROSPEC_RESPONSE_construct (void); + +extern void +LLRP_ADD_ROSPEC_RESPONSE_destruct ( + LLRP_tSADD_ROSPEC_RESPONSE * pThis); + +extern void +LLRP_ADD_ROSPEC_RESPONSE_decodeFields ( + LLRP_tSADD_ROSPEC_RESPONSE * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ADD_ROSPEC_RESPONSE_assimilateSubParameters ( + LLRP_tSADD_ROSPEC_RESPONSE * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ADD_ROSPEC_RESPONSE_encode ( + const LLRP_tSADD_ROSPEC_RESPONSE *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + + +extern LLRP_tSLLRPStatus * +LLRP_ADD_ROSPEC_RESPONSE_getLLRPStatus ( + LLRP_tSADD_ROSPEC_RESPONSE *pThis); + +extern LLRP_tResultCode +LLRP_ADD_ROSPEC_RESPONSE_setLLRPStatus ( + LLRP_tSADD_ROSPEC_RESPONSE *pThis, + LLRP_tSLLRPStatus *pValue); + + + + +struct LLRP_SDELETE_ROSPEC +{ + LLRP_tSMessage hdr; + + llrp_u32_t ROSpecID; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdDELETE_ROSPEC; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdDELETE_ROSPEC[]; + +extern LLRP_tSDELETE_ROSPEC * +LLRP_DELETE_ROSPEC_construct (void); + +extern void +LLRP_DELETE_ROSPEC_destruct ( + LLRP_tSDELETE_ROSPEC * pThis); + +extern void +LLRP_DELETE_ROSPEC_decodeFields ( + LLRP_tSDELETE_ROSPEC * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_DELETE_ROSPEC_assimilateSubParameters ( + LLRP_tSDELETE_ROSPEC * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_DELETE_ROSPEC_encode ( + const LLRP_tSDELETE_ROSPEC *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdDELETE_ROSPEC_ROSpecID; + +extern llrp_u32_t +LLRP_DELETE_ROSPEC_getROSpecID ( + LLRP_tSDELETE_ROSPEC *pThis); + +extern LLRP_tResultCode +LLRP_DELETE_ROSPEC_setROSpecID ( + LLRP_tSDELETE_ROSPEC *pThis, + llrp_u32_t Value); + + + + + +struct LLRP_SDELETE_ROSPEC_RESPONSE +{ + LLRP_tSMessage hdr; + + + LLRP_tSLLRPStatus * pLLRPStatus; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdDELETE_ROSPEC_RESPONSE; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdDELETE_ROSPEC_RESPONSE[]; + +extern LLRP_tSDELETE_ROSPEC_RESPONSE * +LLRP_DELETE_ROSPEC_RESPONSE_construct (void); + +extern void +LLRP_DELETE_ROSPEC_RESPONSE_destruct ( + LLRP_tSDELETE_ROSPEC_RESPONSE * pThis); + +extern void +LLRP_DELETE_ROSPEC_RESPONSE_decodeFields ( + LLRP_tSDELETE_ROSPEC_RESPONSE * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_DELETE_ROSPEC_RESPONSE_assimilateSubParameters ( + LLRP_tSDELETE_ROSPEC_RESPONSE * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_DELETE_ROSPEC_RESPONSE_encode ( + const LLRP_tSDELETE_ROSPEC_RESPONSE *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + + +extern LLRP_tSLLRPStatus * +LLRP_DELETE_ROSPEC_RESPONSE_getLLRPStatus ( + LLRP_tSDELETE_ROSPEC_RESPONSE *pThis); + +extern LLRP_tResultCode +LLRP_DELETE_ROSPEC_RESPONSE_setLLRPStatus ( + LLRP_tSDELETE_ROSPEC_RESPONSE *pThis, + LLRP_tSLLRPStatus *pValue); + + + + +struct LLRP_SSTART_ROSPEC +{ + LLRP_tSMessage hdr; + + llrp_u32_t ROSpecID; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdSTART_ROSPEC; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdSTART_ROSPEC[]; + +extern LLRP_tSSTART_ROSPEC * +LLRP_START_ROSPEC_construct (void); + +extern void +LLRP_START_ROSPEC_destruct ( + LLRP_tSSTART_ROSPEC * pThis); + +extern void +LLRP_START_ROSPEC_decodeFields ( + LLRP_tSSTART_ROSPEC * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_START_ROSPEC_assimilateSubParameters ( + LLRP_tSSTART_ROSPEC * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_START_ROSPEC_encode ( + const LLRP_tSSTART_ROSPEC *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdSTART_ROSPEC_ROSpecID; + +extern llrp_u32_t +LLRP_START_ROSPEC_getROSpecID ( + LLRP_tSSTART_ROSPEC *pThis); + +extern LLRP_tResultCode +LLRP_START_ROSPEC_setROSpecID ( + LLRP_tSSTART_ROSPEC *pThis, + llrp_u32_t Value); + + + + + +struct LLRP_SSTART_ROSPEC_RESPONSE +{ + LLRP_tSMessage hdr; + + + LLRP_tSLLRPStatus * pLLRPStatus; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdSTART_ROSPEC_RESPONSE; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdSTART_ROSPEC_RESPONSE[]; + +extern LLRP_tSSTART_ROSPEC_RESPONSE * +LLRP_START_ROSPEC_RESPONSE_construct (void); + +extern void +LLRP_START_ROSPEC_RESPONSE_destruct ( + LLRP_tSSTART_ROSPEC_RESPONSE * pThis); + +extern void +LLRP_START_ROSPEC_RESPONSE_decodeFields ( + LLRP_tSSTART_ROSPEC_RESPONSE * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_START_ROSPEC_RESPONSE_assimilateSubParameters ( + LLRP_tSSTART_ROSPEC_RESPONSE * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_START_ROSPEC_RESPONSE_encode ( + const LLRP_tSSTART_ROSPEC_RESPONSE *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + + +extern LLRP_tSLLRPStatus * +LLRP_START_ROSPEC_RESPONSE_getLLRPStatus ( + LLRP_tSSTART_ROSPEC_RESPONSE *pThis); + +extern LLRP_tResultCode +LLRP_START_ROSPEC_RESPONSE_setLLRPStatus ( + LLRP_tSSTART_ROSPEC_RESPONSE *pThis, + LLRP_tSLLRPStatus *pValue); + + + + +struct LLRP_SSTOP_ROSPEC +{ + LLRP_tSMessage hdr; + + llrp_u32_t ROSpecID; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdSTOP_ROSPEC; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdSTOP_ROSPEC[]; + +extern LLRP_tSSTOP_ROSPEC * +LLRP_STOP_ROSPEC_construct (void); + +extern void +LLRP_STOP_ROSPEC_destruct ( + LLRP_tSSTOP_ROSPEC * pThis); + +extern void +LLRP_STOP_ROSPEC_decodeFields ( + LLRP_tSSTOP_ROSPEC * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_STOP_ROSPEC_assimilateSubParameters ( + LLRP_tSSTOP_ROSPEC * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_STOP_ROSPEC_encode ( + const LLRP_tSSTOP_ROSPEC *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdSTOP_ROSPEC_ROSpecID; + +extern llrp_u32_t +LLRP_STOP_ROSPEC_getROSpecID ( + LLRP_tSSTOP_ROSPEC *pThis); + +extern LLRP_tResultCode +LLRP_STOP_ROSPEC_setROSpecID ( + LLRP_tSSTOP_ROSPEC *pThis, + llrp_u32_t Value); + + + + + +struct LLRP_SSTOP_ROSPEC_RESPONSE +{ + LLRP_tSMessage hdr; + + + LLRP_tSLLRPStatus * pLLRPStatus; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdSTOP_ROSPEC_RESPONSE; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdSTOP_ROSPEC_RESPONSE[]; + +extern LLRP_tSSTOP_ROSPEC_RESPONSE * +LLRP_STOP_ROSPEC_RESPONSE_construct (void); + +extern void +LLRP_STOP_ROSPEC_RESPONSE_destruct ( + LLRP_tSSTOP_ROSPEC_RESPONSE * pThis); + +extern void +LLRP_STOP_ROSPEC_RESPONSE_decodeFields ( + LLRP_tSSTOP_ROSPEC_RESPONSE * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_STOP_ROSPEC_RESPONSE_assimilateSubParameters ( + LLRP_tSSTOP_ROSPEC_RESPONSE * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_STOP_ROSPEC_RESPONSE_encode ( + const LLRP_tSSTOP_ROSPEC_RESPONSE *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + + +extern LLRP_tSLLRPStatus * +LLRP_STOP_ROSPEC_RESPONSE_getLLRPStatus ( + LLRP_tSSTOP_ROSPEC_RESPONSE *pThis); + +extern LLRP_tResultCode +LLRP_STOP_ROSPEC_RESPONSE_setLLRPStatus ( + LLRP_tSSTOP_ROSPEC_RESPONSE *pThis, + LLRP_tSLLRPStatus *pValue); + + + + +struct LLRP_SENABLE_ROSPEC +{ + LLRP_tSMessage hdr; + + llrp_u32_t ROSpecID; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdENABLE_ROSPEC; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdENABLE_ROSPEC[]; + +extern LLRP_tSENABLE_ROSPEC * +LLRP_ENABLE_ROSPEC_construct (void); + +extern void +LLRP_ENABLE_ROSPEC_destruct ( + LLRP_tSENABLE_ROSPEC * pThis); + +extern void +LLRP_ENABLE_ROSPEC_decodeFields ( + LLRP_tSENABLE_ROSPEC * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ENABLE_ROSPEC_assimilateSubParameters ( + LLRP_tSENABLE_ROSPEC * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ENABLE_ROSPEC_encode ( + const LLRP_tSENABLE_ROSPEC *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdENABLE_ROSPEC_ROSpecID; + +extern llrp_u32_t +LLRP_ENABLE_ROSPEC_getROSpecID ( + LLRP_tSENABLE_ROSPEC *pThis); + +extern LLRP_tResultCode +LLRP_ENABLE_ROSPEC_setROSpecID ( + LLRP_tSENABLE_ROSPEC *pThis, + llrp_u32_t Value); + + + + + +struct LLRP_SENABLE_ROSPEC_RESPONSE +{ + LLRP_tSMessage hdr; + + + LLRP_tSLLRPStatus * pLLRPStatus; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdENABLE_ROSPEC_RESPONSE; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdENABLE_ROSPEC_RESPONSE[]; + +extern LLRP_tSENABLE_ROSPEC_RESPONSE * +LLRP_ENABLE_ROSPEC_RESPONSE_construct (void); + +extern void +LLRP_ENABLE_ROSPEC_RESPONSE_destruct ( + LLRP_tSENABLE_ROSPEC_RESPONSE * pThis); + +extern void +LLRP_ENABLE_ROSPEC_RESPONSE_decodeFields ( + LLRP_tSENABLE_ROSPEC_RESPONSE * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ENABLE_ROSPEC_RESPONSE_assimilateSubParameters ( + LLRP_tSENABLE_ROSPEC_RESPONSE * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ENABLE_ROSPEC_RESPONSE_encode ( + const LLRP_tSENABLE_ROSPEC_RESPONSE *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + + +extern LLRP_tSLLRPStatus * +LLRP_ENABLE_ROSPEC_RESPONSE_getLLRPStatus ( + LLRP_tSENABLE_ROSPEC_RESPONSE *pThis); + +extern LLRP_tResultCode +LLRP_ENABLE_ROSPEC_RESPONSE_setLLRPStatus ( + LLRP_tSENABLE_ROSPEC_RESPONSE *pThis, + LLRP_tSLLRPStatus *pValue); + + + + +struct LLRP_SDISABLE_ROSPEC +{ + LLRP_tSMessage hdr; + + llrp_u32_t ROSpecID; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdDISABLE_ROSPEC; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdDISABLE_ROSPEC[]; + +extern LLRP_tSDISABLE_ROSPEC * +LLRP_DISABLE_ROSPEC_construct (void); + +extern void +LLRP_DISABLE_ROSPEC_destruct ( + LLRP_tSDISABLE_ROSPEC * pThis); + +extern void +LLRP_DISABLE_ROSPEC_decodeFields ( + LLRP_tSDISABLE_ROSPEC * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_DISABLE_ROSPEC_assimilateSubParameters ( + LLRP_tSDISABLE_ROSPEC * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_DISABLE_ROSPEC_encode ( + const LLRP_tSDISABLE_ROSPEC *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdDISABLE_ROSPEC_ROSpecID; + +extern llrp_u32_t +LLRP_DISABLE_ROSPEC_getROSpecID ( + LLRP_tSDISABLE_ROSPEC *pThis); + +extern LLRP_tResultCode +LLRP_DISABLE_ROSPEC_setROSpecID ( + LLRP_tSDISABLE_ROSPEC *pThis, + llrp_u32_t Value); + + + + + +struct LLRP_SDISABLE_ROSPEC_RESPONSE +{ + LLRP_tSMessage hdr; + + + LLRP_tSLLRPStatus * pLLRPStatus; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdDISABLE_ROSPEC_RESPONSE; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdDISABLE_ROSPEC_RESPONSE[]; + +extern LLRP_tSDISABLE_ROSPEC_RESPONSE * +LLRP_DISABLE_ROSPEC_RESPONSE_construct (void); + +extern void +LLRP_DISABLE_ROSPEC_RESPONSE_destruct ( + LLRP_tSDISABLE_ROSPEC_RESPONSE * pThis); + +extern void +LLRP_DISABLE_ROSPEC_RESPONSE_decodeFields ( + LLRP_tSDISABLE_ROSPEC_RESPONSE * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_DISABLE_ROSPEC_RESPONSE_assimilateSubParameters ( + LLRP_tSDISABLE_ROSPEC_RESPONSE * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_DISABLE_ROSPEC_RESPONSE_encode ( + const LLRP_tSDISABLE_ROSPEC_RESPONSE *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + + +extern LLRP_tSLLRPStatus * +LLRP_DISABLE_ROSPEC_RESPONSE_getLLRPStatus ( + LLRP_tSDISABLE_ROSPEC_RESPONSE *pThis); + +extern LLRP_tResultCode +LLRP_DISABLE_ROSPEC_RESPONSE_setLLRPStatus ( + LLRP_tSDISABLE_ROSPEC_RESPONSE *pThis, + LLRP_tSLLRPStatus *pValue); + + + + +struct LLRP_SGET_ROSPECS +{ + LLRP_tSMessage hdr; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdGET_ROSPECS; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdGET_ROSPECS[]; + +extern LLRP_tSGET_ROSPECS * +LLRP_GET_ROSPECS_construct (void); + +extern void +LLRP_GET_ROSPECS_destruct ( + LLRP_tSGET_ROSPECS * pThis); + +extern void +LLRP_GET_ROSPECS_decodeFields ( + LLRP_tSGET_ROSPECS * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_GET_ROSPECS_assimilateSubParameters ( + LLRP_tSGET_ROSPECS * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_GET_ROSPECS_encode ( + const LLRP_tSGET_ROSPECS *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + + + + + +struct LLRP_SGET_ROSPECS_RESPONSE +{ + LLRP_tSMessage hdr; + + + LLRP_tSLLRPStatus * pLLRPStatus; + + LLRP_tSROSpec * listROSpec; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdGET_ROSPECS_RESPONSE; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdGET_ROSPECS_RESPONSE[]; + +extern LLRP_tSGET_ROSPECS_RESPONSE * +LLRP_GET_ROSPECS_RESPONSE_construct (void); + +extern void +LLRP_GET_ROSPECS_RESPONSE_destruct ( + LLRP_tSGET_ROSPECS_RESPONSE * pThis); + +extern void +LLRP_GET_ROSPECS_RESPONSE_decodeFields ( + LLRP_tSGET_ROSPECS_RESPONSE * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_GET_ROSPECS_RESPONSE_assimilateSubParameters ( + LLRP_tSGET_ROSPECS_RESPONSE * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_GET_ROSPECS_RESPONSE_encode ( + const LLRP_tSGET_ROSPECS_RESPONSE *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + + +extern LLRP_tSLLRPStatus * +LLRP_GET_ROSPECS_RESPONSE_getLLRPStatus ( + LLRP_tSGET_ROSPECS_RESPONSE *pThis); + +extern LLRP_tResultCode +LLRP_GET_ROSPECS_RESPONSE_setLLRPStatus ( + LLRP_tSGET_ROSPECS_RESPONSE *pThis, + LLRP_tSLLRPStatus *pValue); + +extern LLRP_tSROSpec * +LLRP_GET_ROSPECS_RESPONSE_beginROSpec ( + LLRP_tSGET_ROSPECS_RESPONSE *pThis); + +extern LLRP_tSROSpec * +LLRP_GET_ROSPECS_RESPONSE_nextROSpec ( + LLRP_tSROSpec *pCurrent); + +extern void +LLRP_GET_ROSPECS_RESPONSE_clearROSpec ( + LLRP_tSGET_ROSPECS_RESPONSE *pThis); + +extern int +LLRP_GET_ROSPECS_RESPONSE_countROSpec ( + LLRP_tSGET_ROSPECS_RESPONSE *pThis); + +extern LLRP_tResultCode +LLRP_GET_ROSPECS_RESPONSE_addROSpec ( + LLRP_tSGET_ROSPECS_RESPONSE *pThis, + LLRP_tSROSpec *pValue); + + + + + +struct LLRP_SADD_ACCESSSPEC +{ + LLRP_tSMessage hdr; + + + LLRP_tSAccessSpec * pAccessSpec; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdADD_ACCESSSPEC; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdADD_ACCESSSPEC[]; + +extern LLRP_tSADD_ACCESSSPEC * +LLRP_ADD_ACCESSSPEC_construct (void); + +extern void +LLRP_ADD_ACCESSSPEC_destruct ( + LLRP_tSADD_ACCESSSPEC * pThis); + +extern void +LLRP_ADD_ACCESSSPEC_decodeFields ( + LLRP_tSADD_ACCESSSPEC * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ADD_ACCESSSPEC_assimilateSubParameters ( + LLRP_tSADD_ACCESSSPEC * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ADD_ACCESSSPEC_encode ( + const LLRP_tSADD_ACCESSSPEC *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + + +extern LLRP_tSAccessSpec * +LLRP_ADD_ACCESSSPEC_getAccessSpec ( + LLRP_tSADD_ACCESSSPEC *pThis); + +extern LLRP_tResultCode +LLRP_ADD_ACCESSSPEC_setAccessSpec ( + LLRP_tSADD_ACCESSSPEC *pThis, + LLRP_tSAccessSpec *pValue); + + + + +struct LLRP_SADD_ACCESSSPEC_RESPONSE +{ + LLRP_tSMessage hdr; + + + LLRP_tSLLRPStatus * pLLRPStatus; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdADD_ACCESSSPEC_RESPONSE; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdADD_ACCESSSPEC_RESPONSE[]; + +extern LLRP_tSADD_ACCESSSPEC_RESPONSE * +LLRP_ADD_ACCESSSPEC_RESPONSE_construct (void); + +extern void +LLRP_ADD_ACCESSSPEC_RESPONSE_destruct ( + LLRP_tSADD_ACCESSSPEC_RESPONSE * pThis); + +extern void +LLRP_ADD_ACCESSSPEC_RESPONSE_decodeFields ( + LLRP_tSADD_ACCESSSPEC_RESPONSE * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ADD_ACCESSSPEC_RESPONSE_assimilateSubParameters ( + LLRP_tSADD_ACCESSSPEC_RESPONSE * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ADD_ACCESSSPEC_RESPONSE_encode ( + const LLRP_tSADD_ACCESSSPEC_RESPONSE *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + + +extern LLRP_tSLLRPStatus * +LLRP_ADD_ACCESSSPEC_RESPONSE_getLLRPStatus ( + LLRP_tSADD_ACCESSSPEC_RESPONSE *pThis); + +extern LLRP_tResultCode +LLRP_ADD_ACCESSSPEC_RESPONSE_setLLRPStatus ( + LLRP_tSADD_ACCESSSPEC_RESPONSE *pThis, + LLRP_tSLLRPStatus *pValue); + + + + +struct LLRP_SDELETE_ACCESSSPEC +{ + LLRP_tSMessage hdr; + + llrp_u32_t AccessSpecID; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdDELETE_ACCESSSPEC; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdDELETE_ACCESSSPEC[]; + +extern LLRP_tSDELETE_ACCESSSPEC * +LLRP_DELETE_ACCESSSPEC_construct (void); + +extern void +LLRP_DELETE_ACCESSSPEC_destruct ( + LLRP_tSDELETE_ACCESSSPEC * pThis); + +extern void +LLRP_DELETE_ACCESSSPEC_decodeFields ( + LLRP_tSDELETE_ACCESSSPEC * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_DELETE_ACCESSSPEC_assimilateSubParameters ( + LLRP_tSDELETE_ACCESSSPEC * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_DELETE_ACCESSSPEC_encode ( + const LLRP_tSDELETE_ACCESSSPEC *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdDELETE_ACCESSSPEC_AccessSpecID; + +extern llrp_u32_t +LLRP_DELETE_ACCESSSPEC_getAccessSpecID ( + LLRP_tSDELETE_ACCESSSPEC *pThis); + +extern LLRP_tResultCode +LLRP_DELETE_ACCESSSPEC_setAccessSpecID ( + LLRP_tSDELETE_ACCESSSPEC *pThis, + llrp_u32_t Value); + + + + + +struct LLRP_SDELETE_ACCESSSPEC_RESPONSE +{ + LLRP_tSMessage hdr; + + + LLRP_tSLLRPStatus * pLLRPStatus; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdDELETE_ACCESSSPEC_RESPONSE; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdDELETE_ACCESSSPEC_RESPONSE[]; + +extern LLRP_tSDELETE_ACCESSSPEC_RESPONSE * +LLRP_DELETE_ACCESSSPEC_RESPONSE_construct (void); + +extern void +LLRP_DELETE_ACCESSSPEC_RESPONSE_destruct ( + LLRP_tSDELETE_ACCESSSPEC_RESPONSE * pThis); + +extern void +LLRP_DELETE_ACCESSSPEC_RESPONSE_decodeFields ( + LLRP_tSDELETE_ACCESSSPEC_RESPONSE * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_DELETE_ACCESSSPEC_RESPONSE_assimilateSubParameters ( + LLRP_tSDELETE_ACCESSSPEC_RESPONSE * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_DELETE_ACCESSSPEC_RESPONSE_encode ( + const LLRP_tSDELETE_ACCESSSPEC_RESPONSE *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + + +extern LLRP_tSLLRPStatus * +LLRP_DELETE_ACCESSSPEC_RESPONSE_getLLRPStatus ( + LLRP_tSDELETE_ACCESSSPEC_RESPONSE *pThis); + +extern LLRP_tResultCode +LLRP_DELETE_ACCESSSPEC_RESPONSE_setLLRPStatus ( + LLRP_tSDELETE_ACCESSSPEC_RESPONSE *pThis, + LLRP_tSLLRPStatus *pValue); + + + + +struct LLRP_SENABLE_ACCESSSPEC +{ + LLRP_tSMessage hdr; + + llrp_u32_t AccessSpecID; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdENABLE_ACCESSSPEC; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdENABLE_ACCESSSPEC[]; + +extern LLRP_tSENABLE_ACCESSSPEC * +LLRP_ENABLE_ACCESSSPEC_construct (void); + +extern void +LLRP_ENABLE_ACCESSSPEC_destruct ( + LLRP_tSENABLE_ACCESSSPEC * pThis); + +extern void +LLRP_ENABLE_ACCESSSPEC_decodeFields ( + LLRP_tSENABLE_ACCESSSPEC * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ENABLE_ACCESSSPEC_assimilateSubParameters ( + LLRP_tSENABLE_ACCESSSPEC * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ENABLE_ACCESSSPEC_encode ( + const LLRP_tSENABLE_ACCESSSPEC *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdENABLE_ACCESSSPEC_AccessSpecID; + +extern llrp_u32_t +LLRP_ENABLE_ACCESSSPEC_getAccessSpecID ( + LLRP_tSENABLE_ACCESSSPEC *pThis); + +extern LLRP_tResultCode +LLRP_ENABLE_ACCESSSPEC_setAccessSpecID ( + LLRP_tSENABLE_ACCESSSPEC *pThis, + llrp_u32_t Value); + + + + + +struct LLRP_SENABLE_ACCESSSPEC_RESPONSE +{ + LLRP_tSMessage hdr; + + + LLRP_tSLLRPStatus * pLLRPStatus; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdENABLE_ACCESSSPEC_RESPONSE; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdENABLE_ACCESSSPEC_RESPONSE[]; + +extern LLRP_tSENABLE_ACCESSSPEC_RESPONSE * +LLRP_ENABLE_ACCESSSPEC_RESPONSE_construct (void); + +extern void +LLRP_ENABLE_ACCESSSPEC_RESPONSE_destruct ( + LLRP_tSENABLE_ACCESSSPEC_RESPONSE * pThis); + +extern void +LLRP_ENABLE_ACCESSSPEC_RESPONSE_decodeFields ( + LLRP_tSENABLE_ACCESSSPEC_RESPONSE * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ENABLE_ACCESSSPEC_RESPONSE_assimilateSubParameters ( + LLRP_tSENABLE_ACCESSSPEC_RESPONSE * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ENABLE_ACCESSSPEC_RESPONSE_encode ( + const LLRP_tSENABLE_ACCESSSPEC_RESPONSE *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + + +extern LLRP_tSLLRPStatus * +LLRP_ENABLE_ACCESSSPEC_RESPONSE_getLLRPStatus ( + LLRP_tSENABLE_ACCESSSPEC_RESPONSE *pThis); + +extern LLRP_tResultCode +LLRP_ENABLE_ACCESSSPEC_RESPONSE_setLLRPStatus ( + LLRP_tSENABLE_ACCESSSPEC_RESPONSE *pThis, + LLRP_tSLLRPStatus *pValue); + + + + +struct LLRP_SDISABLE_ACCESSSPEC +{ + LLRP_tSMessage hdr; + + llrp_u32_t AccessSpecID; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdDISABLE_ACCESSSPEC; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdDISABLE_ACCESSSPEC[]; + +extern LLRP_tSDISABLE_ACCESSSPEC * +LLRP_DISABLE_ACCESSSPEC_construct (void); + +extern void +LLRP_DISABLE_ACCESSSPEC_destruct ( + LLRP_tSDISABLE_ACCESSSPEC * pThis); + +extern void +LLRP_DISABLE_ACCESSSPEC_decodeFields ( + LLRP_tSDISABLE_ACCESSSPEC * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_DISABLE_ACCESSSPEC_assimilateSubParameters ( + LLRP_tSDISABLE_ACCESSSPEC * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_DISABLE_ACCESSSPEC_encode ( + const LLRP_tSDISABLE_ACCESSSPEC *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdDISABLE_ACCESSSPEC_AccessSpecID; + +extern llrp_u32_t +LLRP_DISABLE_ACCESSSPEC_getAccessSpecID ( + LLRP_tSDISABLE_ACCESSSPEC *pThis); + +extern LLRP_tResultCode +LLRP_DISABLE_ACCESSSPEC_setAccessSpecID ( + LLRP_tSDISABLE_ACCESSSPEC *pThis, + llrp_u32_t Value); + + + + + +struct LLRP_SDISABLE_ACCESSSPEC_RESPONSE +{ + LLRP_tSMessage hdr; + + + LLRP_tSLLRPStatus * pLLRPStatus; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdDISABLE_ACCESSSPEC_RESPONSE; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdDISABLE_ACCESSSPEC_RESPONSE[]; + +extern LLRP_tSDISABLE_ACCESSSPEC_RESPONSE * +LLRP_DISABLE_ACCESSSPEC_RESPONSE_construct (void); + +extern void +LLRP_DISABLE_ACCESSSPEC_RESPONSE_destruct ( + LLRP_tSDISABLE_ACCESSSPEC_RESPONSE * pThis); + +extern void +LLRP_DISABLE_ACCESSSPEC_RESPONSE_decodeFields ( + LLRP_tSDISABLE_ACCESSSPEC_RESPONSE * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_DISABLE_ACCESSSPEC_RESPONSE_assimilateSubParameters ( + LLRP_tSDISABLE_ACCESSSPEC_RESPONSE * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_DISABLE_ACCESSSPEC_RESPONSE_encode ( + const LLRP_tSDISABLE_ACCESSSPEC_RESPONSE *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + + +extern LLRP_tSLLRPStatus * +LLRP_DISABLE_ACCESSSPEC_RESPONSE_getLLRPStatus ( + LLRP_tSDISABLE_ACCESSSPEC_RESPONSE *pThis); + +extern LLRP_tResultCode +LLRP_DISABLE_ACCESSSPEC_RESPONSE_setLLRPStatus ( + LLRP_tSDISABLE_ACCESSSPEC_RESPONSE *pThis, + LLRP_tSLLRPStatus *pValue); + + + + +struct LLRP_SGET_ACCESSSPECS +{ + LLRP_tSMessage hdr; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdGET_ACCESSSPECS; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdGET_ACCESSSPECS[]; + +extern LLRP_tSGET_ACCESSSPECS * +LLRP_GET_ACCESSSPECS_construct (void); + +extern void +LLRP_GET_ACCESSSPECS_destruct ( + LLRP_tSGET_ACCESSSPECS * pThis); + +extern void +LLRP_GET_ACCESSSPECS_decodeFields ( + LLRP_tSGET_ACCESSSPECS * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_GET_ACCESSSPECS_assimilateSubParameters ( + LLRP_tSGET_ACCESSSPECS * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_GET_ACCESSSPECS_encode ( + const LLRP_tSGET_ACCESSSPECS *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + + + + + +struct LLRP_SGET_ACCESSSPECS_RESPONSE +{ + LLRP_tSMessage hdr; + + + LLRP_tSLLRPStatus * pLLRPStatus; + + LLRP_tSAccessSpec * listAccessSpec; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdGET_ACCESSSPECS_RESPONSE; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdGET_ACCESSSPECS_RESPONSE[]; + +extern LLRP_tSGET_ACCESSSPECS_RESPONSE * +LLRP_GET_ACCESSSPECS_RESPONSE_construct (void); + +extern void +LLRP_GET_ACCESSSPECS_RESPONSE_destruct ( + LLRP_tSGET_ACCESSSPECS_RESPONSE * pThis); + +extern void +LLRP_GET_ACCESSSPECS_RESPONSE_decodeFields ( + LLRP_tSGET_ACCESSSPECS_RESPONSE * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_GET_ACCESSSPECS_RESPONSE_assimilateSubParameters ( + LLRP_tSGET_ACCESSSPECS_RESPONSE * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_GET_ACCESSSPECS_RESPONSE_encode ( + const LLRP_tSGET_ACCESSSPECS_RESPONSE *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + + +extern LLRP_tSLLRPStatus * +LLRP_GET_ACCESSSPECS_RESPONSE_getLLRPStatus ( + LLRP_tSGET_ACCESSSPECS_RESPONSE *pThis); + +extern LLRP_tResultCode +LLRP_GET_ACCESSSPECS_RESPONSE_setLLRPStatus ( + LLRP_tSGET_ACCESSSPECS_RESPONSE *pThis, + LLRP_tSLLRPStatus *pValue); + +extern LLRP_tSAccessSpec * +LLRP_GET_ACCESSSPECS_RESPONSE_beginAccessSpec ( + LLRP_tSGET_ACCESSSPECS_RESPONSE *pThis); + +extern LLRP_tSAccessSpec * +LLRP_GET_ACCESSSPECS_RESPONSE_nextAccessSpec ( + LLRP_tSAccessSpec *pCurrent); + +extern void +LLRP_GET_ACCESSSPECS_RESPONSE_clearAccessSpec ( + LLRP_tSGET_ACCESSSPECS_RESPONSE *pThis); + +extern int +LLRP_GET_ACCESSSPECS_RESPONSE_countAccessSpec ( + LLRP_tSGET_ACCESSSPECS_RESPONSE *pThis); + +extern LLRP_tResultCode +LLRP_GET_ACCESSSPECS_RESPONSE_addAccessSpec ( + LLRP_tSGET_ACCESSSPECS_RESPONSE *pThis, + LLRP_tSAccessSpec *pValue); + + + + + +struct LLRP_SCLIENT_REQUEST_OP +{ + LLRP_tSMessage hdr; + + + LLRP_tSTagReportData * pTagReportData; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdCLIENT_REQUEST_OP; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdCLIENT_REQUEST_OP[]; + +extern LLRP_tSCLIENT_REQUEST_OP * +LLRP_CLIENT_REQUEST_OP_construct (void); + +extern void +LLRP_CLIENT_REQUEST_OP_destruct ( + LLRP_tSCLIENT_REQUEST_OP * pThis); + +extern void +LLRP_CLIENT_REQUEST_OP_decodeFields ( + LLRP_tSCLIENT_REQUEST_OP * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_CLIENT_REQUEST_OP_assimilateSubParameters ( + LLRP_tSCLIENT_REQUEST_OP * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_CLIENT_REQUEST_OP_encode ( + const LLRP_tSCLIENT_REQUEST_OP *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + + +extern LLRP_tSTagReportData * +LLRP_CLIENT_REQUEST_OP_getTagReportData ( + LLRP_tSCLIENT_REQUEST_OP *pThis); + +extern LLRP_tResultCode +LLRP_CLIENT_REQUEST_OP_setTagReportData ( + LLRP_tSCLIENT_REQUEST_OP *pThis, + LLRP_tSTagReportData *pValue); + + + + +struct LLRP_SCLIENT_REQUEST_OP_RESPONSE +{ + LLRP_tSMessage hdr; + + + LLRP_tSClientRequestResponse * pClientRequestResponse; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdCLIENT_REQUEST_OP_RESPONSE; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdCLIENT_REQUEST_OP_RESPONSE[]; + +extern LLRP_tSCLIENT_REQUEST_OP_RESPONSE * +LLRP_CLIENT_REQUEST_OP_RESPONSE_construct (void); + +extern void +LLRP_CLIENT_REQUEST_OP_RESPONSE_destruct ( + LLRP_tSCLIENT_REQUEST_OP_RESPONSE * pThis); + +extern void +LLRP_CLIENT_REQUEST_OP_RESPONSE_decodeFields ( + LLRP_tSCLIENT_REQUEST_OP_RESPONSE * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_CLIENT_REQUEST_OP_RESPONSE_assimilateSubParameters ( + LLRP_tSCLIENT_REQUEST_OP_RESPONSE * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_CLIENT_REQUEST_OP_RESPONSE_encode ( + const LLRP_tSCLIENT_REQUEST_OP_RESPONSE *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + + +extern LLRP_tSClientRequestResponse * +LLRP_CLIENT_REQUEST_OP_RESPONSE_getClientRequestResponse ( + LLRP_tSCLIENT_REQUEST_OP_RESPONSE *pThis); + +extern LLRP_tResultCode +LLRP_CLIENT_REQUEST_OP_RESPONSE_setClientRequestResponse ( + LLRP_tSCLIENT_REQUEST_OP_RESPONSE *pThis, + LLRP_tSClientRequestResponse *pValue); + + + + +struct LLRP_SGET_READER_CONFIG +{ + LLRP_tSMessage hdr; + + llrp_u16_t AntennaID; + + LLRP_tEGetReaderConfigRequestedData eRequestedData; + + llrp_u16_t GPIPortNum; + + llrp_u16_t GPOPortNum; + + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdGET_READER_CONFIG; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdGET_READER_CONFIG[]; + +extern LLRP_tSGET_READER_CONFIG * +LLRP_GET_READER_CONFIG_construct (void); + +extern void +LLRP_GET_READER_CONFIG_destruct ( + LLRP_tSGET_READER_CONFIG * pThis); + +extern void +LLRP_GET_READER_CONFIG_decodeFields ( + LLRP_tSGET_READER_CONFIG * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_GET_READER_CONFIG_assimilateSubParameters ( + LLRP_tSGET_READER_CONFIG * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_GET_READER_CONFIG_encode ( + const LLRP_tSGET_READER_CONFIG *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdGET_READER_CONFIG_AntennaID; + +extern llrp_u16_t +LLRP_GET_READER_CONFIG_getAntennaID ( + LLRP_tSGET_READER_CONFIG *pThis); + +extern LLRP_tResultCode +LLRP_GET_READER_CONFIG_setAntennaID ( + LLRP_tSGET_READER_CONFIG *pThis, + llrp_u16_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdGET_READER_CONFIG_RequestedData; + +extern LLRP_tEGetReaderConfigRequestedData +LLRP_GET_READER_CONFIG_getRequestedData ( + LLRP_tSGET_READER_CONFIG *pThis); + +extern LLRP_tResultCode +LLRP_GET_READER_CONFIG_setRequestedData ( + LLRP_tSGET_READER_CONFIG *pThis, + LLRP_tEGetReaderConfigRequestedData Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdGET_READER_CONFIG_GPIPortNum; + +extern llrp_u16_t +LLRP_GET_READER_CONFIG_getGPIPortNum ( + LLRP_tSGET_READER_CONFIG *pThis); + +extern LLRP_tResultCode +LLRP_GET_READER_CONFIG_setGPIPortNum ( + LLRP_tSGET_READER_CONFIG *pThis, + llrp_u16_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdGET_READER_CONFIG_GPOPortNum; + +extern llrp_u16_t +LLRP_GET_READER_CONFIG_getGPOPortNum ( + LLRP_tSGET_READER_CONFIG *pThis); + +extern LLRP_tResultCode +LLRP_GET_READER_CONFIG_setGPOPortNum ( + LLRP_tSGET_READER_CONFIG *pThis, + llrp_u16_t Value); + + +extern LLRP_tSParameter * +LLRP_GET_READER_CONFIG_beginCustom ( + LLRP_tSGET_READER_CONFIG *pThis); + +extern LLRP_tSParameter * +LLRP_GET_READER_CONFIG_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_GET_READER_CONFIG_clearCustom ( + LLRP_tSGET_READER_CONFIG *pThis); + +extern int +LLRP_GET_READER_CONFIG_countCustom ( + LLRP_tSGET_READER_CONFIG *pThis); + +extern LLRP_tResultCode +LLRP_GET_READER_CONFIG_addCustom ( + LLRP_tSGET_READER_CONFIG *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SGET_READER_CONFIG_RESPONSE +{ + LLRP_tSMessage hdr; + + + LLRP_tSLLRPStatus * pLLRPStatus; + + LLRP_tSIdentification * pIdentification; + + LLRP_tSAntennaProperties * listAntennaProperties; + + LLRP_tSAntennaConfiguration * listAntennaConfiguration; + + LLRP_tSReaderEventNotificationSpec * pReaderEventNotificationSpec; + + LLRP_tSROReportSpec * pROReportSpec; + + LLRP_tSAccessReportSpec * pAccessReportSpec; + + LLRP_tSLLRPConfigurationStateValue * pLLRPConfigurationStateValue; + + LLRP_tSKeepaliveSpec * pKeepaliveSpec; + + LLRP_tSGPIPortCurrentState * listGPIPortCurrentState; + + LLRP_tSGPOWriteData * listGPOWriteData; + + LLRP_tSEventsAndReports * pEventsAndReports; + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdGET_READER_CONFIG_RESPONSE; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdGET_READER_CONFIG_RESPONSE[]; + +extern LLRP_tSGET_READER_CONFIG_RESPONSE * +LLRP_GET_READER_CONFIG_RESPONSE_construct (void); + +extern void +LLRP_GET_READER_CONFIG_RESPONSE_destruct ( + LLRP_tSGET_READER_CONFIG_RESPONSE * pThis); + +extern void +LLRP_GET_READER_CONFIG_RESPONSE_decodeFields ( + LLRP_tSGET_READER_CONFIG_RESPONSE * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_GET_READER_CONFIG_RESPONSE_assimilateSubParameters ( + LLRP_tSGET_READER_CONFIG_RESPONSE * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_GET_READER_CONFIG_RESPONSE_encode ( + const LLRP_tSGET_READER_CONFIG_RESPONSE *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + + +extern LLRP_tSLLRPStatus * +LLRP_GET_READER_CONFIG_RESPONSE_getLLRPStatus ( + LLRP_tSGET_READER_CONFIG_RESPONSE *pThis); + +extern LLRP_tResultCode +LLRP_GET_READER_CONFIG_RESPONSE_setLLRPStatus ( + LLRP_tSGET_READER_CONFIG_RESPONSE *pThis, + LLRP_tSLLRPStatus *pValue); + +extern LLRP_tSIdentification * +LLRP_GET_READER_CONFIG_RESPONSE_getIdentification ( + LLRP_tSGET_READER_CONFIG_RESPONSE *pThis); + +extern LLRP_tResultCode +LLRP_GET_READER_CONFIG_RESPONSE_setIdentification ( + LLRP_tSGET_READER_CONFIG_RESPONSE *pThis, + LLRP_tSIdentification *pValue); + +extern LLRP_tSAntennaProperties * +LLRP_GET_READER_CONFIG_RESPONSE_beginAntennaProperties ( + LLRP_tSGET_READER_CONFIG_RESPONSE *pThis); + +extern LLRP_tSAntennaProperties * +LLRP_GET_READER_CONFIG_RESPONSE_nextAntennaProperties ( + LLRP_tSAntennaProperties *pCurrent); + +extern void +LLRP_GET_READER_CONFIG_RESPONSE_clearAntennaProperties ( + LLRP_tSGET_READER_CONFIG_RESPONSE *pThis); + +extern int +LLRP_GET_READER_CONFIG_RESPONSE_countAntennaProperties ( + LLRP_tSGET_READER_CONFIG_RESPONSE *pThis); + +extern LLRP_tResultCode +LLRP_GET_READER_CONFIG_RESPONSE_addAntennaProperties ( + LLRP_tSGET_READER_CONFIG_RESPONSE *pThis, + LLRP_tSAntennaProperties *pValue); + + +extern LLRP_tSAntennaConfiguration * +LLRP_GET_READER_CONFIG_RESPONSE_beginAntennaConfiguration ( + LLRP_tSGET_READER_CONFIG_RESPONSE *pThis); + +extern LLRP_tSAntennaConfiguration * +LLRP_GET_READER_CONFIG_RESPONSE_nextAntennaConfiguration ( + LLRP_tSAntennaConfiguration *pCurrent); + +extern void +LLRP_GET_READER_CONFIG_RESPONSE_clearAntennaConfiguration ( + LLRP_tSGET_READER_CONFIG_RESPONSE *pThis); + +extern int +LLRP_GET_READER_CONFIG_RESPONSE_countAntennaConfiguration ( + LLRP_tSGET_READER_CONFIG_RESPONSE *pThis); + +extern LLRP_tResultCode +LLRP_GET_READER_CONFIG_RESPONSE_addAntennaConfiguration ( + LLRP_tSGET_READER_CONFIG_RESPONSE *pThis, + LLRP_tSAntennaConfiguration *pValue); + + +extern LLRP_tSReaderEventNotificationSpec * +LLRP_GET_READER_CONFIG_RESPONSE_getReaderEventNotificationSpec ( + LLRP_tSGET_READER_CONFIG_RESPONSE *pThis); + +extern LLRP_tResultCode +LLRP_GET_READER_CONFIG_RESPONSE_setReaderEventNotificationSpec ( + LLRP_tSGET_READER_CONFIG_RESPONSE *pThis, + LLRP_tSReaderEventNotificationSpec *pValue); + +extern LLRP_tSROReportSpec * +LLRP_GET_READER_CONFIG_RESPONSE_getROReportSpec ( + LLRP_tSGET_READER_CONFIG_RESPONSE *pThis); + +extern LLRP_tResultCode +LLRP_GET_READER_CONFIG_RESPONSE_setROReportSpec ( + LLRP_tSGET_READER_CONFIG_RESPONSE *pThis, + LLRP_tSROReportSpec *pValue); + +extern LLRP_tSAccessReportSpec * +LLRP_GET_READER_CONFIG_RESPONSE_getAccessReportSpec ( + LLRP_tSGET_READER_CONFIG_RESPONSE *pThis); + +extern LLRP_tResultCode +LLRP_GET_READER_CONFIG_RESPONSE_setAccessReportSpec ( + LLRP_tSGET_READER_CONFIG_RESPONSE *pThis, + LLRP_tSAccessReportSpec *pValue); + +extern LLRP_tSLLRPConfigurationStateValue * +LLRP_GET_READER_CONFIG_RESPONSE_getLLRPConfigurationStateValue ( + LLRP_tSGET_READER_CONFIG_RESPONSE *pThis); + +extern LLRP_tResultCode +LLRP_GET_READER_CONFIG_RESPONSE_setLLRPConfigurationStateValue ( + LLRP_tSGET_READER_CONFIG_RESPONSE *pThis, + LLRP_tSLLRPConfigurationStateValue *pValue); + +extern LLRP_tSKeepaliveSpec * +LLRP_GET_READER_CONFIG_RESPONSE_getKeepaliveSpec ( + LLRP_tSGET_READER_CONFIG_RESPONSE *pThis); + +extern LLRP_tResultCode +LLRP_GET_READER_CONFIG_RESPONSE_setKeepaliveSpec ( + LLRP_tSGET_READER_CONFIG_RESPONSE *pThis, + LLRP_tSKeepaliveSpec *pValue); + +extern LLRP_tSGPIPortCurrentState * +LLRP_GET_READER_CONFIG_RESPONSE_beginGPIPortCurrentState ( + LLRP_tSGET_READER_CONFIG_RESPONSE *pThis); + +extern LLRP_tSGPIPortCurrentState * +LLRP_GET_READER_CONFIG_RESPONSE_nextGPIPortCurrentState ( + LLRP_tSGPIPortCurrentState *pCurrent); + +extern void +LLRP_GET_READER_CONFIG_RESPONSE_clearGPIPortCurrentState ( + LLRP_tSGET_READER_CONFIG_RESPONSE *pThis); + +extern int +LLRP_GET_READER_CONFIG_RESPONSE_countGPIPortCurrentState ( + LLRP_tSGET_READER_CONFIG_RESPONSE *pThis); + +extern LLRP_tResultCode +LLRP_GET_READER_CONFIG_RESPONSE_addGPIPortCurrentState ( + LLRP_tSGET_READER_CONFIG_RESPONSE *pThis, + LLRP_tSGPIPortCurrentState *pValue); + + +extern LLRP_tSGPOWriteData * +LLRP_GET_READER_CONFIG_RESPONSE_beginGPOWriteData ( + LLRP_tSGET_READER_CONFIG_RESPONSE *pThis); + +extern LLRP_tSGPOWriteData * +LLRP_GET_READER_CONFIG_RESPONSE_nextGPOWriteData ( + LLRP_tSGPOWriteData *pCurrent); + +extern void +LLRP_GET_READER_CONFIG_RESPONSE_clearGPOWriteData ( + LLRP_tSGET_READER_CONFIG_RESPONSE *pThis); + +extern int +LLRP_GET_READER_CONFIG_RESPONSE_countGPOWriteData ( + LLRP_tSGET_READER_CONFIG_RESPONSE *pThis); + +extern LLRP_tResultCode +LLRP_GET_READER_CONFIG_RESPONSE_addGPOWriteData ( + LLRP_tSGET_READER_CONFIG_RESPONSE *pThis, + LLRP_tSGPOWriteData *pValue); + + +extern LLRP_tSEventsAndReports * +LLRP_GET_READER_CONFIG_RESPONSE_getEventsAndReports ( + LLRP_tSGET_READER_CONFIG_RESPONSE *pThis); + +extern LLRP_tResultCode +LLRP_GET_READER_CONFIG_RESPONSE_setEventsAndReports ( + LLRP_tSGET_READER_CONFIG_RESPONSE *pThis, + LLRP_tSEventsAndReports *pValue); + +extern LLRP_tSParameter * +LLRP_GET_READER_CONFIG_RESPONSE_beginCustom ( + LLRP_tSGET_READER_CONFIG_RESPONSE *pThis); + +extern LLRP_tSParameter * +LLRP_GET_READER_CONFIG_RESPONSE_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_GET_READER_CONFIG_RESPONSE_clearCustom ( + LLRP_tSGET_READER_CONFIG_RESPONSE *pThis); + +extern int +LLRP_GET_READER_CONFIG_RESPONSE_countCustom ( + LLRP_tSGET_READER_CONFIG_RESPONSE *pThis); + +extern LLRP_tResultCode +LLRP_GET_READER_CONFIG_RESPONSE_addCustom ( + LLRP_tSGET_READER_CONFIG_RESPONSE *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SSET_READER_CONFIG +{ + LLRP_tSMessage hdr; + + llrp_u1_t ResetToFactoryDefault; + + + LLRP_tSReaderEventNotificationSpec * pReaderEventNotificationSpec; + + LLRP_tSAntennaProperties * listAntennaProperties; + + LLRP_tSAntennaConfiguration * listAntennaConfiguration; + + LLRP_tSROReportSpec * pROReportSpec; + + LLRP_tSAccessReportSpec * pAccessReportSpec; + + LLRP_tSKeepaliveSpec * pKeepaliveSpec; + + LLRP_tSGPOWriteData * listGPOWriteData; + + LLRP_tSGPIPortCurrentState * listGPIPortCurrentState; + + LLRP_tSEventsAndReports * pEventsAndReports; + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdSET_READER_CONFIG; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdSET_READER_CONFIG[]; + +extern LLRP_tSSET_READER_CONFIG * +LLRP_SET_READER_CONFIG_construct (void); + +extern void +LLRP_SET_READER_CONFIG_destruct ( + LLRP_tSSET_READER_CONFIG * pThis); + +extern void +LLRP_SET_READER_CONFIG_decodeFields ( + LLRP_tSSET_READER_CONFIG * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_SET_READER_CONFIG_assimilateSubParameters ( + LLRP_tSSET_READER_CONFIG * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_SET_READER_CONFIG_encode ( + const LLRP_tSSET_READER_CONFIG *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdSET_READER_CONFIG_ResetToFactoryDefault; + +extern llrp_u1_t +LLRP_SET_READER_CONFIG_getResetToFactoryDefault ( + LLRP_tSSET_READER_CONFIG *pThis); + +extern LLRP_tResultCode +LLRP_SET_READER_CONFIG_setResetToFactoryDefault ( + LLRP_tSSET_READER_CONFIG *pThis, + llrp_u1_t Value); + + +extern LLRP_tSReaderEventNotificationSpec * +LLRP_SET_READER_CONFIG_getReaderEventNotificationSpec ( + LLRP_tSSET_READER_CONFIG *pThis); + +extern LLRP_tResultCode +LLRP_SET_READER_CONFIG_setReaderEventNotificationSpec ( + LLRP_tSSET_READER_CONFIG *pThis, + LLRP_tSReaderEventNotificationSpec *pValue); + +extern LLRP_tSAntennaProperties * +LLRP_SET_READER_CONFIG_beginAntennaProperties ( + LLRP_tSSET_READER_CONFIG *pThis); + +extern LLRP_tSAntennaProperties * +LLRP_SET_READER_CONFIG_nextAntennaProperties ( + LLRP_tSAntennaProperties *pCurrent); + +extern void +LLRP_SET_READER_CONFIG_clearAntennaProperties ( + LLRP_tSSET_READER_CONFIG *pThis); + +extern int +LLRP_SET_READER_CONFIG_countAntennaProperties ( + LLRP_tSSET_READER_CONFIG *pThis); + +extern LLRP_tResultCode +LLRP_SET_READER_CONFIG_addAntennaProperties ( + LLRP_tSSET_READER_CONFIG *pThis, + LLRP_tSAntennaProperties *pValue); + + +extern LLRP_tSAntennaConfiguration * +LLRP_SET_READER_CONFIG_beginAntennaConfiguration ( + LLRP_tSSET_READER_CONFIG *pThis); + +extern LLRP_tSAntennaConfiguration * +LLRP_SET_READER_CONFIG_nextAntennaConfiguration ( + LLRP_tSAntennaConfiguration *pCurrent); + +extern void +LLRP_SET_READER_CONFIG_clearAntennaConfiguration ( + LLRP_tSSET_READER_CONFIG *pThis); + +extern int +LLRP_SET_READER_CONFIG_countAntennaConfiguration ( + LLRP_tSSET_READER_CONFIG *pThis); + +extern LLRP_tResultCode +LLRP_SET_READER_CONFIG_addAntennaConfiguration ( + LLRP_tSSET_READER_CONFIG *pThis, + LLRP_tSAntennaConfiguration *pValue); + + +extern LLRP_tSROReportSpec * +LLRP_SET_READER_CONFIG_getROReportSpec ( + LLRP_tSSET_READER_CONFIG *pThis); + +extern LLRP_tResultCode +LLRP_SET_READER_CONFIG_setROReportSpec ( + LLRP_tSSET_READER_CONFIG *pThis, + LLRP_tSROReportSpec *pValue); + +extern LLRP_tSAccessReportSpec * +LLRP_SET_READER_CONFIG_getAccessReportSpec ( + LLRP_tSSET_READER_CONFIG *pThis); + +extern LLRP_tResultCode +LLRP_SET_READER_CONFIG_setAccessReportSpec ( + LLRP_tSSET_READER_CONFIG *pThis, + LLRP_tSAccessReportSpec *pValue); + +extern LLRP_tSKeepaliveSpec * +LLRP_SET_READER_CONFIG_getKeepaliveSpec ( + LLRP_tSSET_READER_CONFIG *pThis); + +extern LLRP_tResultCode +LLRP_SET_READER_CONFIG_setKeepaliveSpec ( + LLRP_tSSET_READER_CONFIG *pThis, + LLRP_tSKeepaliveSpec *pValue); + +extern LLRP_tSGPOWriteData * +LLRP_SET_READER_CONFIG_beginGPOWriteData ( + LLRP_tSSET_READER_CONFIG *pThis); + +extern LLRP_tSGPOWriteData * +LLRP_SET_READER_CONFIG_nextGPOWriteData ( + LLRP_tSGPOWriteData *pCurrent); + +extern void +LLRP_SET_READER_CONFIG_clearGPOWriteData ( + LLRP_tSSET_READER_CONFIG *pThis); + +extern int +LLRP_SET_READER_CONFIG_countGPOWriteData ( + LLRP_tSSET_READER_CONFIG *pThis); + +extern LLRP_tResultCode +LLRP_SET_READER_CONFIG_addGPOWriteData ( + LLRP_tSSET_READER_CONFIG *pThis, + LLRP_tSGPOWriteData *pValue); + + +extern LLRP_tSGPIPortCurrentState * +LLRP_SET_READER_CONFIG_beginGPIPortCurrentState ( + LLRP_tSSET_READER_CONFIG *pThis); + +extern LLRP_tSGPIPortCurrentState * +LLRP_SET_READER_CONFIG_nextGPIPortCurrentState ( + LLRP_tSGPIPortCurrentState *pCurrent); + +extern void +LLRP_SET_READER_CONFIG_clearGPIPortCurrentState ( + LLRP_tSSET_READER_CONFIG *pThis); + +extern int +LLRP_SET_READER_CONFIG_countGPIPortCurrentState ( + LLRP_tSSET_READER_CONFIG *pThis); + +extern LLRP_tResultCode +LLRP_SET_READER_CONFIG_addGPIPortCurrentState ( + LLRP_tSSET_READER_CONFIG *pThis, + LLRP_tSGPIPortCurrentState *pValue); + + +extern LLRP_tSEventsAndReports * +LLRP_SET_READER_CONFIG_getEventsAndReports ( + LLRP_tSSET_READER_CONFIG *pThis); + +extern LLRP_tResultCode +LLRP_SET_READER_CONFIG_setEventsAndReports ( + LLRP_tSSET_READER_CONFIG *pThis, + LLRP_tSEventsAndReports *pValue); + +extern LLRP_tSParameter * +LLRP_SET_READER_CONFIG_beginCustom ( + LLRP_tSSET_READER_CONFIG *pThis); + +extern LLRP_tSParameter * +LLRP_SET_READER_CONFIG_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_SET_READER_CONFIG_clearCustom ( + LLRP_tSSET_READER_CONFIG *pThis); + +extern int +LLRP_SET_READER_CONFIG_countCustom ( + LLRP_tSSET_READER_CONFIG *pThis); + +extern LLRP_tResultCode +LLRP_SET_READER_CONFIG_addCustom ( + LLRP_tSSET_READER_CONFIG *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SSET_READER_CONFIG_RESPONSE +{ + LLRP_tSMessage hdr; + + + LLRP_tSLLRPStatus * pLLRPStatus; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdSET_READER_CONFIG_RESPONSE; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdSET_READER_CONFIG_RESPONSE[]; + +extern LLRP_tSSET_READER_CONFIG_RESPONSE * +LLRP_SET_READER_CONFIG_RESPONSE_construct (void); + +extern void +LLRP_SET_READER_CONFIG_RESPONSE_destruct ( + LLRP_tSSET_READER_CONFIG_RESPONSE * pThis); + +extern void +LLRP_SET_READER_CONFIG_RESPONSE_decodeFields ( + LLRP_tSSET_READER_CONFIG_RESPONSE * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_SET_READER_CONFIG_RESPONSE_assimilateSubParameters ( + LLRP_tSSET_READER_CONFIG_RESPONSE * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_SET_READER_CONFIG_RESPONSE_encode ( + const LLRP_tSSET_READER_CONFIG_RESPONSE *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + + +extern LLRP_tSLLRPStatus * +LLRP_SET_READER_CONFIG_RESPONSE_getLLRPStatus ( + LLRP_tSSET_READER_CONFIG_RESPONSE *pThis); + +extern LLRP_tResultCode +LLRP_SET_READER_CONFIG_RESPONSE_setLLRPStatus ( + LLRP_tSSET_READER_CONFIG_RESPONSE *pThis, + LLRP_tSLLRPStatus *pValue); + + + + +struct LLRP_SCLOSE_CONNECTION +{ + LLRP_tSMessage hdr; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdCLOSE_CONNECTION; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdCLOSE_CONNECTION[]; + +extern LLRP_tSCLOSE_CONNECTION * +LLRP_CLOSE_CONNECTION_construct (void); + +extern void +LLRP_CLOSE_CONNECTION_destruct ( + LLRP_tSCLOSE_CONNECTION * pThis); + +extern void +LLRP_CLOSE_CONNECTION_decodeFields ( + LLRP_tSCLOSE_CONNECTION * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_CLOSE_CONNECTION_assimilateSubParameters ( + LLRP_tSCLOSE_CONNECTION * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_CLOSE_CONNECTION_encode ( + const LLRP_tSCLOSE_CONNECTION *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + + + + + +struct LLRP_SCLOSE_CONNECTION_RESPONSE +{ + LLRP_tSMessage hdr; + + + LLRP_tSLLRPStatus * pLLRPStatus; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdCLOSE_CONNECTION_RESPONSE; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdCLOSE_CONNECTION_RESPONSE[]; + +extern LLRP_tSCLOSE_CONNECTION_RESPONSE * +LLRP_CLOSE_CONNECTION_RESPONSE_construct (void); + +extern void +LLRP_CLOSE_CONNECTION_RESPONSE_destruct ( + LLRP_tSCLOSE_CONNECTION_RESPONSE * pThis); + +extern void +LLRP_CLOSE_CONNECTION_RESPONSE_decodeFields ( + LLRP_tSCLOSE_CONNECTION_RESPONSE * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_CLOSE_CONNECTION_RESPONSE_assimilateSubParameters ( + LLRP_tSCLOSE_CONNECTION_RESPONSE * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_CLOSE_CONNECTION_RESPONSE_encode ( + const LLRP_tSCLOSE_CONNECTION_RESPONSE *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + + +extern LLRP_tSLLRPStatus * +LLRP_CLOSE_CONNECTION_RESPONSE_getLLRPStatus ( + LLRP_tSCLOSE_CONNECTION_RESPONSE *pThis); + +extern LLRP_tResultCode +LLRP_CLOSE_CONNECTION_RESPONSE_setLLRPStatus ( + LLRP_tSCLOSE_CONNECTION_RESPONSE *pThis, + LLRP_tSLLRPStatus *pValue); + + + + +struct LLRP_SGET_REPORT +{ + LLRP_tSMessage hdr; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdGET_REPORT; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdGET_REPORT[]; + +extern LLRP_tSGET_REPORT * +LLRP_GET_REPORT_construct (void); + +extern void +LLRP_GET_REPORT_destruct ( + LLRP_tSGET_REPORT * pThis); + +extern void +LLRP_GET_REPORT_decodeFields ( + LLRP_tSGET_REPORT * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_GET_REPORT_assimilateSubParameters ( + LLRP_tSGET_REPORT * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_GET_REPORT_encode ( + const LLRP_tSGET_REPORT *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + + + + + +struct LLRP_SRO_ACCESS_REPORT +{ + LLRP_tSMessage hdr; + + + LLRP_tSTagReportData * listTagReportData; + + LLRP_tSRFSurveyReportData * listRFSurveyReportData; + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdRO_ACCESS_REPORT; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdRO_ACCESS_REPORT[]; + +extern LLRP_tSRO_ACCESS_REPORT * +LLRP_RO_ACCESS_REPORT_construct (void); + +extern void +LLRP_RO_ACCESS_REPORT_destruct ( + LLRP_tSRO_ACCESS_REPORT * pThis); + +extern void +LLRP_RO_ACCESS_REPORT_decodeFields ( + LLRP_tSRO_ACCESS_REPORT * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_RO_ACCESS_REPORT_assimilateSubParameters ( + LLRP_tSRO_ACCESS_REPORT * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_RO_ACCESS_REPORT_encode ( + const LLRP_tSRO_ACCESS_REPORT *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + + +extern LLRP_tSTagReportData * +LLRP_RO_ACCESS_REPORT_beginTagReportData ( + LLRP_tSRO_ACCESS_REPORT *pThis); + +extern LLRP_tSTagReportData * +LLRP_RO_ACCESS_REPORT_nextTagReportData ( + LLRP_tSTagReportData *pCurrent); + +extern void +LLRP_RO_ACCESS_REPORT_clearTagReportData ( + LLRP_tSRO_ACCESS_REPORT *pThis); + +extern int +LLRP_RO_ACCESS_REPORT_countTagReportData ( + LLRP_tSRO_ACCESS_REPORT *pThis); + +extern LLRP_tResultCode +LLRP_RO_ACCESS_REPORT_addTagReportData ( + LLRP_tSRO_ACCESS_REPORT *pThis, + LLRP_tSTagReportData *pValue); + + +extern LLRP_tSRFSurveyReportData * +LLRP_RO_ACCESS_REPORT_beginRFSurveyReportData ( + LLRP_tSRO_ACCESS_REPORT *pThis); + +extern LLRP_tSRFSurveyReportData * +LLRP_RO_ACCESS_REPORT_nextRFSurveyReportData ( + LLRP_tSRFSurveyReportData *pCurrent); + +extern void +LLRP_RO_ACCESS_REPORT_clearRFSurveyReportData ( + LLRP_tSRO_ACCESS_REPORT *pThis); + +extern int +LLRP_RO_ACCESS_REPORT_countRFSurveyReportData ( + LLRP_tSRO_ACCESS_REPORT *pThis); + +extern LLRP_tResultCode +LLRP_RO_ACCESS_REPORT_addRFSurveyReportData ( + LLRP_tSRO_ACCESS_REPORT *pThis, + LLRP_tSRFSurveyReportData *pValue); + + +extern LLRP_tSParameter * +LLRP_RO_ACCESS_REPORT_beginCustom ( + LLRP_tSRO_ACCESS_REPORT *pThis); + +extern LLRP_tSParameter * +LLRP_RO_ACCESS_REPORT_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_RO_ACCESS_REPORT_clearCustom ( + LLRP_tSRO_ACCESS_REPORT *pThis); + +extern int +LLRP_RO_ACCESS_REPORT_countCustom ( + LLRP_tSRO_ACCESS_REPORT *pThis); + +extern LLRP_tResultCode +LLRP_RO_ACCESS_REPORT_addCustom ( + LLRP_tSRO_ACCESS_REPORT *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SKEEPALIVE +{ + LLRP_tSMessage hdr; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdKEEPALIVE; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdKEEPALIVE[]; + +extern LLRP_tSKEEPALIVE * +LLRP_KEEPALIVE_construct (void); + +extern void +LLRP_KEEPALIVE_destruct ( + LLRP_tSKEEPALIVE * pThis); + +extern void +LLRP_KEEPALIVE_decodeFields ( + LLRP_tSKEEPALIVE * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_KEEPALIVE_assimilateSubParameters ( + LLRP_tSKEEPALIVE * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_KEEPALIVE_encode ( + const LLRP_tSKEEPALIVE *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + + + + + +struct LLRP_SKEEPALIVE_ACK +{ + LLRP_tSMessage hdr; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdKEEPALIVE_ACK; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdKEEPALIVE_ACK[]; + +extern LLRP_tSKEEPALIVE_ACK * +LLRP_KEEPALIVE_ACK_construct (void); + +extern void +LLRP_KEEPALIVE_ACK_destruct ( + LLRP_tSKEEPALIVE_ACK * pThis); + +extern void +LLRP_KEEPALIVE_ACK_decodeFields ( + LLRP_tSKEEPALIVE_ACK * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_KEEPALIVE_ACK_assimilateSubParameters ( + LLRP_tSKEEPALIVE_ACK * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_KEEPALIVE_ACK_encode ( + const LLRP_tSKEEPALIVE_ACK *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + + + + + +struct LLRP_SREADER_EVENT_NOTIFICATION +{ + LLRP_tSMessage hdr; + + + LLRP_tSReaderEventNotificationData * pReaderEventNotificationData; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdREADER_EVENT_NOTIFICATION; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdREADER_EVENT_NOTIFICATION[]; + +extern LLRP_tSREADER_EVENT_NOTIFICATION * +LLRP_READER_EVENT_NOTIFICATION_construct (void); + +extern void +LLRP_READER_EVENT_NOTIFICATION_destruct ( + LLRP_tSREADER_EVENT_NOTIFICATION * pThis); + +extern void +LLRP_READER_EVENT_NOTIFICATION_decodeFields ( + LLRP_tSREADER_EVENT_NOTIFICATION * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_READER_EVENT_NOTIFICATION_assimilateSubParameters ( + LLRP_tSREADER_EVENT_NOTIFICATION * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_READER_EVENT_NOTIFICATION_encode ( + const LLRP_tSREADER_EVENT_NOTIFICATION *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + + +extern LLRP_tSReaderEventNotificationData * +LLRP_READER_EVENT_NOTIFICATION_getReaderEventNotificationData ( + LLRP_tSREADER_EVENT_NOTIFICATION *pThis); + +extern LLRP_tResultCode +LLRP_READER_EVENT_NOTIFICATION_setReaderEventNotificationData ( + LLRP_tSREADER_EVENT_NOTIFICATION *pThis, + LLRP_tSReaderEventNotificationData *pValue); + + + + +struct LLRP_SENABLE_EVENTS_AND_REPORTS +{ + LLRP_tSMessage hdr; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdENABLE_EVENTS_AND_REPORTS; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdENABLE_EVENTS_AND_REPORTS[]; + +extern LLRP_tSENABLE_EVENTS_AND_REPORTS * +LLRP_ENABLE_EVENTS_AND_REPORTS_construct (void); + +extern void +LLRP_ENABLE_EVENTS_AND_REPORTS_destruct ( + LLRP_tSENABLE_EVENTS_AND_REPORTS * pThis); + +extern void +LLRP_ENABLE_EVENTS_AND_REPORTS_decodeFields ( + LLRP_tSENABLE_EVENTS_AND_REPORTS * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ENABLE_EVENTS_AND_REPORTS_assimilateSubParameters ( + LLRP_tSENABLE_EVENTS_AND_REPORTS * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ENABLE_EVENTS_AND_REPORTS_encode ( + const LLRP_tSENABLE_EVENTS_AND_REPORTS *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + + + + + +struct LLRP_SERROR_MESSAGE +{ + LLRP_tSMessage hdr; + + + LLRP_tSLLRPStatus * pLLRPStatus; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdERROR_MESSAGE; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdERROR_MESSAGE[]; + +extern LLRP_tSERROR_MESSAGE * +LLRP_ERROR_MESSAGE_construct (void); + +extern void +LLRP_ERROR_MESSAGE_destruct ( + LLRP_tSERROR_MESSAGE * pThis); + +extern void +LLRP_ERROR_MESSAGE_decodeFields ( + LLRP_tSERROR_MESSAGE * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ERROR_MESSAGE_assimilateSubParameters ( + LLRP_tSERROR_MESSAGE * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ERROR_MESSAGE_encode ( + const LLRP_tSERROR_MESSAGE *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + + +extern LLRP_tSLLRPStatus * +LLRP_ERROR_MESSAGE_getLLRPStatus ( + LLRP_tSERROR_MESSAGE *pThis); + +extern LLRP_tResultCode +LLRP_ERROR_MESSAGE_setLLRPStatus ( + LLRP_tSERROR_MESSAGE *pThis, + LLRP_tSLLRPStatus *pValue); + + + + +struct LLRP_SUTCTimestamp +{ + LLRP_tSParameter hdr; + + llrp_u64_t Microseconds; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdUTCTimestamp; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdUTCTimestamp[]; + +extern LLRP_tSUTCTimestamp * +LLRP_UTCTimestamp_construct (void); + +extern void +LLRP_UTCTimestamp_destruct ( + LLRP_tSUTCTimestamp * pThis); + +extern void +LLRP_UTCTimestamp_decodeFields ( + LLRP_tSUTCTimestamp * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_UTCTimestamp_assimilateSubParameters ( + LLRP_tSUTCTimestamp * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_UTCTimestamp_encode ( + const LLRP_tSUTCTimestamp *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdUTCTimestamp_Microseconds; + +extern llrp_u64_t +LLRP_UTCTimestamp_getMicroseconds ( + LLRP_tSUTCTimestamp *pThis); + +extern LLRP_tResultCode +LLRP_UTCTimestamp_setMicroseconds ( + LLRP_tSUTCTimestamp *pThis, + llrp_u64_t Value); + + + + + +struct LLRP_SUptime +{ + LLRP_tSParameter hdr; + + llrp_u64_t Microseconds; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdUptime; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdUptime[]; + +extern LLRP_tSUptime * +LLRP_Uptime_construct (void); + +extern void +LLRP_Uptime_destruct ( + LLRP_tSUptime * pThis); + +extern void +LLRP_Uptime_decodeFields ( + LLRP_tSUptime * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_Uptime_assimilateSubParameters ( + LLRP_tSUptime * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_Uptime_encode ( + const LLRP_tSUptime *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdUptime_Microseconds; + +extern llrp_u64_t +LLRP_Uptime_getMicroseconds ( + LLRP_tSUptime *pThis); + +extern LLRP_tResultCode +LLRP_Uptime_setMicroseconds ( + LLRP_tSUptime *pThis, + llrp_u64_t Value); + + + + + +struct LLRP_SCustom +{ + LLRP_tSParameter hdr; + + llrp_u32_t VendorIdentifier; + + llrp_u32_t ParameterSubtype; + + llrp_bytesToEnd_t Data; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdCustom; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdCustom[]; + +extern LLRP_tSCustom * +LLRP_Custom_construct (void); + +extern void +LLRP_Custom_destruct ( + LLRP_tSCustom * pThis); + +extern void +LLRP_Custom_decodeFields ( + LLRP_tSCustom * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_Custom_assimilateSubParameters ( + LLRP_tSCustom * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_Custom_encode ( + const LLRP_tSCustom *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdCustom_VendorIdentifier; + +extern llrp_u32_t +LLRP_Custom_getVendorIdentifier ( + LLRP_tSCustom *pThis); + +extern LLRP_tResultCode +LLRP_Custom_setVendorIdentifier ( + LLRP_tSCustom *pThis, + llrp_u32_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdCustom_ParameterSubtype; + +extern llrp_u32_t +LLRP_Custom_getParameterSubtype ( + LLRP_tSCustom *pThis); + +extern LLRP_tResultCode +LLRP_Custom_setParameterSubtype ( + LLRP_tSCustom *pThis, + llrp_u32_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdCustom_Data; + +extern llrp_bytesToEnd_t +LLRP_Custom_getData ( + LLRP_tSCustom *pThis); + +extern LLRP_tResultCode +LLRP_Custom_setData ( + LLRP_tSCustom *pThis, + llrp_bytesToEnd_t Value); + + + + + +struct LLRP_SGeneralDeviceCapabilities +{ + LLRP_tSParameter hdr; + + llrp_u16_t MaxNumberOfAntennaSupported; + + llrp_u1_t CanSetAntennaProperties; + + llrp_u1_t HasUTCClockCapability; + + llrp_u32_t DeviceManufacturerName; + + llrp_u32_t ModelName; + + llrp_utf8v_t ReaderFirmwareVersion; + + + LLRP_tSReceiveSensitivityTableEntry * listReceiveSensitivityTableEntry; + + LLRP_tSPerAntennaReceiveSensitivityRange * listPerAntennaReceiveSensitivityRange; + + LLRP_tSGPIOCapabilities * pGPIOCapabilities; + + LLRP_tSPerAntennaAirProtocol * listPerAntennaAirProtocol; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdGeneralDeviceCapabilities; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdGeneralDeviceCapabilities[]; + +extern LLRP_tSGeneralDeviceCapabilities * +LLRP_GeneralDeviceCapabilities_construct (void); + +extern void +LLRP_GeneralDeviceCapabilities_destruct ( + LLRP_tSGeneralDeviceCapabilities * pThis); + +extern void +LLRP_GeneralDeviceCapabilities_decodeFields ( + LLRP_tSGeneralDeviceCapabilities * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_GeneralDeviceCapabilities_assimilateSubParameters ( + LLRP_tSGeneralDeviceCapabilities * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_GeneralDeviceCapabilities_encode ( + const LLRP_tSGeneralDeviceCapabilities *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdGeneralDeviceCapabilities_MaxNumberOfAntennaSupported; + +extern llrp_u16_t +LLRP_GeneralDeviceCapabilities_getMaxNumberOfAntennaSupported ( + LLRP_tSGeneralDeviceCapabilities *pThis); + +extern LLRP_tResultCode +LLRP_GeneralDeviceCapabilities_setMaxNumberOfAntennaSupported ( + LLRP_tSGeneralDeviceCapabilities *pThis, + llrp_u16_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdGeneralDeviceCapabilities_CanSetAntennaProperties; + +extern llrp_u1_t +LLRP_GeneralDeviceCapabilities_getCanSetAntennaProperties ( + LLRP_tSGeneralDeviceCapabilities *pThis); + +extern LLRP_tResultCode +LLRP_GeneralDeviceCapabilities_setCanSetAntennaProperties ( + LLRP_tSGeneralDeviceCapabilities *pThis, + llrp_u1_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdGeneralDeviceCapabilities_HasUTCClockCapability; + +extern llrp_u1_t +LLRP_GeneralDeviceCapabilities_getHasUTCClockCapability ( + LLRP_tSGeneralDeviceCapabilities *pThis); + +extern LLRP_tResultCode +LLRP_GeneralDeviceCapabilities_setHasUTCClockCapability ( + LLRP_tSGeneralDeviceCapabilities *pThis, + llrp_u1_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdGeneralDeviceCapabilities_DeviceManufacturerName; + +extern llrp_u32_t +LLRP_GeneralDeviceCapabilities_getDeviceManufacturerName ( + LLRP_tSGeneralDeviceCapabilities *pThis); + +extern LLRP_tResultCode +LLRP_GeneralDeviceCapabilities_setDeviceManufacturerName ( + LLRP_tSGeneralDeviceCapabilities *pThis, + llrp_u32_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdGeneralDeviceCapabilities_ModelName; + +extern llrp_u32_t +LLRP_GeneralDeviceCapabilities_getModelName ( + LLRP_tSGeneralDeviceCapabilities *pThis); + +extern LLRP_tResultCode +LLRP_GeneralDeviceCapabilities_setModelName ( + LLRP_tSGeneralDeviceCapabilities *pThis, + llrp_u32_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdGeneralDeviceCapabilities_ReaderFirmwareVersion; + +extern llrp_utf8v_t +LLRP_GeneralDeviceCapabilities_getReaderFirmwareVersion ( + LLRP_tSGeneralDeviceCapabilities *pThis); + +extern LLRP_tResultCode +LLRP_GeneralDeviceCapabilities_setReaderFirmwareVersion ( + LLRP_tSGeneralDeviceCapabilities *pThis, + llrp_utf8v_t Value); + + +extern LLRP_tSReceiveSensitivityTableEntry * +LLRP_GeneralDeviceCapabilities_beginReceiveSensitivityTableEntry ( + LLRP_tSGeneralDeviceCapabilities *pThis); + +extern LLRP_tSReceiveSensitivityTableEntry * +LLRP_GeneralDeviceCapabilities_nextReceiveSensitivityTableEntry ( + LLRP_tSReceiveSensitivityTableEntry *pCurrent); + +extern void +LLRP_GeneralDeviceCapabilities_clearReceiveSensitivityTableEntry ( + LLRP_tSGeneralDeviceCapabilities *pThis); + +extern int +LLRP_GeneralDeviceCapabilities_countReceiveSensitivityTableEntry ( + LLRP_tSGeneralDeviceCapabilities *pThis); + +extern LLRP_tResultCode +LLRP_GeneralDeviceCapabilities_addReceiveSensitivityTableEntry ( + LLRP_tSGeneralDeviceCapabilities *pThis, + LLRP_tSReceiveSensitivityTableEntry *pValue); + + +extern LLRP_tSPerAntennaReceiveSensitivityRange * +LLRP_GeneralDeviceCapabilities_beginPerAntennaReceiveSensitivityRange ( + LLRP_tSGeneralDeviceCapabilities *pThis); + +extern LLRP_tSPerAntennaReceiveSensitivityRange * +LLRP_GeneralDeviceCapabilities_nextPerAntennaReceiveSensitivityRange ( + LLRP_tSPerAntennaReceiveSensitivityRange *pCurrent); + +extern void +LLRP_GeneralDeviceCapabilities_clearPerAntennaReceiveSensitivityRange ( + LLRP_tSGeneralDeviceCapabilities *pThis); + +extern int +LLRP_GeneralDeviceCapabilities_countPerAntennaReceiveSensitivityRange ( + LLRP_tSGeneralDeviceCapabilities *pThis); + +extern LLRP_tResultCode +LLRP_GeneralDeviceCapabilities_addPerAntennaReceiveSensitivityRange ( + LLRP_tSGeneralDeviceCapabilities *pThis, + LLRP_tSPerAntennaReceiveSensitivityRange *pValue); + + +extern LLRP_tSGPIOCapabilities * +LLRP_GeneralDeviceCapabilities_getGPIOCapabilities ( + LLRP_tSGeneralDeviceCapabilities *pThis); + +extern LLRP_tResultCode +LLRP_GeneralDeviceCapabilities_setGPIOCapabilities ( + LLRP_tSGeneralDeviceCapabilities *pThis, + LLRP_tSGPIOCapabilities *pValue); + +extern LLRP_tSPerAntennaAirProtocol * +LLRP_GeneralDeviceCapabilities_beginPerAntennaAirProtocol ( + LLRP_tSGeneralDeviceCapabilities *pThis); + +extern LLRP_tSPerAntennaAirProtocol * +LLRP_GeneralDeviceCapabilities_nextPerAntennaAirProtocol ( + LLRP_tSPerAntennaAirProtocol *pCurrent); + +extern void +LLRP_GeneralDeviceCapabilities_clearPerAntennaAirProtocol ( + LLRP_tSGeneralDeviceCapabilities *pThis); + +extern int +LLRP_GeneralDeviceCapabilities_countPerAntennaAirProtocol ( + LLRP_tSGeneralDeviceCapabilities *pThis); + +extern LLRP_tResultCode +LLRP_GeneralDeviceCapabilities_addPerAntennaAirProtocol ( + LLRP_tSGeneralDeviceCapabilities *pThis, + LLRP_tSPerAntennaAirProtocol *pValue); + + + + + +struct LLRP_SReceiveSensitivityTableEntry +{ + LLRP_tSParameter hdr; + + llrp_u16_t Index; + + llrp_s16_t ReceiveSensitivityValue; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdReceiveSensitivityTableEntry; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdReceiveSensitivityTableEntry[]; + +extern LLRP_tSReceiveSensitivityTableEntry * +LLRP_ReceiveSensitivityTableEntry_construct (void); + +extern void +LLRP_ReceiveSensitivityTableEntry_destruct ( + LLRP_tSReceiveSensitivityTableEntry * pThis); + +extern void +LLRP_ReceiveSensitivityTableEntry_decodeFields ( + LLRP_tSReceiveSensitivityTableEntry * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ReceiveSensitivityTableEntry_assimilateSubParameters ( + LLRP_tSReceiveSensitivityTableEntry * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ReceiveSensitivityTableEntry_encode ( + const LLRP_tSReceiveSensitivityTableEntry *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdReceiveSensitivityTableEntry_Index; + +extern llrp_u16_t +LLRP_ReceiveSensitivityTableEntry_getIndex ( + LLRP_tSReceiveSensitivityTableEntry *pThis); + +extern LLRP_tResultCode +LLRP_ReceiveSensitivityTableEntry_setIndex ( + LLRP_tSReceiveSensitivityTableEntry *pThis, + llrp_u16_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdReceiveSensitivityTableEntry_ReceiveSensitivityValue; + +extern llrp_s16_t +LLRP_ReceiveSensitivityTableEntry_getReceiveSensitivityValue ( + LLRP_tSReceiveSensitivityTableEntry *pThis); + +extern LLRP_tResultCode +LLRP_ReceiveSensitivityTableEntry_setReceiveSensitivityValue ( + LLRP_tSReceiveSensitivityTableEntry *pThis, + llrp_s16_t Value); + + + + + +struct LLRP_SPerAntennaReceiveSensitivityRange +{ + LLRP_tSParameter hdr; + + llrp_u16_t AntennaID; + + llrp_u16_t ReceiveSensitivityIndexMin; + + llrp_u16_t ReceiveSensitivityIndexMax; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdPerAntennaReceiveSensitivityRange; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdPerAntennaReceiveSensitivityRange[]; + +extern LLRP_tSPerAntennaReceiveSensitivityRange * +LLRP_PerAntennaReceiveSensitivityRange_construct (void); + +extern void +LLRP_PerAntennaReceiveSensitivityRange_destruct ( + LLRP_tSPerAntennaReceiveSensitivityRange * pThis); + +extern void +LLRP_PerAntennaReceiveSensitivityRange_decodeFields ( + LLRP_tSPerAntennaReceiveSensitivityRange * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_PerAntennaReceiveSensitivityRange_assimilateSubParameters ( + LLRP_tSPerAntennaReceiveSensitivityRange * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_PerAntennaReceiveSensitivityRange_encode ( + const LLRP_tSPerAntennaReceiveSensitivityRange *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdPerAntennaReceiveSensitivityRange_AntennaID; + +extern llrp_u16_t +LLRP_PerAntennaReceiveSensitivityRange_getAntennaID ( + LLRP_tSPerAntennaReceiveSensitivityRange *pThis); + +extern LLRP_tResultCode +LLRP_PerAntennaReceiveSensitivityRange_setAntennaID ( + LLRP_tSPerAntennaReceiveSensitivityRange *pThis, + llrp_u16_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdPerAntennaReceiveSensitivityRange_ReceiveSensitivityIndexMin; + +extern llrp_u16_t +LLRP_PerAntennaReceiveSensitivityRange_getReceiveSensitivityIndexMin ( + LLRP_tSPerAntennaReceiveSensitivityRange *pThis); + +extern LLRP_tResultCode +LLRP_PerAntennaReceiveSensitivityRange_setReceiveSensitivityIndexMin ( + LLRP_tSPerAntennaReceiveSensitivityRange *pThis, + llrp_u16_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdPerAntennaReceiveSensitivityRange_ReceiveSensitivityIndexMax; + +extern llrp_u16_t +LLRP_PerAntennaReceiveSensitivityRange_getReceiveSensitivityIndexMax ( + LLRP_tSPerAntennaReceiveSensitivityRange *pThis); + +extern LLRP_tResultCode +LLRP_PerAntennaReceiveSensitivityRange_setReceiveSensitivityIndexMax ( + LLRP_tSPerAntennaReceiveSensitivityRange *pThis, + llrp_u16_t Value); + + + + + +struct LLRP_SPerAntennaAirProtocol +{ + LLRP_tSParameter hdr; + + llrp_u16_t AntennaID; + + llrp_u8v_t ProtocolID; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdPerAntennaAirProtocol; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdPerAntennaAirProtocol[]; + +extern LLRP_tSPerAntennaAirProtocol * +LLRP_PerAntennaAirProtocol_construct (void); + +extern void +LLRP_PerAntennaAirProtocol_destruct ( + LLRP_tSPerAntennaAirProtocol * pThis); + +extern void +LLRP_PerAntennaAirProtocol_decodeFields ( + LLRP_tSPerAntennaAirProtocol * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_PerAntennaAirProtocol_assimilateSubParameters ( + LLRP_tSPerAntennaAirProtocol * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_PerAntennaAirProtocol_encode ( + const LLRP_tSPerAntennaAirProtocol *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdPerAntennaAirProtocol_AntennaID; + +extern llrp_u16_t +LLRP_PerAntennaAirProtocol_getAntennaID ( + LLRP_tSPerAntennaAirProtocol *pThis); + +extern LLRP_tResultCode +LLRP_PerAntennaAirProtocol_setAntennaID ( + LLRP_tSPerAntennaAirProtocol *pThis, + llrp_u16_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdPerAntennaAirProtocol_ProtocolID; + +extern llrp_u8v_t +LLRP_PerAntennaAirProtocol_getProtocolID ( + LLRP_tSPerAntennaAirProtocol *pThis); + +extern LLRP_tResultCode +LLRP_PerAntennaAirProtocol_setProtocolID ( + LLRP_tSPerAntennaAirProtocol *pThis, + llrp_u8v_t Value); + + + + + +struct LLRP_SGPIOCapabilities +{ + LLRP_tSParameter hdr; + + llrp_u16_t NumGPIs; + + llrp_u16_t NumGPOs; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdGPIOCapabilities; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdGPIOCapabilities[]; + +extern LLRP_tSGPIOCapabilities * +LLRP_GPIOCapabilities_construct (void); + +extern void +LLRP_GPIOCapabilities_destruct ( + LLRP_tSGPIOCapabilities * pThis); + +extern void +LLRP_GPIOCapabilities_decodeFields ( + LLRP_tSGPIOCapabilities * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_GPIOCapabilities_assimilateSubParameters ( + LLRP_tSGPIOCapabilities * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_GPIOCapabilities_encode ( + const LLRP_tSGPIOCapabilities *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdGPIOCapabilities_NumGPIs; + +extern llrp_u16_t +LLRP_GPIOCapabilities_getNumGPIs ( + LLRP_tSGPIOCapabilities *pThis); + +extern LLRP_tResultCode +LLRP_GPIOCapabilities_setNumGPIs ( + LLRP_tSGPIOCapabilities *pThis, + llrp_u16_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdGPIOCapabilities_NumGPOs; + +extern llrp_u16_t +LLRP_GPIOCapabilities_getNumGPOs ( + LLRP_tSGPIOCapabilities *pThis); + +extern LLRP_tResultCode +LLRP_GPIOCapabilities_setNumGPOs ( + LLRP_tSGPIOCapabilities *pThis, + llrp_u16_t Value); + + + + + +struct LLRP_SLLRPCapabilities +{ + LLRP_tSParameter hdr; + + llrp_u1_t CanDoRFSurvey; + + llrp_u1_t CanReportBufferFillWarning; + + llrp_u1_t SupportsClientRequestOpSpec; + + llrp_u1_t CanDoTagInventoryStateAwareSingulation; + + llrp_u1_t SupportsEventAndReportHolding; + + llrp_u8_t MaxNumPriorityLevelsSupported; + + llrp_u16_t ClientRequestOpSpecTimeout; + + llrp_u32_t MaxNumROSpecs; + + llrp_u32_t MaxNumSpecsPerROSpec; + + llrp_u32_t MaxNumInventoryParameterSpecsPerAISpec; + + llrp_u32_t MaxNumAccessSpecs; + + llrp_u32_t MaxNumOpSpecsPerAccessSpec; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdLLRPCapabilities; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdLLRPCapabilities[]; + +extern LLRP_tSLLRPCapabilities * +LLRP_LLRPCapabilities_construct (void); + +extern void +LLRP_LLRPCapabilities_destruct ( + LLRP_tSLLRPCapabilities * pThis); + +extern void +LLRP_LLRPCapabilities_decodeFields ( + LLRP_tSLLRPCapabilities * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_LLRPCapabilities_assimilateSubParameters ( + LLRP_tSLLRPCapabilities * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_LLRPCapabilities_encode ( + const LLRP_tSLLRPCapabilities *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdLLRPCapabilities_CanDoRFSurvey; + +extern llrp_u1_t +LLRP_LLRPCapabilities_getCanDoRFSurvey ( + LLRP_tSLLRPCapabilities *pThis); + +extern LLRP_tResultCode +LLRP_LLRPCapabilities_setCanDoRFSurvey ( + LLRP_tSLLRPCapabilities *pThis, + llrp_u1_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdLLRPCapabilities_CanReportBufferFillWarning; + +extern llrp_u1_t +LLRP_LLRPCapabilities_getCanReportBufferFillWarning ( + LLRP_tSLLRPCapabilities *pThis); + +extern LLRP_tResultCode +LLRP_LLRPCapabilities_setCanReportBufferFillWarning ( + LLRP_tSLLRPCapabilities *pThis, + llrp_u1_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdLLRPCapabilities_SupportsClientRequestOpSpec; + +extern llrp_u1_t +LLRP_LLRPCapabilities_getSupportsClientRequestOpSpec ( + LLRP_tSLLRPCapabilities *pThis); + +extern LLRP_tResultCode +LLRP_LLRPCapabilities_setSupportsClientRequestOpSpec ( + LLRP_tSLLRPCapabilities *pThis, + llrp_u1_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdLLRPCapabilities_CanDoTagInventoryStateAwareSingulation; + +extern llrp_u1_t +LLRP_LLRPCapabilities_getCanDoTagInventoryStateAwareSingulation ( + LLRP_tSLLRPCapabilities *pThis); + +extern LLRP_tResultCode +LLRP_LLRPCapabilities_setCanDoTagInventoryStateAwareSingulation ( + LLRP_tSLLRPCapabilities *pThis, + llrp_u1_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdLLRPCapabilities_SupportsEventAndReportHolding; + +extern llrp_u1_t +LLRP_LLRPCapabilities_getSupportsEventAndReportHolding ( + LLRP_tSLLRPCapabilities *pThis); + +extern LLRP_tResultCode +LLRP_LLRPCapabilities_setSupportsEventAndReportHolding ( + LLRP_tSLLRPCapabilities *pThis, + llrp_u1_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdLLRPCapabilities_MaxNumPriorityLevelsSupported; + +extern llrp_u8_t +LLRP_LLRPCapabilities_getMaxNumPriorityLevelsSupported ( + LLRP_tSLLRPCapabilities *pThis); + +extern LLRP_tResultCode +LLRP_LLRPCapabilities_setMaxNumPriorityLevelsSupported ( + LLRP_tSLLRPCapabilities *pThis, + llrp_u8_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdLLRPCapabilities_ClientRequestOpSpecTimeout; + +extern llrp_u16_t +LLRP_LLRPCapabilities_getClientRequestOpSpecTimeout ( + LLRP_tSLLRPCapabilities *pThis); + +extern LLRP_tResultCode +LLRP_LLRPCapabilities_setClientRequestOpSpecTimeout ( + LLRP_tSLLRPCapabilities *pThis, + llrp_u16_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdLLRPCapabilities_MaxNumROSpecs; + +extern llrp_u32_t +LLRP_LLRPCapabilities_getMaxNumROSpecs ( + LLRP_tSLLRPCapabilities *pThis); + +extern LLRP_tResultCode +LLRP_LLRPCapabilities_setMaxNumROSpecs ( + LLRP_tSLLRPCapabilities *pThis, + llrp_u32_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdLLRPCapabilities_MaxNumSpecsPerROSpec; + +extern llrp_u32_t +LLRP_LLRPCapabilities_getMaxNumSpecsPerROSpec ( + LLRP_tSLLRPCapabilities *pThis); + +extern LLRP_tResultCode +LLRP_LLRPCapabilities_setMaxNumSpecsPerROSpec ( + LLRP_tSLLRPCapabilities *pThis, + llrp_u32_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdLLRPCapabilities_MaxNumInventoryParameterSpecsPerAISpec; + +extern llrp_u32_t +LLRP_LLRPCapabilities_getMaxNumInventoryParameterSpecsPerAISpec ( + LLRP_tSLLRPCapabilities *pThis); + +extern LLRP_tResultCode +LLRP_LLRPCapabilities_setMaxNumInventoryParameterSpecsPerAISpec ( + LLRP_tSLLRPCapabilities *pThis, + llrp_u32_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdLLRPCapabilities_MaxNumAccessSpecs; + +extern llrp_u32_t +LLRP_LLRPCapabilities_getMaxNumAccessSpecs ( + LLRP_tSLLRPCapabilities *pThis); + +extern LLRP_tResultCode +LLRP_LLRPCapabilities_setMaxNumAccessSpecs ( + LLRP_tSLLRPCapabilities *pThis, + llrp_u32_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdLLRPCapabilities_MaxNumOpSpecsPerAccessSpec; + +extern llrp_u32_t +LLRP_LLRPCapabilities_getMaxNumOpSpecsPerAccessSpec ( + LLRP_tSLLRPCapabilities *pThis); + +extern LLRP_tResultCode +LLRP_LLRPCapabilities_setMaxNumOpSpecsPerAccessSpec ( + LLRP_tSLLRPCapabilities *pThis, + llrp_u32_t Value); + + + + + +struct LLRP_SRegulatoryCapabilities +{ + LLRP_tSParameter hdr; + + llrp_u16_t CountryCode; + + LLRP_tECommunicationsStandard eCommunicationsStandard; + + + LLRP_tSUHFBandCapabilities * pUHFBandCapabilities; + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdRegulatoryCapabilities; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdRegulatoryCapabilities[]; + +extern LLRP_tSRegulatoryCapabilities * +LLRP_RegulatoryCapabilities_construct (void); + +extern void +LLRP_RegulatoryCapabilities_destruct ( + LLRP_tSRegulatoryCapabilities * pThis); + +extern void +LLRP_RegulatoryCapabilities_decodeFields ( + LLRP_tSRegulatoryCapabilities * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_RegulatoryCapabilities_assimilateSubParameters ( + LLRP_tSRegulatoryCapabilities * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_RegulatoryCapabilities_encode ( + const LLRP_tSRegulatoryCapabilities *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdRegulatoryCapabilities_CountryCode; + +extern llrp_u16_t +LLRP_RegulatoryCapabilities_getCountryCode ( + LLRP_tSRegulatoryCapabilities *pThis); + +extern LLRP_tResultCode +LLRP_RegulatoryCapabilities_setCountryCode ( + LLRP_tSRegulatoryCapabilities *pThis, + llrp_u16_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdRegulatoryCapabilities_CommunicationsStandard; + +extern LLRP_tECommunicationsStandard +LLRP_RegulatoryCapabilities_getCommunicationsStandard ( + LLRP_tSRegulatoryCapabilities *pThis); + +extern LLRP_tResultCode +LLRP_RegulatoryCapabilities_setCommunicationsStandard ( + LLRP_tSRegulatoryCapabilities *pThis, + LLRP_tECommunicationsStandard Value); + + +extern LLRP_tSUHFBandCapabilities * +LLRP_RegulatoryCapabilities_getUHFBandCapabilities ( + LLRP_tSRegulatoryCapabilities *pThis); + +extern LLRP_tResultCode +LLRP_RegulatoryCapabilities_setUHFBandCapabilities ( + LLRP_tSRegulatoryCapabilities *pThis, + LLRP_tSUHFBandCapabilities *pValue); + +extern LLRP_tSParameter * +LLRP_RegulatoryCapabilities_beginCustom ( + LLRP_tSRegulatoryCapabilities *pThis); + +extern LLRP_tSParameter * +LLRP_RegulatoryCapabilities_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_RegulatoryCapabilities_clearCustom ( + LLRP_tSRegulatoryCapabilities *pThis); + +extern int +LLRP_RegulatoryCapabilities_countCustom ( + LLRP_tSRegulatoryCapabilities *pThis); + +extern LLRP_tResultCode +LLRP_RegulatoryCapabilities_addCustom ( + LLRP_tSRegulatoryCapabilities *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SUHFBandCapabilities +{ + LLRP_tSParameter hdr; + + + LLRP_tSTransmitPowerLevelTableEntry * listTransmitPowerLevelTableEntry; + + LLRP_tSFrequencyInformation * pFrequencyInformation; + + LLRP_tSParameter * listAirProtocolUHFRFModeTable; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdUHFBandCapabilities; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdUHFBandCapabilities[]; + +extern LLRP_tSUHFBandCapabilities * +LLRP_UHFBandCapabilities_construct (void); + +extern void +LLRP_UHFBandCapabilities_destruct ( + LLRP_tSUHFBandCapabilities * pThis); + +extern void +LLRP_UHFBandCapabilities_decodeFields ( + LLRP_tSUHFBandCapabilities * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_UHFBandCapabilities_assimilateSubParameters ( + LLRP_tSUHFBandCapabilities * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_UHFBandCapabilities_encode ( + const LLRP_tSUHFBandCapabilities *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + + +extern LLRP_tSTransmitPowerLevelTableEntry * +LLRP_UHFBandCapabilities_beginTransmitPowerLevelTableEntry ( + LLRP_tSUHFBandCapabilities *pThis); + +extern LLRP_tSTransmitPowerLevelTableEntry * +LLRP_UHFBandCapabilities_nextTransmitPowerLevelTableEntry ( + LLRP_tSTransmitPowerLevelTableEntry *pCurrent); + +extern void +LLRP_UHFBandCapabilities_clearTransmitPowerLevelTableEntry ( + LLRP_tSUHFBandCapabilities *pThis); + +extern int +LLRP_UHFBandCapabilities_countTransmitPowerLevelTableEntry ( + LLRP_tSUHFBandCapabilities *pThis); + +extern LLRP_tResultCode +LLRP_UHFBandCapabilities_addTransmitPowerLevelTableEntry ( + LLRP_tSUHFBandCapabilities *pThis, + LLRP_tSTransmitPowerLevelTableEntry *pValue); + + +extern LLRP_tSFrequencyInformation * +LLRP_UHFBandCapabilities_getFrequencyInformation ( + LLRP_tSUHFBandCapabilities *pThis); + +extern LLRP_tResultCode +LLRP_UHFBandCapabilities_setFrequencyInformation ( + LLRP_tSUHFBandCapabilities *pThis, + LLRP_tSFrequencyInformation *pValue); + +extern LLRP_tSParameter * +LLRP_UHFBandCapabilities_beginAirProtocolUHFRFModeTable ( + LLRP_tSUHFBandCapabilities *pThis); + +extern LLRP_tSParameter * +LLRP_UHFBandCapabilities_nextAirProtocolUHFRFModeTable ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_UHFBandCapabilities_clearAirProtocolUHFRFModeTable ( + LLRP_tSUHFBandCapabilities *pThis); + +extern int +LLRP_UHFBandCapabilities_countAirProtocolUHFRFModeTable ( + LLRP_tSUHFBandCapabilities *pThis); + +extern LLRP_tResultCode +LLRP_UHFBandCapabilities_addAirProtocolUHFRFModeTable ( + LLRP_tSUHFBandCapabilities *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_STransmitPowerLevelTableEntry +{ + LLRP_tSParameter hdr; + + llrp_u16_t Index; + + llrp_s16_t TransmitPowerValue; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdTransmitPowerLevelTableEntry; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdTransmitPowerLevelTableEntry[]; + +extern LLRP_tSTransmitPowerLevelTableEntry * +LLRP_TransmitPowerLevelTableEntry_construct (void); + +extern void +LLRP_TransmitPowerLevelTableEntry_destruct ( + LLRP_tSTransmitPowerLevelTableEntry * pThis); + +extern void +LLRP_TransmitPowerLevelTableEntry_decodeFields ( + LLRP_tSTransmitPowerLevelTableEntry * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_TransmitPowerLevelTableEntry_assimilateSubParameters ( + LLRP_tSTransmitPowerLevelTableEntry * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_TransmitPowerLevelTableEntry_encode ( + const LLRP_tSTransmitPowerLevelTableEntry *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdTransmitPowerLevelTableEntry_Index; + +extern llrp_u16_t +LLRP_TransmitPowerLevelTableEntry_getIndex ( + LLRP_tSTransmitPowerLevelTableEntry *pThis); + +extern LLRP_tResultCode +LLRP_TransmitPowerLevelTableEntry_setIndex ( + LLRP_tSTransmitPowerLevelTableEntry *pThis, + llrp_u16_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdTransmitPowerLevelTableEntry_TransmitPowerValue; + +extern llrp_s16_t +LLRP_TransmitPowerLevelTableEntry_getTransmitPowerValue ( + LLRP_tSTransmitPowerLevelTableEntry *pThis); + +extern LLRP_tResultCode +LLRP_TransmitPowerLevelTableEntry_setTransmitPowerValue ( + LLRP_tSTransmitPowerLevelTableEntry *pThis, + llrp_s16_t Value); + + + + + +struct LLRP_SFrequencyInformation +{ + LLRP_tSParameter hdr; + + llrp_u1_t Hopping; + + + LLRP_tSFrequencyHopTable * listFrequencyHopTable; + + LLRP_tSFixedFrequencyTable * pFixedFrequencyTable; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdFrequencyInformation; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdFrequencyInformation[]; + +extern LLRP_tSFrequencyInformation * +LLRP_FrequencyInformation_construct (void); + +extern void +LLRP_FrequencyInformation_destruct ( + LLRP_tSFrequencyInformation * pThis); + +extern void +LLRP_FrequencyInformation_decodeFields ( + LLRP_tSFrequencyInformation * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_FrequencyInformation_assimilateSubParameters ( + LLRP_tSFrequencyInformation * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_FrequencyInformation_encode ( + const LLRP_tSFrequencyInformation *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdFrequencyInformation_Hopping; + +extern llrp_u1_t +LLRP_FrequencyInformation_getHopping ( + LLRP_tSFrequencyInformation *pThis); + +extern LLRP_tResultCode +LLRP_FrequencyInformation_setHopping ( + LLRP_tSFrequencyInformation *pThis, + llrp_u1_t Value); + + +extern LLRP_tSFrequencyHopTable * +LLRP_FrequencyInformation_beginFrequencyHopTable ( + LLRP_tSFrequencyInformation *pThis); + +extern LLRP_tSFrequencyHopTable * +LLRP_FrequencyInformation_nextFrequencyHopTable ( + LLRP_tSFrequencyHopTable *pCurrent); + +extern void +LLRP_FrequencyInformation_clearFrequencyHopTable ( + LLRP_tSFrequencyInformation *pThis); + +extern int +LLRP_FrequencyInformation_countFrequencyHopTable ( + LLRP_tSFrequencyInformation *pThis); + +extern LLRP_tResultCode +LLRP_FrequencyInformation_addFrequencyHopTable ( + LLRP_tSFrequencyInformation *pThis, + LLRP_tSFrequencyHopTable *pValue); + + +extern LLRP_tSFixedFrequencyTable * +LLRP_FrequencyInformation_getFixedFrequencyTable ( + LLRP_tSFrequencyInformation *pThis); + +extern LLRP_tResultCode +LLRP_FrequencyInformation_setFixedFrequencyTable ( + LLRP_tSFrequencyInformation *pThis, + LLRP_tSFixedFrequencyTable *pValue); + + + + +struct LLRP_SFrequencyHopTable +{ + LLRP_tSParameter hdr; + + llrp_u8_t HopTableID; + + llrp_u32v_t Frequency; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdFrequencyHopTable; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdFrequencyHopTable[]; + +extern LLRP_tSFrequencyHopTable * +LLRP_FrequencyHopTable_construct (void); + +extern void +LLRP_FrequencyHopTable_destruct ( + LLRP_tSFrequencyHopTable * pThis); + +extern void +LLRP_FrequencyHopTable_decodeFields ( + LLRP_tSFrequencyHopTable * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_FrequencyHopTable_assimilateSubParameters ( + LLRP_tSFrequencyHopTable * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_FrequencyHopTable_encode ( + const LLRP_tSFrequencyHopTable *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdFrequencyHopTable_HopTableID; + +extern llrp_u8_t +LLRP_FrequencyHopTable_getHopTableID ( + LLRP_tSFrequencyHopTable *pThis); + +extern LLRP_tResultCode +LLRP_FrequencyHopTable_setHopTableID ( + LLRP_tSFrequencyHopTable *pThis, + llrp_u8_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdFrequencyHopTable_Frequency; + +extern llrp_u32v_t +LLRP_FrequencyHopTable_getFrequency ( + LLRP_tSFrequencyHopTable *pThis); + +extern LLRP_tResultCode +LLRP_FrequencyHopTable_setFrequency ( + LLRP_tSFrequencyHopTable *pThis, + llrp_u32v_t Value); + + + + + +struct LLRP_SFixedFrequencyTable +{ + LLRP_tSParameter hdr; + + llrp_u32v_t Frequency; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdFixedFrequencyTable; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdFixedFrequencyTable[]; + +extern LLRP_tSFixedFrequencyTable * +LLRP_FixedFrequencyTable_construct (void); + +extern void +LLRP_FixedFrequencyTable_destruct ( + LLRP_tSFixedFrequencyTable * pThis); + +extern void +LLRP_FixedFrequencyTable_decodeFields ( + LLRP_tSFixedFrequencyTable * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_FixedFrequencyTable_assimilateSubParameters ( + LLRP_tSFixedFrequencyTable * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_FixedFrequencyTable_encode ( + const LLRP_tSFixedFrequencyTable *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdFixedFrequencyTable_Frequency; + +extern llrp_u32v_t +LLRP_FixedFrequencyTable_getFrequency ( + LLRP_tSFixedFrequencyTable *pThis); + +extern LLRP_tResultCode +LLRP_FixedFrequencyTable_setFrequency ( + LLRP_tSFixedFrequencyTable *pThis, + llrp_u32v_t Value); + + + + + +struct LLRP_SROSpec +{ + LLRP_tSParameter hdr; + + llrp_u32_t ROSpecID; + + llrp_u8_t Priority; + + LLRP_tEROSpecState eCurrentState; + + + LLRP_tSROBoundarySpec * pROBoundarySpec; + + LLRP_tSParameter * listSpecParameter; + + LLRP_tSROReportSpec * pROReportSpec; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdROSpec; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdROSpec[]; + +extern LLRP_tSROSpec * +LLRP_ROSpec_construct (void); + +extern void +LLRP_ROSpec_destruct ( + LLRP_tSROSpec * pThis); + +extern void +LLRP_ROSpec_decodeFields ( + LLRP_tSROSpec * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ROSpec_assimilateSubParameters ( + LLRP_tSROSpec * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ROSpec_encode ( + const LLRP_tSROSpec *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdROSpec_ROSpecID; + +extern llrp_u32_t +LLRP_ROSpec_getROSpecID ( + LLRP_tSROSpec *pThis); + +extern LLRP_tResultCode +LLRP_ROSpec_setROSpecID ( + LLRP_tSROSpec *pThis, + llrp_u32_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdROSpec_Priority; + +extern llrp_u8_t +LLRP_ROSpec_getPriority ( + LLRP_tSROSpec *pThis); + +extern LLRP_tResultCode +LLRP_ROSpec_setPriority ( + LLRP_tSROSpec *pThis, + llrp_u8_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdROSpec_CurrentState; + +extern LLRP_tEROSpecState +LLRP_ROSpec_getCurrentState ( + LLRP_tSROSpec *pThis); + +extern LLRP_tResultCode +LLRP_ROSpec_setCurrentState ( + LLRP_tSROSpec *pThis, + LLRP_tEROSpecState Value); + + +extern LLRP_tSROBoundarySpec * +LLRP_ROSpec_getROBoundarySpec ( + LLRP_tSROSpec *pThis); + +extern LLRP_tResultCode +LLRP_ROSpec_setROBoundarySpec ( + LLRP_tSROSpec *pThis, + LLRP_tSROBoundarySpec *pValue); + +extern LLRP_tSParameter * +LLRP_ROSpec_beginSpecParameter ( + LLRP_tSROSpec *pThis); + +extern LLRP_tSParameter * +LLRP_ROSpec_nextSpecParameter ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ROSpec_clearSpecParameter ( + LLRP_tSROSpec *pThis); + +extern int +LLRP_ROSpec_countSpecParameter ( + LLRP_tSROSpec *pThis); + +extern LLRP_tResultCode +LLRP_ROSpec_addSpecParameter ( + LLRP_tSROSpec *pThis, + LLRP_tSParameter *pValue); + + +extern LLRP_tSROReportSpec * +LLRP_ROSpec_getROReportSpec ( + LLRP_tSROSpec *pThis); + +extern LLRP_tResultCode +LLRP_ROSpec_setROReportSpec ( + LLRP_tSROSpec *pThis, + LLRP_tSROReportSpec *pValue); + + + + +struct LLRP_SROBoundarySpec +{ + LLRP_tSParameter hdr; + + + LLRP_tSROSpecStartTrigger * pROSpecStartTrigger; + + LLRP_tSROSpecStopTrigger * pROSpecStopTrigger; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdROBoundarySpec; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdROBoundarySpec[]; + +extern LLRP_tSROBoundarySpec * +LLRP_ROBoundarySpec_construct (void); + +extern void +LLRP_ROBoundarySpec_destruct ( + LLRP_tSROBoundarySpec * pThis); + +extern void +LLRP_ROBoundarySpec_decodeFields ( + LLRP_tSROBoundarySpec * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ROBoundarySpec_assimilateSubParameters ( + LLRP_tSROBoundarySpec * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ROBoundarySpec_encode ( + const LLRP_tSROBoundarySpec *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + + +extern LLRP_tSROSpecStartTrigger * +LLRP_ROBoundarySpec_getROSpecStartTrigger ( + LLRP_tSROBoundarySpec *pThis); + +extern LLRP_tResultCode +LLRP_ROBoundarySpec_setROSpecStartTrigger ( + LLRP_tSROBoundarySpec *pThis, + LLRP_tSROSpecStartTrigger *pValue); + +extern LLRP_tSROSpecStopTrigger * +LLRP_ROBoundarySpec_getROSpecStopTrigger ( + LLRP_tSROBoundarySpec *pThis); + +extern LLRP_tResultCode +LLRP_ROBoundarySpec_setROSpecStopTrigger ( + LLRP_tSROBoundarySpec *pThis, + LLRP_tSROSpecStopTrigger *pValue); + + + + +struct LLRP_SROSpecStartTrigger +{ + LLRP_tSParameter hdr; + + LLRP_tEROSpecStartTriggerType eROSpecStartTriggerType; + + + LLRP_tSPeriodicTriggerValue * pPeriodicTriggerValue; + + LLRP_tSGPITriggerValue * pGPITriggerValue; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdROSpecStartTrigger; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdROSpecStartTrigger[]; + +extern LLRP_tSROSpecStartTrigger * +LLRP_ROSpecStartTrigger_construct (void); + +extern void +LLRP_ROSpecStartTrigger_destruct ( + LLRP_tSROSpecStartTrigger * pThis); + +extern void +LLRP_ROSpecStartTrigger_decodeFields ( + LLRP_tSROSpecStartTrigger * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ROSpecStartTrigger_assimilateSubParameters ( + LLRP_tSROSpecStartTrigger * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ROSpecStartTrigger_encode ( + const LLRP_tSROSpecStartTrigger *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdROSpecStartTrigger_ROSpecStartTriggerType; + +extern LLRP_tEROSpecStartTriggerType +LLRP_ROSpecStartTrigger_getROSpecStartTriggerType ( + LLRP_tSROSpecStartTrigger *pThis); + +extern LLRP_tResultCode +LLRP_ROSpecStartTrigger_setROSpecStartTriggerType ( + LLRP_tSROSpecStartTrigger *pThis, + LLRP_tEROSpecStartTriggerType Value); + + +extern LLRP_tSPeriodicTriggerValue * +LLRP_ROSpecStartTrigger_getPeriodicTriggerValue ( + LLRP_tSROSpecStartTrigger *pThis); + +extern LLRP_tResultCode +LLRP_ROSpecStartTrigger_setPeriodicTriggerValue ( + LLRP_tSROSpecStartTrigger *pThis, + LLRP_tSPeriodicTriggerValue *pValue); + +extern LLRP_tSGPITriggerValue * +LLRP_ROSpecStartTrigger_getGPITriggerValue ( + LLRP_tSROSpecStartTrigger *pThis); + +extern LLRP_tResultCode +LLRP_ROSpecStartTrigger_setGPITriggerValue ( + LLRP_tSROSpecStartTrigger *pThis, + LLRP_tSGPITriggerValue *pValue); + + + + +struct LLRP_SPeriodicTriggerValue +{ + LLRP_tSParameter hdr; + + llrp_u32_t Offset; + + llrp_u32_t Period; + + + LLRP_tSUTCTimestamp * pUTCTimestamp; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdPeriodicTriggerValue; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdPeriodicTriggerValue[]; + +extern LLRP_tSPeriodicTriggerValue * +LLRP_PeriodicTriggerValue_construct (void); + +extern void +LLRP_PeriodicTriggerValue_destruct ( + LLRP_tSPeriodicTriggerValue * pThis); + +extern void +LLRP_PeriodicTriggerValue_decodeFields ( + LLRP_tSPeriodicTriggerValue * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_PeriodicTriggerValue_assimilateSubParameters ( + LLRP_tSPeriodicTriggerValue * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_PeriodicTriggerValue_encode ( + const LLRP_tSPeriodicTriggerValue *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdPeriodicTriggerValue_Offset; + +extern llrp_u32_t +LLRP_PeriodicTriggerValue_getOffset ( + LLRP_tSPeriodicTriggerValue *pThis); + +extern LLRP_tResultCode +LLRP_PeriodicTriggerValue_setOffset ( + LLRP_tSPeriodicTriggerValue *pThis, + llrp_u32_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdPeriodicTriggerValue_Period; + +extern llrp_u32_t +LLRP_PeriodicTriggerValue_getPeriod ( + LLRP_tSPeriodicTriggerValue *pThis); + +extern LLRP_tResultCode +LLRP_PeriodicTriggerValue_setPeriod ( + LLRP_tSPeriodicTriggerValue *pThis, + llrp_u32_t Value); + + +extern LLRP_tSUTCTimestamp * +LLRP_PeriodicTriggerValue_getUTCTimestamp ( + LLRP_tSPeriodicTriggerValue *pThis); + +extern LLRP_tResultCode +LLRP_PeriodicTriggerValue_setUTCTimestamp ( + LLRP_tSPeriodicTriggerValue *pThis, + LLRP_tSUTCTimestamp *pValue); + + + + +struct LLRP_SGPITriggerValue +{ + LLRP_tSParameter hdr; + + llrp_u16_t GPIPortNum; + + llrp_u1_t GPIEvent; + + llrp_u32_t Timeout; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdGPITriggerValue; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdGPITriggerValue[]; + +extern LLRP_tSGPITriggerValue * +LLRP_GPITriggerValue_construct (void); + +extern void +LLRP_GPITriggerValue_destruct ( + LLRP_tSGPITriggerValue * pThis); + +extern void +LLRP_GPITriggerValue_decodeFields ( + LLRP_tSGPITriggerValue * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_GPITriggerValue_assimilateSubParameters ( + LLRP_tSGPITriggerValue * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_GPITriggerValue_encode ( + const LLRP_tSGPITriggerValue *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdGPITriggerValue_GPIPortNum; + +extern llrp_u16_t +LLRP_GPITriggerValue_getGPIPortNum ( + LLRP_tSGPITriggerValue *pThis); + +extern LLRP_tResultCode +LLRP_GPITriggerValue_setGPIPortNum ( + LLRP_tSGPITriggerValue *pThis, + llrp_u16_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdGPITriggerValue_GPIEvent; + +extern llrp_u1_t +LLRP_GPITriggerValue_getGPIEvent ( + LLRP_tSGPITriggerValue *pThis); + +extern LLRP_tResultCode +LLRP_GPITriggerValue_setGPIEvent ( + LLRP_tSGPITriggerValue *pThis, + llrp_u1_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdGPITriggerValue_Timeout; + +extern llrp_u32_t +LLRP_GPITriggerValue_getTimeout ( + LLRP_tSGPITriggerValue *pThis); + +extern LLRP_tResultCode +LLRP_GPITriggerValue_setTimeout ( + LLRP_tSGPITriggerValue *pThis, + llrp_u32_t Value); + + + + + +struct LLRP_SROSpecStopTrigger +{ + LLRP_tSParameter hdr; + + LLRP_tEROSpecStopTriggerType eROSpecStopTriggerType; + + llrp_u32_t DurationTriggerValue; + + + LLRP_tSGPITriggerValue * pGPITriggerValue; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdROSpecStopTrigger; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdROSpecStopTrigger[]; + +extern LLRP_tSROSpecStopTrigger * +LLRP_ROSpecStopTrigger_construct (void); + +extern void +LLRP_ROSpecStopTrigger_destruct ( + LLRP_tSROSpecStopTrigger * pThis); + +extern void +LLRP_ROSpecStopTrigger_decodeFields ( + LLRP_tSROSpecStopTrigger * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ROSpecStopTrigger_assimilateSubParameters ( + LLRP_tSROSpecStopTrigger * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ROSpecStopTrigger_encode ( + const LLRP_tSROSpecStopTrigger *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdROSpecStopTrigger_ROSpecStopTriggerType; + +extern LLRP_tEROSpecStopTriggerType +LLRP_ROSpecStopTrigger_getROSpecStopTriggerType ( + LLRP_tSROSpecStopTrigger *pThis); + +extern LLRP_tResultCode +LLRP_ROSpecStopTrigger_setROSpecStopTriggerType ( + LLRP_tSROSpecStopTrigger *pThis, + LLRP_tEROSpecStopTriggerType Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdROSpecStopTrigger_DurationTriggerValue; + +extern llrp_u32_t +LLRP_ROSpecStopTrigger_getDurationTriggerValue ( + LLRP_tSROSpecStopTrigger *pThis); + +extern LLRP_tResultCode +LLRP_ROSpecStopTrigger_setDurationTriggerValue ( + LLRP_tSROSpecStopTrigger *pThis, + llrp_u32_t Value); + + +extern LLRP_tSGPITriggerValue * +LLRP_ROSpecStopTrigger_getGPITriggerValue ( + LLRP_tSROSpecStopTrigger *pThis); + +extern LLRP_tResultCode +LLRP_ROSpecStopTrigger_setGPITriggerValue ( + LLRP_tSROSpecStopTrigger *pThis, + LLRP_tSGPITriggerValue *pValue); + + + + +struct LLRP_SAISpec +{ + LLRP_tSParameter hdr; + + llrp_u16v_t AntennaIDs; + + + LLRP_tSAISpecStopTrigger * pAISpecStopTrigger; + + LLRP_tSInventoryParameterSpec * listInventoryParameterSpec; + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdAISpec; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdAISpec[]; + +extern LLRP_tSAISpec * +LLRP_AISpec_construct (void); + +extern void +LLRP_AISpec_destruct ( + LLRP_tSAISpec * pThis); + +extern void +LLRP_AISpec_decodeFields ( + LLRP_tSAISpec * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_AISpec_assimilateSubParameters ( + LLRP_tSAISpec * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_AISpec_encode ( + const LLRP_tSAISpec *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdAISpec_AntennaIDs; + +extern llrp_u16v_t +LLRP_AISpec_getAntennaIDs ( + LLRP_tSAISpec *pThis); + +extern LLRP_tResultCode +LLRP_AISpec_setAntennaIDs ( + LLRP_tSAISpec *pThis, + llrp_u16v_t Value); + + +extern LLRP_tSAISpecStopTrigger * +LLRP_AISpec_getAISpecStopTrigger ( + LLRP_tSAISpec *pThis); + +extern LLRP_tResultCode +LLRP_AISpec_setAISpecStopTrigger ( + LLRP_tSAISpec *pThis, + LLRP_tSAISpecStopTrigger *pValue); + +extern LLRP_tSInventoryParameterSpec * +LLRP_AISpec_beginInventoryParameterSpec ( + LLRP_tSAISpec *pThis); + +extern LLRP_tSInventoryParameterSpec * +LLRP_AISpec_nextInventoryParameterSpec ( + LLRP_tSInventoryParameterSpec *pCurrent); + +extern void +LLRP_AISpec_clearInventoryParameterSpec ( + LLRP_tSAISpec *pThis); + +extern int +LLRP_AISpec_countInventoryParameterSpec ( + LLRP_tSAISpec *pThis); + +extern LLRP_tResultCode +LLRP_AISpec_addInventoryParameterSpec ( + LLRP_tSAISpec *pThis, + LLRP_tSInventoryParameterSpec *pValue); + + +extern LLRP_tSParameter * +LLRP_AISpec_beginCustom ( + LLRP_tSAISpec *pThis); + +extern LLRP_tSParameter * +LLRP_AISpec_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_AISpec_clearCustom ( + LLRP_tSAISpec *pThis); + +extern int +LLRP_AISpec_countCustom ( + LLRP_tSAISpec *pThis); + +extern LLRP_tResultCode +LLRP_AISpec_addCustom ( + LLRP_tSAISpec *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SAISpecStopTrigger +{ + LLRP_tSParameter hdr; + + LLRP_tEAISpecStopTriggerType eAISpecStopTriggerType; + + llrp_u32_t DurationTrigger; + + + LLRP_tSGPITriggerValue * pGPITriggerValue; + + LLRP_tSTagObservationTrigger * pTagObservationTrigger; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdAISpecStopTrigger; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdAISpecStopTrigger[]; + +extern LLRP_tSAISpecStopTrigger * +LLRP_AISpecStopTrigger_construct (void); + +extern void +LLRP_AISpecStopTrigger_destruct ( + LLRP_tSAISpecStopTrigger * pThis); + +extern void +LLRP_AISpecStopTrigger_decodeFields ( + LLRP_tSAISpecStopTrigger * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_AISpecStopTrigger_assimilateSubParameters ( + LLRP_tSAISpecStopTrigger * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_AISpecStopTrigger_encode ( + const LLRP_tSAISpecStopTrigger *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdAISpecStopTrigger_AISpecStopTriggerType; + +extern LLRP_tEAISpecStopTriggerType +LLRP_AISpecStopTrigger_getAISpecStopTriggerType ( + LLRP_tSAISpecStopTrigger *pThis); + +extern LLRP_tResultCode +LLRP_AISpecStopTrigger_setAISpecStopTriggerType ( + LLRP_tSAISpecStopTrigger *pThis, + LLRP_tEAISpecStopTriggerType Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdAISpecStopTrigger_DurationTrigger; + +extern llrp_u32_t +LLRP_AISpecStopTrigger_getDurationTrigger ( + LLRP_tSAISpecStopTrigger *pThis); + +extern LLRP_tResultCode +LLRP_AISpecStopTrigger_setDurationTrigger ( + LLRP_tSAISpecStopTrigger *pThis, + llrp_u32_t Value); + + +extern LLRP_tSGPITriggerValue * +LLRP_AISpecStopTrigger_getGPITriggerValue ( + LLRP_tSAISpecStopTrigger *pThis); + +extern LLRP_tResultCode +LLRP_AISpecStopTrigger_setGPITriggerValue ( + LLRP_tSAISpecStopTrigger *pThis, + LLRP_tSGPITriggerValue *pValue); + +extern LLRP_tSTagObservationTrigger * +LLRP_AISpecStopTrigger_getTagObservationTrigger ( + LLRP_tSAISpecStopTrigger *pThis); + +extern LLRP_tResultCode +LLRP_AISpecStopTrigger_setTagObservationTrigger ( + LLRP_tSAISpecStopTrigger *pThis, + LLRP_tSTagObservationTrigger *pValue); + + + + +struct LLRP_STagObservationTrigger +{ + LLRP_tSParameter hdr; + + LLRP_tETagObservationTriggerType eTriggerType; + + llrp_u16_t NumberOfTags; + + llrp_u16_t NumberOfAttempts; + + llrp_u16_t T; + + llrp_u32_t Timeout; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdTagObservationTrigger; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdTagObservationTrigger[]; + +extern LLRP_tSTagObservationTrigger * +LLRP_TagObservationTrigger_construct (void); + +extern void +LLRP_TagObservationTrigger_destruct ( + LLRP_tSTagObservationTrigger * pThis); + +extern void +LLRP_TagObservationTrigger_decodeFields ( + LLRP_tSTagObservationTrigger * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_TagObservationTrigger_assimilateSubParameters ( + LLRP_tSTagObservationTrigger * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_TagObservationTrigger_encode ( + const LLRP_tSTagObservationTrigger *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdTagObservationTrigger_TriggerType; + +extern LLRP_tETagObservationTriggerType +LLRP_TagObservationTrigger_getTriggerType ( + LLRP_tSTagObservationTrigger *pThis); + +extern LLRP_tResultCode +LLRP_TagObservationTrigger_setTriggerType ( + LLRP_tSTagObservationTrigger *pThis, + LLRP_tETagObservationTriggerType Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdTagObservationTrigger_NumberOfTags; + +extern llrp_u16_t +LLRP_TagObservationTrigger_getNumberOfTags ( + LLRP_tSTagObservationTrigger *pThis); + +extern LLRP_tResultCode +LLRP_TagObservationTrigger_setNumberOfTags ( + LLRP_tSTagObservationTrigger *pThis, + llrp_u16_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdTagObservationTrigger_NumberOfAttempts; + +extern llrp_u16_t +LLRP_TagObservationTrigger_getNumberOfAttempts ( + LLRP_tSTagObservationTrigger *pThis); + +extern LLRP_tResultCode +LLRP_TagObservationTrigger_setNumberOfAttempts ( + LLRP_tSTagObservationTrigger *pThis, + llrp_u16_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdTagObservationTrigger_T; + +extern llrp_u16_t +LLRP_TagObservationTrigger_getT ( + LLRP_tSTagObservationTrigger *pThis); + +extern LLRP_tResultCode +LLRP_TagObservationTrigger_setT ( + LLRP_tSTagObservationTrigger *pThis, + llrp_u16_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdTagObservationTrigger_Timeout; + +extern llrp_u32_t +LLRP_TagObservationTrigger_getTimeout ( + LLRP_tSTagObservationTrigger *pThis); + +extern LLRP_tResultCode +LLRP_TagObservationTrigger_setTimeout ( + LLRP_tSTagObservationTrigger *pThis, + llrp_u32_t Value); + + + + + +struct LLRP_SInventoryParameterSpec +{ + LLRP_tSParameter hdr; + + llrp_u16_t InventoryParameterSpecID; + + LLRP_tEAirProtocols eProtocolID; + + + LLRP_tSAntennaConfiguration * listAntennaConfiguration; + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdInventoryParameterSpec; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdInventoryParameterSpec[]; + +extern LLRP_tSInventoryParameterSpec * +LLRP_InventoryParameterSpec_construct (void); + +extern void +LLRP_InventoryParameterSpec_destruct ( + LLRP_tSInventoryParameterSpec * pThis); + +extern void +LLRP_InventoryParameterSpec_decodeFields ( + LLRP_tSInventoryParameterSpec * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_InventoryParameterSpec_assimilateSubParameters ( + LLRP_tSInventoryParameterSpec * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_InventoryParameterSpec_encode ( + const LLRP_tSInventoryParameterSpec *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdInventoryParameterSpec_InventoryParameterSpecID; + +extern llrp_u16_t +LLRP_InventoryParameterSpec_getInventoryParameterSpecID ( + LLRP_tSInventoryParameterSpec *pThis); + +extern LLRP_tResultCode +LLRP_InventoryParameterSpec_setInventoryParameterSpecID ( + LLRP_tSInventoryParameterSpec *pThis, + llrp_u16_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdInventoryParameterSpec_ProtocolID; + +extern LLRP_tEAirProtocols +LLRP_InventoryParameterSpec_getProtocolID ( + LLRP_tSInventoryParameterSpec *pThis); + +extern LLRP_tResultCode +LLRP_InventoryParameterSpec_setProtocolID ( + LLRP_tSInventoryParameterSpec *pThis, + LLRP_tEAirProtocols Value); + + +extern LLRP_tSAntennaConfiguration * +LLRP_InventoryParameterSpec_beginAntennaConfiguration ( + LLRP_tSInventoryParameterSpec *pThis); + +extern LLRP_tSAntennaConfiguration * +LLRP_InventoryParameterSpec_nextAntennaConfiguration ( + LLRP_tSAntennaConfiguration *pCurrent); + +extern void +LLRP_InventoryParameterSpec_clearAntennaConfiguration ( + LLRP_tSInventoryParameterSpec *pThis); + +extern int +LLRP_InventoryParameterSpec_countAntennaConfiguration ( + LLRP_tSInventoryParameterSpec *pThis); + +extern LLRP_tResultCode +LLRP_InventoryParameterSpec_addAntennaConfiguration ( + LLRP_tSInventoryParameterSpec *pThis, + LLRP_tSAntennaConfiguration *pValue); + + +extern LLRP_tSParameter * +LLRP_InventoryParameterSpec_beginCustom ( + LLRP_tSInventoryParameterSpec *pThis); + +extern LLRP_tSParameter * +LLRP_InventoryParameterSpec_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_InventoryParameterSpec_clearCustom ( + LLRP_tSInventoryParameterSpec *pThis); + +extern int +LLRP_InventoryParameterSpec_countCustom ( + LLRP_tSInventoryParameterSpec *pThis); + +extern LLRP_tResultCode +LLRP_InventoryParameterSpec_addCustom ( + LLRP_tSInventoryParameterSpec *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SRFSurveySpec +{ + LLRP_tSParameter hdr; + + llrp_u16_t AntennaID; + + llrp_u32_t StartFrequency; + + llrp_u32_t EndFrequency; + + + LLRP_tSRFSurveySpecStopTrigger * pRFSurveySpecStopTrigger; + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdRFSurveySpec; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdRFSurveySpec[]; + +extern LLRP_tSRFSurveySpec * +LLRP_RFSurveySpec_construct (void); + +extern void +LLRP_RFSurveySpec_destruct ( + LLRP_tSRFSurveySpec * pThis); + +extern void +LLRP_RFSurveySpec_decodeFields ( + LLRP_tSRFSurveySpec * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_RFSurveySpec_assimilateSubParameters ( + LLRP_tSRFSurveySpec * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_RFSurveySpec_encode ( + const LLRP_tSRFSurveySpec *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdRFSurveySpec_AntennaID; + +extern llrp_u16_t +LLRP_RFSurveySpec_getAntennaID ( + LLRP_tSRFSurveySpec *pThis); + +extern LLRP_tResultCode +LLRP_RFSurveySpec_setAntennaID ( + LLRP_tSRFSurveySpec *pThis, + llrp_u16_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdRFSurveySpec_StartFrequency; + +extern llrp_u32_t +LLRP_RFSurveySpec_getStartFrequency ( + LLRP_tSRFSurveySpec *pThis); + +extern LLRP_tResultCode +LLRP_RFSurveySpec_setStartFrequency ( + LLRP_tSRFSurveySpec *pThis, + llrp_u32_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdRFSurveySpec_EndFrequency; + +extern llrp_u32_t +LLRP_RFSurveySpec_getEndFrequency ( + LLRP_tSRFSurveySpec *pThis); + +extern LLRP_tResultCode +LLRP_RFSurveySpec_setEndFrequency ( + LLRP_tSRFSurveySpec *pThis, + llrp_u32_t Value); + + +extern LLRP_tSRFSurveySpecStopTrigger * +LLRP_RFSurveySpec_getRFSurveySpecStopTrigger ( + LLRP_tSRFSurveySpec *pThis); + +extern LLRP_tResultCode +LLRP_RFSurveySpec_setRFSurveySpecStopTrigger ( + LLRP_tSRFSurveySpec *pThis, + LLRP_tSRFSurveySpecStopTrigger *pValue); + +extern LLRP_tSParameter * +LLRP_RFSurveySpec_beginCustom ( + LLRP_tSRFSurveySpec *pThis); + +extern LLRP_tSParameter * +LLRP_RFSurveySpec_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_RFSurveySpec_clearCustom ( + LLRP_tSRFSurveySpec *pThis); + +extern int +LLRP_RFSurveySpec_countCustom ( + LLRP_tSRFSurveySpec *pThis); + +extern LLRP_tResultCode +LLRP_RFSurveySpec_addCustom ( + LLRP_tSRFSurveySpec *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SRFSurveySpecStopTrigger +{ + LLRP_tSParameter hdr; + + LLRP_tERFSurveySpecStopTriggerType eStopTriggerType; + + llrp_u32_t DurationPeriod; + + llrp_u32_t N; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdRFSurveySpecStopTrigger; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdRFSurveySpecStopTrigger[]; + +extern LLRP_tSRFSurveySpecStopTrigger * +LLRP_RFSurveySpecStopTrigger_construct (void); + +extern void +LLRP_RFSurveySpecStopTrigger_destruct ( + LLRP_tSRFSurveySpecStopTrigger * pThis); + +extern void +LLRP_RFSurveySpecStopTrigger_decodeFields ( + LLRP_tSRFSurveySpecStopTrigger * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_RFSurveySpecStopTrigger_assimilateSubParameters ( + LLRP_tSRFSurveySpecStopTrigger * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_RFSurveySpecStopTrigger_encode ( + const LLRP_tSRFSurveySpecStopTrigger *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdRFSurveySpecStopTrigger_StopTriggerType; + +extern LLRP_tERFSurveySpecStopTriggerType +LLRP_RFSurveySpecStopTrigger_getStopTriggerType ( + LLRP_tSRFSurveySpecStopTrigger *pThis); + +extern LLRP_tResultCode +LLRP_RFSurveySpecStopTrigger_setStopTriggerType ( + LLRP_tSRFSurveySpecStopTrigger *pThis, + LLRP_tERFSurveySpecStopTriggerType Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdRFSurveySpecStopTrigger_DurationPeriod; + +extern llrp_u32_t +LLRP_RFSurveySpecStopTrigger_getDurationPeriod ( + LLRP_tSRFSurveySpecStopTrigger *pThis); + +extern LLRP_tResultCode +LLRP_RFSurveySpecStopTrigger_setDurationPeriod ( + LLRP_tSRFSurveySpecStopTrigger *pThis, + llrp_u32_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdRFSurveySpecStopTrigger_N; + +extern llrp_u32_t +LLRP_RFSurveySpecStopTrigger_getN ( + LLRP_tSRFSurveySpecStopTrigger *pThis); + +extern LLRP_tResultCode +LLRP_RFSurveySpecStopTrigger_setN ( + LLRP_tSRFSurveySpecStopTrigger *pThis, + llrp_u32_t Value); + + + + + +struct LLRP_SAccessSpec +{ + LLRP_tSParameter hdr; + + llrp_u32_t AccessSpecID; + + llrp_u16_t AntennaID; + + LLRP_tEAirProtocols eProtocolID; + + LLRP_tEAccessSpecState eCurrentState; + + llrp_u32_t ROSpecID; + + + LLRP_tSAccessSpecStopTrigger * pAccessSpecStopTrigger; + + LLRP_tSAccessCommand * pAccessCommand; + + LLRP_tSAccessReportSpec * pAccessReportSpec; + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdAccessSpec; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdAccessSpec[]; + +extern LLRP_tSAccessSpec * +LLRP_AccessSpec_construct (void); + +extern void +LLRP_AccessSpec_destruct ( + LLRP_tSAccessSpec * pThis); + +extern void +LLRP_AccessSpec_decodeFields ( + LLRP_tSAccessSpec * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_AccessSpec_assimilateSubParameters ( + LLRP_tSAccessSpec * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_AccessSpec_encode ( + const LLRP_tSAccessSpec *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdAccessSpec_AccessSpecID; + +extern llrp_u32_t +LLRP_AccessSpec_getAccessSpecID ( + LLRP_tSAccessSpec *pThis); + +extern LLRP_tResultCode +LLRP_AccessSpec_setAccessSpecID ( + LLRP_tSAccessSpec *pThis, + llrp_u32_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdAccessSpec_AntennaID; + +extern llrp_u16_t +LLRP_AccessSpec_getAntennaID ( + LLRP_tSAccessSpec *pThis); + +extern LLRP_tResultCode +LLRP_AccessSpec_setAntennaID ( + LLRP_tSAccessSpec *pThis, + llrp_u16_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdAccessSpec_ProtocolID; + +extern LLRP_tEAirProtocols +LLRP_AccessSpec_getProtocolID ( + LLRP_tSAccessSpec *pThis); + +extern LLRP_tResultCode +LLRP_AccessSpec_setProtocolID ( + LLRP_tSAccessSpec *pThis, + LLRP_tEAirProtocols Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdAccessSpec_CurrentState; + +extern LLRP_tEAccessSpecState +LLRP_AccessSpec_getCurrentState ( + LLRP_tSAccessSpec *pThis); + +extern LLRP_tResultCode +LLRP_AccessSpec_setCurrentState ( + LLRP_tSAccessSpec *pThis, + LLRP_tEAccessSpecState Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdAccessSpec_ROSpecID; + +extern llrp_u32_t +LLRP_AccessSpec_getROSpecID ( + LLRP_tSAccessSpec *pThis); + +extern LLRP_tResultCode +LLRP_AccessSpec_setROSpecID ( + LLRP_tSAccessSpec *pThis, + llrp_u32_t Value); + + +extern LLRP_tSAccessSpecStopTrigger * +LLRP_AccessSpec_getAccessSpecStopTrigger ( + LLRP_tSAccessSpec *pThis); + +extern LLRP_tResultCode +LLRP_AccessSpec_setAccessSpecStopTrigger ( + LLRP_tSAccessSpec *pThis, + LLRP_tSAccessSpecStopTrigger *pValue); + +extern LLRP_tSAccessCommand * +LLRP_AccessSpec_getAccessCommand ( + LLRP_tSAccessSpec *pThis); + +extern LLRP_tResultCode +LLRP_AccessSpec_setAccessCommand ( + LLRP_tSAccessSpec *pThis, + LLRP_tSAccessCommand *pValue); + +extern LLRP_tSAccessReportSpec * +LLRP_AccessSpec_getAccessReportSpec ( + LLRP_tSAccessSpec *pThis); + +extern LLRP_tResultCode +LLRP_AccessSpec_setAccessReportSpec ( + LLRP_tSAccessSpec *pThis, + LLRP_tSAccessReportSpec *pValue); + +extern LLRP_tSParameter * +LLRP_AccessSpec_beginCustom ( + LLRP_tSAccessSpec *pThis); + +extern LLRP_tSParameter * +LLRP_AccessSpec_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_AccessSpec_clearCustom ( + LLRP_tSAccessSpec *pThis); + +extern int +LLRP_AccessSpec_countCustom ( + LLRP_tSAccessSpec *pThis); + +extern LLRP_tResultCode +LLRP_AccessSpec_addCustom ( + LLRP_tSAccessSpec *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SAccessSpecStopTrigger +{ + LLRP_tSParameter hdr; + + LLRP_tEAccessSpecStopTriggerType eAccessSpecStopTrigger; + + llrp_u16_t OperationCountValue; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdAccessSpecStopTrigger; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdAccessSpecStopTrigger[]; + +extern LLRP_tSAccessSpecStopTrigger * +LLRP_AccessSpecStopTrigger_construct (void); + +extern void +LLRP_AccessSpecStopTrigger_destruct ( + LLRP_tSAccessSpecStopTrigger * pThis); + +extern void +LLRP_AccessSpecStopTrigger_decodeFields ( + LLRP_tSAccessSpecStopTrigger * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_AccessSpecStopTrigger_assimilateSubParameters ( + LLRP_tSAccessSpecStopTrigger * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_AccessSpecStopTrigger_encode ( + const LLRP_tSAccessSpecStopTrigger *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdAccessSpecStopTrigger_AccessSpecStopTrigger; + +extern LLRP_tEAccessSpecStopTriggerType +LLRP_AccessSpecStopTrigger_getAccessSpecStopTrigger ( + LLRP_tSAccessSpecStopTrigger *pThis); + +extern LLRP_tResultCode +LLRP_AccessSpecStopTrigger_setAccessSpecStopTrigger ( + LLRP_tSAccessSpecStopTrigger *pThis, + LLRP_tEAccessSpecStopTriggerType Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdAccessSpecStopTrigger_OperationCountValue; + +extern llrp_u16_t +LLRP_AccessSpecStopTrigger_getOperationCountValue ( + LLRP_tSAccessSpecStopTrigger *pThis); + +extern LLRP_tResultCode +LLRP_AccessSpecStopTrigger_setOperationCountValue ( + LLRP_tSAccessSpecStopTrigger *pThis, + llrp_u16_t Value); + + + + + +struct LLRP_SAccessCommand +{ + LLRP_tSParameter hdr; + + + LLRP_tSParameter * pAirProtocolTagSpec; + + LLRP_tSParameter * listAccessCommandOpSpec; + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdAccessCommand; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdAccessCommand[]; + +extern LLRP_tSAccessCommand * +LLRP_AccessCommand_construct (void); + +extern void +LLRP_AccessCommand_destruct ( + LLRP_tSAccessCommand * pThis); + +extern void +LLRP_AccessCommand_decodeFields ( + LLRP_tSAccessCommand * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_AccessCommand_assimilateSubParameters ( + LLRP_tSAccessCommand * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_AccessCommand_encode ( + const LLRP_tSAccessCommand *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + + +extern LLRP_tSParameter * +LLRP_AccessCommand_getAirProtocolTagSpec ( + LLRP_tSAccessCommand *pThis); + +extern LLRP_tResultCode +LLRP_AccessCommand_setAirProtocolTagSpec ( + LLRP_tSAccessCommand *pThis, + LLRP_tSParameter *pValue); + +extern LLRP_tSParameter * +LLRP_AccessCommand_beginAccessCommandOpSpec ( + LLRP_tSAccessCommand *pThis); + +extern LLRP_tSParameter * +LLRP_AccessCommand_nextAccessCommandOpSpec ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_AccessCommand_clearAccessCommandOpSpec ( + LLRP_tSAccessCommand *pThis); + +extern int +LLRP_AccessCommand_countAccessCommandOpSpec ( + LLRP_tSAccessCommand *pThis); + +extern LLRP_tResultCode +LLRP_AccessCommand_addAccessCommandOpSpec ( + LLRP_tSAccessCommand *pThis, + LLRP_tSParameter *pValue); + + +extern LLRP_tSParameter * +LLRP_AccessCommand_beginCustom ( + LLRP_tSAccessCommand *pThis); + +extern LLRP_tSParameter * +LLRP_AccessCommand_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_AccessCommand_clearCustom ( + LLRP_tSAccessCommand *pThis); + +extern int +LLRP_AccessCommand_countCustom ( + LLRP_tSAccessCommand *pThis); + +extern LLRP_tResultCode +LLRP_AccessCommand_addCustom ( + LLRP_tSAccessCommand *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SClientRequestOpSpec +{ + LLRP_tSParameter hdr; + + llrp_u16_t OpSpecID; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdClientRequestOpSpec; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdClientRequestOpSpec[]; + +extern LLRP_tSClientRequestOpSpec * +LLRP_ClientRequestOpSpec_construct (void); + +extern void +LLRP_ClientRequestOpSpec_destruct ( + LLRP_tSClientRequestOpSpec * pThis); + +extern void +LLRP_ClientRequestOpSpec_decodeFields ( + LLRP_tSClientRequestOpSpec * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ClientRequestOpSpec_assimilateSubParameters ( + LLRP_tSClientRequestOpSpec * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ClientRequestOpSpec_encode ( + const LLRP_tSClientRequestOpSpec *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdClientRequestOpSpec_OpSpecID; + +extern llrp_u16_t +LLRP_ClientRequestOpSpec_getOpSpecID ( + LLRP_tSClientRequestOpSpec *pThis); + +extern LLRP_tResultCode +LLRP_ClientRequestOpSpec_setOpSpecID ( + LLRP_tSClientRequestOpSpec *pThis, + llrp_u16_t Value); + + + + + +struct LLRP_SClientRequestResponse +{ + LLRP_tSParameter hdr; + + llrp_u32_t AccessSpecID; + + + LLRP_tSEPCData * pEPCData; + + LLRP_tSParameter * listAirProtocolOpSpec; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdClientRequestResponse; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdClientRequestResponse[]; + +extern LLRP_tSClientRequestResponse * +LLRP_ClientRequestResponse_construct (void); + +extern void +LLRP_ClientRequestResponse_destruct ( + LLRP_tSClientRequestResponse * pThis); + +extern void +LLRP_ClientRequestResponse_decodeFields ( + LLRP_tSClientRequestResponse * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ClientRequestResponse_assimilateSubParameters ( + LLRP_tSClientRequestResponse * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ClientRequestResponse_encode ( + const LLRP_tSClientRequestResponse *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdClientRequestResponse_AccessSpecID; + +extern llrp_u32_t +LLRP_ClientRequestResponse_getAccessSpecID ( + LLRP_tSClientRequestResponse *pThis); + +extern LLRP_tResultCode +LLRP_ClientRequestResponse_setAccessSpecID ( + LLRP_tSClientRequestResponse *pThis, + llrp_u32_t Value); + + +extern LLRP_tSEPCData * +LLRP_ClientRequestResponse_getEPCData ( + LLRP_tSClientRequestResponse *pThis); + +extern LLRP_tResultCode +LLRP_ClientRequestResponse_setEPCData ( + LLRP_tSClientRequestResponse *pThis, + LLRP_tSEPCData *pValue); + +extern LLRP_tSParameter * +LLRP_ClientRequestResponse_beginAirProtocolOpSpec ( + LLRP_tSClientRequestResponse *pThis); + +extern LLRP_tSParameter * +LLRP_ClientRequestResponse_nextAirProtocolOpSpec ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ClientRequestResponse_clearAirProtocolOpSpec ( + LLRP_tSClientRequestResponse *pThis); + +extern int +LLRP_ClientRequestResponse_countAirProtocolOpSpec ( + LLRP_tSClientRequestResponse *pThis); + +extern LLRP_tResultCode +LLRP_ClientRequestResponse_addAirProtocolOpSpec ( + LLRP_tSClientRequestResponse *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SLLRPConfigurationStateValue +{ + LLRP_tSParameter hdr; + + llrp_u32_t LLRPConfigurationStateValue; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdLLRPConfigurationStateValue; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdLLRPConfigurationStateValue[]; + +extern LLRP_tSLLRPConfigurationStateValue * +LLRP_LLRPConfigurationStateValue_construct (void); + +extern void +LLRP_LLRPConfigurationStateValue_destruct ( + LLRP_tSLLRPConfigurationStateValue * pThis); + +extern void +LLRP_LLRPConfigurationStateValue_decodeFields ( + LLRP_tSLLRPConfigurationStateValue * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_LLRPConfigurationStateValue_assimilateSubParameters ( + LLRP_tSLLRPConfigurationStateValue * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_LLRPConfigurationStateValue_encode ( + const LLRP_tSLLRPConfigurationStateValue *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdLLRPConfigurationStateValue_LLRPConfigurationStateValue; + +extern llrp_u32_t +LLRP_LLRPConfigurationStateValue_getLLRPConfigurationStateValue ( + LLRP_tSLLRPConfigurationStateValue *pThis); + +extern LLRP_tResultCode +LLRP_LLRPConfigurationStateValue_setLLRPConfigurationStateValue ( + LLRP_tSLLRPConfigurationStateValue *pThis, + llrp_u32_t Value); + + + + + +struct LLRP_SIdentification +{ + LLRP_tSParameter hdr; + + LLRP_tEIdentificationType eIDType; + + llrp_u8v_t ReaderID; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdIdentification; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdIdentification[]; + +extern LLRP_tSIdentification * +LLRP_Identification_construct (void); + +extern void +LLRP_Identification_destruct ( + LLRP_tSIdentification * pThis); + +extern void +LLRP_Identification_decodeFields ( + LLRP_tSIdentification * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_Identification_assimilateSubParameters ( + LLRP_tSIdentification * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_Identification_encode ( + const LLRP_tSIdentification *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdIdentification_IDType; + +extern LLRP_tEIdentificationType +LLRP_Identification_getIDType ( + LLRP_tSIdentification *pThis); + +extern LLRP_tResultCode +LLRP_Identification_setIDType ( + LLRP_tSIdentification *pThis, + LLRP_tEIdentificationType Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdIdentification_ReaderID; + +extern llrp_u8v_t +LLRP_Identification_getReaderID ( + LLRP_tSIdentification *pThis); + +extern LLRP_tResultCode +LLRP_Identification_setReaderID ( + LLRP_tSIdentification *pThis, + llrp_u8v_t Value); + + + + + +struct LLRP_SGPOWriteData +{ + LLRP_tSParameter hdr; + + llrp_u16_t GPOPortNumber; + + llrp_u1_t GPOData; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdGPOWriteData; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdGPOWriteData[]; + +extern LLRP_tSGPOWriteData * +LLRP_GPOWriteData_construct (void); + +extern void +LLRP_GPOWriteData_destruct ( + LLRP_tSGPOWriteData * pThis); + +extern void +LLRP_GPOWriteData_decodeFields ( + LLRP_tSGPOWriteData * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_GPOWriteData_assimilateSubParameters ( + LLRP_tSGPOWriteData * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_GPOWriteData_encode ( + const LLRP_tSGPOWriteData *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdGPOWriteData_GPOPortNumber; + +extern llrp_u16_t +LLRP_GPOWriteData_getGPOPortNumber ( + LLRP_tSGPOWriteData *pThis); + +extern LLRP_tResultCode +LLRP_GPOWriteData_setGPOPortNumber ( + LLRP_tSGPOWriteData *pThis, + llrp_u16_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdGPOWriteData_GPOData; + +extern llrp_u1_t +LLRP_GPOWriteData_getGPOData ( + LLRP_tSGPOWriteData *pThis); + +extern LLRP_tResultCode +LLRP_GPOWriteData_setGPOData ( + LLRP_tSGPOWriteData *pThis, + llrp_u1_t Value); + + + + + +struct LLRP_SKeepaliveSpec +{ + LLRP_tSParameter hdr; + + LLRP_tEKeepaliveTriggerType eKeepaliveTriggerType; + + llrp_u32_t PeriodicTriggerValue; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdKeepaliveSpec; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdKeepaliveSpec[]; + +extern LLRP_tSKeepaliveSpec * +LLRP_KeepaliveSpec_construct (void); + +extern void +LLRP_KeepaliveSpec_destruct ( + LLRP_tSKeepaliveSpec * pThis); + +extern void +LLRP_KeepaliveSpec_decodeFields ( + LLRP_tSKeepaliveSpec * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_KeepaliveSpec_assimilateSubParameters ( + LLRP_tSKeepaliveSpec * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_KeepaliveSpec_encode ( + const LLRP_tSKeepaliveSpec *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdKeepaliveSpec_KeepaliveTriggerType; + +extern LLRP_tEKeepaliveTriggerType +LLRP_KeepaliveSpec_getKeepaliveTriggerType ( + LLRP_tSKeepaliveSpec *pThis); + +extern LLRP_tResultCode +LLRP_KeepaliveSpec_setKeepaliveTriggerType ( + LLRP_tSKeepaliveSpec *pThis, + LLRP_tEKeepaliveTriggerType Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdKeepaliveSpec_PeriodicTriggerValue; + +extern llrp_u32_t +LLRP_KeepaliveSpec_getPeriodicTriggerValue ( + LLRP_tSKeepaliveSpec *pThis); + +extern LLRP_tResultCode +LLRP_KeepaliveSpec_setPeriodicTriggerValue ( + LLRP_tSKeepaliveSpec *pThis, + llrp_u32_t Value); + + + + + +struct LLRP_SAntennaProperties +{ + LLRP_tSParameter hdr; + + llrp_u1_t AntennaConnected; + + llrp_u16_t AntennaID; + + llrp_s16_t AntennaGain; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdAntennaProperties; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdAntennaProperties[]; + +extern LLRP_tSAntennaProperties * +LLRP_AntennaProperties_construct (void); + +extern void +LLRP_AntennaProperties_destruct ( + LLRP_tSAntennaProperties * pThis); + +extern void +LLRP_AntennaProperties_decodeFields ( + LLRP_tSAntennaProperties * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_AntennaProperties_assimilateSubParameters ( + LLRP_tSAntennaProperties * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_AntennaProperties_encode ( + const LLRP_tSAntennaProperties *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdAntennaProperties_AntennaConnected; + +extern llrp_u1_t +LLRP_AntennaProperties_getAntennaConnected ( + LLRP_tSAntennaProperties *pThis); + +extern LLRP_tResultCode +LLRP_AntennaProperties_setAntennaConnected ( + LLRP_tSAntennaProperties *pThis, + llrp_u1_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdAntennaProperties_AntennaID; + +extern llrp_u16_t +LLRP_AntennaProperties_getAntennaID ( + LLRP_tSAntennaProperties *pThis); + +extern LLRP_tResultCode +LLRP_AntennaProperties_setAntennaID ( + LLRP_tSAntennaProperties *pThis, + llrp_u16_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdAntennaProperties_AntennaGain; + +extern llrp_s16_t +LLRP_AntennaProperties_getAntennaGain ( + LLRP_tSAntennaProperties *pThis); + +extern LLRP_tResultCode +LLRP_AntennaProperties_setAntennaGain ( + LLRP_tSAntennaProperties *pThis, + llrp_s16_t Value); + + + + + +struct LLRP_SAntennaConfiguration +{ + LLRP_tSParameter hdr; + + llrp_u16_t AntennaID; + + + LLRP_tSRFReceiver * pRFReceiver; + + LLRP_tSRFTransmitter * pRFTransmitter; + + LLRP_tSParameter * listAirProtocolInventoryCommandSettings; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdAntennaConfiguration; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdAntennaConfiguration[]; + +extern LLRP_tSAntennaConfiguration * +LLRP_AntennaConfiguration_construct (void); + +extern void +LLRP_AntennaConfiguration_destruct ( + LLRP_tSAntennaConfiguration * pThis); + +extern void +LLRP_AntennaConfiguration_decodeFields ( + LLRP_tSAntennaConfiguration * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_AntennaConfiguration_assimilateSubParameters ( + LLRP_tSAntennaConfiguration * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_AntennaConfiguration_encode ( + const LLRP_tSAntennaConfiguration *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdAntennaConfiguration_AntennaID; + +extern llrp_u16_t +LLRP_AntennaConfiguration_getAntennaID ( + LLRP_tSAntennaConfiguration *pThis); + +extern LLRP_tResultCode +LLRP_AntennaConfiguration_setAntennaID ( + LLRP_tSAntennaConfiguration *pThis, + llrp_u16_t Value); + + +extern LLRP_tSRFReceiver * +LLRP_AntennaConfiguration_getRFReceiver ( + LLRP_tSAntennaConfiguration *pThis); + +extern LLRP_tResultCode +LLRP_AntennaConfiguration_setRFReceiver ( + LLRP_tSAntennaConfiguration *pThis, + LLRP_tSRFReceiver *pValue); + +extern LLRP_tSRFTransmitter * +LLRP_AntennaConfiguration_getRFTransmitter ( + LLRP_tSAntennaConfiguration *pThis); + +extern LLRP_tResultCode +LLRP_AntennaConfiguration_setRFTransmitter ( + LLRP_tSAntennaConfiguration *pThis, + LLRP_tSRFTransmitter *pValue); + +extern LLRP_tSParameter * +LLRP_AntennaConfiguration_beginAirProtocolInventoryCommandSettings ( + LLRP_tSAntennaConfiguration *pThis); + +extern LLRP_tSParameter * +LLRP_AntennaConfiguration_nextAirProtocolInventoryCommandSettings ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_AntennaConfiguration_clearAirProtocolInventoryCommandSettings ( + LLRP_tSAntennaConfiguration *pThis); + +extern int +LLRP_AntennaConfiguration_countAirProtocolInventoryCommandSettings ( + LLRP_tSAntennaConfiguration *pThis); + +extern LLRP_tResultCode +LLRP_AntennaConfiguration_addAirProtocolInventoryCommandSettings ( + LLRP_tSAntennaConfiguration *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SRFReceiver +{ + LLRP_tSParameter hdr; + + llrp_u16_t ReceiverSensitivity; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdRFReceiver; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdRFReceiver[]; + +extern LLRP_tSRFReceiver * +LLRP_RFReceiver_construct (void); + +extern void +LLRP_RFReceiver_destruct ( + LLRP_tSRFReceiver * pThis); + +extern void +LLRP_RFReceiver_decodeFields ( + LLRP_tSRFReceiver * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_RFReceiver_assimilateSubParameters ( + LLRP_tSRFReceiver * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_RFReceiver_encode ( + const LLRP_tSRFReceiver *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdRFReceiver_ReceiverSensitivity; + +extern llrp_u16_t +LLRP_RFReceiver_getReceiverSensitivity ( + LLRP_tSRFReceiver *pThis); + +extern LLRP_tResultCode +LLRP_RFReceiver_setReceiverSensitivity ( + LLRP_tSRFReceiver *pThis, + llrp_u16_t Value); + + + + + +struct LLRP_SRFTransmitter +{ + LLRP_tSParameter hdr; + + llrp_u16_t HopTableID; + + llrp_u16_t ChannelIndex; + + llrp_u16_t TransmitPower; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdRFTransmitter; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdRFTransmitter[]; + +extern LLRP_tSRFTransmitter * +LLRP_RFTransmitter_construct (void); + +extern void +LLRP_RFTransmitter_destruct ( + LLRP_tSRFTransmitter * pThis); + +extern void +LLRP_RFTransmitter_decodeFields ( + LLRP_tSRFTransmitter * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_RFTransmitter_assimilateSubParameters ( + LLRP_tSRFTransmitter * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_RFTransmitter_encode ( + const LLRP_tSRFTransmitter *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdRFTransmitter_HopTableID; + +extern llrp_u16_t +LLRP_RFTransmitter_getHopTableID ( + LLRP_tSRFTransmitter *pThis); + +extern LLRP_tResultCode +LLRP_RFTransmitter_setHopTableID ( + LLRP_tSRFTransmitter *pThis, + llrp_u16_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdRFTransmitter_ChannelIndex; + +extern llrp_u16_t +LLRP_RFTransmitter_getChannelIndex ( + LLRP_tSRFTransmitter *pThis); + +extern LLRP_tResultCode +LLRP_RFTransmitter_setChannelIndex ( + LLRP_tSRFTransmitter *pThis, + llrp_u16_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdRFTransmitter_TransmitPower; + +extern llrp_u16_t +LLRP_RFTransmitter_getTransmitPower ( + LLRP_tSRFTransmitter *pThis); + +extern LLRP_tResultCode +LLRP_RFTransmitter_setTransmitPower ( + LLRP_tSRFTransmitter *pThis, + llrp_u16_t Value); + + + + + +struct LLRP_SGPIPortCurrentState +{ + LLRP_tSParameter hdr; + + llrp_u16_t GPIPortNum; + + llrp_u1_t Config; + + LLRP_tEGPIPortState eState; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdGPIPortCurrentState; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdGPIPortCurrentState[]; + +extern LLRP_tSGPIPortCurrentState * +LLRP_GPIPortCurrentState_construct (void); + +extern void +LLRP_GPIPortCurrentState_destruct ( + LLRP_tSGPIPortCurrentState * pThis); + +extern void +LLRP_GPIPortCurrentState_decodeFields ( + LLRP_tSGPIPortCurrentState * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_GPIPortCurrentState_assimilateSubParameters ( + LLRP_tSGPIPortCurrentState * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_GPIPortCurrentState_encode ( + const LLRP_tSGPIPortCurrentState *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdGPIPortCurrentState_GPIPortNum; + +extern llrp_u16_t +LLRP_GPIPortCurrentState_getGPIPortNum ( + LLRP_tSGPIPortCurrentState *pThis); + +extern LLRP_tResultCode +LLRP_GPIPortCurrentState_setGPIPortNum ( + LLRP_tSGPIPortCurrentState *pThis, + llrp_u16_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdGPIPortCurrentState_Config; + +extern llrp_u1_t +LLRP_GPIPortCurrentState_getConfig ( + LLRP_tSGPIPortCurrentState *pThis); + +extern LLRP_tResultCode +LLRP_GPIPortCurrentState_setConfig ( + LLRP_tSGPIPortCurrentState *pThis, + llrp_u1_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdGPIPortCurrentState_State; + +extern LLRP_tEGPIPortState +LLRP_GPIPortCurrentState_getState ( + LLRP_tSGPIPortCurrentState *pThis); + +extern LLRP_tResultCode +LLRP_GPIPortCurrentState_setState ( + LLRP_tSGPIPortCurrentState *pThis, + LLRP_tEGPIPortState Value); + + + + + +struct LLRP_SEventsAndReports +{ + LLRP_tSParameter hdr; + + llrp_u1_t HoldEventsAndReportsUponReconnect; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdEventsAndReports; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdEventsAndReports[]; + +extern LLRP_tSEventsAndReports * +LLRP_EventsAndReports_construct (void); + +extern void +LLRP_EventsAndReports_destruct ( + LLRP_tSEventsAndReports * pThis); + +extern void +LLRP_EventsAndReports_decodeFields ( + LLRP_tSEventsAndReports * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_EventsAndReports_assimilateSubParameters ( + LLRP_tSEventsAndReports * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_EventsAndReports_encode ( + const LLRP_tSEventsAndReports *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdEventsAndReports_HoldEventsAndReportsUponReconnect; + +extern llrp_u1_t +LLRP_EventsAndReports_getHoldEventsAndReportsUponReconnect ( + LLRP_tSEventsAndReports *pThis); + +extern LLRP_tResultCode +LLRP_EventsAndReports_setHoldEventsAndReportsUponReconnect ( + LLRP_tSEventsAndReports *pThis, + llrp_u1_t Value); + + + + + +struct LLRP_SROReportSpec +{ + LLRP_tSParameter hdr; + + LLRP_tEROReportTriggerType eROReportTrigger; + + llrp_u16_t N; + + + LLRP_tSTagReportContentSelector * pTagReportContentSelector; + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdROReportSpec; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdROReportSpec[]; + +extern LLRP_tSROReportSpec * +LLRP_ROReportSpec_construct (void); + +extern void +LLRP_ROReportSpec_destruct ( + LLRP_tSROReportSpec * pThis); + +extern void +LLRP_ROReportSpec_decodeFields ( + LLRP_tSROReportSpec * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ROReportSpec_assimilateSubParameters ( + LLRP_tSROReportSpec * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ROReportSpec_encode ( + const LLRP_tSROReportSpec *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdROReportSpec_ROReportTrigger; + +extern LLRP_tEROReportTriggerType +LLRP_ROReportSpec_getROReportTrigger ( + LLRP_tSROReportSpec *pThis); + +extern LLRP_tResultCode +LLRP_ROReportSpec_setROReportTrigger ( + LLRP_tSROReportSpec *pThis, + LLRP_tEROReportTriggerType Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdROReportSpec_N; + +extern llrp_u16_t +LLRP_ROReportSpec_getN ( + LLRP_tSROReportSpec *pThis); + +extern LLRP_tResultCode +LLRP_ROReportSpec_setN ( + LLRP_tSROReportSpec *pThis, + llrp_u16_t Value); + + +extern LLRP_tSTagReportContentSelector * +LLRP_ROReportSpec_getTagReportContentSelector ( + LLRP_tSROReportSpec *pThis); + +extern LLRP_tResultCode +LLRP_ROReportSpec_setTagReportContentSelector ( + LLRP_tSROReportSpec *pThis, + LLRP_tSTagReportContentSelector *pValue); + +extern LLRP_tSParameter * +LLRP_ROReportSpec_beginCustom ( + LLRP_tSROReportSpec *pThis); + +extern LLRP_tSParameter * +LLRP_ROReportSpec_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ROReportSpec_clearCustom ( + LLRP_tSROReportSpec *pThis); + +extern int +LLRP_ROReportSpec_countCustom ( + LLRP_tSROReportSpec *pThis); + +extern LLRP_tResultCode +LLRP_ROReportSpec_addCustom ( + LLRP_tSROReportSpec *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_STagReportContentSelector +{ + LLRP_tSParameter hdr; + + llrp_u1_t EnableROSpecID; + + llrp_u1_t EnableSpecIndex; + + llrp_u1_t EnableInventoryParameterSpecID; + + llrp_u1_t EnableAntennaID; + + llrp_u1_t EnableChannelIndex; + + llrp_u1_t EnablePeakRSSI; + + llrp_u1_t EnableFirstSeenTimestamp; + + llrp_u1_t EnableLastSeenTimestamp; + + llrp_u1_t EnableTagSeenCount; + + llrp_u1_t EnableAccessSpecID; + + + LLRP_tSParameter * listAirProtocolEPCMemorySelector; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdTagReportContentSelector; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdTagReportContentSelector[]; + +extern LLRP_tSTagReportContentSelector * +LLRP_TagReportContentSelector_construct (void); + +extern void +LLRP_TagReportContentSelector_destruct ( + LLRP_tSTagReportContentSelector * pThis); + +extern void +LLRP_TagReportContentSelector_decodeFields ( + LLRP_tSTagReportContentSelector * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_TagReportContentSelector_assimilateSubParameters ( + LLRP_tSTagReportContentSelector * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_TagReportContentSelector_encode ( + const LLRP_tSTagReportContentSelector *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdTagReportContentSelector_EnableROSpecID; + +extern llrp_u1_t +LLRP_TagReportContentSelector_getEnableROSpecID ( + LLRP_tSTagReportContentSelector *pThis); + +extern LLRP_tResultCode +LLRP_TagReportContentSelector_setEnableROSpecID ( + LLRP_tSTagReportContentSelector *pThis, + llrp_u1_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdTagReportContentSelector_EnableSpecIndex; + +extern llrp_u1_t +LLRP_TagReportContentSelector_getEnableSpecIndex ( + LLRP_tSTagReportContentSelector *pThis); + +extern LLRP_tResultCode +LLRP_TagReportContentSelector_setEnableSpecIndex ( + LLRP_tSTagReportContentSelector *pThis, + llrp_u1_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdTagReportContentSelector_EnableInventoryParameterSpecID; + +extern llrp_u1_t +LLRP_TagReportContentSelector_getEnableInventoryParameterSpecID ( + LLRP_tSTagReportContentSelector *pThis); + +extern LLRP_tResultCode +LLRP_TagReportContentSelector_setEnableInventoryParameterSpecID ( + LLRP_tSTagReportContentSelector *pThis, + llrp_u1_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdTagReportContentSelector_EnableAntennaID; + +extern llrp_u1_t +LLRP_TagReportContentSelector_getEnableAntennaID ( + LLRP_tSTagReportContentSelector *pThis); + +extern LLRP_tResultCode +LLRP_TagReportContentSelector_setEnableAntennaID ( + LLRP_tSTagReportContentSelector *pThis, + llrp_u1_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdTagReportContentSelector_EnableChannelIndex; + +extern llrp_u1_t +LLRP_TagReportContentSelector_getEnableChannelIndex ( + LLRP_tSTagReportContentSelector *pThis); + +extern LLRP_tResultCode +LLRP_TagReportContentSelector_setEnableChannelIndex ( + LLRP_tSTagReportContentSelector *pThis, + llrp_u1_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdTagReportContentSelector_EnablePeakRSSI; + +extern llrp_u1_t +LLRP_TagReportContentSelector_getEnablePeakRSSI ( + LLRP_tSTagReportContentSelector *pThis); + +extern LLRP_tResultCode +LLRP_TagReportContentSelector_setEnablePeakRSSI ( + LLRP_tSTagReportContentSelector *pThis, + llrp_u1_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdTagReportContentSelector_EnableFirstSeenTimestamp; + +extern llrp_u1_t +LLRP_TagReportContentSelector_getEnableFirstSeenTimestamp ( + LLRP_tSTagReportContentSelector *pThis); + +extern LLRP_tResultCode +LLRP_TagReportContentSelector_setEnableFirstSeenTimestamp ( + LLRP_tSTagReportContentSelector *pThis, + llrp_u1_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdTagReportContentSelector_EnableLastSeenTimestamp; + +extern llrp_u1_t +LLRP_TagReportContentSelector_getEnableLastSeenTimestamp ( + LLRP_tSTagReportContentSelector *pThis); + +extern LLRP_tResultCode +LLRP_TagReportContentSelector_setEnableLastSeenTimestamp ( + LLRP_tSTagReportContentSelector *pThis, + llrp_u1_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdTagReportContentSelector_EnableTagSeenCount; + +extern llrp_u1_t +LLRP_TagReportContentSelector_getEnableTagSeenCount ( + LLRP_tSTagReportContentSelector *pThis); + +extern LLRP_tResultCode +LLRP_TagReportContentSelector_setEnableTagSeenCount ( + LLRP_tSTagReportContentSelector *pThis, + llrp_u1_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdTagReportContentSelector_EnableAccessSpecID; + +extern llrp_u1_t +LLRP_TagReportContentSelector_getEnableAccessSpecID ( + LLRP_tSTagReportContentSelector *pThis); + +extern LLRP_tResultCode +LLRP_TagReportContentSelector_setEnableAccessSpecID ( + LLRP_tSTagReportContentSelector *pThis, + llrp_u1_t Value); + + +extern LLRP_tSParameter * +LLRP_TagReportContentSelector_beginAirProtocolEPCMemorySelector ( + LLRP_tSTagReportContentSelector *pThis); + +extern LLRP_tSParameter * +LLRP_TagReportContentSelector_nextAirProtocolEPCMemorySelector ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_TagReportContentSelector_clearAirProtocolEPCMemorySelector ( + LLRP_tSTagReportContentSelector *pThis); + +extern int +LLRP_TagReportContentSelector_countAirProtocolEPCMemorySelector ( + LLRP_tSTagReportContentSelector *pThis); + +extern LLRP_tResultCode +LLRP_TagReportContentSelector_addAirProtocolEPCMemorySelector ( + LLRP_tSTagReportContentSelector *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SAccessReportSpec +{ + LLRP_tSParameter hdr; + + LLRP_tEAccessReportTriggerType eAccessReportTrigger; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdAccessReportSpec; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdAccessReportSpec[]; + +extern LLRP_tSAccessReportSpec * +LLRP_AccessReportSpec_construct (void); + +extern void +LLRP_AccessReportSpec_destruct ( + LLRP_tSAccessReportSpec * pThis); + +extern void +LLRP_AccessReportSpec_decodeFields ( + LLRP_tSAccessReportSpec * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_AccessReportSpec_assimilateSubParameters ( + LLRP_tSAccessReportSpec * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_AccessReportSpec_encode ( + const LLRP_tSAccessReportSpec *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdAccessReportSpec_AccessReportTrigger; + +extern LLRP_tEAccessReportTriggerType +LLRP_AccessReportSpec_getAccessReportTrigger ( + LLRP_tSAccessReportSpec *pThis); + +extern LLRP_tResultCode +LLRP_AccessReportSpec_setAccessReportTrigger ( + LLRP_tSAccessReportSpec *pThis, + LLRP_tEAccessReportTriggerType Value); + + + + + +struct LLRP_STagReportData +{ + LLRP_tSParameter hdr; + + + LLRP_tSParameter * pEPCParameter; + + LLRP_tSROSpecID * pROSpecID; + + LLRP_tSSpecIndex * pSpecIndex; + + LLRP_tSInventoryParameterSpecID * pInventoryParameterSpecID; + + LLRP_tSAntennaID * pAntennaID; + + LLRP_tSPeakRSSI * pPeakRSSI; + + LLRP_tSChannelIndex * pChannelIndex; + + LLRP_tSFirstSeenTimestampUTC * pFirstSeenTimestampUTC; + + LLRP_tSFirstSeenTimestampUptime * pFirstSeenTimestampUptime; + + LLRP_tSLastSeenTimestampUTC * pLastSeenTimestampUTC; + + LLRP_tSLastSeenTimestampUptime * pLastSeenTimestampUptime; + + LLRP_tSTagSeenCount * pTagSeenCount; + + LLRP_tSParameter * listAirProtocolTagData; + + LLRP_tSAccessSpecID * pAccessSpecID; + + LLRP_tSParameter * listAccessCommandOpSpecResult; + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdTagReportData; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdTagReportData[]; + +extern LLRP_tSTagReportData * +LLRP_TagReportData_construct (void); + +extern void +LLRP_TagReportData_destruct ( + LLRP_tSTagReportData * pThis); + +extern void +LLRP_TagReportData_decodeFields ( + LLRP_tSTagReportData * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_TagReportData_assimilateSubParameters ( + LLRP_tSTagReportData * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_TagReportData_encode ( + const LLRP_tSTagReportData *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + + +extern LLRP_tSParameter * +LLRP_TagReportData_getEPCParameter ( + LLRP_tSTagReportData *pThis); + +extern LLRP_tResultCode +LLRP_TagReportData_setEPCParameter ( + LLRP_tSTagReportData *pThis, + LLRP_tSParameter *pValue); + +extern LLRP_tSROSpecID * +LLRP_TagReportData_getROSpecID ( + LLRP_tSTagReportData *pThis); + +extern LLRP_tResultCode +LLRP_TagReportData_setROSpecID ( + LLRP_tSTagReportData *pThis, + LLRP_tSROSpecID *pValue); + +extern LLRP_tSSpecIndex * +LLRP_TagReportData_getSpecIndex ( + LLRP_tSTagReportData *pThis); + +extern LLRP_tResultCode +LLRP_TagReportData_setSpecIndex ( + LLRP_tSTagReportData *pThis, + LLRP_tSSpecIndex *pValue); + +extern LLRP_tSInventoryParameterSpecID * +LLRP_TagReportData_getInventoryParameterSpecID ( + LLRP_tSTagReportData *pThis); + +extern LLRP_tResultCode +LLRP_TagReportData_setInventoryParameterSpecID ( + LLRP_tSTagReportData *pThis, + LLRP_tSInventoryParameterSpecID *pValue); + +extern LLRP_tSAntennaID * +LLRP_TagReportData_getAntennaID ( + LLRP_tSTagReportData *pThis); + +extern LLRP_tResultCode +LLRP_TagReportData_setAntennaID ( + LLRP_tSTagReportData *pThis, + LLRP_tSAntennaID *pValue); + +extern LLRP_tSPeakRSSI * +LLRP_TagReportData_getPeakRSSI ( + LLRP_tSTagReportData *pThis); + +extern LLRP_tResultCode +LLRP_TagReportData_setPeakRSSI ( + LLRP_tSTagReportData *pThis, + LLRP_tSPeakRSSI *pValue); + +extern LLRP_tSChannelIndex * +LLRP_TagReportData_getChannelIndex ( + LLRP_tSTagReportData *pThis); + +extern LLRP_tResultCode +LLRP_TagReportData_setChannelIndex ( + LLRP_tSTagReportData *pThis, + LLRP_tSChannelIndex *pValue); + +extern LLRP_tSFirstSeenTimestampUTC * +LLRP_TagReportData_getFirstSeenTimestampUTC ( + LLRP_tSTagReportData *pThis); + +extern LLRP_tResultCode +LLRP_TagReportData_setFirstSeenTimestampUTC ( + LLRP_tSTagReportData *pThis, + LLRP_tSFirstSeenTimestampUTC *pValue); + +extern LLRP_tSFirstSeenTimestampUptime * +LLRP_TagReportData_getFirstSeenTimestampUptime ( + LLRP_tSTagReportData *pThis); + +extern LLRP_tResultCode +LLRP_TagReportData_setFirstSeenTimestampUptime ( + LLRP_tSTagReportData *pThis, + LLRP_tSFirstSeenTimestampUptime *pValue); + +extern LLRP_tSLastSeenTimestampUTC * +LLRP_TagReportData_getLastSeenTimestampUTC ( + LLRP_tSTagReportData *pThis); + +extern LLRP_tResultCode +LLRP_TagReportData_setLastSeenTimestampUTC ( + LLRP_tSTagReportData *pThis, + LLRP_tSLastSeenTimestampUTC *pValue); + +extern LLRP_tSLastSeenTimestampUptime * +LLRP_TagReportData_getLastSeenTimestampUptime ( + LLRP_tSTagReportData *pThis); + +extern LLRP_tResultCode +LLRP_TagReportData_setLastSeenTimestampUptime ( + LLRP_tSTagReportData *pThis, + LLRP_tSLastSeenTimestampUptime *pValue); + +extern LLRP_tSTagSeenCount * +LLRP_TagReportData_getTagSeenCount ( + LLRP_tSTagReportData *pThis); + +extern LLRP_tResultCode +LLRP_TagReportData_setTagSeenCount ( + LLRP_tSTagReportData *pThis, + LLRP_tSTagSeenCount *pValue); + +extern LLRP_tSParameter * +LLRP_TagReportData_beginAirProtocolTagData ( + LLRP_tSTagReportData *pThis); + +extern LLRP_tSParameter * +LLRP_TagReportData_nextAirProtocolTagData ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_TagReportData_clearAirProtocolTagData ( + LLRP_tSTagReportData *pThis); + +extern int +LLRP_TagReportData_countAirProtocolTagData ( + LLRP_tSTagReportData *pThis); + +extern LLRP_tResultCode +LLRP_TagReportData_addAirProtocolTagData ( + LLRP_tSTagReportData *pThis, + LLRP_tSParameter *pValue); + + +extern LLRP_tSAccessSpecID * +LLRP_TagReportData_getAccessSpecID ( + LLRP_tSTagReportData *pThis); + +extern LLRP_tResultCode +LLRP_TagReportData_setAccessSpecID ( + LLRP_tSTagReportData *pThis, + LLRP_tSAccessSpecID *pValue); + +extern LLRP_tSParameter * +LLRP_TagReportData_beginAccessCommandOpSpecResult ( + LLRP_tSTagReportData *pThis); + +extern LLRP_tSParameter * +LLRP_TagReportData_nextAccessCommandOpSpecResult ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_TagReportData_clearAccessCommandOpSpecResult ( + LLRP_tSTagReportData *pThis); + +extern int +LLRP_TagReportData_countAccessCommandOpSpecResult ( + LLRP_tSTagReportData *pThis); + +extern LLRP_tResultCode +LLRP_TagReportData_addAccessCommandOpSpecResult ( + LLRP_tSTagReportData *pThis, + LLRP_tSParameter *pValue); + + +extern LLRP_tSParameter * +LLRP_TagReportData_beginCustom ( + LLRP_tSTagReportData *pThis); + +extern LLRP_tSParameter * +LLRP_TagReportData_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_TagReportData_clearCustom ( + LLRP_tSTagReportData *pThis); + +extern int +LLRP_TagReportData_countCustom ( + LLRP_tSTagReportData *pThis); + +extern LLRP_tResultCode +LLRP_TagReportData_addCustom ( + LLRP_tSTagReportData *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SEPCData +{ + LLRP_tSParameter hdr; + + llrp_u1v_t EPC; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdEPCData; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdEPCData[]; + +extern LLRP_tSEPCData * +LLRP_EPCData_construct (void); + +extern void +LLRP_EPCData_destruct ( + LLRP_tSEPCData * pThis); + +extern void +LLRP_EPCData_decodeFields ( + LLRP_tSEPCData * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_EPCData_assimilateSubParameters ( + LLRP_tSEPCData * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_EPCData_encode ( + const LLRP_tSEPCData *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdEPCData_EPC; + +extern llrp_u1v_t +LLRP_EPCData_getEPC ( + LLRP_tSEPCData *pThis); + +extern LLRP_tResultCode +LLRP_EPCData_setEPC ( + LLRP_tSEPCData *pThis, + llrp_u1v_t Value); + + + + + +struct LLRP_SEPC_96 +{ + LLRP_tSParameter hdr; + + llrp_u96_t EPC; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdEPC_96; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdEPC_96[]; + +extern LLRP_tSEPC_96 * +LLRP_EPC_96_construct (void); + +extern void +LLRP_EPC_96_destruct ( + LLRP_tSEPC_96 * pThis); + +extern void +LLRP_EPC_96_decodeFields ( + LLRP_tSEPC_96 * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_EPC_96_assimilateSubParameters ( + LLRP_tSEPC_96 * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_EPC_96_encode ( + const LLRP_tSEPC_96 *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdEPC_96_EPC; + +extern llrp_u96_t +LLRP_EPC_96_getEPC ( + LLRP_tSEPC_96 *pThis); + +extern LLRP_tResultCode +LLRP_EPC_96_setEPC ( + LLRP_tSEPC_96 *pThis, + llrp_u96_t Value); + + + + + +struct LLRP_SROSpecID +{ + LLRP_tSParameter hdr; + + llrp_u32_t ROSpecID; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdROSpecID; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdROSpecID[]; + +extern LLRP_tSROSpecID * +LLRP_ROSpecID_construct (void); + +extern void +LLRP_ROSpecID_destruct ( + LLRP_tSROSpecID * pThis); + +extern void +LLRP_ROSpecID_decodeFields ( + LLRP_tSROSpecID * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ROSpecID_assimilateSubParameters ( + LLRP_tSROSpecID * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ROSpecID_encode ( + const LLRP_tSROSpecID *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdROSpecID_ROSpecID; + +extern llrp_u32_t +LLRP_ROSpecID_getROSpecID ( + LLRP_tSROSpecID *pThis); + +extern LLRP_tResultCode +LLRP_ROSpecID_setROSpecID ( + LLRP_tSROSpecID *pThis, + llrp_u32_t Value); + + + + + +struct LLRP_SSpecIndex +{ + LLRP_tSParameter hdr; + + llrp_u16_t SpecIndex; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdSpecIndex; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdSpecIndex[]; + +extern LLRP_tSSpecIndex * +LLRP_SpecIndex_construct (void); + +extern void +LLRP_SpecIndex_destruct ( + LLRP_tSSpecIndex * pThis); + +extern void +LLRP_SpecIndex_decodeFields ( + LLRP_tSSpecIndex * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_SpecIndex_assimilateSubParameters ( + LLRP_tSSpecIndex * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_SpecIndex_encode ( + const LLRP_tSSpecIndex *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdSpecIndex_SpecIndex; + +extern llrp_u16_t +LLRP_SpecIndex_getSpecIndex ( + LLRP_tSSpecIndex *pThis); + +extern LLRP_tResultCode +LLRP_SpecIndex_setSpecIndex ( + LLRP_tSSpecIndex *pThis, + llrp_u16_t Value); + + + + + +struct LLRP_SInventoryParameterSpecID +{ + LLRP_tSParameter hdr; + + llrp_u16_t InventoryParameterSpecID; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdInventoryParameterSpecID; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdInventoryParameterSpecID[]; + +extern LLRP_tSInventoryParameterSpecID * +LLRP_InventoryParameterSpecID_construct (void); + +extern void +LLRP_InventoryParameterSpecID_destruct ( + LLRP_tSInventoryParameterSpecID * pThis); + +extern void +LLRP_InventoryParameterSpecID_decodeFields ( + LLRP_tSInventoryParameterSpecID * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_InventoryParameterSpecID_assimilateSubParameters ( + LLRP_tSInventoryParameterSpecID * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_InventoryParameterSpecID_encode ( + const LLRP_tSInventoryParameterSpecID *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdInventoryParameterSpecID_InventoryParameterSpecID; + +extern llrp_u16_t +LLRP_InventoryParameterSpecID_getInventoryParameterSpecID ( + LLRP_tSInventoryParameterSpecID *pThis); + +extern LLRP_tResultCode +LLRP_InventoryParameterSpecID_setInventoryParameterSpecID ( + LLRP_tSInventoryParameterSpecID *pThis, + llrp_u16_t Value); + + + + + +struct LLRP_SAntennaID +{ + LLRP_tSParameter hdr; + + llrp_u16_t AntennaID; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdAntennaID; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdAntennaID[]; + +extern LLRP_tSAntennaID * +LLRP_AntennaID_construct (void); + +extern void +LLRP_AntennaID_destruct ( + LLRP_tSAntennaID * pThis); + +extern void +LLRP_AntennaID_decodeFields ( + LLRP_tSAntennaID * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_AntennaID_assimilateSubParameters ( + LLRP_tSAntennaID * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_AntennaID_encode ( + const LLRP_tSAntennaID *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdAntennaID_AntennaID; + +extern llrp_u16_t +LLRP_AntennaID_getAntennaID ( + LLRP_tSAntennaID *pThis); + +extern LLRP_tResultCode +LLRP_AntennaID_setAntennaID ( + LLRP_tSAntennaID *pThis, + llrp_u16_t Value); + + + + + +struct LLRP_SPeakRSSI +{ + LLRP_tSParameter hdr; + + llrp_s8_t PeakRSSI; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdPeakRSSI; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdPeakRSSI[]; + +extern LLRP_tSPeakRSSI * +LLRP_PeakRSSI_construct (void); + +extern void +LLRP_PeakRSSI_destruct ( + LLRP_tSPeakRSSI * pThis); + +extern void +LLRP_PeakRSSI_decodeFields ( + LLRP_tSPeakRSSI * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_PeakRSSI_assimilateSubParameters ( + LLRP_tSPeakRSSI * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_PeakRSSI_encode ( + const LLRP_tSPeakRSSI *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdPeakRSSI_PeakRSSI; + +extern llrp_s8_t +LLRP_PeakRSSI_getPeakRSSI ( + LLRP_tSPeakRSSI *pThis); + +extern LLRP_tResultCode +LLRP_PeakRSSI_setPeakRSSI ( + LLRP_tSPeakRSSI *pThis, + llrp_s8_t Value); + + + + + +struct LLRP_SChannelIndex +{ + LLRP_tSParameter hdr; + + llrp_u16_t ChannelIndex; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdChannelIndex; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdChannelIndex[]; + +extern LLRP_tSChannelIndex * +LLRP_ChannelIndex_construct (void); + +extern void +LLRP_ChannelIndex_destruct ( + LLRP_tSChannelIndex * pThis); + +extern void +LLRP_ChannelIndex_decodeFields ( + LLRP_tSChannelIndex * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ChannelIndex_assimilateSubParameters ( + LLRP_tSChannelIndex * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ChannelIndex_encode ( + const LLRP_tSChannelIndex *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdChannelIndex_ChannelIndex; + +extern llrp_u16_t +LLRP_ChannelIndex_getChannelIndex ( + LLRP_tSChannelIndex *pThis); + +extern LLRP_tResultCode +LLRP_ChannelIndex_setChannelIndex ( + LLRP_tSChannelIndex *pThis, + llrp_u16_t Value); + + + + + +struct LLRP_SFirstSeenTimestampUTC +{ + LLRP_tSParameter hdr; + + llrp_u64_t Microseconds; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdFirstSeenTimestampUTC; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdFirstSeenTimestampUTC[]; + +extern LLRP_tSFirstSeenTimestampUTC * +LLRP_FirstSeenTimestampUTC_construct (void); + +extern void +LLRP_FirstSeenTimestampUTC_destruct ( + LLRP_tSFirstSeenTimestampUTC * pThis); + +extern void +LLRP_FirstSeenTimestampUTC_decodeFields ( + LLRP_tSFirstSeenTimestampUTC * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_FirstSeenTimestampUTC_assimilateSubParameters ( + LLRP_tSFirstSeenTimestampUTC * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_FirstSeenTimestampUTC_encode ( + const LLRP_tSFirstSeenTimestampUTC *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdFirstSeenTimestampUTC_Microseconds; + +extern llrp_u64_t +LLRP_FirstSeenTimestampUTC_getMicroseconds ( + LLRP_tSFirstSeenTimestampUTC *pThis); + +extern LLRP_tResultCode +LLRP_FirstSeenTimestampUTC_setMicroseconds ( + LLRP_tSFirstSeenTimestampUTC *pThis, + llrp_u64_t Value); + + + + + +struct LLRP_SFirstSeenTimestampUptime +{ + LLRP_tSParameter hdr; + + llrp_u64_t Microseconds; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdFirstSeenTimestampUptime; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdFirstSeenTimestampUptime[]; + +extern LLRP_tSFirstSeenTimestampUptime * +LLRP_FirstSeenTimestampUptime_construct (void); + +extern void +LLRP_FirstSeenTimestampUptime_destruct ( + LLRP_tSFirstSeenTimestampUptime * pThis); + +extern void +LLRP_FirstSeenTimestampUptime_decodeFields ( + LLRP_tSFirstSeenTimestampUptime * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_FirstSeenTimestampUptime_assimilateSubParameters ( + LLRP_tSFirstSeenTimestampUptime * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_FirstSeenTimestampUptime_encode ( + const LLRP_tSFirstSeenTimestampUptime *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdFirstSeenTimestampUptime_Microseconds; + +extern llrp_u64_t +LLRP_FirstSeenTimestampUptime_getMicroseconds ( + LLRP_tSFirstSeenTimestampUptime *pThis); + +extern LLRP_tResultCode +LLRP_FirstSeenTimestampUptime_setMicroseconds ( + LLRP_tSFirstSeenTimestampUptime *pThis, + llrp_u64_t Value); + + + + + +struct LLRP_SLastSeenTimestampUTC +{ + LLRP_tSParameter hdr; + + llrp_u64_t Microseconds; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdLastSeenTimestampUTC; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdLastSeenTimestampUTC[]; + +extern LLRP_tSLastSeenTimestampUTC * +LLRP_LastSeenTimestampUTC_construct (void); + +extern void +LLRP_LastSeenTimestampUTC_destruct ( + LLRP_tSLastSeenTimestampUTC * pThis); + +extern void +LLRP_LastSeenTimestampUTC_decodeFields ( + LLRP_tSLastSeenTimestampUTC * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_LastSeenTimestampUTC_assimilateSubParameters ( + LLRP_tSLastSeenTimestampUTC * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_LastSeenTimestampUTC_encode ( + const LLRP_tSLastSeenTimestampUTC *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdLastSeenTimestampUTC_Microseconds; + +extern llrp_u64_t +LLRP_LastSeenTimestampUTC_getMicroseconds ( + LLRP_tSLastSeenTimestampUTC *pThis); + +extern LLRP_tResultCode +LLRP_LastSeenTimestampUTC_setMicroseconds ( + LLRP_tSLastSeenTimestampUTC *pThis, + llrp_u64_t Value); + + + + + +struct LLRP_SLastSeenTimestampUptime +{ + LLRP_tSParameter hdr; + + llrp_u64_t Microseconds; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdLastSeenTimestampUptime; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdLastSeenTimestampUptime[]; + +extern LLRP_tSLastSeenTimestampUptime * +LLRP_LastSeenTimestampUptime_construct (void); + +extern void +LLRP_LastSeenTimestampUptime_destruct ( + LLRP_tSLastSeenTimestampUptime * pThis); + +extern void +LLRP_LastSeenTimestampUptime_decodeFields ( + LLRP_tSLastSeenTimestampUptime * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_LastSeenTimestampUptime_assimilateSubParameters ( + LLRP_tSLastSeenTimestampUptime * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_LastSeenTimestampUptime_encode ( + const LLRP_tSLastSeenTimestampUptime *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdLastSeenTimestampUptime_Microseconds; + +extern llrp_u64_t +LLRP_LastSeenTimestampUptime_getMicroseconds ( + LLRP_tSLastSeenTimestampUptime *pThis); + +extern LLRP_tResultCode +LLRP_LastSeenTimestampUptime_setMicroseconds ( + LLRP_tSLastSeenTimestampUptime *pThis, + llrp_u64_t Value); + + + + + +struct LLRP_STagSeenCount +{ + LLRP_tSParameter hdr; + + llrp_u16_t TagCount; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdTagSeenCount; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdTagSeenCount[]; + +extern LLRP_tSTagSeenCount * +LLRP_TagSeenCount_construct (void); + +extern void +LLRP_TagSeenCount_destruct ( + LLRP_tSTagSeenCount * pThis); + +extern void +LLRP_TagSeenCount_decodeFields ( + LLRP_tSTagSeenCount * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_TagSeenCount_assimilateSubParameters ( + LLRP_tSTagSeenCount * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_TagSeenCount_encode ( + const LLRP_tSTagSeenCount *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdTagSeenCount_TagCount; + +extern llrp_u16_t +LLRP_TagSeenCount_getTagCount ( + LLRP_tSTagSeenCount *pThis); + +extern LLRP_tResultCode +LLRP_TagSeenCount_setTagCount ( + LLRP_tSTagSeenCount *pThis, + llrp_u16_t Value); + + + + + +struct LLRP_SClientRequestOpSpecResult +{ + LLRP_tSParameter hdr; + + llrp_u16_t OpSpecID; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdClientRequestOpSpecResult; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdClientRequestOpSpecResult[]; + +extern LLRP_tSClientRequestOpSpecResult * +LLRP_ClientRequestOpSpecResult_construct (void); + +extern void +LLRP_ClientRequestOpSpecResult_destruct ( + LLRP_tSClientRequestOpSpecResult * pThis); + +extern void +LLRP_ClientRequestOpSpecResult_decodeFields ( + LLRP_tSClientRequestOpSpecResult * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ClientRequestOpSpecResult_assimilateSubParameters ( + LLRP_tSClientRequestOpSpecResult * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ClientRequestOpSpecResult_encode ( + const LLRP_tSClientRequestOpSpecResult *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdClientRequestOpSpecResult_OpSpecID; + +extern llrp_u16_t +LLRP_ClientRequestOpSpecResult_getOpSpecID ( + LLRP_tSClientRequestOpSpecResult *pThis); + +extern LLRP_tResultCode +LLRP_ClientRequestOpSpecResult_setOpSpecID ( + LLRP_tSClientRequestOpSpecResult *pThis, + llrp_u16_t Value); + + + + + +struct LLRP_SAccessSpecID +{ + LLRP_tSParameter hdr; + + llrp_u32_t AccessSpecID; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdAccessSpecID; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdAccessSpecID[]; + +extern LLRP_tSAccessSpecID * +LLRP_AccessSpecID_construct (void); + +extern void +LLRP_AccessSpecID_destruct ( + LLRP_tSAccessSpecID * pThis); + +extern void +LLRP_AccessSpecID_decodeFields ( + LLRP_tSAccessSpecID * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_AccessSpecID_assimilateSubParameters ( + LLRP_tSAccessSpecID * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_AccessSpecID_encode ( + const LLRP_tSAccessSpecID *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdAccessSpecID_AccessSpecID; + +extern llrp_u32_t +LLRP_AccessSpecID_getAccessSpecID ( + LLRP_tSAccessSpecID *pThis); + +extern LLRP_tResultCode +LLRP_AccessSpecID_setAccessSpecID ( + LLRP_tSAccessSpecID *pThis, + llrp_u32_t Value); + + + + + +struct LLRP_SRFSurveyReportData +{ + LLRP_tSParameter hdr; + + + LLRP_tSROSpecID * pROSpecID; + + LLRP_tSSpecIndex * pSpecIndex; + + LLRP_tSFrequencyRSSILevelEntry * listFrequencyRSSILevelEntry; + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdRFSurveyReportData; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdRFSurveyReportData[]; + +extern LLRP_tSRFSurveyReportData * +LLRP_RFSurveyReportData_construct (void); + +extern void +LLRP_RFSurveyReportData_destruct ( + LLRP_tSRFSurveyReportData * pThis); + +extern void +LLRP_RFSurveyReportData_decodeFields ( + LLRP_tSRFSurveyReportData * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_RFSurveyReportData_assimilateSubParameters ( + LLRP_tSRFSurveyReportData * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_RFSurveyReportData_encode ( + const LLRP_tSRFSurveyReportData *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + + +extern LLRP_tSROSpecID * +LLRP_RFSurveyReportData_getROSpecID ( + LLRP_tSRFSurveyReportData *pThis); + +extern LLRP_tResultCode +LLRP_RFSurveyReportData_setROSpecID ( + LLRP_tSRFSurveyReportData *pThis, + LLRP_tSROSpecID *pValue); + +extern LLRP_tSSpecIndex * +LLRP_RFSurveyReportData_getSpecIndex ( + LLRP_tSRFSurveyReportData *pThis); + +extern LLRP_tResultCode +LLRP_RFSurveyReportData_setSpecIndex ( + LLRP_tSRFSurveyReportData *pThis, + LLRP_tSSpecIndex *pValue); + +extern LLRP_tSFrequencyRSSILevelEntry * +LLRP_RFSurveyReportData_beginFrequencyRSSILevelEntry ( + LLRP_tSRFSurveyReportData *pThis); + +extern LLRP_tSFrequencyRSSILevelEntry * +LLRP_RFSurveyReportData_nextFrequencyRSSILevelEntry ( + LLRP_tSFrequencyRSSILevelEntry *pCurrent); + +extern void +LLRP_RFSurveyReportData_clearFrequencyRSSILevelEntry ( + LLRP_tSRFSurveyReportData *pThis); + +extern int +LLRP_RFSurveyReportData_countFrequencyRSSILevelEntry ( + LLRP_tSRFSurveyReportData *pThis); + +extern LLRP_tResultCode +LLRP_RFSurveyReportData_addFrequencyRSSILevelEntry ( + LLRP_tSRFSurveyReportData *pThis, + LLRP_tSFrequencyRSSILevelEntry *pValue); + + +extern LLRP_tSParameter * +LLRP_RFSurveyReportData_beginCustom ( + LLRP_tSRFSurveyReportData *pThis); + +extern LLRP_tSParameter * +LLRP_RFSurveyReportData_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_RFSurveyReportData_clearCustom ( + LLRP_tSRFSurveyReportData *pThis); + +extern int +LLRP_RFSurveyReportData_countCustom ( + LLRP_tSRFSurveyReportData *pThis); + +extern LLRP_tResultCode +LLRP_RFSurveyReportData_addCustom ( + LLRP_tSRFSurveyReportData *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SFrequencyRSSILevelEntry +{ + LLRP_tSParameter hdr; + + llrp_u32_t Frequency; + + llrp_u32_t Bandwidth; + + llrp_s8_t AverageRSSI; + + llrp_s8_t PeakRSSI; + + + LLRP_tSParameter * pTimestamp; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdFrequencyRSSILevelEntry; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdFrequencyRSSILevelEntry[]; + +extern LLRP_tSFrequencyRSSILevelEntry * +LLRP_FrequencyRSSILevelEntry_construct (void); + +extern void +LLRP_FrequencyRSSILevelEntry_destruct ( + LLRP_tSFrequencyRSSILevelEntry * pThis); + +extern void +LLRP_FrequencyRSSILevelEntry_decodeFields ( + LLRP_tSFrequencyRSSILevelEntry * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_FrequencyRSSILevelEntry_assimilateSubParameters ( + LLRP_tSFrequencyRSSILevelEntry * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_FrequencyRSSILevelEntry_encode ( + const LLRP_tSFrequencyRSSILevelEntry *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdFrequencyRSSILevelEntry_Frequency; + +extern llrp_u32_t +LLRP_FrequencyRSSILevelEntry_getFrequency ( + LLRP_tSFrequencyRSSILevelEntry *pThis); + +extern LLRP_tResultCode +LLRP_FrequencyRSSILevelEntry_setFrequency ( + LLRP_tSFrequencyRSSILevelEntry *pThis, + llrp_u32_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdFrequencyRSSILevelEntry_Bandwidth; + +extern llrp_u32_t +LLRP_FrequencyRSSILevelEntry_getBandwidth ( + LLRP_tSFrequencyRSSILevelEntry *pThis); + +extern LLRP_tResultCode +LLRP_FrequencyRSSILevelEntry_setBandwidth ( + LLRP_tSFrequencyRSSILevelEntry *pThis, + llrp_u32_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdFrequencyRSSILevelEntry_AverageRSSI; + +extern llrp_s8_t +LLRP_FrequencyRSSILevelEntry_getAverageRSSI ( + LLRP_tSFrequencyRSSILevelEntry *pThis); + +extern LLRP_tResultCode +LLRP_FrequencyRSSILevelEntry_setAverageRSSI ( + LLRP_tSFrequencyRSSILevelEntry *pThis, + llrp_s8_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdFrequencyRSSILevelEntry_PeakRSSI; + +extern llrp_s8_t +LLRP_FrequencyRSSILevelEntry_getPeakRSSI ( + LLRP_tSFrequencyRSSILevelEntry *pThis); + +extern LLRP_tResultCode +LLRP_FrequencyRSSILevelEntry_setPeakRSSI ( + LLRP_tSFrequencyRSSILevelEntry *pThis, + llrp_s8_t Value); + + +extern LLRP_tSParameter * +LLRP_FrequencyRSSILevelEntry_getTimestamp ( + LLRP_tSFrequencyRSSILevelEntry *pThis); + +extern LLRP_tResultCode +LLRP_FrequencyRSSILevelEntry_setTimestamp ( + LLRP_tSFrequencyRSSILevelEntry *pThis, + LLRP_tSParameter *pValue); + + + + +struct LLRP_SReaderEventNotificationSpec +{ + LLRP_tSParameter hdr; + + + LLRP_tSEventNotificationState * listEventNotificationState; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdReaderEventNotificationSpec; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdReaderEventNotificationSpec[]; + +extern LLRP_tSReaderEventNotificationSpec * +LLRP_ReaderEventNotificationSpec_construct (void); + +extern void +LLRP_ReaderEventNotificationSpec_destruct ( + LLRP_tSReaderEventNotificationSpec * pThis); + +extern void +LLRP_ReaderEventNotificationSpec_decodeFields ( + LLRP_tSReaderEventNotificationSpec * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ReaderEventNotificationSpec_assimilateSubParameters ( + LLRP_tSReaderEventNotificationSpec * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ReaderEventNotificationSpec_encode ( + const LLRP_tSReaderEventNotificationSpec *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + + +extern LLRP_tSEventNotificationState * +LLRP_ReaderEventNotificationSpec_beginEventNotificationState ( + LLRP_tSReaderEventNotificationSpec *pThis); + +extern LLRP_tSEventNotificationState * +LLRP_ReaderEventNotificationSpec_nextEventNotificationState ( + LLRP_tSEventNotificationState *pCurrent); + +extern void +LLRP_ReaderEventNotificationSpec_clearEventNotificationState ( + LLRP_tSReaderEventNotificationSpec *pThis); + +extern int +LLRP_ReaderEventNotificationSpec_countEventNotificationState ( + LLRP_tSReaderEventNotificationSpec *pThis); + +extern LLRP_tResultCode +LLRP_ReaderEventNotificationSpec_addEventNotificationState ( + LLRP_tSReaderEventNotificationSpec *pThis, + LLRP_tSEventNotificationState *pValue); + + + + + +struct LLRP_SEventNotificationState +{ + LLRP_tSParameter hdr; + + LLRP_tENotificationEventType eEventType; + + llrp_u1_t NotificationState; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdEventNotificationState; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdEventNotificationState[]; + +extern LLRP_tSEventNotificationState * +LLRP_EventNotificationState_construct (void); + +extern void +LLRP_EventNotificationState_destruct ( + LLRP_tSEventNotificationState * pThis); + +extern void +LLRP_EventNotificationState_decodeFields ( + LLRP_tSEventNotificationState * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_EventNotificationState_assimilateSubParameters ( + LLRP_tSEventNotificationState * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_EventNotificationState_encode ( + const LLRP_tSEventNotificationState *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdEventNotificationState_EventType; + +extern LLRP_tENotificationEventType +LLRP_EventNotificationState_getEventType ( + LLRP_tSEventNotificationState *pThis); + +extern LLRP_tResultCode +LLRP_EventNotificationState_setEventType ( + LLRP_tSEventNotificationState *pThis, + LLRP_tENotificationEventType Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdEventNotificationState_NotificationState; + +extern llrp_u1_t +LLRP_EventNotificationState_getNotificationState ( + LLRP_tSEventNotificationState *pThis); + +extern LLRP_tResultCode +LLRP_EventNotificationState_setNotificationState ( + LLRP_tSEventNotificationState *pThis, + llrp_u1_t Value); + + + + + +struct LLRP_SReaderEventNotificationData +{ + LLRP_tSParameter hdr; + + + LLRP_tSParameter * pTimestamp; + + LLRP_tSHoppingEvent * pHoppingEvent; + + LLRP_tSGPIEvent * pGPIEvent; + + LLRP_tSROSpecEvent * pROSpecEvent; + + LLRP_tSReportBufferLevelWarningEvent * pReportBufferLevelWarningEvent; + + LLRP_tSReportBufferOverflowErrorEvent * pReportBufferOverflowErrorEvent; + + LLRP_tSReaderExceptionEvent * pReaderExceptionEvent; + + LLRP_tSRFSurveyEvent * pRFSurveyEvent; + + LLRP_tSAISpecEvent * pAISpecEvent; + + LLRP_tSAntennaEvent * pAntennaEvent; + + LLRP_tSConnectionAttemptEvent * pConnectionAttemptEvent; + + LLRP_tSConnectionCloseEvent * pConnectionCloseEvent; + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdReaderEventNotificationData; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdReaderEventNotificationData[]; + +extern LLRP_tSReaderEventNotificationData * +LLRP_ReaderEventNotificationData_construct (void); + +extern void +LLRP_ReaderEventNotificationData_destruct ( + LLRP_tSReaderEventNotificationData * pThis); + +extern void +LLRP_ReaderEventNotificationData_decodeFields ( + LLRP_tSReaderEventNotificationData * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ReaderEventNotificationData_assimilateSubParameters ( + LLRP_tSReaderEventNotificationData * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ReaderEventNotificationData_encode ( + const LLRP_tSReaderEventNotificationData *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + + +extern LLRP_tSParameter * +LLRP_ReaderEventNotificationData_getTimestamp ( + LLRP_tSReaderEventNotificationData *pThis); + +extern LLRP_tResultCode +LLRP_ReaderEventNotificationData_setTimestamp ( + LLRP_tSReaderEventNotificationData *pThis, + LLRP_tSParameter *pValue); + +extern LLRP_tSHoppingEvent * +LLRP_ReaderEventNotificationData_getHoppingEvent ( + LLRP_tSReaderEventNotificationData *pThis); + +extern LLRP_tResultCode +LLRP_ReaderEventNotificationData_setHoppingEvent ( + LLRP_tSReaderEventNotificationData *pThis, + LLRP_tSHoppingEvent *pValue); + +extern LLRP_tSGPIEvent * +LLRP_ReaderEventNotificationData_getGPIEvent ( + LLRP_tSReaderEventNotificationData *pThis); + +extern LLRP_tResultCode +LLRP_ReaderEventNotificationData_setGPIEvent ( + LLRP_tSReaderEventNotificationData *pThis, + LLRP_tSGPIEvent *pValue); + +extern LLRP_tSROSpecEvent * +LLRP_ReaderEventNotificationData_getROSpecEvent ( + LLRP_tSReaderEventNotificationData *pThis); + +extern LLRP_tResultCode +LLRP_ReaderEventNotificationData_setROSpecEvent ( + LLRP_tSReaderEventNotificationData *pThis, + LLRP_tSROSpecEvent *pValue); + +extern LLRP_tSReportBufferLevelWarningEvent * +LLRP_ReaderEventNotificationData_getReportBufferLevelWarningEvent ( + LLRP_tSReaderEventNotificationData *pThis); + +extern LLRP_tResultCode +LLRP_ReaderEventNotificationData_setReportBufferLevelWarningEvent ( + LLRP_tSReaderEventNotificationData *pThis, + LLRP_tSReportBufferLevelWarningEvent *pValue); + +extern LLRP_tSReportBufferOverflowErrorEvent * +LLRP_ReaderEventNotificationData_getReportBufferOverflowErrorEvent ( + LLRP_tSReaderEventNotificationData *pThis); + +extern LLRP_tResultCode +LLRP_ReaderEventNotificationData_setReportBufferOverflowErrorEvent ( + LLRP_tSReaderEventNotificationData *pThis, + LLRP_tSReportBufferOverflowErrorEvent *pValue); + +extern LLRP_tSReaderExceptionEvent * +LLRP_ReaderEventNotificationData_getReaderExceptionEvent ( + LLRP_tSReaderEventNotificationData *pThis); + +extern LLRP_tResultCode +LLRP_ReaderEventNotificationData_setReaderExceptionEvent ( + LLRP_tSReaderEventNotificationData *pThis, + LLRP_tSReaderExceptionEvent *pValue); + +extern LLRP_tSRFSurveyEvent * +LLRP_ReaderEventNotificationData_getRFSurveyEvent ( + LLRP_tSReaderEventNotificationData *pThis); + +extern LLRP_tResultCode +LLRP_ReaderEventNotificationData_setRFSurveyEvent ( + LLRP_tSReaderEventNotificationData *pThis, + LLRP_tSRFSurveyEvent *pValue); + +extern LLRP_tSAISpecEvent * +LLRP_ReaderEventNotificationData_getAISpecEvent ( + LLRP_tSReaderEventNotificationData *pThis); + +extern LLRP_tResultCode +LLRP_ReaderEventNotificationData_setAISpecEvent ( + LLRP_tSReaderEventNotificationData *pThis, + LLRP_tSAISpecEvent *pValue); + +extern LLRP_tSAntennaEvent * +LLRP_ReaderEventNotificationData_getAntennaEvent ( + LLRP_tSReaderEventNotificationData *pThis); + +extern LLRP_tResultCode +LLRP_ReaderEventNotificationData_setAntennaEvent ( + LLRP_tSReaderEventNotificationData *pThis, + LLRP_tSAntennaEvent *pValue); + +extern LLRP_tSConnectionAttemptEvent * +LLRP_ReaderEventNotificationData_getConnectionAttemptEvent ( + LLRP_tSReaderEventNotificationData *pThis); + +extern LLRP_tResultCode +LLRP_ReaderEventNotificationData_setConnectionAttemptEvent ( + LLRP_tSReaderEventNotificationData *pThis, + LLRP_tSConnectionAttemptEvent *pValue); + +extern LLRP_tSConnectionCloseEvent * +LLRP_ReaderEventNotificationData_getConnectionCloseEvent ( + LLRP_tSReaderEventNotificationData *pThis); + +extern LLRP_tResultCode +LLRP_ReaderEventNotificationData_setConnectionCloseEvent ( + LLRP_tSReaderEventNotificationData *pThis, + LLRP_tSConnectionCloseEvent *pValue); + +extern LLRP_tSParameter * +LLRP_ReaderEventNotificationData_beginCustom ( + LLRP_tSReaderEventNotificationData *pThis); + +extern LLRP_tSParameter * +LLRP_ReaderEventNotificationData_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ReaderEventNotificationData_clearCustom ( + LLRP_tSReaderEventNotificationData *pThis); + +extern int +LLRP_ReaderEventNotificationData_countCustom ( + LLRP_tSReaderEventNotificationData *pThis); + +extern LLRP_tResultCode +LLRP_ReaderEventNotificationData_addCustom ( + LLRP_tSReaderEventNotificationData *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SHoppingEvent +{ + LLRP_tSParameter hdr; + + llrp_u16_t HopTableID; + + llrp_u16_t NextChannelIndex; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdHoppingEvent; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdHoppingEvent[]; + +extern LLRP_tSHoppingEvent * +LLRP_HoppingEvent_construct (void); + +extern void +LLRP_HoppingEvent_destruct ( + LLRP_tSHoppingEvent * pThis); + +extern void +LLRP_HoppingEvent_decodeFields ( + LLRP_tSHoppingEvent * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_HoppingEvent_assimilateSubParameters ( + LLRP_tSHoppingEvent * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_HoppingEvent_encode ( + const LLRP_tSHoppingEvent *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdHoppingEvent_HopTableID; + +extern llrp_u16_t +LLRP_HoppingEvent_getHopTableID ( + LLRP_tSHoppingEvent *pThis); + +extern LLRP_tResultCode +LLRP_HoppingEvent_setHopTableID ( + LLRP_tSHoppingEvent *pThis, + llrp_u16_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdHoppingEvent_NextChannelIndex; + +extern llrp_u16_t +LLRP_HoppingEvent_getNextChannelIndex ( + LLRP_tSHoppingEvent *pThis); + +extern LLRP_tResultCode +LLRP_HoppingEvent_setNextChannelIndex ( + LLRP_tSHoppingEvent *pThis, + llrp_u16_t Value); + + + + + +struct LLRP_SGPIEvent +{ + LLRP_tSParameter hdr; + + llrp_u16_t GPIPortNumber; + + llrp_u1_t GPIEvent; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdGPIEvent; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdGPIEvent[]; + +extern LLRP_tSGPIEvent * +LLRP_GPIEvent_construct (void); + +extern void +LLRP_GPIEvent_destruct ( + LLRP_tSGPIEvent * pThis); + +extern void +LLRP_GPIEvent_decodeFields ( + LLRP_tSGPIEvent * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_GPIEvent_assimilateSubParameters ( + LLRP_tSGPIEvent * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_GPIEvent_encode ( + const LLRP_tSGPIEvent *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdGPIEvent_GPIPortNumber; + +extern llrp_u16_t +LLRP_GPIEvent_getGPIPortNumber ( + LLRP_tSGPIEvent *pThis); + +extern LLRP_tResultCode +LLRP_GPIEvent_setGPIPortNumber ( + LLRP_tSGPIEvent *pThis, + llrp_u16_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdGPIEvent_GPIEvent; + +extern llrp_u1_t +LLRP_GPIEvent_getGPIEvent ( + LLRP_tSGPIEvent *pThis); + +extern LLRP_tResultCode +LLRP_GPIEvent_setGPIEvent ( + LLRP_tSGPIEvent *pThis, + llrp_u1_t Value); + + + + + +struct LLRP_SROSpecEvent +{ + LLRP_tSParameter hdr; + + LLRP_tEROSpecEventType eEventType; + + llrp_u32_t ROSpecID; + + llrp_u32_t PreemptingROSpecID; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdROSpecEvent; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdROSpecEvent[]; + +extern LLRP_tSROSpecEvent * +LLRP_ROSpecEvent_construct (void); + +extern void +LLRP_ROSpecEvent_destruct ( + LLRP_tSROSpecEvent * pThis); + +extern void +LLRP_ROSpecEvent_decodeFields ( + LLRP_tSROSpecEvent * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ROSpecEvent_assimilateSubParameters ( + LLRP_tSROSpecEvent * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ROSpecEvent_encode ( + const LLRP_tSROSpecEvent *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdROSpecEvent_EventType; + +extern LLRP_tEROSpecEventType +LLRP_ROSpecEvent_getEventType ( + LLRP_tSROSpecEvent *pThis); + +extern LLRP_tResultCode +LLRP_ROSpecEvent_setEventType ( + LLRP_tSROSpecEvent *pThis, + LLRP_tEROSpecEventType Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdROSpecEvent_ROSpecID; + +extern llrp_u32_t +LLRP_ROSpecEvent_getROSpecID ( + LLRP_tSROSpecEvent *pThis); + +extern LLRP_tResultCode +LLRP_ROSpecEvent_setROSpecID ( + LLRP_tSROSpecEvent *pThis, + llrp_u32_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdROSpecEvent_PreemptingROSpecID; + +extern llrp_u32_t +LLRP_ROSpecEvent_getPreemptingROSpecID ( + LLRP_tSROSpecEvent *pThis); + +extern LLRP_tResultCode +LLRP_ROSpecEvent_setPreemptingROSpecID ( + LLRP_tSROSpecEvent *pThis, + llrp_u32_t Value); + + + + + +struct LLRP_SReportBufferLevelWarningEvent +{ + LLRP_tSParameter hdr; + + llrp_u8_t ReportBufferPercentageFull; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdReportBufferLevelWarningEvent; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdReportBufferLevelWarningEvent[]; + +extern LLRP_tSReportBufferLevelWarningEvent * +LLRP_ReportBufferLevelWarningEvent_construct (void); + +extern void +LLRP_ReportBufferLevelWarningEvent_destruct ( + LLRP_tSReportBufferLevelWarningEvent * pThis); + +extern void +LLRP_ReportBufferLevelWarningEvent_decodeFields ( + LLRP_tSReportBufferLevelWarningEvent * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ReportBufferLevelWarningEvent_assimilateSubParameters ( + LLRP_tSReportBufferLevelWarningEvent * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ReportBufferLevelWarningEvent_encode ( + const LLRP_tSReportBufferLevelWarningEvent *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdReportBufferLevelWarningEvent_ReportBufferPercentageFull; + +extern llrp_u8_t +LLRP_ReportBufferLevelWarningEvent_getReportBufferPercentageFull ( + LLRP_tSReportBufferLevelWarningEvent *pThis); + +extern LLRP_tResultCode +LLRP_ReportBufferLevelWarningEvent_setReportBufferPercentageFull ( + LLRP_tSReportBufferLevelWarningEvent *pThis, + llrp_u8_t Value); + + + + + +struct LLRP_SReportBufferOverflowErrorEvent +{ + LLRP_tSParameter hdr; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdReportBufferOverflowErrorEvent; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdReportBufferOverflowErrorEvent[]; + +extern LLRP_tSReportBufferOverflowErrorEvent * +LLRP_ReportBufferOverflowErrorEvent_construct (void); + +extern void +LLRP_ReportBufferOverflowErrorEvent_destruct ( + LLRP_tSReportBufferOverflowErrorEvent * pThis); + +extern void +LLRP_ReportBufferOverflowErrorEvent_decodeFields ( + LLRP_tSReportBufferOverflowErrorEvent * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ReportBufferOverflowErrorEvent_assimilateSubParameters ( + LLRP_tSReportBufferOverflowErrorEvent * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ReportBufferOverflowErrorEvent_encode ( + const LLRP_tSReportBufferOverflowErrorEvent *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + + + + + +struct LLRP_SReaderExceptionEvent +{ + LLRP_tSParameter hdr; + + llrp_utf8v_t Message; + + + LLRP_tSROSpecID * pROSpecID; + + LLRP_tSSpecIndex * pSpecIndex; + + LLRP_tSInventoryParameterSpecID * pInventoryParameterSpecID; + + LLRP_tSAntennaID * pAntennaID; + + LLRP_tSAccessSpecID * pAccessSpecID; + + LLRP_tSOpSpecID * pOpSpecID; + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdReaderExceptionEvent; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdReaderExceptionEvent[]; + +extern LLRP_tSReaderExceptionEvent * +LLRP_ReaderExceptionEvent_construct (void); + +extern void +LLRP_ReaderExceptionEvent_destruct ( + LLRP_tSReaderExceptionEvent * pThis); + +extern void +LLRP_ReaderExceptionEvent_decodeFields ( + LLRP_tSReaderExceptionEvent * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ReaderExceptionEvent_assimilateSubParameters ( + LLRP_tSReaderExceptionEvent * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ReaderExceptionEvent_encode ( + const LLRP_tSReaderExceptionEvent *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdReaderExceptionEvent_Message; + +extern llrp_utf8v_t +LLRP_ReaderExceptionEvent_getMessage ( + LLRP_tSReaderExceptionEvent *pThis); + +extern LLRP_tResultCode +LLRP_ReaderExceptionEvent_setMessage ( + LLRP_tSReaderExceptionEvent *pThis, + llrp_utf8v_t Value); + + +extern LLRP_tSROSpecID * +LLRP_ReaderExceptionEvent_getROSpecID ( + LLRP_tSReaderExceptionEvent *pThis); + +extern LLRP_tResultCode +LLRP_ReaderExceptionEvent_setROSpecID ( + LLRP_tSReaderExceptionEvent *pThis, + LLRP_tSROSpecID *pValue); + +extern LLRP_tSSpecIndex * +LLRP_ReaderExceptionEvent_getSpecIndex ( + LLRP_tSReaderExceptionEvent *pThis); + +extern LLRP_tResultCode +LLRP_ReaderExceptionEvent_setSpecIndex ( + LLRP_tSReaderExceptionEvent *pThis, + LLRP_tSSpecIndex *pValue); + +extern LLRP_tSInventoryParameterSpecID * +LLRP_ReaderExceptionEvent_getInventoryParameterSpecID ( + LLRP_tSReaderExceptionEvent *pThis); + +extern LLRP_tResultCode +LLRP_ReaderExceptionEvent_setInventoryParameterSpecID ( + LLRP_tSReaderExceptionEvent *pThis, + LLRP_tSInventoryParameterSpecID *pValue); + +extern LLRP_tSAntennaID * +LLRP_ReaderExceptionEvent_getAntennaID ( + LLRP_tSReaderExceptionEvent *pThis); + +extern LLRP_tResultCode +LLRP_ReaderExceptionEvent_setAntennaID ( + LLRP_tSReaderExceptionEvent *pThis, + LLRP_tSAntennaID *pValue); + +extern LLRP_tSAccessSpecID * +LLRP_ReaderExceptionEvent_getAccessSpecID ( + LLRP_tSReaderExceptionEvent *pThis); + +extern LLRP_tResultCode +LLRP_ReaderExceptionEvent_setAccessSpecID ( + LLRP_tSReaderExceptionEvent *pThis, + LLRP_tSAccessSpecID *pValue); + +extern LLRP_tSOpSpecID * +LLRP_ReaderExceptionEvent_getOpSpecID ( + LLRP_tSReaderExceptionEvent *pThis); + +extern LLRP_tResultCode +LLRP_ReaderExceptionEvent_setOpSpecID ( + LLRP_tSReaderExceptionEvent *pThis, + LLRP_tSOpSpecID *pValue); + +extern LLRP_tSParameter * +LLRP_ReaderExceptionEvent_beginCustom ( + LLRP_tSReaderExceptionEvent *pThis); + +extern LLRP_tSParameter * +LLRP_ReaderExceptionEvent_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_ReaderExceptionEvent_clearCustom ( + LLRP_tSReaderExceptionEvent *pThis); + +extern int +LLRP_ReaderExceptionEvent_countCustom ( + LLRP_tSReaderExceptionEvent *pThis); + +extern LLRP_tResultCode +LLRP_ReaderExceptionEvent_addCustom ( + LLRP_tSReaderExceptionEvent *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SOpSpecID +{ + LLRP_tSParameter hdr; + + llrp_u16_t OpSpecID; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdOpSpecID; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdOpSpecID[]; + +extern LLRP_tSOpSpecID * +LLRP_OpSpecID_construct (void); + +extern void +LLRP_OpSpecID_destruct ( + LLRP_tSOpSpecID * pThis); + +extern void +LLRP_OpSpecID_decodeFields ( + LLRP_tSOpSpecID * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_OpSpecID_assimilateSubParameters ( + LLRP_tSOpSpecID * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_OpSpecID_encode ( + const LLRP_tSOpSpecID *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdOpSpecID_OpSpecID; + +extern llrp_u16_t +LLRP_OpSpecID_getOpSpecID ( + LLRP_tSOpSpecID *pThis); + +extern LLRP_tResultCode +LLRP_OpSpecID_setOpSpecID ( + LLRP_tSOpSpecID *pThis, + llrp_u16_t Value); + + + + + +struct LLRP_SRFSurveyEvent +{ + LLRP_tSParameter hdr; + + LLRP_tERFSurveyEventType eEventType; + + llrp_u32_t ROSpecID; + + llrp_u16_t SpecIndex; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdRFSurveyEvent; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdRFSurveyEvent[]; + +extern LLRP_tSRFSurveyEvent * +LLRP_RFSurveyEvent_construct (void); + +extern void +LLRP_RFSurveyEvent_destruct ( + LLRP_tSRFSurveyEvent * pThis); + +extern void +LLRP_RFSurveyEvent_decodeFields ( + LLRP_tSRFSurveyEvent * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_RFSurveyEvent_assimilateSubParameters ( + LLRP_tSRFSurveyEvent * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_RFSurveyEvent_encode ( + const LLRP_tSRFSurveyEvent *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdRFSurveyEvent_EventType; + +extern LLRP_tERFSurveyEventType +LLRP_RFSurveyEvent_getEventType ( + LLRP_tSRFSurveyEvent *pThis); + +extern LLRP_tResultCode +LLRP_RFSurveyEvent_setEventType ( + LLRP_tSRFSurveyEvent *pThis, + LLRP_tERFSurveyEventType Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdRFSurveyEvent_ROSpecID; + +extern llrp_u32_t +LLRP_RFSurveyEvent_getROSpecID ( + LLRP_tSRFSurveyEvent *pThis); + +extern LLRP_tResultCode +LLRP_RFSurveyEvent_setROSpecID ( + LLRP_tSRFSurveyEvent *pThis, + llrp_u32_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdRFSurveyEvent_SpecIndex; + +extern llrp_u16_t +LLRP_RFSurveyEvent_getSpecIndex ( + LLRP_tSRFSurveyEvent *pThis); + +extern LLRP_tResultCode +LLRP_RFSurveyEvent_setSpecIndex ( + LLRP_tSRFSurveyEvent *pThis, + llrp_u16_t Value); + + + + + +struct LLRP_SAISpecEvent +{ + LLRP_tSParameter hdr; + + LLRP_tEAISpecEventType eEventType; + + llrp_u32_t ROSpecID; + + llrp_u16_t SpecIndex; + + + LLRP_tSParameter * pAirProtocolSingulationDetails; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdAISpecEvent; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdAISpecEvent[]; + +extern LLRP_tSAISpecEvent * +LLRP_AISpecEvent_construct (void); + +extern void +LLRP_AISpecEvent_destruct ( + LLRP_tSAISpecEvent * pThis); + +extern void +LLRP_AISpecEvent_decodeFields ( + LLRP_tSAISpecEvent * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_AISpecEvent_assimilateSubParameters ( + LLRP_tSAISpecEvent * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_AISpecEvent_encode ( + const LLRP_tSAISpecEvent *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdAISpecEvent_EventType; + +extern LLRP_tEAISpecEventType +LLRP_AISpecEvent_getEventType ( + LLRP_tSAISpecEvent *pThis); + +extern LLRP_tResultCode +LLRP_AISpecEvent_setEventType ( + LLRP_tSAISpecEvent *pThis, + LLRP_tEAISpecEventType Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdAISpecEvent_ROSpecID; + +extern llrp_u32_t +LLRP_AISpecEvent_getROSpecID ( + LLRP_tSAISpecEvent *pThis); + +extern LLRP_tResultCode +LLRP_AISpecEvent_setROSpecID ( + LLRP_tSAISpecEvent *pThis, + llrp_u32_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdAISpecEvent_SpecIndex; + +extern llrp_u16_t +LLRP_AISpecEvent_getSpecIndex ( + LLRP_tSAISpecEvent *pThis); + +extern LLRP_tResultCode +LLRP_AISpecEvent_setSpecIndex ( + LLRP_tSAISpecEvent *pThis, + llrp_u16_t Value); + + +extern LLRP_tSParameter * +LLRP_AISpecEvent_getAirProtocolSingulationDetails ( + LLRP_tSAISpecEvent *pThis); + +extern LLRP_tResultCode +LLRP_AISpecEvent_setAirProtocolSingulationDetails ( + LLRP_tSAISpecEvent *pThis, + LLRP_tSParameter *pValue); + + + + +struct LLRP_SAntennaEvent +{ + LLRP_tSParameter hdr; + + LLRP_tEAntennaEventType eEventType; + + llrp_u16_t AntennaID; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdAntennaEvent; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdAntennaEvent[]; + +extern LLRP_tSAntennaEvent * +LLRP_AntennaEvent_construct (void); + +extern void +LLRP_AntennaEvent_destruct ( + LLRP_tSAntennaEvent * pThis); + +extern void +LLRP_AntennaEvent_decodeFields ( + LLRP_tSAntennaEvent * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_AntennaEvent_assimilateSubParameters ( + LLRP_tSAntennaEvent * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_AntennaEvent_encode ( + const LLRP_tSAntennaEvent *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdAntennaEvent_EventType; + +extern LLRP_tEAntennaEventType +LLRP_AntennaEvent_getEventType ( + LLRP_tSAntennaEvent *pThis); + +extern LLRP_tResultCode +LLRP_AntennaEvent_setEventType ( + LLRP_tSAntennaEvent *pThis, + LLRP_tEAntennaEventType Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdAntennaEvent_AntennaID; + +extern llrp_u16_t +LLRP_AntennaEvent_getAntennaID ( + LLRP_tSAntennaEvent *pThis); + +extern LLRP_tResultCode +LLRP_AntennaEvent_setAntennaID ( + LLRP_tSAntennaEvent *pThis, + llrp_u16_t Value); + + + + + +struct LLRP_SConnectionAttemptEvent +{ + LLRP_tSParameter hdr; + + LLRP_tEConnectionAttemptStatusType eStatus; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdConnectionAttemptEvent; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdConnectionAttemptEvent[]; + +extern LLRP_tSConnectionAttemptEvent * +LLRP_ConnectionAttemptEvent_construct (void); + +extern void +LLRP_ConnectionAttemptEvent_destruct ( + LLRP_tSConnectionAttemptEvent * pThis); + +extern void +LLRP_ConnectionAttemptEvent_decodeFields ( + LLRP_tSConnectionAttemptEvent * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ConnectionAttemptEvent_assimilateSubParameters ( + LLRP_tSConnectionAttemptEvent * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ConnectionAttemptEvent_encode ( + const LLRP_tSConnectionAttemptEvent *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdConnectionAttemptEvent_Status; + +extern LLRP_tEConnectionAttemptStatusType +LLRP_ConnectionAttemptEvent_getStatus ( + LLRP_tSConnectionAttemptEvent *pThis); + +extern LLRP_tResultCode +LLRP_ConnectionAttemptEvent_setStatus ( + LLRP_tSConnectionAttemptEvent *pThis, + LLRP_tEConnectionAttemptStatusType Value); + + + + + +struct LLRP_SConnectionCloseEvent +{ + LLRP_tSParameter hdr; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdConnectionCloseEvent; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdConnectionCloseEvent[]; + +extern LLRP_tSConnectionCloseEvent * +LLRP_ConnectionCloseEvent_construct (void); + +extern void +LLRP_ConnectionCloseEvent_destruct ( + LLRP_tSConnectionCloseEvent * pThis); + +extern void +LLRP_ConnectionCloseEvent_decodeFields ( + LLRP_tSConnectionCloseEvent * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ConnectionCloseEvent_assimilateSubParameters ( + LLRP_tSConnectionCloseEvent * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ConnectionCloseEvent_encode ( + const LLRP_tSConnectionCloseEvent *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + + + + + +struct LLRP_SLLRPStatus +{ + LLRP_tSParameter hdr; + + LLRP_tEStatusCode eStatusCode; + + llrp_utf8v_t ErrorDescription; + + + LLRP_tSFieldError * pFieldError; + + LLRP_tSParameterError * pParameterError; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdLLRPStatus; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdLLRPStatus[]; + +extern LLRP_tSLLRPStatus * +LLRP_LLRPStatus_construct (void); + +extern void +LLRP_LLRPStatus_destruct ( + LLRP_tSLLRPStatus * pThis); + +extern void +LLRP_LLRPStatus_decodeFields ( + LLRP_tSLLRPStatus * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_LLRPStatus_assimilateSubParameters ( + LLRP_tSLLRPStatus * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_LLRPStatus_encode ( + const LLRP_tSLLRPStatus *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdLLRPStatus_StatusCode; + +extern LLRP_tEStatusCode +LLRP_LLRPStatus_getStatusCode ( + LLRP_tSLLRPStatus *pThis); + +extern LLRP_tResultCode +LLRP_LLRPStatus_setStatusCode ( + LLRP_tSLLRPStatus *pThis, + LLRP_tEStatusCode Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdLLRPStatus_ErrorDescription; + +extern llrp_utf8v_t +LLRP_LLRPStatus_getErrorDescription ( + LLRP_tSLLRPStatus *pThis); + +extern LLRP_tResultCode +LLRP_LLRPStatus_setErrorDescription ( + LLRP_tSLLRPStatus *pThis, + llrp_utf8v_t Value); + + +extern LLRP_tSFieldError * +LLRP_LLRPStatus_getFieldError ( + LLRP_tSLLRPStatus *pThis); + +extern LLRP_tResultCode +LLRP_LLRPStatus_setFieldError ( + LLRP_tSLLRPStatus *pThis, + LLRP_tSFieldError *pValue); + +extern LLRP_tSParameterError * +LLRP_LLRPStatus_getParameterError ( + LLRP_tSLLRPStatus *pThis); + +extern LLRP_tResultCode +LLRP_LLRPStatus_setParameterError ( + LLRP_tSLLRPStatus *pThis, + LLRP_tSParameterError *pValue); + + + + +struct LLRP_SFieldError +{ + LLRP_tSParameter hdr; + + llrp_u16_t FieldNum; + + LLRP_tEStatusCode eErrorCode; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdFieldError; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdFieldError[]; + +extern LLRP_tSFieldError * +LLRP_FieldError_construct (void); + +extern void +LLRP_FieldError_destruct ( + LLRP_tSFieldError * pThis); + +extern void +LLRP_FieldError_decodeFields ( + LLRP_tSFieldError * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_FieldError_assimilateSubParameters ( + LLRP_tSFieldError * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_FieldError_encode ( + const LLRP_tSFieldError *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdFieldError_FieldNum; + +extern llrp_u16_t +LLRP_FieldError_getFieldNum ( + LLRP_tSFieldError *pThis); + +extern LLRP_tResultCode +LLRP_FieldError_setFieldNum ( + LLRP_tSFieldError *pThis, + llrp_u16_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdFieldError_ErrorCode; + +extern LLRP_tEStatusCode +LLRP_FieldError_getErrorCode ( + LLRP_tSFieldError *pThis); + +extern LLRP_tResultCode +LLRP_FieldError_setErrorCode ( + LLRP_tSFieldError *pThis, + LLRP_tEStatusCode Value); + + + + + +struct LLRP_SParameterError +{ + LLRP_tSParameter hdr; + + llrp_u16_t ParameterType; + + LLRP_tEStatusCode eErrorCode; + + + LLRP_tSFieldError * pFieldError; + + LLRP_tSParameterError * pParameterError; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdParameterError; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdParameterError[]; + +extern LLRP_tSParameterError * +LLRP_ParameterError_construct (void); + +extern void +LLRP_ParameterError_destruct ( + LLRP_tSParameterError * pThis); + +extern void +LLRP_ParameterError_decodeFields ( + LLRP_tSParameterError * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_ParameterError_assimilateSubParameters ( + LLRP_tSParameterError * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_ParameterError_encode ( + const LLRP_tSParameterError *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdParameterError_ParameterType; + +extern llrp_u16_t +LLRP_ParameterError_getParameterType ( + LLRP_tSParameterError *pThis); + +extern LLRP_tResultCode +LLRP_ParameterError_setParameterType ( + LLRP_tSParameterError *pThis, + llrp_u16_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdParameterError_ErrorCode; + +extern LLRP_tEStatusCode +LLRP_ParameterError_getErrorCode ( + LLRP_tSParameterError *pThis); + +extern LLRP_tResultCode +LLRP_ParameterError_setErrorCode ( + LLRP_tSParameterError *pThis, + LLRP_tEStatusCode Value); + + +extern LLRP_tSFieldError * +LLRP_ParameterError_getFieldError ( + LLRP_tSParameterError *pThis); + +extern LLRP_tResultCode +LLRP_ParameterError_setFieldError ( + LLRP_tSParameterError *pThis, + LLRP_tSFieldError *pValue); + +extern LLRP_tSParameterError * +LLRP_ParameterError_getParameterError ( + LLRP_tSParameterError *pThis); + +extern LLRP_tResultCode +LLRP_ParameterError_setParameterError ( + LLRP_tSParameterError *pThis, + LLRP_tSParameterError *pValue); + + + + +struct LLRP_SC1G2LLRPCapabilities +{ + LLRP_tSParameter hdr; + + llrp_u1_t CanSupportBlockErase; + + llrp_u1_t CanSupportBlockWrite; + + llrp_u16_t MaxNumSelectFiltersPerQuery; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdC1G2LLRPCapabilities; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdC1G2LLRPCapabilities[]; + +extern LLRP_tSC1G2LLRPCapabilities * +LLRP_C1G2LLRPCapabilities_construct (void); + +extern void +LLRP_C1G2LLRPCapabilities_destruct ( + LLRP_tSC1G2LLRPCapabilities * pThis); + +extern void +LLRP_C1G2LLRPCapabilities_decodeFields ( + LLRP_tSC1G2LLRPCapabilities * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_C1G2LLRPCapabilities_assimilateSubParameters ( + LLRP_tSC1G2LLRPCapabilities * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_C1G2LLRPCapabilities_encode ( + const LLRP_tSC1G2LLRPCapabilities *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdC1G2LLRPCapabilities_CanSupportBlockErase; + +extern llrp_u1_t +LLRP_C1G2LLRPCapabilities_getCanSupportBlockErase ( + LLRP_tSC1G2LLRPCapabilities *pThis); + +extern LLRP_tResultCode +LLRP_C1G2LLRPCapabilities_setCanSupportBlockErase ( + LLRP_tSC1G2LLRPCapabilities *pThis, + llrp_u1_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdC1G2LLRPCapabilities_CanSupportBlockWrite; + +extern llrp_u1_t +LLRP_C1G2LLRPCapabilities_getCanSupportBlockWrite ( + LLRP_tSC1G2LLRPCapabilities *pThis); + +extern LLRP_tResultCode +LLRP_C1G2LLRPCapabilities_setCanSupportBlockWrite ( + LLRP_tSC1G2LLRPCapabilities *pThis, + llrp_u1_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdC1G2LLRPCapabilities_MaxNumSelectFiltersPerQuery; + +extern llrp_u16_t +LLRP_C1G2LLRPCapabilities_getMaxNumSelectFiltersPerQuery ( + LLRP_tSC1G2LLRPCapabilities *pThis); + +extern LLRP_tResultCode +LLRP_C1G2LLRPCapabilities_setMaxNumSelectFiltersPerQuery ( + LLRP_tSC1G2LLRPCapabilities *pThis, + llrp_u16_t Value); + + + + + +struct LLRP_SC1G2UHFRFModeTable +{ + LLRP_tSParameter hdr; + + + LLRP_tSC1G2UHFRFModeTableEntry * listC1G2UHFRFModeTableEntry; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdC1G2UHFRFModeTable; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdC1G2UHFRFModeTable[]; + +extern LLRP_tSC1G2UHFRFModeTable * +LLRP_C1G2UHFRFModeTable_construct (void); + +extern void +LLRP_C1G2UHFRFModeTable_destruct ( + LLRP_tSC1G2UHFRFModeTable * pThis); + +extern void +LLRP_C1G2UHFRFModeTable_decodeFields ( + LLRP_tSC1G2UHFRFModeTable * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_C1G2UHFRFModeTable_assimilateSubParameters ( + LLRP_tSC1G2UHFRFModeTable * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_C1G2UHFRFModeTable_encode ( + const LLRP_tSC1G2UHFRFModeTable *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + + +extern LLRP_tSC1G2UHFRFModeTableEntry * +LLRP_C1G2UHFRFModeTable_beginC1G2UHFRFModeTableEntry ( + LLRP_tSC1G2UHFRFModeTable *pThis); + +extern LLRP_tSC1G2UHFRFModeTableEntry * +LLRP_C1G2UHFRFModeTable_nextC1G2UHFRFModeTableEntry ( + LLRP_tSC1G2UHFRFModeTableEntry *pCurrent); + +extern void +LLRP_C1G2UHFRFModeTable_clearC1G2UHFRFModeTableEntry ( + LLRP_tSC1G2UHFRFModeTable *pThis); + +extern int +LLRP_C1G2UHFRFModeTable_countC1G2UHFRFModeTableEntry ( + LLRP_tSC1G2UHFRFModeTable *pThis); + +extern LLRP_tResultCode +LLRP_C1G2UHFRFModeTable_addC1G2UHFRFModeTableEntry ( + LLRP_tSC1G2UHFRFModeTable *pThis, + LLRP_tSC1G2UHFRFModeTableEntry *pValue); + + + + + +struct LLRP_SC1G2UHFRFModeTableEntry +{ + LLRP_tSParameter hdr; + + llrp_u32_t ModeIdentifier; + + LLRP_tEC1G2DRValue eDRValue; + + llrp_u1_t EPCHAGTCConformance; + + LLRP_tEC1G2MValue eMValue; + + LLRP_tEC1G2ForwardLinkModulation eForwardLinkModulation; + + LLRP_tEC1G2SpectralMaskIndicator eSpectralMaskIndicator; + + llrp_u32_t BDRValue; + + llrp_u32_t PIEValue; + + llrp_u32_t MinTariValue; + + llrp_u32_t MaxTariValue; + + llrp_u32_t StepTariValue; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdC1G2UHFRFModeTableEntry; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdC1G2UHFRFModeTableEntry[]; + +extern LLRP_tSC1G2UHFRFModeTableEntry * +LLRP_C1G2UHFRFModeTableEntry_construct (void); + +extern void +LLRP_C1G2UHFRFModeTableEntry_destruct ( + LLRP_tSC1G2UHFRFModeTableEntry * pThis); + +extern void +LLRP_C1G2UHFRFModeTableEntry_decodeFields ( + LLRP_tSC1G2UHFRFModeTableEntry * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_C1G2UHFRFModeTableEntry_assimilateSubParameters ( + LLRP_tSC1G2UHFRFModeTableEntry * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_C1G2UHFRFModeTableEntry_encode ( + const LLRP_tSC1G2UHFRFModeTableEntry *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdC1G2UHFRFModeTableEntry_ModeIdentifier; + +extern llrp_u32_t +LLRP_C1G2UHFRFModeTableEntry_getModeIdentifier ( + LLRP_tSC1G2UHFRFModeTableEntry *pThis); + +extern LLRP_tResultCode +LLRP_C1G2UHFRFModeTableEntry_setModeIdentifier ( + LLRP_tSC1G2UHFRFModeTableEntry *pThis, + llrp_u32_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdC1G2UHFRFModeTableEntry_DRValue; + +extern LLRP_tEC1G2DRValue +LLRP_C1G2UHFRFModeTableEntry_getDRValue ( + LLRP_tSC1G2UHFRFModeTableEntry *pThis); + +extern LLRP_tResultCode +LLRP_C1G2UHFRFModeTableEntry_setDRValue ( + LLRP_tSC1G2UHFRFModeTableEntry *pThis, + LLRP_tEC1G2DRValue Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdC1G2UHFRFModeTableEntry_EPCHAGTCConformance; + +extern llrp_u1_t +LLRP_C1G2UHFRFModeTableEntry_getEPCHAGTCConformance ( + LLRP_tSC1G2UHFRFModeTableEntry *pThis); + +extern LLRP_tResultCode +LLRP_C1G2UHFRFModeTableEntry_setEPCHAGTCConformance ( + LLRP_tSC1G2UHFRFModeTableEntry *pThis, + llrp_u1_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdC1G2UHFRFModeTableEntry_MValue; + +extern LLRP_tEC1G2MValue +LLRP_C1G2UHFRFModeTableEntry_getMValue ( + LLRP_tSC1G2UHFRFModeTableEntry *pThis); + +extern LLRP_tResultCode +LLRP_C1G2UHFRFModeTableEntry_setMValue ( + LLRP_tSC1G2UHFRFModeTableEntry *pThis, + LLRP_tEC1G2MValue Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdC1G2UHFRFModeTableEntry_ForwardLinkModulation; + +extern LLRP_tEC1G2ForwardLinkModulation +LLRP_C1G2UHFRFModeTableEntry_getForwardLinkModulation ( + LLRP_tSC1G2UHFRFModeTableEntry *pThis); + +extern LLRP_tResultCode +LLRP_C1G2UHFRFModeTableEntry_setForwardLinkModulation ( + LLRP_tSC1G2UHFRFModeTableEntry *pThis, + LLRP_tEC1G2ForwardLinkModulation Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdC1G2UHFRFModeTableEntry_SpectralMaskIndicator; + +extern LLRP_tEC1G2SpectralMaskIndicator +LLRP_C1G2UHFRFModeTableEntry_getSpectralMaskIndicator ( + LLRP_tSC1G2UHFRFModeTableEntry *pThis); + +extern LLRP_tResultCode +LLRP_C1G2UHFRFModeTableEntry_setSpectralMaskIndicator ( + LLRP_tSC1G2UHFRFModeTableEntry *pThis, + LLRP_tEC1G2SpectralMaskIndicator Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdC1G2UHFRFModeTableEntry_BDRValue; + +extern llrp_u32_t +LLRP_C1G2UHFRFModeTableEntry_getBDRValue ( + LLRP_tSC1G2UHFRFModeTableEntry *pThis); + +extern LLRP_tResultCode +LLRP_C1G2UHFRFModeTableEntry_setBDRValue ( + LLRP_tSC1G2UHFRFModeTableEntry *pThis, + llrp_u32_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdC1G2UHFRFModeTableEntry_PIEValue; + +extern llrp_u32_t +LLRP_C1G2UHFRFModeTableEntry_getPIEValue ( + LLRP_tSC1G2UHFRFModeTableEntry *pThis); + +extern LLRP_tResultCode +LLRP_C1G2UHFRFModeTableEntry_setPIEValue ( + LLRP_tSC1G2UHFRFModeTableEntry *pThis, + llrp_u32_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdC1G2UHFRFModeTableEntry_MinTariValue; + +extern llrp_u32_t +LLRP_C1G2UHFRFModeTableEntry_getMinTariValue ( + LLRP_tSC1G2UHFRFModeTableEntry *pThis); + +extern LLRP_tResultCode +LLRP_C1G2UHFRFModeTableEntry_setMinTariValue ( + LLRP_tSC1G2UHFRFModeTableEntry *pThis, + llrp_u32_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdC1G2UHFRFModeTableEntry_MaxTariValue; + +extern llrp_u32_t +LLRP_C1G2UHFRFModeTableEntry_getMaxTariValue ( + LLRP_tSC1G2UHFRFModeTableEntry *pThis); + +extern LLRP_tResultCode +LLRP_C1G2UHFRFModeTableEntry_setMaxTariValue ( + LLRP_tSC1G2UHFRFModeTableEntry *pThis, + llrp_u32_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdC1G2UHFRFModeTableEntry_StepTariValue; + +extern llrp_u32_t +LLRP_C1G2UHFRFModeTableEntry_getStepTariValue ( + LLRP_tSC1G2UHFRFModeTableEntry *pThis); + +extern LLRP_tResultCode +LLRP_C1G2UHFRFModeTableEntry_setStepTariValue ( + LLRP_tSC1G2UHFRFModeTableEntry *pThis, + llrp_u32_t Value); + + + + + +struct LLRP_SC1G2InventoryCommand +{ + LLRP_tSParameter hdr; + + llrp_u1_t TagInventoryStateAware; + + + LLRP_tSC1G2Filter * listC1G2Filter; + + LLRP_tSC1G2RFControl * pC1G2RFControl; + + LLRP_tSC1G2SingulationControl * pC1G2SingulationControl; + + LLRP_tSParameter * listCustom; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdC1G2InventoryCommand; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdC1G2InventoryCommand[]; + +extern LLRP_tSC1G2InventoryCommand * +LLRP_C1G2InventoryCommand_construct (void); + +extern void +LLRP_C1G2InventoryCommand_destruct ( + LLRP_tSC1G2InventoryCommand * pThis); + +extern void +LLRP_C1G2InventoryCommand_decodeFields ( + LLRP_tSC1G2InventoryCommand * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_C1G2InventoryCommand_assimilateSubParameters ( + LLRP_tSC1G2InventoryCommand * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_C1G2InventoryCommand_encode ( + const LLRP_tSC1G2InventoryCommand *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdC1G2InventoryCommand_TagInventoryStateAware; + +extern llrp_u1_t +LLRP_C1G2InventoryCommand_getTagInventoryStateAware ( + LLRP_tSC1G2InventoryCommand *pThis); + +extern LLRP_tResultCode +LLRP_C1G2InventoryCommand_setTagInventoryStateAware ( + LLRP_tSC1G2InventoryCommand *pThis, + llrp_u1_t Value); + + +extern LLRP_tSC1G2Filter * +LLRP_C1G2InventoryCommand_beginC1G2Filter ( + LLRP_tSC1G2InventoryCommand *pThis); + +extern LLRP_tSC1G2Filter * +LLRP_C1G2InventoryCommand_nextC1G2Filter ( + LLRP_tSC1G2Filter *pCurrent); + +extern void +LLRP_C1G2InventoryCommand_clearC1G2Filter ( + LLRP_tSC1G2InventoryCommand *pThis); + +extern int +LLRP_C1G2InventoryCommand_countC1G2Filter ( + LLRP_tSC1G2InventoryCommand *pThis); + +extern LLRP_tResultCode +LLRP_C1G2InventoryCommand_addC1G2Filter ( + LLRP_tSC1G2InventoryCommand *pThis, + LLRP_tSC1G2Filter *pValue); + + +extern LLRP_tSC1G2RFControl * +LLRP_C1G2InventoryCommand_getC1G2RFControl ( + LLRP_tSC1G2InventoryCommand *pThis); + +extern LLRP_tResultCode +LLRP_C1G2InventoryCommand_setC1G2RFControl ( + LLRP_tSC1G2InventoryCommand *pThis, + LLRP_tSC1G2RFControl *pValue); + +extern LLRP_tSC1G2SingulationControl * +LLRP_C1G2InventoryCommand_getC1G2SingulationControl ( + LLRP_tSC1G2InventoryCommand *pThis); + +extern LLRP_tResultCode +LLRP_C1G2InventoryCommand_setC1G2SingulationControl ( + LLRP_tSC1G2InventoryCommand *pThis, + LLRP_tSC1G2SingulationControl *pValue); + +extern LLRP_tSParameter * +LLRP_C1G2InventoryCommand_beginCustom ( + LLRP_tSC1G2InventoryCommand *pThis); + +extern LLRP_tSParameter * +LLRP_C1G2InventoryCommand_nextCustom ( + LLRP_tSParameter *pCurrent); + +extern void +LLRP_C1G2InventoryCommand_clearCustom ( + LLRP_tSC1G2InventoryCommand *pThis); + +extern int +LLRP_C1G2InventoryCommand_countCustom ( + LLRP_tSC1G2InventoryCommand *pThis); + +extern LLRP_tResultCode +LLRP_C1G2InventoryCommand_addCustom ( + LLRP_tSC1G2InventoryCommand *pThis, + LLRP_tSParameter *pValue); + + + + + +struct LLRP_SC1G2Filter +{ + LLRP_tSParameter hdr; + + LLRP_tEC1G2TruncateAction eT; + + + LLRP_tSC1G2TagInventoryMask * pC1G2TagInventoryMask; + + LLRP_tSC1G2TagInventoryStateAwareFilterAction * pC1G2TagInventoryStateAwareFilterAction; + + LLRP_tSC1G2TagInventoryStateUnawareFilterAction * pC1G2TagInventoryStateUnawareFilterAction; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdC1G2Filter; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdC1G2Filter[]; + +extern LLRP_tSC1G2Filter * +LLRP_C1G2Filter_construct (void); + +extern void +LLRP_C1G2Filter_destruct ( + LLRP_tSC1G2Filter * pThis); + +extern void +LLRP_C1G2Filter_decodeFields ( + LLRP_tSC1G2Filter * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_C1G2Filter_assimilateSubParameters ( + LLRP_tSC1G2Filter * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_C1G2Filter_encode ( + const LLRP_tSC1G2Filter *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdC1G2Filter_T; + +extern LLRP_tEC1G2TruncateAction +LLRP_C1G2Filter_getT ( + LLRP_tSC1G2Filter *pThis); + +extern LLRP_tResultCode +LLRP_C1G2Filter_setT ( + LLRP_tSC1G2Filter *pThis, + LLRP_tEC1G2TruncateAction Value); + + +extern LLRP_tSC1G2TagInventoryMask * +LLRP_C1G2Filter_getC1G2TagInventoryMask ( + LLRP_tSC1G2Filter *pThis); + +extern LLRP_tResultCode +LLRP_C1G2Filter_setC1G2TagInventoryMask ( + LLRP_tSC1G2Filter *pThis, + LLRP_tSC1G2TagInventoryMask *pValue); + +extern LLRP_tSC1G2TagInventoryStateAwareFilterAction * +LLRP_C1G2Filter_getC1G2TagInventoryStateAwareFilterAction ( + LLRP_tSC1G2Filter *pThis); + +extern LLRP_tResultCode +LLRP_C1G2Filter_setC1G2TagInventoryStateAwareFilterAction ( + LLRP_tSC1G2Filter *pThis, + LLRP_tSC1G2TagInventoryStateAwareFilterAction *pValue); + +extern LLRP_tSC1G2TagInventoryStateUnawareFilterAction * +LLRP_C1G2Filter_getC1G2TagInventoryStateUnawareFilterAction ( + LLRP_tSC1G2Filter *pThis); + +extern LLRP_tResultCode +LLRP_C1G2Filter_setC1G2TagInventoryStateUnawareFilterAction ( + LLRP_tSC1G2Filter *pThis, + LLRP_tSC1G2TagInventoryStateUnawareFilterAction *pValue); + + + + +struct LLRP_SC1G2TagInventoryMask +{ + LLRP_tSParameter hdr; + + llrp_u2_t MB; + + llrp_u16_t Pointer; + + llrp_u1v_t TagMask; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdC1G2TagInventoryMask; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdC1G2TagInventoryMask[]; + +extern LLRP_tSC1G2TagInventoryMask * +LLRP_C1G2TagInventoryMask_construct (void); + +extern void +LLRP_C1G2TagInventoryMask_destruct ( + LLRP_tSC1G2TagInventoryMask * pThis); + +extern void +LLRP_C1G2TagInventoryMask_decodeFields ( + LLRP_tSC1G2TagInventoryMask * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_C1G2TagInventoryMask_assimilateSubParameters ( + LLRP_tSC1G2TagInventoryMask * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_C1G2TagInventoryMask_encode ( + const LLRP_tSC1G2TagInventoryMask *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdC1G2TagInventoryMask_MB; + +extern llrp_u2_t +LLRP_C1G2TagInventoryMask_getMB ( + LLRP_tSC1G2TagInventoryMask *pThis); + +extern LLRP_tResultCode +LLRP_C1G2TagInventoryMask_setMB ( + LLRP_tSC1G2TagInventoryMask *pThis, + llrp_u2_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdC1G2TagInventoryMask_Pointer; + +extern llrp_u16_t +LLRP_C1G2TagInventoryMask_getPointer ( + LLRP_tSC1G2TagInventoryMask *pThis); + +extern LLRP_tResultCode +LLRP_C1G2TagInventoryMask_setPointer ( + LLRP_tSC1G2TagInventoryMask *pThis, + llrp_u16_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdC1G2TagInventoryMask_TagMask; + +extern llrp_u1v_t +LLRP_C1G2TagInventoryMask_getTagMask ( + LLRP_tSC1G2TagInventoryMask *pThis); + +extern LLRP_tResultCode +LLRP_C1G2TagInventoryMask_setTagMask ( + LLRP_tSC1G2TagInventoryMask *pThis, + llrp_u1v_t Value); + + + + + +struct LLRP_SC1G2TagInventoryStateAwareFilterAction +{ + LLRP_tSParameter hdr; + + LLRP_tEC1G2StateAwareTarget eTarget; + + LLRP_tEC1G2StateAwareAction eAction; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdC1G2TagInventoryStateAwareFilterAction; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdC1G2TagInventoryStateAwareFilterAction[]; + +extern LLRP_tSC1G2TagInventoryStateAwareFilterAction * +LLRP_C1G2TagInventoryStateAwareFilterAction_construct (void); + +extern void +LLRP_C1G2TagInventoryStateAwareFilterAction_destruct ( + LLRP_tSC1G2TagInventoryStateAwareFilterAction * pThis); + +extern void +LLRP_C1G2TagInventoryStateAwareFilterAction_decodeFields ( + LLRP_tSC1G2TagInventoryStateAwareFilterAction * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_C1G2TagInventoryStateAwareFilterAction_assimilateSubParameters ( + LLRP_tSC1G2TagInventoryStateAwareFilterAction * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_C1G2TagInventoryStateAwareFilterAction_encode ( + const LLRP_tSC1G2TagInventoryStateAwareFilterAction *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdC1G2TagInventoryStateAwareFilterAction_Target; + +extern LLRP_tEC1G2StateAwareTarget +LLRP_C1G2TagInventoryStateAwareFilterAction_getTarget ( + LLRP_tSC1G2TagInventoryStateAwareFilterAction *pThis); + +extern LLRP_tResultCode +LLRP_C1G2TagInventoryStateAwareFilterAction_setTarget ( + LLRP_tSC1G2TagInventoryStateAwareFilterAction *pThis, + LLRP_tEC1G2StateAwareTarget Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdC1G2TagInventoryStateAwareFilterAction_Action; + +extern LLRP_tEC1G2StateAwareAction +LLRP_C1G2TagInventoryStateAwareFilterAction_getAction ( + LLRP_tSC1G2TagInventoryStateAwareFilterAction *pThis); + +extern LLRP_tResultCode +LLRP_C1G2TagInventoryStateAwareFilterAction_setAction ( + LLRP_tSC1G2TagInventoryStateAwareFilterAction *pThis, + LLRP_tEC1G2StateAwareAction Value); + + + + + +struct LLRP_SC1G2TagInventoryStateUnawareFilterAction +{ + LLRP_tSParameter hdr; + + LLRP_tEC1G2StateUnawareAction eAction; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdC1G2TagInventoryStateUnawareFilterAction; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdC1G2TagInventoryStateUnawareFilterAction[]; + +extern LLRP_tSC1G2TagInventoryStateUnawareFilterAction * +LLRP_C1G2TagInventoryStateUnawareFilterAction_construct (void); + +extern void +LLRP_C1G2TagInventoryStateUnawareFilterAction_destruct ( + LLRP_tSC1G2TagInventoryStateUnawareFilterAction * pThis); + +extern void +LLRP_C1G2TagInventoryStateUnawareFilterAction_decodeFields ( + LLRP_tSC1G2TagInventoryStateUnawareFilterAction * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_C1G2TagInventoryStateUnawareFilterAction_assimilateSubParameters ( + LLRP_tSC1G2TagInventoryStateUnawareFilterAction * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_C1G2TagInventoryStateUnawareFilterAction_encode ( + const LLRP_tSC1G2TagInventoryStateUnawareFilterAction *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdC1G2TagInventoryStateUnawareFilterAction_Action; + +extern LLRP_tEC1G2StateUnawareAction +LLRP_C1G2TagInventoryStateUnawareFilterAction_getAction ( + LLRP_tSC1G2TagInventoryStateUnawareFilterAction *pThis); + +extern LLRP_tResultCode +LLRP_C1G2TagInventoryStateUnawareFilterAction_setAction ( + LLRP_tSC1G2TagInventoryStateUnawareFilterAction *pThis, + LLRP_tEC1G2StateUnawareAction Value); + + + + + +struct LLRP_SC1G2RFControl +{ + LLRP_tSParameter hdr; + + llrp_u16_t ModeIndex; + + llrp_u16_t Tari; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdC1G2RFControl; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdC1G2RFControl[]; + +extern LLRP_tSC1G2RFControl * +LLRP_C1G2RFControl_construct (void); + +extern void +LLRP_C1G2RFControl_destruct ( + LLRP_tSC1G2RFControl * pThis); + +extern void +LLRP_C1G2RFControl_decodeFields ( + LLRP_tSC1G2RFControl * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_C1G2RFControl_assimilateSubParameters ( + LLRP_tSC1G2RFControl * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_C1G2RFControl_encode ( + const LLRP_tSC1G2RFControl *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdC1G2RFControl_ModeIndex; + +extern llrp_u16_t +LLRP_C1G2RFControl_getModeIndex ( + LLRP_tSC1G2RFControl *pThis); + +extern LLRP_tResultCode +LLRP_C1G2RFControl_setModeIndex ( + LLRP_tSC1G2RFControl *pThis, + llrp_u16_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdC1G2RFControl_Tari; + +extern llrp_u16_t +LLRP_C1G2RFControl_getTari ( + LLRP_tSC1G2RFControl *pThis); + +extern LLRP_tResultCode +LLRP_C1G2RFControl_setTari ( + LLRP_tSC1G2RFControl *pThis, + llrp_u16_t Value); + + + + + +struct LLRP_SC1G2SingulationControl +{ + LLRP_tSParameter hdr; + + llrp_u2_t Session; + + llrp_u16_t TagPopulation; + + llrp_u32_t TagTransitTime; + + + LLRP_tSC1G2TagInventoryStateAwareSingulationAction * pC1G2TagInventoryStateAwareSingulationAction; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdC1G2SingulationControl; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdC1G2SingulationControl[]; + +extern LLRP_tSC1G2SingulationControl * +LLRP_C1G2SingulationControl_construct (void); + +extern void +LLRP_C1G2SingulationControl_destruct ( + LLRP_tSC1G2SingulationControl * pThis); + +extern void +LLRP_C1G2SingulationControl_decodeFields ( + LLRP_tSC1G2SingulationControl * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_C1G2SingulationControl_assimilateSubParameters ( + LLRP_tSC1G2SingulationControl * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_C1G2SingulationControl_encode ( + const LLRP_tSC1G2SingulationControl *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdC1G2SingulationControl_Session; + +extern llrp_u2_t +LLRP_C1G2SingulationControl_getSession ( + LLRP_tSC1G2SingulationControl *pThis); + +extern LLRP_tResultCode +LLRP_C1G2SingulationControl_setSession ( + LLRP_tSC1G2SingulationControl *pThis, + llrp_u2_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdC1G2SingulationControl_TagPopulation; + +extern llrp_u16_t +LLRP_C1G2SingulationControl_getTagPopulation ( + LLRP_tSC1G2SingulationControl *pThis); + +extern LLRP_tResultCode +LLRP_C1G2SingulationControl_setTagPopulation ( + LLRP_tSC1G2SingulationControl *pThis, + llrp_u16_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdC1G2SingulationControl_TagTransitTime; + +extern llrp_u32_t +LLRP_C1G2SingulationControl_getTagTransitTime ( + LLRP_tSC1G2SingulationControl *pThis); + +extern LLRP_tResultCode +LLRP_C1G2SingulationControl_setTagTransitTime ( + LLRP_tSC1G2SingulationControl *pThis, + llrp_u32_t Value); + + +extern LLRP_tSC1G2TagInventoryStateAwareSingulationAction * +LLRP_C1G2SingulationControl_getC1G2TagInventoryStateAwareSingulationAction ( + LLRP_tSC1G2SingulationControl *pThis); + +extern LLRP_tResultCode +LLRP_C1G2SingulationControl_setC1G2TagInventoryStateAwareSingulationAction ( + LLRP_tSC1G2SingulationControl *pThis, + LLRP_tSC1G2TagInventoryStateAwareSingulationAction *pValue); + + + + +struct LLRP_SC1G2TagInventoryStateAwareSingulationAction +{ + LLRP_tSParameter hdr; + + LLRP_tEC1G2TagInventoryStateAwareI eI; + + LLRP_tEC1G2TagInventoryStateAwareS eS; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdC1G2TagInventoryStateAwareSingulationAction; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdC1G2TagInventoryStateAwareSingulationAction[]; + +extern LLRP_tSC1G2TagInventoryStateAwareSingulationAction * +LLRP_C1G2TagInventoryStateAwareSingulationAction_construct (void); + +extern void +LLRP_C1G2TagInventoryStateAwareSingulationAction_destruct ( + LLRP_tSC1G2TagInventoryStateAwareSingulationAction * pThis); + +extern void +LLRP_C1G2TagInventoryStateAwareSingulationAction_decodeFields ( + LLRP_tSC1G2TagInventoryStateAwareSingulationAction * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_C1G2TagInventoryStateAwareSingulationAction_assimilateSubParameters ( + LLRP_tSC1G2TagInventoryStateAwareSingulationAction * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_C1G2TagInventoryStateAwareSingulationAction_encode ( + const LLRP_tSC1G2TagInventoryStateAwareSingulationAction *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdC1G2TagInventoryStateAwareSingulationAction_I; + +extern LLRP_tEC1G2TagInventoryStateAwareI +LLRP_C1G2TagInventoryStateAwareSingulationAction_getI ( + LLRP_tSC1G2TagInventoryStateAwareSingulationAction *pThis); + +extern LLRP_tResultCode +LLRP_C1G2TagInventoryStateAwareSingulationAction_setI ( + LLRP_tSC1G2TagInventoryStateAwareSingulationAction *pThis, + LLRP_tEC1G2TagInventoryStateAwareI Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdC1G2TagInventoryStateAwareSingulationAction_S; + +extern LLRP_tEC1G2TagInventoryStateAwareS +LLRP_C1G2TagInventoryStateAwareSingulationAction_getS ( + LLRP_tSC1G2TagInventoryStateAwareSingulationAction *pThis); + +extern LLRP_tResultCode +LLRP_C1G2TagInventoryStateAwareSingulationAction_setS ( + LLRP_tSC1G2TagInventoryStateAwareSingulationAction *pThis, + LLRP_tEC1G2TagInventoryStateAwareS Value); + + + + + +struct LLRP_SC1G2TagSpec +{ + LLRP_tSParameter hdr; + + + LLRP_tSC1G2TargetTag * listC1G2TargetTag; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdC1G2TagSpec; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdC1G2TagSpec[]; + +extern LLRP_tSC1G2TagSpec * +LLRP_C1G2TagSpec_construct (void); + +extern void +LLRP_C1G2TagSpec_destruct ( + LLRP_tSC1G2TagSpec * pThis); + +extern void +LLRP_C1G2TagSpec_decodeFields ( + LLRP_tSC1G2TagSpec * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_C1G2TagSpec_assimilateSubParameters ( + LLRP_tSC1G2TagSpec * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_C1G2TagSpec_encode ( + const LLRP_tSC1G2TagSpec *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + + +extern LLRP_tSC1G2TargetTag * +LLRP_C1G2TagSpec_beginC1G2TargetTag ( + LLRP_tSC1G2TagSpec *pThis); + +extern LLRP_tSC1G2TargetTag * +LLRP_C1G2TagSpec_nextC1G2TargetTag ( + LLRP_tSC1G2TargetTag *pCurrent); + +extern void +LLRP_C1G2TagSpec_clearC1G2TargetTag ( + LLRP_tSC1G2TagSpec *pThis); + +extern int +LLRP_C1G2TagSpec_countC1G2TargetTag ( + LLRP_tSC1G2TagSpec *pThis); + +extern LLRP_tResultCode +LLRP_C1G2TagSpec_addC1G2TargetTag ( + LLRP_tSC1G2TagSpec *pThis, + LLRP_tSC1G2TargetTag *pValue); + + + + + +struct LLRP_SC1G2TargetTag +{ + LLRP_tSParameter hdr; + + llrp_u2_t MB; + + llrp_u1_t Match; + + llrp_u16_t Pointer; + + llrp_u1v_t TagMask; + + llrp_u1v_t TagData; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdC1G2TargetTag; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdC1G2TargetTag[]; + +extern LLRP_tSC1G2TargetTag * +LLRP_C1G2TargetTag_construct (void); + +extern void +LLRP_C1G2TargetTag_destruct ( + LLRP_tSC1G2TargetTag * pThis); + +extern void +LLRP_C1G2TargetTag_decodeFields ( + LLRP_tSC1G2TargetTag * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_C1G2TargetTag_assimilateSubParameters ( + LLRP_tSC1G2TargetTag * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_C1G2TargetTag_encode ( + const LLRP_tSC1G2TargetTag *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdC1G2TargetTag_MB; + +extern llrp_u2_t +LLRP_C1G2TargetTag_getMB ( + LLRP_tSC1G2TargetTag *pThis); + +extern LLRP_tResultCode +LLRP_C1G2TargetTag_setMB ( + LLRP_tSC1G2TargetTag *pThis, + llrp_u2_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdC1G2TargetTag_Match; + +extern llrp_u1_t +LLRP_C1G2TargetTag_getMatch ( + LLRP_tSC1G2TargetTag *pThis); + +extern LLRP_tResultCode +LLRP_C1G2TargetTag_setMatch ( + LLRP_tSC1G2TargetTag *pThis, + llrp_u1_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdC1G2TargetTag_Pointer; + +extern llrp_u16_t +LLRP_C1G2TargetTag_getPointer ( + LLRP_tSC1G2TargetTag *pThis); + +extern LLRP_tResultCode +LLRP_C1G2TargetTag_setPointer ( + LLRP_tSC1G2TargetTag *pThis, + llrp_u16_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdC1G2TargetTag_TagMask; + +extern llrp_u1v_t +LLRP_C1G2TargetTag_getTagMask ( + LLRP_tSC1G2TargetTag *pThis); + +extern LLRP_tResultCode +LLRP_C1G2TargetTag_setTagMask ( + LLRP_tSC1G2TargetTag *pThis, + llrp_u1v_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdC1G2TargetTag_TagData; + +extern llrp_u1v_t +LLRP_C1G2TargetTag_getTagData ( + LLRP_tSC1G2TargetTag *pThis); + +extern LLRP_tResultCode +LLRP_C1G2TargetTag_setTagData ( + LLRP_tSC1G2TargetTag *pThis, + llrp_u1v_t Value); + + + + + +struct LLRP_SC1G2Read +{ + LLRP_tSParameter hdr; + + llrp_u16_t OpSpecID; + + llrp_u32_t AccessPassword; + + llrp_u2_t MB; + + llrp_u16_t WordPointer; + + llrp_u16_t WordCount; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdC1G2Read; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdC1G2Read[]; + +extern LLRP_tSC1G2Read * +LLRP_C1G2Read_construct (void); + +extern void +LLRP_C1G2Read_destruct ( + LLRP_tSC1G2Read * pThis); + +extern void +LLRP_C1G2Read_decodeFields ( + LLRP_tSC1G2Read * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_C1G2Read_assimilateSubParameters ( + LLRP_tSC1G2Read * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_C1G2Read_encode ( + const LLRP_tSC1G2Read *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdC1G2Read_OpSpecID; + +extern llrp_u16_t +LLRP_C1G2Read_getOpSpecID ( + LLRP_tSC1G2Read *pThis); + +extern LLRP_tResultCode +LLRP_C1G2Read_setOpSpecID ( + LLRP_tSC1G2Read *pThis, + llrp_u16_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdC1G2Read_AccessPassword; + +extern llrp_u32_t +LLRP_C1G2Read_getAccessPassword ( + LLRP_tSC1G2Read *pThis); + +extern LLRP_tResultCode +LLRP_C1G2Read_setAccessPassword ( + LLRP_tSC1G2Read *pThis, + llrp_u32_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdC1G2Read_MB; + +extern llrp_u2_t +LLRP_C1G2Read_getMB ( + LLRP_tSC1G2Read *pThis); + +extern LLRP_tResultCode +LLRP_C1G2Read_setMB ( + LLRP_tSC1G2Read *pThis, + llrp_u2_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdC1G2Read_WordPointer; + +extern llrp_u16_t +LLRP_C1G2Read_getWordPointer ( + LLRP_tSC1G2Read *pThis); + +extern LLRP_tResultCode +LLRP_C1G2Read_setWordPointer ( + LLRP_tSC1G2Read *pThis, + llrp_u16_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdC1G2Read_WordCount; + +extern llrp_u16_t +LLRP_C1G2Read_getWordCount ( + LLRP_tSC1G2Read *pThis); + +extern LLRP_tResultCode +LLRP_C1G2Read_setWordCount ( + LLRP_tSC1G2Read *pThis, + llrp_u16_t Value); + + + + + +struct LLRP_SC1G2Write +{ + LLRP_tSParameter hdr; + + llrp_u16_t OpSpecID; + + llrp_u32_t AccessPassword; + + llrp_u2_t MB; + + llrp_u16_t WordPointer; + + llrp_u16v_t WriteData; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdC1G2Write; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdC1G2Write[]; + +extern LLRP_tSC1G2Write * +LLRP_C1G2Write_construct (void); + +extern void +LLRP_C1G2Write_destruct ( + LLRP_tSC1G2Write * pThis); + +extern void +LLRP_C1G2Write_decodeFields ( + LLRP_tSC1G2Write * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_C1G2Write_assimilateSubParameters ( + LLRP_tSC1G2Write * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_C1G2Write_encode ( + const LLRP_tSC1G2Write *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdC1G2Write_OpSpecID; + +extern llrp_u16_t +LLRP_C1G2Write_getOpSpecID ( + LLRP_tSC1G2Write *pThis); + +extern LLRP_tResultCode +LLRP_C1G2Write_setOpSpecID ( + LLRP_tSC1G2Write *pThis, + llrp_u16_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdC1G2Write_AccessPassword; + +extern llrp_u32_t +LLRP_C1G2Write_getAccessPassword ( + LLRP_tSC1G2Write *pThis); + +extern LLRP_tResultCode +LLRP_C1G2Write_setAccessPassword ( + LLRP_tSC1G2Write *pThis, + llrp_u32_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdC1G2Write_MB; + +extern llrp_u2_t +LLRP_C1G2Write_getMB ( + LLRP_tSC1G2Write *pThis); + +extern LLRP_tResultCode +LLRP_C1G2Write_setMB ( + LLRP_tSC1G2Write *pThis, + llrp_u2_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdC1G2Write_WordPointer; + +extern llrp_u16_t +LLRP_C1G2Write_getWordPointer ( + LLRP_tSC1G2Write *pThis); + +extern LLRP_tResultCode +LLRP_C1G2Write_setWordPointer ( + LLRP_tSC1G2Write *pThis, + llrp_u16_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdC1G2Write_WriteData; + +extern llrp_u16v_t +LLRP_C1G2Write_getWriteData ( + LLRP_tSC1G2Write *pThis); + +extern LLRP_tResultCode +LLRP_C1G2Write_setWriteData ( + LLRP_tSC1G2Write *pThis, + llrp_u16v_t Value); + + + + + +struct LLRP_SC1G2Kill +{ + LLRP_tSParameter hdr; + + llrp_u16_t OpSpecID; + + llrp_u32_t KillPassword; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdC1G2Kill; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdC1G2Kill[]; + +extern LLRP_tSC1G2Kill * +LLRP_C1G2Kill_construct (void); + +extern void +LLRP_C1G2Kill_destruct ( + LLRP_tSC1G2Kill * pThis); + +extern void +LLRP_C1G2Kill_decodeFields ( + LLRP_tSC1G2Kill * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_C1G2Kill_assimilateSubParameters ( + LLRP_tSC1G2Kill * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_C1G2Kill_encode ( + const LLRP_tSC1G2Kill *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdC1G2Kill_OpSpecID; + +extern llrp_u16_t +LLRP_C1G2Kill_getOpSpecID ( + LLRP_tSC1G2Kill *pThis); + +extern LLRP_tResultCode +LLRP_C1G2Kill_setOpSpecID ( + LLRP_tSC1G2Kill *pThis, + llrp_u16_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdC1G2Kill_KillPassword; + +extern llrp_u32_t +LLRP_C1G2Kill_getKillPassword ( + LLRP_tSC1G2Kill *pThis); + +extern LLRP_tResultCode +LLRP_C1G2Kill_setKillPassword ( + LLRP_tSC1G2Kill *pThis, + llrp_u32_t Value); + + + + + +struct LLRP_SC1G2Lock +{ + LLRP_tSParameter hdr; + + llrp_u16_t OpSpecID; + + llrp_u32_t AccessPassword; + + + LLRP_tSC1G2LockPayload * listC1G2LockPayload; + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdC1G2Lock; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdC1G2Lock[]; + +extern LLRP_tSC1G2Lock * +LLRP_C1G2Lock_construct (void); + +extern void +LLRP_C1G2Lock_destruct ( + LLRP_tSC1G2Lock * pThis); + +extern void +LLRP_C1G2Lock_decodeFields ( + LLRP_tSC1G2Lock * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_C1G2Lock_assimilateSubParameters ( + LLRP_tSC1G2Lock * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_C1G2Lock_encode ( + const LLRP_tSC1G2Lock *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdC1G2Lock_OpSpecID; + +extern llrp_u16_t +LLRP_C1G2Lock_getOpSpecID ( + LLRP_tSC1G2Lock *pThis); + +extern LLRP_tResultCode +LLRP_C1G2Lock_setOpSpecID ( + LLRP_tSC1G2Lock *pThis, + llrp_u16_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdC1G2Lock_AccessPassword; + +extern llrp_u32_t +LLRP_C1G2Lock_getAccessPassword ( + LLRP_tSC1G2Lock *pThis); + +extern LLRP_tResultCode +LLRP_C1G2Lock_setAccessPassword ( + LLRP_tSC1G2Lock *pThis, + llrp_u32_t Value); + + +extern LLRP_tSC1G2LockPayload * +LLRP_C1G2Lock_beginC1G2LockPayload ( + LLRP_tSC1G2Lock *pThis); + +extern LLRP_tSC1G2LockPayload * +LLRP_C1G2Lock_nextC1G2LockPayload ( + LLRP_tSC1G2LockPayload *pCurrent); + +extern void +LLRP_C1G2Lock_clearC1G2LockPayload ( + LLRP_tSC1G2Lock *pThis); + +extern int +LLRP_C1G2Lock_countC1G2LockPayload ( + LLRP_tSC1G2Lock *pThis); + +extern LLRP_tResultCode +LLRP_C1G2Lock_addC1G2LockPayload ( + LLRP_tSC1G2Lock *pThis, + LLRP_tSC1G2LockPayload *pValue); + + + + + +struct LLRP_SC1G2LockPayload +{ + LLRP_tSParameter hdr; + + LLRP_tEC1G2LockPrivilege ePrivilege; + + LLRP_tEC1G2LockDataField eDataField; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdC1G2LockPayload; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdC1G2LockPayload[]; + +extern LLRP_tSC1G2LockPayload * +LLRP_C1G2LockPayload_construct (void); + +extern void +LLRP_C1G2LockPayload_destruct ( + LLRP_tSC1G2LockPayload * pThis); + +extern void +LLRP_C1G2LockPayload_decodeFields ( + LLRP_tSC1G2LockPayload * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_C1G2LockPayload_assimilateSubParameters ( + LLRP_tSC1G2LockPayload * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_C1G2LockPayload_encode ( + const LLRP_tSC1G2LockPayload *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdC1G2LockPayload_Privilege; + +extern LLRP_tEC1G2LockPrivilege +LLRP_C1G2LockPayload_getPrivilege ( + LLRP_tSC1G2LockPayload *pThis); + +extern LLRP_tResultCode +LLRP_C1G2LockPayload_setPrivilege ( + LLRP_tSC1G2LockPayload *pThis, + LLRP_tEC1G2LockPrivilege Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdC1G2LockPayload_DataField; + +extern LLRP_tEC1G2LockDataField +LLRP_C1G2LockPayload_getDataField ( + LLRP_tSC1G2LockPayload *pThis); + +extern LLRP_tResultCode +LLRP_C1G2LockPayload_setDataField ( + LLRP_tSC1G2LockPayload *pThis, + LLRP_tEC1G2LockDataField Value); + + + + + +struct LLRP_SC1G2BlockErase +{ + LLRP_tSParameter hdr; + + llrp_u16_t OpSpecID; + + llrp_u32_t AccessPassword; + + llrp_u2_t MB; + + llrp_u16_t WordPointer; + + llrp_u16_t WordCount; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdC1G2BlockErase; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdC1G2BlockErase[]; + +extern LLRP_tSC1G2BlockErase * +LLRP_C1G2BlockErase_construct (void); + +extern void +LLRP_C1G2BlockErase_destruct ( + LLRP_tSC1G2BlockErase * pThis); + +extern void +LLRP_C1G2BlockErase_decodeFields ( + LLRP_tSC1G2BlockErase * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_C1G2BlockErase_assimilateSubParameters ( + LLRP_tSC1G2BlockErase * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_C1G2BlockErase_encode ( + const LLRP_tSC1G2BlockErase *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdC1G2BlockErase_OpSpecID; + +extern llrp_u16_t +LLRP_C1G2BlockErase_getOpSpecID ( + LLRP_tSC1G2BlockErase *pThis); + +extern LLRP_tResultCode +LLRP_C1G2BlockErase_setOpSpecID ( + LLRP_tSC1G2BlockErase *pThis, + llrp_u16_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdC1G2BlockErase_AccessPassword; + +extern llrp_u32_t +LLRP_C1G2BlockErase_getAccessPassword ( + LLRP_tSC1G2BlockErase *pThis); + +extern LLRP_tResultCode +LLRP_C1G2BlockErase_setAccessPassword ( + LLRP_tSC1G2BlockErase *pThis, + llrp_u32_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdC1G2BlockErase_MB; + +extern llrp_u2_t +LLRP_C1G2BlockErase_getMB ( + LLRP_tSC1G2BlockErase *pThis); + +extern LLRP_tResultCode +LLRP_C1G2BlockErase_setMB ( + LLRP_tSC1G2BlockErase *pThis, + llrp_u2_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdC1G2BlockErase_WordPointer; + +extern llrp_u16_t +LLRP_C1G2BlockErase_getWordPointer ( + LLRP_tSC1G2BlockErase *pThis); + +extern LLRP_tResultCode +LLRP_C1G2BlockErase_setWordPointer ( + LLRP_tSC1G2BlockErase *pThis, + llrp_u16_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdC1G2BlockErase_WordCount; + +extern llrp_u16_t +LLRP_C1G2BlockErase_getWordCount ( + LLRP_tSC1G2BlockErase *pThis); + +extern LLRP_tResultCode +LLRP_C1G2BlockErase_setWordCount ( + LLRP_tSC1G2BlockErase *pThis, + llrp_u16_t Value); + + + + + +struct LLRP_SC1G2BlockWrite +{ + LLRP_tSParameter hdr; + + llrp_u16_t OpSpecID; + + llrp_u32_t AccessPassword; + + llrp_u2_t MB; + + llrp_u16_t WordPointer; + + llrp_u16v_t WriteData; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdC1G2BlockWrite; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdC1G2BlockWrite[]; + +extern LLRP_tSC1G2BlockWrite * +LLRP_C1G2BlockWrite_construct (void); + +extern void +LLRP_C1G2BlockWrite_destruct ( + LLRP_tSC1G2BlockWrite * pThis); + +extern void +LLRP_C1G2BlockWrite_decodeFields ( + LLRP_tSC1G2BlockWrite * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_C1G2BlockWrite_assimilateSubParameters ( + LLRP_tSC1G2BlockWrite * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_C1G2BlockWrite_encode ( + const LLRP_tSC1G2BlockWrite *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdC1G2BlockWrite_OpSpecID; + +extern llrp_u16_t +LLRP_C1G2BlockWrite_getOpSpecID ( + LLRP_tSC1G2BlockWrite *pThis); + +extern LLRP_tResultCode +LLRP_C1G2BlockWrite_setOpSpecID ( + LLRP_tSC1G2BlockWrite *pThis, + llrp_u16_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdC1G2BlockWrite_AccessPassword; + +extern llrp_u32_t +LLRP_C1G2BlockWrite_getAccessPassword ( + LLRP_tSC1G2BlockWrite *pThis); + +extern LLRP_tResultCode +LLRP_C1G2BlockWrite_setAccessPassword ( + LLRP_tSC1G2BlockWrite *pThis, + llrp_u32_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdC1G2BlockWrite_MB; + +extern llrp_u2_t +LLRP_C1G2BlockWrite_getMB ( + LLRP_tSC1G2BlockWrite *pThis); + +extern LLRP_tResultCode +LLRP_C1G2BlockWrite_setMB ( + LLRP_tSC1G2BlockWrite *pThis, + llrp_u2_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdC1G2BlockWrite_WordPointer; + +extern llrp_u16_t +LLRP_C1G2BlockWrite_getWordPointer ( + LLRP_tSC1G2BlockWrite *pThis); + +extern LLRP_tResultCode +LLRP_C1G2BlockWrite_setWordPointer ( + LLRP_tSC1G2BlockWrite *pThis, + llrp_u16_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdC1G2BlockWrite_WriteData; + +extern llrp_u16v_t +LLRP_C1G2BlockWrite_getWriteData ( + LLRP_tSC1G2BlockWrite *pThis); + +extern LLRP_tResultCode +LLRP_C1G2BlockWrite_setWriteData ( + LLRP_tSC1G2BlockWrite *pThis, + llrp_u16v_t Value); + + + + + +struct LLRP_SC1G2EPCMemorySelector +{ + LLRP_tSParameter hdr; + + llrp_u1_t EnableCRC; + + llrp_u1_t EnablePCBits; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdC1G2EPCMemorySelector; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdC1G2EPCMemorySelector[]; + +extern LLRP_tSC1G2EPCMemorySelector * +LLRP_C1G2EPCMemorySelector_construct (void); + +extern void +LLRP_C1G2EPCMemorySelector_destruct ( + LLRP_tSC1G2EPCMemorySelector * pThis); + +extern void +LLRP_C1G2EPCMemorySelector_decodeFields ( + LLRP_tSC1G2EPCMemorySelector * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_C1G2EPCMemorySelector_assimilateSubParameters ( + LLRP_tSC1G2EPCMemorySelector * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_C1G2EPCMemorySelector_encode ( + const LLRP_tSC1G2EPCMemorySelector *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdC1G2EPCMemorySelector_EnableCRC; + +extern llrp_u1_t +LLRP_C1G2EPCMemorySelector_getEnableCRC ( + LLRP_tSC1G2EPCMemorySelector *pThis); + +extern LLRP_tResultCode +LLRP_C1G2EPCMemorySelector_setEnableCRC ( + LLRP_tSC1G2EPCMemorySelector *pThis, + llrp_u1_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdC1G2EPCMemorySelector_EnablePCBits; + +extern llrp_u1_t +LLRP_C1G2EPCMemorySelector_getEnablePCBits ( + LLRP_tSC1G2EPCMemorySelector *pThis); + +extern LLRP_tResultCode +LLRP_C1G2EPCMemorySelector_setEnablePCBits ( + LLRP_tSC1G2EPCMemorySelector *pThis, + llrp_u1_t Value); + + + + + +struct LLRP_SC1G2_PC +{ + LLRP_tSParameter hdr; + + llrp_u16_t PC_Bits; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdC1G2_PC; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdC1G2_PC[]; + +extern LLRP_tSC1G2_PC * +LLRP_C1G2_PC_construct (void); + +extern void +LLRP_C1G2_PC_destruct ( + LLRP_tSC1G2_PC * pThis); + +extern void +LLRP_C1G2_PC_decodeFields ( + LLRP_tSC1G2_PC * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_C1G2_PC_assimilateSubParameters ( + LLRP_tSC1G2_PC * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_C1G2_PC_encode ( + const LLRP_tSC1G2_PC *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdC1G2_PC_PC_Bits; + +extern llrp_u16_t +LLRP_C1G2_PC_getPC_Bits ( + LLRP_tSC1G2_PC *pThis); + +extern LLRP_tResultCode +LLRP_C1G2_PC_setPC_Bits ( + LLRP_tSC1G2_PC *pThis, + llrp_u16_t Value); + + + + + +struct LLRP_SC1G2_CRC +{ + LLRP_tSParameter hdr; + + llrp_u16_t CRC; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdC1G2_CRC; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdC1G2_CRC[]; + +extern LLRP_tSC1G2_CRC * +LLRP_C1G2_CRC_construct (void); + +extern void +LLRP_C1G2_CRC_destruct ( + LLRP_tSC1G2_CRC * pThis); + +extern void +LLRP_C1G2_CRC_decodeFields ( + LLRP_tSC1G2_CRC * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_C1G2_CRC_assimilateSubParameters ( + LLRP_tSC1G2_CRC * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_C1G2_CRC_encode ( + const LLRP_tSC1G2_CRC *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdC1G2_CRC_CRC; + +extern llrp_u16_t +LLRP_C1G2_CRC_getCRC ( + LLRP_tSC1G2_CRC *pThis); + +extern LLRP_tResultCode +LLRP_C1G2_CRC_setCRC ( + LLRP_tSC1G2_CRC *pThis, + llrp_u16_t Value); + + + + + +struct LLRP_SC1G2SingulationDetails +{ + LLRP_tSParameter hdr; + + llrp_u16_t NumCollisionSlots; + + llrp_u16_t NumEmptySlots; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdC1G2SingulationDetails; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdC1G2SingulationDetails[]; + +extern LLRP_tSC1G2SingulationDetails * +LLRP_C1G2SingulationDetails_construct (void); + +extern void +LLRP_C1G2SingulationDetails_destruct ( + LLRP_tSC1G2SingulationDetails * pThis); + +extern void +LLRP_C1G2SingulationDetails_decodeFields ( + LLRP_tSC1G2SingulationDetails * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_C1G2SingulationDetails_assimilateSubParameters ( + LLRP_tSC1G2SingulationDetails * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_C1G2SingulationDetails_encode ( + const LLRP_tSC1G2SingulationDetails *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdC1G2SingulationDetails_NumCollisionSlots; + +extern llrp_u16_t +LLRP_C1G2SingulationDetails_getNumCollisionSlots ( + LLRP_tSC1G2SingulationDetails *pThis); + +extern LLRP_tResultCode +LLRP_C1G2SingulationDetails_setNumCollisionSlots ( + LLRP_tSC1G2SingulationDetails *pThis, + llrp_u16_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdC1G2SingulationDetails_NumEmptySlots; + +extern llrp_u16_t +LLRP_C1G2SingulationDetails_getNumEmptySlots ( + LLRP_tSC1G2SingulationDetails *pThis); + +extern LLRP_tResultCode +LLRP_C1G2SingulationDetails_setNumEmptySlots ( + LLRP_tSC1G2SingulationDetails *pThis, + llrp_u16_t Value); + + + + + +struct LLRP_SC1G2ReadOpSpecResult +{ + LLRP_tSParameter hdr; + + LLRP_tEC1G2ReadResultType eResult; + + llrp_u16_t OpSpecID; + + llrp_u16v_t ReadData; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdC1G2ReadOpSpecResult; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdC1G2ReadOpSpecResult[]; + +extern LLRP_tSC1G2ReadOpSpecResult * +LLRP_C1G2ReadOpSpecResult_construct (void); + +extern void +LLRP_C1G2ReadOpSpecResult_destruct ( + LLRP_tSC1G2ReadOpSpecResult * pThis); + +extern void +LLRP_C1G2ReadOpSpecResult_decodeFields ( + LLRP_tSC1G2ReadOpSpecResult * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_C1G2ReadOpSpecResult_assimilateSubParameters ( + LLRP_tSC1G2ReadOpSpecResult * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_C1G2ReadOpSpecResult_encode ( + const LLRP_tSC1G2ReadOpSpecResult *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdC1G2ReadOpSpecResult_Result; + +extern LLRP_tEC1G2ReadResultType +LLRP_C1G2ReadOpSpecResult_getResult ( + LLRP_tSC1G2ReadOpSpecResult *pThis); + +extern LLRP_tResultCode +LLRP_C1G2ReadOpSpecResult_setResult ( + LLRP_tSC1G2ReadOpSpecResult *pThis, + LLRP_tEC1G2ReadResultType Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdC1G2ReadOpSpecResult_OpSpecID; + +extern llrp_u16_t +LLRP_C1G2ReadOpSpecResult_getOpSpecID ( + LLRP_tSC1G2ReadOpSpecResult *pThis); + +extern LLRP_tResultCode +LLRP_C1G2ReadOpSpecResult_setOpSpecID ( + LLRP_tSC1G2ReadOpSpecResult *pThis, + llrp_u16_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdC1G2ReadOpSpecResult_ReadData; + +extern llrp_u16v_t +LLRP_C1G2ReadOpSpecResult_getReadData ( + LLRP_tSC1G2ReadOpSpecResult *pThis); + +extern LLRP_tResultCode +LLRP_C1G2ReadOpSpecResult_setReadData ( + LLRP_tSC1G2ReadOpSpecResult *pThis, + llrp_u16v_t Value); + + + + + +struct LLRP_SC1G2WriteOpSpecResult +{ + LLRP_tSParameter hdr; + + LLRP_tEC1G2WriteResultType eResult; + + llrp_u16_t OpSpecID; + + llrp_u16_t NumWordsWritten; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdC1G2WriteOpSpecResult; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdC1G2WriteOpSpecResult[]; + +extern LLRP_tSC1G2WriteOpSpecResult * +LLRP_C1G2WriteOpSpecResult_construct (void); + +extern void +LLRP_C1G2WriteOpSpecResult_destruct ( + LLRP_tSC1G2WriteOpSpecResult * pThis); + +extern void +LLRP_C1G2WriteOpSpecResult_decodeFields ( + LLRP_tSC1G2WriteOpSpecResult * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_C1G2WriteOpSpecResult_assimilateSubParameters ( + LLRP_tSC1G2WriteOpSpecResult * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_C1G2WriteOpSpecResult_encode ( + const LLRP_tSC1G2WriteOpSpecResult *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdC1G2WriteOpSpecResult_Result; + +extern LLRP_tEC1G2WriteResultType +LLRP_C1G2WriteOpSpecResult_getResult ( + LLRP_tSC1G2WriteOpSpecResult *pThis); + +extern LLRP_tResultCode +LLRP_C1G2WriteOpSpecResult_setResult ( + LLRP_tSC1G2WriteOpSpecResult *pThis, + LLRP_tEC1G2WriteResultType Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdC1G2WriteOpSpecResult_OpSpecID; + +extern llrp_u16_t +LLRP_C1G2WriteOpSpecResult_getOpSpecID ( + LLRP_tSC1G2WriteOpSpecResult *pThis); + +extern LLRP_tResultCode +LLRP_C1G2WriteOpSpecResult_setOpSpecID ( + LLRP_tSC1G2WriteOpSpecResult *pThis, + llrp_u16_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdC1G2WriteOpSpecResult_NumWordsWritten; + +extern llrp_u16_t +LLRP_C1G2WriteOpSpecResult_getNumWordsWritten ( + LLRP_tSC1G2WriteOpSpecResult *pThis); + +extern LLRP_tResultCode +LLRP_C1G2WriteOpSpecResult_setNumWordsWritten ( + LLRP_tSC1G2WriteOpSpecResult *pThis, + llrp_u16_t Value); + + + + + +struct LLRP_SC1G2KillOpSpecResult +{ + LLRP_tSParameter hdr; + + LLRP_tEC1G2KillResultType eResult; + + llrp_u16_t OpSpecID; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdC1G2KillOpSpecResult; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdC1G2KillOpSpecResult[]; + +extern LLRP_tSC1G2KillOpSpecResult * +LLRP_C1G2KillOpSpecResult_construct (void); + +extern void +LLRP_C1G2KillOpSpecResult_destruct ( + LLRP_tSC1G2KillOpSpecResult * pThis); + +extern void +LLRP_C1G2KillOpSpecResult_decodeFields ( + LLRP_tSC1G2KillOpSpecResult * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_C1G2KillOpSpecResult_assimilateSubParameters ( + LLRP_tSC1G2KillOpSpecResult * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_C1G2KillOpSpecResult_encode ( + const LLRP_tSC1G2KillOpSpecResult *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdC1G2KillOpSpecResult_Result; + +extern LLRP_tEC1G2KillResultType +LLRP_C1G2KillOpSpecResult_getResult ( + LLRP_tSC1G2KillOpSpecResult *pThis); + +extern LLRP_tResultCode +LLRP_C1G2KillOpSpecResult_setResult ( + LLRP_tSC1G2KillOpSpecResult *pThis, + LLRP_tEC1G2KillResultType Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdC1G2KillOpSpecResult_OpSpecID; + +extern llrp_u16_t +LLRP_C1G2KillOpSpecResult_getOpSpecID ( + LLRP_tSC1G2KillOpSpecResult *pThis); + +extern LLRP_tResultCode +LLRP_C1G2KillOpSpecResult_setOpSpecID ( + LLRP_tSC1G2KillOpSpecResult *pThis, + llrp_u16_t Value); + + + + + +struct LLRP_SC1G2LockOpSpecResult +{ + LLRP_tSParameter hdr; + + LLRP_tEC1G2LockResultType eResult; + + llrp_u16_t OpSpecID; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdC1G2LockOpSpecResult; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdC1G2LockOpSpecResult[]; + +extern LLRP_tSC1G2LockOpSpecResult * +LLRP_C1G2LockOpSpecResult_construct (void); + +extern void +LLRP_C1G2LockOpSpecResult_destruct ( + LLRP_tSC1G2LockOpSpecResult * pThis); + +extern void +LLRP_C1G2LockOpSpecResult_decodeFields ( + LLRP_tSC1G2LockOpSpecResult * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_C1G2LockOpSpecResult_assimilateSubParameters ( + LLRP_tSC1G2LockOpSpecResult * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_C1G2LockOpSpecResult_encode ( + const LLRP_tSC1G2LockOpSpecResult *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdC1G2LockOpSpecResult_Result; + +extern LLRP_tEC1G2LockResultType +LLRP_C1G2LockOpSpecResult_getResult ( + LLRP_tSC1G2LockOpSpecResult *pThis); + +extern LLRP_tResultCode +LLRP_C1G2LockOpSpecResult_setResult ( + LLRP_tSC1G2LockOpSpecResult *pThis, + LLRP_tEC1G2LockResultType Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdC1G2LockOpSpecResult_OpSpecID; + +extern llrp_u16_t +LLRP_C1G2LockOpSpecResult_getOpSpecID ( + LLRP_tSC1G2LockOpSpecResult *pThis); + +extern LLRP_tResultCode +LLRP_C1G2LockOpSpecResult_setOpSpecID ( + LLRP_tSC1G2LockOpSpecResult *pThis, + llrp_u16_t Value); + + + + + +struct LLRP_SC1G2BlockEraseOpSpecResult +{ + LLRP_tSParameter hdr; + + LLRP_tEC1G2BlockEraseResultType eResult; + + llrp_u16_t OpSpecID; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdC1G2BlockEraseOpSpecResult; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdC1G2BlockEraseOpSpecResult[]; + +extern LLRP_tSC1G2BlockEraseOpSpecResult * +LLRP_C1G2BlockEraseOpSpecResult_construct (void); + +extern void +LLRP_C1G2BlockEraseOpSpecResult_destruct ( + LLRP_tSC1G2BlockEraseOpSpecResult * pThis); + +extern void +LLRP_C1G2BlockEraseOpSpecResult_decodeFields ( + LLRP_tSC1G2BlockEraseOpSpecResult * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_C1G2BlockEraseOpSpecResult_assimilateSubParameters ( + LLRP_tSC1G2BlockEraseOpSpecResult * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_C1G2BlockEraseOpSpecResult_encode ( + const LLRP_tSC1G2BlockEraseOpSpecResult *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdC1G2BlockEraseOpSpecResult_Result; + +extern LLRP_tEC1G2BlockEraseResultType +LLRP_C1G2BlockEraseOpSpecResult_getResult ( + LLRP_tSC1G2BlockEraseOpSpecResult *pThis); + +extern LLRP_tResultCode +LLRP_C1G2BlockEraseOpSpecResult_setResult ( + LLRP_tSC1G2BlockEraseOpSpecResult *pThis, + LLRP_tEC1G2BlockEraseResultType Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdC1G2BlockEraseOpSpecResult_OpSpecID; + +extern llrp_u16_t +LLRP_C1G2BlockEraseOpSpecResult_getOpSpecID ( + LLRP_tSC1G2BlockEraseOpSpecResult *pThis); + +extern LLRP_tResultCode +LLRP_C1G2BlockEraseOpSpecResult_setOpSpecID ( + LLRP_tSC1G2BlockEraseOpSpecResult *pThis, + llrp_u16_t Value); + + + + + +struct LLRP_SC1G2BlockWriteOpSpecResult +{ + LLRP_tSParameter hdr; + + LLRP_tEC1G2BlockWriteResultType eResult; + + llrp_u16_t OpSpecID; + + llrp_u16_t NumWordsWritten; + + +}; + +extern const LLRP_tSTypeDescriptor +LLRP_tdC1G2BlockWriteOpSpecResult; + +extern const LLRP_tSFieldDescriptor * +LLRP_apfdC1G2BlockWriteOpSpecResult[]; + +extern LLRP_tSC1G2BlockWriteOpSpecResult * +LLRP_C1G2BlockWriteOpSpecResult_construct (void); + +extern void +LLRP_C1G2BlockWriteOpSpecResult_destruct ( + LLRP_tSC1G2BlockWriteOpSpecResult * pThis); + +extern void +LLRP_C1G2BlockWriteOpSpecResult_decodeFields ( + LLRP_tSC1G2BlockWriteOpSpecResult * pThis, + LLRP_tSDecoderStream * pDecoderStream); + +extern void +LLRP_C1G2BlockWriteOpSpecResult_assimilateSubParameters ( + LLRP_tSC1G2BlockWriteOpSpecResult * pThis, + LLRP_tSErrorDetails * pError); + +extern void +LLRP_C1G2BlockWriteOpSpecResult_encode ( + const LLRP_tSC1G2BlockWriteOpSpecResult *pThis, + LLRP_tSEncoderStream * pEncoderStream); + + + + +extern const LLRP_tSFieldDescriptor +LLRP_fdC1G2BlockWriteOpSpecResult_Result; + +extern LLRP_tEC1G2BlockWriteResultType +LLRP_C1G2BlockWriteOpSpecResult_getResult ( + LLRP_tSC1G2BlockWriteOpSpecResult *pThis); + +extern LLRP_tResultCode +LLRP_C1G2BlockWriteOpSpecResult_setResult ( + LLRP_tSC1G2BlockWriteOpSpecResult *pThis, + LLRP_tEC1G2BlockWriteResultType Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdC1G2BlockWriteOpSpecResult_OpSpecID; + +extern llrp_u16_t +LLRP_C1G2BlockWriteOpSpecResult_getOpSpecID ( + LLRP_tSC1G2BlockWriteOpSpecResult *pThis); + +extern LLRP_tResultCode +LLRP_C1G2BlockWriteOpSpecResult_setOpSpecID ( + LLRP_tSC1G2BlockWriteOpSpecResult *pThis, + llrp_u16_t Value); + +extern const LLRP_tSFieldDescriptor +LLRP_fdC1G2BlockWriteOpSpecResult_NumWordsWritten; + +extern llrp_u16_t +LLRP_C1G2BlockWriteOpSpecResult_getNumWordsWritten ( + LLRP_tSC1G2BlockWriteOpSpecResult *pThis); + +extern LLRP_tResultCode +LLRP_C1G2BlockWriteOpSpecResult_setNumWordsWritten ( + LLRP_tSC1G2BlockWriteOpSpecResult *pThis, + llrp_u16_t Value); + + + + + +extern llrp_bool_t +LLRP_SpecParameter_isMember ( + LLRP_tSParameter * pParameter); + +extern const LLRP_tSTypeDescriptor +LLRP_tdSpecParameter; + + +extern llrp_bool_t +LLRP_AccessCommandOpSpec_isMember ( + LLRP_tSParameter * pParameter); + +extern const LLRP_tSTypeDescriptor +LLRP_tdAccessCommandOpSpec; + + +extern llrp_bool_t +LLRP_AccessCommandOpSpecResult_isMember ( + LLRP_tSParameter * pParameter); + +extern const LLRP_tSTypeDescriptor +LLRP_tdAccessCommandOpSpecResult; + + +extern llrp_bool_t +LLRP_EPCParameter_isMember ( + LLRP_tSParameter * pParameter); + +extern const LLRP_tSTypeDescriptor +LLRP_tdEPCParameter; + + +extern llrp_bool_t +LLRP_Timestamp_isMember ( + LLRP_tSParameter * pParameter); + +extern const LLRP_tSTypeDescriptor +LLRP_tdTimestamp; + + +extern llrp_bool_t +LLRP_C1G2OpSpec_isMember ( + LLRP_tSParameter * pParameter); + +extern const LLRP_tSTypeDescriptor +LLRP_tdC1G2OpSpec; + + +extern llrp_bool_t +LLRP_AirProtocolLLRPCapabilities_isMember ( + LLRP_tSParameter * pParameter); + +extern const LLRP_tSTypeDescriptor +LLRP_tdAirProtocolLLRPCapabilities; + + +extern llrp_bool_t +LLRP_AirProtocolUHFRFModeTable_isMember ( + LLRP_tSParameter * pParameter); + +extern const LLRP_tSTypeDescriptor +LLRP_tdAirProtocolUHFRFModeTable; + + +extern llrp_bool_t +LLRP_AirProtocolInventoryCommandSettings_isMember ( + LLRP_tSParameter * pParameter); + +extern const LLRP_tSTypeDescriptor +LLRP_tdAirProtocolInventoryCommandSettings; + + +extern llrp_bool_t +LLRP_AirProtocolTagSpec_isMember ( + LLRP_tSParameter * pParameter); + +extern const LLRP_tSTypeDescriptor +LLRP_tdAirProtocolTagSpec; + + +extern llrp_bool_t +LLRP_AirProtocolOpSpec_isMember ( + LLRP_tSParameter * pParameter); + +extern const LLRP_tSTypeDescriptor +LLRP_tdAirProtocolOpSpec; + + +extern llrp_bool_t +LLRP_AirProtocolEPCMemorySelector_isMember ( + LLRP_tSParameter * pParameter); + +extern const LLRP_tSTypeDescriptor +LLRP_tdAirProtocolEPCMemorySelector; + + +extern llrp_bool_t +LLRP_AirProtocolTagData_isMember ( + LLRP_tSParameter * pParameter); + +extern const LLRP_tSTypeDescriptor +LLRP_tdAirProtocolTagData; + + +extern llrp_bool_t +LLRP_AirProtocolSingulationDetails_isMember ( + LLRP_tSParameter * pParameter); + +extern const LLRP_tSTypeDescriptor +LLRP_tdAirProtocolSingulationDetails; + + +void +LLRP_enrollCoreTypesIntoRegistry ( + LLRP_tSTypeRegistry * pTypeRegistry); + diff --git a/vendor/libltkc/version.inc b/vendor/libltkc/version.inc new file mode 100644 index 0000000..c4bdd65 --- /dev/null +++ b/vendor/libltkc/version.inc @@ -0,0 +1 @@ +#define VERSION_STR 12.2.0.0 diff --git a/vendor/libltkc/xml2llrp b/vendor/libltkc/xml2llrp new file mode 100755 index 0000000..f68de25 Binary files /dev/null and b/vendor/libltkc/xml2llrp differ