dx201.cpp

Go to the documentation of this file.

/*
 ***************************************************************************
 *  Copyright 2007,2008 Impinj, Inc.
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 ***************************************************************************
 */

#include <stdio.h>
#ifdef linux
#include <unistd.h>
#endif

#include "ltkcpp.h"

using namespace LLRP;


class CMyApplication
{
  public:
    int                         m_Verbose;

    int                         m_ModeIndex;
    int                         m_Quiet;
    int                         m_nTagReport;

    CConnection *               m_pConnectionToReader;

    inline
    CMyApplication (void)
     : m_Verbose(0), m_ModeIndex(-1), m_Quiet(0),
       m_nTagReport(0), m_pConnectionToReader(NULL)
    {}

    int
    run (
      char *                    pReaderHostName);

    int
    checkConnectionStatus (void);

    int
    scrubConfiguration (void);

    int
    resetConfigurationToFactoryDefaults (void);

    int
    deleteAllROSpecs (void);

    int
    deleteAllAccessSpecs (void);

    int
    prepareReader(void);

    int
    getAllCapabilities (void);

    int
    getAllConfiguration (void);

    int
    configureNotificationStates (void);

    int
    addROSpec (void);

    int
    enableROSpec (void);

    int
    startAndMonitorOperation (void);

    void
    printTagReportData (
      CRO_ACCESS_REPORT *       pRO_ACCESS_REPORT);

    void
    printOneTagReportData (
      CTagReportData *          pTagReportData);

    int
    checkLLRPStatus (
      CLLRPStatus *             pLLRPStatus,
      char *                    pWhatStr);

    CMessage *
    transact (
      CMessage *                pSendMsg);

    CMessage *
    recvMessage (
      int                       nMaxMS);

    int
    sendMessage (
      CMessage *                pSendMsg);

    void
    printXMLMessage (
      CMessage *                pMessage);
};


/* BEGIN forward declarations */
int
main (
  int                           ac,
  char *                        av[]);

void
usage (
  char *                        pProgName);
/* END forward declarations */


int
main (
  int                           ac,
  char *                        av[])
{
    CMyApplication              myApp;
    char *                      pReaderHostName;
    int                         rc;
#ifdef linux
    char *                      pMemHiwatAtStart = (char*)sbrk(0);
#endif

    /*
     * 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':
                myApp.m_Verbose++;
                break;

            case 'q':
            case 'Q':
                myApp.m_Quiet++;
                break;

            case '0': case '1': case '2': case '3': case '4': case '5':
                myApp.m_ModeIndex = p[-1] - '0';
                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 = myApp.run(pReaderHostName);

    printf("INFO: Done\n");

#ifdef linux
    {
        char *              pMemHiwatAtEnd = (char*)sbrk(0);

        printf("INFO: Needed %d bytes of heap\n",
            pMemHiwatAtEnd - pMemHiwatAtStart);
    }
#endif

    /*
     * Exit with the right status.
     */
    if(0 == rc)
    {
        exit(0);
    }
    else
    {
        exit(2);
    }
    /*NOTREACHED*/
}


void
usage (
  char *                        pProgName)
{
#ifdef linux
    printf("Usage: %s [-v[v]] READERHOSTNAME\n", pProgName);
    printf("\n");
    printf("Each -v increases verbosity level\n");
#endif /* linux */
#ifdef WIN32
    printf("Usage: %s [/v[v]] READERHOSTNAME\n", pProgName);
    printf("\n");
    printf("Each /v increases verbosity level\n");
#endif /* WIN32 */
    exit(1);
}


int
CMyApplication::run (
  char *                        pReaderHostName)
{
    CTypeRegistry *             pTypeRegistry;
    CConnection *               pConn;
    int                         rc;

    /*
     * Allocate the type registry. This is needed
     * by the connection to decode.
     */
    pTypeRegistry = getTheTypeRegistry();
    if(NULL == pTypeRegistry)
    {
        printf("ERROR: getTheTypeRegistry failed\n");
        return -1;
    }

    /*
     * Construct a connection (LLRP::CConnection).
     * 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 = new CConnection(pTypeRegistry, 32u*1024u);
    if(NULL == pConn)
    {
        printf("ERROR: new CConnection failed\n");
        return -2;
    }

    /*
     * Open the connection to the reader
     */
    if(m_Verbose)
    {
        printf ("INFO: Connecting to %s....\n", pReaderHostName);
    }

    rc = pConn->openConnectionToReader(pReaderHostName);
    if(0 != rc)
    {
        printf("ERROR: connect: %s (%d)\n", pConn->getConnectError(), rc);
        delete pConn;
        return -3;
    }

    /*
     * Record the pointer to the connection object so other
     * routines can use it.
     */
    m_pConnectionToReader = pConn;

    if(m_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 == prepareReader())
            {
                rc = 4;
                if(0 == startAndMonitorOperation())
                {
                    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(m_Verbose)
            {
                printf("INFO: Clean up reader configuration...\n");
            }
            scrubConfiguration();
        }
    }

    if(m_Verbose)
    {
        printf ("INFO: Finished\n");
    }

    /*
     * Close the connection and release its resources
     */
    pConn->closeConnectionToReader();
    delete pConn;

    /*
     * Done with the registry.
     */
    delete pTypeRegistry;

    /*
     * Maybe tattle on the number of tags. Normally tags are reported.
     * The -q command option prevents that and instead asks for just a
     * total. With the -v command option we're probably reporting tags
     * and a final count.
     */
    if(m_Verbose || m_Quiet)
    {
        printf("INFO: %d Tag reports\n", m_nTagReport);
    }

    /*
     * When we get here all allocated memory should have been deallocated.
     */

    return rc;
}


int
CMyApplication::checkConnectionStatus (void)
{
    CMessage *                  pMessage;
    CREADER_EVENT_NOTIFICATION *pNtf;
    CReaderEventNotificationData *pNtfData;
    CConnectionAttemptEvent *   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(&CREADER_EVENT_NOTIFICATION::s_typeDescriptor != pMessage->m_pType)
    {
        goto fail;
    }

    /*
     * Now that we are sure it is a READER_EVENT_NOTIFICATION,
     * traverse to the ReaderEventNotificationData parameter.
     */
    pNtf = (CREADER_EVENT_NOTIFICATION *) pMessage;
    pNtfData = pNtf->getReaderEventNotificationData();
    if(NULL == pNtfData)
    {
        goto fail;
    }

    /*
     * The ConnectionAttemptEvent parameter must be present.
     */
    pEvent = pNtfData->getConnectionAttemptEvent();
    if(NULL == pEvent)
    {
        goto fail;
    }

    /*
     * The status in the ConnectionAttemptEvent parameter
     * must indicate connection success.
     */
    if(ConnectionAttemptStatusType_Success != pEvent->getStatus())
    {
        goto fail;
    }

    /*
     * Done with the message
     */
    delete pMessage;

    if(m_Verbose)
    {
        printf("INFO: Connection status OK\n");
    }

    /*
     * Victory.
     */
    return 0;

  fail:
    /*
     * Something went wrong. Tattle. Clean up. Return error.
     */
    printf("ERROR: checkConnectionStatus failed\n");
    delete pMessage;
    return -1;
}


int
CMyApplication::scrubConfiguration (void)
{
    if(0 != resetConfigurationToFactoryDefaults())
    {
        return -1;
    }

    if(0 != deleteAllROSpecs())
    {
        return -2;
    }

    if(0 != deleteAllAccessSpecs())
    {
        return -3;
    }

    return 0;
}


int
CMyApplication::resetConfigurationToFactoryDefaults (void)
{
    CSET_READER_CONFIG *        pCmd;
    CMessage *                  pRspMsg;
    CSET_READER_CONFIG_RESPONSE *pRsp;

    /*
     * Compose the command message
     */
    pCmd = new CSET_READER_CONFIG();
    pCmd->setMessageID(101);
    pCmd->setResetToFactoryDefault(1);

    /*
     * Send the message, expect the response of certain type
     */
    pRspMsg = transact(pCmd);

    /*
     * Done with the command message
     */
    delete pCmd;

    /*
     * transact() returns NULL if something went wrong.
     */
    if(NULL == pRspMsg)
    {
        /* transact already tattled */
        return -1;
    }

    /*
     * Cast to a SET_READER_CONFIG_RESPONSE message.
     */
    pRsp = (CSET_READER_CONFIG_RESPONSE *) pRspMsg;

    /*
     * Check the LLRPStatus parameter.
     */
    if(0 != checkLLRPStatus(pRsp->getLLRPStatus(),
                        "resetConfigurationToFactoryDefaults"))
    {
        /* checkLLRPStatus already tattled */
        delete pRspMsg;
        return -1;
    }

    /*
     * Done with the response message.
     */
    delete pRspMsg;

    /*
     * Tattle progress, maybe
     */
    if(m_Verbose)
    {
        printf("INFO: Configuration reset to factory defaults\n");
    }

    /*
     * Victory.
     */
    return 0;
}


int
CMyApplication::deleteAllROSpecs (void)
{
    CDELETE_ROSPEC *            pCmd;
    CMessage *                  pRspMsg;
    CDELETE_ROSPEC_RESPONSE *   pRsp;

    /*
     * Compose the command message
     */
    pCmd = new CDELETE_ROSPEC();
    pCmd->setMessageID(102);
    pCmd->setROSpecID(0);               /* All */

    /*
     * Send the message, expect the response of certain type
     */
    pRspMsg = transact(pCmd);

    /*
     * Done with the command message
     */
    delete pCmd;

    /*
     * transact() returns NULL if something went wrong.
     */
    if(NULL == pRspMsg)
    {
        /* transact already tattled */
        return -1;
    }

    /*
     * Cast to a DELETE_ROSPEC_RESPONSE message.
     */
    pRsp = (CDELETE_ROSPEC_RESPONSE *) pRspMsg;

    /*
     * Check the LLRPStatus parameter.
     */
    if(0 != checkLLRPStatus(pRsp->getLLRPStatus(), "deleteAllROSpecs"))
    {
        /* checkLLRPStatus already tattled */
        delete pRspMsg;
        return -1;
    }

    /*
     * Done with the response message.
     */
    delete pRspMsg;

    /*
     * Tattle progress, maybe
     */
    if(m_Verbose)
    {
        printf("INFO: All ROSpecs are deleted\n");
    }

    /*
     * Victory.
     */
    return 0;
}


int
CMyApplication::deleteAllAccessSpecs (void)
{
    CDELETE_ACCESSSPEC *        pCmd;
    CMessage *                  pRspMsg;
    CDELETE_ACCESSSPEC_RESPONSE *pRsp;

    /*
     * Compose the command message
     */
    pCmd = new CDELETE_ACCESSSPEC();
    pCmd->setMessageID(103);
    pCmd->setAccessSpecID(0);           /* All */

    /*
     * Send the message, expect the response of certain type
     */
    pRspMsg = transact(pCmd);

    /*
     * Done with the command message
     */
    delete pCmd;

    /*
     * transact() returns NULL if something went wrong.
     */
    if(NULL == pRspMsg)
    {
        /* transact already tattled */
        return -1;
    }

    /*
     * Cast to a DELETE_ACCESSSPEC_RESPONSE message.
     */
    pRsp = (CDELETE_ACCESSSPEC_RESPONSE *) pRspMsg;

    /*
     * Check the LLRPStatus parameter.
     */
    if(0 != checkLLRPStatus(pRsp->getLLRPStatus(), "deleteAllAccessSpecs"))
    {
        /* checkLLRPStatus already tattled */
        delete pRspMsg;
        return -1;
    }

    /*
     * Done with the response message.
     */
    delete pRspMsg;

    /*
     * Tattle progress, maybe
     */
    if(m_Verbose)
    {
        printf("INFO: All AccessSpecs are deleted\n");
    }

    /*
     * Victory.
     */
    return 0;
}


int
CMyApplication::prepareReader(void)
{
    if(0 != getAllCapabilities())
    {
        return -1;
    }

    if(0 != getAllConfiguration())
    {
        return -2;
    }

    if(0 != configureNotificationStates())
    {
        return -3;
    }

    if(0 != getAllConfiguration())
    {
        return -4;
    }

    if(0 != addROSpec())
    {
        return -5;
    }

    if(0 != enableROSpec())
    {
        return -6;
    }

    return 0;
}


int
CMyApplication::getAllCapabilities (void)
{
    CGET_READER_CAPABILITIES *  pCmd;
    CMessage *                  pRspMsg;
    CGET_READER_CAPABILITIES_RESPONSE *pRsp;

    /*
     * Compose the command message
     */
    pCmd = new CGET_READER_CAPABILITIES();
    pCmd->setMessageID(120);
    pCmd->setRequestedData(GetReaderCapabilitiesRequestedData_All);

    /*
     * Send the message, expect the response of certain type
     */
    pRspMsg = transact(pCmd);

    /*
     * Done with the command message
     */
    delete pCmd;

    /*
     * transact() returns NULL if something went wrong.
     */
    if(NULL == pRspMsg)
    {
        /* transact already tattled */
        return -1;
    }

    /*
     * Cast to a GET_READER_CAPABILITIES_RESPONSE message.
     */
    pRsp = (CGET_READER_CAPABILITIES_RESPONSE *) pRspMsg;

    /*
     * Check the LLRPStatus parameter.
     */
    if(0 != checkLLRPStatus(pRsp->getLLRPStatus(), "getAllCapabilities"))
    {
        /* checkLLRPStatus already tattled */
        delete pRspMsg;
        return -1;
    }

    /*
     * Done with the response message.
     */
    delete pRspMsg;

    /*
     * Tattle progress, maybe
     */
    if(m_Verbose)
    {
        printf("INFO: Got capabilities\n");
    }

    /*
     * Victory.
     */
    return 0;
}


int
CMyApplication::getAllConfiguration (void)
{
    CGET_READER_CONFIG *        pCmd;
    CMessage *                  pRspMsg;
    CGET_READER_CONFIG_RESPONSE *pRsp;

    /*
     * Compose the command message
     */
    pCmd = new CGET_READER_CONFIG();
    pCmd->setMessageID(121);
    pCmd->setRequestedData(GetReaderConfigRequestedData_All);

    /*
     * Send the message, expect the response of certain type
     */
    pRspMsg = transact(pCmd);

    /*
     * Done with the command message
     */
    delete pCmd;

    /*
     * transact() returns NULL if something went wrong.
     */
    if(NULL == pRspMsg)
    {
        /* transact already tattled */
        return -1;
    }

    /*
     * Cast to a GET_READER_CONFIG_RESPONSE message.
     */
    pRsp = (CGET_READER_CONFIG_RESPONSE *) pRspMsg;

    /*
     * Check the LLRPStatus parameter.
     */
    if(0 != checkLLRPStatus(pRsp->getLLRPStatus(), "getAllConfiguration"))
    {
        /* checkLLRPStatus already tattled */
        delete pRspMsg;
        return -1;
    }

    /*
     * Done with the response message.
     */
    delete pRspMsg;

    /*
     * Tattle progress, maybe
     */
    if(m_Verbose)
    {
        printf("INFO: Got configuration\n");
    }

    /*
     * Victory.
     */
    return 0;
}


int
CMyApplication::configureNotificationStates (void)
{
    CEventNotificationState *   pENHop = new CEventNotificationState();
    pENHop->setEventType(NotificationEventType_Upon_Hopping_To_Next_Channel);
    pENHop->setNotificationState(TRUE);

    CEventNotificationState *   pENGPI = new CEventNotificationState();
    pENGPI->setEventType(NotificationEventType_GPI_Event);
    pENGPI->setNotificationState(FALSE);

    CEventNotificationState *   pENROSpec = new CEventNotificationState();
    pENROSpec->setEventType(NotificationEventType_ROSpec_Event);
    pENROSpec->setNotificationState(TRUE);

    CEventNotificationState *   pENBufWarn = new CEventNotificationState();
    pENBufWarn->setEventType(NotificationEventType_Report_Buffer_Fill_Warning);
    pENBufWarn->setNotificationState(TRUE);

    CEventNotificationState *   pENExcept = new CEventNotificationState();
    pENExcept->setEventType(NotificationEventType_Reader_Exception_Event);
    pENExcept->setNotificationState(TRUE);

    CEventNotificationState *   pENSurvey = new CEventNotificationState();
    pENSurvey->setEventType(NotificationEventType_RFSurvey_Event);
    pENSurvey->setNotificationState(FALSE);

    CEventNotificationState *   pENAISpec = new CEventNotificationState();
    pENAISpec->setEventType(NotificationEventType_AISpec_Event);
    pENAISpec->setNotificationState(TRUE);

    CEventNotificationState *   pENAISpecDetails
                                    = new CEventNotificationState();
    pENAISpecDetails->setEventType(
            NotificationEventType_AISpec_Event_With_Details);
    pENAISpecDetails->setNotificationState(FALSE);

    CEventNotificationState *   pENAnt = new CEventNotificationState();
    pENAnt->setEventType(NotificationEventType_Antenna_Event);
    pENAnt->setNotificationState(TRUE);

    CReaderEventNotificationSpec * pReaderEventNotificationSpec;

    pReaderEventNotificationSpec = new CReaderEventNotificationSpec;

    pReaderEventNotificationSpec->addEventNotificationState(pENHop);
    pReaderEventNotificationSpec->addEventNotificationState(pENGPI);
    pReaderEventNotificationSpec->addEventNotificationState(pENROSpec);
    pReaderEventNotificationSpec->addEventNotificationState(pENBufWarn);
    pReaderEventNotificationSpec->addEventNotificationState(pENExcept);
    pReaderEventNotificationSpec->addEventNotificationState(pENSurvey);
    pReaderEventNotificationSpec->addEventNotificationState(pENAISpec);
    pReaderEventNotificationSpec->addEventNotificationState(
                pENAISpecDetails);
    pReaderEventNotificationSpec->addEventNotificationState(pENAnt);

    CSET_READER_CONFIG *        pCmd;
    CMessage *                  pRspMsg;
    CSET_READER_CONFIG_RESPONSE *pRsp;

    /*
     * Compose the command message.
     * N.B.: After the message is composed, all the parameters
     *       constructed, immediately above, are considered "owned"
     *       by the command message. When it is destructed so
     *       too will the parameters be.
     */
    pCmd = new CSET_READER_CONFIG();
    pCmd->setMessageID(150);
    pCmd->setReaderEventNotificationSpec(pReaderEventNotificationSpec);

    /*
     * Send the message, expect the response of certain type
     */
    pRspMsg = transact(pCmd);

    /*
     * Done with the command message.
     * N.B.: And the parameters
     */
    delete pCmd;

    /*
     * transact() returns NULL if something went wrong.
     */
    if(NULL == pRspMsg)
    {
        /* transact already tattled */
        return -1;
    }

    /*
     * Cast to a SET_READER_CONFIG_RESPONSE message.
     */
    pRsp = (CSET_READER_CONFIG_RESPONSE *) pRspMsg;

    /*
     * Check the LLRPStatus parameter.
     */
    if(0 != checkLLRPStatus(pRsp->getLLRPStatus(),
                    "configureNotificationStates"))
    {
        delete pRspMsg;
        return -1;
    }

    /*
     * Done with the response message.
     */
    delete pRspMsg;

    /*
     * Tattle progress, maybe
     */
    if(m_Verbose)
    {
        printf("INFO: Notifications are configured\n");
    }

    /*
     * Victory.
     */
    return 0;
}


int
CMyApplication::addROSpec (void)
{
    CROSpecStartTrigger *       pROSpecStartTrigger =
                                    new CROSpecStartTrigger();
    pROSpecStartTrigger->setROSpecStartTriggerType(
                                ROSpecStartTriggerType_Null);

    CROSpecStopTrigger *        pROSpecStopTrigger = new CROSpecStopTrigger();
    pROSpecStopTrigger->setROSpecStopTriggerType(ROSpecStopTriggerType_Null);
    pROSpecStopTrigger->setDurationTriggerValue(0);     /* n/a */

    CROBoundarySpec *           pROBoundarySpec = new CROBoundarySpec();
    pROBoundarySpec->setROSpecStartTrigger(pROSpecStartTrigger);
    pROBoundarySpec->setROSpecStopTrigger(pROSpecStopTrigger);

#if 1
    CAISpecStopTrigger *        pAISpecStopTrigger = new CAISpecStopTrigger();
    pAISpecStopTrigger->setAISpecStopTriggerType(
                            AISpecStopTriggerType_Duration);
    pAISpecStopTrigger->setDurationTrigger(30000);
#else
    CTagObservationTrigger *    pTagObservationTrigger =
                                    new CTagObservationTrigger();
    pTagObservationTrigger->setTriggerType (
 TagObservationTriggerType_Upon_Seeing_No_More_New_Tags_For_Tms_Or_Timeout);
    pTagObservationTrigger->setNumberOfTags(0);         /* unlimited */
    pTagObservationTrigger->setNumberOfAttempts(0);     /* n/a */
    pTagObservationTrigger->setT(3500);                 /* 3.5 sec */
    pTagObservationTrigger->setTimeout(12500);          /* 12.5 sec */

    CAISpecStopTrigger *        pAISpecStopTrigger = new CAISpecStopTrigger();
    pAISpecStopTrigger->setAISpecStopTriggerType(
                            AISpecStopTriggerType_Tag_Observation);
    pAISpecStopTrigger->setDurationTrigger(0);
    pAISpecStopTrigger->setTagObservationTrigger(pTagObservationTrigger);
#endif

    CC1G2SingulationControl *   pC1G2SingulationControl =
                                    new CC1G2SingulationControl();
    pC1G2SingulationControl->setSession(2);
    pC1G2SingulationControl->setTagPopulation(32);

    CC1G2InventoryCommand *     pC1G2InventoryCommand =
                                    new CC1G2InventoryCommand();
    pC1G2InventoryCommand->setC1G2SingulationControl(
                                        pC1G2SingulationControl);
    /*
     * C1G2RFControl might be set below if a m_ModeIndex was
     * given on the command line.
     */
    CAntennaConfiguration *     pAntennaConfiguration =
                                    new CAntennaConfiguration();
    pAntennaConfiguration->addAirProtocolInventoryCommandSettings (
                                        pC1G2InventoryCommand);

    CInventoryParameterSpec *   pInventoryParameterSpec =
                                    new CInventoryParameterSpec();
    pInventoryParameterSpec->setInventoryParameterSpecID(1234);
    pInventoryParameterSpec->setProtocolID(AirProtocols_EPCGlobalClass1Gen2);
    pInventoryParameterSpec->addAntennaConfiguration (
                                        pAntennaConfiguration);

    llrp_u16v_t                 AntennaIDs = llrp_u16v_t(1);
    AntennaIDs.m_pValue[0] = 0;         /* All */

    CAISpec *                   pAISpec = new CAISpec();
    pAISpec->setAntennaIDs(AntennaIDs);
    pAISpec->setAISpecStopTrigger(pAISpecStopTrigger);
    pAISpec->addInventoryParameterSpec(pInventoryParameterSpec);

    CTagReportContentSelector * pTagReportContentSelector =
                                    new CTagReportContentSelector();
    pTagReportContentSelector->setEnableROSpecID(FALSE);
    pTagReportContentSelector->setEnableSpecIndex(FALSE);
    pTagReportContentSelector->setEnableInventoryParameterSpecID(FALSE);
    pTagReportContentSelector->setEnableAntennaID(TRUE);
    pTagReportContentSelector->setEnableChannelIndex(FALSE);
    pTagReportContentSelector->setEnablePeakRSSI(TRUE);
    pTagReportContentSelector->setEnableFirstSeenTimestamp(TRUE);
    pTagReportContentSelector->setEnableLastSeenTimestamp(TRUE);
    pTagReportContentSelector->setEnableTagSeenCount(TRUE);
    pTagReportContentSelector->setEnableAccessSpecID(FALSE);

    CROReportSpec *             pROReportSpec = new CROReportSpec();
    pROReportSpec->setROReportTrigger(
            ROReportTriggerType_Upon_N_Tags_Or_End_Of_ROSpec);
    pROReportSpec->setN(1);         /* Report every singulation */
    pROReportSpec->setTagReportContentSelector(pTagReportContentSelector);

    CROSpec *                   pROSpec = new CROSpec();
    pROSpec->setROSpecID(123);
    pROSpec->setPriority(0);
    pROSpec->setCurrentState(ROSpecState_Disabled);
    pROSpec->setROBoundarySpec(pROBoundarySpec);
    pROSpec->addSpecParameter(pAISpec);
    pROSpec->setROReportSpec(pROReportSpec);

    CADD_ROSPEC *               pCmd;
    CMessage *                  pRspMsg;
    CADD_ROSPEC_RESPONSE *      pRsp;

    /*
     * Compose the command message.
     * N.B.: After the message is composed, all the parameters
     *       constructed, immediately above, are considered "owned"
     *       by the command message. When it is destructed so
     *       too will the parameters be.
     */
    pCmd = new CADD_ROSPEC();
    pCmd->setMessageID(201);
    pCmd->setROSpec(pROSpec);

    /*
     * If the mode was specified link in the AntennaConfiguration
     * that was prepared, above. The absence of the AntennaConfiguration
     * tells the reader to use the default mode.
     */
    if(0 <= m_ModeIndex)
    {
        CC1G2RFControl *        pC1G2RFControl =
                                    new CC1G2RFControl();

        pC1G2RFControl->setModeIndex(m_ModeIndex);
        pC1G2InventoryCommand->setC1G2RFControl(pC1G2RFControl);
    }

    /*
     * Send the message, expect the response of certain type
     */
    pRspMsg = transact(pCmd);

    /*
     * Done with the command message.
     * N.B.: And the parameters
     */
    delete pCmd;

    /*
     * transact() returns NULL if something went wrong.
     */
    if(NULL == pRspMsg)
    {
        /* transact already tattled */
        return -1;
    }

    /*
     * Cast to a ADD_ROSPEC_RESPONSE message.
     */
    pRsp = (CADD_ROSPEC_RESPONSE *) pRspMsg;

    /*
     * Check the LLRPStatus parameter.
     */
    if(0 != checkLLRPStatus(pRsp->getLLRPStatus(), "addROSpec"))
    {
        /* checkLLRPStatus already tattled */
        delete pRspMsg;
        return -1;
    }

    /*
     * Done with the response message.
     */
    delete pRspMsg;

    /*
     * Tattle progress, maybe
     */
    if(m_Verbose)
    {
        printf("INFO: ROSpec added\n");
    }

    /*
     * Victory.
     */
    return 0;
}


int
CMyApplication::enableROSpec (void)
{
    CENABLE_ROSPEC *            pCmd;
    CMessage *                  pRspMsg;
    CENABLE_ROSPEC_RESPONSE *   pRsp;

    /*
     * Compose the command message
     */
    pCmd = new CENABLE_ROSPEC();
    pCmd->setMessageID(202);
    pCmd->setROSpecID(123);

    /*
     * Send the message, expect the response of certain type
     */
    pRspMsg = transact(pCmd);

    /*
     * Done with the command message
     */
    delete pCmd;

    /*
     * transact() returns NULL if something went wrong.
     */
    if(NULL == pRspMsg)
    {
        /* transact already tattled */
        return -1;
    }

    /*
     * Cast to a ENABLE_ROSPEC_RESPONSE message.
     */
    pRsp = (CENABLE_ROSPEC_RESPONSE *) pRspMsg;

    /*
     * Check the LLRPStatus parameter.
     */
    if(0 != checkLLRPStatus(pRsp->getLLRPStatus(), "enableROSpec"))
    {
        /* checkLLRPStatus already tattled */
        delete pRspMsg;
        return -1;
    }

    /*
     * Done with the response message.
     */
    delete pRspMsg;

    /*
     * Tattle progress, maybe
     */
    if(m_Verbose)
    {
        printf("INFO: ROSpec enabled\n");
    }

    /*
     * Victory.
     */
    return 0;
}


int
CMyApplication::startAndMonitorOperation (void)
{
    CSTART_ROSPEC *             pCmd;
    int                         bDone = 0;
    int                         RetVal = 0;

    /*
     * Tattle as we start.
     */
    printf("INFO: Inventory operation starting\n");

    /*
     * Compose the command message
     */
    pCmd = new CSTART_ROSPEC();
    pCmd->setMessageID(203);
    pCmd->setROSpecID(123);

    /*
     * Just send the START_ROSPEC message, do not wait for the resposne.
     */
    if(0 != sendMessage(pCmd))
    {
        /* sendMessage already tattled */
        return -1;
    }

    /*
     * Done with the command message
     */
    delete pCmd;

    /*
     * Keep receiving messages until done or until
     * something bad happens.
     */
    while(!bDone)
    {
        CMessage *              pMessage;
        const CTypeDescriptor * pType;

        /*
         * Wait up to 20 seconds for a message. They should
         * be much more frequent because there will be several
         * hopping events per second.
         */
        pMessage = recvMessage(20000);
        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 (m_pType) to
         * discriminate message types.
         */
        pType = pMessage->m_pType;

        /*
         * Is it the response from the START_ROSPEC?
         * If so, just make sure the status is good.
         * If the status is not good there is no
         * ROSpec running and things are done.
         */
        if(&CSTART_ROSPEC_RESPONSE::s_typeDescriptor == pType)
        {
            CSTART_ROSPEC_RESPONSE *pRsp;

            /*
             * Cast to a START_ROSPEC_RESPONSE message.
             */
            pRsp = (CSTART_ROSPEC_RESPONSE *) pMessage;

            /*
             * Check the LLRPStatus parameter.
             */
            if(0 != checkLLRPStatus(pRsp->getLLRPStatus(), "startROSpec"))
            {
                /* checkLLRPStatus already tattled */
                RetVal = -3;
                bDone = 1;
            }
            else
            {
                /* Good start. Tattle, maybe. */
                if(m_Verbose)
                {
                    printf("INFO: Start command acknowledged\n");
                }
            }
        }

        /*
         * Is it a reader event? If so, which ones?
         */
        else if(&CREADER_EVENT_NOTIFICATION::s_typeDescriptor == pType)
        {
            CREADER_EVENT_NOTIFICATION *pNtf;
            CReaderEventNotificationData *pNtfData;

            pNtf = (CREADER_EVENT_NOTIFICATION *) pMessage;
            pNtfData = pNtf->getReaderEventNotificationData();

            /*
             * Is there an ROSpecEvent? These tell use when the ROSpec
             * starts and stops. When it stops things are done.
             */
            if(NULL != pNtfData->getROSpecEvent())
            {
                CROSpecEvent *    pROEvent;

                pROEvent = pNtfData->getROSpecEvent();
                switch(pROEvent->getEventType())
                {
                default:
                    printf("ERROR: Unknown RO event type\n");
                    RetVal = -4;
                    bDone = 1;
                    break;

                case ROSpecEventType_Start_Of_ROSpec:
                    if(m_Verbose)
                    {
                        printf("INFO: RO running\n");
                    }
                    break;

                case ROSpecEventType_End_Of_ROSpec:
                    if(m_Verbose)
                    {
                        printf("INFO: RO stopped\n");
                    }
                    RetVal = 0;
                    bDone = 1;
                    break;
                }
            }

            /*
             * Other reader events may be present.
             * Notifications enabled include AISpec events,
             * antenna events, and hopping events.
             * Run this programs with -vv to see the
             * XML for the other events.
             *
             * For this example we just ignore them.
             */
        }

        /*
         * Is it a tag report? If so, print it out.
         */
        else if(&CRO_ACCESS_REPORT::s_typeDescriptor == pType)
        {
            CRO_ACCESS_REPORT * pNtf;

            pNtf = (CRO_ACCESS_REPORT *) pMessage;

            printTagReportData(pNtf);
        }

        /*
         * Hmmm. Something unexpected. Just tattle and keep going.
         */
        else
        {
            printf("WARNING: Ignored unexpected message during monitor: %s\n",
                pType->m_pName);
        }

        /*
         * Done with the received message
         */
        delete pMessage;
    }

    /*
     * Tattle about how things turned out.
     */
    if(RetVal != 0)
    {
        printf("ERROR: Inventory operation terminated (%d)\n", RetVal);
    }
    else if(m_Verbose)
    {
        printf("INFO: Inventory operation finished\n");
    }

    return RetVal;
}


void
CMyApplication::printTagReportData (
  CRO_ACCESS_REPORT *           pRO_ACCESS_REPORT)
{
    std::list<CTagReportData *>::iterator Cur;
    unsigned int                nEntry = 0;

    /*
     * Count the number of tag reports.
     */
    m_nTagReport++;

    /*
     * If individual tag reports are not wanted, just return.
     */
    if(m_Quiet)
    {
        return;
    }

    /*
     * Loop through and count the number of entries
     */
    for (
        Cur = pRO_ACCESS_REPORT->beginTagReportData();
        Cur != pRO_ACCESS_REPORT->endTagReportData();
        Cur++)
    {
        nEntry++;
    }

    printf("INFO: %u tag report entries\n", nEntry);

    /*
     * Loop through again and print each entry.
     */
    for (
        Cur = pRO_ACCESS_REPORT->beginTagReportData();
        Cur != pRO_ACCESS_REPORT->endTagReportData();
        Cur++)
    {
        printOneTagReportData (*Cur);
    }
}


void
CMyApplication::printOneTagReportData (
  CTagReportData *              pTagReportData)
{
    const CTypeDescriptor *     pType;
    char                        aBuf[64];

    /*
     * Print the EPC. It could be an 96-bit EPC_96 parameter
     * or an variable length EPCData parameter.
     */

    CParameter *                pEPCParameter =
                                    pTagReportData->getEPCParameter();

    if(NULL != pEPCParameter)
    {
        char *              p = aBuf;
        llrp_u96_t          my_u96;
        llrp_u1v_t          my_u1v;
        llrp_u8_t *         pValue = NULL;
        unsigned int        n, i;

        pType = pEPCParameter->m_pType;
        if(&CEPC_96::s_typeDescriptor == pType)
        {
            CEPC_96             *pEPC_96;

            pEPC_96 = (CEPC_96 *) pEPCParameter;
            my_u96 = pEPC_96->getEPC();
            pValue = my_u96.m_aValue;
            n = 12u;
        }
        else if(&CEPCData::s_typeDescriptor == pType)
        {
            CEPCData *          pEPCData;

            pEPCData = (CEPCData *) pEPCParameter;
            my_u1v = pEPCData->getEPC();
            pValue = my_u1v.m_pValue;
            n = (my_u1v.m_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);

    /*
     * Print the antenna ID number
     */
    if(NULL != pTagReportData->getAntennaID())
    {
        sprintf(aBuf, "ant%d",
            pTagReportData->getAntennaID()->getAntennaID());
    }
    else
    {
        sprintf(aBuf, "ant?");
    }
    printf(" %-5s", aBuf);

    /*
     * Print the peak RSSI
     */
    if(NULL != pTagReportData->getPeakRSSI())
    {
        sprintf(aBuf, "%3ddBm",
            pTagReportData->getPeakRSSI()->getPeakRSSI());
    }
    else
    {
        sprintf(aBuf, "  ?dBm");
    }
    printf(" %-7s", aBuf);

    /*
     * Print the number of times the tag was seen
     */
    if(NULL != pTagReportData->getTagSeenCount())
    {
        sprintf(aBuf, "%4dseen",
            pTagReportData->getTagSeenCount()->getTagCount());
    }
    else
    {
        sprintf(aBuf, "   ?seen");
    }
    printf(" %-8s", aBuf);

    /*
     * End of line
     */
    printf("\n");
}


int
CMyApplication::checkLLRPStatus (
  CLLRPStatus *                 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(StatusCode_M_Success != pLLRPStatus->getStatusCode())
    {
        llrp_utf8v_t            ErrorDesc;

        ErrorDesc = pLLRPStatus->getErrorDescription();

        if(0 == ErrorDesc.m_nValue)
        {
            printf("ERROR: %s failed, no error description given\n",
                pWhatStr);
        }
        else
        {
            printf("ERROR: %s failed, %.*s\n",
                pWhatStr, ErrorDesc.m_nValue, ErrorDesc.m_pValue);
        }
        return -2;
    }

    /*
     * Victory. Everything is fine.
     */
    return 0;
}


CMessage *
CMyApplication::transact (
  CMessage *                    pSendMsg)
{
    CConnection *               pConn = m_pConnectionToReader;
    CMessage *                  pRspMsg;

    /*
     * Print the XML text for the outbound message if
     * verbosity is 2 or higher.
     */
    if(1 < m_Verbose)
    {
        /* If -qq command option, do XML encode but don't actually print */
        if(2 > m_Quiet)
        {
            printf("\n===================================\n");
            printf("INFO: Transact sending\n");
        }
        printXMLMessage(pSendMsg);
    }

    /*
     * Send the message, expect the response of certain type.
     * If LLRP::CConnection::transact() returns NULL then there was
     * an error. In that case we try to print the error details.
     */
    pRspMsg = pConn->transact(pSendMsg, 5000);

    if(NULL == pRspMsg)
    {
        const CErrorDetails *   pError = pConn->getTransactError();

        printf("ERROR: %s transact failed, %s\n",
            pSendMsg->m_pType->m_pName,
            pError->m_pWhatStr ? pError->m_pWhatStr : "no reason given");

        if(NULL != pError->m_pRefType)
        {
            printf("ERROR: ... reference type %s\n",
                pError->m_pRefType->m_pName);
        }

        if(NULL != pError->m_pRefField)
        {
            printf("ERROR: ... reference field %s\n",
                pError->m_pRefField->m_pName);
        }

        return NULL;
    }

    /*
     * Print the XML text for the inbound message if
     * verbosity is 2 or higher.
     */
    if(1 < m_Verbose)
    {
        /* If -qq command option, do XML encode but don't actually print */
        if(2 > m_Quiet)
        {
            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(&CERROR_MESSAGE::s_typeDescriptor == pRspMsg->m_pType)
    {
        const CTypeDescriptor * pResponseType;

        pResponseType = pSendMsg->m_pType->m_pResponseType;

        printf("ERROR: Received ERROR_MESSAGE instead of %s\n",
            pResponseType->m_pName);
        delete pRspMsg;
        pRspMsg = NULL;
    }

    return pRspMsg;
}


CMessage *
CMyApplication::recvMessage (
  int                           nMaxMS)
{
    CConnection *               pConn = m_pConnectionToReader;
    CMessage *                  pMessage;

    /*
     * Receive the message subject to a time limit
     */
    pMessage = pConn->recvMessage(nMaxMS);

    /*
     * If LLRP::CConnection::recvMessage() returns NULL then there was
     * an error. In that case we try to print the error details.
     */
    if(NULL == pMessage)
    {
        const CErrorDetails *   pError = pConn->getRecvError();

        printf("ERROR: recvMessage failed, %s\n",
            pError->m_pWhatStr ? pError->m_pWhatStr : "no reason given");

        if(NULL != pError->m_pRefType)
        {
            printf("ERROR: ... reference type %s\n",
                pError->m_pRefType->m_pName);
        }

        if(NULL != pError->m_pRefField)
        {
            printf("ERROR: ... reference field %s\n",
                pError->m_pRefField->m_pName);
        }

        return NULL;
    }

    /*
     * Print the XML text for the inbound message if
     * verbosity is 2 or higher.
     */
    if(1 < m_Verbose)
    {
        /* If -qq command option, do XML encode but don't actually print */
        if(2 > m_Quiet)
        {
            printf("\n===================================\n");
            printf("INFO: Message received\n");
        }
        printXMLMessage(pMessage);
    }

    return pMessage;
}


int
CMyApplication::sendMessage (
  CMessage *                    pSendMsg)
{
    CConnection *               pConn = m_pConnectionToReader;

    /*
     * Print the XML text for the outbound message if
     * verbosity is 2 or higher.
     */
    if(1 < m_Verbose)
    {
        /* If -qq command option, do XML encode but don't actually print */
        if(2 > m_Quiet)
        {
            printf("\n===================================\n");
            printf("INFO: Sending\n");
        }
        printXMLMessage(pSendMsg);
    }

    /*
     * If LLRP::CConnection::sendMessage() returns other than RC_OK
     * then there was an error. In that case we try to print
     * the error details.
     */
    if(RC_OK != pConn->sendMessage(pSendMsg))
    {
        const CErrorDetails *   pError = pConn->getSendError();

        printf("ERROR: %s sendMessage failed, %s\n",
            pSendMsg->m_pType->m_pName,
            pError->m_pWhatStr ? pError->m_pWhatStr : "no reason given");

        if(NULL != pError->m_pRefType)
        {
            printf("ERROR: ... reference type %s\n",
                pError->m_pRefType->m_pName);
        }

        if(NULL != pError->m_pRefField)
        {
            printf("ERROR: ... reference field %s\n",
                pError->m_pRefField->m_pName);
        }

        return -1;
    }

    /*
     * Victory
     */
    return 0;
}


void
CMyApplication::printXMLMessage (
  CMessage *                    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.
     */

    pMessage->toXMLString(aBuf, sizeof aBuf);

    /*
     * Print the XML Text to the standard output.
     * For characterization, command line option -qq
     * prevents the XML text actually being printed and
     * so the CPU utilization of XMLTextEncoder can be measured
     * without the noise.
     */
    if(2 > m_Quiet)
    {
        printf("%s", aBuf);
    }
}

---