void getPower(int readerID)
{
int16_t max, min;
int32_t current;
checkError(TMR_stopReading(readers[readerID]), "Stopping Reader for power reading");
TMR_paramGet(readers[readerID], TMR_PARAM_RADIO_POWERMAX , &max);
TMR_paramGet(readers[readerID], TMR_PARAM_RADIO_POWERMIN , &min);
TMR_paramGet(readers[readerID], TMR_PARAM_RADIO_READPOWER , ¤t);
printf("Max transmission power is: %i\n", max);
printf("Min transmission power is: %i\n", min);
printf("Current transmission power is: %i\n", current);
checkError(TMR_startReading(readers[readerID]), "Starting reader");
}
static PyObject *
Reader_get_write_powers(Reader *self)
{
int row;
TMR_Status ret;
PyObject *antenna_power;
PyObject *antenna_powers;
antenna_powers = PyList_New(0);
TMR_PortValueList ant_pow_list;
TMR_PortValue pow_value_list[MAX_ANTENNA_COUNT];
ant_pow_list.list = pow_value_list;
ant_pow_list.max = numberof(pow_value_list);
TMR_uint8List port_list;
uint8_t port_value_list[MAX_ANTENNA_COUNT];
port_list.list = port_value_list;
port_list.max = numberof(port_value_list);
if ((ret = TMR_paramGet(&self->reader, TMR_PARAM_ANTENNA_PORTLIST, &port_list)) != TMR_SUCCESS)
{
PyErr_SetString(PyExc_TypeError, "Error getting antennas");
return NULL;
}
if ((ret = TMR_paramGet(&self->reader, TMR_PARAM_RADIO_PORTWRITEPOWERLIST, &ant_pow_list)) != TMR_SUCCESS)
{
PyErr_SetString(PyExc_TypeError, TMR_strerr(&self->reader, ret));
return NULL;
}
for (row = 0; row < port_list.len; row++)
{
antenna_power = PyTuple_New(2);
PyTuple_SetItem(antenna_power, 0, PyLong_FromLong((long) ant_pow_list.list[row].port));
PyTuple_SetItem(antenna_power, 1, PyLong_FromLong((long) ant_pow_list.list[row].value));
PyList_Append(antenna_powers, antenna_power);
}
return antenna_powers;
}
static PyObject *
Reader_get_power_range(Reader *self)
{
int lim_power;
TMR_Status ret;
PyObject *powers;
powers = PyTuple_New(2);
if ((ret = TMR_paramGet(&self->reader, TMR_PARAM_RADIO_POWERMIN, &lim_power)) != TMR_SUCCESS)
{
PyErr_SetString(PyExc_TypeError, TMR_strerr(&self->reader, ret));
return NULL;
}
PyTuple_SetItem(powers, 0, PyLong_FromLong((long) lim_power));
if ((ret = TMR_paramGet(&self->reader, TMR_PARAM_RADIO_POWERMAX, &lim_power)) != TMR_SUCCESS)
{
PyErr_SetString(PyExc_TypeError, TMR_strerr(&self->reader, ret));
return NULL;
}
PyTuple_SetItem(powers, 1, PyLong_FromLong((long) lim_power));
return powers;
}
static PyObject *
Reader_get_temperature(Reader *self)
{
TMR_Status ret;
uint8_t temp;
if ((ret = TMR_paramGet(&self->reader, TMR_PARAM_RADIO_TEMPERATURE, &temp)) != TMR_SUCCESS)
{
PyErr_SetString(PyExc_TypeError, "Error getting temperature");
return NULL;
}
return PyLong_FromLong(temp);
}
static PyObject *
Reader_get_gen2_session(Reader* self)
{
TMR_Status ret;
TMR_GEN2_Session session_val;
if ((ret = TMR_paramGet(&self->reader, TMR_PARAM_GEN2_SESSION, &session_val)) != TMR_SUCCESS)
{
PyErr_SetString(PyExc_TypeError, TMR_strerr(&self->reader, ret));
return NULL;
}
return PyLong_FromLong(session_val);
}
static PyObject *
Reader_get_gen2_blf(Reader* self)
{
TMR_Status ret;
TMR_GEN2_LinkFrequency blf_val;
if ((ret = TMR_paramGet(&self->reader, TMR_PARAM_GEN2_BLF, &blf_val)) != TMR_SUCCESS)
{
PyErr_SetString(PyExc_TypeError, TMR_strerr(&self->reader, ret));
return NULL;
}
return PyLong_FromLong(blf_val);
}
static PyObject *
Reader_get_gen2_tari(Reader* self)
{
TMR_Status ret;
TMR_GEN2_Tari tari_val;
if ((ret = TMR_paramGet(&self->reader, TMR_PARAM_GEN2_TARI, &tari_val)) != TMR_SUCCESS)
{
PyErr_SetString(PyExc_TypeError, TMR_strerr(&self->reader, ret));
return NULL;
}
return PyLong_FromLong(tari_val);
}
void getHopTime(int readerID)
{
checkError(TMR_stopReading(readers[readerID]), "Stopping reader for hop time reading");
uint32_t hoptimeval;
TMR_paramGet(readers[readerID], TMR_PARAM_REGION_HOPTIME, &hoptimeval);
//TMR_paramGet(readers[readerID], TMR_PARAM_REGION_HOPTABLE, &);
printf("HOPTIME: %" PRIu32 "\n", hoptimeval);
//printf("HOPTABLE: \n");
checkError(TMR_startReading(readers[readerID]), "Starting Reader");
}
static PyObject *
Reader_get_model(Reader* self)
{
TMR_String model;
char str[64];
TMR_Status ret;
model.value = str;
model.max = sizeof(str);
if ((ret = TMR_paramGet(&self->reader, TMR_PARAM_VERSION_MODEL, &model)) != TMR_SUCCESS)
{
PyErr_SetString(PyExc_TypeError, TMR_strerr(&self->reader, ret));
return NULL;
}
return PyUnicode_FromString(model.value);
}
static PyObject *
Reader_get_gen2_q(Reader* self)
{
TMR_Status ret;
TMR_SR_GEN2_Q model;
PyObject *q_value;
if ((ret = TMR_paramGet(&self->reader, TMR_PARAM_GEN2_Q, &model)) != TMR_SUCCESS)
{
PyErr_SetString(PyExc_TypeError, TMR_strerr(&self->reader, ret));
return NULL;
}
q_value = PyTuple_New(2);
PyTuple_SetItem(q_value, 0, PyLong_FromLong((long) model.type));
PyTuple_SetItem(q_value, 1, PyLong_FromLong((long) model.u.staticQ.initialQ));
return q_value;
}
void getReaderConfig()
{
/* integers */
ret = TMR_paramGet(rp, TMR_PARAM_BAUDRATE, &BaudRate);
ret = TMR_paramGet(rp, TMR_PARAM_COMMANDTIMEOUT, &CommandTimeout);
ret = TMR_paramGet(rp, TMR_PARAM_TRANSPORTTIMEOUT, &TransportTimeout);
ret = TMR_paramGet(rp, TMR_PARAM_READ_ASYNCOFFTIME, &ASyncOffTime);
ret = TMR_paramGet(rp, TMR_PARAM_READ_ASYNCONTIME, &ASyncOnTime);
ret = TMR_paramGet(rp, TMR_PARAM_REGION_HOPTIME, &HopTime);
ret = TMR_paramGet(rp, TMR_PARAM_GEN2_BLF, &Gen2BLF);
ret = TMR_paramGet(rp, TMR_PARAM_READER_WRITE_REPLY_TIMEOUT, &Gen2WriteReplyTimeout);
ret = TMR_paramGet(rp, TMR_PARAM_RADIO_POWERMAX, &MaxPower);
ret = TMR_paramGet(rp, TMR_PARAM_RADIO_POWERMIN, &MinPower);
ret = TMR_paramGet(rp, TMR_PARAM_RADIO_READPOWER, &ReadPower);
ret = TMR_paramGet(rp, TMR_PARAM_RADIO_WRITEPOWER, &WritePower);
ret = TMR_paramGet(rp, TMR_PARAM_RADIO_TEMPERATURE, &Temperature);
ret = TMR_paramGet(rp, TMR_PARAM_TAGREADATA_TAGOPSUCCESSCOUNT, &TagOpSuccess);
ret = TMR_paramGet(rp, TMR_PARAM_TAGREADATA_TAGOPFAILURECOUNT, &TagOpFailures);
ret = TMR_paramGet(rp, TMR_PARAM_TAGOP_ANTENNA, &Antenna);
ret = TMR_paramGet(rp, TMR_PARAM_TAGREADDATA_READFILTERTIMEOUT, &ReadFilterTimeout);
ret = TMR_paramGet(rp, TMR_PARAM_PRODUCT_GROUP_ID, &ProductGroupID);
/* integer arrays */
/* uint lists need to be initialized this way
*/
ConnectedPortList.list = arrayConnectedPortList;
ConnectedPortList.max = sizeof(arrayConnectedPortList)/sizeof(arrayConnectedPortList[0]);
ConnectedPortList.len = 0;
ret = TMR_paramGet(rp, TMR_PARAM_ANTENNA_CONNECTEDPORTLIST, &ConnectedPortList);
PortList.list = arrayPortList;
PortList.max = sizeof(arrayPortList)/sizeof(arrayPortList[0]);
PortList.len = 0;
ret = TMR_paramGet(rp, TMR_PARAM_ANTENNA_PORTLIST, &PortList);
PortSwitchGPOs.list = arrayPortSwitchGPOs;
PortSwitchGPOs.max = sizeof(arrayPortSwitchGPOs)/sizeof(arrayPortSwitchGPOs[0]);
PortSwitchGPOs.len = 0;
ret = TMR_paramGet(rp, TMR_PARAM_ANTENNA_PORTSWITCHGPOS, &PortSwitchGPOs);
InputList.list = arrayInputList;
InputList.max = sizeof(arrayInputList)/sizeof(arrayInputList[0]);
InputList.len = 0;
ret = TMR_paramGet(rp, TMR_PARAM_GPIO_INPUTLIST, &InputList);
OutputList.list = arrayOutputList;
OutputList.max = sizeof(arrayOutputList)/sizeof(arrayOutputList[0]);
OutputList.len = 0;
ret = TMR_paramGet(rp, TMR_PARAM_GPIO_OUTPUTLIST, &OutputList);
HopTable.list = arrayHopTable;
HopTable.max = sizeof(arrayHopTable)/sizeof(arrayHopTable[0]);
HopTable.len = 0;
ret = TMR_paramGet(rp, TMR_PARAM_REGION_HOPTABLE, &HopTable);
/* integer arrays arrays */
SettlingTime.list = arraySettlingTime;
SettlingTime.max = sizeof(arraySettlingTime)/sizeof(arraySettlingTime[0]);
SettlingTime.len = 0;
ret = TMR_paramGet(rp, TMR_PARAM_ANTENNA_SETTLINGTIMELIST, &SettlingTime);
PortRead.list = arrayPortRead;
PortRead.max = sizeof(arrayPortRead)/sizeof(arrayPortRead[0]);
PortRead.len = 0;
ret = TMR_paramGet(rp, TMR_PARAM_RADIO_PORTREADPOWERLIST, &PortRead);
PortWrite.list = arrayPortWrite;
PortWrite.max = sizeof(arrayPortWrite)/sizeof(arrayPortWrite[0]);
PortWrite.len = 0;
ret = TMR_paramGet(rp, TMR_PARAM_RADIO_PORTWRITEPOWERLIST, &PortWrite);
txrxMap.list = arrayTxRxMap;
txrxMap.max = sizeof(arrayTxRxMap)/sizeof(arrayTxRxMap[0]);
txrxMap.len = 0;
ret = TMR_paramGet(rp, TMR_PARAM_ANTENNA_TXRXMAP, &txrxMap);
/* strings */
/* TMR_Strings need to be initialized this way
*/
ReaderURI.value = stringReaderURI;
ReaderURI.max = sizeof(stringReaderURI)/sizeof(stringReaderURI[0]);
ret = TMR_paramGet(rp, TMR_PARAM_URI, &ReaderURI);
HardwareVersion.value = stringHardwareVersion;
HardwareVersion.max = sizeof(stringHardwareVersion)/sizeof(stringHardwareVersion[0]);
ret = TMR_paramGet(rp, TMR_PARAM_VERSION_HARDWARE, &HardwareVersion);
Model.value = stringModel;
Model.max = sizeof(stringModel)/sizeof(stringModel[0]);
ret = TMR_paramGet(rp, TMR_PARAM_VERSION_MODEL, &Model);
ProductGroup.value = stringProductGroup;
ProductGroup.max = sizeof(stringProductGroup)/sizeof(stringProductGroup[0]);
ret = TMR_paramGet(rp, TMR_PARAM_PRODUCT_GROUP, &ProductGroup);
SerialNumber.value = stringSerialNumber;
SerialNumber.max = sizeof(stringSerialNumber)/sizeof(stringSerialNumber[0]);
ret = TMR_paramGet(rp, TMR_PARAM_VERSION_SERIAL, &SerialNumber);
SoftwareVersion.value = stringSoftwareVersion;
SoftwareVersion.max = sizeof(stringSoftwareVersion)/sizeof(stringSoftwareVersion[0]);
ret = TMR_paramGet(rp, TMR_PARAM_VERSION_SOFTWARE, &SoftwareVersion);
description.value = stringDescription;
description.max = sizeof(stringDescription)/sizeof(stringDescription[0]);
ret = TMR_paramGet(rp, TMR_PARAM_READER_DESCRIPTION, &description);
/* booleans */
ret = TMR_paramGet(rp, TMR_PARAM_ANTENNA_CHECKPORT, &CheckPort);
ret = TMR_paramGet(rp, TMR_PARAM_READER_WRITE_EARLY_EXIT, &WriteEarlyExit);
ret = TMR_paramGet(rp, TMR_PARAM_RADIO_ENABLEPOWERSAVE, &EnablePowerSave);
ret = TMR_paramGet(rp, TMR_PARAM_REGION_LBT_ENABLE, &LBTEnable);
ret = TMR_paramGet(rp, TMR_PARAM_STATUS_ENABLE_ANTENNAREPORT, &AntennaEnable);
ret = TMR_paramGet(rp, TMR_PARAM_STATUS_ENABLE_FREQUENCYREPORT, &FrequencyEnable);
ret = TMR_paramGet(rp, TMR_PARAM_STATUS_ENABLE_TEMPERATUREREPORT, &TemperatureEnable);
ret = TMR_paramGet(rp, TMR_PARAM_TAGREADDATA_RECORDHIGHESTRSSI, &RecordHighestRSSI);
ret = TMR_paramGet(rp, TMR_PARAM_TAGREADDATA_REPORTRSSIINDBM, &RSSIdBm);
ret = TMR_paramGet(rp, TMR_PARAM_TAGREADDATA_UNIQUEBYANTENNA, &UniqueByAntenna);
ret = TMR_paramGet(rp, TMR_PARAM_TAGREADDATA_UNIQUEBYDATA, &UniqueByData);
ret = TMR_paramGet(rp, TMR_PARAM_RADIO_ENABLESJC, &EnableSJC);
ret = TMR_paramGet(rp, TMR_PARAM_EXTENDEDEPC, &ExtendedEPC);
ret = TMR_paramGet(rp, TMR_PARAM_TAGREADDATA_ENABLEREADFILTER, &EnableReadFilter);
/* the rest */
ret = TMR_paramGet(rp, TMR_PARAM_REGION_ID, ®ion);
regionList.list = regionValue;
regionList.max = sizeof(regionValue)/sizeof(regionValue[0]);
regionList.len = 0;
ret = TMR_paramGet(rp, TMR_PARAM_REGION_SUPPORTEDREGIONS, ®ionList);
ret = TMR_paramGet(rp, TMR_PARAM_USERMODE, &userMode);
ret = TMR_paramGet(rp, TMR_PARAM_POWERMODE, &powerMode);
ret = TMR_paramGet(rp, TMR_PARAM_GEN2_ACCESSPASSWORD, &accessPassword);
ret = TMR_paramGet(rp, TMR_PARAM_GEN2_TAGENCODING, &tagEncoding);
ret = TMR_paramGet(rp, TMR_PARAM_GEN2_SESSION, &session);
ret = TMR_paramGet(rp, TMR_PARAM_GEN2_TARGET, &target);
ret = TMR_paramGet(rp, TMR_PARAM_GEN2_Q, &q);
ret = TMR_paramGet(rp, TMR_PARAM_GEN2_TARI, &tari);
supportedProtocols.max = sizeof(valueTP)/sizeof(valueTP[0]);
supportedProtocols.list = valueTP;
supportedProtocols.len = 0;
ret = TMR_paramGet(rp, TMR_PARAM_VERSION_SUPPORTEDPROTOCOLS, &supportedProtocols);
ret = TMR_paramGet(rp, TMR_PARAM_TAGOP_PROTOCOL, &protocol);
ret = TMR_paramGet(rp, TMR_PARAM_READ_PLAN, &readPlan);
ret = TMR_paramGet(rp, TMR_PARAM_ISO180006B_BLF, &ISOBLF);
ret = TMR_paramGet(rp, TMR_PARAM_ISO180006B_MODULATION_DEPTH, &modulation);
ret = TMR_paramGet(rp, TMR_PARAM_ISO180006B_DELIMITER, &delimiter);
ret = TMR_paramGet(rp, TMR_PARAM_GEN2_WRITEMODE, &writeMode);
ret = TMR_paramGet(rp, TMR_PARAM_CURRENTTIME, ¤tTime);
strftime(value_data8, sizeof(value_data8), "%FT%H:%M:%S", ¤tTime);
}
int main(int argc, char *argv[])
{
TMR_Reader r, *rp;
TMR_Status ret;
TMR_Region region;
#if USE_TRANSPORT_LISTENER
TMR_TransportListenerBlock tb;
#endif
if (argc < 2)
{
errx(1, "Please provide reader URL, such as:\n"
"tmr:///com4\n"
"tmr://my-reader.example.com\n");
}
rp = &r;
ret = TMR_create(rp, argv[1]);
checkerr(rp, ret, 1, "creating reader");
#if USE_TRANSPORT_LISTENER
if (TMR_READER_TYPE_SERIAL == rp->readerType)
{
tb.listener = serialPrinter;
}
else
{
tb.listener = stringPrinter;
}
tb.cookie = stdout;
TMR_addTransportListener(rp, &tb);
#endif
ret = TMR_connect(rp);
checkerr(rp, ret, 1, "connecting reader");
region = TMR_REGION_NONE;
ret = TMR_paramGet(rp, TMR_PARAM_REGION_ID, ®ion);
checkerr(rp, ret, 1, "getting region");
if (TMR_REGION_NONE == region)
{
TMR_RegionList regions;
TMR_Region _regionStore[32];
regions.list = _regionStore;
regions.max = sizeof(_regionStore)/sizeof(_regionStore[0]);
regions.len = 0;
ret = TMR_paramGet(rp, TMR_PARAM_REGION_SUPPORTEDREGIONS, ®ions);
checkerr(rp, ret, __LINE__, "getting supported regions");
if (regions.len < 1)
{
checkerr(rp, TMR_ERROR_INVALID_REGION, __LINE__, "Reader doesn't supportany regions");
}
region = regions.list[0];
ret = TMR_paramSet(rp, TMR_PARAM_REGION_ID, ®ion);
checkerr(rp, ret, 1, "setting region");
}
{
uint16_t retryCount = 1;
/**
* Power cycle the reader. Calling TMR_reboot() will do that.
**/
ret = TMR_reboot(rp);
checkerr(rp, ret, 1, "power cycling reader");
/**
* power cycle will take some time to complete.
* 1. Fixed reader : approximately 90sec.
* 2. Serial reader : approximately 250ms.
*
* till then try to reconnect the reader.
**/
printf("The reader is being rebooted. Once it has finished, it will reconnect ....\n");
//reconnect to the reader
TMR_destroy(rp);
ret = TMR_create(rp, argv[1]);
do
{
printf("Trying to reconnect.... Attempt:%d\n", retryCount);
ret = TMR_connect(rp);
if (TMR_SUCCESS == ret)
{
/* reader reconnected */
break;
}
retryCount++;
}while(true);
printf("Reader is reconnected successfully\n");
}
TMR_destroy(rp);
return 0;
}
int main(int argc, char *argv[])
{
TMR_Reader r, *rp;
TMR_Status ret;
TMR_Region region;
#if USE_TRANSPORT_LISTENER
TMR_TransportListenerBlock tb;
#endif
if (argc < 2)
{
errx(1, "Please provide reader URL, such as:\n"
"tmr:///com4\n"
"tmr://my-reader.example.com\n");
}
rp = &r;
ret = TMR_create(rp, argv[1]);
checkerr(rp, ret, 1, "creating reader");
#if USE_TRANSPORT_LISTENER
if (TMR_READER_TYPE_SERIAL == rp->readerType)
{
tb.listener = serialPrinter;
}
else
{
tb.listener = stringPrinter;
}
tb.cookie = stdout;
TMR_addTransportListener(rp, &tb);
#endif
ret = TMR_connect(rp);
checkerr(rp, ret, 1, "connecting reader");
region = TMR_REGION_NONE;
ret = TMR_paramGet(rp, TMR_PARAM_REGION_ID, ®ion);
checkerr(rp, ret, 1, "getting region");
if (TMR_REGION_NONE == region)
{
TMR_RegionList regions;
TMR_Region _regionStore[32];
regions.list = _regionStore;
regions.max = sizeof(_regionStore)/sizeof(_regionStore[0]);
regions.len = 0;
ret = TMR_paramGet(rp, TMR_PARAM_REGION_SUPPORTEDREGIONS, ®ions);
checkerr(rp, ret, __LINE__, "getting supported regions");
if (regions.len < 1)
{
checkerr(rp, TMR_ERROR_INVALID_REGION, __LINE__, "Reader doesn't supportany regions");
}
region = regions.list[0];
ret = TMR_paramSet(rp, TMR_PARAM_REGION_ID, ®ion);
checkerr(rp, ret, 1, "setting region");
}
{
TMR_ReadPlan simpleReadPlan, multiReadPlan;
TMR_ReadPlan subplans[5];
TMR_ReadPlan* subplanPtrs[5];
TMR_TagProtocolList value;
TMR_TagProtocol valueList[32];
int subplanCount = 0;
int j;
TMR_SR_GEN2_Q qValue;
uint8_t antenna[] = {1};
uint32_t tagCount = 1;
/* Initial test setup */
/* Set the Q value as per the tag population */
qValue.type = TMR_SR_GEN2_Q_STATIC;
qValue.u.staticQ.initialQ = 0;
ret = TMR_paramSet(rp, TMR_PARAM_GEN2_Q, &qValue);
checkerr(rp, ret, 1, "setting the Q Value");
/* The simple read plan */
TMR_RP_init_simple (&simpleReadPlan, 1, antenna, TMR_TAG_PROTOCOL_GEN2, 1000);
/* Stop N trigger */
TMR_RP_set_stopTrigger (&simpleReadPlan, tagCount);
/* The multi read plan */
{
value.max = 32;
value.list = valueList;
/* Berfore setting the readplen, we must get list of supported protocols */
ret = TMR_paramGet(rp, TMR_PARAM_VERSION_SUPPORTEDPROTOCOLS, &value);
checkerr(rp, ret, 1, "Getting the supported protocols");
{
ret = TMR_RP_init_simple(&subplans[subplanCount], 1, antenna,TMR_TAG_PROTOCOL_GEN2 , 1000);
TMR_RP_set_stopTrigger (&subplans[subplanCount], tagCount);
subplanCount++;
ret = TMR_RP_init_simple(&subplans[subplanCount], 1, antenna, TMR_TAG_PROTOCOL_ISO180006B, 1000);
TMR_RP_set_stopTrigger (&subplans[subplanCount], tagCount);
subplanCount++;
}
for (j = 0; j < subplanCount; j++)
{
subplanPtrs[j] = &subplans[j];
}
TMR_RP_init_multi(&multiReadPlan, subplanPtrs, subplanCount, 0);
}
/* Set the read plan */
ret = TMR_paramSet(rp, TMR_PARAM_READ_PLAN, &simpleReadPlan);
//enable this for multi read plan
//ret = TMR_paramSet(rp, TMR_PARAM_READ_PLAN, &multiReadPlan);
checkerr(rp, ret, 1, "setting read plan");
/* The sync read */
{
ret = TMR_read(rp, 1000, NULL);
checkerr(rp, ret, 1, "reading tags");
while (TMR_SUCCESS == TMR_hasMoreTags(rp))
{
TMR_TagReadData trd;
char epcStr[128];
ret = TMR_getNextTag(rp, &trd);
checkerr(rp, ret, 1, "fetching tag");
TMR_bytesToHex(trd.tag.epc, trd.tag.epcByteCount, epcStr);
printf("EPC:%s\n", epcStr);
}
}
}
TMR_destroy(rp);
return 0;
}
int main(int argc, char *argv[])
{
#ifndef TMR_ENABLE_BACKGROUND_READS
errx(1, "This sample requires background read functionality.\n"
"Please enable TMR_ENABLE_BACKGROUND_READS in tm_config.h\n"
"to run this codelet\n");
return -1;
#else
TMR_Reader r, *rp;
TMR_Status ret;
TMR_Region region;
TMR_ReadListenerBlock rlb;
TMR_ReadExceptionListenerBlock reb;
#if USE_TRANSPORT_LISTENER
TMR_TransportListenerBlock tb;
#endif
if (argc < 2)
{
errx(1, "Please provide reader URL, such as:\n"
"tmr:///com4\n"
"tmr://my-reader.example.com\n");
}
rp = &r;
ret = TMR_create(rp, argv[1]);
checkerr(rp, ret, 1, "creating reader");
#if USE_TRANSPORT_LISTENER
if (TMR_READER_TYPE_SERIAL == rp->readerType)
{
tb.listener = serialPrinter;
}
else
{
tb.listener = stringPrinter;
}
tb.cookie = stdout;
TMR_addTransportListener(rp, &tb);
#endif
ret = TMR_connect(rp);
checkerr(rp, ret, 1, "connecting reader");
region = TMR_REGION_NONE;
ret = TMR_paramGet(rp, TMR_PARAM_REGION_ID, ®ion);
checkerr(rp, ret, 1, "getting region");
if (TMR_REGION_NONE == region)
{
TMR_RegionList regions;
TMR_Region _regionStore[32];
regions.list = _regionStore;
regions.max = sizeof(_regionStore)/sizeof(_regionStore[0]);
regions.len = 0;
ret = TMR_paramGet(rp, TMR_PARAM_REGION_SUPPORTEDREGIONS, ®ions);
checkerr(rp, ret, __LINE__, "getting supported regions");
if (regions.len < 1)
{
checkerr(rp, TMR_ERROR_INVALID_REGION, __LINE__, "Reader doesn't supportany regions");
}
region = regions.list[0];
ret = TMR_paramSet(rp, TMR_PARAM_REGION_ID, ®ion);
checkerr(rp, ret, 1, "setting region");
}
rlb.listener = callback;
rlb.cookie = NULL;
reb.listener = exceptionCallback;
reb.cookie = NULL;
ret = TMR_addReadListener(rp, &rlb);
checkerr(rp, ret, 1, "adding read listener");
ret = TMR_addReadExceptionListener(rp, &reb);
checkerr(rp, ret, 1, "adding exception listener");
{
TMR_ReadPlan plan;
TMR_TagFilter filter;
TMR_ISO180006B_Delimiter delimiter;
uint8_t wordData[8] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 };
/* Set the Delimiter to 1 */
delimiter = TMR_ISO180006B_Delimiter1;
ret = TMR_paramSet(rp, TMR_PARAM_ISO180006B_DELIMITER, &delimiter);
checkerr(rp, ret, 1, "setting the delimiter");
/* Read Plan */
TMR_RP_init_simple(&plan, 0, NULL, TMR_TAG_PROTOCOL_ISO180006B, 1000);
TMR_TF_init_ISO180006B_select(&filter, false, TMR_ISO180006B_SELECT_OP_NOT_EQUALS, 0, 0xff, wordData);
/* Commit read plan */
ret = TMR_RP_set_filter(&plan, &filter);
checkerr(rp, ret, 1, "setting filter to the read plan");
ret = TMR_paramSet(rp, TMR_PARAM_READ_PLAN, &plan);
checkerr(rp, ret, 1, "setting read plan");
}
ret = TMR_startReading(rp);
checkerr(rp, ret, 1, "starting reading");
#ifndef WIN32
sleep(5);
#else
Sleep(5000);
#endif
ret = TMR_stopReading(rp);
checkerr(rp, ret, 1, "stopping reading");
TMR_destroy(rp);
return 0;
#endif /* TMR_ENABLE_BACKGROUND_READS */
}
int RFIDstartReader(const char* deviceURI)
{
readers = realloc(readers, (readerCount + 1) * sizeof(TMR_Reader*));
TMR_Reader* pr = malloc(sizeof(TMR_Reader));
readers[readerCount] = pr;
plan = realloc(plan, (readerCount + 1) * sizeof(TMR_ReadPlan*));
TMR_ReadPlan* prp = malloc(sizeof(TMR_ReadPlan));
plan[readerCount] = prp;
rlb = realloc(rlb, (readerCount + 1) * sizeof(TMR_ReadListenerBlock*));
TMR_ReadListenerBlock* prlb = malloc(sizeof(TMR_ReadListenerBlock));
rlb[readerCount] = prlb;
reb = realloc(reb, (readerCount + 1) * sizeof(TMR_ReadExceptionListenerBlock*));
TMR_ReadExceptionListenerBlock* preb = malloc(sizeof(TMR_ReadExceptionListenerBlock));
reb[readerCount] = preb;
region = realloc(region, (readerCount + 1) * sizeof(TMR_Region*));
TMR_Region* preg = malloc(sizeof(TMR_Region));
region[readerCount] = preg;
status = realloc(status, (readerCount + 1) * sizeof(TMR_Status*));
TMR_Status* pstat = malloc(sizeof(TMR_Status));
status[readerCount] = pstat;
model = realloc(model, (readerCount + 1) * sizeof(TMR_String*));
TMR_String* pstr = malloc(sizeof(TMR_String));
model[readerCount] = pstr;
if(checkError(TMR_create(readers[readerCount], deviceURI), "Creating reader"))
{
return -1;
}
if(checkError(TMR_connect(readers[readerCount]), "Connecting to reader"))
{
return -1;
}
*(region[readerCount]) = TMR_REGION_NONE;
if(checkError(TMR_paramGet(readers[readerCount], TMR_PARAM_REGION_ID, region[readerCount]), "Getting Saved Region"))
{
return -1;
}
if(*(region[readerCount]) == TMR_REGION_NONE)
{
printf("No saved regions\n");
TMR_RegionList regions;
TMR_Region _regionStore[32];
regions.list = _regionStore;
regions.max = sizeof(_regionStore)/sizeof(_regionStore[0]);
regions.len = 0;
if(checkError(TMR_paramGet(readers[readerCount], TMR_PARAM_REGION_SUPPORTEDREGIONS, ®ions), "Getting List of Regions"))
{
return -1;
}
if(regions.len < 1)
{
printf("Reader doesn't support any regions\n");
return -1;
}
*(region[readerCount]) = regions.list[0];
if(checkError(TMR_paramSet(readers[readerCount], TMR_PARAM_REGION_ID, &*(region[readerCount])), "Setting region"))
{
return -1;
}
}
if(checkError(TMR_RP_init_simple(plan[readerCount], 0x0, NULL, TMR_TAG_PROTOCOL_GEN2, 1000), "Initialising read plan"))
{
return -1;
}
if(checkError(TMR_paramSet(readers[readerCount], TMR_PARAM_READ_PLAN, plan[readerCount]), "Setting Read Plan"))
{
return -1;
}
rlb[readerCount]->listener = tagCallback;
rlb[readerCount]->cookie = NULL;
reb[readerCount]->listener = exceptionCallback;
reb[readerCount]->cookie = NULL;
if(checkError(TMR_addReadListener(readers[readerCount], rlb[readerCount]), "Adding read listener"))
{
return -1;
}
if(checkError(TMR_addReadExceptionListener(readers[readerCount], reb[readerCount]), "Adding Exception Listener"))
{
return -1;
}
if(checkError(TMR_startReading(readers[readerCount]), "Starting reader"))
{
return -1;
}
uniqueReaderInstance++;
return (uniqueReaderInstance - 1);
}
int main(int argc, char *argv[])
{
#ifndef TMR_ENABLE_BACKGROUND_READS
errx(1, "This sample requires background read functionality.\n"
"Please enable TMR_ENABLE_BACKGROUND_READS in tm_config.h\n"
"to run this codelet\n");
return -1;
#else
TMR_Reader r, *rp;
TMR_Status ret;
TMR_Region region;
#if USE_TRANSPORT_LISTENER
TMR_TransportListenerBlock tb;
#endif
TMR_ReadListenerBlock rlb;
TMR_ReadExceptionListenerBlock reb;
TMR_StatsListenerBlock slb;
if (argc < 2)
{
errx(1, "Please provide reader URL, such as:\n"
"tmr:///com4\n"
"tmr://my-reader.example.com\n");
}
rp = &r;
ret = TMR_create(rp, argv[1]);
checkerr(rp, ret, 1, "creating reader");
#if USE_TRANSPORT_LISTENER
if (TMR_READER_TYPE_SERIAL == rp->readerType)
{
tb.listener = serialPrinter;
}
else
{
tb.listener = stringPrinter;
}
tb.cookie = stdout;
TMR_addTransportListener(rp, &tb);
#endif
ret = TMR_connect(rp);
checkerr(rp, ret, 1, "connecting reader");
region = TMR_REGION_NONE;
ret = TMR_paramGet(rp, TMR_PARAM_REGION_ID, ®ion);
checkerr(rp, ret, 1, "getting region");
if (TMR_REGION_NONE == region)
{
TMR_RegionList regions;
TMR_Region _regionStore[32];
regions.list = _regionStore;
regions.max = sizeof(_regionStore)/sizeof(_regionStore[0]);
regions.len = 0;
ret = TMR_paramGet(rp, TMR_PARAM_REGION_SUPPORTEDREGIONS, ®ions);
checkerr(rp, ret, __LINE__, "getting supported regions");
if (regions.len < 1)
{
checkerr(rp, TMR_ERROR_INVALID_REGION, __LINE__, "Reader doesn't supportany regions");
}
region = regions.list[0];
ret = TMR_paramSet(rp, TMR_PARAM_REGION_ID, ®ion);
checkerr(rp, ret, 1, "setting region");
}
{
/* Code to get the reader stats after the sync read */
TMR_Reader_StatsValues stats;
TMR_Reader_StatsFlag setFlag;
TMR_PortValueList value;
TMR_PortValue valueList[64];
int i, j;
printf("\nReader stats after the sync read\n");
/** request for the statics fields of your interest, before search */
setFlag = TMR_READER_STATS_FLAG_ALL;
value.max = sizeof(valueList)/sizeof(valueList[0]);
value.list = valueList;
ret = TMR_paramSet(rp, TMR_PARAM_READER_STATS_ENABLE, &setFlag);
checkerr(rp, ret, 1, "setting the fields");
for (j = 1; j < 4; j++)
{
/**
* perform three iterations to see that reader stats are
* resetting after each search operation.
**/
printf("\nIteration:%d\n", j);
/**
* performing the search operation. for 1 sec,
* Individual search will reset the reader stats, before doing the search
*/
printf("Performing the search operation. for 1 sec\n");
ret = TMR_read(rp, 1000, NULL);
checkerr(rp, ret, 1, "reading tags");
/** Initialize the reader statics variable to default values */
TMR_STATS_init(&stats);
/* Search is completed. Get the reader stats */
printf("Search is completed. Get the reader stats\n");
ret = TMR_paramGet(rp, TMR_PARAM_READER_STATS, &stats);
checkerr(rp, ret, 1, "getting the reader statistics");
/** Each field should be validated before extracting the value */
if (TMR_READER_STATS_FLAG_CONNECTED_ANTENNAS & stats.valid)
{
printf("Antenna Connection Status\n");
for (i = 0; i < stats.connectedAntennas.len; i += 2)
{
printf("Antenna %d |%s\n", stats.connectedAntennas.list[i],
stats.connectedAntennas.list[i + 1] ? "connected":"Disconnected");
}
}
/* Get the antenna return loss value, this parameter is not the part of reader stats */
ret = TMR_paramGet(rp, TMR_PARAM_ANTENNA_RETURNLOSS, &value);
checkerr(rp, ret, 1, "getting the antenna return loss");
printf("Antenna Return Loss\n");
for (i = 0; i < value.len && i < value.max; i++)
{
printf("Antenna %d | %d \n", value.list[i].port, value.list[i].value);
}
if (TMR_READER_STATS_FLAG_NOISE_FLOOR_SEARCH_RX_TX_WITH_TX_ON & stats.valid)
{
printf("Noise Floor With Tx On\n");
for (i = 0; i < stats.perAntenna.len; i++)
{
printf("Antenna %d | %d db\n", stats.perAntenna.list[i].antenna, stats.perAntenna.list[i].noiseFloor);
}
}
if (TMR_READER_STATS_FLAG_RF_ON_TIME & stats.valid)
{
printf("RF On Time\n");
for (i = 0; i < stats.perAntenna.len; i++)
{
printf("Antenna %d | %d ms\n", stats.perAntenna.list[i].antenna, stats.perAntenna.list[i].rfOnTime);
}
}
if (TMR_READER_STATS_FLAG_FREQUENCY & stats.valid)
{
printf("Frequency %d(khz)\n", stats.frequency);
}
if (TMR_READER_STATS_FLAG_TEMPERATURE & stats.valid)
{
printf("Temperature %d(C)\n", stats.temperature);
}
if (TMR_READER_STATS_FLAG_PROTOCOL & stats.valid)
{
printf("Protocol %s\n", protocolName(stats.protocol));
}
if (TMR_READER_STATS_FLAG_ANTENNA_PORTS & stats.valid)
{
printf("currentAntenna %d\n", stats.antenna);
}
}
}
{
/* Code to get the reader stats after the async read */
TMR_Reader_StatsFlag setFlag = TMR_READER_STATS_FLAG_ALL;
rlb.listener = callback;
rlb.cookie = NULL;
reb.listener = exceptionCallback;
reb.cookie = NULL;
slb.listener = statsCallback;
slb.cookie = NULL;
ret = TMR_addReadListener(rp, &rlb);
checkerr(rp, ret, 1, "adding read listener");
ret = TMR_addReadExceptionListener(rp, &reb);
checkerr(rp, ret, 1, "adding exception listener");
ret = TMR_addStatsListener(rp, &slb);
checkerr(rp, ret, 1, "adding the stats listener");
printf("\nReader stats after the async read \n");
/** request for the statics fields of your interest, before search */
ret = TMR_paramSet(rp, TMR_PARAM_READER_STATS_ENABLE, &setFlag);
checkerr(rp, ret, 1, "setting the fields");
printf("Initiating the search operation. for 1 sec and the listener will provide the reader stats\n");
ret = TMR_startReading(rp);
checkerr(rp, ret, 1, "starting reading");
#ifndef WIN32
sleep(1);
#else
Sleep(1000);
#endif
ret = TMR_stopReading(rp);
checkerr(rp, ret, 1, "stopping reading");
}
TMR_destroy(rp);
return 0;
#endif /* TMR_ENABLE_BACKGROUND_READS */
}
int main(int argc, char *argv[])
{
#ifndef TMR_ENABLE_BACKGROUND_READS
errx(1, "This sample requires background read functionality.\n"
"Please enable TMR_ENABLE_BACKGROUND_READS in tm_config.h\n"
"to run this codelet\n");
return -1;
#else
TMR_Reader r, *rp;
TMR_Status ret;
TMR_Region region;
#if USE_TRANSPORT_LISTENER
TMR_TransportListenerBlock tb;
#endif
TMR_ReadListenerBlock rlb;
TMR_ReadExceptionListenerBlock reb;
if (argc < 2)
{
errx(1, "Please provide reader URL, such as:\n"
"customschemename://readerIP:portname\n");
}
rp = &r;
/**
* Add the custom transport scheme before calling TMR_create().
* This can be done by using C API helper function TMR_setSerialTransport().
* It accepts two arguments. scheme and nativeInit.
* scheme: the custom transport scheme name. For demonstration using scheme as "tcp".
* nativeInit: reference to the transport factory init function.
*/
ret = TMR_setSerialTransport("tcp", &TMR_SR_SerialTransportTcpNativeInit);
checkerr(rp, ret, 1, "adding the custom transport scheme");
ret = TMR_create(rp, argv[1]);
checkerr(rp, ret, 1, "creating reader");
#if USE_TRANSPORT_LISTENER
if (TMR_READER_TYPE_SERIAL == rp->readerType)
{
tb.listener = serialPrinter;
}
else
{
tb.listener = stringPrinter;
}
tb.cookie = stdout;
TMR_addTransportListener(rp, &tb);
#endif
ret = TMR_connect(rp);
checkerr(rp, ret, 1, "connecting reader");
region = TMR_REGION_NONE;
ret = TMR_paramGet(rp, TMR_PARAM_REGION_ID, ®ion);
checkerr(rp, ret, 1, "getting region");
if (TMR_REGION_NONE == region)
{
TMR_RegionList regions;
TMR_Region _regionStore[32];
regions.list = _regionStore;
regions.max = sizeof(_regionStore)/sizeof(_regionStore[0]);
regions.len = 0;
ret = TMR_paramGet(rp, TMR_PARAM_REGION_SUPPORTEDREGIONS, ®ions);
checkerr(rp, ret, __LINE__, "getting supported regions");
if (regions.len < 1)
{
checkerr(rp, TMR_ERROR_INVALID_REGION, __LINE__, "Reader doesn't supportany regions");
}
region = regions.list[0];
ret = TMR_paramSet(rp, TMR_PARAM_REGION_ID, ®ion);
checkerr(rp, ret, 1, "setting region");
}
{
/* Initiate a sync read */
printf("\nDoing a sync read for 1sec duration\n");
ret = TMR_read(rp, 1000, NULL);
if (TMR_SUCCESS != ret)
{
fprintf(stderr, "Error reading tags: %s\n", TMR_strerr(rp, ret));
/* Don't exit, tags might still have been read before the error occurred. */
}
while (TMR_SUCCESS == TMR_hasMoreTags(rp))
{
TMR_TagReadData trd;
char epcStr[128];
ret = TMR_getNextTag(rp, &trd);
checkerr(rp, ret, 1, "fetching tag");
TMR_bytesToHex(trd.tag.epc, trd.tag.epcByteCount, epcStr);
printf("Background read: %s Protocol:%0x \n", epcStr, trd.tag.protocol);
}
}
{
/* Initiate an async read */
printf("\nDoing an async read for 1sec duration\n");
rlb.listener = callback;
rlb.cookie = NULL;
reb.listener = exceptionCallback;
reb.cookie = NULL;
ret = TMR_addReadListener(rp, &rlb);
checkerr(rp, ret, 1, "adding read listener");
ret = TMR_addReadExceptionListener(rp, &reb);
checkerr(rp, ret, 1, "adding exception listener");
ret = TMR_startReading(rp);
checkerr(rp, ret, 1, "starting reading");
tmr_sleep(1000);
ret = TMR_stopReading(rp);
checkerr(rp, ret, 1, "stopping reading");
}
TMR_destroy(rp);
return 0;
#endif /* TMR_ENABLE_BACKGROUND_READS */
}
