tm_reader.h

Go to the documentation of this file.

/* ex: set tabstop=2 shiftwidth=2 expandtab cindent: */
#ifndef _TM_READER_H
#define _TM_READER_H

 /*
 * Copyright (c) 2009 ThingMagic, Inc.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

#include "tm_config.h"

#if !defined(TMR_ENABLE_SERIAL_READER_ONLY) && !defined(TMR_ENABLE_JNI_SERIAL_READER_ONLY)  && defined(TMR_ENABLE_LLRP_TRANSPORT)
#define TMR_ENABLE_LLRP_READER
#endif

#ifdef TMR_ENABLE_BACKGROUND_READS
#include <pthread.h>
#include <semaphore.h>
#endif

typedef struct TMR_Reader TMR_Reader;

#include "tmr_types.h"
#include "tmr_status.h"

#include "tmr_gpio.h"
#include "tmr_params.h"
#include "tmr_read_plan.h"
#include "tmr_tag_auth.h"
#include "tmr_tag_data.h"
#include "tmr_tag_lock_action.h"
#include "tmr_tag_protocol.h"
#include "tmr_tagop.h"

#include "tmr_serial_reader.h"
#ifdef TMR_ENABLE_LLRP_READER
#include "tmr_llrp_reader.h"
#endif

#ifdef  __cplusplus
extern "C" {
#endif


#ifndef DOXYGEN_IGNORE
typedef TMR_Status (*TMR_TransportNativeInit)(TMR_SR_SerialTransport *transport, TMR_SR_SerialPortNativeContext *context,
    const char *device);

typedef struct TMR_readParams
{
#ifdef TMR_ENABLE_BACKGROUND_READS
  uint32_t asyncOnTime;
  uint32_t asyncOffTime;
#endif
  TMR_ReadPlan defaultReadPlan;
  TMR_ReadPlan *readPlan;
} TMR_readParams;

typedef struct TMR_tagOpParams
{
  uint8_t antenna;
  TMR_TagProtocol protocol;
}TMR_tagOpParams;

typedef enum TMR_ReaderType
{
  TMR_READER_TYPE_INVALID,
  TMR_READER_TYPE_RQL,
  TMR_READER_TYPE_SERIAL,
  TMR_READER_TYPE_LLRP,
} TMR_ReaderType;

typedef enum TMR_ReadState
{
  TMR_READ_STATE_IDLE,
  TMR_READ_STATE_STARTING,
  TMR_READ_STATE_STARTED,
  TMR_READ_STATE_ACTIVE,
  TMR_READ_STATE_DONE,
} TMR_ReadState;


#endif /* DOXYGEN_IGNORE */

typedef enum TMR_Reader_StatsFlag
{
  TMR_READER_STATS_FLAG_NONE = 0x00,
  TMR_READER_STATS_FLAG_RF_ON_TIME = (1 << 0),
  TMR_READER_STATS_FLAG_NOISE_FLOOR_SEARCH_RX_TX_WITH_TX_ON = (1 << 6),
  TMR_READER_STATS_FLAG_FREQUENCY = (1 << 7),
  TMR_READER_STATS_FLAG_TEMPERATURE = (1 << 8),
  TMR_READER_STATS_FLAG_ANTENNA_PORTS = (1 << 9),
  TMR_READER_STATS_FLAG_PROTOCOL = (1 << 10),
  TMR_READER_STATS_FLAG_CONNECTED_ANTENNAS = (1 << 11),
  /* ALL */
  TMR_READER_STATS_FLAG_ALL = (TMR_READER_STATS_FLAG_RF_ON_TIME |
      TMR_READER_STATS_FLAG_NOISE_FLOOR_SEARCH_RX_TX_WITH_TX_ON |
      TMR_READER_STATS_FLAG_TEMPERATURE |
      TMR_READER_STATS_FLAG_PROTOCOL |
      TMR_READER_STATS_FLAG_ANTENNA_PORTS |
      TMR_READER_STATS_FLAG_FREQUENCY |
      TMR_READER_STATS_FLAG_CONNECTED_ANTENNAS),
}TMR_Reader_StatsFlag;

typedef struct TMR_StatsPerAntennaValues
{
        uint8_t antenna;
        uint32_t rfOnTime;
        int8_t noiseFloor;
} TMR_StatsPerAntennaValues;

typedef struct TMR_StatsPerAntennaValuesList
{
        TMR_StatsPerAntennaValues *list;
        uint16_t max;
        uint16_t len;
} TMR_StatsPerAntennaValuesList;

typedef struct TMR_Reader_StatsValues
{
        TMR_Reader_StatsFlag valid;
        int8_t temperature;
        TMR_TagProtocol protocol;
        uint16_t antenna;
        uint32_t frequency;
        TMR_uint8List connectedAntennas;
        uint8_t _connectedAntennasStorage[TMR_SR_MAX_ANTENNA_PORTS];
        TMR_StatsPerAntennaValuesList perAntenna;
        TMR_StatsPerAntennaValues _perAntStorage[TMR_SR_MAX_ANTENNA_PORTS];
}TMR_Reader_StatsValues;

typedef void (*TMR_ReadListener)(TMR_Reader *reader, const TMR_TagReadData *t,
                                 void *cookie);
typedef struct TMR_ReadListenerBlock
{
  TMR_ReadListener listener;
  void *cookie;
  struct TMR_ReadListenerBlock *next;
} TMR_ReadListenerBlock;

typedef void (*TMR_AuthReqListener)(TMR_Reader *reader, const TMR_TagReadData *trd,
                                                                        void *cookie, TMR_TagAuthentication *auth);
typedef struct TMR_AuthReqListenerBlock
{
  TMR_AuthReqListener listener;
  void *cookie;
  struct TMR_AuthReqListenerBlock *next;
} TMR_AuthReqListenerBlock;

typedef void (*TMR_ReadExceptionListener)(TMR_Reader *reader, TMR_Status error, void *cookie);
typedef struct TMR_ReadExceptionListenerBlock
{
  TMR_ReadExceptionListener listener;
  void *cookie;
  struct TMR_ReadExceptionListenerBlock *next;
} TMR_ReadExceptionListenerBlock;

typedef void (*TMR_TransportListener) (bool tx, uint32_t dataLen,
                                       const uint8_t data[], uint32_t timeout,
                                       void *cookie);
typedef struct TMR_TransportListenerBlock
{
  TMR_TransportListener listener;
  void *cookie;
  struct TMR_TransportListenerBlock *next;
} TMR_TransportListenerBlock;

typedef void (*TMR_StatsListener)(TMR_Reader *reader, const TMR_Reader_StatsValues* value,
                                void *cookie);
typedef void (*TMR_StatusListener)(TMR_Reader *reader, const TMR_SR_StatusReport report[],
                                 void *cookie);
typedef struct TMR_StatsListenerBlock
{
  TMR_StatsListener listener;
  void *cookie;
  struct TMR_StatsListenerBlock *next;
} TMR_StatsListenerBlock;

typedef struct TMR_StatusListenerBlock
{
  TMR_StatusListener listener;
  void *cookie;
  struct TMR_StatusListenerBlock *next;
} TMR_StatusListenerBlock;

typedef struct TMR_Queue_tagReads
{
  union
  {
    /* Buffer to hold serial message response */
    uint8_t *sMsg;
#ifdef TMR_ENABLE_LLRP_READER
    /* Buffer to hold LLRP message response */
    LLRP_tSMessage *lMsg;
#endif
  } tagEntry;

  uint8_t bufPointer;
  /* Object to hold tag results */
  TMR_TagReadData trd;
  bool isStatusResponse;
  struct TMR_Queue_tagReads  *next;
}TMR_Queue_tagReads;

typedef TMR_SR_GEN2_QType TMR_GEN2_QType;
typedef TMR_SR_GEN2_QStatic TMR_GEN2_QStatic;
typedef TMR_SR_GEN2_Q TMR_GEN2_Q;

struct TMR_Reader
{
  enum TMR_ReaderType readerType;
  bool connected;
  TMR_TransportListenerBlock *transportListeners;

  TMR_readParams readParams;
  TMR_tagOpParams tagOpParams;
  char uri[TMR_MAX_READER_NAME_LENGTH];
  
  bool continuousReading;
  bool trueAsyncflag;
  bool searchStatus;
  /* Statistics response indicator */
  bool isStatusResponse;
  /* Option for Fast Search */
  bool fastSearch;
  /* Option for Trigger Read */
  bool triggerRead;
  /* Option for Duty cycle*/
  bool dutyCycle;
  /* Option for stop N tag trigger */
  bool isStopNTags;
  /* Param wait indicator for Reader and protocol param control during continuous read */
  bool paramWait;
  /* Param responsefor Reader and protocol param control during continuous read */
  uint8_t paramMessage[256];
  /* True Continuous Read Start indicator */
  bool hasContinuousReadStarted;
  /* Total tag count for sto N trigger */
  uint32_t numberOfTagsToRead;
  /* Does ResetStats feature work on this reader?
   * Unknown: NULL == pSupportsResetStats
   * Yes: (NULL != pSupportsResetStats) && (true == *pSupportsResetStats)
   * No: (NULL != pSupportsResetStats) && (false == *pSupportsResetStats)
   */
  bool* pSupportsResetStats/* = NULL*/;
  bool _storeSupportsResetStats;
  /* the option to request for background thread cancel */
  bool backgroundThreadCancel;

  union
  {
    TMR_SR_SerialReader serialReader;
    /*
     *TMR_RQL_RqlReader rqlReader;
     */
#ifdef TMR_ENABLE_LLRP_READER
    TMR_LLRP_LlrpReader llrpReader;
#endif
  }u;

#ifdef TMR_ENABLE_BACKGROUND_READS
  bool backgroundSetup, backgroundEnabled, backgroundRunning;
  bool parserSetup, parserEnabled, parserRunning;
#endif
  bool finishedReading;
#ifdef TMR_ENABLE_BACKGROUND_READS
  enum TMR_ReadState readState;
  unsigned int queue_depth;
  sem_t queue_slots, queue_length;
  pthread_mutex_t queue_lock;
  pthread_mutex_t backgroundLock;
  pthread_mutex_t parserLock;
  pthread_mutex_t listenerLock;  
  pthread_cond_t backgroundCond;
  pthread_cond_t parserCond;
  pthread_cond_t readCond;
  pthread_t backgroundReader;
  pthread_t backgroundParser;
  pthread_t autonomousBackgroundReader;
  TMR_AuthReqListenerBlock *authReqListeners;
#endif
  TMR_ReadListenerBlock *readListeners;
  TMR_ReadExceptionListenerBlock *readExceptionListeners;
  TMR_StatsListenerBlock *statsListeners;
#ifdef TMR_ENABLE_BACKGROUND_READS
  TMR_StatusListenerBlock *statusListeners;
  TMR_Queue_tagReads *tagQueueTail;
  TMR_Queue_tagReads *tagQueueHead;
#endif
  TMR_Reader_StatsFlag statsFlag;
  TMR_SR_StatusType streamStats;
  TMR_TRD_MetadataFlag userMetadataFlag;
  uint8_t portmask;


  /* Level 1 */
#ifndef TMR_ENABLE_SERIAL_READER_ONLY
  TMR_Status (*connect)(struct TMR_Reader *reader);
  TMR_Status (*destroy)(struct TMR_Reader *reader);
  TMR_Status (*read)(struct TMR_Reader *reader, uint32_t timeoutMs, int32_t *tagCount);
  TMR_Status (*hasMoreTags)(struct TMR_Reader *reader);
  TMR_Status (*getNextTag)(struct TMR_Reader *reader, TMR_TagReadData *read);
  TMR_Status (*writeTag)(struct TMR_Reader *reader, const TMR_TagFilter *filter, const TMR_TagData *data);
#endif /* TMR_ENABLE_SERIAL_READER_ONLY  */
  TMR_Status (*paramGet)(struct TMR_Reader *reader, TMR_Param key, void *value);
  TMR_Status (*paramSet)(struct TMR_Reader *reader, TMR_Param key, const void *value);
  
  /* Level 2 */
#ifndef TMR_ENABLE_SERIAL_READER_ONLY
  TMR_Status (*killTag)(struct TMR_Reader *reader, const TMR_TagFilter *filter, const TMR_TagAuthentication *auth);
  TMR_Status (*lockTag)(struct TMR_Reader *reader, const TMR_TagFilter *filter, TMR_TagLockAction *action);
  TMR_Status (*executeTagOp)(struct TMR_Reader *reader, TMR_TagOp *tagop, TMR_TagFilter *filter, TMR_uint8List *data);
  TMR_Status (*readTagMemBytes)(struct TMR_Reader *reader, const TMR_TagFilter *filter, 
                               uint32_t bank, uint32_t address,
                               uint16_t count, uint8_t data[]);
  TMR_Status (*readTagMemWords)(struct TMR_Reader *reader, const TMR_TagFilter *filter,
                               uint32_t bank, uint32_t address,
                               uint16_t count, uint16_t *data);
  TMR_Status (*writeTagMemBytes)(struct TMR_Reader *reader, const TMR_TagFilter *filter,
                               uint32_t bank, uint32_t address,
                               uint16_t count, const uint8_t data[]);
  TMR_Status (*writeTagMemWords)(struct TMR_Reader *reader, const TMR_TagFilter *filter,
                               uint32_t bank, uint32_t address,
                               uint16_t count, const uint16_t data[]);
  TMR_Status (*gpoSet)(struct TMR_Reader *reader, uint8_t count, const TMR_GpioPin state[]);
  TMR_Status (*gpiGet)(struct TMR_Reader *reader, uint8_t *count, TMR_GpioPin state[]);
  TMR_Status (*firmwareLoad)(TMR_Reader *reader, void *cookie, TMR_FirmwareDataProvider provider);
  TMR_Status (*modifyFlash) (TMR_Reader *reader, uint8_t sector, uint32_t address, uint32_t password,
                             uint8_t length, const uint8_t data[], uint32_t offset);
  TMR_Status (*reboot) (TMR_Reader *reader);
#endif /* TMR_ENABLE_SERIAL_READER_ONLY  */

  /* Level 3 */
#ifdef TMR_ENABLE_BACKGROUND_READS
  TMR_Status (*cmdAutonomousReading)(struct TMR_Reader *reader, TMR_TagReadData *trd, TMR_Reader_StatsValues *stats);
#endif
  TMR_Status (*cmdStopReading)(struct TMR_Reader *reader);
};

TMR_Status TMR_create(TMR_Reader *reader, const char* deviceUri);

TMR_Status TMR_create_alloc(TMR_Reader **readerPointer, const char* deviceUri);


TMR_Status TMR_connect(struct TMR_Reader *reader);

TMR_Status TMR_destroy(TMR_Reader *reader);

TMR_Status TMR_read(TMR_Reader *reader, uint32_t timeoutMs, int32_t *tagCount);

TMR_Status TMR_hasMoreTags(TMR_Reader *reader);

TMR_Status TMR_getNextTag(TMR_Reader *reader, TMR_TagReadData *tagData);

TMR_Status TMR_executeTagOp(struct TMR_Reader *reader, TMR_TagOp *tagop, TMR_TagFilter *filter, TMR_uint8List *data);

TMR_Status TMR_readIntoArray(struct TMR_Reader *reader, uint32_t timeoutMs, int32_t *tagCount, TMR_TagReadData *result[]);

TMR_Status TMR_writeTag(TMR_Reader *reader, const TMR_TagFilter *target, TMR_TagData *data);

TMR_Status TMR_killTag(TMR_Reader *reader, TMR_TagFilter *target, TMR_TagAuthentication *auth);


TMR_Status TMR_lockTag(TMR_Reader *reader, TMR_TagFilter *target, TMR_TagLockAction *action);


TMR_Status TMR_readTagMemBytes(TMR_Reader *reader, TMR_TagFilter *target, 
                               uint32_t bank, uint32_t byteAddress, 
                               uint16_t byteCount, uint8_t data[]);

TMR_Status TMR_readTagMemWords(TMR_Reader *reader, TMR_TagFilter *target, 
                               uint32_t bank, uint32_t wordAddress, 
                               uint16_t wordCount, uint16_t data[]);

TMR_Status TMR_writeTagMemBytes(TMR_Reader *reader, TMR_TagFilter *target,
                                uint32_t bank, uint32_t byteAddress,
                                uint16_t byteCount, const uint8_t data[]);

TMR_Status TMR_writeTagMemWords(TMR_Reader *reader, TMR_TagFilter *target,
                                uint32_t bank, uint32_t wordAddress,
                                uint16_t wordCount, const uint16_t data[]);


TMR_Status TMR_gpoSet(TMR_Reader *reader, uint8_t count, const TMR_GpioPin state[]);

TMR_Status TMR_gpiGet(TMR_Reader *reader, uint8_t *count, TMR_GpioPin state[]);

TMR_Status TMR_firmwareLoad(TMR_Reader *reader, void *cookie, TMR_FirmwareDataProvider provider);

typedef struct TMR_memoryCookie {
  uint8_t *firmwareStart;
  uint32_t firmwareSize;
} TMR_memoryCookie;

bool TMR_memoryProvider(void *cookie, uint16_t *size, uint8_t *data);

bool TMR_fileProvider(void *cookie, uint16_t *size, uint8_t *data);

TMR_Status TMR_paramSet(struct TMR_Reader *reader, TMR_Param key, const void *value);

TMR_Status TMR_paramGet(struct TMR_Reader *reader, TMR_Param key, void *value);

TMR_Status TMR_reboot(struct TMR_Reader *reader);

TMR_Status TMR_paramList(struct TMR_Reader *reader, TMR_Param *keys, uint32_t *len);
void TMR_paramProbe (struct TMR_Reader *reader, TMR_Param key);

const char* TMR_paramName(TMR_Param key);

TMR_Param TMR_paramID(const char *name);


TMR_Status TMR_addTransportListener(TMR_Reader *reader, TMR_TransportListenerBlock *block);


TMR_Status TMR_removeTransportListener(TMR_Reader *reader, TMR_TransportListenerBlock *block);

TMR_Status TMR_addReadListener(struct TMR_Reader *reader,
                               TMR_ReadListenerBlock *block);

TMR_Status TMR_addAuthReqListener(struct TMR_Reader *reader,
                                  TMR_AuthReqListenerBlock *block);

TMR_Status TMR_removeReadListener(struct TMR_Reader *reader,
                                  TMR_ReadListenerBlock *block);

TMR_Status TMR_addReadExceptionListener(struct TMR_Reader *reader,
                                        TMR_ReadExceptionListenerBlock *block);

TMR_Status TMR_removeReadExceptionListener(struct TMR_Reader *reader,
                                           TMR_ReadExceptionListenerBlock *block);

TMR_Status TMR_addStatusListener(struct TMR_Reader *reader,
                               TMR_StatusListenerBlock *block);

TMR_Status TMR_removeStatusListener(struct TMR_Reader *reader,
                                  TMR_StatusListenerBlock *block);


TMR_Status TMR_addStatsListener(struct TMR_Reader *reader,
                               TMR_StatsListenerBlock *block);

TMR_Status TMR_removeStatsListener(struct TMR_Reader *reader,
                                  TMR_StatsListenerBlock *block);


TMR_Status TMR_startReading(struct TMR_Reader *reader);
TMR_Status TMR_receiveAutonomousReading(struct TMR_Reader *reader, TMR_TagReadData *trd, TMR_Reader_StatsValues *stats);
TMR_Status TMR_stopReading(struct TMR_Reader *reader);

TMR_Status TMR_setSerialTransport(char* scheme, TMR_TransportNativeInit nativeInit);

const char *TMR_strerr(TMR_Reader *reader, TMR_Status status);

TMR_Status TMR_STATS_init(TMR_Reader_StatsValues *stats);

TMR_Status TMR_loadConfig(struct TMR_Reader *reader, char *filePath);

TMR_Status TMR_saveConfig(struct TMR_Reader *reader, char *filePath);

#ifndef DOXYGEN_IGNORE

TMR_Status TMR_reader_init_internal(struct TMR_Reader *reader);
/*TMR_Status TMR_init_statusListenerBlock(TMR_StatusListenerBlock *slb, TMR_StatusListener listener,
                                        void *cookie, TMR_SR_StatusContentFlags statusFlags);*/
TMR_Status validateReadPlan(TMR_Reader *reader, TMR_ReadPlan *plan, TMR_AntennaMapList *txRxMap, uint32_t protocols);

void TMR__notifyTransportListeners(TMR_Reader *reader, bool tx, 
                                   uint32_t dataLen, uint8_t *data,
                                   int timeout);

void notify_exception_listeners(TMR_Reader *reader, TMR_Status status);
void cleanup_background_threads(TMR_Reader *reader);

#ifdef TMR_ENABLE_SERIAL_READER_ONLY

#define TMR_connect(reader) (TMR_SR_connect(reader))
#define TMR_destroy(reader) (TMR_SR_destroy(reader))
#define TMR_read(reader, timeoutMs, tagCount) (TMR_SR_read((reader),(timeoutMs),(tagCount)))
#define TMR_hasMoreTags(reader) (TMR_SR_hasMoreTags(reader))
#define TMR_getNextTag(reader, read) (TMR_SR_getNextTag((reader),(read)))
#define TMR_writeTag(reader, filter, data) (TMR_SR_writeTag((reader),(filter),(data)))
#define TMR_readTagMemWords(reader, target, bank, address, count, data) (TMR_SR_readTagMemWords((reader),(target),(bank),(address),(count),(data)))
#define TMR_readTagMemBytes(reader, target, bank, address, count, data) (TMR_SR_readTagMemBytes((reader),(target),(bank),(address),(count),(data)))
#define TMR_writeTagMemWords(reader, target, bank, address, count, data) (TMR_SR_writeTagMemWords((reader),(target),(bank),(address),(count),(data)))
#define TMR_writeTagMemBytes(reader, target, bank, address, count, data) (TMR_SR_writeTagMemBytes((reader),(target),(bank),(address),(count),(data)))
#define TMR_killTag(reader, filter, auth) (TMR_SR_killTag((reader),(filter),(auth)))
#define TMR_lockTag(reader, filter, action) (TMR_SR_lockTag((reader),(filter),(action)))
#define TMR_executeTagOp(reader, tagop, filter, data) (TMR_SR_executeTagOp((reader), (tagop), (filter), (data)))
#define TMR_gpoSet(reader, count, state) (TMR_SR_gpoSet((reader),(count),(state)))
#define TMR_gpiGet(reader, count, state) (TMR_SR_gpiGet((reader),(count),(state)))
#define TMR_firmwareLoad(reader, cookie, provider) (TMR_SR_firmwareLoad((reader),(cookie),(provider)))
#define TMR_reboot(reader) (TMR_SR_reboot((reader)))

#else

#define TMR_connect(reader) ((reader)->connect(reader))
#define TMR_destroy(reader) ((reader)->destroy(reader))
#define TMR_read(reader, timeoutMs, tagCount) ((reader)->read((reader),(timeoutMs),(tagCount)))
#define TMR_hasMoreTags(reader) ((reader)->hasMoreTags(reader))
#define TMR_getNextTag(reader, read) ((reader)->getNextTag((reader),(read)))
#define TMR_writeTag(reader, filter, data) ((reader)->writeTag((reader),(filter),(data)))
#define TMR_readTagMemWords(reader, target, bank, address, count, data) ((reader)->readTagMemWords((reader),(target),(bank),(address),(count),(data)))
#define TMR_readTagMemBytes(reader, target, bank, address, count, data) ((reader)->readTagMemBytes((reader),(target),(bank),(address),(count),(data)))
#define TMR_writeTagMemWords(reader, target, bank, address, count, data) ((reader)->writeTagMemWords((reader),(target),(bank),(address),(count),(data)))
#define TMR_writeTagMemBytes(reader, target, bank, address, count, data) ((reader)->writeTagMemBytes((reader),(target),(bank),(address),(count),(data)))
#define TMR_killTag(reader, filter, auth) ((reader)->killTag((reader),(filter),(auth)))
#define TMR_lockTag(reader, filter, action) ((reader)->lockTag((reader),(filter),(action)))
#define TMR_executeTagOp(reader, tagop, filter, data) ((reader)->executeTagOp((reader), (tagop), (filter), (data)))
#define TMR_gpoSet(reader, count, state) ((reader)->gpoSet((reader),(count),(state)))
#define TMR_gpiGet(reader, count, state) ((reader)->gpiGet((reader),(count),(state)))
#define TMR_firmwareLoad(reader, cookie, provider) ((reader)->firmwareLoad((reader),(cookie),(provider)))
#define TMR_modifyFlash(reader, sector, address, password, length, data, offset)  ((reader->modifyFlash((reader),(sector),(address),(password),(length),(data),(offset)))
#define TMR_reboot(reader) ((reader)->reboot(reader))
#endif /* TMR_ENABLE_SERIAL_READER_ONLY  */

#endif /* DOXYGEN_IGNORE */

#ifdef  __cplusplus
}
#endif

#endif /* _TM_READER_H_ */