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 */ }